firefly-compiler 0.4.4

package/core/Task.ff

@@ -0,0 +1,138 @@
+capability Task {}
+
+extend self: Task {
+    // Spawns a task running body. The return value as well as the argument to body is the task handle.
+    // Automatically aborts and then joins subtasks when body returns or throws an unhandled exception.
+    // If body throws, the parent task is also aborted with the dueToSubtask flag set to true.
+    spawn(body: Task => Unit): Task
+        target js async """
+            return ff_core_Task.Task_spawn(self_, body_)
+        """
+        target js sync """
+            ff_core_Task.Task_throwIfAborted(self_)
+            const task = {controller: new AbortController(), subtasks: new Set(), started: performance.now() * 0.001}
+            self_.subtasks.add(task)
+            task.promise = Promise.resolve(task).then(async () => {
+                try {
+                    await body_(task, task)
+                } catch(e) {
+                    await ff_core_Task.Task_abort$(self_)
+                    throw e
+                } finally {
+                    for(const subtask of task.subtasks) subtask.controller.abort()
+                    await Promise.allSettled([...task.subtasks].map(subtask => subtask.promise))
+                    self_.subtasks.delete(task)
+                }
+            })
+            return task
+        """
+
+    // If the aborted flag is set for the current task, clears it and throws TaskAbortedException.
+    // You don't normally need to call this, but you might want to before doing an expensive computation.
+    throwIfAborted(): Unit
+        target js async """
+            ff_core_Task.Task_throwIfAborted(self_)
+        """
+        target js sync """
+            if(self_.controller.signal.aborted) {
+                const signal = self_.controller.signal
+                self_.controller = new AbortController()
+                signal.throwIfAborted()
+            }
+        """
+
+    // Sets the tasks aborted flag, which causes the ongoing/next async call to throw TaskAbortedException.
+    abort(): Unit
+        target js async """
+            self_.controller.abort()
+        """
+
+    // Create a blocking channel with the specified capacity. The channel is not tied to the task.
+    channel[T](capacity: Int = 0): Channel[T]
+        target js async """return ff_core_Task.Task_channel(capacity_)"""
+        target js sync """return {capacity: capacity_, buffer: [], readers: new Set(), writers: new Set()}"""
+
+    // Create a mutex. The mutex is not tied to the task.
+    lock(): Lock
+        target js async """return {owner: null, level: 0, stack: [], queue: []}"""
+    
+    now(): Instant
+        target js sync "return Date.now() * 0.001"
+        target js async "return Date.now() * 0.001" // TODO: Mark now() as sync and remove async version
+
+    elapsed(): Duration
+        target js sync "return performance.now() * 0.001 - self_.started"
+        target js async "return performance.now() * 0.001 - self_.started" // TODO: Mark sync and remove async version
+
+    time[R](body: () => R): Pair[R, Duration] {
+        let start = self.elapsed()
+        let result = body()
+        let stop = self.elapsed()
+        let duration = Duration(stop.seconds - start.seconds)
+        Pair(result, duration)
+    }
+
+}
+
+// Convenience methods
+extend self: Task {
+
+    sleep(duration: Duration): Unit {
+        Channel.
+            readOr(self.channel()) {_ => }.
+            timeout(duration) {}
+    }
+
+    all[T](tasks: List[() => T]): List[T] {
+        let successChannel = self.channel()
+        let failureChannel = self.channel()
+        self.spawn {t =>
+            let channel = t.channel()
+            try {
+                tasks.pairs().each {| Pair(i, task) =>
+                    t.spawn {_ =>
+                        channel.write(Pair(i, task()))
+                    }
+                }
+                let result = tasks.map {_ =>
+                    channel.read()
+                }.sortBy {_.first}.map {_.second}
+                successChannel.write(result)
+            } catchAny {error =>
+                failureChannel.write(error)
+                t.abort()
+            } grab()
+        }
+        Channel.
+            readOr(successChannel, {_}).
+            readOr(failureChannel, {_.rethrow()}).
+            wait()
+    }
+
+    race[T](tasks: List[() => T]): T {
+        let successChannel = self.channel()
+        let failureChannel = self.channel()
+        mutable live = tasks.size()
+        let started = tasks.map {task =>
+            self.spawn {_ =>
+                try {
+                    successChannel.write(task())
+                } catchAny {e =>
+                    live -= 1 // Not thread safe (but OK in JS)
+                    if(live == 0) {
+                        failureChannel.write(e)
+                    }
+                } grab()
+            }
+        }
+        try {
+            Channel.
+                readOr(successChannel, {_}).
+                readOr(failureChannel, {_.rethrow()}).
+                wait()
+        } finally {
+            started.each {_.abort()}
+        } grab()
+    }
+            
+}

package/core/Try.ff

@@ -0,0 +1,81 @@
+data Try[T] {
+    Success(value: T)
+    Failure(error: Error)
+}
+
+extend self[T]: Try[T] {
+
+    map[S](body: T => S): Try[S] {
+        self.{
+            | Success(value) => try {body(value)}
+            | Failure(error) => Failure(error)
+        }
+    }
+
+    flatMap[S](body: T => Try[S]): Try[S] {
+        self.map(body).flatten()
+    }
+
+    catch[E: HasAnyTag](body: (E, Error) => T): Try[T] {
+        self.{
+            | Failure(error) {error.exception().flatMap(Any.fromAny) | Some(e)} => try {body(e, error)}
+            | _ => self
+        }
+    }
+
+    catchAny(body: Error => T): Try[T] {
+        self.{
+            | Failure(error) => try {body(error)}
+            | _ => self
+        }
+    }
+
+    finally(body: () => Unit): Try[T] {
+        self.{
+            | Success(value) => try {body(); value}
+            | Failure(_) =>
+                try {body()}.{
+                    | Success(_) => self
+                    | Failure(error) => Failure(error)
+                }
+        }
+    }
+
+    else(body: () => T): T {
+        self.{
+            | Success(value) => value
+            | Failure(_) => body()
+        }
+    }
+
+    grab(): T {
+        self.{
+            | Success(value) => value
+            | Failure(error) => error.rethrow()
+        }
+    }
+
+    toOption(): Option[T] {
+        self.{
+            | Success(value) => Some(value)
+            | Failure(_) => None
+        }
+    }
+
+}
+
+extend self[T]: Try[Try[T]] {
+
+    flatten(): Try[T] {
+        self.{
+            | Success(Success(_)@t) => t
+            | Success(Failure(_)@t) => t
+            | Failure(error) => Failure(error)
+        }
+    }
+
+}
+
+internalThrowGrabException[T](): T {
+    throw(GrabException())
+}

package/core/Unit.ff

@@ -0,0 +1,3 @@
+data Unit {
+    Unit
+}

package/experimental/random/AltGeneric.ff

@@ -0,0 +1,44 @@
+// Two fields, zero fields and a particular field
+
+data GFields[A, B](
+    first: A
+    second: B
+)
+
+data GNoFields()
+
+data GField[S, V](value: V)
+
+
+// Two constructors, zero constructors and a particular constructor
+
+data GConstructors[L, R] {
+    GLeft(value: L)
+    GRight(value: R)
+}
+
+data GNoConstructors {}
+
+data GConstructor[S, V](value: V)
+
+trait T: Generic[R] {
+    toGeneric(value: T): R
+    fromGeneric(generic: R): T
+}
+
+data Person(name : String, age : Int)
+
+// Mål: Show på Person
+// Vej: Person -> R -> String
+
+// instance Person: Generic[GType[_, GConstructor[_, GFields[GField[_, String], GField[_, Int]]]]]
+
+trait T: Show {
+    show(value: T): String
+}
+
+instance GFields[A: Show, B: Show]: Show {
+    show(v) { show(v.first) + ", " + show(v.second) }
+}
+
+person_show_GFields[A: Show, B: Show](a : A, b : B) = show(a) + ", " + show(b)

package/experimental/random/Async.ff

@@ -0,0 +1,68 @@
+import Syntax
+
+data Async()
+
+make(): Async {
+    Async()
+}
+
+extend self: Async {
+
+    groupRecursive(functions: List[DFunction]) : List[List[DFunction]] {
+
+    }
+
+    checkRecursive(functions: List[List[DFunction]]) : List[DFunction] {
+        // function f(x) {}
+        f : $1 -> $2
+        --
+        f : forall a. a -> Unit
+
+        // function g() { f(42); h(False) }
+        // function h(y) { if(y) g() }
+        g : () -> $3
+        h : $4 -> $5
+        --
+        g : () -> Unit
+        h : Bool -> Unit
+    }
+
+    type Quux[A, B, s](f: A =s> B)
+    type Baz[s1, s2](quux: Quux[String, Int =s1> Bool, s2])
+
+    type Foo[s](f: Int =s> String)
+    type Bar[s](foo: Foo[s])
+
+    process(term: Term): Term {
+        | ELet e => e.ELet(value = self.fixWildcards(e.value), body = self.fixWildcards(e.body))
+        | ESequential e => e.ESequential(before = self.fixWildcards(e.before), after = self.fixWildcards(e.after))
+        | EAssign e => e.EAssign(value = self.fixWildcards(e.value))
+        | EAssignField e => e.EAssignField(record = self.fixWildcards(e.record), value = self.fixWildcards(e.value))
+        | EPipe e => e.EPipe(value = self.fixWildcards(e.value), function = self.fixWildcards(e.function))
+        | ECall e =>
+            e.ECall(
+                function = self.fixWildcards(e.function),
+                arguments = e.arguments.map { a => a.Argument(value = self.fixWildcards(a.value)) }
+            )
+        | EList e =>
+            e.EList(items = e.items.map { | Pair(item, spread) =>
+                Pair(self.fixWildcards(item), spread)
+            })
+        | ECopy e =>
+            e.ECopy(
+                record = self.fixWildcards(e.record),
+                arguments = e.arguments.map { a => a.Field(value = self.fixWildcards(a.value)) }
+            )
+        | EVariant e =>
+            e.EVariant(arguments = e.arguments.map { _.map { a =>
+                a.Argument(value = self.fixWildcards(a.value))
+            }})
+        | ERecord e => e.ERecord(fields = e.fields.map { a => a.Field(value = self.fixWildcards(a.value)) })
+        | EField e => e.EField(record = self.fixWildcards(e.record))
+        | EWildcard e =>
+            self.seenWildcards += 1
+            e.EWildcard(index = self.seenWildcards)
+        | _ => term
+    }
+
+}

package/experimental/random/Buffer2.ff

@@ -0,0 +1,77 @@
+data DataView {}
+
+make(size: Int, shared: Bool = False): Buffer2
+    target js sync "return new DataView(shared_ ? new SharedArrayBuffer(size_) : new ArrayBuffer(size_))"
+
+extend self: Buffer2 {
+
+    size(): Int
+        target js sync "return self_.byteLength"
+
+    shared(): Bool
+        target js sync "return typeof SharedArrayBuffer !== 'undefined' && self_.buffer instanceof SharedArrayBuffer"
+
+    grabBigInt64(byteOffset: Int, littleEndian: Bool = False): BigInt
+        target js sync "return self_.getBigInt64(byteOffset_, littleEndian_)"
+        
+    grabBigUint64(byteOffset: Int, littleEndian: Bool = False): BigInt
+        target js sync "return self_.getBigUint64(byteOffset_, littleEndian_)"
+        
+    grabFloat32(byteOffset: Int, littleEndian: Bool = False): Float
+        target js sync "return self_.getFloat32(byteOffset_, littleEndian_)"
+        
+    grabFloat64(byteOffset: Int, littleEndian: Bool = False): Float
+        target js sync "return self_.getFloat64(byteOffset_, littleEndian_)"
+        
+    grabInt16(byteOffset: Int, littleEndian: Bool = False): Int
+        target js sync "return self_.getInt16(byteOffset_, littleEndian_)"
+        
+    grabInt32(byteOffset: Int, littleEndian: Bool = False): Int
+        target js sync "return self_.getInt32(byteOffset_, littleEndian_)"
+        
+    grabInt8(byteOffset: Int, littleEndian: Bool = False): Int
+        target js sync "return self_.getInt8(byteOffset_, littleEndian_)"
+        
+    grabUint16(byteOffset: Int, littleEndian: Bool = False): Int
+        target js sync "return self_.getUint16(byteOffset_, littleEndian_)"
+        
+    grabUint32(byteOffset: Int, littleEndian: Bool = False): Int
+        target js sync "return self_.getUint32(byteOffset_, littleEndian_)"
+        
+    grabUint8(byteOffset: Int, littleEndian: Bool = False): Int
+        target js sync "return self_.getUint8(byteOffset_, littleEndian_)"
+
+    setBigInt64(byteOffset: Int, value: BigInt, littleEndian: Bool = False): Unit
+        target js sync "self_.setBigInt64(byteOffset_, littleEndian_)"
+        
+    setBigUint64(byteOffset: Int, value: BigInt, littleEndian: Bool = False): Unit
+        target js sync "self_.setBigUint64(byteOffset_, littleEndian_)"
+        
+    setFloat32(byteOffset: Int, value: Float, littleEndian: Bool = False): Unit
+        target js sync "self_.setFloat32(byteOffset_, littleEndian_)"
+        
+    setFloat64(byteOffset: Int, value: Float, littleEndian: Bool = False): Unit
+        target js sync "self_.setFloat64(byteOffset_, littleEndian_)"
+        
+    setInt16(byteOffset: Int, value: Int, littleEndian: Bool = False): Unit
+        target js sync "self_.setInt16(byteOffset_, littleEndian_)"
+        
+    setInt32(byteOffset: Int, value: Int, littleEndian: Bool = False): Unit
+        target js sync "self_.setInt32(byteOffset_, littleEndian_)"
+        
+    setInt8(byteOffset: Int, value: Int, littleEndian: Bool = False): Unit
+        target js sync "self_.setInt8(byteOffset_, littleEndian_)"
+        
+    setUint16(byteOffset: Int, value: Int, littleEndian: Bool = False): Unit
+        target js sync "self_.setUint16(byteOffset_, littleEndian_)"
+        
+    setUint32(byteOffset: Int, value: Int, littleEndian: Bool = False): Unit
+        target js sync "self_.setUint32(byteOffset_, littleEndian_)"
+        
+    setUint8(byteOffset: Int, value: Int, littleEndian: Bool = False): Unit
+        target js sync "self_.setUint8(byteOffset_, littleEndian_)"
+
+    slice(begin: Int, end: Int): Buffer2
+        target js sync "return new DataView(self_.buffer.slice(begin, end))"
+
+}

package/experimental/random/Cat.ff

@@ -0,0 +1,12 @@
+main(system: NodeSystem) {
+    let outputFileName = system.arguments().grabFirst()
+    let fileNames = system.arguments().dropFirst()
+    let result = cat(system.files(), fileNames)
+    system.files().writeStream(outputFileName, result)
+}
+
+cat(fs: FileSystem, fileNames: Array[String]): Stream[Buffer] {
+    fileNames.toStream().flatMap {fileName =>
+        fs.readStream(fileName)
+    }
+}

package/experimental/random/Dictionary.ff

@@ -0,0 +1,52 @@
+data JsValue {}
+
+data Dictionary[K, V] {}
+
+trait K: DictionaryKey {
+    add[V](js: JsValue, key: K, value: V): Unit
+    has(js: JsValue, key: K): Bool
+    grab[V](js: JsValue, key: K): V
+}
+
+instance Int: DictionaryKey {
+    add[V](js: JsValue, key: Int, value: V): Unit
+        target js sync "js_.set(key_, value_)"
+    has(js: JsValue, key: Int): Bool
+        target js sync "return js_.has(key_)"
+    get[V](js: JsValue, key: Int): Option[V]
+        target js sync "return js_.has(key_) ? ff_core_Option.Some(js_.get(key_)) : ff_core_Option.None()"
+}
+
+instance String: DictionaryKey {
+    add[V](js: JsValue, key: String, value: V): Unit
+        target js sync "js_.set(key_, value_)"
+    has(js: JsValue, key: String): Bool
+        target js sync "return js_.has(key_)"
+    get[V](js: JsValue, key: String): Option[V]
+        target js sync "return js_.has(key_) ? ff_core_Option.Some(js_.get(key_)) : ff_core_Option.None()"
+}
+
+instance Pair[A: DictionaryKey, B: DictionaryKey]: DictionaryKey {
+    add[V](basic: JsDictionary, key: Pair[A, B], value: V): Unit
+        javascript """
+            let inner = basic_.get(key_.first_)
+            if(inner === undefined) {
+                inner = new Map()
+            }
+            basic_.set(key_.first_, )
+        """
+    has(basic: JsDictionary, key: Pair[A, B]): Bool
+        javascript """
+            return basic_.has(key_)
+        """
+    get[V](basic: JsDictionary, key: Pair[A, B]): Option[V]
+        javascript """
+            return basic_.has(key_) ? ff_core_Option.Some(basic_.get(key_)) : ff_core_Option.None()
+        """
+}
+
+extend self[K: DictionaryKey, V]: Dictionary[K, V] {
+    add(key: K, value: V): Unit {
+
+    }
+}

package/experimental/random/Example.ff

@@ -0,0 +1,46 @@
+trait Show[T] {
+    show(value: T): String
+}
+
+instance Show[List[T: Show]] {
+    show(value: List[T]) {
+        value.map { show(_) }.join(", ")
+    }
+}
+
+map[A, B](list: List[A], body: A => B): List[B] {
+    | Empty, _ => Empty
+    | Link(head, tail), _ => Link(body(head), map(tail, body))
+}
+
+data Stack {
+    EmptyStack
+    PushStack(value: Int, stack: Stack)
+}
+
+extend stack: Stack {
+    map(body: Int => Int): Stack {
+        switch(stack) {
+            | EmptyStack => EmptyStack
+            | PushStack s => PushStack(body(s.value), s.stack.map(body))
+        }
+    }
+}
+
+user: (name: String, email: String) = (name = "Joe", email = "jj@example.com")
+
+load(files: FileSystem, file1: String, file2: String): String {
+    try {
+        files.readText(file1) ++
+        files.readText(file2)
+    } catch(FileNotFound?) { e =>
+        ""
+    } grab
+}
+
+data FileException(file: String) {
+    FileNotFound
+    AccessDenied
+}
+
+instance Exceptional[FileException]

package/experimental/random/Generic.ff

@@ -0,0 +1,102 @@
+// Haskell-like Generic programming. Thanks to nathanf for instructions.
+
+// Two fields, zero fields and a particular field
+
+data GFields[A, B](
+    first: A
+    second: B
+)
+
+data GNoFields()
+
+data GField[S, V](value: V)
+
+
+// Two constructors, zero constructors and a particular constructor
+
+data GConstructors[L, R] {
+    GLeft(value: L)
+    GRight(value: R)
+}
+
+data GNoConstructors {}
+
+data GConstructor[S, V](value: V)
+
+
+// Type declarations
+
+data GType[S, C](constructors: C)
+
+
+// Names and such
+
+trait S: GFieldSymbol {
+    fieldName(): String
+}
+
+trait S: GConstructorSymbol {
+    constructorName(): String
+}
+
+trait S: GTypeSymbol {
+    typeName(): String
+    packageName(): String
+    moduleName(): String
+}
+
+
+// The type class that converts from/to the generic representation
+
+trait T: Generic[R] {
+    toGeneric(value: T): R
+    fromGeneric(generic: R): T
+}
+
+
+// Example of implementing a generic instance of Show
+
+instance GFields[A: Show, B: Show]: Show {
+    show(v) { show(v.first) + ", " + show(v.second) }
+}
+
+instance GNoFields: Show {
+    show(v) { "" }
+}
+
+instance GField[S: GFieldSymbol, V: Show]: Show {
+    show(v) { fieldName[S]() + " = " + show(v.value) }
+}
+
+instance GConstructors[A: Show, B: Show]: Show {
+    show(v) {
+        | GLeft(v) => show(v)
+        | GRight(v) => show(v)
+    }
+}
+
+instance GConstructor[S: GConstructorSymbol, V: Show]: Show {
+    show(v) { constructorName[S]() + "(" + show(v.value) + ")" }
+}
+
+instance GType[S, C: Show]: Show {
+    show(v) {
+        show(v.constructors)
+    }
+}
+
+
+// Example of using the generic instance of Show above
+
+trait T: Show {
+    show(value: T): String {
+        show(toGeneric(value)) // Type checked at each instance, not in the trait (to allow T: Generic[R])
+    }
+}
+
+data User(id: Int, email: String)
+
+instance User: Show
+
+
+// Perhaps Generic is automatic, and the instance is only in scope where the constructors of the type are accessible.

package/experimental/random/HappyEyeballs.ff

@@ -0,0 +1,40 @@
+// https://datatracker.ietf.org/doc/html/rfc8305#section-5
+
+data Ip(ipAddress: String, seconds: Duration, succeed: Bool)
+
+main(system: NodeSystem): Unit {
+    let ips = [
+        Ip("1.1.1.1", Duration(1.7), False)
+        Ip("2.2.2.2", Duration(0.4), False)
+        Ip("3.3.3.3", Duration(1.5), True)
+        Ip("4.4.4.4", Duration(0.6), True)
+    ]
+    let channel = system.tasks().channel(capacity = 2)
+    channel.write(Unit)
+    channel.write(Unit)
+    let winner = happyEyeballs(system.tasks(), channel, ips)
+    Log.debug(winner)
+}
+
+happyEyeballs(taskSystem: TaskSystem, channel: Channel[Unit], ips: List[Ip]): String {
+    let ip = ips.grabFirst()
+    let nextChannel = taskSystem.channel(capacity = 2)
+    taskSystem.race([
+        {
+            channel.read()
+            Channel.readOr(channel, {_}).timeout(Duration(0.5), {})
+            nextChannel.write(Unit)
+            try {
+                taskSystem.sleep(ip.seconds)
+                if(!ip.succeed) { panic("Network error") }
+                ip.ipAddress
+            } catchAny { error =>
+                nextChannel.write(Unit)
+                error.rethrow()
+            } grab()
+        }
+        {
+            happyEyeballs(taskSystem, nextChannel, ips.dropFirst())
+        }
+    ])
+}