firefly-compiler 0.4.78 → 0.4.80

package/core/Stream.ff

@@ -42,7 +42,7 @@ extend self[T]: Stream[T] {
                 self.close()
             } finally {
                 that.close()
-            } grab()
+            }
         }
     }
 
@@ -76,7 +76,7 @@ extend self[T]: Stream[T] {
                 inner.close()
             } finally {
                 self.close()
-            } grab()
+            }
         }
     }
 
@@ -111,7 +111,7 @@ extend self[T]: Stream[T] {
                 self.close()
             } finally {
                 that.close()
-            } grab()
+            }
         }
     }
 
@@ -224,7 +224,7 @@ extend self[T]: Stream[T] {
             body(self)
         } finally {
             self.close()
-        } grab()
+        }
     }
 
     each(body: T => Unit): Unit {
@@ -238,7 +238,7 @@ extend self[T]: Stream[T] {
             }
         } finally {
             self.close()
-        } grab()
+        }
     }
 
     eachWhile(body: T => Bool): Unit {
@@ -252,7 +252,7 @@ extend self[T]: Stream[T] {
             }
         } finally {
             self.close()
-        } grab()
+        }
     }
 
     all(body: T => Bool): Bool {
@@ -278,7 +278,7 @@ extend self[T]: Stream[T] {
             self.next()
         } finally {
             self.close()
-        } grab()
+        }
     }
 
     last(): Option[T] {
@@ -294,7 +294,7 @@ extend self[T]: Stream[T] {
             result
         } finally {
             self.close()
-        } grab()
+        }
     }
 
     grabFirst(): T {
@@ -324,7 +324,7 @@ extend self[T]: Stream[T] {
             result
         } finally {
             self.close()
-        } grab()
+        }
     }
 
     find(body: T => Bool): Option[T] {

package/core/Task.ff

@@ -104,7 +104,7 @@ extend self: Task {
             } catchAny {error =>
                 failureChannel.write(error)
                 t.abort()
-            } grab()
+            }
         }
         Channel.
             readOr(successChannel, {_}).
@@ -125,7 +125,7 @@ extend self: Task {
                     if(live == 0) {
                         failureChannel.write(e)
                     }
-                } grab()
+                }
             }
         }
         try {
@@ -135,7 +135,7 @@ extend self: Task {
                 wait()
         } finally {
             started.each {_.abort()}
-        } grab()
+        }
     }
             
 }

package/core/Try.ff

@@ -16,21 +16,42 @@ extend self[T]: Try[T] {
         self.map(body).flatten()
     }
 
-    catch[E: HasAnyTag](body: (E, Error) => T): Try[T] {
+    catch[E: HasAnyTag](body: (E, Error) => T): T {
+        self.{
+            | Failure(error) {error.exception().flatMap(Any.fromAny) | Some(e)} => body(e, error)
+            | _ => self.grab()
+        }
+    }
+
+    catchAny(body: Error => T): T {
+        self.{
+            | Failure(error) => body(error)
+            | _ => self.grab()
+        }
+    }
+
+    finally(body: () => Unit): T {
+        self.{
+            | Success(value) => body(); value
+            | Failure(_) => body(); self.grab()
+        }
+    }
+
+    tryCatch[E: HasAnyTag](body: (E, Error) => T): Try[T] {
         self.{
             | Failure(error) {error.exception().flatMap(Any.fromAny) | Some(e)} => try {body(e, error)}
             | _ => self
         }
     }
 
-    catchAny(body: Error => T): Try[T] {
+    tryCatchAny(body: Error => T): Try[T] {
         self.{
             | Failure(error) => try {body(error)}
             | _ => self
         }
     }
 
-    finally(body: () => Unit): Try[T] {
+    tryFinally(body: () => Unit): Try[T] {
         self.{
             | Success(value) => try {body(); value}
             | Failure(_) =>
@@ -40,7 +61,7 @@ extend self[T]: Try[T] {
                 }
         }
     }
-
+    
     else(body: () => T): T {
         self.{
             | Success(value) => value

package/experimental/s3/S3TestAuthorizationHeader.ff

@@ -1,4 +1,5 @@
-import S3
+dependency ff:s3:0.0.0
+import S3 from ff:s3
 
 nodeMain(system: NodeSystem) {
     // Trying to reproduce the result from an example here 

package/experimental/s3/S3TestPut.ff

@@ -1,4 +1,5 @@
-import S3
+dependency ff:s3:0.0.0
+import S3 from ff:s3
 
 nodeMain(system: NodeSystem) {
     S3.put(system, 

package/fireflysite/CommunityOverview.ff

@@ -3,13 +3,13 @@ import CountingButtonDemo
 import MatchingPasswordsDemo
 
 new(): Document {
-    Document([
+    ReadyDocument([
         Section("Community", [
             Paragraph([
                 Text("The developers of Firefly hang out in")
                 Code("#firefly")
                 Text("on the")
-                Link("r/ProgrammingLanguages", "https://discord.gg/yQ9mSk7CJ5")
+                Link("Programming Languages", "https://discord.gg/yQ9mSk7CJ5")
                 Text("Discord.")
             ])
             Paragraph([

package/fireflysite/CountingButtonDemo.ff

@@ -25,7 +25,7 @@ render(lux: Lux): Unit {
 }
 
 newDocument(): Document {
-    Document([
+    ReadyDocument([
         Section(name, [
             Paragraph([Text("A button that counts how many times it's been clicked.")])
         ])

package/fireflysite/DocumentParser.ff

@@ -0,0 +1,332 @@
+import WebServer from ff:webserver // This is required to run the file.
+import Guide
+
+nodeMain(system: NodeSystem) {
+
+    function logDuration[T](label: String, body: () => T): T {
+        let started = system.mainTask().elapsed()
+        let result = body()
+        Log.debug(label + ": " + Show.show(Duration(system.mainTask().elapsed().seconds - started.seconds)))
+        result
+    }
+    
+    let file = system.path("assets/markdown/reference/FunctionsAndMethods.md")
+    
+    /*
+    logDuration("parse " + file.base()) {
+        mutable i = 0
+        while {i < 10000} {
+            parse(file)
+            i += 1
+        }
+    } 
+    */   
+    let document = parse(file)
+    printSections(system, document)
+}
+
+
+
+parse(file: Path): List[Section] {
+    let content = file.readText()
+    let lines = content.split('\n')
+    let parser = DocumentParser(file.absolute(), lines, 0)
+    parser.parseDocument()
+}
+
+class DocumentParser(
+    fileName: String
+    lines: List[String]
+    mutable i: Int
+)
+
+extend self: DocumentParser {
+    
+    parseDocument(): List[Section] {
+        iterate {self.parseSection()}
+    }
+    
+    parseSection(): Option[Section] {
+        self.skipWhile {_.trim() == ""}
+        self.first().{
+            | Some(line) {line.trim().removeFirst("#") | Some(heading)} => 
+                self.skip(1)
+                let blocks = iterate {self.parseBlock()}
+                Some(Section(heading.trim(), blocks))
+            | _ => None
+        }
+    }
+    
+    parseBlock(): Option[Block] {
+        self.skipWhile {_.trim() == ""}
+        let first = self.first().map {_.trimStart()}
+        first.{
+            | Some(line) {line.removeFirst("```") | Some(l)} => 
+                self.skip(1)
+                let isFirefly = l.startsWith("firefly")
+                let block = self.parseRemainingCodeBlock(isFirefly)
+                Some(block)
+            | Some(line) {line.removeFirst("* ") | Some(l)} => 
+                self.skip(1)
+                Some(Bullets(self.parseBullets(l)))
+            | Some(line) {line.first().any {_ != '#'}} => 
+                Some(self.parseParagraph())
+            | _ => None
+        }
+    }
+    
+    parseParagraph(): Block {
+        let lines = self.consumeWhile {_.trim() != ""}
+        Paragraph(self.parseInlines(lines))
+    }
+    
+    parseInlines(lines: List[String]): List[Inline] {
+        let parser = InlineParser(self.fileName, lines.join("\n"), 0)
+        let inlines = parser.parseInlines()
+        inlines
+    }
+
+    parseBullets(firstLine: String): List[List[Inline]] {
+        let pair = self.consumeToSome {line =>
+            let trimmed = line.trim()
+            let endWithNextLine = trimmed.{
+                | "" => Some(None)
+                | t {t.removeFirst("* ") | Some(nextLine)} => Some(Some(nextLine))
+                | _ => None
+            }
+            endWithNextLine
+        }
+        let bulletLines = [firstLine, ...pair.first]
+        let bullet = self.parseInlines(bulletLines)
+        pair.second.{
+            | None => [bullet]
+            | Some(None) => [bullet]
+            | Some(Some(nextLine)) => [bullet, ...self.parseBullets(nextLine)]
+        }
+    }
+
+    parseRemainingCodeBlock(isFirefly: Bool): Block {
+        let code = self.consumeWhile {!_.trimStart().startsWith("```")}
+        self.skip(1)
+        CodeBlock(code.join("\n"), isFirefly)
+    } 
+    
+    first(): Option[String] {
+        if(self.i < self.lines.size()) {
+            self.lines.grab(self.i)
+        }
+    }
+    
+    skip(count: Int): Unit {
+        self.i += count
+    }
+    
+    skipWhile(body: String => Bool): Unit {
+        while {self.i < self.lines.size() && body(self.lines.grab(self.i))} {
+            self.i += 1
+        }
+    }
+    
+    consumeWhile(body: String => Bool): List[String] {
+        let oldI = self.i
+        self.skipWhile(body)
+        self.lines.slice(oldI, self.i)
+    }
+
+    consumeToSome[T](body: String => Option[T]): Pair[List[String], Option[T]] {
+        let oldI = self.i
+        mutable end = None
+        while {self.i < self.lines.size() && end.isEmpty()} {
+            end = body(self.lines.grab(self.i))
+            self.i += 1
+        }
+        let endI = if(end.isEmpty()) {self.i} else {self.i - 1}
+        Pair(self.lines.slice(oldI, endI), end)
+    }
+}
+
+class InlineParser(
+    fileName: String
+    line: String
+    mutable i: Int
+)
+
+extend self: InlineParser {
+    
+    parseInlines(): List[Inline] {
+        iterateLists {self.parseInline()}
+    }
+       
+    parseInline(): List[Inline] {
+        mutable inline = []
+        mutable j = 0
+        
+        doWhile {
+            let remaining = self.size() - j
+            if(remaining >= 3) {
+                self.grab(j).{
+                    | '_' => inline = self.parseNextInline(j, {self.parseItalic()})
+                    | '`' => inline = self.parseNextInline(j, {self.parseCode()})
+                    | '[' => inline = self.parseNextInline(j, {self.parseLink()})
+                    | '*' {self.grab(j + 1) == '*'} => inline = self.parseNextInline(j, {self.parseBold()})
+                    | _ =>
+                }
+            }
+            j += 1
+            remaining > 0 && inline.isEmpty()
+        }
+
+        inline.{
+            | [] {j == 1} => []
+            | []  => [Text(self.consume(j - 1))]
+            | inlines => inlines
+        }
+    }     
+    
+    parseNextInline(offset: Int, parseNext: () => Option[Inline]): List[Inline] {
+        if(offset == 0) {parseNext().toList()} else:
+
+        let oldI = self.i
+        self.i += offset
+        parseNext().{
+            | None => 
+                self.i = oldI
+                []
+            | Some(nextInline) => 
+                let text = self.line.slice(oldI, oldI + offset)
+                let textInline = Text(text)
+                [textInline, nextInline]
+        }
+    }
+    
+    parseLink(): Option[Inline] {
+        let oldI = self.i
+        self.parseEnclosed("[", "]").flatMap {text => 
+            self.parseEnclosed("(", ")").{
+                | None => 
+                    self.i = oldI
+                    None
+                | Some(url) => Some(Link(text, url))
+            }
+        }
+    }
+
+    parseBold(): Option[Inline] {
+        self.parseEnclosed("**", "**").map {Bold(_)}
+    }
+
+    parseItalic(): Option[Inline] {
+        self.parseEnclosed("_", "_").map {Italic(_)}
+    }
+    
+    parseCode(): Option[Inline] {
+        self.parseEnclosed("`", "`").map {Code(_)}
+    }
+    
+    parseEnclosed(left: String, right: String): Option[String] {
+        if(self.startsWith(left)) {
+            indexOf(self.line, right, self.i + left.size()).map {end =>
+                let text = self.line.slice(self.i + left.size(), end)
+                self.i = end + right.size()
+                text
+            }
+        }.flatten()
+    }    
+       
+    grab(index: Int): Char {
+        self.line.grab(self.i + index)
+    }
+    
+    size(): Int {
+        self.line.size() - self.i
+    }
+    
+    startsWith(text: String): Bool {
+        self.size() >= text.size() && self.line.slice(self.i, self.i + text.size()) == text
+    }
+    
+    consume(count: Int): String {
+        let text = self.line.slice(self.i, self.i + count)
+        self.i += count
+        text
+    }    
+}
+
+iterate[T](body: () => Option[T]): List[T] {
+    let array = Array.new()
+    doWhile {
+        body().{
+            | None => False
+            | Some(s) =>
+                array.push(s)
+                True
+        }
+    }
+    array.drain()  
+}   
+
+iterateLists[T](body: () => List[T]): List[T] {
+    let array = Array.new()
+    doWhile {
+        body().{
+            | [] => False
+            | list =>
+                array.pushList(list)
+                True
+        }
+    }
+    array.drain()  
+}   
+
+indexOf(string: String, searchString: String, position: Int = 0): Option[Int]
+    target js sync """
+        const i = string_.indexOf(searchString_, position_);
+        return i == -1 ? ff_core_Option.None() : ff_core_Option.Some(i);
+    """
+    
+printSections(system: NodeSystem, sections: List[Section]) {
+    sections.each {
+        | Section(heading, blocks) => 
+            system.writeLine("# " + heading)
+            blocks.each {
+                | Bullets(items) => 
+                    system.writeLine("  Bullets:")
+                    system.writeLine("    " + Show.show(items))
+                | CodeBlock(code, True) => 
+                    system.writeLine("  Code (Firefly):")
+                    system.writeLine("    " + Show.show(code))
+                | CodeBlock(code, False) => 
+                    system.writeLine("  Code:")
+                    system.writeLine("    " + Show.show(code))
+                | Image(url) => 
+                    system.writeLine("  Image:")
+                    system.writeLine("    " + Show.show(url))
+                | LuxDemo(demo) => 
+                    system.writeLine("  Lux:")
+                    system.writeLine("    " + Show.show(demo))
+                | Paragraph(inlines) => 
+                    system.writeLine("  Paragraph:")
+                    inlines.each {
+                        | Anchor(heading, title) => 
+                            system.writeLine("    Anchor: " + Show.show(heading) + ", " + Show.show(title))
+                        | Bold(text) => 
+                            system.writeLine("    Bold: " + Show.show(text))
+                        | Code(code, True) => 
+                            system.writeLine("    Code (firefly): " + Show.show(code))
+                        | Code(code, False) => 
+                            system.writeLine("    Code: " + Show.show(code))
+                        | Italic(text) => 
+                            system.writeLine("    Italic: " + Show.show(text))
+                        | Link(text, url) => 
+                            system.writeLine("    Link: " + Show.show(text) + ", " + Show.show(url))
+                        | Text(text) => 
+                            system.writeLine("    Text: " + Show.show(text))
+                    }
+                | Video(url) => 
+                    system.writeLine("  Video:")
+                    system.writeLine("    " + Show.show(url))
+            }
+        | SplitSection(heading, first, second) => 
+            system.writeLine("SPLIT")
+    }    
+}

package/fireflysite/ExamplesOverview.ff

@@ -1,18 +1,27 @@
 import Guide
 import CountingButtonDemo
 import MatchingPasswordsDemo
+import PostgresqlDemo
 
 mock(): List[Document] {
     [
         new()
         CountingButtonDemo.newDocument()
         MatchingPasswordsDemo.newDocument()
+        PostgresqlDemo.newDocument()
+    ]
+}
+
+demos(): List[Demo] {
+    [
+        CountingButtonDemo.new()
+        MatchingPasswordsDemo.new()
     ]
 }
 
 new(): Document {
-    Document([
-        Section("Overview", [
+    ReadyDocument([
+        Section("Examples", [
             Paragraph([
                 Text("Here you'll find examples that demonstrate what you can do with Firefly.")
                 Text("In fact, you're looking at an example right now - this site is")