firefly-compiler 0.5.39 → 0.5.41

package/experimental/random/RunLength.ff

@@ -1,65 +1,65 @@
-main(system: NodeSystem) {
-    let inBuffers = 1.to(100).map {_ => Buffer.fromByteList([5, 5, 3, 1, 2].toArray())}
-    let inStream = inBuffers.toStream()
-    let outStream = toRunLength(inStream, 3)
-    printRunLength(outStream)
-}
-
-printRunLength(outStream: Stream[Buffer]) {
-    let buffer = Buffer.fromBufferList(outStream.toArray())
-    Log.debug(buffer.toHex())
-    let stack = Stack.make()
-    mutable i = 0
-    while {i < buffer.size()} {
-        1.to(buffer.grabUint8(i)).each {_ => stack.push(buffer.grabUint8(i + 1))}
-        i += 2
-    }
-    Log.debug(Buffer.fromByteList(stack.drain()).toHex())
-}
-
-toRunLength(stream: Stream[Buffer], bufferSize: Int = 65536): Stream[Buffer] {
-    mutable outBuffer = Buffer.new(bufferSize)
-    mutable outOffset = 0
-    let outBuffers = Stack.make()
-    function writeByte(byte: Int): Unit {
-        if(outOffset >= outBuffer.size()) {
-            outBuffers.push(outBuffer)
-            outBuffer = Buffer.new(bufferSize)
-            outOffset = 0
-        }
-        outBuffer.setUint8(outOffset, byte)
-        outOffset += 1
-    }
-    mutable extraCount = 0
-    mutable value = 0
-    let result = stream.flatMap {inBuffer =>
-        mutable i = 0
-        while {i < inBuffer.size()} {
-            value = if(extraCount > 0) {value} else {inBuffer.grabUint8(i)}
-            mutable j = if(extraCount > 0) {-1} else {0}
-            doWhile {
-                j += 1
-                j + extraCount < 256 && i + j < inBuffer.size() && inBuffer.grabUint8(i + j) == value
-            }
-            i += j
-            if(i < inBuffer.size() || j + extraCount == 256) {
-                writeByte(j + extraCount)
-                writeByte(value)
-                extraCount = 0
-            } else {
-                extraCount += j
-            }
-        }
-        outBuffers.drain().toStream()
-    }
-    result.addAll(Stream.do {
-        if(extraCount > 0) {
-            writeByte(extraCount)
-            writeByte(value)
-        }
-        if(outOffset > 0) {
-            outBuffers.push(outBuffer.view(0, outOffset))
-        }
-        outBuffers.drain().toStream()
-    })
-}
+main(system: NodeSystem) {
+    let inBuffers = 1.to(100).map {_ => Buffer.fromByteList([5, 5, 3, 1, 2].toArray())}
+    let inStream = inBuffers.toStream()
+    let outStream = toRunLength(inStream, 3)
+    printRunLength(outStream)
+}
+
+printRunLength(outStream: Stream[Buffer]) {
+    let buffer = Buffer.fromBufferList(outStream.toArray())
+    Log.debug(buffer.toHex())
+    let stack = Stack.make()
+    mutable i = 0
+    while {i < buffer.size()} {
+        1.to(buffer.grabUint8(i)).each {_ => stack.push(buffer.grabUint8(i + 1))}
+        i += 2
+    }
+    Log.debug(Buffer.fromByteList(stack.drain()).toHex())
+}
+
+toRunLength(stream: Stream[Buffer], bufferSize: Int = 65536): Stream[Buffer] {
+    mutable outBuffer = Buffer.new(bufferSize)
+    mutable outOffset = 0
+    let outBuffers = Stack.make()
+    function writeByte(byte: Int): Unit {
+        if(outOffset >= outBuffer.size()) {
+            outBuffers.push(outBuffer)
+            outBuffer = Buffer.new(bufferSize)
+            outOffset = 0
+        }
+        outBuffer.setUint8(outOffset, byte)
+        outOffset += 1
+    }
+    mutable extraCount = 0
+    mutable value = 0
+    let result = stream.flatMap {inBuffer =>
+        mutable i = 0
+        while {i < inBuffer.size()} {
+            value = if(extraCount > 0) {value} else {inBuffer.grabUint8(i)}
+            mutable j = if(extraCount > 0) {-1} else {0}
+            doWhile {
+                j += 1
+                j + extraCount < 256 && i + j < inBuffer.size() && inBuffer.grabUint8(i + j) == value
+            }
+            i += j
+            if(i < inBuffer.size() || j + extraCount == 256) {
+                writeByte(j + extraCount)
+                writeByte(value)
+                extraCount = 0
+            } else {
+                extraCount += j
+            }
+        }
+        outBuffers.drain().toStream()
+    }
+    result.addAll(Stream.do {
+        if(extraCount > 0) {
+            writeByte(extraCount)
+            writeByte(value)
+        }
+        if(outOffset > 0) {
+            outBuffers.push(outBuffer.view(0, outOffset))
+        }
+        outBuffers.drain().toStream()
+    })
+}

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

package/experimental/random/Symbols.ff

@@ -1,74 +1,74 @@
-nodeMain(system: NodeSystem) {
-    /*
-    Log.show(splitCamelCased(""))
-    Log.show(splitCamelCased("ABC"))
-    Log.show(splitCamelCased("abc"))
-    Log.show(splitCamelCased("AbC"))
-    Log.show(splitCamelCased("AbCd"))
-    Log.show(splitCamelCased("aaBccDee"))
-    Log.show(splitCamelCased("AaBccDee"))
-    
-    Log.show(prefixes(""))
-    Log.show(prefixes("abcde"))
-    
-    test(["add", "addAll", "addToList"], "al")
-    test(["aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ"], "abcdefghijklmnopqrstuvwxyz")
-    test(["aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ"], "abcdefghijklmnopqrstuvwxyzA")
-    test(["aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ"], "aabcdefghijklmnopqrstuvwxyz")
-    */
-    printTime(system.time(), "matchSymbol") {
-        Log.show(matchSymbol(splitCamelCased("aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ", True), "abcdefghijklmnopqrstuvwxyzA", True))
-    }
-    
-}
-
-test(symbols: List[String], query: String) {
-    Log.debug("")
-    Log.debug("#" + query)
-    symbols.each {s => 
-        let symbolWords = splitCamelCased(s, True)
-        let match = matchSymbol(symbolWords, query, !query.any {_.isAsciiUpper()})
-        Log.debug(s + " (" + Show.show(symbolWords) + " ): " + Show.show(match))
-    }
-}
-
-matchSymbol(symbolWords: List[String], query: String, lower: Bool): Bool {
-    let memo: IntMap[IntMap[Bool]] = IntMap.new()
-    function go(wordIndex: Int, queryOffset: Int): Bool {
-        memo.getOrSet(wordIndex) {IntMap.new()}.getOrSet(queryOffset):
-        if(queryOffset >= query.size()) {True} else:
-        if(wordIndex >= symbolWords.size()) {False} else:
-        prefixes(query.dropFirst(queryOffset)).any {prefix => 
-            symbolWords.grab(wordIndex).startsWith(prefix) && 
-            go(wordIndex + 1, queryOffset + prefix.size())
-        }
-    }
-    go(0, 0)
-}
-
-prefixes(string: String): List[String] {
-    if(string == "") {
-        [""]
-    } else {
-        [string, ...prefixes(string.dropLast())]
-    }
-}
-
-splitCamelCased(name: String, lower: Bool): List[String] {
-    name.first().{
-        | None => []
-        | Some(c) => 
-            let word = c.toString() + name.dropFirst().takeWhile {_.isAsciiLower()}
-            let rest = name.dropFirst(word.size())
-            [if(lower) {word.lower()} else {word}, ...splitCamelCased(rest, lower)]
-    }
-}
-
-printTime[R](ts: TimeSystem, label: String, body: () => R): R {
-    let start = ts.elapsed()
-    let result = body()
-    let stop = ts.elapsed()
-    let duration = ("" + (stop.seconds - start.seconds)).slice(0, 5)
-    Log.trace(label + ": " + duration + "s")
-    result
+nodeMain(system: NodeSystem) {
+    /*
+    Log.show(splitCamelCased(""))
+    Log.show(splitCamelCased("ABC"))
+    Log.show(splitCamelCased("abc"))
+    Log.show(splitCamelCased("AbC"))
+    Log.show(splitCamelCased("AbCd"))
+    Log.show(splitCamelCased("aaBccDee"))
+    Log.show(splitCamelCased("AaBccDee"))
+    
+    Log.show(prefixes(""))
+    Log.show(prefixes("abcde"))
+    
+    test(["add", "addAll", "addToList"], "al")
+    test(["aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ"], "abcdefghijklmnopqrstuvwxyz")
+    test(["aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ"], "abcdefghijklmnopqrstuvwxyzA")
+    test(["aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ"], "aabcdefghijklmnopqrstuvwxyz")
+    */
+    printTime(system.time(), "matchSymbol") {
+        Log.show(matchSymbol(splitCamelCased("aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ", True), "abcdefghijklmnopqrstuvwxyzA", True))
+    }
+    
+}
+
+test(symbols: List[String], query: String) {
+    Log.debug("")
+    Log.debug("#" + query)
+    symbols.each {s => 
+        let symbolWords = splitCamelCased(s, True)
+        let match = matchSymbol(symbolWords, query, !query.any {_.isAsciiUpper()})
+        Log.debug(s + " (" + Show.show(symbolWords) + " ): " + Show.show(match))
+    }
+}
+
+matchSymbol(symbolWords: List[String], query: String, lower: Bool): Bool {
+    let memo: IntMap[IntMap[Bool]] = IntMap.new()
+    function go(wordIndex: Int, queryOffset: Int): Bool {
+        memo.getOrSet(wordIndex) {IntMap.new()}.getOrSet(queryOffset):
+        if(queryOffset >= query.size()) {True} else:
+        if(wordIndex >= symbolWords.size()) {False} else:
+        prefixes(query.dropFirst(queryOffset)).any {prefix => 
+            symbolWords.grab(wordIndex).startsWith(prefix) && 
+            go(wordIndex + 1, queryOffset + prefix.size())
+        }
+    }
+    go(0, 0)
+}
+
+prefixes(string: String): List[String] {
+    if(string == "") {
+        [""]
+    } else {
+        [string, ...prefixes(string.dropLast())]
+    }
+}
+
+splitCamelCased(name: String, lower: Bool): List[String] {
+    name.first().{
+        | None => []
+        | Some(c) => 
+            let word = c.toString() + name.dropFirst().takeWhile {_.isAsciiLower()}
+            let rest = name.dropFirst(word.size())
+            [if(lower) {word.lower()} else {word}, ...splitCamelCased(rest, lower)]
+    }
+}
+
+printTime[R](ts: TimeSystem, label: String, body: () => R): R {
+    let start = ts.elapsed()
+    let result = body()
+    let stop = ts.elapsed()
+    let duration = ("" + (stop.seconds - start.seconds)).slice(0, 5)
+    Log.trace(label + ": " + duration + "s")
+    result
 }

package/experimental/random/Tensor.ff

@@ -1,52 +1,52 @@
-// Brainstorming representation for Tensors where the scalar types and operators are left open ended.
-// The purpose of this type is to build up a syntax tree of tensor operations that can then be
-// optimized and executed on CPU/GPU/TPU, enabling machine learning and other numerical applications.
-
-data Tensor(scalar: String, shape: List[Int]) {
-    TensorVariable(name: String)
-    TensorInts(data: Array[Int])
-    TensorFloats(data: Array[Float])
-    TensorBuffer(data: Buffer)
-    TensorOperator(operator: String, operands: List[Tensor])
-}
-
-data TensorException(message: String)
-
-capability TensorProcessor(
-    toFloats: Tensor => Array[Float]
-    toInts: Tensor => Array[Int]
-    toBuffer: Tensor => Buffer
-)
-
-defaultProcessor(): TensorProcessor {
-    throw(TensorException("Default tensor processor not yet implemented"))
-}
-
-f32(shape: List[Int], data: List[Float]): Tensor {
-    TensorFloats("ff_f32", shape, data.toArray())
-}
-
-f32a(shape: List[Int], data: Array[Float]): Tensor {
-    TensorFloats("ff_f64", shape, data)
-}
-
-extend this: Tensor {
-
-    multiply(that: Tensor): Tensor {
-        if(this.scalar != that.scalar) {
-            throw(TensorException("Scalar type mismatch: " + this.scalar + " vs. " + that.scalar))
-        }
-        let scalar = this.scalar
-        let shape = [] // TODO: Check and compute
-        TensorOperator(scalar, shape, "ff_multiply", [this, that])
-    }
-
-    toFloats(processor: TensorProcessor = defaultProcessor()): Array[Float] {
-        processor.toFloats(this)
-    }
-
-}
-
-main(system: NodeSystem) {
-    let tensor = Tensor.f32([], [1.0])
-}
+// Brainstorming representation for Tensors where the scalar types and operators are left open ended.
+// The purpose of this type is to build up a syntax tree of tensor operations that can then be
+// optimized and executed on CPU/GPU/TPU, enabling machine learning and other numerical applications.
+
+data Tensor(scalar: String, shape: List[Int]) {
+    TensorVariable(name: String)
+    TensorInts(data: Array[Int])
+    TensorFloats(data: Array[Float])
+    TensorBuffer(data: Buffer)
+    TensorOperator(operator: String, operands: List[Tensor])
+}
+
+data TensorException(message: String)
+
+capability TensorProcessor(
+    toFloats: Tensor => Array[Float]
+    toInts: Tensor => Array[Int]
+    toBuffer: Tensor => Buffer
+)
+
+defaultProcessor(): TensorProcessor {
+    throw(TensorException("Default tensor processor not yet implemented"))
+}
+
+f32(shape: List[Int], data: List[Float]): Tensor {
+    TensorFloats("ff_f32", shape, data.toArray())
+}
+
+f32a(shape: List[Int], data: Array[Float]): Tensor {
+    TensorFloats("ff_f64", shape, data)
+}
+
+extend this: Tensor {
+
+    multiply(that: Tensor): Tensor {
+        if(this.scalar != that.scalar) {
+            throw(TensorException("Scalar type mismatch: " + this.scalar + " vs. " + that.scalar))
+        }
+        let scalar = this.scalar
+        let shape = [] // TODO: Check and compute
+        TensorOperator(scalar, shape, "ff_multiply", [this, that])
+    }
+
+    toFloats(processor: TensorProcessor = defaultProcessor()): Array[Float] {
+        processor.toFloats(this)
+    }
+
+}
+
+main(system: NodeSystem) {
+    let tensor = Tensor.f32([], [1.0])
+}

package/experimental/random/Units.ff

@@ -1,36 +1,36 @@
-
-nodeMain(system: NodeSystem) {
-    if(True) {
-        1 + 1
-    } else {
-        "foo"
-    }
-    if(True) {
-        1
-    } elseIf {False} {
-        'x'
-    } else {
-        "foo"
-    }
-    if(True) {
-        if(True) {
-            1
-        } else {
-            "foo"
-        }
-    } else {
-        "foo"
-    }
-    try {
-        1
-    } catchAny {_ =>
-        "foo"
-    } grab()
-    [1, 2, 3].each {_ =>
-        try {
-            if(False) {1} else {2}
-        } catchAny {_ =>
-            "foo"
-        } grab()
-    }
-}
+
+nodeMain(system: NodeSystem) {
+    if(True) {
+        1 + 1
+    } else {
+        "foo"
+    }
+    if(True) {
+        1
+    } elseIf {False} {
+        'x'
+    } else {
+        "foo"
+    }
+    if(True) {
+        if(True) {
+            1
+        } else {
+            "foo"
+        }
+    } else {
+        "foo"
+    }
+    try {
+        1
+    } catchAny {_ =>
+        "foo"
+    } grab()
+    [1, 2, 3].each {_ =>
+        try {
+            if(False) {1} else {2}
+        } catchAny {_ =>
+            "foo"
+        } grab()
+    }
+}

package/experimental/s3/S3TestAuthorizationHeader.ff

@@ -1,40 +1,40 @@
-dependency ff:s3:0.0.0
-import S3 from ff:s3
-
-nodeMain(system: NodeSystem) {
-    // Trying to reproduce the result from an example here 
-    // https://docs.aws.amazon.com/AmazonS3/latest/API/sig-v4-header-based-auth.html
-    let expectedHeader = "AWS4-HMAC-SHA256 Credential=AKIAIOSFODNN7EXAMPLE/20130524/us-east-1/s3/aws4_request,SignedHeaders=date;host;x-amz-content-sha256;x-amz-date;x-amz-storage-class,Signature=98ad721746da40c64f1a55b78f14c238d841ea1380cd77a1b5971af0ece108bd"
-    let amzDate = "20130524T000000Z" // TODO
-    let headerDate = "Fri, 24 May 2013 00:00:00 GMT" // TODO
-    let bucket = "examplebucket"
-    let body = "Welcome to Amazon S3.".toBuffer()
-    let actualHeader = S3.makeS3AuthorizationHeader(
-        system = system
-        accessKeyId = "AKIAIOSFODNN7EXAMPLE"
-        secretAccessKey = "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
-        region = "us-east-1"
-        bucket = bucket
-        encodedKey = S3.encode("test$file.text")
-        body = body
-        canonicalHeaders = [
-            Pair("date", headerDate) 
-            Pair("host", bucket + ".s3.amazonaws.com")
-            Pair("x-amz-date", amzDate)
-            Pair("x-amz-content-sha256", system.crypto().sha256(body).toHex())
-            Pair("x-amz-storage-class", "REDUCED_REDUNDANCY")
-        ]        
-        amzDate = amzDate
-    )
-    system.writeLine("")
-    system.writeLine("actual  : " + actualHeader)
-    system.writeLine("")
-    system.writeLine("expected: " + expectedHeader)
-    
-    system.writeLine("")
-    if(actualHeader == expectedHeader) {
-        system.writeLine("Test passed")
-    } else {
-        system.writeLine("Test failed")
-    }
+dependency ff:s3:0.0.0
+import S3 from ff:s3
+
+nodeMain(system: NodeSystem) {
+    // Trying to reproduce the result from an example here 
+    // https://docs.aws.amazon.com/AmazonS3/latest/API/sig-v4-header-based-auth.html
+    let expectedHeader = "AWS4-HMAC-SHA256 Credential=AKIAIOSFODNN7EXAMPLE/20130524/us-east-1/s3/aws4_request,SignedHeaders=date;host;x-amz-content-sha256;x-amz-date;x-amz-storage-class,Signature=98ad721746da40c64f1a55b78f14c238d841ea1380cd77a1b5971af0ece108bd"
+    let amzDate = "20130524T000000Z" // TODO
+    let headerDate = "Fri, 24 May 2013 00:00:00 GMT" // TODO
+    let bucket = "examplebucket"
+    let body = "Welcome to Amazon S3.".toBuffer()
+    let actualHeader = S3.makeS3AuthorizationHeader(
+        system = system
+        accessKeyId = "AKIAIOSFODNN7EXAMPLE"
+        secretAccessKey = "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
+        region = "us-east-1"
+        bucket = bucket
+        encodedKey = S3.encode("test$file.text")
+        body = body
+        canonicalHeaders = [
+            Pair("date", headerDate) 
+            Pair("host", bucket + ".s3.amazonaws.com")
+            Pair("x-amz-date", amzDate)
+            Pair("x-amz-content-sha256", system.crypto().sha256(body).toHex())
+            Pair("x-amz-storage-class", "REDUCED_REDUNDANCY")
+        ]        
+        amzDate = amzDate
+    )
+    system.writeLine("")
+    system.writeLine("actual  : " + actualHeader)
+    system.writeLine("")
+    system.writeLine("expected: " + expectedHeader)
+    
+    system.writeLine("")
+    if(actualHeader == expectedHeader) {
+        system.writeLine("Test passed")
+    } else {
+        system.writeLine("Test failed")
+    }
 }