Order.flix
/*
* Copyright 2020 Esben Bjerre
*
* Use of this source code is governed by the Apache 2.0 license
* that can be found in the LICENSE.md file.
*/
///
/// Trait for types that have a total order, and its functions.
///
pub mod Order {
///
/// Trait for types that have a total order.
///
pub trait Order[a] with Eq[a] {
///
/// Returns `Comparison.LessThan` if `x` < `y`, `Equal` if `x` == `y` or `Comparison.GreaterThan` `if `x` > `y`.
///
pub def compare(x: a, y: a): Comparison
///
/// Returns `true` if and only if `x < y`.
///
pub def less(x: a, y: a): Bool = match Order.compare(x, y) {
case Comparison.LessThan => true
case _ => false
}
///
/// Returns `true` if and only if `x <= y`.
///
pub def lessEqual(x: a, y: a): Bool = match Order.compare(x, y) {
case Comparison.LessThan => true
case Comparison.EqualTo => true
case _ => false
}
///
/// Returns `true` if and only if `x > y`.
///
pub def greater(x: a, y: a): Bool = match Order.compare(x, y) {
case Comparison.GreaterThan => true
case _ => false
}
///
/// Returns `true` if and only if `x >= y`.
///
pub def greaterEqual(x: a, y: a): Bool = match Order.compare(x, y) {
case Comparison.GreaterThan => true
case Comparison.EqualTo => true
case _ => false
}
///
/// Returns the minimum of `x` and `y`.
///
pub def min(x: a, y: a): a = match (x <=> y) {
case Comparison.GreaterThan => y
case _ => x
}
///
/// Returns the maximum of `x` and `y`.
///
pub def max(x: a, y: a): a = match (x <=> y) {
case Comparison.LessThan => y
case _ => x
}
}
///
/// Returns the minimum of `x` and `y` according to the given comparator `cmp`.
///
pub def minBy(cmp: (a, a) -> Comparison, x: a, y: a): a =
if (cmp(x, y) == Comparison.GreaterThan) y else x
///
/// Returns the maximum of `x` and `y` according to the given comparator `cmp`.
///
pub def maxBy(cmp: (a, a) -> Comparison, x: a, y: a): a =
if (cmp(x, y) == Comparison.LessThan) y else x
instance Order[Unit] {
pub def compare(_: Unit, _: Unit): Comparison = Comparison.EqualTo
}
instance Order[Bool] {
pub def compare(x: Bool, y: Bool): Comparison =
if (x) {
if (y)
Comparison.EqualTo
else
Comparison.GreaterThan
} else {
if (y)
Comparison.LessThan
else
Comparison.EqualTo
}
}
instance Order[Char] {
redef less(x: Char, y: Char): Bool = %%CHAR_LT%%(x, y)
redef lessEqual(x: Char, y: Char): Bool = %%CHAR_LE%%(x, y)
redef greater(x: Char, y: Char): Bool = %%CHAR_GT%%(x, y)
redef greaterEqual(x: Char, y: Char): Bool = %%CHAR_GE%%(x, y)
pub def compare(x: Char, y: Char): Comparison =
if (%%CHAR_LT%%(x, y))
Comparison.LessThan
else if (%%CHAR_GT%%(x, y))
Comparison.GreaterThan
else
Comparison.EqualTo
}
instance Order[Float32] {
redef less(x: Float32, y: Float32): Bool = %%FLOAT32_LT%%(x, y)
redef lessEqual(x: Float32, y: Float32): Bool = %%FLOAT32_LE%%(x, y)
redef greater(x: Float32, y: Float32): Bool = %%FLOAT32_GT%%(x, y)
redef greaterEqual(x: Float32, y: Float32): Bool = %%FLOAT32_GE%%(x, y)
pub def compare(x: Float32, y: Float32): Comparison =
if (%%FLOAT32_LT%%(x, y))
Comparison.LessThan
else if (%%FLOAT32_GT%%(x, y))
Comparison.GreaterThan
else
Comparison.EqualTo
}
instance Order[Float64] {
redef less(x: Float64, y: Float64): Bool = %%FLOAT64_LT%%(x, y)
redef lessEqual(x: Float64, y: Float64): Bool = %%FLOAT64_LE%%(x, y)
redef greater(x: Float64, y: Float64): Bool = %%FLOAT64_GT%%(x, y)
redef greaterEqual(x: Float64, y: Float64): Bool = %%FLOAT64_GE%%(x, y)
pub def compare(x: Float64, y: Float64): Comparison =
if (%%FLOAT64_LT%%(x, y))
Comparison.LessThan
else if (%%FLOAT64_GT%%(x, y))
Comparison.GreaterThan
else
Comparison.EqualTo
}
instance Order[BigDecimal] {
redef less(x: BigDecimal, y: BigDecimal): Bool =
x.compareTo(y) < 0
redef lessEqual(x: BigDecimal, y: BigDecimal): Bool =
x.compareTo(y) <= 0
redef greater(x: BigDecimal, y: BigDecimal): Bool =
x.compareTo(y) > 0
redef greaterEqual(x: BigDecimal, y: BigDecimal): Bool =
x.compareTo(y) >= 0
pub def compare(x: BigDecimal, y: BigDecimal): Comparison =
match x.compareTo(y) {
case 0 => Comparison.EqualTo
case z if z < 0 => Comparison.LessThan
case _ => Comparison.GreaterThan
}
}
instance Order[Int8] {
redef less(x: Int8, y: Int8): Bool = %%INT8_LT%%(x, y)
redef lessEqual(x: Int8, y: Int8): Bool = %%INT8_LE%%(x, y)
redef greater(x: Int8, y: Int8): Bool = %%INT8_GT%%(x, y)
redef greaterEqual(x: Int8, y: Int8): Bool = %%INT8_GE%%(x, y)
pub def compare(x: Int8, y: Int8): Comparison =
if (%%INT8_LT%%(x, y))
Comparison.LessThan
else if (%%INT8_GT%%(x, y))
Comparison.GreaterThan
else
Comparison.EqualTo
}
instance Order[Int16] {
redef less(x: Int16, y: Int16): Bool = %%INT16_LT%%(x, y)
redef lessEqual(x: Int16, y: Int16): Bool = %%INT16_LE%%(x, y)
redef greater(x: Int16, y: Int16): Bool = %%INT16_GT%%(x, y)
redef greaterEqual(x: Int16, y: Int16): Bool = %%INT16_GE%%(x, y)
pub def compare(x: Int16, y: Int16): Comparison =
if (%%INT16_LT%%(x, y))
Comparison.LessThan
else if (%%INT16_GT%%(x, y))
Comparison.GreaterThan
else
Comparison.EqualTo
}
instance Order[Int32] {
redef less(x: Int32, y: Int32): Bool = %%INT32_LT%%(x, y)
redef lessEqual(x: Int32, y: Int32): Bool = %%INT32_LE%%(x, y)
redef greater(x: Int32, y: Int32): Bool = %%INT32_GT%%(x, y)
redef greaterEqual(x: Int32, y: Int32): Bool = %%INT32_GE%%(x, y)
pub def compare(x: Int32, y: Int32): Comparison =
if (%%INT32_LT%%(x, y))
Comparison.LessThan
else if (%%INT32_GT%%(x, y))
Comparison.GreaterThan
else
Comparison.EqualTo
}
instance Order[Int64] {
redef less(x: Int64, y: Int64): Bool = %%INT64_LT%%(x, y)
redef lessEqual(x: Int64, y: Int64): Bool = %%INT64_LE%%(x, y)
redef greater(x: Int64, y: Int64): Bool = %%INT64_GT%%(x, y)
redef greaterEqual(x: Int64, y: Int64): Bool = %%INT64_GE%%(x, y)
pub def compare(x: Int64, y: Int64): Comparison =
if (%%INT64_LT%%(x, y))
Comparison.LessThan
else if (%%INT64_GT%%(x, y))
Comparison.GreaterThan
else
Comparison.EqualTo
}
instance Order[BigInt] {
redef less(x: BigInt, y: BigInt): Bool =
x.compareTo(y) < 0
redef lessEqual(x: BigInt, y: BigInt): Bool =
x.compareTo(y) <= 0
redef greater(x: BigInt, y: BigInt): Bool =
x.compareTo(y) > 0
redef greaterEqual(x: BigInt, y: BigInt): Bool =
x.compareTo(y) >= 0
pub def compare(x: BigInt, y: BigInt): Comparison =
match x.compareTo(y) {
case 0 => Comparison.EqualTo
case z if z < 0 => Comparison.LessThan
case _ => Comparison.GreaterThan
}
}
instance Order[String] {
pub def compare(x: String, y: String): Comparison =
Comparison.fromInt32(x.compareTo(y))
}
instance Order[(a1, a2)] with Order[a1], Order[a2] {
///
/// Compares `t1` and `t2` lexicographically.
///
pub def compare(t1: (a1, a2), t2: (a1, a2)): Comparison =
let (x1, x2) = t1;
let (y1, y2) = t2;
match x1 <=> y1 {
case Comparison.EqualTo => x2 <=> y2
case res => res
}
}
instance Order[(a1, a2, a3)] with Order[a1], Order[a2], Order[a3] {
///
/// Compares `t1` and `t2` lexicographically.
///
pub def compare(t1: (a1, a2, a3), t2: (a1, a2, a3)): Comparison =
let (x1, x2, x3) = t1;
let (y1, y2, y3) = t2;
match x1 <=> y1 {
case Comparison.EqualTo => match x2 <=> y2 {
case Comparison.EqualTo => x3 <=> y3
case res => res
}
case res => res
}
}
instance Order[(a1, a2, a3, a4)] with Order[a1], Order[a2], Order[a3], Order[a4] {
///
/// Compares `t1` and `t2` lexicographically.
///
pub def compare(t1: (a1, a2, a3, a4), t2: (a1, a2, a3, a4)): Comparison =
let (x1, x2, x3, x4) = t1;
let (y1, y2, y3, y4) = t2;
match x1 <=> y1 {
case Comparison.EqualTo => match x2 <=> y2 {
case Comparison.EqualTo => match x3 <=> y3 {
case Comparison.EqualTo => x4 <=> y4
case res => res
}
case res => res
}
case res => res
}
}
instance Order[(a1, a2, a3, a4, a5)] with Order[a1], Order[a2], Order[a3], Order[a4], Order[a5] {
///
/// Compares `t1` and `t2` lexicographically.
///
pub def compare(t1: (a1, a2, a3, a4, a5), t2: (a1, a2, a3, a4, a5)): Comparison =
let (x1, x2, x3, x4, x5) = t1;
let (y1, y2, y3, y4, y5) = t2;
match x1 <=> y1 {
case Comparison.EqualTo => match x2 <=> y2 {
case Comparison.EqualTo => match x3 <=> y3 {
case Comparison.EqualTo => match x4 <=> y4 {
case Comparison.EqualTo => x5 <=> y5
case res => res
}
case res => res
}
case res => res
}
case res => res
}
}
instance Order[(a1, a2, a3, a4, a5, a6)] with Order[a1], Order[a2], Order[a3], Order[a4], Order[a5], Order[a6] {
///
/// Compares `t1` and `t2` lexicographically.
///
pub def compare(t1: (a1, a2, a3, a4, a5, a6), t2: (a1, a2, a3, a4, a5, a6)): Comparison =
let (x1, x2, x3, x4, x5, x6) = t1;
let (y1, y2, y3, y4, y5, y6) = t2;
match x1 <=> y1 {
case Comparison.EqualTo => match x2 <=> y2 {
case Comparison.EqualTo => match x3 <=> y3 {
case Comparison.EqualTo => match x4 <=> y4 {
case Comparison.EqualTo => match x5 <=> y5 {
case Comparison.EqualTo => x6 <=> y6
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
}
instance Order[(a1, a2, a3, a4, a5, a6, a7)] with Order[a1], Order[a2], Order[a3], Order[a4], Order[a5], Order[a6], Order[a7] {
///
/// Compares `t1` and `t2` lexicographically.
///
pub def compare(t1: (a1, a2, a3, a4, a5, a6, a7), t2: (a1, a2, a3, a4, a5, a6, a7)): Comparison =
let (x1, x2, x3, x4, x5, x6, x7) = t1;
let (y1, y2, y3, y4, y5, y6, y7) = t2;
match x1 <=> y1 {
case Comparison.EqualTo => match x2 <=> y2 {
case Comparison.EqualTo => match x3 <=> y3 {
case Comparison.EqualTo => match x4 <=> y4 {
case Comparison.EqualTo => match x5 <=> y5 {
case Comparison.EqualTo => match x6 <=> y6 {
case Comparison.EqualTo => x7 <=> y7
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
}
instance Order[(a1, a2, a3, a4, a5, a6, a7, a8)] with Order[a1], Order[a2], Order[a3], Order[a4], Order[a5], Order[a6], Order[a7], Order[a8] {
///
/// Compares `t1` and `t2` lexicographically.
///
pub def compare(t1: (a1, a2, a3, a4, a5, a6, a7, a8), t2: (a1, a2, a3, a4, a5, a6, a7, a8)): Comparison =
let (x1, x2, x3, x4, x5, x6, x7, x8) = t1;
let (y1, y2, y3, y4, y5, y6, y7, y8) = t2;
match x1 <=> y1 {
case Comparison.EqualTo => match x2 <=> y2 {
case Comparison.EqualTo => match x3 <=> y3 {
case Comparison.EqualTo => match x4 <=> y4 {
case Comparison.EqualTo => match x5 <=> y5 {
case Comparison.EqualTo => match x6 <=> y6 {
case Comparison.EqualTo => match x7 <=> y7 {
case Comparison.EqualTo => x8 <=> y8
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
}
instance Order[(a1, a2, a3, a4, a5, a6, a7, a8, a9)] with Order[a1], Order[a2], Order[a3], Order[a4], Order[a5], Order[a6], Order[a7], Order[a8], Order[a9] {
///
/// Compares `t1` and `t2` lexicographically.
///
pub def compare(t1: (a1, a2, a3, a4, a5, a6, a7, a8, a9), t2: (a1, a2, a3, a4, a5, a6, a7, a8, a9)): Comparison =
let (x1, x2, x3, x4, x5, x6, x7, x8, x9) = t1;
let (y1, y2, y3, y4, y5, y6, y7, y8, y9) = t2;
match x1 <=> y1 {
case Comparison.EqualTo => match x2 <=> y2 {
case Comparison.EqualTo => match x3 <=> y3 {
case Comparison.EqualTo => match x4 <=> y4 {
case Comparison.EqualTo => match x5 <=> y5 {
case Comparison.EqualTo => match x6 <=> y6 {
case Comparison.EqualTo => match x7 <=> y7 {
case Comparison.EqualTo => match x8 <=> y8 {
case Comparison.EqualTo => x9 <=> y9
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
}
instance Order[(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)] with Order[a1], Order[a2], Order[a3], Order[a4], Order[a5], Order[a6], Order[a7], Order[a8], Order[a9], Order[a10] {
///
/// Compares `t1` and `t2` lexicographically.
///
pub def compare(t1: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10), t2: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)): Comparison =
let (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) = t1;
let (y1, y2, y3, y4, y5, y6, y7, y8, y9, y10) = t2;
match x1 <=> y1 {
case Comparison.EqualTo => match x2 <=> y2 {
case Comparison.EqualTo => match x3 <=> y3 {
case Comparison.EqualTo => match x4 <=> y4 {
case Comparison.EqualTo => match x5 <=> y5 {
case Comparison.EqualTo => match x6 <=> y6 {
case Comparison.EqualTo => match x7 <=> y7 {
case Comparison.EqualTo => match x8 <=> y8 {
case Comparison.EqualTo => match x9 <=> y9 {
case Comparison.EqualTo => x10 <=> y10
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
}
instance Order[(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11)] with Order[a1], Order[a2], Order[a3], Order[a4], Order[a5], Order[a6], Order[a7], Order[a8], Order[a9], Order[a10], Order[a11] {
///
/// Compares `t1` and `t2` lexicographically.
///
pub def compare(t1: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11), t2: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11)): Comparison =
let (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) = t1;
let (y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11) = t2;
match x1 <=> y1 {
case Comparison.EqualTo => match x2 <=> y2 {
case Comparison.EqualTo => match x3 <=> y3 {
case Comparison.EqualTo => match x4 <=> y4 {
case Comparison.EqualTo => match x5 <=> y5 {
case Comparison.EqualTo => match x6 <=> y6 {
case Comparison.EqualTo => match x7 <=> y7 {
case Comparison.EqualTo => match x8 <=> y8 {
case Comparison.EqualTo => match x9 <=> y9 {
case Comparison.EqualTo => match x10 <=> y10 {
case Comparison.EqualTo => x11 <=> y11
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
}
instance Order[(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12)] with Order[a1], Order[a2], Order[a3], Order[a4], Order[a5], Order[a6], Order[a7], Order[a8], Order[a9], Order[a10], Order[a11], Order[a12] {
///
/// Compares `t1` and `t2` lexicographically.
///
pub def compare(t1: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12), t2: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12)): Comparison =
let (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) = t1;
let (y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12) = t2;
match x1 <=> y1 {
case Comparison.EqualTo => match x2 <=> y2 {
case Comparison.EqualTo => match x3 <=> y3 {
case Comparison.EqualTo => match x4 <=> y4 {
case Comparison.EqualTo => match x5 <=> y5 {
case Comparison.EqualTo => match x6 <=> y6 {
case Comparison.EqualTo => match x7 <=> y7 {
case Comparison.EqualTo => match x8 <=> y8 {
case Comparison.EqualTo => match x9 <=> y9 {
case Comparison.EqualTo => match x10 <=> y10 {
case Comparison.EqualTo => match x11 <=> y11 {
case Comparison.EqualTo => x12 <=> y12
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
}
instance Order[(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13)] with Order[a1], Order[a2], Order[a3], Order[a4], Order[a5], Order[a6], Order[a7], Order[a8], Order[a9], Order[a10], Order[a11], Order[a12], Order[a13] {
///
/// Compares `t1` and `t2` lexicographically.
///
pub def compare(t1: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13), t2: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13)): Comparison =
let (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) = t1;
let (y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13) = t2;
match x1 <=> y1 {
case Comparison.EqualTo => match x2 <=> y2 {
case Comparison.EqualTo => match x3 <=> y3 {
case Comparison.EqualTo => match x4 <=> y4 {
case Comparison.EqualTo => match x5 <=> y5 {
case Comparison.EqualTo => match x6 <=> y6 {
case Comparison.EqualTo => match x7 <=> y7 {
case Comparison.EqualTo => match x8 <=> y8 {
case Comparison.EqualTo => match x9 <=> y9 {
case Comparison.EqualTo => match x10 <=> y10 {
case Comparison.EqualTo => match x11 <=> y11 {
case Comparison.EqualTo => match x12 <=> y12 {
case Comparison.EqualTo => x13 <=> y13
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
}
instance Order[(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14)] with Order[a1], Order[a2], Order[a3], Order[a4], Order[a5], Order[a6], Order[a7], Order[a8], Order[a9], Order[a10], Order[a11], Order[a12], Order[a13], Order[a14] {
///
/// Compares `t1` and `t2` lexicographically.
///
pub def compare(t1: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14), t2: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14)): Comparison =
let (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) = t1;
let (y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14) = t2;
match x1 <=> y1 {
case Comparison.EqualTo => match x2 <=> y2 {
case Comparison.EqualTo => match x3 <=> y3 {
case Comparison.EqualTo => match x4 <=> y4 {
case Comparison.EqualTo => match x5 <=> y5 {
case Comparison.EqualTo => match x6 <=> y6 {
case Comparison.EqualTo => match x7 <=> y7 {
case Comparison.EqualTo => match x8 <=> y8 {
case Comparison.EqualTo => match x9 <=> y9 {
case Comparison.EqualTo => match x10 <=> y10 {
case Comparison.EqualTo => match x11 <=> y11 {
case Comparison.EqualTo => match x12 <=> y12 {
case Comparison.EqualTo => match x13 <=> y13 {
case Comparison.EqualTo => x14 <=> y14
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
}
instance Order[(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15)] with Order[a1], Order[a2], Order[a3], Order[a4], Order[a5], Order[a6], Order[a7], Order[a8], Order[a9], Order[a10], Order[a11], Order[a12], Order[a13], Order[a14], Order[a15] {
///
/// Compares `t1` and `t2` lexicographically.
///
pub def compare(t1: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15), t2: (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15)): Comparison =
let (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) = t1;
let (y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15) = t2;
match x1 <=> y1 {
case Comparison.EqualTo => match x2 <=> y2 {
case Comparison.EqualTo => match x3 <=> y3 {
case Comparison.EqualTo => match x4 <=> y4 {
case Comparison.EqualTo => match x5 <=> y5 {
case Comparison.EqualTo => match x6 <=> y6 {
case Comparison.EqualTo => match x7 <=> y7 {
case Comparison.EqualTo => match x8 <=> y8 {
case Comparison.EqualTo => match x9 <=> y9 {
case Comparison.EqualTo => match x10 <=> y10 {
case Comparison.EqualTo => match x11 <=> y11 {
case Comparison.EqualTo => match x12 <=> y12 {
case Comparison.EqualTo => match x13 <=> y13 {
case Comparison.EqualTo => match x14 <=> y14 {
case Comparison.EqualTo => x15 <=> y15
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
case res => res
}
}
}