firefly-compiler 0.4.80 → 0.4.82

package/compiler/Parser.ff

@@ -1025,11 +1025,10 @@ extend self: Parser {
         if(self.current().is(LKeyword) && (self.current().rawIs("let") || self.current().rawIs("mutable"))) {self.parseLet()} else:
         if(self.current().is(LKeyword) && self.current().rawIs("function")) {self.parseFunctions()} else:
         let term = self.parseTerm()
-        if(!self.current().is(LAssign) && !self.current().is3(LAssignPlus, LAssignMinus, LAssignLink)) {term} else:
+        if(!self.current().is(LAssign) && !self.current().is2(LAssignPlus, LAssignMinus)) {term} else:
         let token = do {
             if(self.current().is(LAssignPlus)) {self.skip(LAssignPlus)} else:
             if(self.current().is(LAssignMinus)) {self.skip(LAssignMinus)} else:
-            if(self.current().is(LAssignLink)) {self.skip(LAssignLink)} else:
             self.skip(LAssign)
         }
         let operator = token.raw().dropLast(1)
@@ -1153,7 +1152,7 @@ extend self: Parser {
             True
         } else {False}
         mutable result = self.parseAtom()
-        while {self.current().is(LBracketLeft) || self.current().is(LColon) || self.current().is(LDot)} {
+        while {self.current().is4(LBracketLeft, LColon, LDot, LArrowThin)} {
             if(self.current().is(LDot)) {
                 self.skip(LDot)
                 if(self.current().rawIs("{")) {
@@ -1166,6 +1165,8 @@ extend self: Parser {
                     let token = self.skip(LLower)
                     result = EField(token.at(), False, result, token.raw())
                 }
+            } elseIf {self.current().is(LArrowThin)} {
+                result = self.parseDynamicMember(result)
             } else {
                 let at = self.current().at()
                 let typeArguments = if(!self.current().rawIs("[")) {[]} else {self.parseTypeArguments()}
@@ -1181,6 +1182,46 @@ extend self: Parser {
         }
         result
     }
+    
+    parseDynamicMember(record: Term): Term {
+        self.skip(LArrowThin)
+        let token = self.skip(LLower)
+        let member = EString(token.at(), "\"" + token.raw() + "\"")
+        if(self.current().rawIs("(")) {
+            let arguments = self.parseFunctionArguments(record.at, False)
+            let effect = self.freshUnificationVariable(record.at)
+            let target = DynamicCall(EField(token.at(), False, record, "call" + arguments.first.size()), False)
+            ECall(record.at, target, effect, [], [
+                Argument(member.at, None, member)
+                ...arguments.first
+            ], [])
+        } elseIf {self.current().is3(LAssign, LAssignPlus, LAssignMinus)} {
+            let method = 
+                if(self.current().is(LAssign)) {
+                    self.skip(LAssign)
+                    "set"
+                } elseIf {self.current().is(LAssignPlus)} {
+                    self.skip(LAssignPlus)
+                    "increment"
+                } else {
+                    self.skip(LAssignMinus)
+                    "decrement"
+                }
+            let value = self.parseTerm()
+            let effect = self.freshUnificationVariable(record.at)
+            let target = DynamicCall(EField(token.at(), False, record, "set"), False)
+            ECall(record.at, target, effect, [], [
+                Argument(member.at, None, member)
+                Argument(value.at, None, value)
+            ], [])
+        } else {
+            let effect = self.freshUnificationVariable(record.at)
+            let target = DynamicCall(EField(token.at(), False, record, "get"), False)
+            ECall(record.at, target, effect, [], [
+                Argument(member.at, None, member)
+            ], [])
+        }
+    }
 
     parseAtom(): Term {
         if(self.current().is(LString)) {

package/compiler/Token.ff

@@ -38,6 +38,10 @@ extend token: Token {
         token.kind == kind1 || token.kind == kind2 || token.kind == kind3
     }
 
+    is4(kind1: TokenKind, kind2: TokenKind, kind3: TokenKind, kind4: TokenKind): Bool {
+        token.kind == kind1 || token.kind == kind2 || token.kind == kind3 || token.kind == kind4
+    }
+
     rawIs(value: String): Bool {
         token.stopOffset - token.startOffset == value.size() &&
         token.code.startsWith(value, token.startOffset)
@@ -78,11 +82,11 @@ data TokenKind {
     LPipe
     LColon
     LDotDotDot
+    LArrowThin
     LArrowThick
     LAssign
     LAssignPlus
     LAssignMinus
-    LAssignLink
 }
 
 extend self: TokenKind {
@@ -109,11 +113,11 @@ extend self: TokenKind {
             | LPipe => False
             | LColon => False
             | LDotDotDot => False
+            | LArrowThin => False
             | LArrowThick => False
             | LAssign => False
             | LAssignPlus => False
             | LAssignMinus => False
-            | LAssignLink => False
         }
     }
 
@@ -139,11 +143,11 @@ extend self: TokenKind {
             | LPipe => False
             | LColon => False
             | LDotDotDot => True
+            | LArrowThin => False
             | LArrowThick => False
             | LAssign => False
             | LAssignPlus => False
             | LAssignMinus => False
-            | LAssignLink => False
         }
     }
 
@@ -169,11 +173,11 @@ extend self: TokenKind {
             | LPipe => False
             | LColon => False
             | LDotDotDot => False
+            | LArrowThin => False
             | LArrowThick => False
             | LAssign => False
             | LAssignPlus => False
             | LAssignMinus => False
-            | LAssignLink => False
         }
     }
 

package/compiler/Tokenizer.ff

@@ -226,6 +226,8 @@ tokenize(file: String, code: String, completionAt: Option[Location], attemptFixe
                         LColon
                     } elseIf {i - start == 3 && code.grab(i - 3) == '.' && code.grab(i - 2) == '.' && code.grab(i - 1) == '.'} {
                         LDotDotDot
+                    } elseIf {i - start == 2 && code.grab(i - 2) == '-' && code.grab(i - 1) == '>'} {
+                        LArrowThin
                     } elseIf {i - start == 2 && code.grab(i - 2) == '=' && code.grab(i - 1) == '>'} {
                         LArrowThick
                     } elseIf {i - start == 1 && code.grab(i - 1) == '='} {
@@ -234,8 +236,6 @@ tokenize(file: String, code: String, completionAt: Option[Location], attemptFixe
                         LAssignPlus
                     } elseIf {i - start == 2 && code.grab(i - 2) == '-' && code.grab(i - 1) == '='} {
                         LAssignMinus
-                    } elseIf {i - start == 3 && code.grab(i - 3) == ':' && code.grab(i - 2) == ':' && code.grab(i - 1) == '='} {
-                        LAssignLink
                     } else {
                         LOperator
                     }

package/core/JsSystem.ff

@@ -5,6 +5,18 @@ extend self: JsSystem {
     global(): JsValue
         target js sync "return self_"
 
+    get(key: String): JsValue
+        target js sync "return self_[key_]"
+
+    set[V: IsJsValue](key: String, value: V): Unit
+        target js sync "self_[key_] = value_"
+
+    increment[V: IsJsValue](key: String, value: V): Unit
+        target js sync "self_[key_] += value_"
+        
+    decrement[V: IsJsValue](key: String, value: V): Unit
+        target js sync "self_[key_] -= value_"
+        
     parseJson(json: String): JsValue
         target js sync "return JSON.parse(json_)"
 

package/core/JsValue.ff

@@ -88,6 +88,12 @@ extend self: JsValue {
     set[K: IsJsValue, V: IsJsValue](key: K, value: V): Unit
         target js sync "self_[key_] = value_"
 
+    increment[K: IsJsValue, V: IsJsValue](key: K, value: V): Unit
+        target js sync "self_[key_] += value_"
+        
+    decrement[K: IsJsValue, V: IsJsValue](key: K, value: V): Unit
+        target js sync "self_[key_] -= value_"
+
     delete[K: IsJsValue](key: K): Unit
         target js sync "delete self_[key_]"
 

package/core/Task.ff

@@ -85,6 +85,14 @@ extend self: Task {
             readOr(self.channel()) {_ => }.
             timeout(duration) {}
     }
+    
+    mapList[T, R](list: List[T], body: T => R): List[R] {
+        self.all(list.map {x => {body(x)}})
+    }
+    
+    raceList[T, R](list: List[T], body: T => R): R {
+        self.race(list.map {x => {body(x)}})
+    }
 
     all[T](tasks: List[() => T]): List[T] {
         let successChannel = self.channel()

package/fireflysite/Guide.ff

@@ -92,12 +92,11 @@ data GuideDocument(
     document: Document
 )
 
-render(lux: Lux, browser: BrowserSystem, prefix: String, kebab: String, guides: List[Guide], demos: List[Demo]) {
+render(lux: Lux, httpClient: HttpClient, prefix: String, kebab: String, guides: List[Guide], demos: List[Demo]) {
     let guide = guides.find {_.prefix == prefix}.else {guides.grabFirst()}
     let document = guide.documents.find {d => 
         kebabCase(d.heading()) == kebab
     }.else {guide.documents.grabFirst()}
-    browser.js().global().get("document").set("title", document.title(guide))
     let guideDocuments = guides.flatMap {guide => guide.documents.map {document => 
         GuideDocument(guide, document)
     }}
@@ -111,7 +110,7 @@ render(lux: Lux, browser: BrowserSystem, prefix: String, kebab: String, guides:
             lux.cssClass(Styles.guideCss)
             lux.add("main") {
                 lux.cssClass(Styles.guideMainCss)
-                renderDocument(lux, browser.httpClient(), prefix, document, demos, nextDocument)
+                renderDocument(lux, httpClient, prefix, document, demos, nextDocument)
             }
             renderTopbar(lux, menu, setMenu)
             lux.add("div") {

package/fireflysite/Main.ff

@@ -1,5 +1,6 @@
 import WebServer from ff:webserver
 import Lux from ff:lux
+import Css from ff:lux
 import Guide
 import GettingStarted
 import ReferenceAll
@@ -18,18 +19,6 @@ nodeMain(system: NodeSystem): Unit {
         let path = request.readPath()
         let segments = path.split('/').filter {s => s != "" && s != "." && s != ".."}
         segments.{
-            | ["reference", ...] => 
-                serveGuideHtml("Firefly Reference", request)
-            | ["getting-started", ...] => 
-                serveGuideHtml("Firefly Getting Started", request)
-            | ["examples", ...] => 
-                serveGuideHtml("Firefly Examples", request)
-            | ["packages", ...] => 
-                serveGuideHtml("Firefly Packages", request)
-            | ["community", ...] => 
-                serveGuideHtml("Firefly Community", request)
-            | ["front", ...] => 
-                serveGuideHtml("Firefly", request)
             | ["js", ...] => 
                 let asset = if(path == "/js/ff/fireflysite/Main.mjs" && system.assets().exists("/js/Main.bundle.js")) {
                     "/js/Main.bundle.js"
@@ -44,6 +33,7 @@ nodeMain(system: NodeSystem): Unit {
             | ["assets", "font", "FireflySans.ttf"] => 
                 serveAsset(system, cacheSalt, request, "font/ttf", "/assets/font/NunitoSans-VariableFont_YTLC,opsz,wdth,wght.ttf")
             | ["assets", ...rest] => serveAssets(system, cacheSalt, request, rest)
+            | _ {serveGuide(system, request)} => 
             | _ =>
                 let parameters = if(request.readRawQueryString().size() == 0) {""} else {
                     "?" + request.readRawQueryString()
@@ -54,21 +44,40 @@ nodeMain(system: NodeSystem): Unit {
     }    
 }
 
+guides = [
+    Guide("/front/", [FrontPage.new()])
+    Guide("/getting-started/", [GettingStarted.new()])
+    Guide("/examples/", ExamplesOverview.mock())
+    Guide("/reference/", ReferenceAll.mock())
+    Guide("/packages/", [PackagesOverview.new()])
+    Guide("/community/", [CommunityOverview.new()])
+]
+
+serveGuide(system: NodeSystem, request: WebRequest[WebResponse]): Bool {
+    let demos = ExamplesOverview.demos()
+    mutable served = False
+    guides.each {guide => 
+        if(request.readPath().startsWith(guide.prefix)):
+        let kebab = request.readPath().dropFirst(guide.prefix.size())
+        let htmlAndCss = Lux.renderToString(system) {lux =>
+            Guide.render(lux, system.httpClient(), guide.prefix, kebab, guides, demos)
+        }
+        let title = guide.documents.find {d => 
+            Guide.kebabCase(d.heading()) == kebab
+        }.map {_.title(guide)}.else {guide.title()}
+        serveGuideHtml(title, htmlAndCss.first, htmlAndCss.second, request)
+        served = True
+    }
+    served
+}
+
 browserMain(system: BrowserSystem): Unit {
     let demos = ExamplesOverview.demos()
-    let guides = [
-        Guide("/front/", [FrontPage.new()])
-        Guide("/getting-started/", [GettingStarted.new()])
-        Guide("/examples/", ExamplesOverview.mock())
-        Guide("/reference/", ReferenceAll.mock())
-        Guide("/packages/", [PackagesOverview.new()])
-        Guide("/community/", [CommunityOverview.new()])
-    ]
     guides.collect {guide => 
         if(system.urlPath().startsWith(guide.prefix)):
         Lux.renderById(system, "main") {lux => 
             let kebab = system.urlPath().dropFirst(guide.prefix.size())
-            Guide.render(lux, system, guide.prefix, kebab, guides, demos)
+            Guide.render(lux, system.httpClient(), guide.prefix, kebab, guides, demos)
         }
     }
 }
@@ -119,10 +128,11 @@ serveAsset(system: NodeSystem, salt: Buffer, request: WebRequest[WebResponse], c
     }
 }
 
-serveGuideHtml(title: String, request: WebRequest[WebResponse]): Unit {
+serveGuideHtml(title: String, contentHtml: String, styleTags: String, request: WebRequest[WebResponse]): Unit {
     request.writeHeader("Content-Type", "text/html; charset=UTF-8")
     request.writeText("<!doctype html>")
     request.writeText("<html lang='en' style='background-color: #ffffff; color: #333333; width: 100%; height: 100%; color-scheme: light;'>")
+    request.writeText("<script type='module' src='/js/ff/fireflysite/Main.mjs'></script>")
     request.writeText("<head>")
     request.writeText("<title>" + title + "</title>")
     request.writeText("<meta name='viewport' content='width=device-width, initial-scale=1.0'>")
@@ -132,10 +142,10 @@ serveGuideHtml(title: String, request: WebRequest[WebResponse]): Unit {
     request.writeText("<link rel='preload' href='/assets/image/firefly-logo-yellow.png' as='image'>")
     request.writeText("<style>@font-face { font-family: 'Firefly Mono'; font-display: fallback; src: url('/assets/font/FireflyMono.ttf'); unicode-range: U+000-5FF; }</style>")
     request.writeText("<style>@font-face { font-family: 'Firefly Sans'; font-display: fallback; src: url('/assets/font/FireflySans.ttf'); unicode-range: U+000-5FF; }</style>")
+    request.writeText(styleTags)
     request.writeText("</head>")
     request.writeText("<body style='margin: 0; padding: 0; width: 100%; height: 100%; touch-action: manipulation;'>")
-    request.writeText("<div id='main'></div>")
-    request.writeText("<script type='module' src='/js/ff/fireflysite/Main.mjs'></script>")
+    request.writeText("<div id='main'>" + contentHtml + "</div>")
     request.writeText("</body>")
     request.writeText("</html>")
 }

package/fireflysite/ReferenceAll.ff

@@ -12,8 +12,7 @@ mock(): List[Document] {
         UnfetchedDocument("Pattern matching")
         UnfetchedDocument("Traits and instances")
         UnfetchedDocument("Exceptions")
-        UnfetchedDocument("JavaScript interop")
-        UnfetchedDocument("Async I/O")
         UnfetchedDocument("Structured concurrency")
+        UnfetchedDocument("JavaScript interop")
     ]
 }

package/fireflysite/Test.ff

@@ -19,6 +19,14 @@ nodeMain(system: NodeSystem) {
         
     Log.show([1, 2].map(increment))
     
+    Log.show(p(42))
+    let f2 = {42}
+    Log.show(f2())
+    let pairs = {Pair(_, {_})}
+    let pp = pairs(42)
+    let foo = {{_ + 1}(_)}
+    Log.show(foo(1))
+    
 }
 
 factorial(n: Int): Int {

package/fireflysite/assets/markdown/reference/EmittedJavascript.md

@@ -0,0 +1,66 @@
+# Emitted JavaScript
+
+While most Firefly code maps directly to the JavaScript equivalent, there are two notable exceptions:
+
+ * I/O appears to be blocking, but compiles down to JavaScript `async`/`await`.
+ * Methods are resolved statically in Firefly and become top level functions in JavaScript.
+
+In addition, pattern matching doesn't have a direct equivalent in JavaScript, and neither does traits.
+
+
+# Example
+
+Consider the following main function:
+
+```firefly
+nodeMain(system: NodeSystem) {
+    
+    let files = ["a.txt", "b.txt"]
+    
+    let contents = files.map {file =>
+        system.path(file).readText()
+    }
+    
+    let upper = contents.map {content =>
+        content.upper()
+    }
+    
+    system.writeLine("Result: " + upper.join(""))
+    
+}
+```
+
+The JavaScript that's emitted looks roughly like this:
+
+```js
+export async function nodeMain$(system) {
+    
+    const files = ["a.txt", "b.txt"]
+    
+    const contents = await List_map$(files, async file => {
+        return await Path_readText$(await NodeSystem_path$(system, file))
+    })
+    
+    const upper = List_map(contents, content => {
+        return String_upper(content)
+    })
+    
+    NodeSystem_writeLine$("Result: " + String_join(upper, ""))
+    
+}
+```
+
+In JavaScript, `nodeMain` becomes an `async` function and gets the `$` suffix to distinguish it from a synchronous function.
+
+The `let` keyword in Firefly corresponds to the `const` keyword in JavaScript, and Firefly list literals become JavaScript array literals.
+
+The `map` method becomes a top level function, or rather, one `async` top level function named `List_map$` and another synchronous function named `List_map`.
+A static analysis is performed to decide which version to call.
+
+Because the first call to `map` is passed an anonymous function that calls a method on `system`, which is a capability, and the current top level function is asynchronous,
+the analysis picks the asynchronous version `List_map$` and uses the `await` keyword.
+
+The second call to `map` is passed an anonymous function that doesn't involve any other capabilities, the analysis picks the synchronous version `List_map`.
+
+This static analysis is necessarily conservative, and may occasionally call the asynchronous version of a function where the synchrhonous version would suffice.
+When using the VSCode extension, the hover information for a call will note if the call is asynchronous.

package/fireflysite/assets/markdown/reference/Exceptions.md

@@ -0,0 +1,101 @@
+# Exceptions
+
+Exceptions allow a program to transfer control from the point of error to a designated exception handler, separating error-handling logic from regular program flow.
+
+
+# Throwing exceptions
+
+Exceptions are thrown using the `throw` function. Example:
+
+```firefly
+grabOption[T](option: Option[T]): T {
+    | Some(v) => v
+    | None => throw(GrabException())
+}
+```
+
+In this example, if the argument is `Some(v)`, then `v` is returned. Otherwise, a `GrabException` is thrown.
+
+Any type declared with the `data` or `newtype` keyword can be thrown as an exception, since the type will have an instance for the `HasAnyTag` trait.
+
+
+# Catching exceptions
+
+When an exception is thrown, it propagates up the call chain to the nearest `try`, where it can be caught:
+
+```firefly
+try {
+    grabOption(None)
+} catch {| GrabException, error =>
+    Log.trace("A GrabException occurred")
+    error.rethrow()
+}
+```
+
+The first argument passed to `catch` is the thrown value, and the second parameter contains the stack trace.
+The `rethrow()` method throws the exception again without altering the stack trace.
+It is used when the exception is caught where it can't be fully handled.
+
+If the exception reaches the top of the call stack, the exception value and the stack trace will be printed.
+
+
+# Catching any exception
+
+It is also posssible to catch any exception, regardless of its type, using the `catchAny` method:
+
+```firefly
+try {
+    let result = fragileOperation()
+    Some(result)
+} catchAny {error =>
+    None
+}
+```
+
+
+# Cleaning up
+
+Cleanup often needs to happen whether or not an exception is thrown.
+This is what the `finally` method guarantees:
+
+```firefly
+let fileHandle = path.readHandle()
+try {
+    process(fileHandle)
+} finally {
+    fileHandle.close()
+}
+```
+
+If the program is terminated abnormally (force closed, power is lost, etc.) there is no guarantee that `finally` will get called.
+In most environments, the operating system will occasionally terminate the program abnormally, so programs should be designed such that they can recover from abnormal termination.
+
+
+# Catching multiple exceptions
+
+The `try` function returns a value of type `Try[T]` that is defined as follows:
+
+```firefly
+data Try[T] {
+    Success(value: T)
+    Failure(error: Error)
+}
+```
+
+The `catch`, `catchAny` and `finally` methods are defined on this type. However, since they don't return a `Try[T]` value, they can't be chained.
+
+However, the alternative `tryCatch`, `tryCatchAny` and `tryFinally` methods do return a `Try[T]` value, and can thus be chained:
+
+```firefly
+try {
+    doSomething()
+} tryCatch {| GrabException, error =>
+    reportSpecificError()
+} tryCatchAny {error =>
+    reportGeneralError()
+} finally {
+    performCleanup()
+}
+```
+
+The last method in the chain here is `finally`. If it was `tryFinally`, a value of type `Try[T]` would be returned.