firefly-compiler 0.5.34 → 0.5.36

package/core/StringMap.ff

@@ -1,45 +1,66 @@
 class StringMap[V] {}
 
-new[V](): StringMap[V]
-    target js sync "return new Map()"
-
+new[V](): StringMap[V] {
+    Js->Map->()?
+}
+    
 extend self[V]: StringMap[V] {
 
-    get(key: String): Option[V]
-        target js sync "return self_.has(key_) ? ff_core_Option.Some(self_.get(key_)) : ff_core_Option.None()"
-
-    grab(key: String): V
-        target js sync """
-            const result = self_.get(key_)
-            if(key_ === void 0 && !self_.has(key_)) {
-                ff_core_Try.internalThrowGrabException_()
-            }
-            return result
-        """
-
-    set(key: String, value: V): Unit
-        target js sync "self_.set(key_, value_)"
-
-    has(key: String): Bool
-        target js sync "return self_.has(key_)"
+    get(key: String): Option[V] {
+        let result = self!->get(key)
+        if(!result.isUndefined() || self!->has(key)?) {result?}
+    }
 
-    remove(key: String): Bool
-        target js sync "return self_.delete(key_)"
+    grab(key: String): V {
+        let result = self!->get(key)
+        if(result.isUndefined() && !self.has(key)) {throw(GrabException())}
+        result?
+    }
+        
+    set(key: String, value: V): Unit {
+        self!->set(key, value!)
+    }
 
-    clear(): Unit
-        target js sync "self_.clear()"
+    has(key: String): Bool {
+        self!->has(key)?
+    }
 
-    size(): Int
-        target js sync "return self_.size"
+    remove(key: String): Bool {
+        self!->delete(key)?
+    }
 
-    each(body: (String, V) => Unit): Unit
-        target js sync "self_.forEach((v, k) => body_(k, v))"
-        target js async "for(const [k, v] of self_) await body_(k, v)"
+    clear(): Unit {
+        self!->clear()
+    }
 
-    eachWhile(body: (String, V) => Bool): Unit
-        target js sync "for(const [k, v] of self_) if(!body_(k, v)) break"
-        target js async "for(const [k, v] of self_) if(!await body_(k, v)) break"
+    size(): Int {
+        self!->size?
+    }
+    
+    isEmpty(): Bool {
+        self.size() == 0
+    }
 
+    each(body: (String, V) => Unit): Unit {
+        if(Js.inAsync()) {
+            let iterator = self!->entries()
+            mutable result = iterator->next()
+            while {!result->done?} {
+                let value = result->value
+                body(value.get(0)?, value.get(1)?)
+                result = iterator->next()
+            }
+        } else {
+            self!->forEach(Js->{v, k => body(k?, v?)})
+        }
+    }
+    
+    eachWhile(body: (String, V) => Bool): Unit {
+        self!.eachWhile {value =>
+            body(value.get(0)?, value.get(1)?)
+        }
+    }
+            
     toArray(): Array[Pair[String, V]] {
         let array = Array.new()
         self.each {k, v => array.push(Pair(k, v))}
@@ -61,17 +82,18 @@ extend self[V]: StringMap[V] {
     keys(): List[String] {
         let array = Array.new()
         self.each {k, v => array.push(k)}
-        array.toList()
+        array.drain()
     }
 
     values(): List[V] {
         let array = Array.new()
         self.each {k, v => array.push(v)}
-        array.toList()
+        array.drain()
     }
 
-    copy(): StringMap[V]
-        target js sync "return new Map(self_)"
+    copy(): StringMap[V] {
+        Js->Map->(self!)?
+    }
 
     getOrSet(key: String, body: () => V): V {
         if(!self.has(key)) {self.set(key, body())}

package/core/Task.ff

@@ -1,149 +1,165 @@
-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()
-        """
-        target js sync """
-            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) {}
-    }
-    
-    mapList[T, R](list: List[T], body: T => R): List[R] {
-        self.all(list.map {x => {body(x)}})
-    }
-    
-    raceList[T, R](list: List[T], body: T => R): R {
-        self.race(list.map {x => {body(x)}})
-    }
-
-    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()
-            }
-        }
-        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)
-                    }
-                }
-            }
-        }
-        try {
-            Channel.
-                readOr(successChannel, {_}).
-                readOr(failureChannel, {_.rethrow()}).
-                wait()
-        } finally {
-            started.each {_.abort()}
-        }
-    }
-            
-}
+capability Task(
+    mutable controller: JsValue
+    subtasks: JsValue
+    mutable promise: JsValue
+    started: Duration
+)
+
+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 {
+        self.throwIfAborted()
+        let task = Task(
+            controller = Js->AbortController->()
+            subtasks = Js->Set->()
+            promise = Js.undefined()
+            started = Duration(Js->performance->now()? * 0.001)
+        )
+        self.subtasks->add(task!)
+        task.promise = Js->Promise->resolve(task!)->then(Js.async0 {
+            try {
+                Js.await(body!.callValue2(task!, task!))
+            } tryCatchAny {e => 
+                Js.await(self.controller->abort())
+                e.rethrow()
+            } finally {
+                task.subtasks.each {subtask => 
+                    Js.fromValue[Task](subtask).controller->abort()
+                }
+                Js.await(Js->Promise->allSettled(
+                    task.subtasks.spreadToArray().map {subtask => 
+                        Js.fromValue[Task](subtask).promise
+                    }                    
+                ))
+                self.subtasks->delete(task!)
+            }
+        })
+        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 {
+        let signal = self.controller->signal
+        if(signal->aborted?) {
+            self.controller = Js->AbortController->()
+            signal->throwIfAborted()
+        }
+    }
+
+    // Sets the tasks aborted flag, which causes the ongoing/next async call to throw TaskAbortedException.
+    abort(): Unit {
+        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] {
+        Channel(
+            capacity = capacity
+            buffer = Array.new()
+            readers = Js->Set->()
+            writers = Js->Set->()
+        )
+    }
+
+    // Create a mutex. The mutex is not tied to the task.
+    lock(): Lock {
+        Lock(
+            owner = Js.undefined()
+            level = 0
+            queue = Queue.new()
+        )
+    }
+    
+    now(): Instant {
+        Instant(Duration(Js->Date->now()? * 0.001))
+    }
+    
+    elapsed(): Duration {
+        let now = Js->performance->now()? * 0.001
+        Duration(now - self.started.seconds)
+    }
+
+    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) {}
+    }
+    
+    mapList[T, R](list: List[T], body: T => R): List[R] {
+        self.all(list.map {x => {body(x)}})
+    }
+    
+    raceList[T, R](list: List[T], body: T => R): R {
+        self.race(list.map {x => {body(x)}})
+    }
+
+    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()
+            }
+        }
+        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)
+                    }
+                }
+            }
+        }
+        try {
+            Channel.
+                readOr(successChannel, {_}).
+                readOr(failureChannel, {_.rethrow()}).
+                wait()
+        } finally {
+            started.each {_.abort()}
+        }
+    }
+            
+}

package/experimental/benchmarks/ListGrab.ff

@@ -1,23 +1,23 @@
-nodeMain(system: NodeSystem) {
-    let list = 1.to(10000)
-    benchmark(list, 100000)
-    let time = system.mainTask().time {
-        benchmark(list, 100000)
-    }
-    Log.trace(time.second.show())
-}
-
-benchmark(list: List[Int], iterations: Int): Int {
-    mutable sum = 0
-    mutable i = 0
-    while {i < iterations} {
-        mutable j = 0
-        sum = 0
-        while {j < 10000} {
-            sum += list.grab(j)
-            j += 1
-        }
-        i += 1
-    }
-    sum
-}
+nodeMain(system: NodeSystem) {
+    let list = 1.to(10000)
+    benchmark(list, 100000)
+    let time = system.mainTask().time {
+        benchmark(list, 100000)
+    }
+    Log.trace(time.second.show())
+}
+
+benchmark(list: List[Int], iterations: Int): Int {
+    mutable sum = 0
+    mutable i = 0
+    while {i < iterations} {
+        mutable j = 0
+        sum = 0
+        while {j < 10000} {
+            sum += list.grab(j)
+            j += 1
+        }
+        i += 1
+    }
+    sum
+}

package/experimental/benchmarks/ListGrab.java

@@ -1,55 +1,55 @@
-/*
-
-nodeMain(system: NodeSystem) {
-    let list = 1.to(10000)
-    benchmark(list, 10000)
-    let time = system.mainTask().time {
-        benchmark(list, 10000)
-    }
-    Log.trace(time.second.show())
-}
-
-benchmark(list: List[Int], iterations: Int): Int {
-    mutable sum = 0
-    mutable i = 0
-    while {i < iterations} {
-        mutable j = 0
-        while {j < 10000} {
-            sum += list.grab(j)
-            j += 1
-        }
-        i += 1
-    }
-    sum
-}
-
- */
-
- // Rewrite the above to Java
-
-import java.util.ArrayList;
-
-public class ListGrab {
-    public static void main(String[] args) {
-        ArrayList<Integer> list = new ArrayList<>();
-        for (int i = 1; i <= 10000; i++) {
-            list.add(i);
-        }
-        benchmark(list, 100000);
-        long time = System.currentTimeMillis();
-        benchmark(list, 100000);
-        time = System.currentTimeMillis() - time;
-        System.out.println(time / 1000.0);
-    }
-
-    public static long benchmark(ArrayList<Integer> list, int iterations) {
-        long sum = 0;
-        for (int i = 0; i < iterations; i++) {
-            sum = 0;
-            for (int j = 0; j < 10000; j++) {
-                sum += list.get(j);
-            }
-        }
-        return sum;
-    }
-}
+/*
+
+nodeMain(system: NodeSystem) {
+    let list = 1.to(10000)
+    benchmark(list, 10000)
+    let time = system.mainTask().time {
+        benchmark(list, 10000)
+    }
+    Log.trace(time.second.show())
+}
+
+benchmark(list: List[Int], iterations: Int): Int {
+    mutable sum = 0
+    mutable i = 0
+    while {i < iterations} {
+        mutable j = 0
+        while {j < 10000} {
+            sum += list.grab(j)
+            j += 1
+        }
+        i += 1
+    }
+    sum
+}
+
+ */
+
+ // Rewrite the above to Java
+
+import java.util.ArrayList;
+
+public class ListGrab {
+    public static void main(String[] args) {
+        ArrayList<Integer> list = new ArrayList<>();
+        for (int i = 1; i <= 10000; i++) {
+            list.add(i);
+        }
+        benchmark(list, 100000);
+        long time = System.currentTimeMillis();
+        benchmark(list, 100000);
+        time = System.currentTimeMillis() - time;
+        System.out.println(time / 1000.0);
+    }
+
+    public static long benchmark(ArrayList<Integer> list, int iterations) {
+        long sum = 0;
+        for (int i = 0; i < iterations; i++) {
+            sum = 0;
+            for (int j = 0; j < 10000; j++) {
+                sum += list.get(j);
+            }
+        }
+        return sum;
+    }
+}

package/experimental/benchmarks/Pyrotek45.ff

@@ -1,30 +1,30 @@
-nodeMain(system: NodeSystem) {
-    benchmark()
-    let time = system.mainTask().time {
-        benchmark()
-    }
-    Log.trace(time.second.show())
-}
-
-benchmark() {
-    mutable num = 20000
-    let v = num
-    mutable i = 1
-    mutable j = 1
-    mutable sum = 0
-    while {i < v} {
-        j = 1
-        while {j < num - 1} {
-            if(num % j == 0) {
-                sum += j
-            }
-            j += 1
-        }
-        if(num == sum) {
-            Log.show(sum)
-        }
-        sum = 0
-        num -= 1
-        i += 1
-    }    
-}
+nodeMain(system: NodeSystem) {
+    benchmark()
+    let time = system.mainTask().time {
+        benchmark()
+    }
+    Log.trace(time.second.show())
+}
+
+benchmark() {
+    mutable num = 20000
+    let v = num
+    mutable i = 1
+    mutable j = 1
+    mutable sum = 0
+    while {i < v} {
+        j = 1
+        while {j < num - 1} {
+            if(num % j == 0) {
+                sum += j
+            }
+            j += 1
+        }
+        if(num == sum) {
+            Log.show(sum)
+        }
+        sum = 0
+        num -= 1
+        i += 1
+    }    
+}