firefly-compiler 0.5.39 → 0.5.40

package/core/Array.ff

@@ -1,298 +1,298 @@
-class Array[T] {}
-
-new[T](): Array[T] {
-    Js->(array = [])?
-}
- 
-fill[T](size: Int, value: T): List[T] {
-    Js->(array = List.fill(size, value)!)?
-}
-
-fillBy[T](size: Int, body: Int => T): List[T] {
-    Js->(array = List.fillBy(size, body)!)?
-}
-
-range(size: Int): List[Int] {
-    Js->(array = List.range(size)!)?
-}
-
-extend self[T]: Array[T] {
-
-    isEmpty(): Bool {
-        self.size() == 0
-    }
-
-    size(): Int {
-        self!->array->length?
-    }
-
-    get(index: Int): Option[T] {
-        if(index >= 0 && index < self.size()) {
-            Some(self!->array.get(index)?)
-        } else {
-            None
-        }
-    }
-
-    grab(index: Int): T {
-        if(index < 0 || index >= self.size()) {
-            throw(GrabException())
-        }
-        self!->array.get(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)}
-
-    push(value: T): Unit {
-        self!->array->push(value!)?
-    }
-
-    pushArray(value: Array[T]): Unit {
-        self.pushList(value!->array?)
-    }
-
-    pushList(list: List[T]): Unit {
-        let originalLength = self.size()
-        self!->array->length += list.size()
-        0.until(list.size()).each {i =>
-            self!->array.set(originalLength + i, list!.get(i))
-        }
-    }        
-
-    pop(): Option[T] {
-        if(self.size() > 0) {
-            self!->array->pop()?
-        }
-    }
-
-    set(index: Int, value: T): Unit {
-        if(index < 0 || index >= self.size()) {
-            throw(GrabException())
-        }
-        self!->array.set(index, value!)
-    }
-
-    modify(index: Int, body: T => T): Unit {
-        if(index < 0 || index >= self.size()) {
-            throw(GrabException())
-        }
-        self!->array.set(index, body(self!->array.get(index)?)!)
-    }
-
-    fill(value: T, start: Int = 0, end: Int = 9007199254740991): Unit {
-        self!->array->fill(value!, start, end)
-    }
-
-    copy(target: Int, start: Int, end: Int): Unit {
-        self!->array->copyWithin(target, start, end)
-    }
-
-    delete(start: Int, deleteCount: Int): Unit {
-        self!->array->splice(start, deleteCount)
-    }
-
-    insert(start: Int, value: T, deleteCount: Int = 0): Unit {
-        self!->array->splice(start, deleteCount, value!)
-    }
-
-    insertArray(start: Int, array: Array[T], deleteCount: Int = 0): Unit {
-        self.insertList(start, array!->array?, deleteCount)
-    }
-
-    insertList(start: Int, list: List[T], deleteCount: Int = 0): Unit {
-        if(start < 0 || start > self.size()) {
-            throw(GrabException())
-        }
-
-        let deleteEnd = start + deleteCount
-
-        if(deleteEnd < 0 || deleteEnd > self.size()) {
-            throw(GrabException())
-        }
-
-        let insertCount = list.size()
-        let delta = insertCount - deleteCount
-        
-        if(delta > 0) {
-            self!->array->length += delta
-            self!->array->copyWithin(start + insertCount, deleteEnd)
-        } elseIf {delta < 0} {
-            self!->array->copyWithin(start + insertCount, deleteEnd)
-            self!->array->length += delta
-        }
-
-        0.until(insertCount).each {i => 
-            self!->array.set(start + i, list!.get(i))
-        }        
-    }
-
-    mapInPlace[S](body: T => S): Unit {
-        mutable i = 0
-        while {i < self.size()} {
-            self!->array.set(i, body(self!->array.get(i)?)!)
-            i += 1
-        }
-    }
-    
-    each(body: T => Unit): Unit {
-        mutable i = 0
-        while {i < self.size()} {
-            body(self!->array.get(i)?)
-            i += 1
-        }
-    }
-    
-    eachWithIndex(body: (Int, T) => Unit): Unit {
-        mutable i = 0
-        while {i < self.size()} {
-            body(i, self!->array.get(i)?)
-            i += 1
-        }
-    }
-
-    eachWhile(body: T => Bool): Unit {
-        mutable i = 0
-        while {i < self.size()} {
-            if(body(self!->array.get(i)?)) {
-                i += 1
-            } else {
-                i = self.size()
-            }
-        }
-    }
-
-    all(body: T => Bool): Bool {
-        mutable result = True
-        self.eachWhile {x =>
-            result = body(x)
-            result
-        }
-        result
-    }
-
-    any(body: T => Bool): Bool {
-        mutable result = False
-        self.eachWhile {x =>
-            result = body(x)
-            (!result)
-        }
-        result
-    }
-    
-    find(body: T => Bool): Option[T] {
-        mutable result = None
-        self.eachWhile {x =>
-            if(body(x)) {
-                result = Some(x)
-                False
-            } else {
-                True
-            }
-        }
-        result
-    }
-
-    indexWhere(body: T => Bool): Option[Int] {
-        mutable i = -1
-        mutable result = False
-        self.eachWhile {x =>
-            i += 1
-            result = body(x)
-            (!result)
-        }
-        if(result) {i}
-    }
-
-    drain(): List[T] {
-        let result = self!->array
-        self!->array = []
-        result?
-    }
-
-    toList(start: Int = 0, end: Int = 9007199254740991): List[T] {
-        self!->array->slice(start, end)?
-    }
-
-    toStream(start: Int = 0, end: Int = 9007199254740991): Stream[T] {
-        self.toList(start, end).toStream()
-    }
-
-    reverse(): Unit {
-        self!->array->reverse()?
-    }
-
-    sortBy[S: Order](body: T => S): Unit {
-        self.sortWith {Ordering.compare(body(_), body(_))}
-    }
-
-    sortWith(ordering: (T, T) => Ordering): Unit {
-        if(Js.inAsync()) {
-            sortRange(self, ordering, 0, self.size())
-        } else {
-            self!->array->sort(Js->{x, y => ordering(x?, y?).toInt()})
-        }
-    }
-
-}
-
-extend self[T: Order]: Array[T] {
-
-    sort(): Unit {
-        self.sortWith(Ordering.compare)
-    }
-
-}
-
-extend self: Array[String] {
-
-    join(separator: String = ""): String {
-        self!->array->join(separator)?
-    }
-
-}
-
-instance Array[T: Show]: Show {
-    show(value: Array[T]): String {
-        let array = Array.new()
-        array.push("[")
-        value.each {x =>
-            if(array.size() > 1) {array.push(", ")}
-            array.push(Show.show(x))
-        }
-        array.push("].toArray()")
-        array.join()
-    }
-}
-
-sortRange[T](array: Array[T], compare: (T, T) => Ordering, start: Int, end: Int): Unit {
-    if(end - start < 2) {} else:
-
-    mutable middle = start + (end - start).div(2)
-    sortRange(array, compare, start, middle)
-    sortRange(array, compare, middle, end)
-
-    mutable i = start
-    mutable j = middle
-    while {i < middle && j < end} {
-        if(compare(array.grab(i), array.grab(j)) != OrderingAfter) {
-            i += 1
-        } else {
-            let value = array.grab(j)
-            mutable k = j
-            while {k > i} {
-                array.set(k, array.grab(k - 1))
-                k -= 1
-            }
-            array.set(i, value)
-            i += 1
-            middle += 1
-            j += 1
-        }
-    }
-}
+class Array[T] {}
+
+new[T](): Array[T] {
+    Js->(array = [])?
+}
+ 
+fill[T](size: Int, value: T): List[T] {
+    Js->(array = List.fill(size, value)!)?
+}
+
+fillBy[T](size: Int, body: Int => T): List[T] {
+    Js->(array = List.fillBy(size, body)!)?
+}
+
+range(size: Int): List[Int] {
+    Js->(array = List.range(size)!)?
+}
+
+extend self[T]: Array[T] {
+
+    isEmpty(): Bool {
+        self.size() == 0
+    }
+
+    size(): Int {
+        self!->array->length?
+    }
+
+    get(index: Int): Option[T] {
+        if(index >= 0 && index < self.size()) {
+            Some(self!->array.get(index)?)
+        } else {
+            None
+        }
+    }
+
+    grab(index: Int): T {
+        if(index < 0 || index >= self.size()) {
+            throw(GrabException())
+        }
+        self!->array.get(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)}
+
+    push(value: T): Unit {
+        self!->array->push(value!)?
+    }
+
+    pushArray(value: Array[T]): Unit {
+        self.pushList(value!->array?)
+    }
+
+    pushList(list: List[T]): Unit {
+        let originalLength = self.size()
+        self!->array->length += list.size()
+        0.until(list.size()).each {i =>
+            self!->array.set(originalLength + i, list!.get(i))
+        }
+    }        
+
+    pop(): Option[T] {
+        if(self.size() > 0) {
+            self!->array->pop()?
+        }
+    }
+
+    set(index: Int, value: T): Unit {
+        if(index < 0 || index >= self.size()) {
+            throw(GrabException())
+        }
+        self!->array.set(index, value!)
+    }
+
+    modify(index: Int, body: T => T): Unit {
+        if(index < 0 || index >= self.size()) {
+            throw(GrabException())
+        }
+        self!->array.set(index, body(self!->array.get(index)?)!)
+    }
+
+    fill(value: T, start: Int = 0, end: Int = 9007199254740991): Unit {
+        self!->array->fill(value!, start, end)
+    }
+
+    copy(target: Int, start: Int, end: Int): Unit {
+        self!->array->copyWithin(target, start, end)
+    }
+
+    delete(start: Int, deleteCount: Int): Unit {
+        self!->array->splice(start, deleteCount)
+    }
+
+    insert(start: Int, value: T, deleteCount: Int = 0): Unit {
+        self!->array->splice(start, deleteCount, value!)
+    }
+
+    insertArray(start: Int, array: Array[T], deleteCount: Int = 0): Unit {
+        self.insertList(start, array!->array?, deleteCount)
+    }
+
+    insertList(start: Int, list: List[T], deleteCount: Int = 0): Unit {
+        if(start < 0 || start > self.size()) {
+            throw(GrabException())
+        }
+
+        let deleteEnd = start + deleteCount
+
+        if(deleteEnd < 0 || deleteEnd > self.size()) {
+            throw(GrabException())
+        }
+
+        let insertCount = list.size()
+        let delta = insertCount - deleteCount
+        
+        if(delta > 0) {
+            self!->array->length += delta
+            self!->array->copyWithin(start + insertCount, deleteEnd)
+        } elseIf {delta < 0} {
+            self!->array->copyWithin(start + insertCount, deleteEnd)
+            self!->array->length += delta
+        }
+
+        0.until(insertCount).each {i => 
+            self!->array.set(start + i, list!.get(i))
+        }        
+    }
+
+    mapInPlace[S](body: T => S): Unit {
+        mutable i = 0
+        while {i < self.size()} {
+            self!->array.set(i, body(self!->array.get(i)?)!)
+            i += 1
+        }
+    }
+    
+    each(body: T => Unit): Unit {
+        mutable i = 0
+        while {i < self.size()} {
+            body(self!->array.get(i)?)
+            i += 1
+        }
+    }
+    
+    eachWithIndex(body: (Int, T) => Unit): Unit {
+        mutable i = 0
+        while {i < self.size()} {
+            body(i, self!->array.get(i)?)
+            i += 1
+        }
+    }
+
+    eachWhile(body: T => Bool): Unit {
+        mutable i = 0
+        while {i < self.size()} {
+            if(body(self!->array.get(i)?)) {
+                i += 1
+            } else {
+                i = self.size()
+            }
+        }
+    }
+
+    all(body: T => Bool): Bool {
+        mutable result = True
+        self.eachWhile {x =>
+            result = body(x)
+            result
+        }
+        result
+    }
+
+    any(body: T => Bool): Bool {
+        mutable result = False
+        self.eachWhile {x =>
+            result = body(x)
+            (!result)
+        }
+        result
+    }
+    
+    find(body: T => Bool): Option[T] {
+        mutable result = None
+        self.eachWhile {x =>
+            if(body(x)) {
+                result = Some(x)
+                False
+            } else {
+                True
+            }
+        }
+        result
+    }
+
+    indexWhere(body: T => Bool): Option[Int] {
+        mutable i = -1
+        mutable result = False
+        self.eachWhile {x =>
+            i += 1
+            result = body(x)
+            (!result)
+        }
+        if(result) {i}
+    }
+
+    drain(): List[T] {
+        let result = self!->array
+        self!->array = []
+        result?
+    }
+
+    toList(start: Int = 0, end: Int = 9007199254740991): List[T] {
+        self!->array->slice(start, end)?
+    }
+
+    toStream(start: Int = 0, end: Int = 9007199254740991): Stream[T] {
+        self.toList(start, end).toStream()
+    }
+
+    reverse(): Unit {
+        self!->array->reverse()?
+    }
+
+    sortBy[S: Order](body: T => S): Unit {
+        self.sortWith {Ordering.compare(body(_), body(_))}
+    }
+
+    sortWith(ordering: (T, T) => Ordering): Unit {
+        if(Js.inAsync()) {
+            sortRange(self, ordering, 0, self.size())
+        } else {
+            self!->array->sort(Js->{x, y => ordering(x?, y?).toInt()})
+        }
+    }
+
+}
+
+extend self[T: Order]: Array[T] {
+
+    sort(): Unit {
+        self.sortWith(Ordering.compare)
+    }
+
+}
+
+extend self: Array[String] {
+
+    join(separator: String = ""): String {
+        self!->array->join(separator)?
+    }
+
+}
+
+instance Array[T: Show]: Show {
+    show(value: Array[T]): String {
+        let array = Array.new()
+        array.push("[")
+        value.each {x =>
+            if(array.size() > 1) {array.push(", ")}
+            array.push(Show.show(x))
+        }
+        array.push("].toArray()")
+        array.join()
+    }
+}
+
+sortRange[T](array: Array[T], compare: (T, T) => Ordering, start: Int, end: Int): Unit {
+    if(end - start < 2) {} else:
+
+    mutable middle = start + (end - start).div(2)
+    sortRange(array, compare, start, middle)
+    sortRange(array, compare, middle, end)
+
+    mutable i = start
+    mutable j = middle
+    while {i < middle && j < end} {
+        if(compare(array.grab(i), array.grab(j)) != OrderingAfter) {
+            i += 1
+        } else {
+            let value = array.grab(j)
+            mutable k = j
+            while {k > i} {
+                array.set(k, array.grab(k - 1))
+                k -= 1
+            }
+            array.set(i, value)
+            i += 1
+            middle += 1
+            j += 1
+        }
+    }
+}