firefly-compiler 0.4.6 → 0.4.8

package/compiler/Compiler.ff

@@ -94,6 +94,7 @@ coreImports: List[DImport] =
         "Ordering"
         "Pair"
         "Path"
+        "Random"
         "Serializable"
         "Set"
         "Show"
@@ -105,6 +106,7 @@ coreImports: List[DImport] =
         "Task"
         "Try"
         "Unit"
+        "WebSocket"
     ].map {moduleName =>
         DImport(
             at = Location("<prelude>", 1, 1)

package/compiler/Deriver.ff

@@ -516,6 +516,12 @@ extend self: Deriver {
             let variantName = modulePrefix + "." + variant.name
             let fields = [...declaration.commonFields, ...variant.fields]
             let updateChecksum = self.makeUpdateChecksum(at, variantName, declaration, variant)
+            let autoResize = self.makeMethodCall(
+                at = at
+                target = EVariable(at, "serialization")
+                methodName = "autoResize"
+                arguments = [EInt(at, "1")]
+            )
             let setVariantIndex = self.makeMethodCall(
                 at = at
                 target = EField(at, False, EVariable(at, "serialization"), "buffer")
@@ -533,6 +539,7 @@ extend self: Deriver {
                 patterns = [wildcardPattern, PVariantAs(at, variantName, at, Some("v"))]
                 guards = []
                 body = [
+                    autoResize
                     setVariantIndex
                     EAssignField(at, "+", EVariable(at, "serialization"), "offset", EInt(at, "1"))
                     ...fieldSerializations

package/core/Array.ff

@@ -14,6 +14,13 @@ fillBy[T](size: Int, body: Int => T): Array[T]
     target js sync """
         return Array.from({length: size_}, (_, i) => body_(i));
     """
+    target js async """
+        const array = new Array(size_);
+        for(let i = 0; i < size_; i++) {
+            array[i] = await(body_(_i));
+        }
+        return array;
+    """
 
 range(size: Int): Array[Int]
     target js sync """
@@ -46,13 +53,19 @@ extend self[T]: Array[T] {
             return self_[index_]
         """
 
-    first(): Option[T] { self.get(0) }
+    first(): Option[T] {self.get(0)}
+
+    last(): Option[T] {self.get(self.size() - 1)}
+
+    grabFirst(): T {self.grab(0)}
 
-    last(): Option[T] { self.get(self.size() - 1) }
+    grabLast(): T {self.grab(self.size() - 1)}
 
-    grabFirst(): T { self.grab(0) }
+    takeFirst(count: Int = 1): Array[T]
+        target js sync "return self_.slice(0, count_)"
 
-    grabLast(): T { self.grab(self.size() - 1) }
+    takeLast(count: Int = 1): Array[T]
+        target js sync "return self_.slice(-count_)"
 
     dropFirst(count: Int = 1): Array[T]
         target js sync "return self_.slice(count_)"

package/core/AssetSystem.ff

@@ -22,7 +22,7 @@ extend self: AssetSystem {
     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))
+            | Pair(p, s) {p.startsWith(prefix)} => Some(Pair(p.dropFirst(prefix.size() - 1), s))
             | _ => None
         }
         AssetSystem(streams.toMap())

package/core/BrowserSystem.ff

@@ -5,10 +5,37 @@ extend self: BrowserSystem {
     httpClient(): HttpClient
         target js async "return null"
 
+    webSocket(url: String): WebSocket {
+        WebSocket.internalOpenBrowserWebSocket(self, url)
+    }
+    
     mainTask(): Task
         target js async "return self_.task_"
 
     js(): JsSystem
         target js async "return typeof globalThis !== 'undefined' ? globalThis : window"
+        
+    url(): String
+        target js async """
+            return location.href;
+        """
+    
+    urlPath(): String
+        target js async """
+            return location.pathname;
+        """
 
+    urlQuery(name: String): Option[String]
+        target js async """
+            const param = new URLSearchParams(location.search).get(name_)
+            if(param == null) return ff_core_Option.None();
+            return ff_core_Option.Some(param);
+        """
+
+    urlFragment(): Option[String]
+        target js async """
+            if(!location.hash.startsWith('#')) return ff_core_Option.None();
+            return ff_core_Option.Some(location.hash.slice(1));
+        """
+               
 }

package/core/List.ff

@@ -142,6 +142,10 @@ extend self[T]: List[T] {
                 tailcall tail.each(body)
         }
     }
+    
+    eachWhile(body: T => Bool): Bool {
+        self.all(body)
+    }
 
     all(body: T => Bool): Bool {
         self.{

package/core/Lock.ff

@@ -76,7 +76,7 @@ extend self: LockCondition {
             }
             const level = self_.lock.level
             self_.lock.level = 1
-            await ff_core.Lock_release$(self_.lock)
+            await ff_core_Lock.Lock_release$(self_.lock)
             try {
                 await new Promise((resolve, reject) => {
                     $task.controller.signal.addEventListener('abort', reject)
@@ -92,7 +92,7 @@ extend self: LockCondition {
                 let acquired = false
                 while(!acquired) {
                     try {
-                        await ff_core.Lock_acquire$(self_.lock)
+                        await ff_core_Lock.Lock_acquire$(self_.lock)
                         self_.lock.level = level
                         acquired = true
                     } catch(e) {

package/core/Random.ff

@@ -0,0 +1,148 @@
+class Random {}
+
+// Using Alea PRNG by Johannes Baagøe <baagoe@baagoe.com>, 2010
+// Typical use: Random.seedInstant(system.task().now())
+
+seedInt(seed: Int): Random {
+    seedFloat(seed.toFloat())
+}
+
+seedFloat(seed: Float): Random {
+    let buffer = Buffer.make(8)
+    buffer.setFloat64(0, seed)
+    seedBuffer(buffer)
+}
+
+seedInstant(seed: Instant): Random {
+    seedFloat(seed.since1970.seconds)
+}
+
+seedBuffer(buffer: Buffer): Random
+    target js sync """
+        var n = 0xefc8249d;
+        function mash(data) {
+            for(var i = 0; i < data.byteLength; i++) {
+                n += data.getUint8(i);
+                var h = 0.02519603282416938 * n;
+                n = h >>> 0;
+                h -= n;
+                h *= n;
+                n = h >>> 0;
+                h -= n;
+                n += h * 0x100000000; // 2^32
+            }
+            return (n >>> 0) * 2.3283064365386963e-10; // 2^-32
+        }
+        var space = new DataView(new Uint8Array([32]).buffer);
+        var r = {
+            s0: mash(space),
+            s1: mash(space),
+            s2: mash(space),
+            c: 1,
+            spareGauss: NaN
+        };
+        r.s0 -= mash(buffer_);
+        if(r.s0 < 0) r.s0 += 1;
+        r.s1 -= mash(buffer_);
+        if(r.s1 < 0) r.s1 += 1;
+        r.s2 -= mash(buffer_);
+        if(r.s2 < 0) r.s2 += 1;
+        return r;
+    """
+
+extend self: Random {
+    
+    copy(): Random
+        target js sync """
+            return {...self_};
+        """
+
+    nextInt(from: Int, until: Int): Int
+        target js sync """
+            return Random_nextFloat(self_, from_, until_) | 0;
+        """
+
+    nextFloat(from: Float, until: Float): Float
+        target js sync """
+            var t = 2091639 * self_.s0 + self_.c * 2.3283064365386963e-10; // 2^-32
+            self_.s0 = self_.s1;
+            self_.s1 = self_.s2;
+            var uniform = self_.s2 = t - (self_.c = t | 0);
+            return from_ + uniform * (until_ - from_);
+        """
+        
+    nextBool(): Bool {
+        self.nextInt(0, 2) == 0
+    }
+
+    nextBytes(buffer: Buffer, start: Int, stop: Int): Unit {
+        start.until(stop).each {i =>
+            buffer.setUint8(i, self.nextInt(0, 256))
+        }
+    }
+
+    nextGauss(mean: Float, standardDeviation: Float): Float
+        target js sync """
+            if(!isNaN(self_.spareGauss)) {
+                const result = self_.spareGauss * standardDeviation_ + mean_;
+                self_.spareGauss = NaN;
+                return result;
+            } else {
+                let u = 0.5, v = 0.5, s = 0.5;
+                do {
+                    u = Random_nextFloat(self_, 0.0, 1.0) * 2 - 1;
+                    v = Random_nextFloat(self_, 0.0, 1.0) * 2 - 1;
+                    s = u * u + v * v;
+                } while(s >= 1 || s == 0);
+                s = Math.sqrt(-2.0 * Math.log(s) / s);
+                self_.spareGauss = v * s;
+                return mean_ + standardDeviation_ * u * s;
+            }
+        """
+
+    shuffleStack[T](stack: Stack[T]): Unit {
+        0.until(stack.size() - 1).each {i =>
+            let j = self.nextInt(0, stack.size() - i) + i
+            let value = stack.grab(i)
+            stack.set(i, stack.grab(j))
+            stack.set(j, value)
+        }
+    }
+    
+    shuffleArray[T](array: Array[T]): Array[T] {
+        let stack = array.toStack()
+        self.shuffleStack(array.toStack())
+        stack.drain()
+    }
+    
+    shuffleList[T](list: List[T]): List[T] {
+        let stack = list.toStack()
+        self.shuffleStack(list.toStack())
+        stack.toList()
+    }
+
+    sampleStack[T](count: Int, stack: Stack[T], body: T => Unit): Unit {
+        self.shuffleArray(stack.toArray()).takeFirst(count).each {body(_)}
+    }
+
+    sampleArray[T](count: Int, array: Array[T]): Array[T] {
+        self.shuffleArray(array).takeFirst(count)
+    }
+    
+    sampleList[T](count: Int, list: List[T]): List[T] {
+        self.shuffleList(list).takeFirst(count)
+    }
+
+    grabStack[T](stack: Stack[T]): T {
+        stack.grab(self.nextInt(0, stack.size()))
+    }
+
+    grabArray[T](array: Array[T]): T {
+        array.grab(self.nextInt(0, array.size()))
+    }
+
+    grabList[T](list: Stack[T]): T {
+        list.grab(self.nextInt(0, list.size()))
+    }
+
+}

package/core/SourceLocation.ff

@@ -39,3 +39,30 @@ extend self: SourceLocation {
     }
 
 }
+
+instance SourceLocation: Show {
+    show(self: SourceLocation): String {
+        self.location
+    }
+}
+
+instance SourceLocation: Equal {
+    equals(a: SourceLocation, b: SourceLocation): Bool {
+        a.location == b.location
+    }
+}
+
+instance SourceLocation: Order {
+    compare(a: SourceLocation, b: SourceLocation): Ordering {
+        Ordering.compare(a.location, b.location)
+    }
+}
+
+instance SourceLocation: Serializable {
+    serializeUsing(serialization: Serialization, self: SourceLocation) {
+        Serializable.serializeUsing(serialization, self.location)
+    }
+    deserializeUsing(serialization: Serialization): SourceLocation {
+        SourceLocation(Serializable.deserializeUsing(serialization))
+    }
+}

package/core/Task.ff

@@ -46,6 +46,9 @@ extend self: Task {
         target js async """
             self_.controller.abort()
         """
+        target js sync """
+            self_.controller.abort()
+        """
 
     // Create a blocking channel with the specified capacity. The channel is not tied to the task.
     channel[T](capacity: Int = 0): Channel[T]

package/core/WebSocket.ff

@@ -0,0 +1,127 @@
+capability WebSocket {}
+
+extend self: WebSocket {
+    
+    readText(encoding: String = "utf8"): Option[String] {
+        self.readAny {_} {_.toString(encoding)}
+    }
+
+    readBuffer(): Option[Buffer] {
+        self.readAny {_.toBuffer()} {_}
+    }
+    
+    readAny[T](fromText: String => T, fromBuffer: Buffer => T): Option[T]
+        target browser async """
+            ff_core_Task.Task_throwIfAborted($task);
+            while(self_.ffFront.length === 0) {
+                while(self_.ffBack.length !== 0) {
+                    self_.ffFront.push(self_.ffBack.pop());
+                }
+                if(self_.ffFront.length !== 0) break;
+                if(self_.readyState === 3) return ff_core_Option.None();
+                let abort = null;
+                try {
+                    await new Promise((resolve, reject) => {
+                        self_.ffListeners.push(resolve);
+                        if($task !== self_.ffTask) {
+                            abort = () => {
+                                self_.ffListeners = self_.ffListeners.filter(l => l != resolve);
+                                reject();
+                            };
+                            $task.controller.signal.addEventListener('abort', abort);
+                        }
+                    });
+                } finally {
+                    if($task !== self_.ffTask) {
+                        $task.controller.signal.removeEventListener('abort', abort);
+                    }
+                }
+            }
+            const message = self_.ffFront.pop();
+            if(!(message instanceof MessageEvent)) throw new Error("WebSocket error");
+            const data = message.data;
+            if(typeof data === 'string') return ff_core_Option.Some(await fromText_(data));
+            return ff_core_Option.Some(await fromBuffer_(new DataView(data)));
+        """
+
+    writeBuffer(data: Buffer): Unit
+        target browser async """
+            ff_core_Task.Task_throwIfAborted($task);
+            self_.send(data_);
+        """
+
+    writeText(data: String): Unit
+        target browser async """
+            ff_core_Task.Task_throwIfAborted($task);
+            self_.send(data_);
+        """
+        
+    close(code: Int = 1000, reason: String = ""): Unit
+        target browser async """
+            if(self_.readyState === 2 || self_.readyState === 3) return;
+            await new Promise((resolve, reject) => {
+                self_.addEventListener('close', resolve);
+                self_.close(code_, reason !== "" ? reason : void 0);
+            });
+            return;
+        """
+
+    isOpen(): Bool
+        target browser async """
+            return self_.readyState === 1;
+        """
+
+    isClosing(): Bool
+        target browser async """
+            return self_.readyState === 2;
+        """
+
+    isClosed(): Bool
+        target browser async """
+            return self_.readyState === 3;
+        """
+
+}
+
+internalOpenBrowserWebSocket(browserSystem: BrowserSystem, url: String): WebSocket
+    target browser async """
+        if(typeof location !== 'undefined' && !url_.includes("://")) {
+            if(location.href && location.href.startsWith("http")) {
+                url_ = new URL(url_, location.href).href.replace(/^http/, 'ws');
+            }
+        }
+        const socket = new WebSocket(url_);
+        socket.binaryType = "arraybuffer";
+        socket.ffFront = [];
+        socket.ffBack = [];
+        socket.ffListeners = [];
+        socket.ffTask = $task;
+        $task.controller.signal.addEventListener('message', m => socket.ffBack.push(m));
+        const abort = () => socket.close();
+        try {
+            await new Promise((resolve, reject) => {
+                socket.onopen = resolve;
+                socket.onerror = reject;
+                $task.controller.signal.addEventListener('abort', abort);
+            });
+        } finally {
+            socket.onopen = null;
+            socket.onerror = null;
+        }
+        socket.addEventListener('close', () => {
+            $task.controller.signal.removeEventListener('abort', abort);
+            for(let i = 0; i < socket.ffListeners.length; i++) socket.ffListeners[i]();
+            socket.ffListeners.length = 0;
+        });
+        socket.addEventListener('message', m => {
+            socket.ffBack.push(m);
+            for(let i = 0; i < socket.ffListeners.length; i++) socket.ffListeners[i]();
+            socket.ffListeners.length = 0;
+        });
+        socket.addEventListener('error', e => {
+            socket.ffBack.push(e);
+            for(let i = 0; i < socket.ffListeners.length; i++) socket.ffListeners[i]();
+            socket.ffListeners.length = 0;
+        });
+        return socket;
+    """

package/httpserver/HttpServer.ff

@@ -146,7 +146,7 @@ extend self: HttpResponse {
         target node async """
             import * as http from 'http'
             ff_core_Task.Task_throwIfAborted($task)
-            if(!self_.write(buffer_)) {
+            if(!self_.write(Buffer.from(buffer_.buffer))) {
                 let reject = null;
                 await new Promise((resolve, reject) => {
                     const abort = () => {