firefly-compiler 0.4.18 → 0.4.19

package/core/Map.ff

@@ -42,10 +42,6 @@ extend self[K: Order, V]: Map[K, V] {
         self.redBlack.pairs()
     }
 
-    toArray(): Array[Pair[K, V]] {
-        self.redBlack.pairs().toArray() // TODO: Avoid going through List
-    }
-
     toStream(cycle: Bool = False): Stream[Pair[K, V]] {
         self.redBlack.toStream(cycle)
     }
@@ -107,12 +103,12 @@ extend self[K: Order, V]: Map[K, List[V]] {
 
 }
 
-extend self[K: Order, V]: Map[K, Stack[V]] {
+extend self[K: Order, V]: Map[K, Array[V]] {
 
-    push(key: K, value: V): Map[K, Stack[V]] {
+    push(key: K, value: V): Map[K, Array[V]] {
         self.get(key).{
-            | None => self.add(key, [value].toStack())
-            | Some(stack) => stack.push(value); self
+            | None => self.add(key, [value].toArray())
+            | Some(array) => array.push(value); self
         }
     }
 

package/core/NodeSystem.ff

@@ -2,7 +2,7 @@ capability NodeSystem {}
 
 extend self: NodeSystem {
 
-    arguments(): Array[String]
+    arguments(): List[String]
         target node async "return self_.array_"
 
     assets(): AssetSystem {
@@ -88,7 +88,7 @@ extend self: NodeSystem {
 internalAssets(system: NodeSystem): AssetSystem
     target node async "return system_.assets_"
 
-internalListDirectoryWithoutOpendir(system: NodeSystem, path: Path): Array[Path]
+internalListDirectoryWithoutOpendir(system: NodeSystem, path: Path): List[Path]
     target node async """
         import * as fsPromises from 'fs/promises'
         import * as path from 'path'

package/core/Option.ff

@@ -44,10 +44,6 @@ extend self[T]: Option[T] {
         }
     }
 
-    toStack(): Stack[T] {
-        self.toList().toStack()
-    }
-
     toArray(): Array[T] {
         self.toList().toArray()
     }

package/core/Ordering.ff

@@ -86,12 +86,16 @@ instance Pair[A: Order, B: Order]: Order {
 
 instance List[T: Order]: Order {
     compare(x: List[T], y: List[T]): Ordering {
-        | [], [] => OrderingSame
-        | [], _ => OrderingBefore
-        | _, [] => OrderingAfter
-        | [a, ...as], [b, ...bs] => compare(a, b).{
-            | OrderingSame => compare(as, bs)
-            | o => o
+        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
         }
     }
 }

package/core/Pair.ff

@@ -32,10 +32,6 @@ extend self[A, A]: Pair[A, A] {
         self.toList().toArray()
     }
 
-    toStack(): Stack[A] {
-        self.toList().toStack()
-    }
-
 }
 
 extend self[A: Order]: Pair[A, A] {

package/core/Random.ff

@@ -100,48 +100,34 @@ extend self: Random {
             }
         """
 
-    shuffleStack[T](stack: Stack[T]): Unit {
-        0.until(stack.size() - 1).each {i =>
-            let j = self.nextInt(0, stack.size() - i) + i
-            let value = stack.grab(i)
-            stack.set(i, stack.grab(j))
-            stack.set(j, value)
+    shuffleArray[T](array: Array[T]): Unit {
+        0.until(array.size() - 1).each {i =>
+            let j = self.nextInt(0, array.size() - i) + i
+            let value = array.grab(i)
+            array.set(i, array.grab(j))
+            array.set(j, value)
         }
     }
     
-    shuffleArray[T](array: Array[T]): Array[T] {
-        let stack = array.toStack()
-        self.shuffleStack(array.toStack())
-        stack.drain()
-    }
-    
     shuffleList[T](list: List[T]): List[T] {
-        let stack = list.toStack()
-        self.shuffleStack(list.toStack())
-        stack.toList()
+        let array = list.toArray()
+        self.shuffleArray(list.toArray())
+        array.drain()
     }
 
-    sampleStack[T](count: Int, stack: Stack[T], body: T => Unit): Unit {
-        self.shuffleArray(stack.toArray()).takeFirst(count).each {body(_)}
+    sampleArray[T](count: Int, array: Array[T], body: T => Unit): Unit {
+        self.shuffleList(array.toList()).takeFirst(count).each {body(_)}
     }
 
-    sampleArray[T](count: Int, array: Array[T]): Array[T] {
-        self.shuffleArray(array).takeFirst(count)
-    }
-    
     sampleList[T](count: Int, list: List[T]): List[T] {
         self.shuffleList(list).takeFirst(count)
     }
 
-    grabStack[T](stack: Stack[T]): T {
-        stack.grab(self.nextInt(0, stack.size()))
-    }
-
     grabArray[T](array: Array[T]): T {
         array.grab(self.nextInt(0, array.size()))
     }
 
-    grabList[T](list: Stack[T]): T {
+    grabList[T](list: List[T]): T {
         list.grab(self.nextInt(0, list.size()))
     }
 

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]] {
-        mutable result = []
-        self.each {k, v =>
-            result = [Pair(k, v), ...result]
-        }
-        result.reverse()
-    }
-
-    toStream(cycle: Bool): Stream[Pair[K, V]] {
-        mutable stack = [self]
-        function next(): Option[Pair[K, V]] {
-            stack.{
-                | [] =>
-                    if(cycle && self.{| E => False | _ => True}) {
-                        stack = [self]
-                        tailcall next()
-                    } else {
-                        None
-                    }
-                | [E, ...tail] =>
-                    stack = tail
-                    tailcall next()
-                | [T(_, E, k, v, E), ...tail] =>
-                    stack = tail
-                    Some(Pair(k, v))
-                | [T(_, l, k, v, r), ...tail] =>
-                    stack = [l, T(B, E, k, v, E), r, ...tail]
-                    tailcall next()
-            }
-        }
-        Stream.make(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.make(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

@@ -67,8 +67,8 @@ instance Bool: Serializable {
     }
 }
 
-instance Array[T: Serializable]: Serializable {
-    serializeUsing(serialization: Serialization, value: Array[T]): Unit {
+instance List[T: Serializable]: Serializable {
+    serializeUsing(serialization: Serialization, value: List[T]): Unit {
         if(value.size() < 255) {
             serialization.autoResize(1)
             serialization.buffer.setUint8(serialization.offset, value.size())
@@ -83,43 +83,34 @@ instance Array[T: Serializable]: Serializable {
         }
         value.each {serializeUsing(serialization, _)}
     }
-    deserializeUsing(serialization: Serialization): Array[T] {
+    deserializeUsing(serialization: Serialization): List[T] {
         let smallSize = serialization.buffer.grabUint8(serialization.offset)
         if(smallSize != 255) {
             serialization.offset += 1
-            Array.fillBy(smallSize) {_ => deserializeUsing(serialization)}
+            List.fillBy(smallSize) {_ => deserializeUsing(serialization)}
         } else {
             let size = serialization.buffer.grabUint32(serialization.offset + 1)
             serialization.offset += 1 + 4
-            Array.fillBy(size) {_ => deserializeUsing(serialization)}
+            List.fillBy(size) {_ => deserializeUsing(serialization)}
         }
     }
 }
 
-instance List[T: Serializable]: Serializable {
-    serializeUsing(serialization: Serialization, value: List[T]): Unit {
-        serializeUsing(serialization, value.toArray())
-    }
-    deserializeUsing(serialization: Serialization): List[T] {
-        deserializeUsing[Array[T]](serialization).toList()
-    }
-}
-
 instance Set[T: Serializable: Order]: Serializable {
     serializeUsing(serialization: Serialization, value: Set[T]): Unit {
-        serializeUsing(serialization, value.toArray())
+        serializeUsing(serialization, value.toList())
     }
     deserializeUsing(serialization: Serialization): Set[T] {
-        deserializeUsing[Array[T]](serialization).toSet()
+        deserializeUsing[List[T]](serialization).toSet()
     }
 }
 
 instance Map[K: Serializable: Order, V: Serializable]: Serializable {
     serializeUsing(serialization: Serialization, value: Map[K, V]): Unit {
-        serializeUsing(serialization, value.toArray())
+        serializeUsing(serialization, value.toList())
     }
     deserializeUsing(serialization: Serialization): Map[K, V] {
-        deserializeUsing[Array[Pair[K, V]]](serialization).toMap()
+        deserializeUsing[List[Pair[K, V]]](serialization).toMap()
     }
 }
 

package/core/Set.ff

@@ -12,7 +12,6 @@ extend self[T: Order]: Set[T] {
     contains(value: T): Bool {self.map.contains(value)}
     size(): Int {self.map.size()}
     toList(): List[T] {self.map.toList().map {_.first}}
-    toArray(): Array[T] {self.map.toArray().map {_.first}}
     toStream(cycle: Bool = False): Stream[T] {self.map.toStream(cycle).map {_.first }}
     each(body: T => Unit): Unit {self.map.each {| k, _ => body(k)}}
     eachWhile(body: T => Bool): Bool {self.map.eachWhile {| k, _ => body(k)}}

package/core/SourceLocation.ff

@@ -34,7 +34,7 @@ extend self: SourceLocation {
         self.location.dropWhile {_ != ':'}.dropFirst().dropWhile {_ != ':'}.dropFirst().takeWhile {_ != ','}.grabInt()
     }
     
-    breadcrumbs(): Array[String] {
+    breadcrumbs(): List[String] {
         self.location.dropWhile {_ != '>'}.dropFirst().split('>')
     }