firefly-compiler 0.4.40 → 0.4.48

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/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)
+        // ...
+    }
+}

package/experimental/random/Scrape.ff

@@ -1,51 +1,51 @@
-
-nodeMain(system: NodeSystem) {
-    
-    let urlFile = system.arguments().grab(0)
-    let urls = system.path(urlFile).readText().lines()
-    
-    let urlChannel = system.mainTask().channel(urls.size())
-    let htmlChannel = system.mainTask().channel(urls.size())
-    let resultChannel = system.mainTask().channel(urls.size())
-    
-    1.to(1000).each {_ => 
-        system.mainTask().spawn {task =>
-            let url = urlChannel.read()
-            let html = system.httpClient().fetch(url).readText()
-            htmlChannel.write(html)
-        }
-    }
-
-    1.to(10).each {_ => 
-        system.mainTask().spawn {task =>
-            let html = htmlChannel.read()
-            let result = scrape(html)
-            resultChannel.write(result)
-        }
-    }
-
-    urls.each {url => urlChannel.write(url)}
-    let results = urls.map {_ => resultChannel.read()}
-    system.writeText(results.join("\n"))
-    
-}
-
-scrape(html: String): String {
-    html // Uhm...
-}
-
-foo() {
-    
-    let result = urls.toStream()
-        .parallelMap(threads = 1000) {url => download(url)}
-        .parallelMap(threads = 10) {result => result.map(scrape)}
-
-    let result = urls.toStream()
-        .parallelMap(threads = 1000) {task, url => task.timeout(Duration(5)) {download(url)}}
-        .parallelMap(threads = 10) {_, result => result.map(scrape)}
-
-    let result = urls.toStream()
-        .parallelMap(1000) {task, url => task.deadline(task.now().add(Duration(5))) {download(url)}}
-        .parallelMap(10) {_, result => result.map(scrape)}
-    
-}
+
+nodeMain(system: NodeSystem) {
+    
+    let urlFile = system.arguments().grab(0)
+    let urls = system.path(urlFile).readText().lines()
+    
+    let urlChannel = system.mainTask().channel(urls.size())
+    let htmlChannel = system.mainTask().channel(urls.size())
+    let resultChannel = system.mainTask().channel(urls.size())
+    
+    1.to(1000).each {_ => 
+        system.mainTask().spawn {task =>
+            let url = urlChannel.read()
+            let html = system.httpClient().fetch(url).readText()
+            htmlChannel.write(html)
+        }
+    }
+
+    1.to(10).each {_ => 
+        system.mainTask().spawn {task =>
+            let html = htmlChannel.read()
+            let result = scrape(html)
+            resultChannel.write(result)
+        }
+    }
+
+    urls.each {url => urlChannel.write(url)}
+    let results = urls.map {_ => resultChannel.read()}
+    system.writeText(results.join("\n"))
+    
+}
+
+scrape(html: String): String {
+    html // Uhm...
+}
+
+foo() {
+    
+    let result = urls.toStream()
+        .parallelMap(threads = 1000) {url => download(url)}
+        .parallelMap(threads = 10) {result => result.map(scrape)}
+
+    let result = urls.toStream()
+        .parallelMap(threads = 1000) {task, url => task.timeout(Duration(5)) {download(url)}}
+        .parallelMap(threads = 10) {_, result => result.map(scrape)}
+
+    let result = urls.toStream()
+        .parallelMap(1000) {task, url => task.deadline(task.now().add(Duration(5))) {download(url)}}
+        .parallelMap(10) {_, result => result.map(scrape)}
+    
+}