firefly-compiler 0.4.4

package/core/List.ff

@@ -0,0 +1,440 @@
+data List[T] {
+    Empty
+    Link(head: T, tail: List[T])
+}
+
+range(size: Int): List[Int]
+    target js sync """
+        let result = ff_core_List.Empty();
+        for(let i = size_ - 1; i >= 0; i--) {
+            result = ff_core_List.Link(i, result);
+        }
+        return result;
+    """
+
+build[A, B](initial: A, body: A => Option[Pair[A, B]]): List[B] {
+    function go(state: A, result: List[B]): List[B] {
+        body(state).{
+            | None => result.reverse()
+            | Some(Pair(s, x)) => tailcall go(s, [x, ...result])
+        }
+    }
+    go(initial, [])
+}
+
+extend self[T]: List[T] {
+
+    addAll(list: List[T]): List[T] {
+        [self, list].flatten()
+    }
+
+    toStack(): Stack[T]
+        target js sync """
+            let current = self_;
+            let result = [];
+            while(current.Link) {
+                result.push(current.head_);
+                current = current.tail_;
+            }
+            return {array: result};
+        """
+
+    toArray(): Array[T] {
+        self.toStack().drain()
+    }
+
+    grab(index: Int): T {
+        function go(list: List[T], i: Int): T {
+            list.{
+                | [] => Try.internalThrowGrabException()
+                | [head, ...] {i == 0} => head
+                | [_, ...tail] => tailcall go(tail, i - 1)
+            }
+        }
+        go(self, index)
+    }
+
+    first(): Option[T] {
+        self.{
+            | [] => None
+            | [head, ...] => Some(head)
+        }
+    }
+
+    last(): Option[T] {
+        self.{
+            | [] => None
+            | [head] => Some(head)
+            | [_, ...tail] => tailcall tail.last()
+        }
+    }
+
+    grabFirst(): T {
+        self.first().else {Try.internalThrowGrabException()}
+    }
+
+    grabLast(): T {
+        self.last().else {Try.internalThrowGrabException()}
+    }
+
+    dropFirst(count: Int = 1): List[T] {
+        self.{
+            | _ {count <= 0} => self
+            | [] => self
+            | [_, ...tail] => tailcall tail.dropFirst(count - 1)
+        }
+    }
+
+    dropLast(count: Int = 1): List[T] {
+        self.reverse().dropFirst(count).reverse()
+    }
+
+    takeFirst(count: Int = 1): List[T] {
+        function go(list: List[T], count: Int, result: List[T]): List[T] {
+            list.{
+                | _ {count <= 0} => result.reverse()
+                | [] => result.reverse()
+                | [head, ...tail] => tailcall go(tail, count - 1, [head, ...result])
+            }
+        }
+        go(self, count, [])
+    }
+
+    takeLast(count: Int = 1): List[T] {
+        self.reverse().takeFirst(count).reverse()
+    }
+
+    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)
+    }
+
+    isEmpty(): Bool {
+        self.{
+            | [] => True
+            | _ => False
+        }
+    }
+
+    size(): Int {
+        function go(list: List[T], result: Int): Int {
+            list.{
+                | [] => result
+                | [_, ...tail] => tailcall go(tail, result + 1)
+            }
+        }
+        go(self, 0)
+    }
+
+    each(body: T => Unit): Unit {
+        self.{
+            | [] =>
+            | [head, ...tail] =>
+                body(head)
+                tailcall tail.each(body)
+        }
+    }
+
+    all(body: T => Bool): Bool {
+        self.{
+            | [] => True
+            | [head, ...] {!body(head)} => False
+            | [_, ...tail] => tailcall tail.all(body)
+        }
+    }
+
+    any(body: T => Bool): Bool {
+        self.{
+            | [] => False
+            | [head, ...] {body(head)} => True
+            | [_, ...tail] => tailcall tail.any(body)
+        }
+    }
+
+    find(body: T => Bool): Option[T] {
+        self.{
+            | [] => None
+            | [head, ...] {body(head)} => Some(head)
+            | [_, ...tail] => tailcall tail.find(body)
+        }
+    }
+
+    filter(body: T => Bool): List[T] {
+        function go(list: List[T], result: List[T]): List[T] {
+            list.{
+                | [] =>
+                    result.reverse()
+                | [head, ...tail] {body(head)} =>
+                    tailcall go(tail, [head, ...result])
+                | [_, ...tail] =>
+                    tailcall go(tail, result)
+            }
+        }
+        go(self, [])
+    }
+
+    partition(body: T => Bool): Pair[List[T], List[T]] {
+        Pair(self.filter(body), self.filter {!body(_)})
+    }
+
+    map[R](body: T => R): List[R] {
+        function go(list: List[T], result: List[R]): List[R] {
+            list.{
+                | [] =>
+                    result.reverse()
+                | [head, ...tail] =>
+                    tailcall go(tail, [body(head), ...result])
+            }
+        }
+        go(self, [])
+    }
+
+    flatMap[R](body: T => List[R]): List[R] {
+        function go(list: List[T], result: List[List[R]]): List[R] {
+            list.{
+                | [] =>
+                    result.reverse().flatten()
+                | [head, ...tail] =>
+                    tailcall go(tail, [body(head), ...result])
+            }
+        }
+        go(self, [])
+    }
+
+    collect[R](body: T => Option[R]): List[R] {
+        self.toStream().collect(body).toList()
+    }
+
+    collectFirst[R](body: T => Option[R]): Option[R] {
+        self.{
+            | [] =>
+                None
+            | [head, ...tail] =>
+                body(head).{
+                    | None => tailcall tail.collectFirst(body)
+                    | Some(value) => Some(value)
+                }
+        }
+    }
+
+    foldLeft[R](initial: R, body: (R, T) => R): R {
+        function go(state: R, list: List[T]): R {
+            list.{
+                | [] =>
+                    state
+                | [head, ...tail] =>
+                    tailcall go(body(state, head), tail)
+            }
+        }
+        go(initial, self)
+    }
+
+    updated(index: Int, value: T): List[T] {
+        function go(list: List[T], i: Int, result: List[T]): List[T] {
+            list.{
+                | [] =>
+                    result.reverse()
+                | [head, ...tail] {i == 0} =>
+                    tailcall go(tail, i - 1, [value, ...result])
+                | [head, ...tail] =>
+                    tailcall go(tail, i - 1, [head, ...result])
+            }
+        }
+        go(self, index, [])
+    }
+
+    modify(index: Int, body: T => T): List[T] {
+        function go(list: List[T], i: Int, result: List[T]): List[T] {
+            list.{
+                | [] =>
+                    result.reverse()
+                | [head, ...tail] {i == 0} =>
+                    tailcall go(tail, i - 1, [body(head), ...result])
+                | [head, ...tail] =>
+                    tailcall go(tail, i - 1, [head, ...result])
+            }
+        }
+        go(self, index, [])
+    }
+
+    zip[S](that: List[S]): List[Pair[T, S]] {
+        function go(list1: List[T], list2: List[S], result: List[Pair[T, S]]): List[Pair[T, S]] {
+            Pair(list1, list2).{
+                | Pair([x, ...xs], [y, ...ys]) =>
+                    tailcall go(xs, ys, [Pair(x, y), ...result])
+                | _ =>
+                    result.reverse()
+            }
+        }
+        go(self, that, [])
+    }
+
+    sortBy[O: Order](body: T => O): List[T] {
+        if(self.size() <= 1) {self} else:
+        let stack = self.toStack()
+        stack.sortBy(body)
+        stack.toList()
+    }
+
+    sortWith(compare: (T, T) => Ordering): List[T] {
+        if(self.size() <= 1) {self} else:
+        let stack = self.toStack()
+        stack.sortWith(compare)
+        stack.toList()
+    }
+
+    reverse(): List[T] {
+        function go(list: List[T], result: List[T]): List[T] {
+            list.{
+                | [] =>
+                    result
+                | [head, ...tail] =>
+                    tailcall go(tail, [head, ...result])
+            }
+        }
+        go(self, [])
+    }
+
+    chunk(chunkSize: Int): List[List[T]] {
+        mutable results = []
+        mutable result = []
+        mutable added = 0
+        self.each {item =>
+            if(added < chunkSize) {
+                result = [item, ...result]
+                added += 1
+            } else {
+                results = [result.reverse(), ...results]
+                result = [item]
+                added = 1
+            }
+        }
+        if(added != 0) {
+            results = [result.reverse(), ...results]
+        }
+        results.reverse()
+    }
+
+    toStream(cycle: Bool = False): Stream[T] {
+        mutable remaining = self
+        Stream(
+            next = {
+                remaining.{
+                    | [head, ...tail] =>
+                        remaining = tail
+                        Some(head)
+                    | [] {self | [head, ...tail]} {cycle} =>
+                        remaining = tail
+                        Some(head)
+                    | [] =>
+                        None
+                }
+            }
+            close = {
+                remaining = []
+            }
+        )
+    }
+
+    insertBetween(separator: List[T]): List[T] {
+        self.flatMap {e => [...separator, e]}.dropFirst(separator.size())
+    }
+
+}
+
+extend self[T: Order]: List[T] {
+
+    sort(): List[T] {
+        if(self.size() <= 1) {self} else:
+        let stack = self.toStack()
+        stack.sort()
+        stack.toList()
+    }
+    
+    toSet(): Set[T] {
+        self.foldLeft(Set.empty[T]()) {set, value => set.add(value)}
+    }
+
+    distinct(): List[T] {
+        mutable seen = [].toSet()
+        self.filter {
+            | item {!seen.contains(item)} =>
+                seen = seen.add(item)
+                True
+            | _ =>
+                False
+        }
+    }
+
+}
+
+extend self[T: Show]: List[T] {
+
+    show(): String {
+        Show.show(self)
+    }
+
+}
+
+extend self[T]: List[List[T]] {
+
+    flatten(): List[T] {
+        function finish(list: List[T], result: List[T]): List[T] {
+            | as, [] => as
+            | as, [x, ...xs] => tailcall finish([x, ...as], xs)
+        }
+        function go(lists: List[List[T]], result: List[T]): List[T] {
+            lists.{
+                | [] => []
+                | [as] => finish(as, result)
+                | [[], ...aas] => tailcall go(aas, result)
+                | [[a, ...as], ...aas] => tailcall go([as, ...aas], [a, ...result])
+            }
+        }
+        go(self, [])
+    }
+
+}
+
+extend self[K: Order, V]: List[Pair[K, V]] {
+
+    toMap(): Map[K, V] {
+        self.foldLeft(Map.empty[K, V]()) {map, pair => map.add(pair.first, pair.second)}
+    }
+
+    group(): Map[K, List[V]] {
+        let initial: List[Pair[K, List[V]]] = []
+        self.foldLeft(initial.toMap()) {map, pair => map.addToList(pair.first, pair.second)}
+    }
+
+}
+
+extend self[K, V]: List[Pair[K, V]] {
+
+    unzip(): Pair[List[K], List[V]] {
+        function go(pairs: List[Pair[K, V]], ks: List[K], vs: List[V]): Pair[List[K], List[V]] {
+            pairs.{
+                | [] =>
+                    Pair(ks.reverse(), vs.reverse())
+                | [Pair(k, v), ...tail] =>
+                    tailcall go(tail, [k, ...ks], [v, ...vs])
+            }
+        }
+        go(self, [], [])
+    }
+
+}
+
+extend self: List[String] {
+
+    join(separator: String = ""): String {self.toArray().join(separator)}
+
+}

package/core/Lock.ff

@@ -0,0 +1,144 @@
+capability Lock {}
+capability LockCondition {}
+
+extend self: Lock {
+
+    condition(): LockCondition
+        target js async """
+            return {lock: self_, stack: [], queue: []}
+        """
+
+    acquire(): Unit
+        target js async """
+            if(self_.level === 0) {
+                self_.owner = $task
+                self_.level += 1
+            } else {
+                if(self_.owner !== $task) {
+                    try {
+                        await new Promise((resolve, reject) => {
+                            $task.controller.signal.addEventListener('abort', reject)
+                            try {
+                                self_.queue.push({owner: $task, resolve: resolve})
+                            } finally {
+                                $task.controller.signal.removeEventListener('abort', reject)
+                            }
+                        })
+                    } finally {
+                        if($task.controller.signal.aborted) $task.controller = new AbortController()
+                    }
+                } else {
+                    self_.level += 1
+                }
+            }
+        """
+    
+    release(): Unit
+        target js async """
+            if(self_.owner !== $task) {
+                throw new Error("Tried to release a lock without acquiring it first.")
+            } else if(self_.level > 1) {
+                self_.level -= 1
+            } else {
+                self_.owner = null
+                self_.level = 0
+                if(self_.stack.length === 0) {
+                    const empty = self_.stack
+                    self_.stack = self_.queue.reverse()
+                    self_.queue = empty
+                }
+                if(self_.stack.length !== 0) {
+                    const pending = self_.stack.pop()
+                    self_.owner = pending.owner
+                    self_.level = 1
+                    pending.resolve()
+                }
+            }
+        """
+    
+    do[T](body: () => T): T {
+        self.acquire()
+        try {
+            body()
+        } finally {
+            self.release()
+        } grab()
+    }
+
+}
+
+extend self: LockCondition {
+
+    sleep(): Unit
+        target js async """
+            if(self_.lock.owner !== $task) {
+                throw new Error("Tried to sleep on a condition without acquiring it first.")
+            }
+            const level = self_.lock.level
+            self_.lock.level = 1
+            await ff_core.Lock_release$(self_.lock)
+            try {
+                await new Promise((resolve, reject) => {
+                    $task.controller.signal.addEventListener('abort', reject)
+                    try {
+                        self_.queue.push(resolve)
+                    } finally {
+                        $task.controller.signal.removeEventListener('abort', reject)
+                        if($task.controller.signal.aborted) $task.controller = new AbortController()
+                    }
+                })
+            } finally {
+                let exception = null
+                let acquired = false
+                while(!acquired) {
+                    try {
+                        await ff_core.Lock_acquire$(self_.lock)
+                        self_.lock.level = level
+                        acquired = true
+                    } catch(e) {
+                        exception = e
+                    }
+                }
+                if(e !== null) throw e;
+            }
+        """
+
+    sleepUntil[T](body: () => Option[T]): T {
+        body().{
+            | Some(value) =>
+                value
+            | None =>
+                self.sleep()
+                tailcall self.sleepUntil(body)
+        }
+    }
+
+    wakeOne(): Unit
+        target js async """
+            if(self_.stack.length === 0) {
+                const empty = self_.stack
+                self_.stack = self_.queue.reverse()
+                self_.queue = empty
+            }
+            if(self_.stack.length !== 0) {
+                const resolve = self_.stack.pop()
+                resolve()
+            }
+        """
+
+    wakeAll(): Unit
+        target js async """
+            while(self_.stack.length !== 0) {
+                const resolve = self_.stack.pop()
+                resolve()
+            }
+            const empty = self_.stack
+            self_.stack = self_.queue.reverse()
+            self_.queue = empty
+            while(self_.stack.length !== 0) {
+                const resolve = self_.stack.pop()
+                resolve()
+            }
+        """
+
+}

package/core/Log.ff

@@ -0,0 +1,24 @@
+show[T: Show](value: T): Unit {
+    trace(Show.show(value))
+}
+
+debugDynamic[T](value: T): Unit
+    target js sync "console.debug(value_)"
+
+debug(value: String): Unit
+    target js sync "console.debug(value_)"
+
+verbose(value: String): Unit
+    target js sync "console.log(value_)"
+
+info(value: String): Unit
+    target js sync "console.info(value_)"
+
+warn(value: String): Unit
+    target js sync "console.warn(value_)"
+
+error(value: String): Unit
+    target js sync "console.error(value_)"
+
+trace(value: String): Unit
+    target js sync "process.stderr.write(value_ + String.fromCharCode(10))"