firefly-compiler 0.4.4

package/core/Path.ff

@@ -0,0 +1,393 @@
+capability Path {}
+capability PathEntry {}
+
+extend self: Path {
+
+    exists(checkReadable: Bool = False, checkWritable: Bool = False, checkExecutable: Bool = False): Bool
+        target node async """
+            import * as fs from 'fs'
+            import * as fsPromises from 'fs/promises'
+            const flags = 
+                (fs.constants.R_OK * checkReadable_) | 
+                (fs.constants.W_OK * checkWritable_) | 
+                (fs.constants.X_OK * checkExecutable_)
+            try {
+                await fsPromises.access(self_, flags === 0 ? fs.constants.F_OK : flags)
+                return true
+            } catch(e) {
+                return false
+            }
+        """
+        
+    isReadable(): Bool {
+        self.exists(checkReadable = True)
+    }
+        
+    isWritable(): Bool {
+        self.exists(checkWritable = True)
+    }
+
+    isExecutable(): Bool {
+        self.exists(checkExecutable = True)
+    }
+
+    isDirectory(): Bool
+        target node async """
+            import * as fsPromises from 'fs/promises'
+            try {
+                return (await fsPromises.lstat(self_)).isDirectory();
+            } catch(e) {
+                return false;
+            }
+        """
+
+    isFile(): Bool
+        target node async """
+            import * as fsPromises from 'fs/promises'
+            try {
+                return (await fsPromises.lstat(self_)).isFile();
+            } catch(e) {
+                return false;
+            }
+        """
+
+    isSymbolicLink(): Bool
+        target node async """
+            import * as fsPromises from 'fs/promises'
+            try {
+                return (await fsPromises.lstat(self_)).isSymbolicLink();
+            } catch(e) {
+                return false;
+            }
+        """
+
+    isInsideOf(path: Path): Bool
+        target node async """
+            import * as path from 'path'
+            if(path_ === '/') return true
+            const childPath = path.resolve(self_)
+            const parentPath = path.resolve(path_)
+            return childPath.startsWith(parentPath + path.sep) || childPath === parentPath
+        """
+
+    size(): Int
+        target node async """
+            return (await fs.promises.stat(file)).size
+        """
+        
+    modified(): Instant
+        target node async """
+            return (await fs.promises.stat(file)).mtimeMs * 0.001
+        """
+
+    entries(): Stream[PathEntry]
+        target node async """
+            import * as fsPromises from 'fs/promises'
+            let dir = null
+            return ff_core_Stream.Stream(
+                async () => {
+                    if(dir === null) dir = await fsPromises.opendir(self_, {bufferSize: 128})
+                    const entry = await dir.read()
+                    if(entry === null) return ff_core_Option.None()
+                    entry.ffPath = self_
+                    return ff_core_Option.Some(entry)
+                },
+                async () => {
+                    await dir.close()
+                }
+            )
+        """
+
+    absolute(): String
+        target node async """
+            import * as path from 'path'
+            return path.resolve(self_)
+        """
+
+    relativeTo(path: Path): String
+        target node async """
+            import * as path from 'path';
+            return path.relative(path_, self_);
+        """
+    
+    endsWith(parts: List[String]): Bool {
+        function go(pathOption: Option[Path], reversed: List[String]): Bool {
+            | _, [] => True
+            | Some(path), [p, ...ps] => path.base() == p && go(path.parent(), ps)
+            | None, _ => False
+        }
+        go(Some(self), parts.reverse())
+    }
+
+    base(): String
+        target node async """
+            import * as path from 'path'
+            return path.basename(self_)
+        """
+
+    extension(): String
+        target node async """
+            import * as path from 'path'
+            return path.extname(self_)
+        """
+
+    url(): String
+        target node async """
+            import * as url from 'url';
+            return '' + url.pathToFileURL(self_);
+        """
+
+    delimiter(): String
+        target node async """
+            import * as path from 'path';
+            return path.delimiter(self_);
+        """
+
+    separator(): String
+        target node async """
+            import * as path from 'path';
+            return path.separator();
+        """
+
+    parent(): Option[Path]
+        target node async """
+            import * as path from 'path'
+            const result = path.dirname(self_)
+            return result !== "" && result !== self_
+                ? ff_core_Option.Some(result) 
+                : ff_core_Option.None()
+        """
+
+    slash(relativePath: String): Path
+        target node async """
+            import * as path from 'path'
+            return path.join(self_, relativePath_)
+        """
+
+    path(absoluteOrRelativePath: String): Path
+        target node async """
+            import * as path from 'path'
+            return path.resolve(self_, absoluteOrRelativePath_)
+        """
+
+    copyTo(path: Path, retries: Int = 0, retryDelay: Int = 100) {
+        if(self.isDirectory()) {
+            if(path.exists()) {path.delete(retries, retryDelay)}
+            path.createDirectory()
+            self.entries().each {file =>
+                file.path().copyTo(path.slash(file.path().relativeTo(self)), retries, retryDelay)
+            }
+        } else {
+            path.writeStream(self.readStream())
+        }
+    }
+
+    createDirectory(createParentDirectories: Bool = False)
+        target node async """
+            import * as fsPromises from 'fs/promises'
+            await fsPromises.mkdir(self_, {recursive: createParentDirectories_})
+        """
+
+    createSymlinkTo(path: Path)
+        target node async """
+            import * as fsPromises from 'fs/promises'
+            await fsPromises.symlink(path_, self_)
+        """
+
+    delete(retries: Int = 0, retryDelay: Int = 100)
+        target node async """
+            import * as fsPromises from 'fs/promises'
+            await fsPromises.rm(self_, {recursive: true, retries: retries_, retryDelay: retryDelay_})
+        """
+    
+    truncate(length: Int = 0)
+        target node async """
+            import * as fsPromises from 'fs/promises'
+            await fsPromises.truncate(self_, length_)
+        """
+
+    renameTo(path: Path)
+        target node async """
+            import * as fsPromises from 'fs/promises'
+            await fsPromises.rename(self_, path_)
+        """
+
+    readText(): String
+        target node async """
+            import * as fsPromises from 'fs/promises'
+            try {
+                return await fsPromises.readFile(self_, {encoding: 'UTF-8', signal: $task.controller.signal})
+            } finally {
+                if($task.controller.signal.aborted) $task.controller = new AbortController()
+            }
+        """
+
+    writeText(text: String)
+        target node async """
+            import * as fsPromises from 'fs/promises'
+            try {
+                await fsPromises.writeFile(self_, text_, {encoding: 'UTF-8', signal: $task.controller.signal})
+            } finally {
+                if($task.controller.signal.aborted) $task.controller = new AbortController()
+            }
+        """
+
+    appendText(text: String)
+        target node async """
+            import * as fsPromises from 'fs/promises'
+            try {
+                await fsPromises.appendFile(self_, text_, {encoding: 'UTF-8', signal: $task.controller.signal})
+            } finally {
+                if($task.controller.signal.aborted) $task.controller = new AbortController()
+            }
+        """
+
+    readBuffer(): Buffer {
+        self.readStream().toBuffer()
+    }
+    
+    writeBuffer(buffer: Buffer) {
+        self.writeStream([buffer].toStream())
+    }
+    
+    appendBuffer(buffer: Buffer) {
+        self.appendStream([buffer].toStream())
+    }
+
+    readStream(): Stream[Buffer]
+        target node async """
+            import * as fs from 'fs'
+            return ff_core_Path.internalReadStream_$(() => fs.createReadStream(self_))
+        """
+
+    writeStream(stream: Stream[Buffer], createOnly: Bool = False)
+        target node async """
+            import * as fs from 'fs'
+            let writeable = fs.createWriteStream(self_, {flags: createOnly_ ? 'wx' : 'w'})
+            try {
+                await ff_core_Stream.Stream_each$(stream_, async buffer => {
+                    if(!writeable.write(new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength))) {
+                        await new Promise((resolve, reject) => {
+                            $task.controller.signal.addEventListener('abort', reject)
+                            writeable.once('drain', () => {
+                                $task.controller.signal.removeEventListener('abort', reject)
+                                resolve()
+                            })
+                        })
+                    }
+                }, $task)
+            } finally {
+                writeable.close()
+            }
+        """
+
+    appendStream(stream: Stream[Buffer])
+        target node async """
+            import * as fs from 'fs'
+            let writeable = fs.createWriteStream(self_, {flags: 'a'})
+            try {
+                await ff_core_Stream.Stream_each$(stream_, async buffer => {
+                    if(!writeable.write(new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength))) {
+                        await new Promise((resolve, reject) => {
+                            $task.controller.signal.addEventListener('abort', reject)
+                            writeable.once('drain', () => {
+                                $task.controller.signal.removeEventListener('abort', reject)
+                                resolve()
+                            })
+                        })
+                    }
+                }, $task)
+            } finally {
+                writeable.close()
+            }
+        """
+
+    readHandle(alsoWrite: Bool = False): FileHandle
+        target node async """
+            import * as fsPromises from 'fs/promises'
+            return await fsPromises.open(self_, alsoWrite_ ? 'r+' : 'r')
+        """
+
+    writeHandle(alsoRead: Bool = False, mustCreate: Bool = False): FileHandle
+        target node async """
+            import * as fsPromises from 'fs/promises'
+            return await fsPromises.open(self_, (mustCreate_ ? 'wx' : 'w') + (alsoRead_ ? '+' : ''))
+        """
+
+    appendHandle(alsoRead: Bool = False, mustCreate: Bool = False): FileHandle
+        target node async """
+            import * as fsPromises from 'fs/promises'
+            return await fsPromises.open(self_, (mustCreate_ ? 'wx' : 'w') + (alsoRead_ ? '+' : ''))
+        """
+
+}
+
+extend self: PathEntry {
+    
+    path(): Path
+        target node async """
+            import * as path from 'path'
+            return path.join(self_.ffPath, self_.name)
+        """
+
+    isDirectory(): Bool
+        target node async """
+            return self_.isDirectory()
+        """
+
+    isFile(): Bool
+        target node async """
+            return self_.isFile()
+        """
+
+    isSymbolicLink(): Bool
+        target node async """
+            return self_.isSymbolicLink()
+        """
+
+}
+
+internalReadStream(createReadStream: () => JsValue): Stream[Buffer]
+    target node async """
+        let task = null
+        let readable = null
+        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)
+            task = $task
+            readable = createReadStream_()
+            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(new DataView(buffer.buffer, buffer.byteOffset, buffer.length))
+            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)
+    """

package/core/RbMap.ff

@@ -0,0 +1,216 @@
+// Based on https://www.cs.kent.ac.uk/people/staff/smk/redblack/Untyped.hs
+
+data Color {
+    R
+    B
+}
+
+data RB[K, V] {
+    E
+    T(color: Color, left: RB[K, V], key: K, value: V, right: RB[K, V])
+}
+
+insert[K: Order, V](x: K, xv: V, s: RB[K, V]): RB[K, V] {
+    function ins(s: RB[K, V]): RB[K, V] {
+        | E => T(R, E, x, xv, E)
+        | T(B, a, y, yv, b) => Ordering.compare(x, y).{
+            | OrderingBefore => balance(ins(a), y, yv, b)
+            | OrderingAfter => balance(a, y, yv, ins(b))
+            | OrderingSame => T(B, a, x, xv, b)
+        }
+        | T(R, a, y, yv, b) => Ordering.compare(x, y).{
+            | OrderingBefore => T(R, ins(a), y, yv, b)
+            | OrderingAfter => T(R, a, y, yv, ins(b))
+            | OrderingSame => T(R, a, x, xv, b)
+        }
+    }
+
+    ins(s).{
+        | E => panic("Unexpected empty tree")
+        | T(_, a, z, zv, b) => T(B, a, z, zv, b)
+    }
+}
+
+member[K: Order, V](key: K, tree: RB[K, V]): Bool {
+    | x, E => False
+    | x, T(_, a, y, _, b,) => Ordering.compare(x, y).{
+        | OrderingBefore => member(x, a)
+        | OrderingAfter => member(x, b)
+        | OrderingSame => True
+    }
+}
+
+balance[K: Order, V](tree1: RB[K, V], key: K, value: V, tree2: RB[K, V]): RB[K, V] {
+    | T(R, a, x, xv, b), y, yv, T(R, c, z, zv, d) => T(R, T(B, a, x, xv, b), y, yv, T(B, c, z, zv, d))
+    | T(R, T(R, a, x, xv, b), y, yv, c), z, zv, d => T(R, T(B, a, x, xv, b), y, yv, T(B, c, z, zv, d))
+    | T(R, a, x, xv, T(R, b, y, yv, c)), z, zv, d => T(R, T(B, a, x, xv, b), y, yv, T(B, c, z, zv, d))
+    | a, x, xv, T(R, b, y, yv, T(R, c, z, zv, d)) => T(R, T(B, a, x, xv, b), y, yv, T(B, c, z, zv, d))
+    | a, x, xv, T(R, T(R, b, y, yv, c), z, zv, d) => T(R, T(B, a, x, xv, b), y, yv, T(B, c, z, zv, d))
+    | a, x, xv, b => T(B, a, x, xv, b)
+}
+
+delete[K: Order, V](x: K, t: RB[K, V]): RB[K, V] {
+    function del(ss: RB[K, V]): RB[K, V] {
+        | E => E
+        | T(_, a, y, yv, b) => Ordering.compare(x, y).{
+            | OrderingBefore => delformLeft(a, y, yv, b)
+            | OrderingAfter => delformRight(a, y, yv, b)
+            | OrderingSame => app(a, b)
+        }
+    }
+
+    function delformLeft(left: RB[K, V], key: K, value: V, right: RB[K, V]): RB[K, V] {
+        | T(B, _, _, _, _), y, yv, b => balleft(del(left), y, yv, b)
+        | a, y, yv, b => T(R, del(a), y, yv, b)
+    }
+
+    function delformRight(left: RB[K, V], key: K, value: V, right: RB[K, V]): RB[K, V] {
+        | a, y, yv, T(B, _, _, _, _) => balright(a, y, yv, del(right))
+        | a, y, yv, b => T(R, a, y, yv, del(b))
+    }
+
+    del(t).{
+        | T(_, a, y, yv, b) => T(B, a, y, yv, b)
+        | _ => E
+    }
+}
+
+balleft[K: Order, V](tree1: RB[K, V], key: K, value: V, tree2: RB[K, V]): RB[K, V] {
+    | T(R, a, x, xv, b), y, yv, c => T(R, T(B, a, x, xv, b), y, yv, c)
+    | bl, x, xv, T(B, a, y, yv, b) => balance(bl, x, xv, T(R, a, y, yv, b))
+    | bl, x, xv, T(R, T(B, a, y, yv, b), z, zv, c) => T(R, T(B, bl, x, xv, a), y, yv, (balance(b, z, zv, sub1(c))))
+    | _, _, _, _ => panic("Unexhaustive match in balleft")
+}
+
+balright[K: Order, V](tree1: RB[K, V], key: K, value: V, tree2: RB[K, V]): RB[K, V] {
+    | a, x, xv, T(R, b, y, yv, c) => T(R, a, x, xv, T(B, b, y, yv, c))
+    | T(B, a, x, xv, b), y, yv, bl => balance(T(R, a, x, xv, b), y, yv, bl)
+    | T(R, a, x, xv, T(B, b, y, yv, c)), z, zv, bl => T(R, balance(sub1(a), x, xv, b), y, yv, T(B, c, z, zv, bl))
+    | _, _, _, _ => panic("Unexhaustive match in balright")
+}
+
+sub1[K: Order, V](tree: RB[K, V]): RB[K, V] {
+    | T(B, a, x, xv, b) => T(R, a, x, xv, b)
+    | _ => panic("invariance violation")
+}
+
+app[K: Order, V](tree1: RB[K, V], tree2: RB[K, V]): RB[K, V] {
+    | E, b => b
+    | a, E => a
+    | T(R, a, x, xv, b), T(R, c, y, yv, d) =>
+        app(b, c).{
+            | T(R, b2, z, zv, c2) => T(R, T(R, a, x, xv, b2), z, zv, T(R, c2, y, yv, d))
+            | bc => T(R, a, x, xv, T(R, bc, y, yv, d))
+        }
+    | T(B, a, x, xv, b), T(B, c, y, yv, d) =>
+        app(b, c).{
+            | T(R, b2, z, zv, c2) => T(R, T(B, a, x, xv, b2), z, zv, T(B, c2, y, yv, d))
+            | bc => balleft(a, x, xv, T(B, bc, y, yv, d))
+        }
+    | a, T(R, b, x, xv, c) => T(R, app(a, b), x, xv, c)
+    | T(R, a, x, xv, b), c => T(R, a, x, xv, app(b, c))
+}
+
+extend self[K: Order, V]: RB[K, V] {
+
+    get(key: K): Option[V] {
+        self.{
+            | E_ => None
+            | T(_, a, y, yv, b) => Ordering.compare(key, y).{
+                | OrderingBefore => a.get(key)
+                | OrderingAfter => b.get(key)
+                | OrderingSame => Some(yv)
+            }
+        }
+    }
+
+    size(): Int {
+        self.{
+            | E => 0
+            | T(_, l, _, _, r) => l.size() + 1 + r.size()
+        }
+    }
+
+    pairs(): List[Pair[K, V]] {
+        mutable result = []
+        self.each {k, v =>
+            result = [Pair(k, v), ...result]
+        }
+        result.reverse()
+    }
+
+    toStream(cycle: Bool): Stream[Pair[K, V]] {
+        mutable stack = [self]
+        function next(): Option[Pair[K, V]] {
+            stack.{
+                | [] =>
+                    if(cycle && self.{| E => False | _ => True}) {
+                        stack = [self]
+                        tailcall next()
+                    } else {
+                        None
+                    }
+                | [E, ...tail] =>
+                    stack = tail
+                    tailcall next()
+                | [T(_, E, k, v, E), ...tail] =>
+                    stack = tail
+                    Some(Pair(k, v))
+                | [T(_, l, k, v, r), ...tail] =>
+                    stack = [l, T(B, E, k, v, E), r, ...tail]
+                    tailcall next()
+            }
+        }
+        Stream.make(next)
+    }
+
+    each(body: (K, V) => Unit): Unit {
+        self.{
+            | E =>
+            | T(_, l, k, v, r) =>
+                l.each(body)
+                body(k, v)
+                r.each(body)
+        }
+    }
+
+    eachWhile(body: (K, V) => Bool): Bool {
+        self.{
+            | E =>
+                True
+            | T(_, l, k, v, r) =>
+                l.eachWhile(body) &&
+                body(k, v) &&
+                r.eachWhile(body)
+        }
+    }
+
+    map[K2: Order, V2](body: (K, V) => Pair[K2, V2]): RB[K2, V2] {
+        mutable result = E
+        self.each {k, v =>
+            let pair = body(k, v)
+            result = insert(pair.first, pair.second, result)
+        }
+        result
+    }
+
+    mapValues[V2](body: (K, V) => V2): RB[K, V2] {
+        self.{
+            | E => E
+            | T(c, l, k, v, r) =>
+                T(c, l.mapValues(body), k, body(k, v), r.mapValues(body))
+        }
+    }
+
+    find(body: (K, V) => Bool): Option[Pair[K, V]] {
+        mutable result = None
+        self.eachWhile {k, v => 
+            if(body(k, v)) {
+                result = Some(Pair(k, v))
+                False
+            } else {True}
+        }
+        result
+    }
+
+}