firefly-compiler 0.4.78 → 0.4.79

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/Show.ff

@@ -1,43 +1,43 @@
-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
+        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) + ")"
+    }
+}

package/core/SourceLocation.ff

@@ -1,68 +1,68 @@
-newtype SourceLocation(location: String) // E.g. "directory/Module:line:column,group,package>Type>function"
-
-here(location: SourceLocation = SourceLocation.callSite()): SourceLocation {
-    location
-}
-
-callSite(): SourceLocation {
-    panic("SourceLocation.callSite() can only occur as the default value of an argument")
-}
-
-extend self: SourceLocation {
-
-    group(): String {
-        self.location.dropWhile {_ != ','}.dropFirst().takeWhile {_ != ','}
-    }
-    
-    package(): String {
-        self.location.dropWhile {_ != ','}.dropFirst().dropWhile {_ != ','}.dropFirst().takeWhile {_ != '>'}
-    }
-    
-    directory(): String {
-        self.location.takeWhile {_ != ':'}.reverse().dropWhile {_ != '/'}.dropFirst().reverse()
-    }
-
-    module(): String {
-        self.location.takeWhile {_ != ':'}.reverse().takeWhile {_ != '/'}.reverse()
-    }
-    
-    line(): Int {
-        self.location.dropWhile {_ != ':'}.dropFirst().takeWhile {_ != ':'}.grabInt()
-    }
-
-    column(): Int {
-        self.location.dropWhile {_ != ':'}.dropFirst().dropWhile {_ != ':'}.dropFirst().takeWhile {_ != ','}.grabInt()
-    }
-    
-    breadcrumbs(): List[String] {
-        self.location.dropWhile {_ != '>'}.dropFirst().split('>')
-    }
-
-}
-
-instance SourceLocation: Show {
-    show(self: SourceLocation): String {
-        self.location
-    }
-}
-
-instance SourceLocation: Equal {
-    equals(a: SourceLocation, b: SourceLocation): Bool {
-        a.location == b.location
-    }
-}
-
-instance SourceLocation: Order {
-    compare(a: SourceLocation, b: SourceLocation): Ordering {
-        Ordering.compare(a.location, b.location)
-    }
-}
-
-instance SourceLocation: Serializable {
-    serializeUsing(serialization: Serialization, self: SourceLocation) {
-        Serializable.serializeUsing(serialization, self.location)
-    }
-    deserializeUsing(serialization: Serialization): SourceLocation {
-        SourceLocation(Serializable.deserializeUsing(serialization))
-    }
-}
+newtype SourceLocation(location: String) // E.g. "directory/Module:line:column,group,package>Type>function"
+
+here(location: SourceLocation = SourceLocation.callSite()): SourceLocation {
+    location
+}
+
+callSite(): SourceLocation {
+    panic("SourceLocation.callSite() can only occur as the default value of an argument")
+}
+
+extend self: SourceLocation {
+
+    group(): String {
+        self.location.dropWhile {_ != ','}.dropFirst().takeWhile {_ != ','}
+    }
+    
+    package(): String {
+        self.location.dropWhile {_ != ','}.dropFirst().dropWhile {_ != ','}.dropFirst().takeWhile {_ != '>'}
+    }
+    
+    directory(): String {
+        self.location.takeWhile {_ != ':'}.reverse().dropWhile {_ != '/'}.dropFirst().reverse()
+    }
+
+    module(): String {
+        self.location.takeWhile {_ != ':'}.reverse().takeWhile {_ != '/'}.reverse()
+    }
+    
+    line(): Int {
+        self.location.dropWhile {_ != ':'}.dropFirst().takeWhile {_ != ':'}.grabInt()
+    }
+
+    column(): Int {
+        self.location.dropWhile {_ != ':'}.dropFirst().dropWhile {_ != ':'}.dropFirst().takeWhile {_ != ','}.grabInt()
+    }
+    
+    breadcrumbs(): List[String] {
+        self.location.dropWhile {_ != '>'}.dropFirst().split('>')
+    }
+
+}
+
+instance SourceLocation: Show {
+    show(self: SourceLocation): String {
+        self.location
+    }
+}
+
+instance SourceLocation: Equal {
+    equals(a: SourceLocation, b: SourceLocation): Bool {
+        a.location == b.location
+    }
+}
+
+instance SourceLocation: Order {
+    compare(a: SourceLocation, b: SourceLocation): Ordering {
+        Ordering.compare(a.location, b.location)
+    }
+}
+
+instance SourceLocation: Serializable {
+    serializeUsing(serialization: Serialization, self: SourceLocation) {
+        Serializable.serializeUsing(serialization, self.location)
+    }
+    deserializeUsing(serialization: Serialization): SourceLocation {
+        SourceLocation(Serializable.deserializeUsing(serialization))
+    }
+}