firefly-compiler 0.5.39 → 0.5.40

package/experimental/bidirectional/Bidi.ff

@@ -1,88 +1,88 @@
-data Expression {
-    EVariable(name: String)
-    EApply(function: Expression, argument: Expression)
-    ELambda(variable: String, body: Expression)
-    EAnnotate(type: Type, expression: Expression)
-}
-
-data Type(name: String, typeArguments: List[Type])
-
-data Context(variables: Map[String, Type])
-
-data TypeError(message: String)
-
-
-check(c0: Context, t0: Type, e0: Expression): Unit {
-    e0.{
-        | ELambda(x1, e1) => 
-            t0.{
-                | Type("Function", [t2, t3]) =>
-                    let c2 = c0.Context(variables = c0.variables.add(x1, t2))
-                    check(c2, t3, e1)
-                    t3
-                | _ =>
-                    throw(TypeError("Function type not expected here"))
-            }
-        | _ => 
-            let t1 = infer(c0, e0)
-            checkSame(t0, t1)
-    }
-}
-
-
-infer(c0: Context, e0: Expression): Type {
-    e0.{
-        | EVariable(x1) => 
-            c0.variables.get(x1).{
-                | None => 
-                    throw(TypeError("Variable not in scope: " + x1))
-                | Some(t1) => 
-                    t1
-            }
-        | EApply(e1, e2) => 
-            let t1 = infer(c0, e1)
-            t1.{
-                | Type("Function", [t2, t3]) =>
-                    check(c0, t2, e2)
-                    t3
-                | _ =>
-                    throw(TypeError("Can't call non-functions"))
-            }
-        | ELambda _ => 
-            throw(TypeError("Lambda functions must be explicitly typed"))
-        | EAnnotate(t1, e1) =>
-            checkType(t1)
-            check(c0, t1, e1)
-            t1
-    }
-}
-
-
-checkSame(t1: Type, t2: Type): Unit {
-    if(t1.name != t2.name) {throw(TypeError("Type mismatch: " + t1.name + " vs. " + t2.name + ""))}
-    if(t1.typeArguments.size() != t2.typeArguments.size()) {
-        throw(TypeError(
-            "Type mismatch: " + t1.name + " with " + 
-            t1.typeArguments.size() + " vs. " + t2.typeArguments.size() +
-            " type arguments"
-        ))
-    }
-    t1.typeArguments.zip(t2.typeArguments).each {| Pair(t3, t4) =>
-        checkSame(t3, t4)
-    }
-}
-
-
-checkType(t0: Type): Unit {
-    t0.{
-        | Type("Function", [t1, t2]) =>
-            checkType(t1)
-            checkType(t2)
-        | Type("Bool", []) =>
-        | Type("Int", []) =>
-        | Type("List", [t1]) =>
-            checkType(t1)
-        | _ =>
-            throw(TypeError("Type is not well formed"))
-    }
-}
+data Expression {
+    EVariable(name: String)
+    EApply(function: Expression, argument: Expression)
+    ELambda(variable: String, body: Expression)
+    EAnnotate(type: Type, expression: Expression)
+}
+
+data Type(name: String, typeArguments: List[Type])
+
+data Context(variables: Map[String, Type])
+
+data TypeError(message: String)
+
+
+check(c0: Context, t0: Type, e0: Expression): Unit {
+    e0.{
+        | ELambda(x1, e1) => 
+            t0.{
+                | Type("Function", [t2, t3]) =>
+                    let c2 = c0.Context(variables = c0.variables.add(x1, t2))
+                    check(c2, t3, e1)
+                    t3
+                | _ =>
+                    throw(TypeError("Function type not expected here"))
+            }
+        | _ => 
+            let t1 = infer(c0, e0)
+            checkSame(t0, t1)
+    }
+}
+
+
+infer(c0: Context, e0: Expression): Type {
+    e0.{
+        | EVariable(x1) => 
+            c0.variables.get(x1).{
+                | None => 
+                    throw(TypeError("Variable not in scope: " + x1))
+                | Some(t1) => 
+                    t1
+            }
+        | EApply(e1, e2) => 
+            let t1 = infer(c0, e1)
+            t1.{
+                | Type("Function", [t2, t3]) =>
+                    check(c0, t2, e2)
+                    t3
+                | _ =>
+                    throw(TypeError("Can't call non-functions"))
+            }
+        | ELambda _ => 
+            throw(TypeError("Lambda functions must be explicitly typed"))
+        | EAnnotate(t1, e1) =>
+            checkType(t1)
+            check(c0, t1, e1)
+            t1
+    }
+}
+
+
+checkSame(t1: Type, t2: Type): Unit {
+    if(t1.name != t2.name) {throw(TypeError("Type mismatch: " + t1.name + " vs. " + t2.name + ""))}
+    if(t1.typeArguments.size() != t2.typeArguments.size()) {
+        throw(TypeError(
+            "Type mismatch: " + t1.name + " with " + 
+            t1.typeArguments.size() + " vs. " + t2.typeArguments.size() +
+            " type arguments"
+        ))
+    }
+    t1.typeArguments.zip(t2.typeArguments).each {| Pair(t3, t4) =>
+        checkSame(t3, t4)
+    }
+}
+
+
+checkType(t0: Type): Unit {
+    t0.{
+        | Type("Function", [t1, t2]) =>
+            checkType(t1)
+            checkType(t2)
+        | Type("Bool", []) =>
+        | Type("Int", []) =>
+        | Type("List", [t1]) =>
+            checkType(t1)
+        | _ =>
+            throw(TypeError("Type is not well formed"))
+    }
+}

package/experimental/lines/Main.ff

@@ -1,40 +1,40 @@
-nodeMain(system: NodeSystem) {
-    let extension = system.arguments().grab(0)
-    let root = system.arguments().grab(1)
-    let path = system.path(root)
-    let count = countPathLines(system, extension, path)
-    system.writeLine("Total lines: " + count)
-}
-
-countPathLines(system: NodeSystem, extension: String, path: Path): Int {
-    mutable count = 0
-    if(path.isFile()) {
-        if(path.extension() == extension) {
-            count += countFileLines(path)
-        }
-    } elseIf {path.isDirectory()} {
-        path.entries().each {p =>
-            let relative = p.path().relativeTo(path)
-            if(!relative.startsWith(".") && !relative.contains("_")) {
-                count += countPathLines(system, extension, p.path())
-            }
-        }
-    }
-    if(count != 0) {
-        system.writeLine(path.absolute() + "    " + count + " lines")
-    }
-    count
-}
-
-countFileLines(path: Path): Int {
-    mutable count = 0
-    path.readText().lines().each {line =>
-        let trimmed = line.trim()
-        if(trimmed == "" || trimmed.startsWith("//")) {
-            // Multiline comments not supported yet
-        } else {
-            count += 1
-        }
-    }
-    count
-}
+nodeMain(system: NodeSystem) {
+    let extension = system.arguments().grab(0)
+    let root = system.arguments().grab(1)
+    let path = system.path(root)
+    let count = countPathLines(system, extension, path)
+    system.writeLine("Total lines: " + count)
+}
+
+countPathLines(system: NodeSystem, extension: String, path: Path): Int {
+    mutable count = 0
+    if(path.isFile()) {
+        if(path.extension() == extension) {
+            count += countFileLines(path)
+        }
+    } elseIf {path.isDirectory()} {
+        path.entries().each {p =>
+            let relative = p.path().relativeTo(path)
+            if(!relative.startsWith(".") && !relative.contains("_")) {
+                count += countPathLines(system, extension, p.path())
+            }
+        }
+    }
+    if(count != 0) {
+        system.writeLine(path.absolute() + "    " + count + " lines")
+    }
+    count
+}
+
+countFileLines(path: Path): Int {
+    mutable count = 0
+    path.readText().lines().each {line =>
+        let trimmed = line.trim()
+        if(trimmed == "" || trimmed.startsWith("//")) {
+            // Multiline comments not supported yet
+        } else {
+            count += 1
+        }
+    }
+    count
+}

package/experimental/random/Index.ff

@@ -1,53 +1,53 @@
-data Index[K, R]()
-
-extend self[K, R]: Index[K, R] {
-    
-    get(key: K): Option[R] {
-        panic("Oops")
-    }
-
-    getUnique(key: K): Option[R] {
-        panic("Oops")
-    }
-    
-    getOnly(): Option[R] {
-        panic("Oops")
-    }
-
-    grab(key: K): R {
-        panic("Oops")
-    }
-
-    grabUnique(key: K): R {
-        panic("Oops")
-    }
-
-    grabOnly(key: K): R {
-        panic("Oops")
-    }
-
-    getAll(key: K): List[R] {
-        panic("Oops")
-    }
-
-    range(from: K, until: K): Index[K, R] {
-        panic("Oops")
-    }
-    
-    join[R1](that: Index[K, R1]): Index[K, Pair[R, R1]] {
-        panic("Oops")
-    }
-    
-    keep(only: Set[K]): Index[K, R] {
-        panic("Oops")
-    }
-    
-    filter(body: (K, R) => Bool): Index[K, R] {
-        panic("Oops")
-    }
-    
-    withKeys[K1](body: (K, R) => K1): Index[K1, R] {
-        panic("Oops")
-    }
-    
-}
+data Index[K, R]()
+
+extend self[K, R]: Index[K, R] {
+    
+    get(key: K): Option[R] {
+        panic("Oops")
+    }
+
+    getUnique(key: K): Option[R] {
+        panic("Oops")
+    }
+    
+    getOnly(): Option[R] {
+        panic("Oops")
+    }
+
+    grab(key: K): R {
+        panic("Oops")
+    }
+
+    grabUnique(key: K): R {
+        panic("Oops")
+    }
+
+    grabOnly(key: K): R {
+        panic("Oops")
+    }
+
+    getAll(key: K): List[R] {
+        panic("Oops")
+    }
+
+    range(from: K, until: K): Index[K, R] {
+        panic("Oops")
+    }
+    
+    join[R1](that: Index[K, R1]): Index[K, Pair[R, R1]] {
+        panic("Oops")
+    }
+    
+    keep(only: Set[K]): Index[K, R] {
+        panic("Oops")
+    }
+    
+    filter(body: (K, R) => Bool): Index[K, R] {
+        panic("Oops")
+    }
+    
+    withKeys[K1](body: (K, R) => K1): Index[K1, R] {
+        panic("Oops")
+    }
+    
+}

package/experimental/random/Process.ff

@@ -1,120 +1,120 @@
-capability Process {}
-
-data ProcessException(exitCode: Int)
-
-extend self: Process {
-    
-    readStream(): Stream[Buffer] {
-        
-    }
-    
-    readErrorStream(): Stream[Buffer] {
-        
-    }
-    
-    readBothStreams(): Stream[Pair[Bool, Buffer]] {
-        
-    }
-    
-    readBuffer(): Buffer {
-        
-    }
-    
-    readErrorBuffer(): Buffer {
-        
-    }
-    
-    readBothBuffers(): Pair[Buffer, Buffer] {
-        
-    }
-    
-    readText(): String {
-        
-    }
-    
-    readErrorText(): String {
-        
-    }
-    
-    readBothTexts(): Pair[String, String] {
-        
-    }
-    
-    writeStream(stream: Stream[Buffer]) {
-        
-    }
-    
-    writeBuffer(buffer: Buffer) {
-        
-    }
-    
-    writeText(text: String) {
-        
-    }
-    
-    writeLine(text: String) {
-        
-    }
-    
-    closeStandardIn() {
-        
-    }
-    
-    running(): Bool {
-        
-    }
-    
-    exitCode(): Int {
-        
-    }
-    
-    setEnvironment(environment: Map[String, String]) {
-        
-    }
-    
-    setEnvironmentVariable(name: String, value: String) {
-        
-    }
-    
-    setWorkingDirectory(path: Path) {
-        
-    }
-    
-    setArgumentZero(commandName: String) {
-        
-    }
-    
-    setRedirection(in: Bool = False, out: Bool = False, error: Bool = False) {
-        
-    }
-    
-    setCloseAfterWrite(close: Bool) {
-        
-    }
-    
-}
-
-internalExecute[T](system: NodeSystem, command: String, arguments: List[String], body: Process => T): T {
-    throw(GrabException) // TODO
-}
-
-main(system: NodeSystem) {
-    let initialize = ""
-    let hoverRequest = ""
-    function parseInitializeResponse(stream: Stream[Buffer]) {
-        
-    }
-    function parseHoverResponse(stream: Stream[Buffer]) {
-        
-    }
-    
-    system.execute("my-lsp", []) {process =>
-        process.setCloseAfterWrite(False)
-        let stream = process.readStream()
-        process.writeText(initialize)
-        let config = parseInitializeResponse(stream)
-        process.writeText(hoverRequest)
-        let hover = parseHoverResponse(stream)
-        // ...
-    }
-}
+capability Process {}
+
+data ProcessException(exitCode: Int)
+
+extend self: Process {
+    
+    readStream(): Stream[Buffer] {
+        
+    }
+    
+    readErrorStream(): Stream[Buffer] {
+        
+    }
+    
+    readBothStreams(): Stream[Pair[Bool, Buffer]] {
+        
+    }
+    
+    readBuffer(): Buffer {
+        
+    }
+    
+    readErrorBuffer(): Buffer {
+        
+    }
+    
+    readBothBuffers(): Pair[Buffer, Buffer] {
+        
+    }
+    
+    readText(): String {
+        
+    }
+    
+    readErrorText(): String {
+        
+    }
+    
+    readBothTexts(): Pair[String, String] {
+        
+    }
+    
+    writeStream(stream: Stream[Buffer]) {
+        
+    }
+    
+    writeBuffer(buffer: Buffer) {
+        
+    }
+    
+    writeText(text: String) {
+        
+    }
+    
+    writeLine(text: String) {
+        
+    }
+    
+    closeStandardIn() {
+        
+    }
+    
+    running(): Bool {
+        
+    }
+    
+    exitCode(): Int {
+        
+    }
+    
+    setEnvironment(environment: Map[String, String]) {
+        
+    }
+    
+    setEnvironmentVariable(name: String, value: String) {
+        
+    }
+    
+    setWorkingDirectory(path: Path) {
+        
+    }
+    
+    setArgumentZero(commandName: String) {
+        
+    }
+    
+    setRedirection(in: Bool = False, out: Bool = False, error: Bool = False) {
+        
+    }
+    
+    setCloseAfterWrite(close: Bool) {
+        
+    }
+    
+}
+
+internalExecute[T](system: NodeSystem, command: String, arguments: List[String], body: Process => T): T {
+    throw(GrabException) // TODO
+}
+
+main(system: NodeSystem) {
+    let initialize = ""
+    let hoverRequest = ""
+    function parseInitializeResponse(stream: Stream[Buffer]) {
+        
+    }
+    function parseHoverResponse(stream: Stream[Buffer]) {
+        
+    }
+    
+    system.execute("my-lsp", []) {process =>
+        process.setCloseAfterWrite(False)
+        let stream = process.readStream()
+        process.writeText(initialize)
+        let config = parseInitializeResponse(stream)
+        process.writeText(hoverRequest)
+        let hover = parseHoverResponse(stream)
+        // ...
+    }
+}