firefly-compiler 0.4.4

package/experimental/random/HashMap.ff

@@ -0,0 +1,72 @@
+data HashMap[K, V] {}
+
+empty() { panic("magic") }
+    target js sync "return new Map()"
+
+extend self: HashMap[K, V] {
+
+    add(key: K, value: V): Unit { panic("magic") }
+        javascript """
+            if(typeof key !== "object") {
+                self_.set(key, value)
+            } else {
+                throw new Error('Key not hashable: ' + key)
+            }
+        """
+
+    get(key: K): Option[V] { panic("magic") }
+        javascript """
+            if(typeof key !== "object") {
+                return self_.has(key) ? ff_core_Option.Some(self_.get(key)) : ff_core_Option.None()
+            } else {
+                throw new Error('Key not hashable: ' + key)
+            }
+        """
+
+    remove(key: K): Bool { panic("magic") }
+        javascript """
+            if(typeof key !== "object") {
+                return self_.delete(key)
+            } else {
+                throw new Error('Key not hashable: ' + key)
+            }
+        """
+
+    contains(key: K): Bool { panic("magic") }
+        javascript """
+            if(typeof key !== "object") {
+                return self_.has(key)
+            } else {
+                throw new Error('Key not hashable: ' + key)
+            }
+        """
+
+    each(body: (K, V) => Unit): Unit { panic("magic") }
+        javascript """
+            self_.forEach(body)
+        """
+
+    pairs(): List[Pair[K, V]] {
+        let list = []
+        self.each { k, v => list = [Pair(k, v), ...list] }
+        list.reverse()
+    }
+
+    keys(): Set[K] {
+        let keys = Set.empty()
+        self.each { k, v => keys = keys.add(k, v) }
+        keys
+    }
+
+    values(): List[K] {
+        let list = []
+        self.each { k, v => list = [v, ...list] }
+        list.reverse()
+    }
+
+    clear(): Unit { panic("magic") }
+        javascript """
+            self_.clear()
+        """
+
+}

package/experimental/random/IfElseUnit.ff

@@ -0,0 +1,9 @@
+nodeMain(fubar: NodeSystem) {
+    if(True) {
+        42
+    } else {
+        "foo"
+    }
+}
+
+// Also elseIf, catch, catchAny

package/experimental/random/InputOutput.ff

@@ -0,0 +1,23 @@
+capability Writer(
+    writeBuffer: Buffer => Unit
+)
+
+extend self: Writer {
+
+    writeStream(stream: Stream[Buffer]): Unit {
+
+    }
+
+    writeText(text: String, encoding: String = "utf8"): Unit {
+
+    }
+
+}
+
+main(system: NodeSystem) {
+    let in: Stream[Buffer] = system.in
+    system.out.writeStream(in)
+    system.err.writeStream(in)
+    system.out.writeText("Hello")
+    system.err.writeText("Hello")
+}

package/experimental/random/ListVsArray.ff

@@ -0,0 +1,45 @@
+main(system: NodeSystem) {
+
+    function logDuration[T](label: String, body: () => T): T {
+        let started = system.time().elapsed()
+        let result = body()
+        Log.debug(label + ": " + Show.show(Duration(system.time().elapsed().seconds - started.seconds)))
+        result
+    }
+
+    function test() {
+        let array = Array.fillBy(1000) {_}
+        let list = array.toList()
+        logDuration("array.map") {
+            mutable i = 0
+            while {i < 1000} {
+                array.map {_ + 1}
+                i += 1
+            }
+        }
+        logDuration("list.map") {
+            mutable i = 0
+            while {i < 1000} {
+                list.map {_ + 1}
+                i += 1
+            }
+        }
+        logDuration("array.sort") {
+            mutable i = 0
+            while {i < 1000} {
+                array.sort()
+                i += 1
+            }
+        }
+        logDuration("list.sort") {
+            mutable i = 0
+            while {i < 1000} {
+                list.sort()
+                i += 1
+            }
+        }
+    }
+
+    test()
+
+}

package/experimental/random/Main.ff

@@ -0,0 +1,44 @@
+data Person(
+    email: String
+    name: String
+    born: Int
+)
+
+main(system: NodeSystem): Unit {
+    Log.show([
+        Pair(4, 2)
+        Pair(3, 4)
+    ].toMap())
+    Log.show([1, 2, 3].flatMap {x => [x, x * 2]})
+    Log.show([6, 4, 36, 8, 9, 5, [4, 2], 12, 2, 34, 4, 5, 65].toSet().toStream().toList())
+    Log.show([6, 4, 36, 8, 9, 5, 4, 2, 12, 2, 34, 4, 5, 65].toSet().toList())
+    let people = [Person("joe@example.com", "Joe", 1970), Person("jane@example.com", "Jane", 1977)].toArray()
+    let sortedPeople = people.sortBy {_.born}
+
+    Log.show(sortedPeople)
+
+    try {
+        throw(people.grabFirst())
+    } catch {| Person p, error =>
+        Log.debug(p.email)
+    } finally {
+        Log.debug("bar")
+    } grab()
+
+    try {
+        Log.debug("foo")
+    } finally {
+        Log.debug("bar")
+    } grab()
+
+}
+
+returnStuff(): Int {
+    try {
+        7
+    } catch {| Person p, error =>
+        p.born
+    } finally {
+        Log.debug("quux")
+    } grab()
+}

package/experimental/random/MapTest.ff

@@ -0,0 +1,67 @@
+main(system: NodeSystem): Unit {
+    testMap(system)
+    testIntMap(system)
+    testStringMap(system)
+    testStack(system)
+    testRawMap()
+}
+
+testStringMap(system: NodeSystem) {
+    let measurement = system.time().measure {
+        let map = StringMap.make()
+        mutable i = 0
+        while {i < 1000000} {
+            map.set("" + i, i)
+            i += 1
+        }
+    }
+    Log.debug("StringMap: " + measurement.second.show())
+}
+
+testIntMap(system: NodeSystem) {
+    let measurement = system.time().measure {
+        let map = IntMap.make()
+        mutable i = 0
+        while {i < 1000000} {
+            map.set(i, i)
+            i += 1
+        }
+    }
+    Log.debug("IntMap: " + measurement.second.show())
+}
+
+testMap(system: NodeSystem) {
+    let measurement = system.time().measure {
+        mutable map = [].toMap()
+        mutable i = 0
+        while {i < 1000000} {
+            map = map.add(i, i)
+            i += 1
+        }
+    }
+    Log.debug("Map: " + measurement.second.show())
+}
+
+testStack(system: NodeSystem) {
+    let measurement = system.time().measure {
+        let map = [].toStack()
+        mutable i = 0
+        while {i < 1000000} {
+            map.set(i, i)
+            i += 1
+        }
+    }
+    Log.debug("Stack: " + measurement.second.show())
+}
+
+testRawMap()
+    target js sync """
+        const start = performance.now();
+        const map = new Map();
+        let i = 0;
+        while(i < 1000000) {
+            map.set(i, i);
+            i += 1
+        }
+        console.log("RawMap: " + (performance.now() - start) + " ms")
+    """

package/experimental/random/OldTaskSystem.ff

@@ -0,0 +1,210 @@
+capability TaskSystem {}
+
+extend self: TaskSystem {
+
+    start[T](task: () => T): () => T { panic("magic") }
+        javascriptasync """
+            const promise = Promise.resolve().then(() => {
+                try {
+                    if(self_.controller.signal.aborted) throw self_.controller.signal.reason
+                    return task_(self_.controller.signal)
+                } catch(e) {
+                    if(self_.error == null) self_.error = e
+                    throw e
+                } finally {
+                    self_.promises.delete(promise)
+                }
+            })
+            self_.promises.add(promise)
+            return async (signal) => {
+                if(signal.aborted) throw signal.reason
+                let abort
+                let cancelPromise = new Promise((_, reject) => abort = () => reject(signal.reason))
+                signal.addEventListener('abort', abort)
+                try {
+                    await Promise.race([
+                        promise,
+                        cancelPromise
+                    ])
+                } finally {
+                    signal.removeEventListener('abort', abort)
+                }
+            }
+        """
+
+    cancel(): Unit { panic("magic") }
+        javascriptasync """
+            self_.controller.abort()
+        """
+
+    scope[T](body: TaskSystem => T): T { panic("magic") }
+        javascriptasync """
+            if(self_.controller.signal.aborted) throw self_.controller.signal.reason
+            let controller = new AbortController()
+            let abort = () => controller.abort(self_.controller.signal.reason)
+            self_.controller.signal.addEventListener('abort', abort)
+            let result = undefined
+            let newTaskSystem = {promises: new Set(), controller: controller, error: null}
+            try {
+                result = await body_(newTaskSystem, newTaskSystem.controller.signal)
+            } finally {
+                self_.controller.signal.removeEventListener('abort', abort)
+                await Promise.allSettled(newTaskSystem.promises)
+            }
+            if(self_.error != null) throw e
+            return result
+        """
+
+    sleep(duration: Duration): Unit { panic("magic") }
+        javascriptasync """
+            if(self_.controller.signal.aborted) throw self_.controller.signal.reason
+            await new Promise((resolve, reject) => {
+                let abort = () => {
+                    self_.controller.signal.removeEventListener('abort', abort)
+                    if(timeoutId != null) clearTimeout(timeoutId)
+                    reject(self_.controller.signal.reason)
+                }
+                self_.controller.signal.addEventListener('abort', abort)
+                let complete = () => {
+                    self_.controller.signal.removeEventListener('abort', abort)
+                    resolve()
+                }
+                let timeoutId = setTimeout(complete, duration_ * 1000);
+            })
+        """
+
+    yield(): Unit { panic("magic") }
+        javascriptasync """
+            if(self_.controller.signal.aborted) throw self_.controller.signal.reason
+            await Promise.resolve().then(() => {})
+        """
+
+    channel[T](buffer: Int = 0): Pair[() => T, T => Unit] { panic("magic") }
+        javascriptasync """
+            let readers = new Set()
+            let writers = new Set()
+            async function read(signal) {
+                if(self_.controller.signal.aborted) throw self_.controller.signal.reason
+                if(signal.aborted) throw signal.reason
+                if(writers.size != 0) {
+                    let writer = writers.values().next().value
+                    writers.delete(writer)
+                    writer.resolve()
+                    return writer.value
+                } else {
+                    let reader
+                    let abort
+                    let promise = new Promise((resolve, reject) => {
+                        reader = resolve
+                        abort = () => reject(self_.controller.signal.reason || signal.reason)
+                    })
+                    readers.add(reader)
+                    self_.controller.signal.addEventListener('abort', abort)
+                    signal.addEventListener('abort', abort)
+                    try {
+                        return await promise
+                    } finally {
+                        readers.remove(reader)
+                        self_.controller.signal.removeEventListener('abort', abort)
+                        signal.removeEventListener('abort', abort)
+                    }
+                }
+            }
+            async function write(value, signal) {
+                if(self_.controller.signal.aborted) throw self_.controller.signal.reason
+                if(signal.aborted) throw signal.reason
+                if(readers.size != 0) {
+                    let reader = readers.values().next().value
+                    readers.delete(reader)
+                    reader.resolve(value)
+                } else {
+                    let send
+                    let abort
+                    let promise = new Promise((resolve, reject) => {
+                        send = resolve
+                        abort = () => reject(self_.controller.signal.reason || signal.reason)
+                    })
+                    let writer = {value, resolve: send}
+                    writers.add(writer)
+                    if(writers.size > buffer) {
+                        self_.controller.signal.addEventListener('abort', abort)
+                        signal.addEventListener('abort', abort)
+                        try {
+                            await promise
+                        } finally {
+                            writers.remove(writer)
+                            self_.controller.signal.removeEventListener('abort', abort)
+                            signal.removeEventListener('abort', abort)
+                        }
+                    }
+                }
+            }
+            return {first_: read, second_: write}
+        """
+
+    race[T](tasks: List[() => T]): T { panic("magic") }
+        javascriptasync """
+            if(self_.controller.signal.aborted) throw self_.controller.signal.reason
+            let controller = new AbortController()
+            let abort = () => controller.abort(self_.controller.signal.reason)
+            self_.controller.signal.addEventListener('abort', abort)
+            let promises = []
+            try {
+                ff_core_List.List_toArray(tasks_).forEach(f =>
+                    promises.push(Promise.resolve(controller.signal).then(f))
+                )
+                return await Promise.race(promises)
+            } finally {
+                self_.controller.signal.removeEventListener('abort', abort)
+                controller.abort()
+                await Promise.allSettled(promises)
+            }
+        """
+
+    all[T](tasks: List[() => T]): List[T] { panic("magic") }
+        javascriptasync """
+            if(self_.controller.signal.aborted) throw self_.controller.signal.reason
+            let controller = new AbortController()
+            let abort = () => controller.abort(self_.controller.signal.reason)
+            self_.controller.signal.addEventListener('abort', abort)
+            let promises = []
+            try {
+                ff_core_List.List_toArray(tasks_).forEach(f =>
+                    promises.push(Promise.resolve(controller.signal).then(f))
+                )
+                let array = await Promise.all(promises)
+                return ff_core_Array.Array_toList(array)
+            } finally {
+                self_.controller.signal.removeEventListener('abort', abort)
+                controller.abort()
+                await Promise.allSettled(promises)
+            }
+        """
+
+    both[A, B](task1: () => A, task2: () => B): Pair[A, B] { panic("magic") }
+        javascriptasync """
+            if(self_.controller.signal.aborted) throw self_.controller.signal.reason
+            let controller = new AbortController()
+            let abort = () => controller.abort(self_.controller.signal.reason)
+            self_.controller.signal.addEventListener('abort', abort)
+            let promises = []
+            try {
+                promises.push(Promise.resolve(controller.signal).then(task1_))
+                promises.push(Promise.resolve(controller.signal).then(task2_))
+                let array = await Promise.all(promises)
+                return {first_: array[0], second_: array[1]}
+            } finally {
+                self_.controller.signal.removeEventListener('abort', abort)
+                controller.abort()
+                await Promise.allSettled(promises)
+            }
+        """
+
+}
+
+
+extend self: TaskSystem {
+    start[T](task: () => Unit): Task
+    channel[T](capacity: Int = 0): Channel[T]
+    sleep(duration: Duration): Unit
+}

package/experimental/random/PatternTest.ff

@@ -0,0 +1,39 @@
+/*test1(foo: Option[Int], bar: Option[Int]): Option[Int] {
+    | a, b => b
+}
+
+test2(foo: Option[Int], bar: Option[Int]): Option[Int] {
+    function f(baz: Option[Int], quux: Option[Int]): Option[Int] {
+        | Some(_), b => b
+        | None, _ => None
+    }
+    f(foo, bar)
+}
+
+data Moo(x: Int)
+
+extend self: Moo {
+    test3(moo: Moo): Moo {
+        | m => m
+    }
+}
+*/
+data Color {
+    R
+    B
+}
+
+data RB[K, V] {
+    E
+    T(color : Color, left: RB[K, V], key: K, value: V)
+}
+
+test4[K, V](left: RB[K, V], key: K): RB[K, V] {
+    | T(_, _, _, _), y => E
+    | a, y => E
+}
+
+nodeMain(main: NodeSystem) {
+    //Log.debug(Moo(7).test3(Moo(8)))
+    //Log.debug(test3())
+}