firefly-compiler 0.5.35 → 0.5.37

package/core/RbMap.ff

@@ -1,216 +1,216 @@
-// Based on https://www.cs.kent.ac.uk/people/staff/smk/redblack/Untyped.hs
-
-data Color {
-    R
-    B
-}
-
-data RB[K, V] {
-    E
-    T(color: Color, left: RB[K, V], key: K, value: V, right: RB[K, V])
-}
-
-insert[K: Order, V](x: K, xv: V, s: RB[K, V]): RB[K, V] {
-    function ins(s: RB[K, V]): RB[K, V] {
-        | E => T(R, E, x, xv, E)
-        | T(B, a, y, yv, b) => Ordering.compare(x, y).{
-            | OrderingBefore => balance(ins(a), y, yv, b)
-            | OrderingAfter => balance(a, y, yv, ins(b))
-            | OrderingSame => T(B, a, x, xv, b)
-        }
-        | T(R, a, y, yv, b) => Ordering.compare(x, y).{
-            | OrderingBefore => T(R, ins(a), y, yv, b)
-            | OrderingAfter => T(R, a, y, yv, ins(b))
-            | OrderingSame => T(R, a, x, xv, b)
-        }
-    }
-
-    ins(s).{
-        | E => panic("Unexpected empty tree")
-        | T(_, a, z, zv, b) => T(B, a, z, zv, b)
-    }
-}
-
-member[K: Order, V](key: K, tree: RB[K, V]): Bool {
-    | x, E => False
-    | x, T(_, a, y, _, b,) => Ordering.compare(x, y).{
-        | OrderingBefore => member(x, a)
-        | OrderingAfter => member(x, b)
-        | OrderingSame => True
-    }
-}
-
-balance[K: Order, V](tree1: RB[K, V], key: K, value: V, tree2: RB[K, V]): RB[K, V] {
-    | T(R, a, x, xv, b), y, yv, T(R, c, z, zv, d) => T(R, T(B, a, x, xv, b), y, yv, T(B, c, z, zv, d))
-    | T(R, T(R, a, x, xv, b), y, yv, c), z, zv, d => T(R, T(B, a, x, xv, b), y, yv, T(B, c, z, zv, d))
-    | T(R, a, x, xv, T(R, b, y, yv, c)), z, zv, d => T(R, T(B, a, x, xv, b), y, yv, T(B, c, z, zv, d))
-    | a, x, xv, T(R, b, y, yv, T(R, c, z, zv, d)) => T(R, T(B, a, x, xv, b), y, yv, T(B, c, z, zv, d))
-    | a, x, xv, T(R, T(R, b, y, yv, c), z, zv, d) => T(R, T(B, a, x, xv, b), y, yv, T(B, c, z, zv, d))
-    | a, x, xv, b => T(B, a, x, xv, b)
-}
-
-delete[K: Order, V](x: K, t: RB[K, V]): RB[K, V] {
-    function del(ss: RB[K, V]): RB[K, V] {
-        | E => E
-        | T(_, a, y, yv, b) => Ordering.compare(x, y).{
-            | OrderingBefore => delformLeft(a, y, yv, b)
-            | OrderingAfter => delformRight(a, y, yv, b)
-            | OrderingSame => app(a, b)
-        }
-    }
-
-    function delformLeft(left: RB[K, V], key: K, value: V, right: RB[K, V]): RB[K, V] {
-        | T(B, _, _, _, _), y, yv, b => balleft(del(left), y, yv, b)
-        | a, y, yv, b => T(R, del(a), y, yv, b)
-    }
-
-    function delformRight(left: RB[K, V], key: K, value: V, right: RB[K, V]): RB[K, V] {
-        | a, y, yv, T(B, _, _, _, _) => balright(a, y, yv, del(right))
-        | a, y, yv, b => T(R, a, y, yv, del(b))
-    }
-
-    del(t).{
-        | T(_, a, y, yv, b) => T(B, a, y, yv, b)
-        | _ => E
-    }
-}
-
-balleft[K: Order, V](tree1: RB[K, V], key: K, value: V, tree2: RB[K, V]): RB[K, V] {
-    | T(R, a, x, xv, b), y, yv, c => T(R, T(B, a, x, xv, b), y, yv, c)
-    | bl, x, xv, T(B, a, y, yv, b) => balance(bl, x, xv, T(R, a, y, yv, b))
-    | bl, x, xv, T(R, T(B, a, y, yv, b), z, zv, c) => T(R, T(B, bl, x, xv, a), y, yv, (balance(b, z, zv, sub1(c))))
-    | _, _, _, _ => panic("Unexhaustive match in balleft")
-}
-
-balright[K: Order, V](tree1: RB[K, V], key: K, value: V, tree2: RB[K, V]): RB[K, V] {
-    | a, x, xv, T(R, b, y, yv, c) => T(R, a, x, xv, T(B, b, y, yv, c))
-    | T(B, a, x, xv, b), y, yv, bl => balance(T(R, a, x, xv, b), y, yv, bl)
-    | T(R, a, x, xv, T(B, b, y, yv, c)), z, zv, bl => T(R, balance(sub1(a), x, xv, b), y, yv, T(B, c, z, zv, bl))
-    | _, _, _, _ => panic("Unexhaustive match in balright")
-}
-
-sub1[K: Order, V](tree: RB[K, V]): RB[K, V] {
-    | T(B, a, x, xv, b) => T(R, a, x, xv, b)
-    | _ => panic("invariance violation")
-}
-
-app[K: Order, V](tree1: RB[K, V], tree2: RB[K, V]): RB[K, V] {
-    | E, b => b
-    | a, E => a
-    | T(R, a, x, xv, b), T(R, c, y, yv, d) =>
-        app(b, c).{
-            | T(R, b2, z, zv, c2) => T(R, T(R, a, x, xv, b2), z, zv, T(R, c2, y, yv, d))
-            | bc => T(R, a, x, xv, T(R, bc, y, yv, d))
-        }
-    | T(B, a, x, xv, b), T(B, c, y, yv, d) =>
-        app(b, c).{
-            | T(R, b2, z, zv, c2) => T(R, T(B, a, x, xv, b2), z, zv, T(B, c2, y, yv, d))
-            | bc => balleft(a, x, xv, T(B, bc, y, yv, d))
-        }
-    | a, T(R, b, x, xv, c) => T(R, app(a, b), x, xv, c)
-    | T(R, a, x, xv, b), c => T(R, a, x, xv, app(b, c))
-}
-
-extend self[K: Order, V]: RB[K, V] {
-
-    get(key: K): Option[V] {
-        self.{
-            | E_ => None
-            | T(_, a, y, yv, b) => Ordering.compare(key, y).{
-                | OrderingBefore => a.get(key)
-                | OrderingAfter => b.get(key)
-                | OrderingSame => Some(yv)
-            }
-        }
-    }
-
-    size(): Int {
-        self.{
-            | E => 0
-            | T(_, l, _, _, r) => l.size() + 1 + r.size()
-        }
-    }
-
-    pairs(): List[Pair[K, V]] {
-        let result = [].toArray()
-        self.each {k, v =>
-            result.push(Pair(k, v))
-        }
-        result.drain()
-    }
-
-    toStream(cycle: Bool): Stream[Pair[K, V]] {
-        mutable array = [self]
-        function next(): Option[Pair[K, V]] {
-            array.{
-                | [] =>
-                    if(cycle && self.{| E => False | _ => True}) {
-                        array = [self]
-                        tailcall next()
-                    } else {
-                        None
-                    }
-                | [E, ...tail] =>
-                    array = tail
-                    tailcall next()
-                | [T(_, E, k, v, E), ...tail] =>
-                    array = tail
-                    Some(Pair(k, v))
-                | [T(_, l, k, v, r), ...tail] =>
-                    array = [l, T(B, E, k, v, E), r, ...tail]
-                    tailcall next()
-            }
-        }
-        Stream.new(next)
-    }
-
-    each(body: (K, V) => Unit): Unit {
-        self.{
-            | E =>
-            | T(_, l, k, v, r) =>
-                l.each(body)
-                body(k, v)
-                r.each(body)
-        }
-    }
-
-    eachWhile(body: (K, V) => Bool): Bool {
-        self.{
-            | E =>
-                True
-            | T(_, l, k, v, r) =>
-                l.eachWhile(body) &&
-                body(k, v) &&
-                r.eachWhile(body)
-        }
-    }
-
-    map[K2: Order, V2](body: (K, V) => Pair[K2, V2]): RB[K2, V2] {
-        mutable result = E
-        self.each {k, v =>
-            let pair = body(k, v)
-            result = insert(pair.first, pair.second, result)
-        }
-        result
-    }
-
-    mapValues[V2](body: (K, V) => V2): RB[K, V2] {
-        self.{
-            | E => E
-            | T(c, l, k, v, r) =>
-                T(c, l.mapValues(body), k, body(k, v), r.mapValues(body))
-        }
-    }
-
-    find(body: (K, V) => Bool): Option[Pair[K, V]] {
-        mutable result = None
-        self.eachWhile {k, v => 
-            if(body(k, v)) {
-                result = Some(Pair(k, v))
-                False
-            } else {True}
-        }
-        result
-    }
-
-}
+// Based on https://www.cs.kent.ac.uk/people/staff/smk/redblack/Untyped.hs
+
+data Color {
+    R
+    B
+}
+
+data RB[K, V] {
+    E
+    T(color: Color, left: RB[K, V], key: K, value: V, right: RB[K, V])
+}
+
+insert[K: Order, V](x: K, xv: V, s: RB[K, V]): RB[K, V] {
+    function ins(s: RB[K, V]): RB[K, V] {
+        | E => T(R, E, x, xv, E)
+        | T(B, a, y, yv, b) => Ordering.compare(x, y).{
+            | OrderingBefore => balance(ins(a), y, yv, b)
+            | OrderingAfter => balance(a, y, yv, ins(b))
+            | OrderingSame => T(B, a, x, xv, b)
+        }
+        | T(R, a, y, yv, b) => Ordering.compare(x, y).{
+            | OrderingBefore => T(R, ins(a), y, yv, b)
+            | OrderingAfter => T(R, a, y, yv, ins(b))
+            | OrderingSame => T(R, a, x, xv, b)
+        }
+    }
+
+    ins(s).{
+        | E => panic("Unexpected empty tree")
+        | T(_, a, z, zv, b) => T(B, a, z, zv, b)
+    }
+}
+
+member[K: Order, V](key: K, tree: RB[K, V]): Bool {
+    | x, E => False
+    | x, T(_, a, y, _, b,) => Ordering.compare(x, y).{
+        | OrderingBefore => member(x, a)
+        | OrderingAfter => member(x, b)
+        | OrderingSame => True
+    }
+}
+
+balance[K: Order, V](tree1: RB[K, V], key: K, value: V, tree2: RB[K, V]): RB[K, V] {
+    | T(R, a, x, xv, b), y, yv, T(R, c, z, zv, d) => T(R, T(B, a, x, xv, b), y, yv, T(B, c, z, zv, d))
+    | T(R, T(R, a, x, xv, b), y, yv, c), z, zv, d => T(R, T(B, a, x, xv, b), y, yv, T(B, c, z, zv, d))
+    | T(R, a, x, xv, T(R, b, y, yv, c)), z, zv, d => T(R, T(B, a, x, xv, b), y, yv, T(B, c, z, zv, d))
+    | a, x, xv, T(R, b, y, yv, T(R, c, z, zv, d)) => T(R, T(B, a, x, xv, b), y, yv, T(B, c, z, zv, d))
+    | a, x, xv, T(R, T(R, b, y, yv, c), z, zv, d) => T(R, T(B, a, x, xv, b), y, yv, T(B, c, z, zv, d))
+    | a, x, xv, b => T(B, a, x, xv, b)
+}
+
+delete[K: Order, V](x: K, t: RB[K, V]): RB[K, V] {
+    function del(ss: RB[K, V]): RB[K, V] {
+        | E => E
+        | T(_, a, y, yv, b) => Ordering.compare(x, y).{
+            | OrderingBefore => delformLeft(a, y, yv, b)
+            | OrderingAfter => delformRight(a, y, yv, b)
+            | OrderingSame => app(a, b)
+        }
+    }
+
+    function delformLeft(left: RB[K, V], key: K, value: V, right: RB[K, V]): RB[K, V] {
+        | T(B, _, _, _, _), y, yv, b => balleft(del(left), y, yv, b)
+        | a, y, yv, b => T(R, del(a), y, yv, b)
+    }
+
+    function delformRight(left: RB[K, V], key: K, value: V, right: RB[K, V]): RB[K, V] {
+        | a, y, yv, T(B, _, _, _, _) => balright(a, y, yv, del(right))
+        | a, y, yv, b => T(R, a, y, yv, del(b))
+    }
+
+    del(t).{
+        | T(_, a, y, yv, b) => T(B, a, y, yv, b)
+        | _ => E
+    }
+}
+
+balleft[K: Order, V](tree1: RB[K, V], key: K, value: V, tree2: RB[K, V]): RB[K, V] {
+    | T(R, a, x, xv, b), y, yv, c => T(R, T(B, a, x, xv, b), y, yv, c)
+    | bl, x, xv, T(B, a, y, yv, b) => balance(bl, x, xv, T(R, a, y, yv, b))
+    | bl, x, xv, T(R, T(B, a, y, yv, b), z, zv, c) => T(R, T(B, bl, x, xv, a), y, yv, (balance(b, z, zv, sub1(c))))
+    | _, _, _, _ => panic("Unexhaustive match in balleft")
+}
+
+balright[K: Order, V](tree1: RB[K, V], key: K, value: V, tree2: RB[K, V]): RB[K, V] {
+    | a, x, xv, T(R, b, y, yv, c) => T(R, a, x, xv, T(B, b, y, yv, c))
+    | T(B, a, x, xv, b), y, yv, bl => balance(T(R, a, x, xv, b), y, yv, bl)
+    | T(R, a, x, xv, T(B, b, y, yv, c)), z, zv, bl => T(R, balance(sub1(a), x, xv, b), y, yv, T(B, c, z, zv, bl))
+    | _, _, _, _ => panic("Unexhaustive match in balright")
+}
+
+sub1[K: Order, V](tree: RB[K, V]): RB[K, V] {
+    | T(B, a, x, xv, b) => T(R, a, x, xv, b)
+    | _ => panic("invariance violation")
+}
+
+app[K: Order, V](tree1: RB[K, V], tree2: RB[K, V]): RB[K, V] {
+    | E, b => b
+    | a, E => a
+    | T(R, a, x, xv, b), T(R, c, y, yv, d) =>
+        app(b, c).{
+            | T(R, b2, z, zv, c2) => T(R, T(R, a, x, xv, b2), z, zv, T(R, c2, y, yv, d))
+            | bc => T(R, a, x, xv, T(R, bc, y, yv, d))
+        }
+    | T(B, a, x, xv, b), T(B, c, y, yv, d) =>
+        app(b, c).{
+            | T(R, b2, z, zv, c2) => T(R, T(B, a, x, xv, b2), z, zv, T(B, c2, y, yv, d))
+            | bc => balleft(a, x, xv, T(B, bc, y, yv, d))
+        }
+    | a, T(R, b, x, xv, c) => T(R, app(a, b), x, xv, c)
+    | T(R, a, x, xv, b), c => T(R, a, x, xv, app(b, c))
+}
+
+extend self[K: Order, V]: RB[K, V] {
+
+    get(key: K): Option[V] {
+        self.{
+            | E_ => None
+            | T(_, a, y, yv, b) => Ordering.compare(key, y).{
+                | OrderingBefore => a.get(key)
+                | OrderingAfter => b.get(key)
+                | OrderingSame => Some(yv)
+            }
+        }
+    }
+
+    size(): Int {
+        self.{
+            | E => 0
+            | T(_, l, _, _, r) => l.size() + 1 + r.size()
+        }
+    }
+
+    pairs(): List[Pair[K, V]] {
+        let result = [].toArray()
+        self.each {k, v =>
+            result.push(Pair(k, v))
+        }
+        result.drain()
+    }
+
+    toStream(cycle: Bool): Stream[Pair[K, V]] {
+        mutable array = [self]
+        function next(): Option[Pair[K, V]] {
+            array.{
+                | [] =>
+                    if(cycle && self.{| E => False | _ => True}) {
+                        array = [self]
+                        tailcall next()
+                    } else {
+                        None
+                    }
+                | [E, ...tail] =>
+                    array = tail
+                    tailcall next()
+                | [T(_, E, k, v, E), ...tail] =>
+                    array = tail
+                    Some(Pair(k, v))
+                | [T(_, l, k, v, r), ...tail] =>
+                    array = [l, T(B, E, k, v, E), r, ...tail]
+                    tailcall next()
+            }
+        }
+        Stream.new(next)
+    }
+
+    each(body: (K, V) => Unit): Unit {
+        self.{
+            | E =>
+            | T(_, l, k, v, r) =>
+                l.each(body)
+                body(k, v)
+                r.each(body)
+        }
+    }
+
+    eachWhile(body: (K, V) => Bool): Bool {
+        self.{
+            | E =>
+                True
+            | T(_, l, k, v, r) =>
+                l.eachWhile(body) &&
+                body(k, v) &&
+                r.eachWhile(body)
+        }
+    }
+
+    map[K2: Order, V2](body: (K, V) => Pair[K2, V2]): RB[K2, V2] {
+        mutable result = E
+        self.each {k, v =>
+            let pair = body(k, v)
+            result = insert(pair.first, pair.second, result)
+        }
+        result
+    }
+
+    mapValues[V2](body: (K, V) => V2): RB[K, V2] {
+        self.{
+            | E => E
+            | T(c, l, k, v, r) =>
+                T(c, l.mapValues(body), k, body(k, v), r.mapValues(body))
+        }
+    }
+
+    find(body: (K, V) => Bool): Option[Pair[K, V]] {
+        mutable result = None
+        self.eachWhile {k, v => 
+            if(body(k, v)) {
+                result = Some(Pair(k, v))
+                False
+            } else {True}
+        }
+        result
+    }
+
+}

package/core/Serializable.ff

@@ -147,18 +147,21 @@ instance String: Serializable {
 }
 
 
-internalSetLatin1(self: Buffer, byteOffset: Int, value: String): Bool
-    target js sync """
-        for(let i = 0; i < value_.length; i++) {
-            let charCode = value_.charCodeAt(i)
-            if(charCode >= 256) return false
-            self_.setUint8(byteOffset_ + i, charCode)
+internalSetLatin1(self: Buffer, byteOffset: Int, value: String): Bool {
+    mutable result = True
+    0.until(value.size()).eachWhile {i =>
+        let charCode: Int = value!->charCodeAt(i)?
+        if(charCode >= 256) {
+            result = False
+        } else {
+            self!->setUint8(byteOffset + i, charCode)
         }
-        return true
-    """
+        result
+    }
+    result
+}
 
-internalGrabLatin1(self: Buffer, byteOffset: Int, size: Int): String
-    target js sync """
-        const codeUnits = new Uint8Array(self_.buffer, self_.byteOffset + byteOffset_, size_)
-        return String.fromCharCode.apply(null, codeUnits)
-    """
+internalGrabLatin1(self: Buffer, byteOffset: Int, size: Int): String {
+    let codeUnits = Js->Uint8Array->(self!->buffer, self!->byteOffset + byteOffset!, size)
+    Js->String->fromCharCode->apply(Js.null(), codeUnits)?
+}

package/core/Show.ff

@@ -1,43 +1,44 @@
-trait T: Show {
-    show(value: T): String
-}
-
-instance Bool: Show {
-    show(value: Bool): String {
-        | False => "False"
-        | True => "True"
-    }
-}
-
-instance Nothing: Show {
-    show(value: Nothing): String {""}
-}
-
-instance Char: Show {
-    show(value: Char): String {value.toString()}
-}
-
-instance Int: Show {
-    show(value: Int): String {"" + value}
-}
-
-instance Float: Show {
-    show(value: Float): String {"" + value}
-}
-
-instance String: Show {
-    show(value: String): String
-        target js sync "return JSON.stringify(value_);"
-}
-
-instance List[T: Show]: Show {
-    show(value: List[T]): String {
-        "[" + value.map(show).join(", ") + "]"
-    }
-}
-
-instance Pair[A: Show, B: Show]: Show {
-    show(value: Pair[A, B]): String {
-        "Pair(" + show(value.first) + ", " + show(value.second) + ")"
-    }
-}
+trait T: Show {
+    show(value: T): String
+}
+
+instance Bool: Show {
+    show(value: Bool): String {
+        | False => "False"
+        | True => "True"
+    }
+}
+
+instance Nothing: Show {
+    show(value: Nothing): String {""}
+}
+
+instance Char: Show {
+    show(value: Char): String {value.toString()}
+}
+
+instance Int: Show {
+    show(value: Int): String {"" + value}
+}
+
+instance Float: Show {
+    show(value: Float): String {"" + value}
+}
+
+instance String: Show {
+    show(value: String): String {
+        Js->JSON->stringify(value)?
+    }
+}
+
+instance List[T: Show]: Show {
+    show(value: List[T]): String {
+        "[" + value.map(show).join(", ") + "]"
+    }
+}
+
+instance Pair[A: Show, B: Show]: Show {
+    show(value: Pair[A, B]): String {
+        "Pair(" + show(value.first) + ", " + show(value.second) + ")"
+    }
+}