firefly-compiler 0.4.51 → 0.4.52

package/core/List.ff

@@ -1,486 +1,486 @@
-data List[T] {}
-
-new[T](): List[T]
-    target js sync """
-        return [];
-    """
-
-fill[T](size: Int, value: T): List[T]
-    target js sync """
-        return new Array(size_).fill(value_);
-    """
-
-fillBy[T](size: Int, body: Int => T): List[T]
-    target js sync """
-        return Array.from({length: size_}, (_, i) => body_(i));
-    """
-    target js async """
-        const array = new Array(size_);
-        for(let i = 0; i < size_; i++) {
-            array[i] = await(body_(_i));
-        }
-        return array;
-    """
-
-range(size: Int): List[Int]
-    target js sync """
-        return Array.from({length: size_}, (_, i) => i);
-    """
-
-extend self[T]: List[T] {
-
-    addAll(that: List[T]): List[T]
-        target js sync "return self_.concat(that_)"
-
-    isEmpty(): Bool
-        target js sync "return self_.length === 0"
-
-    size(): Int
-        target js sync "return self_.length"
-
-    get(index: Int): Option[T]
-        target js sync """
-            return index_ >= 0 && index_ < self_.length
-                ? ff_core_Option.Some(self_[index_])
-                : ff_core_Option.None()
-        """
-
-    grab(index: Int): T
-        target js sync """
-            return self_[index_] ?? internalGrab_(self_, index_);
-        """
-
-    first(): Option[T] {self.get(0)}
-
-    last(): Option[T] {self.get(self.size() - 1)}
-
-    grabFirst(): T {self.grab(0)}
-
-    grabLast(): T {self.grab(self.size() - 1)}
-
-    takeFirst(count: Int = 1): List[T]
-        target js sync "return self_.slice(0, count_)"
-
-    takeLast(count: Int = 1): List[T]
-        target js sync "return self_.slice(-count_)"
-
-    dropFirst(count: Int = 1): List[T]
-        target js sync "return self_.slice(count_)"
-
-    dropLast(count: Int = 1): List[T]
-        target js sync "return self_.slice(0, self_.length - count_)"
-        
-    count(body: T => Bool): Int {
-        mutable result = 0
-        mutable i = 0
-        while {i < self.size()} {
-            if(body(self.grab(i))) {result += 1}
-            i += 1
-        }
-        result
-    }
-
-    countWhile(body: T => Bool): Int {
-        mutable i = 0
-        while {i < self.size() && body(self.grab(i))} {
-            i += 1
-        }
-        i
-    }
-
-    takeWhile(body: T => Bool): List[T] {
-        let result = Array.new()
-        mutable i = 0
-        while {i < self.size() && body(self.grab(i))} {
-            result.push(self.grab(i))
-            i += 1
-        }
-        result.drain()
-    }
-
-    dropWhile(body: T => Bool): List[T] {
-        let result = Array.new()
-        mutable i = 0
-        while {i < self.size() && body(self.grab(i))} {
-            i += 1
-        }
-        while {i < self.size()} {
-            result.push(self.grab(i))
-            i += 1
-        }
-        result.drain()
-    }
-    
-    partitionWhile(body: T => Bool): Pair[List[T], List[T]] {
-        let first = Array.new()
-        let second = Array.new()
-        mutable i = 0
-        while {i < self.size() && body(self.grab(i))} {
-            first.push(self.grab(i))
-            i += 1
-        }
-        while {i < self.size()} {
-            second.push(self.grab(i))
-            i += 1
-        }
-        Pair(first.drain(), second.drain())
-    }
-    
-    pairs(): List[Pair[Int, T]] {
-        mutable i = 0
-        self.map {x =>
-            let r = Pair(i, x)
-            i += 1
-            r
-        }
-    }
-    
-    slice(from: Int, until: Int): List[T] {
-        self.dropFirst(from).takeFirst(until - from)
-    }
-    
-    foldLeft[R](initial: R, body: (R, T) => R): R {
-        mutable result = initial
-        self.each {x =>
-            result = body(result, x)
-        }
-        result
-    }    
-
-    update(index: Int, value: T): List[T] {
-        self.modify(index) {_ => value}
-    }
-    
-    modify(index: Int, body: T => T): List[T]
-        target js sync """
-            if(index_ < 0 || index_ >= self_.length) {
-                ff_core_Try.internalThrowGrabException_()
-            }
-            let result = self_.slice();
-            result[index_] = body_(result[index_]);
-            return result;
-        """
-        target js async """
-            if(index_ < 0 || index_ >= self_.length) {
-                ff_core_Try.internalThrowGrabException_()
-            }
-            let result = self_.slice();
-            result[index_] = await body_(result[index_], $task);
-            return result;
-        """
-        
-    zip[S](that: List[S]): List[Pair[T, S]] {
-        if(self.size() <= that.size()) {
-            mutable i = -1
-            self.map {x => 
-                i += 1
-                Pair(x, that.grab(i))
-            }
-        } else {
-            mutable i = -1
-            that.map {y => 
-                i += 1
-                Pair(self.grab(i), y)
-            }
-        }
-    }
-
-    chunk(chunkSize: Int): List[List[T]] {
-        let results = Array.new()
-        let result = Array.new()
-        mutable added = 0
-        self.each {item =>
-            if(added < chunkSize) {
-                added += 1
-            } else {
-                results.push(result.drain())
-                added = 1
-            }
-            result.push(item)
-        }
-        if(added != 0) {
-            results.push(result.drain())
-        }
-        results.drain()
-    }
-
-    toStream(cycle: Bool = False): Stream[T] {
-        mutable index = 0
-        Stream.new {
-            if(index < self.size()) {
-                let result = self.grab(index)
-                index += 1
-                result
-            } elseIf {cycle && index != 0} {
-                let result = self.grab(0)
-                index = 1
-                result
-            }
-        }
-    }
-
-    toArray(): Array[T]
-        target js sync "return {array: self_.slice()}"
-
-    each(body: T => Unit): Unit
-        target js sync """
-            return self_.forEach(body_);
-        """
-        target js async """
-            for(let i = 0; i < self_.length; i++) {
-                await body_(self_[i], $task)
-            }
-        """
-
-    eachWhile(body: T => Bool): Unit
-        target js sync "for(const value of self_) if(!body_(value)) break"
-        target js async "for(const value of self_) if(!await body_(value, $task)) break"
-
-    all(body: T => Bool): Bool {
-        mutable result = True
-        self.eachWhile {x =>
-            result = result && body(x)
-            result
-        }
-        result
-    }
-
-    any(body: T => Bool): Bool {
-        mutable result = False
-        self.eachWhile {x =>
-            result = result || body(x)
-            (!result)
-        }
-        result
-    }
-
-    indexWhere(body: T => Bool): Option[Int] {
-        mutable result = None
-        mutable i = 0
-        self.eachWhile {x =>
-            if(body(x)) {
-                result = Some(i)
-                False
-            } else {
-                i += 1
-                True
-            }
-        }
-        result
-    }
-    
-    find(body: T => Bool): Option[T] {
-        mutable result = None
-        self.eachWhile {x =>
-            if(body(x)) {
-                result = Some(x)
-                False
-            } else {
-                True
-            }
-        }
-        result
-    }
-
-    filter(body: T => Bool): List[T] {
-        let result = Array.new()
-        self.each {x =>
-            if(body(x)) {
-                result.push(x)
-            }
-        }
-        result.drain()
-    }
-    
-    partition(body: T => Bool): Pair[List[T], List[T]] {
-        Pair(self.filter(body), self.filter {!body(_)})
-    }
-
-    map[S](body: T => S): List[S]
-        target js sync """
-            return self_.map(body_)
-        """
-        target js async """
-            let result = [];
-            for(let i = 0; i < self_.length; i++) {
-                result.push(await body_(self_[i], $task));
-            }
-            return result;
-        """
-        
-    flatMap[S](body: T => List[S]): List[S] {
-        let results = Array.new()
-        self.each {x =>
-            results.pushList(body(x))
-        }
-        results.drain()
-    }
-    
-    collect[R](body: T => Option[R]): List[R] {
-        mutable result = Array.new()
-        self.each {x =>
-            body(x).each {result.push(_)}
-        }
-        result.drain()
-    }
-
-    collectFirst[R](body: T => Option[R]): Option[R] {
-        mutable result = None
-        self.eachWhile {x =>
-            body(x).{
-                | None =>
-                    True
-                | o =>
-                    result = o
-                    False
-            }
-        }
-        result
-    }
-
-    sortBy[S: Order](body: T => S): List[T] {
-        self.sortWith {Ordering.compare(body(_), body(_))}
-    }
-
-    sortWith(ordering: (T, T) => Ordering): List[T] {
-        let array = self.toArray()
-        array.sortWith(ordering)
-        array.drain()
-    }
-    
-    reverse(): List[T] {
-        1.to(self.size()).map {i =>
-            self.grab(self.size() - i)
-        }
-    }
-    
-    separate(separator: List[T]): List[T] {
-        let array = Array.new()
-        self.pairs().each {| Pair(i, x) =>
-            if(i != 0) {
-                array.pushList(separator)
-            }
-            array.push(x)
-        }
-        array.drain()
-    }
-
-}
-
-extend self[T: Order]: List[T] {
-
-    sort(): List[T] {
-        self.sortWith(Ordering.compare)
-    }
-
-    toSet(): Set[T] {
-        self.foldLeft(Set.new()) {_.add(_)}
-    }
-    
-    distinct(): List[T] {
-        mutable seen = [].toSet()
-        self.filter {
-            | item {!seen.contains(item)} =>
-                seen = seen.add(item)
-                True
-            | _ =>
-                False
-        }
-    }
-
-}
-
-extend self[T]: List[List[T]] {
-
-    flatten(): List[T] {
-        let result = Array.new()
-        self.each {xs =>
-            result.pushList(xs)
-        }
-        result.drain()
-    }
-
-}
-
-extend self[K: Order, V]: List[Pair[K, V]] {
-    
-    toMap(): Map[K, V] {
-        self.foldLeft(Map.new()) {| map, Pair(key, value) => map.add(key, value)}
-    }
-    
-    group(): Map[K, List[V]] {
-        mutable map = Map.new[K, Array[V]]()
-        self.each {| Pair(k, v) => map = map.push(k, v)}
-        map.mapValues {_, v => v.drain()}
-    }
-    
-}
-
-extend self[K, V]: List[Pair[K, V]] {
-
-    unzip(): Pair[List[K], List[V]] {
-        let first = Array.new()
-        let second = Array.new()
-        self.each {| Pair(x, y) =>
-            first.push(x)
-            second.push(y)
-        }
-        Pair(first.drain(), second.drain())
-    }
-
-}
-
-extend self: List[String] {
-
-    join(separator: String = ""): String
-        target js sync "return self_.join(separator_)"
-
-}
-
-instance List[T: Show]: Show {
-    show(value: List[T]): String {
-        let array = Array.new()
-        array.push("[")
-        value.each {x =>
-            if(array.size() > 1) {array.push(", ")}
-            array.push(Show.show(x))
-        }
-        array.push("]")
-        array.join()
-    }
-}
-
-instance List[T: Equal]: Equal {
-    equals(x: List[T], y: List[T]): Bool {
-        if(internalSame(x, y)) {True} else:
-        if(x.size() != y.size()) {False} else:
-        mutable i = -1
-        x.all {l =>
-            i += 1
-            l == y.grab(i)
-        }
-    }
-}
-
-instance List[T: Order]: Order {
-    compare(x: List[T], y: List[T]): Ordering {
-        if(internalSame(x, y)) {OrderingSame} else:
-        let size = x.size().min(y.size())
-        mutable i = 0
-        mutable ordering = OrderingSame
-        while {ordering == OrderingSame && i < size} {
-            ordering = Ordering.compare(x.grab(i), y.grab(i))
-            i += 1
-        }
-        if(ordering != OrderingSame) {ordering} else:
-        Ordering.compare(x.size(), y.size())
-    }
-}
-
-internalSame[T](left: List[T], right: List[T]): Bool
-    target js sync "return left_ === right_"
-
-internalGrab[T](self: List[T], index: Int): T
-    target js sync """
-        return index_ < 0 || index_ >= self_.length ? ff_core_Try.internalThrowGrabException_() : self_[index_];
-    """
+data List[T] {}
+
+new[T](): List[T]
+    target js sync """
+        return [];
+    """
+
+fill[T](size: Int, value: T): List[T]
+    target js sync """
+        return new Array(size_).fill(value_);
+    """
+
+fillBy[T](size: Int, body: Int => T): List[T]
+    target js sync """
+        return Array.from({length: size_}, (_, i) => body_(i));
+    """
+    target js async """
+        const array = new Array(size_);
+        for(let i = 0; i < size_; i++) {
+            array[i] = await(body_(_i));
+        }
+        return array;
+    """
+
+range(size: Int): List[Int]
+    target js sync """
+        return Array.from({length: size_}, (_, i) => i);
+    """
+
+extend self[T]: List[T] {
+
+    addAll(that: List[T]): List[T]
+        target js sync "return self_.concat(that_)"
+
+    isEmpty(): Bool
+        target js sync "return self_.length === 0"
+
+    size(): Int
+        target js sync "return self_.length"
+
+    get(index: Int): Option[T]
+        target js sync """
+            return index_ >= 0 && index_ < self_.length
+                ? ff_core_Option.Some(self_[index_])
+                : ff_core_Option.None()
+        """
+
+    grab(index: Int): T
+        target js sync """
+            return self_[index_] ?? internalGrab_(self_, index_);
+        """
+
+    first(): Option[T] {self.get(0)}
+
+    last(): Option[T] {self.get(self.size() - 1)}
+
+    grabFirst(): T {self.grab(0)}
+
+    grabLast(): T {self.grab(self.size() - 1)}
+
+    takeFirst(count: Int = 1): List[T]
+        target js sync "return self_.slice(0, count_)"
+
+    takeLast(count: Int = 1): List[T]
+        target js sync "return self_.slice(-count_)"
+
+    dropFirst(count: Int = 1): List[T]
+        target js sync "return self_.slice(count_)"
+
+    dropLast(count: Int = 1): List[T]
+        target js sync "return self_.slice(0, self_.length - count_)"
+        
+    count(body: T => Bool): Int {
+        mutable result = 0
+        mutable i = 0
+        while {i < self.size()} {
+            if(body(self.grab(i))) {result += 1}
+            i += 1
+        }
+        result
+    }
+
+    countWhile(body: T => Bool): Int {
+        mutable i = 0
+        while {i < self.size() && body(self.grab(i))} {
+            i += 1
+        }
+        i
+    }
+
+    takeWhile(body: T => Bool): List[T] {
+        let result = Array.new()
+        mutable i = 0
+        while {i < self.size() && body(self.grab(i))} {
+            result.push(self.grab(i))
+            i += 1
+        }
+        result.drain()
+    }
+
+    dropWhile(body: T => Bool): List[T] {
+        let result = Array.new()
+        mutable i = 0
+        while {i < self.size() && body(self.grab(i))} {
+            i += 1
+        }
+        while {i < self.size()} {
+            result.push(self.grab(i))
+            i += 1
+        }
+        result.drain()
+    }
+    
+    partitionWhile(body: T => Bool): Pair[List[T], List[T]] {
+        let first = Array.new()
+        let second = Array.new()
+        mutable i = 0
+        while {i < self.size() && body(self.grab(i))} {
+            first.push(self.grab(i))
+            i += 1
+        }
+        while {i < self.size()} {
+            second.push(self.grab(i))
+            i += 1
+        }
+        Pair(first.drain(), second.drain())
+    }
+    
+    pairs(): List[Pair[Int, T]] {
+        mutable i = 0
+        self.map {x =>
+            let r = Pair(i, x)
+            i += 1
+            r
+        }
+    }
+    
+    slice(from: Int, until: Int): List[T] {
+        self.dropFirst(from).takeFirst(until - from)
+    }
+    
+    foldLeft[R](initial: R, body: (R, T) => R): R {
+        mutable result = initial
+        self.each {x =>
+            result = body(result, x)
+        }
+        result
+    }    
+
+    update(index: Int, value: T): List[T] {
+        self.modify(index) {_ => value}
+    }
+    
+    modify(index: Int, body: T => T): List[T]
+        target js sync """
+            if(index_ < 0 || index_ >= self_.length) {
+                ff_core_Try.internalThrowGrabException_()
+            }
+            let result = self_.slice();
+            result[index_] = body_(result[index_]);
+            return result;
+        """
+        target js async """
+            if(index_ < 0 || index_ >= self_.length) {
+                ff_core_Try.internalThrowGrabException_()
+            }
+            let result = self_.slice();
+            result[index_] = await body_(result[index_], $task);
+            return result;
+        """
+        
+    zip[S](that: List[S]): List[Pair[T, S]] {
+        if(self.size() <= that.size()) {
+            mutable i = -1
+            self.map {x => 
+                i += 1
+                Pair(x, that.grab(i))
+            }
+        } else {
+            mutable i = -1
+            that.map {y => 
+                i += 1
+                Pair(self.grab(i), y)
+            }
+        }
+    }
+
+    chunk(chunkSize: Int): List[List[T]] {
+        let results = Array.new()
+        let result = Array.new()
+        mutable added = 0
+        self.each {item =>
+            if(added < chunkSize) {
+                added += 1
+            } else {
+                results.push(result.drain())
+                added = 1
+            }
+            result.push(item)
+        }
+        if(added != 0) {
+            results.push(result.drain())
+        }
+        results.drain()
+    }
+
+    toStream(cycle: Bool = False): Stream[T] {
+        mutable index = 0
+        Stream.new {
+            if(index < self.size()) {
+                let result = self.grab(index)
+                index += 1
+                result
+            } elseIf {cycle && index != 0} {
+                let result = self.grab(0)
+                index = 1
+                result
+            }
+        }
+    }
+
+    toArray(): Array[T]
+        target js sync "return {array: self_.slice()}"
+
+    each(body: T => Unit): Unit
+        target js sync """
+            return self_.forEach(body_);
+        """
+        target js async """
+            for(let i = 0; i < self_.length; i++) {
+                await body_(self_[i], $task)
+            }
+        """
+
+    eachWhile(body: T => Bool): Unit
+        target js sync "for(const value of self_) if(!body_(value)) break"
+        target js async "for(const value of self_) if(!await body_(value, $task)) break"
+
+    all(body: T => Bool): Bool {
+        mutable result = True
+        self.eachWhile {x =>
+            result = result && body(x)
+            result
+        }
+        result
+    }
+
+    any(body: T => Bool): Bool {
+        mutable result = False
+        self.eachWhile {x =>
+            result = result || body(x)
+            (!result)
+        }
+        result
+    }
+
+    indexWhere(body: T => Bool): Option[Int] {
+        mutable result = None
+        mutable i = 0
+        self.eachWhile {x =>
+            if(body(x)) {
+                result = Some(i)
+                False
+            } else {
+                i += 1
+                True
+            }
+        }
+        result
+    }
+    
+    find(body: T => Bool): Option[T] {
+        mutable result = None
+        self.eachWhile {x =>
+            if(body(x)) {
+                result = Some(x)
+                False
+            } else {
+                True
+            }
+        }
+        result
+    }
+
+    filter(body: T => Bool): List[T] {
+        let result = Array.new()
+        self.each {x =>
+            if(body(x)) {
+                result.push(x)
+            }
+        }
+        result.drain()
+    }
+    
+    partition(body: T => Bool): Pair[List[T], List[T]] {
+        Pair(self.filter(body), self.filter {!body(_)})
+    }
+
+    map[S](body: T => S): List[S]
+        target js sync """
+            return self_.map(body_)
+        """
+        target js async """
+            let result = [];
+            for(let i = 0; i < self_.length; i++) {
+                result.push(await body_(self_[i], $task));
+            }
+            return result;
+        """
+        
+    flatMap[S](body: T => List[S]): List[S] {
+        let results = Array.new()
+        self.each {x =>
+            results.pushList(body(x))
+        }
+        results.drain()
+    }
+    
+    collect[R](body: T => Option[R]): List[R] {
+        mutable result = Array.new()
+        self.each {x =>
+            body(x).each {result.push(_)}
+        }
+        result.drain()
+    }
+
+    collectFirst[R](body: T => Option[R]): Option[R] {
+        mutable result = None
+        self.eachWhile {x =>
+            body(x).{
+                | None =>
+                    True
+                | o =>
+                    result = o
+                    False
+            }
+        }
+        result
+    }
+
+    sortBy[S: Order](body: T => S): List[T] {
+        self.sortWith {Ordering.compare(body(_), body(_))}
+    }
+
+    sortWith(ordering: (T, T) => Ordering): List[T] {
+        let array = self.toArray()
+        array.sortWith(ordering)
+        array.drain()
+    }
+    
+    reverse(): List[T] {
+        1.to(self.size()).map {i =>
+            self.grab(self.size() - i)
+        }
+    }
+    
+    separate(separator: List[T]): List[T] {
+        let array = Array.new()
+        self.pairs().each {| Pair(i, x) =>
+            if(i != 0) {
+                array.pushList(separator)
+            }
+            array.push(x)
+        }
+        array.drain()
+    }
+
+}
+
+extend self[T: Order]: List[T] {
+
+    sort(): List[T] {
+        self.sortWith(Ordering.compare)
+    }
+
+    toSet(): Set[T] {
+        self.foldLeft(Set.new()) {_.add(_)}
+    }
+    
+    distinct(): List[T] {
+        mutable seen = [].toSet()
+        self.filter {
+            | item {!seen.contains(item)} =>
+                seen = seen.add(item)
+                True
+            | _ =>
+                False
+        }
+    }
+
+}
+
+extend self[T]: List[List[T]] {
+
+    flatten(): List[T] {
+        let result = Array.new()
+        self.each {xs =>
+            result.pushList(xs)
+        }
+        result.drain()
+    }
+
+}
+
+extend self[K: Order, V]: List[Pair[K, V]] {
+    
+    toMap(): Map[K, V] {
+        self.foldLeft(Map.new()) {| map, Pair(key, value) => map.add(key, value)}
+    }
+    
+    group(): Map[K, List[V]] {
+        mutable map = Map.new[K, Array[V]]()
+        self.each {| Pair(k, v) => map = map.push(k, v)}
+        map.mapValues {_, v => v.drain()}
+    }
+    
+}
+
+extend self[K, V]: List[Pair[K, V]] {
+
+    unzip(): Pair[List[K], List[V]] {
+        let first = Array.new()
+        let second = Array.new()
+        self.each {| Pair(x, y) =>
+            first.push(x)
+            second.push(y)
+        }
+        Pair(first.drain(), second.drain())
+    }
+
+}
+
+extend self: List[String] {
+
+    join(separator: String = ""): String
+        target js sync "return self_.join(separator_)"
+
+}
+
+instance List[T: Show]: Show {
+    show(value: List[T]): String {
+        let array = Array.new()
+        array.push("[")
+        value.each {x =>
+            if(array.size() > 1) {array.push(", ")}
+            array.push(Show.show(x))
+        }
+        array.push("]")
+        array.join()
+    }
+}
+
+instance List[T: Equal]: Equal {
+    equals(x: List[T], y: List[T]): Bool {
+        if(internalSame(x, y)) {True} else:
+        if(x.size() != y.size()) {False} else:
+        mutable i = -1
+        x.all {l =>
+            i += 1
+            l == y.grab(i)
+        }
+    }
+}
+
+instance List[T: Order]: Order {
+    compare(x: List[T], y: List[T]): Ordering {
+        if(internalSame(x, y)) {OrderingSame} else:
+        let size = x.size().min(y.size())
+        mutable i = 0
+        mutable ordering = OrderingSame
+        while {ordering == OrderingSame && i < size} {
+            ordering = Ordering.compare(x.grab(i), y.grab(i))
+            i += 1
+        }
+        if(ordering != OrderingSame) {ordering} else:
+        Ordering.compare(x.size(), y.size())
+    }
+}
+
+internalSame[T](left: List[T], right: List[T]): Bool
+    target js sync "return left_ === right_"
+
+internalGrab[T](self: List[T], index: Int): T
+    target js sync """
+        return index_ < 0 || index_ >= self_.length ? ff_core_Try.internalThrowGrabException_() : self_[index_];
+    """