firefly-compiler 0.4.77 → 0.4.79

package/fireflysite/Guide.ff

@@ -0,0 +1,411 @@
+import Lux from ff:lux
+import LuxEvent from ff:lux
+import Css from ff:lux
+import Tokenizer from ff:compiler
+import Token from ff:compiler
+import Styles
+import DocumentParser
+
+data Guide(
+    prefix: String
+    documents: List[Document]
+)
+
+data Document {
+    ReadyDocument(
+        sections: List[Section]
+    )
+    UnfetchedDocument(
+        header: String
+    )
+}
+
+
+data Section(heading: String) {
+    Section(
+        blocks: List[Block]
+    )
+    SplitSection(
+        first: Block
+        second: Block
+    )
+}
+
+data Block {
+    Paragraph(inlines: List[Inline])
+    Bullets(items: List[List[Inline]])
+    CodeBlock(code: String, firefly: Bool = False)
+    Image(url: String)
+    Video(url: String)
+    LuxDemo(demo: String)
+}
+
+data Inline {
+    Text(text: String)
+    Bold(text: String)
+    Italic(text: String)
+    Code(code: String, firefly: Bool = False)
+    Link(text: String, url: String)
+    Anchor(heading: String, title: Option[String] = None)
+}
+
+extend self: Guide {
+    heading(): String {
+        self.documents.first().map {_.heading()}.else {""}
+    }
+    title(): String {
+        if(self.heading() == "Firefly") {self.heading()} else {"Firefly " + self.heading()}
+    }
+}
+
+extend self: Document {
+    heading(): String {
+        self.{
+            | ReadyDocument(sections) => 
+                sections.first().map {_.heading}.else {""}
+            | UnfetchedDocument(header) => header
+        }
+    }
+    title(guide: Guide): String {
+        if(guide.documents.first().any {_.heading() == self.heading()}) {
+            guide.title()
+        } else {
+            self.heading() + " · " + guide.title()
+        }
+    }
+    path(guide: Guide): String {
+        if(guide.documents.first().any {_.heading() == self.heading()}) {
+            guide.prefix
+        } else {
+            guide.prefix + kebabCase(self.heading())
+        }
+    }
+}
+
+capability Demo(
+    name: String
+    render: Lux => Unit
+)
+
+data GuideDocument(
+    guide: Guide
+    document: Document
+)
+
+render(lux: Lux, browser: BrowserSystem, 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)
+    }}
+    let nextDocument = guideDocuments.dropWhile {n => 
+        n.guide.prefix != guide.prefix || n.document.heading() != document.heading()
+    }.dropFirst().first()
+    lux.add("div") {
+        lux.useState(False): menu, setMenu =>
+        lux.cssClass(Styles.pageCss)
+        lux.add("div") {
+            lux.cssClass(Styles.guideCss)
+            lux.add("main") {
+                lux.cssClass(Styles.guideMainCss)
+                renderDocument(lux, browser.httpClient(), document, demos, nextDocument)
+            }
+            lux.add("button") {
+                lux.set("aria-label", "Toggle the menu")
+                lux.cssClass(Styles.guideSidebarButtonCss)
+                if(menu) {lux.cssClass(Styles.guideSidebarButtonOpenCss)}
+                lux.onClick {event =>
+                    event.preventDefault()
+                    setMenu(True)
+                }
+            }
+            lux.add("div") {
+                lux.cssClass(Styles.guideSidebarBackdropCss)
+                if(menu) {lux.cssClass(Styles.guideSidebarBackdropOpenCss)}
+                lux.onClick {event =>
+                    event.preventDefault()
+                    setMenu(False)
+                }
+            }
+            renderSidebar(lux, guides, guide, document.heading(), menu)
+        }
+    }
+}
+
+renderSidebar(lux: Lux, guides: List[Guide], selectedGuide: Guide, selectedHeading: String, menu: Bool) {
+    lux.add("nav") {
+        lux.cssClass(Styles.guideSidebarCss)
+        if(menu) {lux.cssClass(Styles.guideSidebarOpenCss)}
+        lux.add("a") {
+            lux.set("href", "/front/")
+            lux.cssClass(Styles.guideSidebarLogoCss)
+            lux.add("img") {
+                lux.set("src", "/assets/firefly-logo-yellow.png")
+            }
+            lux.div {
+                lux.text("Firefly")
+            }
+        }
+        lux.add("form") {
+            lux.set("role", "search")
+            lux.add("input") {
+                lux.set("aria-label", "Search")
+                lux.cssClass(Styles.searchInputCss)
+                lux.set("placeholder", "Search...")
+            }
+        }
+        lux.add("ul") {
+            lux.cssClass(Styles.guideSidebarUl1Css)
+            guides.dropFirst().each {guide =>
+                lux.add("li") {
+                    lux.cssClass(Styles.guideSidebarLi1Css)
+                    lux.add("a") {
+                        lux.cssClass(Styles.whiteLinkCss)
+                        let heading = guide.documents.grabFirst().heading()
+                        if(selectedGuide.prefix == guide.prefix && heading == selectedHeading) {
+                            lux.set("aria-current", "page")
+                        }
+                        lux.set("href", guide.prefix)
+                        lux.text(heading)
+                    }
+                    if(guide.documents.size() > 1): 
+                    lux.add("ul") {
+                        lux.cssClass(Styles.guideSidebarUl2Css)
+                        guide.documents.dropFirst().each {document =>
+                            lux.add("li") {
+                                lux.cssClass(Styles.guideSidebarLi2Css)
+                                lux.add("a") {
+                                    lux.cssClass(Styles.whiteLinkCss)
+                                    let heading = document.heading()
+                                    if(selectedGuide.prefix == guide.prefix && heading == selectedHeading) {
+                                        lux.set("aria-current", "page")
+                                    }
+                                    lux.set("href", guide.prefix + kebabCase(heading))
+                                    lux.text(heading)
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+renderDocument(lux: Lux, http: HttpClient, document: Document, demos: List[Demo], nextDocument: Option[GuideDocument]) {
+    lux.add("article") {
+        lux.cssClass(Styles.guideDocumentCss)
+        document.{
+            | ReadyDocument(sections) => 
+                renderSections(lux, sections, demos)
+            | UnfetchedDocument(header) => 
+                lux.div {
+                    lux.useSuspense {lux.div {lux.text("Loading document...")}}: lux =>
+                    let asset = "/assets/markdown/" + document.heading().replace(" ", "") + ".md"
+                    let markdown = http.get(asset, []) {_.readText()}
+                    let parser = DocumentParser(asset, markdown.split('\n'))
+                    let sections = parser.parseDocument()
+                    renderSections(lux, sections, demos)
+                }
+        }
+        nextDocument.each {next => 
+            lux.div {
+                lux.cssClass(Styles.guideNextButtonCss)
+                lux.add("a") {
+                    lux.cssClass(Styles.guideButtonCss)
+                    lux.set("href", next.document.path(next.guide))
+                    lux.text("Next: " + next.document.heading())
+                }
+            }
+        }
+    }
+}
+
+renderSections(lux: Lux, sections: List[Section], demos: List[Demo]) {
+    sections.pairs().each {| Pair(index, section) => 
+        renderSection(lux, index == 0, section, demos)
+    }
+}
+
+renderSection(lux: Lux, firstSection: Bool, section: Section, demos: List[Demo]) {
+    section.{
+        | Section(heading, blocks) => 
+            lux.add(if(firstSection) {"h1"} else {"h2"}) {
+                lux.cssClass(if(firstSection) {Styles.guideH1Css} else {Styles.guideH2Css})
+                lux.text(heading)
+            }
+            blocks.each {renderBlock(lux, _, demos)}
+        | SplitSection(heading, first, second) => 
+            lux.add("div") {
+                lux.cssClass(Styles.guideSplitCss)
+                lux.add("div") {
+                    lux.add("h2") {
+                        lux.cssClass(Styles.guideSplitHeadingCss)
+                        lux.text(section.heading)
+                    }
+                    renderBlock(lux, first, demos)
+                }
+                lux.add("div") {
+                    renderBlock(lux, second, demos)
+                }
+            }
+        }
+}
+
+renderBlock(lux: Lux, block: Block, demos: List[Demo]) {
+    block.{
+        | Paragraph(inlines) => renderParagraph(lux, inlines)
+        | CodeBlock(code, firefly) => renderCodeBlock(lux, code, firefly)
+        | Bullets(items) => renderBullets(lux, items)
+        | Image(url) => renderImage(lux, url)
+        | Video(url) => renderVideo(lux, url)
+        | LuxDemo(name) => renderLuxDemo(lux, name, demos)
+    }
+}
+
+renderParagraph(lux: Lux, inlines: List[Inline]) {
+    lux.add("p") {
+        renderInlines(lux, inlines)
+    }
+}
+
+renderCodeBlock(lux: Lux, code: String, firefly: Bool) {
+    let lines = code.lines().dropWhile {_.all {_ == ' '}}.reverse().dropWhile {_.all {_ == ' '}}.reverse()
+    let indentation = lines.first().map {_.takeWhile {_ == ' '}.size()}.else {0}
+    lux.add("pre") {
+        lux.cssClass(Styles.guideCodeBlockCss)
+        lux.add("code") {
+            lux.cssClass(Styles.guideCodeCss)
+            let unindentedCode = lines.map {_.dropFirst(indentation)}.join("\n")
+            if(firefly) {
+                renderHighlightedCode(lux, unindentedCode)
+            } else {
+                lux.text(unindentedCode)
+            }
+        }
+    }
+}
+
+renderBullets(lux: Lux, items: List[List[Inline]]) {
+    lux.add("ul") {
+        items.each {inlines =>
+            lux.add("li") {
+                renderInlines(lux, inlines)
+            }
+        }
+    }
+}
+
+renderImage(lux: Lux, url: String) {
+    lux.add("img") {
+        lux.set("src", url)
+        lux.css(Css.maxWidth("100%"))
+        lux.css(Css.borderRadius("8px"))
+    }
+}
+
+renderVideo(lux: Lux, url: String) {
+    lux.add("video") {
+        lux.set("src", url)
+        lux.css(Css.maxWidth("100%"))
+    }
+}
+
+renderLuxDemo(lux: Lux, name: String, demos: List[Demo]) {
+    demos.find {_.name == name}.map {_.render(lux)}.else {lux.text("Demo not found")}
+}
+
+renderInlines(lux: Lux, inlines: List[Inline]) {
+    inlines.separate([Text(" ")]).each {renderInline(lux, _)}
+}
+
+renderInline(lux: Lux, inline: Inline) {
+    inline.{
+        | Anchor(heading, title) => 
+            lux.add("a") {
+                let url = title.map {"/guide/" + kebabCase(_)}.else {""} + "#" + kebabCase(heading)
+                lux.cssClass(Styles.guideLinkCss)
+                lux.set("href", url)
+                lux.text(title.map {_ + ": "}.else {""} + heading)
+            }
+        | Bold(text) => 
+            lux.add("b") {
+                lux.text(text)
+            }
+        | Code(code, firefly) => 
+            lux.add("code") {
+                lux.cssClass(Styles.guideCodeCss)
+                if(firefly) {
+                    renderHighlightedCode(lux, code)
+                } else {
+                    lux.text(code)
+                }
+            }
+        | Italic(text) => 
+            lux.add("i") {
+                lux.text(text)
+            }
+        | Link(text, url) => 
+            lux.add("a") {
+                lux.cssClass(Styles.guideLinkCss)
+                lux.set("href", url)
+                lux.text(text)
+            }
+        | Text(text) => 
+            lux.text(text)
+    }
+}
+
+renderHighlightedCode(lux: Lux, code: String) {
+    try {
+        Tokenizer.tokenize("<example>", code + "\n", None, False)
+    }.toOption().map {tokens => 
+        mutable offset = 0
+        mutable index = 0
+        tokens.each {token =>
+            if(token.startOffset > offset) {
+                lux.span {
+                    lux.cssClass(Styles.codeCommentCss)
+                    lux.text(code.slice(offset, token.startOffset))
+                }
+            }
+            if(token.kind != LEnd) {
+                let css = token.kind.{
+                    | LChar => Styles.codeStringCss
+                    | LFloat => Styles.codeNumberCss
+                    | LInt => Styles.codeNumberCss
+                    | LKeyword => Styles.codeKeywordCss
+                    | LNamespace => Styles.codeTypeCss
+                    | LString => Styles.codeStringCss
+                    | LUpper => Styles.codeTypeCss
+                    | LWildcard => Styles.codeVariableCss
+                    | LLower {tokens.get(index - 1).any {t => 
+                        t.kind == LBracketRight || t.kind == LDot
+                    }} => Styles.codeCallCss
+                    | LLower {tokens.grab(index + 1).kind == LBracketLeft} => Styles.codeCallCss
+                    | LLower => Styles.codeVariableCss
+                    | _ => Styles.codeOtherCss
+                }
+                lux.span {
+                    lux.cssClass(css)
+                    lux.text(code.slice(token.startOffset, token.stopOffset))
+                }
+                offset = token.stopOffset
+            }
+            index += 1
+        }
+    }.else {lux.text(code)}
+}
+
+kebabCase(text: String): String {
+    mutable result = text.trim().lower().filter {c => c.isAsciiLetterOrDigit() || c == ' '}
+    doWhile {
+        let before = result
+        result = result.replace("  ", "")
+        result != before
+    }
+    result.replace(" ", "-")
+}

package/fireflysite/GuideAll.ff

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,168 @@
+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.")
+            ])
+        ])
+    ])
+}