firefly-compiler 0.4.79 → 0.4.81

package/websocket/.firefly/package.ff

@@ -1 +1 @@
-package ff:websocket:0.0.0
+package ff:websocket:0.0.0

package/websocket/WebSocket.ff

@@ -1,131 +1,131 @@
-capability WebSocket {}
-
-open(browserSystem: BrowserSystem, url: String): WebSocket {
-    internalOpenBrowserWebSocket(browserSystem, url)
-}
-
-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;
-    """
+capability WebSocket {}
+
+open(browserSystem: BrowserSystem, url: String): WebSocket {
+    internalOpenBrowserWebSocket(browserSystem, url)
+}
+
+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/fireflysite/GuideAll.ff

@@ -1,21 +0,0 @@
-import Guide
-import GuideIntroduction
-import GuideControlFlow
-import GuideBaseTypes
-
-mock(): List[Document] {
-    [
-        GuideIntroduction.new()
-        GuideBaseTypes.new()
-        //GuideControlFlow.new()
-        UnfetchedDocument("Control Flow")
-        ReadyDocument([Section("Custom types", [])])
-        ReadyDocument([Section("Async I/O", [])])
-        ReadyDocument([Section("Structured concurrency", [])])
-        ReadyDocument([Section("Applications", [])])
-        ReadyDocument([Section("Packages and modules", [])])
-        ReadyDocument([Section("Functions and methods", [])])
-        ReadyDocument([Section("Traits and instances", [])])
-        ReadyDocument([Section("JavaScript interop", [])])
-    ]
-}

package/fireflysite/GuideBaseTypes.ff

@@ -1,168 +0,0 @@
-import Guide
-
-new(): Document {
-    ReadyDocument([
-
-        Section("Base types", [
-            Paragraph([
-                Text("Firefly has four primitive types: ")
-                Code("String, Char, Int, Float.", firefly = True)
-                Text("They have the following literal syntax:")
-            ])
-            CodeBlock("""
-                "Hello, World!" // String
-                'H' // Char
-                42 // Int
-                3.14 // Float
-            """.replace("'''", "\"\"\""), firefly = True)
-            Paragraph([
-                Text("Strings may be concatenated using plus, e.g. ")
-                Code("\"ban\" + \"ana\".", firefly = True)
-                Text("String literals may contain escape sequences, e.g. ")
-                Code("\\n, \\t, \\r, \\\", \\\'.")
-                Text("You may also write multiline strings using triple quotes:")
-                Code("\"\"\"...\"\"\".", firefly = True)
-            ])
-            Paragraph([
-                Text("Ints support the usual arithmetic operators:")
-                Code("+ - * / ^", firefly = True)
-                Text("(division returns a Float, use the")
-                Code(".div()", firefly = True)
-                Text("method for integer division).")
-            ])
-            Paragraph([
-                Text("Float literals may use scientific notation, e.g. ")
-                Code("1.0e3, 1.0e-3", firefly = True)
-                Text("The usual arithmetic operators are available:")
-                Code("+ - * / ^", firefly = True)
-            ])
-        ])
-        Section("Booleans", [
-            Paragraph([
-                Text("Bool is defined as a data type:")
-            ])
-            CodeBlock("""
-                data Bool {
-                    False
-                    True
-                }
-            """, firefly = True)
-            Paragraph([
-                Text("Meaning it has two values:")
-                Code("False, True.", firefly = True)
-                Text("They support the usual logical operators:")
-                Code("&& || !", firefly = True)
-            ])
-        ])
-        Section("Durations and instants", [
-            Paragraph([
-                Text("Durations represent elapsed time, and instants represent points in time.")
-            ])
-            CodeBlock("""
-                newtype Duration(seconds: Float)
-                newtype Instant(since1970: Duration)
-            """, firefly = True)
-            Paragraph([
-                Text("You can get the current instant:")
-                Code("system.mainTask.now()", firefly = True)
-                Text("or ask how much time elapsed since the program started:")
-                Code("system.mainTask.elapsed().", firefly = True)
-                Text("Note that neither has a time zone nor support for local calendars.")
-            ])
-        ])
-        Section("Lists and arrays", [
-            Paragraph([
-                Text("List is the most common data structure in Firefly.")
-                Text("It's an immutable contiguous blocks of values that can be indexed by integers, mapped over, filtered and so on.")
-            ])
-            CodeBlock("""
-                let fruits: List[String] = 
-                    ["apple", "banana", "orange"]
-            """, firefly = True)
-            Paragraph([
-                Text("You can flatten one list into another using the spread syntax:")
-                Code("[...friuts, \"cherry\"] == [\"apple\", \"banana\", \"orange\", \"cherry\"].", firefly = True)
-            ])
-            Paragraph([
-                Text("Arrays is the mutable (and resizable) version of lists. You can convert a list to an array like this:")
-                Code("fruits.toArray(),", firefly = True)
-                Text("and you can construct an empty array like this:")
-                Code("Array.new().", firefly = True)
-            ])
-        ])
-        Section("Sets and maps", [
-            Paragraph([
-                Text("Set and Map are immutable and sorted collections. Sets have no duplicate entries, and maps have no duplicate keys.")
-            ])
-            CodeBlock("""
-                let fruitSet: Set[String] = 
-                    ["apple", "banana", "orange"].toSet()
-                    
-                let numberMap: Map[String, Int] = 
-                    [Pair("one", 1), Pair("two", 2)].toMap()
-            """, firefly = True)
-            Paragraph([
-                Text("They have methods for lookup, union, intersection, etc.")
-                Text("In addition, there's a mutable IntMap and StringMap that's optimized for integer and string keys, respectively.")
-            ])
-        ])
-        Section("Streams and buffers", [
-            Paragraph([
-                Text("Streams are lazy sequences that are consumed when read. They're often used for streaming I/O.")
-            ])
-            CodeBlock("""
-                // Streaming file copy
-                let stream = system.path("file1.txt").readStream()
-                system.path("file2.txt").writeStream(stream)
-            """, firefly = True)
-            Paragraph([
-                Text("Note that there is no risk of leaking a file handle above, as the file isn't opened until the first element of the stream is read,")
-                Text("and the writeStream method will take care of closing the stream, even in the face of I/O errors.")
-            ])
-            Paragraph([
-                Text("In this case you get a")
-                Code("Stream[Buffer]", firefly = True)
-                Text("back, which is common for streaming I/O in Firefly.")
-                Text("A buffer is a mutable fixed-size array of bytes that you can manipulate with hardware friendly binary operations (8-bit, 16-bit, 32-bit etc.).")
-            ])
-        ])
-        Section("Option, Pair, Unit and Nothing", [
-            Paragraph([
-                Text("Option represent a value that may be missing. There's no null in Firefly, so Option is often the return type of lookups. It's defined like this:")
-            ])
-            CodeBlock("""
-                data Option[T] {
-                    None
-                    Some(value: T)
-                }
-            """, firefly = True)
-            Paragraph([
-                Text("Pair is a generic record with two fields, e.g. for key/value pairs in a map:")
-            ])
-            CodeBlock("""
-                data Pair[A, B](first: A, second: B)
-            """, firefly = True)
-            Paragraph([
-                Text("Unit is the return type for functions that have no interesting return value:")
-            ])
-            CodeBlock("""
-                data Unit {
-                    Unit
-                }
-            """, firefly = True)
-            Paragraph([
-                Text("Meaning it only has one possible value:")
-                Code("Unit.", firefly = True)
-            ])
-            Paragraph([
-                Text("Nothing is a type that has no values:")
-            ])
-            CodeBlock("""
-                data Nothing {}
-            """, firefly = True)
-            Paragraph([
-                Text("It's occasionally useful to statically rule out the possibility of constructing something.")
-            ])
-        ])
-    ])
-}

package/fireflysite/GuideControlFlow.ff

@@ -1,212 +0,0 @@
-import Guide
-
-new(): Document {
-    ReadyDocument([
-
-        Section("Control flow", [
-            Paragraph([
-                Text("Firefly provides several ways to implement branching. ")
-                Anchor("Pattern matching")
-                Text(" is the most powerful, built directly into the language. ")
-                Code("if")
-                Text(", ")
-                Code("elseIf")
-                Text(" and ")
-                Code("else")
-                Text(" do what you expect and are functions and methods in the standard library, implemented using the")
-                Anchor("Option")
-                Text(" type. An then finally, there are ")
-                Anchor("exceptions")
-                Text(".")
-            ])
-        ])
-
-        Section("Pattern matching", [
-            Paragraph([
-                Text("Pattern matching allows you to check a given data structure against a pattern. ")
-                Text("For example, if we want to parse the command line arguments provided by the user, we could do it like this:")
-            ])
-            CodeBlock("""
-                let pair = system.arguments().{
-                    | [host] => Pair(host, 80)
-                    | ["localhost", port] => Pair("localhost", port.grabInt())
-                    | _ => 
-                        system.writeErrorLine("Usage: 'localhost' | (host port)")
-                        system.exit(0)
-                }            
-            """, firefly = True)
-            Paragraph([
-                Text("In Firefly you construct a list of strings (")
-                Code("List[String]")
-                Text(") like this ")
-                Code("""["example.com", "80"]""")
-                Text(", and using pattern matching you can de-construct in the same way.")
-            ])  
-            Paragraph([
-                Text("The basic syntax for pattern matching is:")
-            ])
-            CodeBlock("""
-                data.{
-                    | pattern1 => // case 1
-                    | pattern2 => // case N
-                    ...
-                }
-            """, firefly = True)
-            Paragraph([
-                Text("The patterns must be exhaustive, that is, for any possible value of the given type, there must be a matching pattern. ")
-                Text("In the example above, there are no value for the empty list ")
-                Code("[]")
-                Text(", list with two values, where the first is not ")
-                Code(""""localhost"""")
-                Text(" or lists with more than 2 arguments. That's why we need the wildcard case at the end. ")
-                Text("Without this last case, the compiler would  produce a compile-time error, stating that the patterns must be exhaustive.")
-            ])
-            Paragraph([
-                Text("Here are more examples — all exhaustive. Let's start with records:")
-            ])  
-            CodeBlock("""
-                pair.{
-                    | Pair(first, second) => 
-                }
-            """, firefly = True)
-
-            Paragraph([
-                Text("Numbers")
-            ])  
-            CodeBlock("""
-                n.{
-                    | 1 => 
-                    | 2 => 
-                    | n => 
-                }
-            """, firefly = True)    
-            
-            Paragraph([
-                Text("Booleans")
-            ])  
-            CodeBlock("""
-                n.{
-                    | True => 
-                    | False => 
-                }
-            """, firefly = True)    
-            Paragraph([
-                Text("And you can combine pattern as needed. Imagine you have a pair of type ")
-                Code("Pair[List[Bool], Pair(Int, String)]")
-            ])  
-            CodeBlock("""
-                pair.{
-                    | Pair([True, False], Pair(42, "foo")) => 
-                    | other => 
-                }
-            """, firefly = True)          
-        ])
-
-        Section("Option", [
-            Paragraph([
-                Text("Sometimes you don't have a value. Other languages uses ")
-                Code("null")
-                Text(" for this purpose, but Firefly does not have ")
-                Code("null")
-                Text(". Instead, we have ")
-                Code("Option")
-                Text(" from the core package.")
-            ])
-            CodeBlock("""
-                data Option[T] {
-                    None
-                    Some(value: T)
-                }
-            """, firefly = True)
-            Paragraph([
-                Text("For some type T, say String, Option[String] is either some string or no value (")
-                Code("None")
-                Text("). This way, the type system guides you to check for no-value.")                
-            ])
-
-            Paragraph([
-                Text("Many functions and methods returns an ") 
-                Code("Option")
-                Text(" in Firefly. For instance the ")
-                Code("getInt ")
-                Text(" method on ")
-                Code("String")
-                Text(" . This method returns ")
-                Code("Some[Int]")
-                Text(" when the string consists only of digits and ")
-                Code("None")
-                Text(" otherwise. We can perform pattern matching on ")
-                Code("Option")
-                Text("like this:")
-            ])
-            CodeBlock("""
-                port.getInt().{
-                    | None => 80
-                    | Some(p) => p
-                }
-            """, firefly = True)  
-            Paragraph([
-                Text("Many methods like ")
-                Code("getInt")
-                Text(" have a non-total counterpart ")
-                Code("grabInt")
-                Text(" , which returns an ")
-                Code("Int")
-                Text(" . But it will throw an exception when the input cannot be parsed. Options let's you code in an exception-safe manner.")
-            ])
-        ])
-
-
-        Section("if - elseIf - else", [
-            Paragraph([
-                Text("You write if-statements in Firefly like this:")
-            ])
-            CodeBlock("""
-                if(path == "/") {
-                    response.writeText("<!doctype html>")
-                } elseIf {path.startsWith("/js/")} {
-                    response.writeText("<script>")
-                } else {
-                    response.writeStatus("404 Not found")
-                }
-            """, firefly = True)
-            Paragraph([
-                Text("You can also use it as an expression like this")
-            ])
-            CodeBlock("""
-                let contentType = if(path == "/") {
-                    "text/html; charset=UTF-8"
-                } elseIf(directory2.exists) {
-                    "text/javascript; charset=UTF-8"
-                } else {
-                    "text/plain; charset=UTF-8"
-                }
-            """, firefly = True)
-            Paragraph([
-                Code("if")
-                Text(", ")
-                Code("elseIf")
-                Text(" and ")
-                Code("else")
-                Text(" are not keywords or construct build into Firefly. ")
-                Text("If you are curious, you can look at how they are implemented. ")
-                Code("if")
-                Text(" is just a function defined like this: ")
-            ])
-            CodeBlock("""
-                if[T](condition: Bool, body: () => T): Option[T] {
-                    condition.{
-                        | False => None
-                        | True => Some(body())
-                    }
-                }
-            """, firefly = True)
-            // TODO: But still, why are this syntactically correct?            
-        ])
-        Section("Exceptions", [
-            Paragraph([
-                Text("...")
-            ])
-        ])
-    ])
-}