firefly-compiler 0.4.4

package/experimental/random/kahrs/Kahrs.ff

@@ -0,0 +1,112 @@
+// Based on https://www.cs.kent.ac.uk/people/staff/smk/redblack/Untyped.hs
+
+data Color {
+    R
+    B
+}
+
+data RB[A] {
+    E
+    T(color : Color, left: RB[A], element: A, right: RB[A])
+}
+
+insert[A: Order](x: A, s: RB[A]): RB[A] {
+    function ins(s: RB[A]): RB[A] {
+        | E => T(R, E, x, E)
+        | T(B, a, y, b) => Ordering.compare(x, y).{
+            | OrderingBefore => balance(ins(a), y, b)
+            | OrderingAfter => balance(a, y, ins(b))
+            | OrderingSame => a
+        }
+        | T(R, a, y, b) => Ordering.compare(x, y).{
+            | OrderingBefore => T(R, ins(a), y, b)
+            | OrderingAfter => T(R, a, y, ins(b))
+            | OrderingSame => s
+        }
+    }
+
+    ins(s).{
+        | E => panic("Unexpected empty tree")
+        | T(_, a, z, b) => T(B, a, z, b)
+    }
+}
+
+member[A: Order](x: A, s: RB[A]): Bool {
+    | x, E => False
+    | x, T(_, a, y, b,) => Ordering.compare(x, y).{
+        | OrderingBefore => member(x, a)
+        | OrderingAfter => member(x, b)
+        | OrderingSame => True
+    }
+}
+
+balance[A: Order](aa : RB[A], xx: A, bb: RB[A]): RB[A] {
+    | T(R, a, x, b), y, T(R, c, z, d) => T(R, T(B, a, x, b), y, T(B, c, z, d))
+    | T(R, T(R, a, x, b), y, c), z, d => T(R, T(B, a, x, b), y, T(B, c, z, d))
+    | T(R, a, x, T(R, b, y, c)), z, d => T(R, T(B, a, x, b), y, T(B, c, z, d))
+    | a, x, T(R, b, y, T(R, c, z, d)) => T(R, T(B, a, x, b), y, T(B, c, z, d))
+    | a, x, T(R, T(R, b, y, c), z, d) => T(R, T(B, a, x, b), y, T(B, c, z, d))
+    | a, x, b => T(B, a, x, b)
+}
+
+delete[A: Order](x: A, t: RB[A]): RB[A] {
+    function del(ss: RB[A]): RB[A] {
+        | E => E
+        | T(_, a, y, b) => Ordering.compare(x, y).{
+            | OrderingBefore => delformLeft(a, y, b)
+            | OrderingAfter => delformRight(a, y, b)
+            | OrderingSame => app(a, b)
+        }
+    }
+
+    function delformLeft(a: RB[A], y: A, b: RB[A]): RB[A] {
+        | T(B, _, _, _), y, b => balleft(del(a), y, b)
+        | a, y, b => T(R, del(a), y, b)
+    }
+
+    function delformRight(a: RB[A], y: A, b: RB[A]): RB[A] {
+        | a, y, T(B, _, _, _) => balright(a, y, del(b))
+        | a, y, b => T(R, a, y, del(b))
+    }
+
+    del(t).{
+        | T(_, a, y, b) => T(B, a, y, b)
+        | _ => E
+    }
+}
+
+balleft[A: Order](aa: RB[A], xx: A, bb: RB[A]): RB[A] {
+    | T(R, a, x, b), y, c => T(R, T(B, a, x, b), y, c)
+    | bl, x, T(B, a, y, b) => balance(bl, x, T(R, a, y, b))
+    | bl, x, T(R, T(B, a, y, b), z, c) => T(R, T(B, bl, x, a), y, (balance(b, z, sub1(c))))
+    | _, _, _ => panic("Unexhaustive match in balleft")
+}
+
+balright[A: Order](aa: RB[A], xx: A, bb: RB[A]): RB[A] {
+    | a, x, T(R, b, y, c) => T(R, a, x, T(B, b, y, c))
+    | T(B, a, x, b), y, bl => balance(T(R, a, x, b), y, bl)
+    | T(R, a, x, T(B, b, y, c)), z, bl => T(R, balance(sub1(a), x, b), y, T(B, c, z, bl))
+    | _, _, _ => panic("Unexhaustive match in balright")
+}
+
+sub1[A: Order](tt: RB[A]): RB[A] {
+    | T(B, a, x, b) => T(R, a, x, b)
+    | _ => panic("invariance violation")
+}
+
+app[A: Order](aa: RB[A], bb: RB[A]): RB[A] {
+    | E, x => x
+    | x, E => x
+    | T(R, a, x, b), T(R, c, y, d) =>
+        app(b, c).{
+            | T(R, b2, z, c2) => T(R, T(R, a, x, b2), z, T(R, c2, y, d))
+            | bc => T(R, a, x, T(R, bc, y, d))
+        }
+    | T(B, a, x, b), T(B, c, y, d) =>
+        app(b, c).{
+            | T(R, b2, z, c2) => T(R, T(B, a, x, b2), z, T(B, c2, y, d))
+            | bc => balleft(a, x, T(B, bc, y, d))
+        }
+    | a, T(R, b, x, c) => T(R, app(a, b), x, c)
+    | T(R, a, x, b), c => T(R, a, x, app(b, c))
+}

package/experimental/random/kahrs/TestKahrs.ff

@@ -0,0 +1,22 @@
+import Kahrs
+
+nodeMain(system: NodeSystem): Unit {
+
+    let values = [8, 3, 2, 1, 4, 7, 6, 5, 9]
+    let full = values.foldLeft(Kahrs.E, {t, a =>
+        let t2 = Kahrs.insert(a, t)
+        Log.debug("Insert " + a + ": " + Show.show(toList(t2)))
+        t2
+    })
+    values.foldLeft(full, {t, a =>
+        let t2 = Kahrs.delete(a, t)
+        Log.debug("Delete " + a + ": " + Show.show(toList(t2)))
+        t2
+    })
+
+}
+
+toList[A: Order](t: RB[A]): List[A] {
+    | E => []
+    | T(_, left, e, right) => [...toList(left), e, ...toList(right)]
+}

package/experimental/random/kahrs/TestMap.ff

@@ -0,0 +1,18 @@
+import RbMap from ff:core
+
+nodeMain(system: NodeSystem): Unit {
+    let values = [8, 3, 2, 1, 4, 7, 6, 5, 9]
+    let full = values.foldLeft(RbMap.E, {t, a =>
+        let t2 = RbMap.insert(a, "" + a, t)
+        Log.debug("Insert " + a + ": " + Show.show(t2.pairs()))
+        t2
+    })
+    values.foldLeft(full, {t, a =>
+        let t2 = RbMap.delete(a, t)
+        Log.debug("Delete " + a + ": " + Show.show(t2.pairs()))
+        t2
+    })
+
+    //RbMap.delete(1, RbMap.delete(1, RbMap.insert(1, "A", RbMap.E)))
+
+}

package/experimental/random/streaming/Gzip.ff

@@ -0,0 +1,3 @@
+compress(stream: Stream[Buffer]): Stream[Buffer] {panic("TODO")}
+
+decompress(stream: Stream[Buffer]): Stream[Buffer] {panic("TODO")}

package/experimental/random/streaming/Main.ff

@@ -0,0 +1,34 @@
+// Have: Gzipped .tar archives containing .xml files in S3.
+// Want: Gzipped .tar archives containing .json files in S3.
+// But: Too big to store it all in memory, and disk is too slow.
+// Firefly iterators to the rescue!
+
+    convertFiles(bucket: S3Bucket): Unit {
+        bucket.listKeys(prefix = "xml/").each {key =>
+            let xmlTarGz = bucket.readStream(key)
+            let xmlTar = Gzip.decompress(xmlTarGz)
+            let entries = Tar.unarchive(xmlTar).map {entry =>
+                TarEntry(entry.name.replace(".xml", ".json"), process(entry))
+            }
+            let jsonTar = Tar.archive(entries)
+            let jsonTarGz = Gzip.compress(jsonTar)
+            bucket.writeStream(key.replace("xml/", "json/"), jsonTarGz)
+        )
+    }
+
+
+
+    Gzip.compress(stream: Stream[Buffer]): Stream[Buffer]
+    Gzip.decompress(stream: Stream[Buffer]): Stream[Buffer]
+    Tar.archive(stream: Stream[TarEntry]): Stream[Buffer]
+    Tar.unarchive(stream: Stream[Buffer]): Stream[TarEntry]
+    bucket.listKeys(prefix: String = ""): Stream[String]
+    bucket.readStream(key: String): Stream[Buffer]
+    bucket.writeStream(key: String, stream: Stream[Buffer]): Unit
+
+
+    class Stream[T](
+        next: () => Option[T]
+        close: () => Unit
+    )
+

package/experimental/random/streaming/S3Bucket.ff

@@ -0,0 +1,11 @@
+data S3Bucket
+
+extend self: S3Bucket {
+
+    listKeys(): Stream[String]
+
+    readStream(key: String): Stream[Buffer] {panic("TODO")}
+
+    writeStream(key: String, stream: Stream[Buffer]): Unit {panic("TODO")}
+
+}

package/experimental/random/streaming/Tar.ff

@@ -0,0 +1,5 @@
+data TarEntry(name: String, stream: Stream[Buffer])
+
+archive(stream: Stream[TarEntry]): Stream[Buffer] {panic("TODO")}
+
+unarchive(stream: Stream[Buffer]): Stream[TarEntry] {panic("TODO")}

package/experimental/rhymeapp/Main.ff

@@ -0,0 +1,81 @@
+dependency ff:httpserver:0.0.0
+import HttpServer from ff:httpserver
+
+browserMain(system: BrowserSystem): Unit {
+
+    let document = system.js().global().get("document")
+    let input = document.call1("getElementById", "input")
+    let output = document.call1("getElementById", "output")
+    let button = document.call1("getElementById", "button")
+
+    let handler = system.js().function1 {event =>
+        let text = input.get("value").grabString()
+        let serialized = Serializable.serialize(text)
+        let result = system.httpClient().fetch(
+            url = "http://localhost:8080/rhyme"
+            method = "POST"
+            body = Some(HttpClient.bodyBuffer(serialized))
+        )
+        output.set("innerText", result.readText())
+    }
+
+    button.call2("addEventListener", "click", handler)
+
+}
+
+nodeMain(system: NodeSystem): Unit {
+    HttpServer.listen(system, "localhost", 8080) {request, response =>
+
+        if(request.path() == "/") {
+
+            response.setHeader("Content-Type", ["text/html; charset=UTF-8"])
+            response.writeText(system.assets().readText("/index.html"))
+
+        } elseIf {request.path().startsWith("/js/") && !request.path().contains("..")} {
+
+            let path = request.path().dropFirst("/js/".size())
+            response.setHeader("Content-Type", ["text/javascript"])
+            response.writeText(system.assets().readText("/browser/" + path))
+
+        } elseIf {request.path() == "/rhyme"} {
+
+            let buffer = request.readBuffer()
+            let deserialized = Serializable.deserialize(buffer)
+            let result = system.httpClient().fetch("https://api.datamuse.com/words?rel_rhy=" + deserialized)
+            let json = system.js().parseJson(result.readText())
+            let rhyme = json.get(0).get("word").grabString()
+            response.setHeader("Access-Control-Allow-Origin", ["*"])
+            response.writeText(rhyme)
+
+        } else {
+
+            response.writeStatus(404, Some("Not found"))
+
+        }
+
+    }
+}
+
+buildMain(system: BuildSystem) {
+    let browser: BrowserCode = system.compileForBrowser("Main.ff")
+    let browserAssets = if(system.buildMode()) {
+        browser.bundle().assets()
+    } else {
+        browser.assets()
+    }
+    let indexAssets = if(system.buildMode()) {
+        let html = system.packageAssets().readText("/index.html")
+        let newHtml = html.replace(
+            """<script type="module" src="/js/script/script/Main.mjs"></script>"""
+            """<script defer src="/js/Main.bundle.js"></script>"""
+        )
+        let stream = {[newHtml.toBuffer()].toStream()}
+        AssetSystem([Pair("/index.html", stream)].toMap())
+    } else {
+        system.packageAssets().asset("/index.html")
+    }
+    let assets = AssetSystem.create()
+        .addAssets("/", indexAssets)
+        .addAssets("/browser", browserAssets)
+    system.setAssets(assets)
+}

package/experimental/rhymeapp/index.html

@@ -0,0 +1,14 @@
+<!doctype html>
+<html>
+<head>
+    <script type="module" src="/js/script/script/Main.mjs"></script>
+</head>
+<body>
+<h3>Find rhyme</h3>
+<br>
+<input id="input" value="fish">
+<button id="button">Rhyme</button>
+<br><br>
+<div id="output"></div>
+</body>
+</html>

package/firefly.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+set -e
+firefly_link=`readlink -f "$0"`
+firefly=`dirname "$firefly_link"`
+node "$firefly/output/js/ff/compiler/Main.mjs" $@

package/fireflysite/Main.ff

@@ -0,0 +1,13 @@
+dependency ff:httpserver:0.0.0
+import HttpServer from ff:httpserver
+
+nodeMain(system: NodeSystem): Unit {
+    let host = system.arguments().grab(0)
+    let port = system.arguments().grab(1).grabInt()
+    HttpServer.listen(system, host, port) {request, response =>
+        let parameters = request.parameters().map {"?" + _}.else {""}
+        response.setHeader("Location", ["https://www.firefly-lang.org" + request.path() + parameters])
+        response.writeStatus(302, Some("Found"))
+    }
+}
+

package/httpserver/.firefly/package.ff

@@ -0,0 +1 @@
+package ff:httpserver:0.0.0

package/httpserver/HttpServer.ff

@@ -0,0 +1,184 @@
+capability HttpRequest {}
+capability HttpResponse {}
+
+listen(system: NodeSystem, host: String, port: Int, handler: (HttpRequest, HttpResponse) => Unit): Unit
+    target node async """
+        import * as http from 'http'
+        ff_core_Task.Task_throwIfAborted($task)
+        const server = http.createServer(async (req, res) => {
+            try {
+                const channel = ff_core_Task.Task_channel($task)
+                ff_core_Task.Task_spawn($task, async task => {
+                    try {
+                        await handler_(req, res, task)
+                    } finally {
+                        await ff_core_Channel.Channel_write$(channel, null, task)
+                    }
+                })
+                await ff_core_Channel.Channel_read$(channel, $task)
+                if(!res.headersSent) res.writeHead(200, 'OK')
+            } finally {
+                if(!res.headersSent) res.writeHead(500, 'Internal Server Error')
+                if(!res.writableEnded) res.end()
+            }
+        })
+        await new Promise((resolve, reject) => {
+            server.listen(port_, host_, error => {if(error != null) reject(error); else resolve()})
+        })
+        await new Promise((resolve, reject) => {
+            const abort = () => {
+                $task.controller.signal.removeEventListener('abort', abort)
+                const reason = $task.controller.signal.reason
+                $task.controller = new AbortController()
+                server.close(() => reject(reason))
+            }
+            $task.controller.signal.addEventListener('abort', abort)
+        })
+    """
+
+
+extend self: HttpRequest {
+
+    method(): String
+        target node async "return self_.method"
+
+    path(): String
+        target node async """
+            let i = self_.url.indexOf('?')
+            return i === -1 ? self_.url : self_.url.slice(0, i)
+        """
+
+    parameters(): Option[String]
+        target node async """
+            let i = self_.url.indexOf('?')
+            return i === -1 ? ff_core_Option.None() : ff_core_Option.Some(self_.url.slice(i + 1))
+        """
+
+    parameter(name: String): Option[String]
+        target node async """
+            let i = self_.url.indexOf('?')
+            if(i === -1) return ff_core_Option.None()
+            let ps = self_.url.slice(i + 1).split('&')
+            let n = name_ + '='
+            let r = ps.find(p => p === name_ || p.startsWith(n))
+            if(r == null) return ff_core_Option.None()
+            return ff_core_Option.Some(r.slice(name_.length + 1))
+        """
+
+    header(name: String): Option[String]
+        target node async """
+            let header = self_.headers[name_.toLowerCase()]
+            if(header == null || header.length == 0) ff_core_Option.None()
+            return ff_core_Option.Some(Array.isArray(header) ? header[0] : header)
+        """
+
+    encoding(): Option[String]
+        target node async """
+            return self_.readableEncoding ? ff_core_Option.Some(self_.readableEncoding) : ff_core_Option.None()
+        """
+
+    readText(encoding: Option[String] = None): String {
+        self.readStream().toString(encoding.else {self.encoding().else {"utf8"}})
+    }
+
+    readBuffer(): Buffer {
+        self.readStream().toBuffer()
+    }
+
+    readStream(): Stream[Buffer]
+        target node async """
+            import * as http from 'http'
+            let task = null
+            let readable = self_
+            let doResolve = null
+            let doReject = null
+            let seenError = null
+            const abort = () => {
+                if(task != null) {
+                    task.controller.signal.removeEventListener('abort', abort)
+                    readable.destroy()
+                }
+            }
+            function open($task) {
+                ff_core_Task.Task_throwIfAborted($task)
+                if(self_.streamWorkaround != null) throw new Error("Can't open HttpRequest body stream twice")
+                task = $task
+                self_.streamWorkaround = true
+                readable.on('readable', () => {
+                    if(doResolve != null) doResolve()
+                })
+                readable.on('error', error => {
+                    task.controller.signal.removeEventListener('abort', abort)
+                    seenError = error
+                    if(doReject != null) doReject(error)
+                })
+                readable.on('close', () => {
+                    task.controller.signal.removeEventListener('abort', abort)
+                    if(doResolve != null) doResolve()
+                })
+                $task.controller.signal.addEventListener('abort', abort)
+            }
+            return ff_core_Stream.Stream(async function go($task) {
+                if(task == null) open($task)
+                let buffer = readable.read()
+                if(buffer != null) return ff_core_Option.Some(buffer)
+                if(seenError != null) throw seenError
+                if(readable.destroyed) return ff_core_Option.None()
+                let promise = new Promise((resolve, reject) => {
+                    doResolve = () => {doResolve = null; doReject = null; resolve()}
+                    doReject = error => {doResolve = null; doReject = null; reject(error)}
+                }).then(() => go($task))
+                return await promise
+            }, abort)
+        """
+
+}
+
+extend self: HttpResponse {
+
+    setHeader(name: String, values: List[String]): Unit
+        target node async "self_.setHeader(name_, ff_core_List.List_toArray(values_))"
+
+    writeStatus(code: Int, message: Option[String]): Unit
+        target node async "self_.writeHead(code_, message_.value_)"
+
+    write(buffer: Buffer): Unit
+        target node async """
+            import * as http from 'http'
+            ff_core_Task.Task_throwIfAborted($task)
+            if(!self_.write(buffer_)) {
+                let reject = null;
+                await new Promise((resolve, reject) => {
+                    const abort = () => {
+                        $task.controller.signal.removeEventListener('abort', abort)
+                        reject($task.controller.signal.reason)
+                    }
+                    $task.controller.signal.addEventListener('abort', abort)
+                    self_.once('drain', () => {
+                        $task.controller.signal.removeEventListener('abort', abort)
+                        resolve()
+                    })
+                })
+            }
+        """
+
+    writeText(text: String, encoding: String = "utf8"): Unit
+        target node async """
+            import * as http from 'http'
+            ff_core_Task.Task_throwIfAborted($task)
+            if(!self_.write(text_, encoding_)) {
+                await new Promise((resolve, reject) => {
+                    const abort = () => {
+                        $task.controller.signal.removeEventListener('abort', abort)
+                        reject($task.controller.signal.reason)
+                    }
+                    $task.controller.signal.addEventListener('abort', abort)
+                    self_.once('drain', () => {
+                        $task.controller.signal.removeEventListener('abort', abort)
+                        resolve()
+                    })
+                })
+            }
+        """
+
+}

package/lsp/.firefly/package.ff

@@ -0,0 +1 @@
+dependency ff:compiler:0.0.0