firefly-compiler 0.4.4

package/core/Serializable.ff

@@ -0,0 +1,173 @@
+data DeserializationChecksumException()
+
+serialize[T: Serializable](value: T, initialBufferSize: Int = 1024): Buffer {
+    let serialization = Serialization(Buffer.make(initialBufferSize), 0, 0)
+    serializeUsing(serialization, value)
+    serialization.autoResize(4)
+    serialization.buffer.setInt32(serialization.offset, serialization.checksum)
+    serialization.offset += 4
+    serialization.buffer.view(0, serialization.offset)
+}
+
+deserialize[T: Serializable](buffer: Buffer): T {
+    let serialization = Serialization(buffer, 0, 0)
+    let result = deserializeUsing(serialization)
+    let checksum = serialization.buffer.grabInt32(serialization.offset)
+    if(checksum != serialization.checksum) {
+        throw(DeserializationChecksumException)
+    }
+    result
+}
+
+trait T: Serializable {
+    serializeUsing(serialization: Serialization, value: T): Unit
+    deserializeUsing(serialization: Serialization): T
+}
+
+class Serialization(
+    mutable buffer: Buffer
+    mutable offset: Int
+    mutable checksum: Int
+)
+
+extend self: Serialization {
+    autoResize(minSpareCapacity: Int) {
+        if(self.offset + minSpareCapacity > self.buffer.size()) {
+            let minSize = self.buffer.size() + minSpareCapacity
+            let newBuffer = Buffer.make((self.buffer.size() * 2).max(minSize))
+            newBuffer.setAll(0, self.buffer)
+            self.buffer = newBuffer
+        }
+    }
+}
+
+instance Int: Serializable {
+    serializeUsing(serialization: Serialization, value: Int): Unit {
+        serialization.autoResize(8)
+        serialization.buffer.setInt64(serialization.offset, value)
+        serialization.offset += 8
+    }
+    deserializeUsing(serialization: Serialization): Int {
+        let result = serialization.buffer.grabInt64(serialization.offset)
+        serialization.offset += 8
+        result
+    }
+}
+
+instance Bool: Serializable {
+    serializeUsing(serialization: Serialization, value: Bool): Unit {
+        serialization.autoResize(1)
+        serialization.buffer.setUint8(serialization.offset, if(value) {1} else {0})
+        serialization.offset += 1
+    }
+    deserializeUsing(serialization: Serialization): Bool {
+        let result = serialization.buffer.grabUint8(serialization.offset)
+        serialization.offset += 1
+        result == 1
+    }
+}
+
+instance Array[T: Serializable]: Serializable {
+    serializeUsing(serialization: Serialization, value: Array[T]): Unit {
+        if(value.size() < 255) {
+            serialization.autoResize(1)
+            serialization.buffer.setUint8(serialization.offset, value.size())
+            serialization.offset += 1
+        } elseIf {value.size() < 1073741824} {
+            serialization.autoResize(1 + 4)
+            serialization.buffer.setUint8(serialization.offset, 255)
+            serialization.buffer.setUint32(1 + serialization.offset, value.size())
+            serialization.offset += 1 + 4
+        } else {
+            panic("Can't serialize arrays where size() >= 1073741824")
+        }
+        value.each {serializeUsing(serialization, _)}
+    }
+    deserializeUsing(serialization: Serialization): Array[T] {
+        let smallSize = serialization.buffer.grabUint8(serialization.offset)
+        if(smallSize != 255) {
+            serialization.offset += 1
+            Array.fillBy(smallSize) {_ => deserializeUsing(serialization)}
+        } else {
+            let size = serialization.buffer.grabUint32(serialization.offset + 1)
+            serialization.offset += 1 + 4
+            Array.fillBy(size) {_ => deserializeUsing(serialization)}
+        }
+    }
+}
+
+instance List[T: Serializable]: Serializable {
+    serializeUsing(serialization: Serialization, value: List[T]): Unit {
+        serializeUsing(serialization, value.toArray())
+    }
+    deserializeUsing(serialization: Serialization): List[T] {
+        deserializeUsing[Array[T]](serialization).toList()
+    }
+}
+
+instance Set[T: Serializable: Order]: Serializable {
+    serializeUsing(serialization: Serialization, value: Set[T]): Unit {
+        serializeUsing(serialization, value.toArray())
+    }
+    deserializeUsing(serialization: Serialization): Set[T] {
+        deserializeUsing[Array[T]](serialization).toSet()
+    }
+}
+
+instance Map[K: Serializable: Order, V: Serializable]: Serializable {
+    serializeUsing(serialization: Serialization, value: Map[K, V]): Unit {
+        serializeUsing(serialization, value.toArray())
+    }
+    deserializeUsing(serialization: Serialization): Map[K, V] {
+        deserializeUsing[Array[Pair[K, V]]](serialization).toMap()
+    }
+}
+
+instance String: Serializable {
+    serializeUsing(serialization: Serialization, value: String): Unit {
+        serialization.autoResize(1 + value.size())
+        serialization.buffer.setUint8(serialization.offset, value.size())
+        if(value.size() < 255 && internalSetLatin1(serialization.buffer, serialization.offset + 1, value)) {
+            serialization.offset += 1 + value.size()
+        } elseIf {value.size() < 1073741824} {
+            let stringBuffer = value.toBuffer()
+            serialization.autoResize(5 + stringBuffer.size())
+            serialization.buffer.setUint8(serialization.offset, 255)
+            serialization.buffer.setUint32(serialization.offset + 1, stringBuffer.size())
+            serialization.buffer.setAll(serialization.offset + 5, stringBuffer)
+            serialization.offset += 5 + stringBuffer.size()
+        } else {
+            panic("Can't serialize strings where size() >= 1073741824")
+        }
+    }
+    deserializeUsing(serialization: Serialization): String {
+        let smallSize = serialization.buffer.grabUint8(serialization.offset)
+        if(smallSize != 255) {
+            let result = internalGrabLatin1(serialization.buffer, serialization.offset + 1, smallSize)
+            serialization.offset += 1 + smallSize
+            result
+        } else {
+            let size = serialization.buffer.grabUint32(serialization.offset + 1)
+            let stringBuffer = serialization.buffer.view(serialization.offset + 5, serialization.offset + 5 + size)
+            serialization.offset += 5 + size
+            stringBuffer.toString()
+        }
+    }
+}
+
+
+internalSetLatin1(self: Buffer, byteOffset: Int, value: String): Bool
+    target js sync """
+        for(let i = 0; i < value_.length; i++) {
+            let charCode = value_.charCodeAt(i)
+            if(charCode >= 256) return false
+            self_.setUint8(byteOffset_ + i, charCode)
+        }
+        return true
+    """
+
+internalGrabLatin1(self: Buffer, byteOffset: Int, size: Int): String
+    target js sync """
+        const codeUnits = new Uint8Array(self_.buffer, self_.byteOffset + byteOffset_, size_)
+        return String.fromCharCode.apply(null, codeUnits)
+    """

package/core/Set.ff

@@ -0,0 +1,38 @@
+newtype Set[T](map: Map[T, Unit])
+
+empty[T](): Set[T] {
+    Set(Map.empty())
+}
+
+extend self[T: Order]: Set[T] {
+    add(value: T): Set[T] {Set(self.map.add(value, Unit))}
+    addAll(that: Set[T]): Set[T] {Set(self.map.addAll(that.map))}
+    remove(value: T): Set[T] {Set(self.map.remove(value))}
+    removeAll(that: Set[T]): Set[T] {Set(self.map.removeAll(that.map))}
+    contains(value: T): Bool {self.map.contains(value)}
+    size(): Int {self.map.size()}
+    toList(): List[T] {self.map.toList().map {_.first}}
+    toArray(): Array[T] {self.map.toArray().map {_.first}}
+    toStream(cycle: Bool = False): Stream[T] {self.map.toStream(cycle).map {_.first }}
+    each(body: T => Unit): Unit {self.map.each {| k, _ => body(k)}}
+    eachWhile(body: T => Bool): Bool {self.map.eachWhile {| k, _ => body(k)}}
+    find(body: T => Bool): Option[T] {self.map.find {| k, _ => body(k)}.map {_.first}}
+}
+
+instance Set[A: Equal: Order]: Equal {
+    equals(x: Set[A], y: Set[A]): Bool {
+        Equal.equals(x.toList(), y.toList())
+    }
+}
+
+instance Set[A: Order]: Order {
+    compare(x: Set[A], y: Set[A]): Ordering {
+        Ordering.compare(x.toList(), y.toList())
+    }
+}
+
+instance Set[A: Show: Order]: Show {
+    show(value: Set[A]): String {
+        Show.show(value.toList()) + ".toSet()"
+    }
+}

package/core/Show.ff

@@ -0,0 +1,43 @@
+trait T: Show {
+    show(value: T): String
+}
+
+instance Bool: Show {
+    show(value: Bool): String {
+        | False => "False"
+        | True => "True"
+    }
+}
+
+instance Nothing: Show {
+    show(value: Nothing): String {""}
+}
+
+instance Char: Show {
+    show(value: Char): String {value.toString()}
+}
+
+instance Int: Show {
+    show(value: Int): String {"" + value}
+}
+
+instance Float: Show {
+    show(value: Float): String {"" + value}
+}
+
+instance String: Show {
+    show(value: String): String
+        target js sync "return JSON.stringify(value_);"
+}
+
+instance List[T: Show]: Show {
+    show(value: List[T]): String {
+        "[" + value.map(show).join(", ") + "]"
+    }
+}
+
+instance Pair[A: Show, B: Show]: Show {
+    show(value: Pair[A, B]): String {
+        "Pair(" + show(value.first) + ", " + show(value.second) + ")"
+    }
+}

package/core/Stack.ff

@@ -0,0 +1,263 @@
+class Stack[T] {}
+
+make[T](): Stack[T]
+    target js sync "return {array: []}"
+
+fill[T](size: Int, value: T): Array[T]
+    target js sync """
+        return {array: new Array(size_).fill(value_)};
+    """
+
+fillBy[T](size: Int, body: Int => T): Array[T]
+    target js sync """
+        return {array: Array.from({length: size_}, (_, i) => body_(i))};
+    """
+
+range(size: Int): Array[Int]
+    target js sync """
+        return {array: Array.from({length: size_}, (_, i) => i)};
+    """
+
+extend self[T]: Stack[T] {
+
+    isEmpty(): Bool
+        target js sync "return self_.array.length === 0"
+
+    size(): Int
+        target js sync "return self_.array.length"
+
+    get(index: Int): Option[T]
+        target js sync """
+            return index_ >= 0 && index_ < self_.array.length
+                ? ff_core_Option.Some(self_.array[index_])
+                : ff_core_Option.None()
+        """
+
+    grab(index: Int): T
+        target js sync """
+            if(index_ < 0 || index_ >= self_.array.length) {
+                ff_core_Try.internalThrowGrabException_()
+            }
+            return self_.array[index_]
+        """
+
+    grabFirst(): T { self.grab(0) }
+
+    grabLast(): T { self.grab(self.size() - 1) }
+
+    first(): Option[T]
+        target js sync """
+            return self_.array.length > 0
+                ? ff_core_Option.Some(self_.array[0])
+                : ff_core_Option.None()
+        """
+
+    last(): Option[T]
+        target js sync """
+            return self_.array.length > 0
+                ? ff_core_Option.Some(self_.array[self_.array.length - 1])
+                : ff_core_Option.None()
+        """
+
+    push(value: T): Unit
+        target js sync "self_.array.push(value_)"
+
+    pushAll(value: Stack[T]): Unit
+        target js sync "self_.array.push(...value_.array)"
+
+    pushArray(value: Array[T]): Unit
+        target js sync "self_.array.push(...value_)"
+
+    pop(): Option[T]
+        target js sync """
+            return self_.array.length > 0
+                ? ff_core_Option.Some(self_.array.pop())
+                : ff_core_Option.None()
+        """
+
+    set(index: Int, value: T): Unit
+        target js sync """
+            if(index_ < 0 || index_ > self_.array.length) {
+                ff_core_Try.internalThrowGrabException_()
+            }
+            self_.array[index_] = value_
+        """
+
+    modify(index: Int, body: T => T): Unit
+        target js sync """
+            if(index_ < 0 || index_ >= self_.array.length) {
+                ff_core_Try.internalThrowGrabException_()
+            }
+            self_.array[index_] = body_(self_.array[index_])
+        """
+        target js async """
+            if(index_ < 0 || index_ >= self_.array.length) {
+                ff_core_Try.internalThrowGrabException_()
+            }
+            self_.array[index_] = await body_(self_.array[index_], $task)
+        """
+
+    fill(value: T, start: Int = 0, end: Int = 9007199254740991): Unit
+        target js sync """
+            self.array.fill(value_, start, end);
+        """
+
+    copy(target: Int, start: Int, end: Int): Unit
+        target js sync """
+            self.array.copyWithin(target, start, end);
+        """
+
+    delete(start: Int, deleteCount: Int): Unit
+        target js sync """
+            self.array.splice(start, deleteCount_);
+        """
+
+    insert(start: Int, value: T, deleteCount: Int = 0): Unit
+        target js sync """
+            self.array.splice(start, deleteCount_, value_);
+        """
+
+    insertAll(start: Int, value: Stack[T], deleteCount: Int = 0): Unit
+        target js sync """
+            self.array.splice(start, deleteCount_, ...value_.array);
+        """
+
+    insertArray(start: Int, value: Array[T], deleteCount: Int = 0): Unit
+        target js sync """
+            self.array.splice(start, deleteCount_, ...value_);
+        """
+
+    each(body: T => Unit): Unit
+        target js sync """
+            return self_.array.forEach(body_);
+        """
+        target js async """
+            for(let i = 0; i < self_.array.length; i++) {
+                await body_(self_.array[i], $task)
+            }
+        """
+
+    eachWhile(body: T => Bool): Unit
+        target js sync "for(const value of self_.array) if(!body_(value)) break"
+        target js async "for(const value of self_.array) if(!await body_(value, $task)) break"
+
+    all(body: T => Bool): Bool {
+        mutable result = True
+        self.eachWhile {x =>
+            result = body(x)
+            result
+        }
+        result
+    }
+
+    any(body: T => Bool): Bool {
+        mutable result = False
+        self.eachWhile {x =>
+            result = body(x)
+            (!result)
+        }
+        result
+    }
+
+    indexWhere(body: T => Bool): Option[Int] {
+        mutable i = -1
+        mutable result = False
+        self.eachWhile {x =>
+            i += 1
+            result = body(x)
+            (!result)
+        }
+        if(result) {i}
+    }
+
+    drain(): Array[T]
+        target js sync "const result = self_.array; self_.array = []; return result"
+
+    toArray(start: Int = 0, end: Int = 9007199254740991): Array[T]
+        target js sync """return self_.array.slice(start_, end_)"""
+
+    toList(start: Int = 0, end: Int = 9007199254740991): List[T]
+        target js sync """
+            if(start_ < 0) start_ = self_.array.length + start_
+            if(end_ < 0) end_ = self_.array.length + start_
+            start_ = Math.max(0, Math.min(start_, self_.array.length))
+            end_ = Math.max(0, Math.min(end_, self_.array.length))
+            let result = ff_core_List.Empty();
+            for(let i = end_ - 1; i >= start_; i--) {
+                result = ff_core_List.Link(self_.array[i], result);
+            }
+            return result;
+        """
+
+    toStream(start: Int = 0, end: Int = 9007199254740991): Stream[T] {
+        self.toArray(start, end).toStream()
+    }
+
+    reverse(): Unit
+        target js sync "self_.array.reverse()"
+
+    sortBy[S: Order](body: T => S): Unit {
+        self.sortWith {Ordering.compare(body(_), body(_))}
+    }
+
+    sortWith(ordering: (T, T) => Ordering): Unit {
+        sortRange(self, ordering, 0, self.size())
+    }
+        target js sync "self_.array.sort((x, y) => ff_core_Ordering.Ordering_toInt(ordering_(x, y)))"
+
+}
+
+extend self[T: Order]: Stack[T] {
+
+    sort(): Unit {
+        self.sortWith(Ordering.compare)
+    }
+
+}
+
+extend self: Stack[String] {
+
+    join(separator: String = ""): String
+        target js sync "return self_.array.join(separator_)"
+
+}
+
+instance Stack[T: Show]: Show {
+    show(value: Stack[T]): String {
+        let stack = Stack.make()
+        stack.push("[")
+        value.each {x =>
+            if(stack.size() > 1) {stack.push(", ")}
+            stack.push(Show.show(x))
+        }
+        stack.push("].toStack()")
+        stack.join()
+    }
+}
+
+sortRange[T](stack: Stack[T], compare: (T, T) => Ordering, start: Int, end: Int): Unit {
+    if(end - start < 2) {} else:
+
+    mutable middle = start + ((end - start) / 2)
+    sortRange(stack, compare, start, middle)
+    sortRange(stack, compare, middle, end)
+
+    mutable i = start
+    mutable j = middle
+    while {i < middle && j < end} {
+        if(compare(stack.grab(i), stack.grab(j)) != OrderingAfter) {
+            i += 1
+        } else {
+            let value = stack.grab(j)
+            mutable k = j
+            while {k > i} {
+                stack.set(k, stack.grab(k - 1))
+                k -= 1
+            }
+            stack.set(i, value)
+            i += 1
+            middle += 1
+            j += 1
+        }
+    }
+}