firefly-compiler 0.4.4

package/core/Map.ff

@@ -0,0 +1,126 @@
+import RbMap
+
+newtype Map[K, V](redBlack: RB[K, V])
+
+empty[K, V](): Map[K, V] {Map(E)}
+
+extend self[K: Order, V]: Map[K, V] {
+
+    add(key: K, value: V): Map[K, V] {
+        Map(RbMap.insert(key, value, self.redBlack))
+    }
+
+    addAll(that: Map[K, V]): Map[K, V] {
+        mutable result = self.redBlack
+        that.redBlack.each {k, v =>
+            result = RbMap.insert(k, v, result)
+        }
+        Map(result)
+    }
+
+    get(key: K): Option[V] {
+        self.redBlack.get(key)
+    }
+
+    remove(key: K): Map[K, V] {
+        Map(RbMap.delete(key, self.redBlack))
+    }
+
+    removeAll(that: Map[K, V]): Map[K, V] {
+        mutable result = self.redBlack
+        that.redBlack.each {| k, _ =>
+            result = RbMap.delete(k, result)
+        }
+        Map(result)
+    }
+
+    pairs(): List[Pair[K, V]] { // TODO: Remove this method (use toList)
+        self.toList()
+    }
+
+    toList(): List[Pair[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)
+    }
+
+    keys(): Set[K] {
+        self.pairs().map {_.first}.toSet()
+    }
+
+    values(): List[V] {
+        self.pairs().map {_.second}
+    }
+
+    size(): Int {
+        self.redBlack.size()
+    }
+
+    map[K1: Order, V1](body: (K, V) => Pair[K1, V1]): Map[K1, V1] {
+        Map(self.redBlack.map(body))
+    }
+
+    mapValues[V1](body: (K, V) => V1): Map[K, V1] {
+        Map(self.redBlack.mapValues(body))
+    }
+
+    contains(key: K): Bool {
+        !self.get(key).isEmpty()
+    }
+
+    grab(key: K): V {
+        self.get(key).grab()
+    }
+
+    updateOrInsert(key: K, update: V => V, default: () => V): Map[K, V] {
+        self.get(key).{
+            | None => self.add(key, default())
+            | Some(v) => self.add(key, update(v))
+        }
+    }
+
+    each(body: (K, V) => Unit): Unit {
+        self.redBlack.each(body)
+    }
+
+    eachWhile(body: (K, V) => Bool): Bool {
+        self.redBlack.eachWhile(body)
+    }
+
+    find(body: (K, V) => Bool): Option[Pair[K, V]] {
+        self.redBlack.find(body)
+    }
+
+}
+
+extend self[K: Order, V]: Map[K, List[V]] {
+
+    addToList(key: K, value: V): Map[K, List[V]] {
+        self.updateOrInsert(key, {[value, ..._]}, {[value]})
+    }
+
+}
+
+instance Map[K: Equal: Order, V: Equal]: Equal {
+    equals(x: Map[K, V], y: Map[K, V]): Bool {
+        Equal.equals(x.pairs(), y.pairs())
+    }
+}
+
+instance Map[K: Order, V: Order]: Order {
+    compare(x: Map[K, V], y: Map[K, V]): Ordering {
+        Ordering.compare(x.pairs(), y.pairs())
+    }
+}
+
+instance Map[K: Show: Order, V: Show]: Show {
+    show(value: Map[K, V]): String {
+        Show.show(value.pairs()) + ".toMap()"
+    }
+}

package/core/NodeSystem.ff

@@ -0,0 +1,88 @@
+capability NodeSystem {}
+
+extend self: NodeSystem {
+
+    arguments(): Array[String]
+        target node async "return self_.array_"
+
+    assets(): AssetSystem {
+        let assetPkgSnapshotPath = self.path("/snapshot/output/assets")
+        if(assetPkgSnapshotPath.isDirectory()) {
+            function streams(path: Path): Stream[Pair[String, () => Stream[Buffer]]] {
+                path.entries().flatMap {file =>
+                    if(file.isDirectory()) {
+                        streams(file.path())
+                    } else {
+                        [Pair(file.path().relativeTo(assetPkgSnapshotPath), {file.path().readStream()})].toStream()
+                    }
+                }
+            }
+            AssetSystem(streams(assetPkgSnapshotPath).toMap())
+        } else {
+            internalAssets(self)
+        }
+    }
+
+    path(relativePath: String): Path
+        target node async """
+            import * as path from 'path'
+            return path.resolve(relativePath_)
+        """
+
+    pathFromUrl(url: String): Path
+        target node async """
+            import * as url from 'url';
+            return url.fileURLToPath(new URL(url_));
+        """
+
+    httpClient(): HttpClient
+        target js async "return null"
+
+    mainTask(): Task
+        target js async "return self_.task_"
+
+    js(): JsSystem
+        target js async "return typeof globalThis !== 'undefined' ? globalThis : window"
+
+    exit[T](exitCode: Int = 0): T
+        target js async "process.exit(exitCode_)"
+
+    readStream(): Stream[Buffer]
+        target js async """
+            return ff_core_Path.internalReadStream_$(() => process.stdin)
+        """
+
+    writeBuffer(buffer: Buffer): Unit
+        target js async "process.stdout.write(new Uint8Array(buffer_.buffer, buffer_.byteOffset, buffer_.byteLength))"
+
+    writeStream(stream: Stream[Buffer]): Unit {
+        stream.each {self.writeBuffer(_)}
+    }
+
+    writeText(text: String): Unit {
+        self.writeBuffer(text.toBuffer())
+    }
+
+    writeLine(text: String): Unit {
+        self.writeText(text + "\n")
+    }
+
+    writeErrorBuffer(buffer: Buffer): Unit
+        target js async "process.stderr.write(new Uint8Array(buffer_.buffer, buffer_.byteOffset, buffer_.byteLength))"
+
+    writeErrorStream(stream: Stream[Buffer]): Unit {
+        stream.each {self.writeErrorBuffer(_)}
+    }
+
+    writeErrorText(text: String): Unit {
+        self.writeErrorBuffer(text.toBuffer())
+    }
+
+    writeErrorLine(text: String): Unit {
+        self.writeErrorText(text + "\n")
+    }
+
+}
+
+internalAssets(system: NodeSystem): AssetSystem
+    target node async "return system_.assets_"

package/core/Nothing.ff

@@ -0,0 +1 @@
+data Nothing {}

package/core/Option.ff

@@ -0,0 +1,133 @@
+data Option[T] {
+    None
+    Some(value: T)
+}
+
+extend self[T]: Option[T] {
+
+    else(body: () => T): T {
+        self.{
+            | None => body()
+            | Some(value) => value
+        }
+    }
+
+    elseIf(condition: () => Bool, body: () => T): Option[T] {
+        self.{
+            | None =>
+                condition().{
+                    | True => Some(body())
+                    | False => None
+                }
+            | Some(_) => self
+        }
+    }
+
+    orElse(body: () => Option[T]): Option[T] {
+        self.{
+            | None => body()
+            | Some(_) => self
+        }
+    }
+
+    isEmpty(): Bool {
+        self.{
+            | None => True
+            | Some(_) => False
+        }
+    }
+
+    toList(): List[T] {
+        self.{
+            | None => []
+            | Some(v) => [v]
+        }
+    }
+
+    toStack(): Stack[T] {
+        self.toList().toStack()
+    }
+
+    toArray(): Array[T] {
+        self.toList().toArray()
+    }
+
+    toStream(cycle: Bool = False): Stream[T] {
+        mutable next = self
+        Stream.make {
+            let result = next
+            if(!cycle) {next = None}
+            result
+        }
+    }
+
+    filter(body: T => Bool): Option[T] {
+        self.{
+            | Some(v) {body(v)} => Some(v)
+            | _ => None
+        }
+    }
+
+    map[R](body: T => R): Option[R] {
+        self.{
+            | None => None
+            | Some(v) => Some(body(v))
+        }
+    }
+
+    flatMap[R](body: T => Option[R]): Option[R] {
+        self.{
+            | None => None
+            | Some(v) => body(v)
+        }
+    }
+
+    each(body: T => Unit): Unit {
+        self.{
+            | None =>
+            | Some(v) => body(v)
+        }
+    }
+
+    all(body: T => Bool): Bool {
+        self.{
+            | None => True
+            | Some(v) => body(v)
+        }
+    }
+
+    any(body: T => Bool): Bool {
+        self.{
+            | None => False
+            | Some(v) => body(v)
+        }
+    }
+
+    grab(): T {
+        self.{
+            | None => Try.internalThrowGrabException()
+            | Some(v) => v
+        }
+    }
+
+}
+
+extend self[T: Equal]: Option[T] {
+    contains(value: T): Bool {
+        self.{
+            | None => False
+            | Some(v) => v == value
+        }
+    }
+}
+
+extend self[T]: Option[Option[T]] {
+
+    flatten(): Option[T] {
+        self.{
+            | None => None
+            | Some(v) => v
+        }
+    }
+
+}

package/core/Ordering.ff

@@ -0,0 +1,157 @@
+trait T: Order {
+    compare(x: T, y: T): Ordering
+}
+
+before[T: Order](x: T, y: T): Bool {
+    compare(x, y) == OrderingBefore
+}
+
+notBefore[T: Order](x: T, y: T): Bool {
+    compare(x, y) != OrderingBefore
+}
+
+after[T: Order](x: T, y: T): Bool {
+    compare(x, y) == OrderingAfter
+}
+
+notAfter[T: Order](x: T, y: T): Bool {
+    compare(x, y) != OrderingAfter
+}
+
+reverse[T](compare: (T, T) => Ordering): (T, T) => Ordering {
+    {x, y => compare(x, y).{
+        | OrderingBefore => OrderingAfter
+        | OrderingSame => OrderingSame
+        | OrderingAfter => OrderingBefore
+    }}
+}
+
+pair[A, B](
+    compareFirst: (A, A) => Ordering
+    compareSecond: (B, B) => Ordering
+): (Pair[A, B], Pair[A, B]) => Ordering {
+    {x, y => compareFirst(x.first, y.first).{
+        | OrderingSame => compareSecond(x.second, y.second)
+        | ordering => ordering
+    }}
+}
+
+instance Nothing: Order {
+    compare(x: Nothing, y: Nothing): Ordering {OrderingSame}
+}
+
+instance Bool: Order {
+    compare(x: Bool, y: Bool): Ordering {
+        | False, True => OrderingBefore
+        | True, False => OrderingAfter
+        | _, _ => OrderingSame
+    }
+}
+
+instance Char: Order {
+    compare(x: Char, y: Char): Ordering {
+        fromInt(x.codeUnit - y.codeUnit)
+    }
+}
+
+instance Int: Order {
+    compare(x: Int, y: Int): Ordering {fromInt(x - y)}
+}
+
+instance Float: Order {
+    compare(x: Float, y: Float): Ordering {fromFloat(x - y)}
+}
+
+instance String: Order {
+    compare(x: String, y: String): Ordering
+        target js sync """
+            if(x_ < y_) {
+                return ff_core_Ordering.OrderingBefore()
+            } else if(x_ > y_) {
+                return ff_core_Ordering.OrderingAfter()
+            } else {
+                return ff_core_Ordering.OrderingSame()
+            }
+        """
+}
+
+instance Pair[A: Order, B: Order]: Order {
+    compare(x: Pair[A, B], y: Pair[A, B]): Ordering {
+        compare(x.first, y.first).{
+            | OrderingSame => compare(x.second, y.second)
+            | o => o
+        }
+    }
+}
+
+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
+        }
+    }
+}
+
+data Ordering {
+    OrderingBefore
+    OrderingSame
+    OrderingAfter
+}
+
+instance Ordering: Equal {
+    equals(x: Ordering, y: Ordering): Bool {
+        | OrderingBefore, OrderingBefore => True
+        | OrderingSame, OrderingSame => True
+        | OrderingAfter, OrderingAfter => True
+        | _, _ => False
+    }
+}
+
+fromInt(order: Int): Ordering {
+    if(order < 0) {
+        OrderingBefore
+    } elseIf {order == 0} {
+        OrderingSame
+    } else {
+        OrderingAfter
+    }
+}
+
+fromFloat(order: Float): Ordering {
+    if(order < 0.0) {
+        OrderingBefore
+    } elseIf {order == 0.0} {
+        OrderingSame
+    } else {
+        OrderingAfter
+    }
+}
+
+fromLessThan[T](lessThan: (T, T) => Bool): (T, T) => Ordering {
+    {
+        | x, y {lessThan(x, y)} => OrderingBefore
+        | x, y {lessThan(y, x)} => OrderingAfter
+        | _, _ => OrderingSame
+    }
+}
+
+extend self: Ordering {
+    toInt(): Int {
+        self.{
+            | OrderingBefore => -1
+            | OrderingSame => 0
+            | OrderingAfter => 1
+        }
+    }
+    reverse(): Ordering {
+        self.{
+            | OrderingBefore => OrderingAfter
+            | OrderingSame => OrderingSame
+            | OrderingAfter => OrderingBefore
+        }
+    }
+}

package/core/Pair.ff

@@ -0,0 +1,55 @@
+data Pair[A, B](first: A, second: B) {
+    Pair()
+}
+
+extend self[A, B]: Pair[A, B] {
+
+    mapFirst[C](body: A => C): Pair[C, B] {
+        self.Pair(first = body(self.first))
+    }
+
+    mapSecond[C](body: B => C): Pair[A, C] {
+        self.Pair(second = body(self.second))
+    }
+
+    swap(): Pair[B, A] {
+        Pair(self.second, self.first)
+    }
+
+}
+
+extend self[A, A]: Pair[A, A] {
+
+    mapBoth[C](body: A => C): Pair[C, C] {
+        self.Pair(first = body(self.first), second = body(self.second))
+    }
+
+    toList(): List[A] {
+        [self.first, self.second]
+    }
+
+    toArray(): Array[A] {
+        self.toList().toArray()
+    }
+
+    toStack(): Stack[A] {
+        self.toList().toStack()
+    }
+
+}
+
+extend self[A: Order]: Pair[A, A] {
+
+    toSet(): Set[A] {
+        self.toList().toSet()
+    }
+
+}
+
+extend self[A: Order, B]: Pair[A, B] {
+
+    toMap(): Map[A, B] {
+        [self].toMap()
+    }
+
+}