firefly-compiler 0.5.39 → 0.5.40

package/core/Queue.ff

@@ -1,90 +1,90 @@
-class Queue[T](items: IntMap[T], mutable nextKey: Int)
-newtype QueueKey(key: Int)
-
-new[T](): Queue[T] {
-    Queue(IntMap.new(), 0)
-}
-
-extend self[T]: Queue[T] {
-    
-    push(item: T): QueueKey {
-        self.nextKey += 1
-        self.items.set(self.nextKey, item)
-        QueueKey(self.nextKey)
-    }
-    
-    pop(): Option[T] {
-        if(self.items.size() == 0) {None} else:
-        let key = self.items!->keys()->next()->value?
-        let value = self.items.get(key)
-        self.items.remove(key)
-        value
-    }
-    
-    first(): Option[T] {
-        if(self.items.size() == 0) {None} else:
-        let key = self.items!->keys()->next()->value?
-        let value = self.items.get(key)
-        value
-    }
-
-    remove(key: QueueKey): Bool {
-        self.items.remove(key.key)
-    }
-    
-    has(key: QueueKey): Bool {
-        self.items.has(key.key)
-    }
-    
-    clear(): Unit {
-        self.items.clear()
-    }
-
-    size(): Int {
-        self.items.size()
-    }
-    
-    isEmpty(): Bool {
-        self.size() == 0
-    }
-    
-    each(body: (QueueKey, T) => Unit): Unit {
-        self.items.each {k, v => body(QueueKey(k), v)}
-    }
-    
-    eachWhile(body: (QueueKey, T) => Bool): Unit {
-        self.items.eachWhile {k, v => body(QueueKey(k), v)}
-    }
-
-    toArray(): Array[T] {
-        let array = Array.new()
-        self.each {_, v => array.push(v)}
-        array
-    }
-
-    toList(): List[T] {
-        self.toArray().drain()
-    }
-
-    toStream(): Stream[T] {
-        self.toList().toStream()
-    }
-
-    keys(): List[QueueKey] {
-        let array = Array.new()
-        self.items.each {k, _ => array.push(QueueKey(k))}
-        array.drain()
-    }
-
-    values(): List[T] {
-        let array = Array.new()
-        self.items.each {_, v => array.push(v)}
-        array.drain()
-    }
-
-    copy(): Queue[T] {
-        Queue(self.items.copy(), self.nextKey)
-    }
-    
-}
-
+class Queue[T](items: IntMap[T], mutable nextKey: Int)
+newtype QueueKey(key: Int)
+
+new[T](): Queue[T] {
+    Queue(IntMap.new(), 0)
+}
+
+extend self[T]: Queue[T] {
+    
+    push(item: T): QueueKey {
+        self.nextKey += 1
+        self.items.set(self.nextKey, item)
+        QueueKey(self.nextKey)
+    }
+    
+    pop(): Option[T] {
+        if(self.items.size() == 0) {None} else:
+        let key = self.items!->keys()->next()->value?
+        let value = self.items.get(key)
+        self.items.remove(key)
+        value
+    }
+    
+    first(): Option[T] {
+        if(self.items.size() == 0) {None} else:
+        let key = self.items!->keys()->next()->value?
+        let value = self.items.get(key)
+        value
+    }
+
+    remove(key: QueueKey): Bool {
+        self.items.remove(key.key)
+    }
+    
+    has(key: QueueKey): Bool {
+        self.items.has(key.key)
+    }
+    
+    clear(): Unit {
+        self.items.clear()
+    }
+
+    size(): Int {
+        self.items.size()
+    }
+    
+    isEmpty(): Bool {
+        self.size() == 0
+    }
+    
+    each(body: (QueueKey, T) => Unit): Unit {
+        self.items.each {k, v => body(QueueKey(k), v)}
+    }
+    
+    eachWhile(body: (QueueKey, T) => Bool): Unit {
+        self.items.eachWhile {k, v => body(QueueKey(k), v)}
+    }
+
+    toArray(): Array[T] {
+        let array = Array.new()
+        self.each {_, v => array.push(v)}
+        array
+    }
+
+    toList(): List[T] {
+        self.toArray().drain()
+    }
+
+    toStream(): Stream[T] {
+        self.toList().toStream()
+    }
+
+    keys(): List[QueueKey] {
+        let array = Array.new()
+        self.items.each {k, _ => array.push(QueueKey(k))}
+        array.drain()
+    }
+
+    values(): List[T] {
+        let array = Array.new()
+        self.items.each {_, v => array.push(v)}
+        array.drain()
+    }
+
+    copy(): Queue[T] {
+        Queue(self.items.copy(), self.nextKey)
+    }
+    
+}
+

package/core/Random.ff

@@ -1,140 +1,140 @@
-class Random(
-    mutable s0: Float
-    mutable s1: Float
-    mutable s2: Float
-    mutable c: Float
-    mutable spareGauss: Float
-)
-
-// Using Alea PRNG by Johannes Baagøe <baagoe@baagoe.com>, 2010
-// Typical use: Random.seedInstant(system.task().now())
-
-newFromInt(seed: Int): Random {
-    newFromFloat(seed.toFloat())
-}
-
-newFromFloat(seed: Float): Random {
-    let buffer = Buffer.new(8)
-    buffer.setFloat64(0, seed)
-    newFromBuffer(buffer)
-}
-
-newFromInstant(seed: Instant): Random {
-    newFromFloat(seed.since1970.seconds)
-}
-
-newFromBuffer(buffer: Buffer): Random {
-    mutable n: Float = (0xefc8249d).toFloat()
-    function mash(data: Buffer): Float {
-        0.until(data.size()).each {i =>
-            n += data.grabUint8(i).toFloat()
-            mutable h = 0.02519603282416938 * n
-            n = Js.binaryOperator(">>>", h, 0)?
-            h -= n
-            h *= n
-            n = Js.binaryOperator(">>>", h, 0)?
-            h -=n
-            n += h * 0x100000000 // 2^32
-        }
-        Js.binaryOperator(">>>", n, 0)? * 2.3283064365386963e-10
-    }
-    let space: Buffer = Js->DataView->(Js->Uint8Array->([32])->buffer)?
-    let r = Random(
-        s0 = mash(space)
-        s1 = mash(space)
-        s2 = mash(space)
-        c = 1.0
-        spareGauss = Float.nan()
-    )
-    r.s0 -= mash(buffer)
-    if(r.s0 < 0.0) {r.s0 += 1.0}
-    r.s1 -= mash(buffer);
-    if(r.s1 < 0.0) {r.s1 +=1.0}
-    r.s2 -= mash(buffer);
-    if(r.s2 < 0.0) {r.s2 += 1.0}
-    r
-}
-
-extend self: Random {
-    
-    copy(): Random {
-        self.Random()
-    }
-
-    nextInt(from: Int, until: Int): Int {
-        Js.binaryOperator("|", self.nextFloat(from.toFloat(), until.toFloat())!, 0)?
-    }
-
-    nextFloat(from: Float, until: Float): Float {
-        let t = 2091639 * self.s0 + self.c * 2.3283064365386963e-10
-        self.s0 = self.s1;
-        self.s1 = self.s2;
-        self.c = Js.binaryOperator("|", t, 0)?
-        let uniform = t - self.c
-        self.s2 = uniform
-        from + uniform * (until - from)
-    }
-        
-    nextBool(): Bool {
-        self.nextInt(0, 2) == 0
-    }
-
-    nextBytes(buffer: Buffer, start: Int, stop: Int): Unit {
-        start.until(stop).each {i =>
-            buffer.setUint8(i, self.nextInt(0, 256))
-        }
-    }
-
-    nextGauss(mean: Float, standardDeviation: Float): Float {
-        if(!self.spareGauss.isNan()) {
-            let result = self.spareGauss * standardDeviation + mean
-            self.spareGauss = Float.nan()
-            result
-        } else {
-            mutable u = 0.5
-            mutable v = 0.5
-            mutable s = 0.5
-            doWhile {
-                u = self.nextFloat(0.0, 1.0) * 2 - 1
-                v = self.nextFloat(0.0, 1.0) * 2 - 1
-                s = u * u + v * v
-                s >= 1.0 || s == 0.0
-            }
-            s = (-2.0 * s.ln() / s).sqrt()
-            self.spareGauss = v * s
-            mean + standardDeviation * u * s
-        }
-    }
-
-    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)
-        }
-    }
-    
-    shuffleList[T](list: List[T]): List[T] {
-        let array = list.toArray()
-        self.shuffleArray(list.toArray())
-        array.drain()
-    }
-
-    sampleArray[T](count: Int, array: Array[T], body: T => Unit): Unit {
-        self.shuffleList(array.toList()).takeFirst(count).each {body(_)}
-    }
-
-    sampleList[T](count: Int, list: List[T]): List[T] {
-        self.shuffleList(list).takeFirst(count)
-    }
-
-    grabArray[T](array: Array[T]): T {
-        array.grab(self.nextInt(0, array.size()))
-    }
-
-    grabList[T](list: List[T]): T {
-        list.grab(self.nextInt(0, list.size()))
-    }
-    
-}
+class Random(
+    mutable s0: Float
+    mutable s1: Float
+    mutable s2: Float
+    mutable c: Float
+    mutable spareGauss: Float
+)
+
+// Using Alea PRNG by Johannes Baagøe <baagoe@baagoe.com>, 2010
+// Typical use: Random.seedInstant(system.task().now())
+
+newFromInt(seed: Int): Random {
+    newFromFloat(seed.toFloat())
+}
+
+newFromFloat(seed: Float): Random {
+    let buffer = Buffer.new(8)
+    buffer.setFloat64(0, seed)
+    newFromBuffer(buffer)
+}
+
+newFromInstant(seed: Instant): Random {
+    newFromFloat(seed.since1970.seconds)
+}
+
+newFromBuffer(buffer: Buffer): Random {
+    mutable n: Float = (0xefc8249d).toFloat()
+    function mash(data: Buffer): Float {
+        0.until(data.size()).each {i =>
+            n += data.grabUint8(i).toFloat()
+            mutable h = 0.02519603282416938 * n
+            n = Js.binaryOperator(">>>", h, 0)?
+            h -= n
+            h *= n
+            n = Js.binaryOperator(">>>", h, 0)?
+            h -=n
+            n += h * 0x100000000 // 2^32
+        }
+        Js.binaryOperator(">>>", n, 0)? * 2.3283064365386963e-10
+    }
+    let space: Buffer = Js->DataView->(Js->Uint8Array->([32])->buffer)?
+    let r = Random(
+        s0 = mash(space)
+        s1 = mash(space)
+        s2 = mash(space)
+        c = 1.0
+        spareGauss = Float.nan()
+    )
+    r.s0 -= mash(buffer)
+    if(r.s0 < 0.0) {r.s0 += 1.0}
+    r.s1 -= mash(buffer);
+    if(r.s1 < 0.0) {r.s1 +=1.0}
+    r.s2 -= mash(buffer);
+    if(r.s2 < 0.0) {r.s2 += 1.0}
+    r
+}
+
+extend self: Random {
+    
+    copy(): Random {
+        self.Random()
+    }
+
+    nextInt(from: Int, until: Int): Int {
+        Js.binaryOperator("|", self.nextFloat(from.toFloat(), until.toFloat())!, 0)?
+    }
+
+    nextFloat(from: Float, until: Float): Float {
+        let t = 2091639 * self.s0 + self.c * 2.3283064365386963e-10
+        self.s0 = self.s1;
+        self.s1 = self.s2;
+        self.c = Js.binaryOperator("|", t, 0)?
+        let uniform = t - self.c
+        self.s2 = uniform
+        from + uniform * (until - from)
+    }
+        
+    nextBool(): Bool {
+        self.nextInt(0, 2) == 0
+    }
+
+    nextBytes(buffer: Buffer, start: Int, stop: Int): Unit {
+        start.until(stop).each {i =>
+            buffer.setUint8(i, self.nextInt(0, 256))
+        }
+    }
+
+    nextGauss(mean: Float, standardDeviation: Float): Float {
+        if(!self.spareGauss.isNan()) {
+            let result = self.spareGauss * standardDeviation + mean
+            self.spareGauss = Float.nan()
+            result
+        } else {
+            mutable u = 0.5
+            mutable v = 0.5
+            mutable s = 0.5
+            doWhile {
+                u = self.nextFloat(0.0, 1.0) * 2 - 1
+                v = self.nextFloat(0.0, 1.0) * 2 - 1
+                s = u * u + v * v
+                s >= 1.0 || s == 0.0
+            }
+            s = (-2.0 * s.ln() / s).sqrt()
+            self.spareGauss = v * s
+            mean + standardDeviation * u * s
+        }
+    }
+
+    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)
+        }
+    }
+    
+    shuffleList[T](list: List[T]): List[T] {
+        let array = list.toArray()
+        self.shuffleArray(list.toArray())
+        array.drain()
+    }
+
+    sampleArray[T](count: Int, array: Array[T], body: T => Unit): Unit {
+        self.shuffleList(array.toList()).takeFirst(count).each {body(_)}
+    }
+
+    sampleList[T](count: Int, list: List[T]): List[T] {
+        self.shuffleList(list).takeFirst(count)
+    }
+
+    grabArray[T](array: Array[T]): T {
+        array.grab(self.nextInt(0, array.size()))
+    }
+
+    grabList[T](list: List[T]): T {
+        list.grab(self.nextInt(0, list.size()))
+    }
+    
+}