firefly-compiler 0.5.35 → 0.5.37

package/core/Ordering.ff

@@ -1,161 +1,160 @@
-trait T: Order {
-    compare(x: T, y: T): Ordering
-}
-
-before[T: Order](x: T, y: T): Bool {
-    compare(x, y) == OrderingBefore
-}
-
-notBefore[T: Order](x: T, y: T): Bool {
-    compare(x, y) != OrderingBefore
-}
-
-after[T: Order](x: T, y: T): Bool {
-    compare(x, y) == OrderingAfter
-}
-
-notAfter[T: Order](x: T, y: T): Bool {
-    compare(x, y) != OrderingAfter
-}
-
-reverse[T](compare: (T, T) => Ordering): (T, T) => Ordering {
-    {x, y => compare(x, y).{
-        | OrderingBefore => OrderingAfter
-        | OrderingSame => OrderingSame
-        | OrderingAfter => OrderingBefore
-    }}
-}
-
-pair[A, B](
-    compareFirst: (A, A) => Ordering
-    compareSecond: (B, B) => Ordering
-): (Pair[A, B], Pair[A, B]) => Ordering {
-    {x, y => compareFirst(x.first, y.first).{
-        | OrderingSame => compareSecond(x.second, y.second)
-        | ordering => ordering
-    }}
-}
-
-instance Nothing: Order {
-    compare(x: Nothing, y: Nothing): Ordering {OrderingSame}
-}
-
-instance Bool: Order {
-    compare(x: Bool, y: Bool): Ordering {
-        | False, True => OrderingBefore
-        | True, False => OrderingAfter
-        | _, _ => OrderingSame
-    }
-}
-
-instance Char: Order {
-    compare(x: Char, y: Char): Ordering {
-        fromInt(x.codeUnit - y.codeUnit)
-    }
-}
-
-instance Int: Order {
-    compare(x: Int, y: Int): Ordering {fromInt(x - y)}
-}
-
-instance Float: Order {
-    compare(x: Float, y: Float): Ordering {fromFloat(x - y)}
-}
-
-instance String: Order {
-    compare(x: String, y: String): Ordering
-        target js sync """
-            if(x_ < y_) {
-                return ff_core_Ordering.OrderingBefore()
-            } else if(x_ > y_) {
-                return ff_core_Ordering.OrderingAfter()
-            } else {
-                return ff_core_Ordering.OrderingSame()
-            }
-        """
-}
-
-instance Pair[A: Order, B: Order]: Order {
-    compare(x: Pair[A, B], y: Pair[A, B]): Ordering {
-        compare(x.first, y.first).{
-            | OrderingSame => compare(x.second, y.second)
-            | o => o
-        }
-    }
-}
-
-instance List[T: Order]: Order {
-    compare(x: List[T], y: List[T]): Ordering {
-        mutable ordering = OrderingSame
-        mutable i = 0
-        while {i < x.size() && i < y.size() && ordering == OrderingSame} {
-            ordering = compare(x.grab(i), y.grab(i))
-            i += 1
-        }
-        if(ordering != OrderingSame) {
-            fromInt(x.size() - y.size())
-        } else {
-            ordering
-        }
-    }
-}
-
-data Ordering {
-    OrderingBefore
-    OrderingSame
-    OrderingAfter
-}
-
-instance Ordering: Equal {
-    equals(x: Ordering, y: Ordering): Bool {
-        | OrderingBefore, OrderingBefore => True
-        | OrderingSame, OrderingSame => True
-        | OrderingAfter, OrderingAfter => True
-        | _, _ => False
-    }
-}
-
-fromInt(order: Int): Ordering {
-    if(order < 0) {
-        OrderingBefore
-    } elseIf {order == 0} {
-        OrderingSame
-    } else {
-        OrderingAfter
-    }
-}
-
-fromFloat(order: Float): Ordering {
-    if(order < 0.0) {
-        OrderingBefore
-    } elseIf {order == 0.0} {
-        OrderingSame
-    } else {
-        OrderingAfter
-    }
-}
-
-fromLessThan[T](lessThan: (T, T) => Bool): (T, T) => Ordering {
-    {
-        | x, y {lessThan(x, y)} => OrderingBefore
-        | x, y {lessThan(y, x)} => OrderingAfter
-        | _, _ => OrderingSame
-    }
-}
-
-extend self: Ordering {
-    toInt(): Int {
-        self.{
-            | OrderingBefore => -1
-            | OrderingSame => 0
-            | OrderingAfter => 1
-        }
-    }
-    reverse(): Ordering {
-        self.{
-            | OrderingBefore => OrderingAfter
-            | OrderingSame => OrderingSame
-            | OrderingAfter => OrderingBefore
-        }
-    }
-}
+trait T: Order {
+    compare(x: T, y: T): Ordering
+}
+
+before[T: Order](x: T, y: T): Bool {
+    compare(x, y) == OrderingBefore
+}
+
+notBefore[T: Order](x: T, y: T): Bool {
+    compare(x, y) != OrderingBefore
+}
+
+after[T: Order](x: T, y: T): Bool {
+    compare(x, y) == OrderingAfter
+}
+
+notAfter[T: Order](x: T, y: T): Bool {
+    compare(x, y) != OrderingAfter
+}
+
+reverse[T](compare: (T, T) => Ordering): (T, T) => Ordering {
+    {x, y => compare(x, y).{
+        | OrderingBefore => OrderingAfter
+        | OrderingSame => OrderingSame
+        | OrderingAfter => OrderingBefore
+    }}
+}
+
+pair[A, B](
+    compareFirst: (A, A) => Ordering
+    compareSecond: (B, B) => Ordering
+): (Pair[A, B], Pair[A, B]) => Ordering {
+    {x, y => compareFirst(x.first, y.first).{
+        | OrderingSame => compareSecond(x.second, y.second)
+        | ordering => ordering
+    }}
+}
+
+instance Nothing: Order {
+    compare(x: Nothing, y: Nothing): Ordering {OrderingSame}
+}
+
+instance Bool: Order {
+    compare(x: Bool, y: Bool): Ordering {
+        | False, True => OrderingBefore
+        | True, False => OrderingAfter
+        | _, _ => OrderingSame
+    }
+}
+
+instance Char: Order {
+    compare(x: Char, y: Char): Ordering {
+        fromInt(x.codeUnit - y.codeUnit)
+    }
+}
+
+instance Int: Order {
+    compare(x: Int, y: Int): Ordering {fromInt(x - y)}
+}
+
+instance Float: Order {
+    compare(x: Float, y: Float): Ordering {fromFloat(x - y)}
+}
+
+instance String: Order {
+    compare(x: String, y: String): Ordering {
+        if(Js.binaryOperator("<", x, y)?) {
+            OrderingBefore
+        } elseIf {Js.binaryOperator(">", x, y)?} {
+            OrderingAfter
+        } else {
+            OrderingSame
+        }
+    }
+}
+
+instance Pair[A: Order, B: Order]: Order {
+    compare(x: Pair[A, B], y: Pair[A, B]): Ordering {
+        compare(x.first, y.first).{
+            | OrderingSame => compare(x.second, y.second)
+            | o => o
+        }
+    }
+}
+
+instance List[T: Order]: Order {
+    compare(x: List[T], y: List[T]): Ordering {
+        mutable ordering = OrderingSame
+        mutable i = 0
+        while {i < x.size() && i < y.size() && ordering == OrderingSame} {
+            ordering = compare(x.grab(i), y.grab(i))
+            i += 1
+        }
+        if(ordering != OrderingSame) {
+            fromInt(x.size() - y.size())
+        } else {
+            ordering
+        }
+    }
+}
+
+data Ordering {
+    OrderingBefore
+    OrderingSame
+    OrderingAfter
+}
+
+instance Ordering: Equal {
+    equals(x: Ordering, y: Ordering): Bool {
+        | OrderingBefore, OrderingBefore => True
+        | OrderingSame, OrderingSame => True
+        | OrderingAfter, OrderingAfter => True
+        | _, _ => False
+    }
+}
+
+fromInt(order: Int): Ordering {
+    if(order < 0) {
+        OrderingBefore
+    } elseIf {order == 0} {
+        OrderingSame
+    } else {
+        OrderingAfter
+    }
+}
+
+fromFloat(order: Float): Ordering {
+    if(order < 0.0) {
+        OrderingBefore
+    } elseIf {order == 0.0} {
+        OrderingSame
+    } else {
+        OrderingAfter
+    }
+}
+
+fromLessThan[T](lessThan: (T, T) => Bool): (T, T) => Ordering {
+    {
+        | x, y {lessThan(x, y)} => OrderingBefore
+        | x, y {lessThan(y, x)} => OrderingAfter
+        | _, _ => OrderingSame
+    }
+}
+
+extend self: Ordering {
+    toInt(): Int {
+        self.{
+            | OrderingBefore => -1
+            | OrderingSame => 0
+            | OrderingAfter => 1
+        }
+    }
+    reverse(): Ordering {
+        self.{
+            | OrderingBefore => OrderingAfter
+            | OrderingSame => OrderingSame
+            | OrderingAfter => OrderingBefore
+        }
+    }
+}