firefly-compiler 0.4.4

package/core/Stream.ff

@@ -0,0 +1,406 @@
+capability Stream[T](
+    next: () => Option[T]
+    close: () => Unit
+)
+
+make[T](next: () => Option[T], close: () => Unit = {}): Stream[T] {
+    Stream(next, close)
+}
+
+init[T](body: () => Stream[T]): Stream[T] {
+    mutable initialized = False
+    mutable stream = Stream {None} {}
+    Stream({
+        if(initialized) {
+            stream.next()
+        } else {
+            initialized = True
+            stream = body()
+            stream.next()
+        }
+    }, {
+        initialized = True
+        stream.close()
+    })
+}
+
+extend self[T]: Stream[T] {
+
+    addAll(that: Stream[T]): Stream[T] {
+        mutable firstDone = False
+        Stream {
+            if(firstDone) {
+                that.next()
+            } else {
+                self.next().orElse {
+                    firstDone = True
+                    that.next()
+                }
+            }
+        } {
+            try {
+                self.close()
+            } finally {
+                that.close()
+            } grab()
+        }
+    }
+
+    map[S](body: T => S): Stream[S] {
+        Stream {
+            self.next().map(body)
+        } {
+            self.close()
+        }
+    }
+
+    flatMap[S](body: T => Stream[S]): Stream[S] {
+        mutable inner = Stream {None} {}
+        Stream {
+            mutable result = None
+            while {result.isEmpty()} {
+                inner.next().{
+                    | Some(_)@i => result = Some(i)
+                    | None =>
+                        self.next().{
+                            | None => result = Some(None)
+                            | Some(o) => 
+                                inner.close()
+                                inner = body(o)
+                        }
+                }
+            }
+            result.grab()
+        } {
+            try {
+                inner.close()
+            } finally {
+                self.close()
+            } grab()
+        }
+    }
+
+    collect[S](body: T => Option[S]): Stream[S] {
+        self.flatMap {body(_).toStream()}
+    }
+
+    filter(body: T => Bool): Stream[T] {
+        Stream {
+            mutable result = None
+            while {result.isEmpty()} {
+                self.next().{
+                    | Some(x) {body(x)} => result = Some(Some(x))
+                    | Some(_) =>
+                    | None => result = Some(None)
+                }
+            }
+            result.grab()
+        } {
+            self.close()
+        }
+    }
+
+    zip[S](that: Stream[S]): Stream[Pair[T, S]] {
+        Stream {
+            Pair(self.next(), that.next()).{
+                | Pair(Some(x), Some(y)) => Some(Pair(x, y))
+                | _ => None
+            }
+        } {
+            try {
+                self.close()
+            } finally {
+                that.close()
+            } grab()
+        }
+    }
+
+    takeFirst(count: Int = 1): Stream[T] {
+        mutable remaining = count
+        Stream {
+            self.next().filter {_ =>
+                remaining -= 1
+                remaining >= 0
+            }
+        } {
+            self.close()
+        }
+    }
+
+    dropFirst(count: Int = 1): Stream[T] {
+        mutable remaining = count
+        Stream {
+            while {remaining >= 1} {
+                self.next().{
+                    | None => remaining = 0
+                    | Some(_) => remaining -= 1
+                }
+            }
+            self.next()
+        } {
+            self.close()
+        }
+    }
+
+    takeWhile(body: T => Bool): Stream[T] {
+        mutable done = False
+        Stream {
+            if(done) {None} else:
+            self.next().{
+                | None =>
+                    done = True
+                    None
+                | Some(x)@o =>
+                    done = !body(x)
+                    if(done) {None} else {o}
+            }
+        } {
+            self.close()
+        }
+    }
+
+    dropWhile(body: T => Bool): Stream[T] {
+        mutable done = False
+        Stream {
+            if(!done) {
+                mutable result = None
+                while {!done} {
+                    self.next().{
+                        | None => done = True
+                        | Some(x) {body(x)} =>
+                        | Some(x)@o =>
+                            result = o
+                            done = True
+                    }
+                }
+                result
+            } else {
+                self.next()
+            }
+        } {
+            self.close()
+        }
+    }
+
+    pairs(): Stream[Pair[Int, T]] {
+        mutable i = 0
+        self.map {x =>
+            let r = Pair(i, x)
+            i += 1
+            r
+        }
+    }
+
+    chunked(size: Int): Stream[List[T]] {
+        mutable remaining = size
+        Stream {
+            if(remaining <= 0) {None} else:
+            self.next().{
+                | None =>
+                    remaining = -1
+                    None
+                | Some(x) =>
+                    mutable list = [x]
+                    remaining -= 1
+                    while {remaining > 0} {
+                        remaining -= 1
+                        self.next().{
+                            | None => remaining = -1
+                            | Some(x) => list = [x, ...list]
+                        }
+                    }
+                    if(remaining != -1) {remaining = size}
+                    Some(list.reverse())
+            }
+        } {
+            self.close()
+        }
+    }
+
+    // Consuming methods
+
+    use[R](body: Stream[T] => R): R {
+        try {
+            body(self)
+        } finally {
+            self.close()
+        } grab()
+    }
+
+    each(body: T => Unit): Unit {
+        try {
+            mutable done = False
+            while {!done} {
+                self.next().{
+                    | None => done = True
+                    | Some(x) => body(x)
+                }
+            }
+        } finally {
+            self.close()
+        } grab()
+    }
+
+    eachWhile(body: T => Bool): Unit {
+        try {
+            mutable done = False
+            while {!done} {
+                self.next().{
+                    | None => done = True
+                    | Some(x) => done = !body(x)
+                }
+            }
+        } finally {
+            self.close()
+        } grab()
+    }
+
+    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
+    }
+
+    first(): Option[T] {
+        try {
+            self.next()
+        } finally {
+            self.close()
+        } grab()
+    }
+
+    last(): Option[T] {
+        try {
+            mutable done = False
+            mutable result = None
+            while {!done} {
+                self.next().{
+                    | None => done = True
+                    | Some(x)@o => result = o
+                }
+            }
+            result
+        } finally {
+            self.close()
+        } grab()
+    }
+
+    grabFirst(): T {
+        self.first().else {panic("grabFirst() on empty iterator")}
+    }
+
+    grabLast(): T {
+        self.last().else {panic("grabLast() on empty iterator")}
+    }
+
+    collectFirst[R](body: T => Option[R]): Option[R] {
+        try {
+            mutable done = False
+            mutable result = None
+            while {!done} {
+                self.next().{
+                    | None => done = True
+                    | Some(x) =>
+                        body(x).{
+                            | None =>
+                            | o =>
+                                done = True
+                                result = o
+                        }
+                }
+            }
+            result
+        } finally {
+            self.close()
+        } grab()
+    }
+
+    find(body: T => Bool): Option[T] {
+        self.filter(body).first()
+    }
+
+    foldLeft[R](initial: R, body: (R, T) => R): R {
+        mutable result = initial
+        self.each {result = body(result, _)}
+        result
+    }
+
+    toStack(): Stack[T] {
+        let stack = Stack.make()
+        self.each {stack.push(_)}
+        stack
+    }
+
+    toArray(): Array[T] {
+        self.toStack().drain()
+    }
+
+    toList(): List[T] {
+        self.toStack().toList()
+    }
+
+}
+
+extend self[T]: Stream[Stream[T]] {
+    flatten(): Stream[T] {
+        self.flatMap {_}
+    }
+}
+
+extend self[T: Order]: Stream[T] {
+    toSet(): Set[T] {
+        self.toArray().toSet()
+    }
+}
+
+extend self[K: Order, V]: Stream[Pair[K, V]] {
+    toMap(): Map[K, V] {
+        self.toArray().toMap()
+    }
+}
+
+extend self: Stream[Buffer] {
+
+    toBuffer(): Buffer {
+        let builder = Stack.make()
+        self.each {builder.push(_)}
+        Buffer.fromBufferArray(builder.drain())
+    }
+
+    toString(encoding: String = "utf8"): String {
+        self.toBuffer().toString(encoding)
+    }
+
+    readBytes(bytes: Int): Pair[Array[Buffer], Stream[Buffer]] {
+        if(bytes <= 0) {Pair([].toArray(), self)} else:
+        let buffers = Stack.make()
+        mutable buffer = self.next().grab()
+        mutable taken = 0
+        mutable remainder = None
+        while {remainder == None} {
+            let needed = bytes - taken
+            if(needed > buffer.size()) {
+                buffers.push(buffer)
+                taken += buffer.size()
+                buffer = self.next().grab()
+            } else {
+                buffers.push(buffer.view(0, needed))
+                remainder = Some(buffer.view(needed, buffer.size()))
+            }
+        }
+        Pair(buffers.drain(), remainder.toStream().addAll(self))
+    }
+
+}

package/core/String.ff

@@ -0,0 +1,175 @@
+data String {}
+
+extend self: String {
+
+    size(): Int
+        target js sync "return self_.length"
+
+    grab(index: Int): Char
+        target js sync """
+            if(index_ < 0 || index_ >= self_.length) {
+                ff_core_Try.internalThrowGrabException_()
+            }
+            return self_.charCodeAt(index_)
+        """
+
+    replace(needle: String, replacement: String): String
+        target js sync "return self_.replaceAll(needle_, replacement_)"
+
+    replaceFirst(needle: String, replacement: String): String
+        target js sync "return self_.replace(needle_, replacement_)"
+
+    reverse(): String
+        target js sync "return [...self_].reverse().join('')"
+
+    lower(): String
+        target js sync "return self_.toLowerCase()"
+
+    upper(): String
+        target js sync "return self_.toUpperCase()"
+
+    dropWhile(p: Char => Bool): String
+        target js sync """
+            let i = 0
+            for(; i < self_.length && p_(self_.codePointAt(i)); i++);
+            return self_.slice(i)
+        """
+        target js async """
+            let i = 0
+            for(; i < self_.length && await p_(self_.codePointAt(i), $task); i++);
+            return self_.slice(i)
+        """
+
+    takeWhile(p: Char => Bool): String
+        target js sync """
+            let i = 0
+            for(; i < self_.length && p_(self_.codePointAt(i)); i++);
+            return self_.slice(0, i)
+        """
+        target js async """
+            let i = 0
+            for(; i < self_.length && await p_(self_.codePointAt(i), $task); i++);
+            return self_.slice(0, i)
+        """
+
+    slice(from: Int, until: Int): String
+        target js sync "return self_.slice(from_, until_)"
+
+    split(char: Char): Array[String]
+        target js sync "return self_.split(String.fromCharCode(char_))"
+
+    splitFirst(char: Char): Option[Pair[String, String]]
+        target js sync """
+            const array = self_.split(String.fromCharCode(char_), 2)
+            return array.length === 2
+                ? ff_core_Option.Some(ff_core_Pair.Pair(array[0], array[1]))
+                : ff_core_Option.None()
+        """
+
+    lines(): List[String]
+        target js sync """
+            return ff_core_Array.Array_toList(self_.split(
+                new RegExp("[" + String.fromCharCode(13) + "]?[" + String.fromCharCode(10) + "]", "g")
+            ))
+        """
+
+    dropFirst(count: Int = 1): String
+        target js sync "return self_.slice(count_)"
+
+    dropLast(count: Int = 1): String
+        target js sync "return self_.slice(0, self_.length - count_)"
+
+    getInt(): Option[Int]
+        target js sync """
+            if(self_.length == 0) {
+                return ff_core_Option.None()
+            }
+            for(let i = 0; i < self_.length; i++) {
+                const c = self_.codePointAt(i)
+                if(c < 48 || c > 57) ff_core_Option.None()
+            }
+            return ff_core_Option.Some(parseInt(self_, 10));
+        """
+
+    grabInt(): Int
+        target js sync """
+            if(self_.length == 0) {
+                ff_core_Try.internalThrowGrabException_()
+            }
+            for(let i = 0; i < self_.length; i++) {
+                const c = self_.codePointAt(i)
+                if(c < 48 || c > 57) ff_core_Try.internalThrowGrabException_()
+            }
+            return parseInt(self_, 10);
+        """
+
+    first(): Option[Char]
+        target js sync """
+            return self_.length > 0
+                ? ff_core_Option.Some(self_.charCodeAt(0))
+                : ff_core_Option.None()
+        """
+
+    last(): Option[Char]
+        target js sync """
+            return self_.length > 0
+                ? ff_core_Option.Some(self_.charCodeAt(self_.length - 1))
+                : ff_core_Option.None()
+        """
+
+    grabFirst(): Char { self.first().else {Try.internalThrowGrabException()} }
+
+    grabLast(): Char { self.last().else {Try.internalThrowGrabException()} }
+
+    contains(substring: String): Bool
+        target js sync "return self_.includes(substring_)"
+
+    startsWith(prefix: String, offset: Int = 0): Bool
+        target js sync "return self_.startsWith(prefix_, offset_)"
+
+    endsWith(prefix: String): Bool
+        target js sync "return self_.endsWith(prefix_)"
+
+    removeFirst(prefix: String): Option[String] {
+        if(self.startsWith(prefix)) {Some(self.dropFirst(prefix.size()))} else {None}
+    }
+
+    removeLast(suffix: String): Option[String] {
+        if(self.endsWith(suffix)) {Some(self.dropLast(suffix.size()))} else {None}
+    }
+
+    any(body: Char => Bool): Bool
+        target js sync """
+            for(let i = 0; i < self_.length; i++) {
+                if(body_(self_.charCodeAt(i))) return true;
+            }
+            return false;
+        """
+        target js async """
+            for(let i = 0; i < self_.length; i++) {
+                if(await body_(self_.charCodeAt(i), $task)) return true;
+            }
+            return false;
+        """
+
+    all(body: Char => Bool): Bool
+        target js sync """
+            for(let i = 0; i < self_.length; i++) {
+                if(!body_(self_.charCodeAt(i))) return false;
+            }
+            return true;
+        """
+        target js async """
+            for(let i = 0; i < self_.length; i++) {
+                if(!await body_(self_.charCodeAt(i), $task)) return false;
+            }
+            return true;
+        """
+
+    toBuffer(): Buffer
+        target js sync """
+            const encoded = new TextEncoder().encode(self_)
+            return new DataView(encoded.buffer, encoded.byteOffset, encoded.byteLength)
+        """
+
+}

package/core/StringMap.ff

@@ -0,0 +1,85 @@
+class StringMap[V] {}
+
+make[V](): StringMap[V]
+    target js sync "return new Map()"
+
+extend self[V]: StringMap[V] {
+
+    get(key: String): Option[V]
+        target js sync "return self_.has(key_) ? ff_core_Option.Some(self_.get(key_)) : ff_core_Option.None()"
+
+    grab(key: String): V
+        target js sync """
+            const result = self_.get(key_)
+            if(key_ === void 0 && !self_.has(key_)) {
+                ff_core_Try.internalThrowGrabException_()
+            }
+            return result
+        """
+
+    set(key: String, value: V): Unit
+        target js sync "self_.set(key_, value_)"
+
+    has(key: String): Bool
+        target js sync "return self_.has(key_)"
+
+    remove(key: String): Bool
+        target js sync "return self_.delete(key_)"
+
+    clear(): Unit
+        target js sync "self_.clear()"
+
+    size(): Int
+        target js sync "return self_.size"
+
+    each(body: (String, V) => Unit): Bool
+        target js sync "return self_.forEach((v, k) => body_(k, v))"
+        target js async "for(const [k, v] of self_) await body_(k, v)"
+
+    eachWhile(body: (String, V) => Bool): Bool
+        target js sync "for(const [k, v] of self_) if(!body_(k, v)) break"
+        target js async "for(const [k, v] of self_) if(!await body_(k, v)) break"
+
+    toStack(): Stack[Pair[String, V]] {
+        let stack = Stack.make()
+        self.each {k, v => stack.push(Pair(k, v))}
+        stack
+    }
+
+    toArray(): Array[Pair[String, V]] {
+        self.toStack().drain()
+    }
+
+    toList(): List[Pair[String, V]] {
+        self.toArray().toList()
+    }
+
+    toStream(): Stream[Pair[String, V]] {
+        self.toArray().toStream()
+    }
+
+    toMap(): Map[String, V] {
+        self.toArray().toMap()
+    }
+
+    keys(): List[String] {
+        let stack = Stack.make()
+        self.each {k, v => stack.push(k)}
+        stack.toList()
+    }
+
+    values(): List[V] {
+        let stack = Stack.make()
+        self.each {k, v => stack.push(v)}
+        stack.toList()
+    }
+
+    copy(): StringMap[V]
+        target js sync "return new Map(self_)"
+
+    getOrSet(key: String, body: () => V): V {
+        if(!self.has(key)) {self.set(key, body())}
+        self.grab(key)
+    }
+            
+}