firefly-compiler 0.4.4

package/experimental/random/Symbols.ff

@@ -0,0 +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.make()
+    function go(wordIndex: Int, queryOffset: Int): Bool {
+        memo.getOrSet(wordIndex) {IntMap.make()}.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/Tag.ff

@@ -0,0 +1,49 @@
+// This may solve VDOM props, but what about "render props"?
+// https://reactjs.org/docs/render-props.html
+
+data Tag[M] {
+    ComponentTag(component: ComponentConstructor[M], key: Option[String])
+    ElementTag(name: String, tags: List[Tag[M]], key: Option[String])
+    AttributeTag(name: String, value: String)
+    StyleTag(name: String, value: String)
+    EventTag(name: String, value: M)
+    TextTag(text: String)
+}
+
+data ComponentConstructor[M]() {}
+
+extend self: Tag[M] {
+    map[T](body: M => T): Tag[T] {
+        self.{
+            | ComponentTag(constructor, key) => ComponentTag(constructor.map(body), key) // How to compare this function
+            | ElementTag(name, tags, key) => ElementTag(name, tags.map(_.map(body)), key)
+            | AttributeTag(_, _) => self
+            | StyleTag(_, _) => self
+            | EventTag(name, value) => EventTag(name, body(value))
+        }
+    }
+}
+
+component[C: Component[M], M](value: C, key: Option[String] = None): Tag[M] {
+    panic("TODO")
+}
+
+element[M](name: String, tags: List[Tag[M]], key: Option[String] = None): Tag[M] {
+    ElementTag(name, tags, key)
+}
+
+attribute[M](name: String, value: String): Tag[M] {
+    AttributeTag(name, value)
+}
+
+style[M](name: String, value: String): Tag[M] {
+    StyleTag(name, value)
+}
+
+event[M](name: String, value: M): Tag[M] {
+    EventTag(name, value)
+}
+
+text[M](value: String): Tag[M] {
+    TextTag(value)
+}

package/experimental/random/Tensor.ff

@@ -0,0 +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])
+}

package/experimental/random/Try.ff

@@ -0,0 +1,56 @@
+
+try {
+    Parser.parse(code)
+} catch[ParseException] { e =>
+    e.rethrow()
+} orThrow()
+
+
+data Try[T] {
+    Ok(value: T)
+    NotOk(exception: DynamicException)
+}
+
+extend self[T]: Try[T] {
+
+    map[S](body: T => S): Try[S] {
+        | Ok(value) => try { body(value) }
+        | NotOk(exception) => NotOk(exception)
+    }
+
+    flatMap[S](body: T => Try[S]): Try[S] {
+        self.map(body).flatten()
+    }
+
+    else(body: () => T): T {
+        | Ok(value) => value
+        | NotOk(_) => body()
+    }
+
+    grab(): T {
+        | Ok(value) => value
+        | NotOk(exception) => exception.rethrow()
+    }
+
+    catch[E: Exception](body: E => T): Try[T] {
+        | NotOk(exception) {exception.as[E]() | Some(e)} => try { body(e) }
+        | _ => self
+    }
+
+    finally(body: () => Unit): Try[T] {
+        | Ok(value) => try { body(); value }
+        | NotOk(_) => body(); self
+    }
+
+}
+
+extend self[T]: Try[Try[T]] {
+
+    flatten(): Try[T] {
+        | Ok(Ok(value)) => value
+        | Ok(NotOk(_)@t) => t
+        | NotOk(_)@t => t
+    }
+
+}
+

package/experimental/random/Tsv.ff

@@ -0,0 +1,9 @@
+parseTsv(fs: FileSystem, tsvFileName: String): Stream[Map[String, String]] {
+    fs.readFile(tsvFileName).lines().withFirst { first, rest =>
+        let headers = first.split("\t")
+        rest.map { line =>
+            let cells = line.split("\t")
+            headers.zip(cells).toMap()
+        }
+    }
+}

package/experimental/random/TypesAreModules.ff

@@ -0,0 +1,87 @@
+// Set.ff only contains the Set type
+
+newtype Set[T](map: Map[T, Unit])
+
+empty[T](): Set[T] {
+    Set(Map.empty())
+}
+
+self.add(value: T): Set[T] @Order[T] { Set(self.map.add(value, Unit)) }
+self.addAll(that: Set[T]): Set[T] @Order[T] { Set(self.map.addAll(that.map)) }
+self.remove(value: T): Set[T] @Order[T] { Set(self.map.remove(value)) }
+self.removeAll(that: Set[T]): Set[T] @Order[T] { Set(self.map.removeAll(that.map)) }
+self.contains(value: T): Bool @Order[T] { self.map.contains(value) }
+self.size(): Int @Order[T] { self.map.size() }
+self.toList(): List[T] @Order[T] { self.map.pairs().map { _.first } }
+self.each(body: T => Unit): Unit @Order[T] { self.map.each {| k, _ => body(k)} }
+self.flatten[T](): Set[T] @[Set[T]] @Order[T] { todo() }
+self.join(separator: String): String @[String] @Order[T] { todo() }
+
+// Term.ff only contains the Term type
+
+data Term(at: Location) {
+    EString(value: String)
+    EChar(value: String)
+    EInt(value: String)
+    EFloat(value: String)
+    EVariable(name: String)
+    ELambda(lambda: Lambda)
+    EFunctions(functions: List[DFunction], body: Term)
+    ELet(mutable: Bool, name: String, valueType: Type, value: Term, body: Term)
+    ESequential(before: Term, after: Term)
+    EAssign(operator: String, variable: String, value: Term)
+    EAssignField(operator: String, record: Term, field: String, value: Term)
+    EPipe(value: Term, function: Term)
+    ECall(
+        target: CallTarget
+        effect: Type
+        typeArguments: List[Type]
+        arguments: List[Argument]
+        dictionaries: List[Dictionary]
+    )
+    EList(elementType: Type, items: List[Pair[Term, Bool]])
+    ECopy(name: String, record: Term, arguments: List[Field])
+    EVariant(name: String, typeArguments: List[Type], arguments: Option[List[Argument]])
+    EVariantIs(name: String, typeArguments: List[Type])
+    ERecord(fields: List[Field])
+    EField(newtype: Bool, record: Term, field: String)
+    EWildcard(index: Int)
+}
+
+self.toString(): String {
+    self.{
+        | string(v) => v
+        | char(c) => ...
+    }
+}
+
+
+// Bool.ff only contains the Bool type
+
+data Bool {
+    False
+    True
+}
+
+self.toString(): String {
+    self.{
+        | False => "false"
+        | True => "true"
+    }
+}
+
+    // False/True is resolved by expected type - or written in full as Bool.True/Bool.False
+    file.open(read: Bool = True, write: Bool = False): Bool {
+        ...
+    }
+
+
+// Traits are defined as follows. Note that modules may define a trait instead of a type.
+trait Order[T] {}
+
+instance Order[String] {}
+
+instance Order[List[T]] @Order[T] {}
+
+// Imports import one type and all its constructors. The type can be renamed with as. Nothing else can be unqualified.
+import ff.core.Bool as B

package/experimental/random/blueprints/Blueprint.ff

@@ -0,0 +1,52 @@
+// Two fields, zero fields and a particular field
+
+data BpFields[A, B](
+    first: A
+    second: B
+)
+
+data BpNoFields()
+
+data BpField[S, V](value: V)
+
+
+// Two constructors, zero constructors and a particular constructor
+
+data BpConstructors[L, R] {
+    BpLeft(value: L)
+    BpRight(value: R)
+}
+
+data BpNoConstructors {}
+
+data BpConstructor[S, V](value: V)
+
+
+// Type declarations
+
+data BpType[S, C](constructors: C)
+
+
+// Names and such
+
+trait S: BpFieldSymbol {
+    fieldName(): String
+}
+
+trait S: BpConstructorSymbol {
+    constructorName(): String
+}
+
+trait S: BpTypeSymbol {
+    typeName(): String
+    packageName(): String
+    moduleName(): String
+}
+
+
+// The type class that converts from/to the generic representation
+
+trait T: Blueprint[R] {
+    toBlueprint(value: T): R
+    fromBlueprint(generic: R): T
+}

package/experimental/random/blueprints/Main.ff

@@ -0,0 +1,11 @@
+import User
+import Pretty
+
+nodeMain(system: NodeSystem) {
+    Log.debug("Hello blueprints")
+    Log.debug(Pretty.pretty(User(1, "foo@example.com")))
+}
+
+// TODO: Use default trait method implementations
+// TODO: Check that all trait methods have been implemented in instances
+// TODO: Fix "wrong number of type parameters" above (where Unit is used)

package/experimental/random/blueprints/Pretty.ff

@@ -0,0 +1,58 @@
+import Blueprint
+
+trait T: Pretty {
+    pretty(value: T): String {
+        pretty(Blueprint.toBlueprint(value))
+    }
+}
+
+instance Int: Pretty {
+    pretty(value: Int): String {
+        "" + value
+    }
+}
+
+instance String: Pretty {
+    pretty(value: String): String {
+        "\"" + value + "\""
+    }
+}
+
+// Example of implementing a generic instance of Pretty
+
+instance BpFields[A: Pretty, B: Pretty]: Pretty {
+    pretty(v: BpFields[A, B]): String {
+        pretty(v.first) + ", " + pretty(v.second)
+    }
+}
+
+instance BpNoFields: Pretty {
+    pretty(v: BpNoFields): String {
+        ""
+    }
+}
+
+instance BpField[S: BpFieldSymbol, V: Pretty]: Pretty {
+    pretty(v: BpField[S, V]): String {
+        Blueprint.fieldName[S, Unit]() + " = " + pretty(v.value)
+    }
+}
+
+instance BpConstructors[A: Pretty, B: Pretty]: Pretty {
+    pretty(v: BpConstructors[A, B]): String {
+        | BpLeft(v) => pretty(v)
+        | BpRight(v) => pretty(v)
+    }
+}
+
+instance BpConstructor[S: BpConstructorSymbol, V: Pretty]: Pretty {
+    pretty(v: BpConstructor[S, V]): String {
+        Blueprint.constructorName[S, Unit]() + "(" + pretty(v.value) + ")"
+    }
+}
+
+instance BpType[S, C: Pretty]: Pretty {
+    pretty(v: BpType[S, C]): String {
+        pretty(v.constructors)
+    }
+}

package/experimental/random/blueprints/User.ff

@@ -0,0 +1,64 @@
+import Blueprint
+import Pretty
+
+data User(id: Int, email: String)
+
+
+//instance User: Pretty
+
+data UserIdField {}
+instance UserIdField: BpFieldSymbol {
+    fieldName(): String { "id" }
+}
+
+data UserEmailField {}
+instance UserEmailField: BpFieldSymbol {
+    fieldName(): String { "email" }
+}
+
+data UserUserConstructor {}
+instance UserUserConstructor: BpConstructorSymbol {
+    constructorName(): String { "User" }
+}
+
+data UserType {}
+instance UserType: BpTypeSymbol {
+    typeName(): String { "User" }
+    packageName(): String { "ff:blueprints" }
+    moduleName(): String { "Main" }
+}
+
+instance User: Blueprint[BpType[UserType,
+    BpConstructor[UserUserConstructor, BpFields[
+        BpField[UserIdField, Int],
+        BpField[UserEmailField, String]
+    ]]
+]] {
+
+    toBlueprint(value: User): BpType[UserType,
+        BpConstructor[UserUserConstructor, BpFields[
+            BpField[UserIdField, Int],
+            BpField[UserEmailField, String]
+        ]]
+    ] {
+        BpType(BpConstructor(BpFields(BpField(value.id), BpField(value.email))))
+    }
+
+    fromBlueprint(generic: BpType[UserType,
+        BpConstructor[UserUserConstructor, BpFields[
+            BpField[UserIdField, Int],
+            BpField[UserEmailField, String]
+        ]]
+    ]): User {
+        generic.{
+            | BpType(BpConstructor(BpFields(BpField(id), BpField(email)))) => User(id, email)
+        }
+    }
+
+}
+
+instance User: Pretty {
+    pretty(value: User): String {
+        Pretty.pretty(Blueprint.toBlueprint(value))
+    }
+}

package/experimental/random/blueprintsystem/BlueprintSystem.ff

@@ -0,0 +1,48 @@
+data BlueprintSystem {}
+data ConstructorBlueprint {}
+data FieldBlueprint {}
+data TypeBlueprint {}
+newtype Blueprint(code: String)
+
+extend self: BlueprintSystem {
+    groupName(): String
+    packageName(): String
+    moduleName(): String
+    typeName(): String
+    typeParameters(): List[String]
+    commonFields(): List[FieldBlueprint]
+    constructors(): List[ConstructorBlueprint]
+
+    typeBlueprint(typeArguments: List[TypeBlueprint] = []): TypeBlueprint
+
+    fresh(name: String): Blueprint
+    bool(value: Bool): Blueprint
+    char(value: Char): Blueprint
+    int(value: Int): Blueprint
+    float(value: Float): Blueprint
+    string(value: String): Blueprint
+}
+
+extend self: ConstructorBlueprint {
+    typeBlueprint(typeArguments: List[TypeBlueprint] = []): TypeBlueprint
+    constructorName(): String
+    fields(): List[GeneratorField]
+    emit(typeArguments: List[TypeBlueprint] = []): Blueprint
+}
+
+extend self: FieldBlueprint {
+    fieldName(): String
+    fieldType(): TypeBlueprint
+    mutable(): Bool
+    defaultValue(): Option[Blueprint]
+    emit(): Blueprint
+}
+
+extend self: TypeBlueprint {
+    groupName(): String
+    packageName(): String
+    moduleName(): String
+    typeName(): TypeBlueprint
+    typeArguments(): List[TypeBlueprint]
+    emit(): Blueprint
+}

package/experimental/random/blueprintsystem/Deserialize.ff

@@ -0,0 +1,53 @@
+trait T: Deserializable {
+    deserialize(value: Json): T { blueprint t =>
+        let constructors = t.constructors()
+        Blueprint.code("""value.get("$tag").grabString().{\n""" +
+            constructors.map { constructor =>
+                "| " + Blueprint.string(constructor.constructorName()) + " =>\n" +
+                constructor.emit() + "(" + constructor.fields.map { field =>
+                    field.emit() + " = deserialize(value.get(" + Blueprint.string(field.fieldName()) + "))"
+                }.join(", ") + ")"
+            }.join("\n") +
+        """\n| tag => panic("Unknown tag: " + tag)\n}""")
+    }
+}
+
+data Shape {
+    Circle(radius: Float)
+    Rectangle(width: Float, height: Float)
+}
+
+instance Shape: Deserializable
+
+instance Shape: Deserializable {
+    deserialize(value: Json): Shape {
+        value.get("$tag").grabString().{
+            | "Circle" =>
+                Circle(
+                    radius = deserialize(value.get("radius"))
+                )
+            | "Rectangle" =>
+                Rectangle(
+                    width = deserialize(value.get("width"))
+                    height = deserialize(value.get("height"))
+                )
+            | tag =>
+                panic("Unknown tag: " + tag)
+        }
+    }
+}
+
+trait T: Foo[M] {
+    bar(x: Int): Int { blueprint t, m =>
+        ...
+    }
+}
+
+trait T: Baz(trimStrings: Bool) {
+    Quux(x: Int): Int { blueprint t =>
+        // Use t and trimStrings here to generate code
+    }
+}
+
+instance Shape: Baz(trimStrings = False)
+

package/experimental/random/blueprintsystem/ReadJs.ff

@@ -0,0 +1,13 @@
+trait T: ReadJs {
+    readJs(value: JsValue): T { blueprint system =>
+        let constructors = system.constructors()
+        Blueprint("""value.get("$tag").grabString().{\n""" +
+            constructors.map { constructor =>
+                "| " + system.string(constructor.constructorName()).code + " =>\n" +
+                constructor.emit().code + "(" + constructor.fields.map { field =>
+                    field.emit().code + " = readJs(value.get(" + system.string(field.fieldName()) + "))"
+                }.join(", ") + ")"
+            }.join("\n") +
+        """\n}""")
+    }
+}

package/experimental/random/blueprintsystem/User.ff

@@ -0,0 +1,2 @@
+data User(id: Int, email: String)
+