firefly-compiler 0.4.4

package/core/Array.ff

@@ -0,0 +1,249 @@
+data Array[T] {}
+
+empty[T](): Array[T]
+    target js sync """
+        return [];
+    """
+
+fill[T](size: Int, value: T): Array[T]
+    target js sync """
+        return new Array(size_).fill(value_);
+    """
+
+fillBy[T](size: Int, body: Int => T): Array[T]
+    target js sync """
+        return Array.from({length: size_}, (_, i) => body_(i));
+    """
+
+range(size: Int): Array[Int]
+    target js sync """
+        return Array.from({length: size_}, (_, i) => i);
+    """
+
+extend self[T]: Array[T] {
+
+    addAll(that: Array[T]): Array[T]
+        target js sync "return self_.concat(that_)"
+
+    isEmpty(): Bool
+        target js sync "return self_.length === 0"
+
+    size(): Int
+        target js sync "return self_.length"
+
+    get(index: Int): Option[T]
+        target js sync """
+            return index_ >= 0 && index_ < self_.length
+                ? ff_core_Option.Some(self_[index_])
+                : ff_core_Option.None()
+        """
+
+    grab(index: Int): T
+        target js sync """
+            if(index_ < 0 || index_ >= self_.length) {
+                ff_core_Try.internalThrowGrabException_()
+            }
+            return self_[index_]
+        """
+
+    first(): Option[T] { self.get(0) }
+
+    last(): Option[T] { self.get(self.size() - 1) }
+
+    grabFirst(): T { self.grab(0) }
+
+    grabLast(): T { self.grab(self.size() - 1) }
+
+    dropFirst(count: Int = 1): Array[T]
+        target js sync "return self_.slice(count_)"
+
+    dropLast(count: Int = 1): Array[T]
+        target js sync "return self_.slice(0, self_.length - count_)"
+
+    update(index: Int, body: T => T): Array[T]
+        target js sync """
+            if(index_ < 0 || index_ >= self_.length) {
+                ff_core_Try.internalThrowGrabException_()
+            }
+            let result = self_.slice();
+            result[index_] = body_(result[index_]);
+            return result;
+        """
+        target js async """
+            if(index_ < 0 || index_ >= self_.length) {
+                ff_core_Try.internalThrowGrabException_()
+            }
+            let result = self_.slice();
+            result[index_] = await body_(result[index_], $task);
+            return result;
+        """
+
+    chunk(chunkSize: Int): Array[Array[T]] {
+        let results = Stack.make()
+        let result = Stack.make()
+        mutable added = 0
+        self.each { item =>
+            if(added < chunkSize) {
+                added += 1
+            } else {
+                results.push(result.drain())
+                added = 1
+            }
+            result.push(item)
+        }
+        if(added != 0) {
+            results.push(result.drain())
+        }
+        results.drain()
+    }
+
+    toList(): List[T]
+        target js sync """
+            let result = ff_core_List.Empty();
+            for(let i = self_.length - 1; i >= 0; i--) {
+                result = ff_core_List.Link(self_[i], result);
+            }
+            return result;
+        """
+
+    toStream(cycle: Bool = False): Stream[T] {
+        mutable index = 0
+        Stream.make {
+            if(index < self.size()) {
+                let result = self.grab(index)
+                index += 1
+                result
+            } elseIf {cycle && index != 0} {
+                let result = self.grab(0)
+                index = 1
+                result
+            }
+        }
+    }
+
+    toStack(): Stack[T]
+        target js sync "return {array: self_.slice()}"
+
+    each(body: T => Unit): Unit
+        target js sync """
+            return self_.forEach(body_);
+        """
+        target js async """
+            for(let i = 0; i < self_.length; i++) {
+                await body_(self_[i], $task)
+            }
+        """
+
+    eachWhile(body: T => Bool): Unit
+        target js sync "for(const value of self_) if(!body_(value)) break"
+        target js async "for(const value of self_) if(!await body_(value, $task)) break"
+
+    all(body: T => Bool): Bool {
+        mutable result = True
+        self.eachWhile {x =>
+            result = result && body(x)
+            result
+        }
+        result
+    }
+
+    any(body: T => Bool): Bool {
+        mutable result = False
+        self.eachWhile {x =>
+            result = result || body(x)
+            (!result)
+        }
+        result
+    }
+
+    map[S](body: T => S): Array[S]
+        target js sync """
+            return self_.map(body_)
+        """
+        target js async """
+            let result = [];
+            for(let i = self_.length - 1; i >= 0; i--) {
+                result.push(await body_(self_[i], $task));
+            }
+            return result;
+        """
+
+    sortBy[S: Order](body: T => S): Array[T] {
+        self.sortWith {Ordering.compare(body(_), body(_))}
+    }
+
+    sortWith(ordering: (T, T) => Ordering): Array[T] {
+        let stack = self.toStack()
+        stack.sortWith(ordering)
+        stack.drain()
+    }
+
+}
+
+extend self[T: Order]: Array[T] {
+
+    sort(): Array[T] {
+        self.sortWith(Ordering.compare)
+    }
+
+    toSet(): Set[T] {
+        self.toList().toSet()
+    }
+
+}
+
+extend self[K: Order, V]: Array[Pair[K, V]] {
+    toMap(): Map[K, V] {
+        self.toList().toMap()
+    }
+}
+
+extend self: Array[String] {
+
+    join(separator: String = ""): String
+        target js sync "return self_.join(separator_)"
+
+}
+
+instance Array[T: Show]: Show {
+    show(value: Array[T]): String {
+        let stack = Stack.make()
+        stack.push("[")
+        value.each {x =>
+            if(stack.size() > 1) {stack.push(", ")}
+            stack.push(Show.show(x))
+        }
+        stack.push("].toArray()")
+        stack.join()
+    }
+}
+
+instance Array[T: Equal]: Equal {
+    equals(x: Array[T], y: Array[T]): Bool {
+        if(internalSame(x, y)) {True} else:
+        if(x.size() != y.size()) {False} else:
+        mutable i = -1
+        x.all {l =>
+            i += 1
+            l == y.grab(i)
+        }
+    }
+}
+
+instance Array[T: Order]: Order {
+    compare(x: Array[T], y: Array[T]): Ordering {
+        if(internalSame(x, y)) {OrderingSame} else:
+        let size = x.size().min(y.size())
+        mutable i = 0
+        mutable ordering = OrderingSame
+        while {ordering == OrderingSame && i < size} {
+            ordering = Ordering.compare(x.grab(i), y.grab(i))
+            i += 1
+        }
+        if(ordering != OrderingSame) {ordering} else:
+        Ordering.compare(x.size(), y.size())
+    }
+}
+
+internalSame[T](left: Array[T], right: Array[T]): Bool
+    target js sync "return left_ === right_"

package/core/AssetSystem.ff

@@ -0,0 +1,61 @@
+capability AssetSystem(
+    files: Map[String, () => Stream[Buffer]]
+)
+
+create(): AssetSystem {
+    AssetSystem([].toMap())
+}
+
+extend self: AssetSystem {
+
+    addAssets(path: String, assets: AssetSystem): AssetSystem {
+        let prefix = if(path.endsWith("/")) {path.dropLast(1)} else {path}
+        AssetSystem(
+            self.files.addAll(
+                assets.files.map {p, stream =>
+                     Pair(prefix + p, stream)
+                }
+            )
+        )
+    }
+
+    assets(path: String): AssetSystem {
+        let prefix = if(path.endsWith("/")) {path} else {path + "/"}
+        let streams = self.files.pairs().collect {
+            | Pair(p, s) {p.startsWith(prefix)} => Some(Pair(p.dropFirst(prefix.size()), s))
+            | _ => None
+        }
+        AssetSystem(streams.toMap())
+    }
+
+    asset(path: String): AssetSystem {
+        let name = path.reverse().takeWhile {_ != '/'}.reverse()
+        let streams = self.files.get(path).toList().map {s => Pair("/" + name, s)}
+        AssetSystem(streams.toMap())
+    }
+
+    list(path: String): List[String] {
+        let prefix = if(path.endsWith("/")) {path} else {path + "/"}
+        self.files.pairs().collect {
+            | Pair(p, _) {p.startsWith(prefix)} => Some(p.dropFirst(prefix.size()).takeWhile {_ != '/'})
+            | _ => None
+        }.distinct()
+    }
+
+    exists(path: String): Bool {
+        let prefix = if(path.endsWith("/")) {path} else {path + "/"}
+        self.files.contains(path) || self.files.pairs().any {_.first.startsWith(prefix)}
+    }
+
+    readStream(file: String): Stream[Buffer] {
+        let makeStream = self.files.get(file).else {
+            panic("Asset not found for readStream: " + file)
+        }
+        makeStream()
+    }
+
+    readText(file: String): String {
+        self.readStream(file).toString()
+    }
+
+}

package/core/Atomic.ff

@@ -0,0 +1,64 @@
+class Atomic[T] {}
+
+make[T](value: T): Atomic[T]
+    target js sync """
+        return {value: value_}
+    """
+
+extend self[T]: Atomic[T] {
+
+    modify(body: T => T): T
+        target js sync """
+            return self_.value = body_(self_.value)
+        """
+        target js async """
+            let currentValue, newValue
+            do {
+                currentValue = self_.value
+                newValue = await body_(currentValue)
+            } while(currentValue !== self_.value)
+            self_.value = newValue
+            return newValue
+        """
+
+    getAndModify(body: T => T): T
+        target js sync """
+            const currentValue = self_.value
+            self_.value = body_(currentValue)
+            return currentValue
+        """
+        target js async """
+            let currentValue, newValue
+            do {
+                currentValue = self_.value
+                newValue = await body_(currentValue)
+            } while(currentValue !== self_.value)
+            self_.value = newValue
+            return currentValue
+        """
+
+    get(): T
+        target js sync """
+            return self_.value
+        """
+
+    set(value: T): Unit
+        target js sync """
+            self_.value = value
+        """
+
+    getAndSet(newValue: T): T
+        target js sync """
+            const currentValue = self_.value
+            self_.value = newValue
+            return currentValue
+        """
+
+    compareAndSet(currentValue: T, newValue: T): Bool
+        target js sync """
+            if(self_.value !== currentValue) return false
+            self_.value = newValue
+            return true
+        """
+
+}

package/core/Bool.ff

@@ -0,0 +1,13 @@
+data Bool {
+    False
+    True
+}
+
+extend self: Bool {
+    toInt(): Int {
+        self.{
+            | False => 0
+            | True => 1
+        }
+    }
+}

package/core/BrowserSystem.ff

@@ -0,0 +1,14 @@
+capability BrowserSystem {}
+
+extend self: BrowserSystem {
+
+    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"
+
+}

package/core/Buffer.ff

@@ -0,0 +1,211 @@
+class Buffer {}
+
+make(size: Int, shared: Bool = False): Buffer
+    target js sync "return new DataView(shared_ ? new SharedArrayBuffer(size_) : new ArrayBuffer(size_))"
+
+extend self: Buffer {
+
+    /*grabBigInt64(byteOffset: Int, littleEndian: Bool = True): BigInt
+        target js sync "return self_.getBigInt64(byteOffset_, littleEndian_)"*/
+
+    /*grabBigUint64(byteOffset: Int, littleEndian: Bool = True): BigInt
+        target js sync "return self_.getBigUint64(byteOffset_, littleEndian_)"*/
+
+    grabUint64(byteOffset: Int, littleEndian: Bool = True): Int
+        target js sync """
+            const high = self_.getUint32(byteOffset_ + (littleEndian_ ? 4 : 0), littleEndian_)
+            const low = self_.getUint32(byteOffset_ + (littleEndian_ ? 0 : 4), littleEndian_)
+            const result = (high * 0x100000000) + low
+            if(!Number.isSafeInteger(result)) throw 'grabUint64 out of range (consider grabBigUint64)'
+            return result
+        """
+
+    grabInt64(byteOffset: Int, littleEndian: Bool = True): Int
+        target js sync """
+            const high = self_.getInt32(byteOffset_ + (littleEndian_ ? 4 : 0), littleEndian_)
+            const low = self_.getUint32(byteOffset_ + (littleEndian_ ? 0 : 4), littleEndian_)
+            const result = (high * 0x100000000) + low
+            if(!Number.isSafeInteger(result)) throw 'grabInt64 out of range (consider grabBigInt64)'
+            return result
+        """
+
+    grabFloat32(byteOffset: Int, littleEndian: Bool = True): Float
+        target js sync "return self_.getFloat32(byteOffset_, littleEndian_)"
+
+    grabFloat64(byteOffset: Int, littleEndian: Bool = True): Float
+        target js sync "return self_.getFloat64(byteOffset_, littleEndian_)"
+
+    grabInt16(byteOffset: Int, littleEndian: Bool = True): Int
+        target js sync "return self_.getInt16(byteOffset_, littleEndian_)"
+
+    grabInt32(byteOffset: Int, littleEndian: Bool = True): Int
+        target js sync "return self_.getInt32(byteOffset_, littleEndian_)"
+
+    grabInt8(byteOffset: Int): Int
+        target js sync "return self_.getInt8(byteOffset_)"
+
+    grabUint16(byteOffset: Int, littleEndian: Bool = True): Int
+        target js sync "return self_.getUint16(byteOffset_, littleEndian_)"
+
+    grabUint32(byteOffset: Int, littleEndian: Bool = True): Int
+        target js sync "return self_.getUint32(byteOffset_, littleEndian_)"
+
+    grabUint8(byteOffset: Int): Int
+        target js sync "return self_.getUint8(byteOffset_)"
+
+    /*setBigInt64(byteOffset: Int, value: BigInt, littleEndian: Bool = False): Unit
+        target js sync "self_.setBigInt64(byteOffset_, value_, littleEndian_)"*/
+
+    /*setBigUint64(byteOffset: Int, value: BigInt, littleEndian: Bool = False): Unit
+        target js sync "self_.setBigUint64(byteOffset_, value_, littleEndian_)"*/
+
+    setUint64(byteOffset: Int, value: Int, littleEndian: Bool = True): Int
+        target js sync """
+            self_.setUint32(byteOffset_ + (littleEndian_ ? 4 : 0), (value_ >>> 16) >>> 16, littleEndian_)
+            self_.setUint32(byteOffset_ + (littleEndian_ ? 0 : 4), value_ & 0xffffffff, littleEndian_)
+        """
+
+    setInt64(byteOffset: Int, value: Int, littleEndian: Bool = True): Int
+        target js sync """
+            self_.setUint32(byteOffset_ + (littleEndian_ ? 4 : 0), (value_ >> 16) >> 16, littleEndian_)
+            self_.setUint32(byteOffset_ + (littleEndian_ ? 0 : 4), value_ & 0xffffffff, littleEndian_)
+        """
+
+    setFloat32(byteOffset: Int, value: Float, littleEndian: Bool = True): Unit
+        target js sync "self_.setFloat32(byteOffset_, value_, littleEndian_)"
+
+    setFloat64(byteOffset: Int, value: Float, littleEndian: Bool = True): Unit
+        target js sync "self_.setFloat64(byteOffset_, value_, littleEndian_)"
+
+    setInt16(byteOffset: Int, value: Int, littleEndian: Bool = True): Unit
+        target js sync "self_.setInt16(byteOffset_, value_, littleEndian_)"
+
+    setInt32(byteOffset: Int, value: Int, littleEndian: Bool = True): Unit
+        target js sync "self_.setInt32(byteOffset_, value_, littleEndian_)"
+
+    setInt8(byteOffset: Int, value: Int): Unit
+        target js sync "self_.setInt8(byteOffset_, value_)"
+
+    setUint16(byteOffset: Int, value: Int, littleEndian: Bool = True): Unit
+        target js sync "self_.setUint16(byteOffset_, value_, littleEndian_)"
+
+    setUint32(byteOffset: Int, value: Int, littleEndian: Bool = True): Unit
+        target js sync "self_.setUint32(byteOffset_, value_, littleEndian_)"
+
+    setUint8(byteOffset: Int, value: Int): Unit
+        target js sync "self_.setUint8(byteOffset_, value_)"
+
+    setAll(byteOffset: Int, buffer: Buffer): Unit
+        target js sync """
+            const sourceBuffer = new Uint8Array(buffer_.buffer, buffer_.byteOffset, buffer_.byteLength)
+            const targetBuffer = new Uint8Array(self_.buffer, self_.byteOffset, self_.byteLength)
+            targetBuffer.set(sourceBuffer, byteOffset_)
+        """
+
+    size(): Int
+        target js sync "return self_.byteLength"
+
+    shared(): Bool
+        target js sync "return typeof SharedArrayBuffer !== 'undefined' && self_.buffer instanceof SharedArrayBuffer"
+
+    view(begin: Int, end: Int): Buffer
+        target js sync "return new DataView(self_.buffer, self_.byteOffset + begin_, end_ - begin_)"
+
+    copy(): Buffer
+        target js sync "return new DataView(self_.buffer.slice(self_.byteOffset, self_.byteOffset + self_.byteLength))"
+
+    toString(encoding: String = "utf8"): String
+        target js sync """
+            if(encoding_ === "utf8") {
+                if(typeof TextDecoder.ffSingleton === 'undefined') TextDecoder.ffSingleton = new TextDecoder()
+                return TextDecoder.ffSingleton.decode(self_)
+            }
+            return new TextDecoder().decode(self_)
+        """
+
+    toByteArray(): Array[Int]
+        target js sync "return [...new Uint8Array(self_.buffer, self_.byteOffset, self_.byteLength)]"
+
+    toHex(): String
+        target js sync """
+            let hex = ''
+            for (let i = 0; i < self_.byteLength; i++) {
+                hex += self_.getUint8(i).toString(16).padStart(2, '0')
+            }
+            return hex
+        """
+
+    toBase64(): String
+        target js sync """
+            const view = new Uint8Array(self_.buffer, self_.byteOffset, self_.byteLength);
+            return btoa(String.fromCharCode(...view));
+        """
+
+}
+
+fromByteArray(array: Array[Int]): Buffer
+    target js sync "return new DataView(new Uint8Array(array_).buffer)"
+
+fromBufferArray(array: Array[Buffer]): Buffer
+    target js sync """
+        let length = 0
+        for(let b of array_) length += b.byteLength
+        const arrayBuffer = new ArrayBuffer(length);
+        const result = new Uint8Array(arrayBuffer)
+        let offset = 0
+        for(let b of array_) {
+            result.set(new Uint8Array(b.buffer, b.byteOffset, b.byteLength), offset)
+            offset += b.byteLength
+        }
+        return new DataView(arrayBuffer)
+    """
+
+fromHex(hex: String): Buffer
+    target js sync """
+        const hexValues = hexString.match(/.{1,2}/g) || []
+        const numbers = hexValues.map(value => parseInt(value, 16))
+        return new DataView(new Uint8Array(numbers).buffer)
+    """
+
+fromBase64(base64: String): Buffer
+    target js sync """
+        const binaryString = atob(base64_)
+        const dataView = new DataView(new ArrayBuffer(binaryString.length))
+        dataView.setUint8(binaryString.split('').map(char => char.charCodeAt(0)))
+        return dataView
+    """
+
+instance Buffer: Show {
+    show(value: Buffer): String {
+        """Buffer.fromHex("""" + value.toHex() + """")"""
+    }
+}
+
+instance Buffer: Equal {
+    equals(x: Buffer, y: Buffer): Bool
+        target js sync """
+            if(x_.buffer.byteLength !== y_.buffer.byteLength) return false
+            if(x_.buffer === y_.buffer) return true
+            for(let i = 0; i + 4 <= x_.buffer.byteLength; i += 4) {
+                if(x_.getInt32(i) !== y_.getInt32(i)) return false
+            }
+            for(; i < x_.buffer.byteLength; i++) {
+                if(x_.getUint8(i) !== y_.getUint8(i)) return false
+            }
+            return true
+        """
+}
+
+instance Buffer: Order {
+    compare(x: Buffer, y: Buffer): Ordering
+        target js sync """
+            if(x_.buffer === y_.buffer) return ff_core_Ordering.OrderingSame()
+            const minLength = Math.min(x_.buffer.byteLength, y_.buffer.byteLength)
+            for(let i = 0; i < minLength; i++) {
+                if(x_.getUint8(i) !== y_.getUint8(i)) {
+                    return ff_core_Ordering.fromInt_(x_.getUint8(i) - y_.getUint8(i))
+                }
+            }
+            return ff_core_Ordering.fromInt_(x_.buffer.byteLength - y_.buffer.byteLength)
+        """
+}