firefly-compiler 0.5.39 → 0.5.40

package/core/Task.ff

@@ -1,165 +1,165 @@
-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()}
-        }
-    }
-            
-}
+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
+    }    
+}

package/experimental/benchmarks/Pyrotek45.java

@@ -1,64 +1,64 @@
-/*
-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
-    }    
-}
-*/
-
-// Rewrite this in Java
-
-public class Pyrotek45 {
-    public static void main(String[] args) {
-        benchmark();
-        long time = System.currentTimeMillis();
-        benchmark();
-        time = System.currentTimeMillis() - time;
-        System.out.println(time / 1000.0);
-    }
-
-    public static void benchmark() {
-        int num = 20000;
-        int v = num;
-        int i = 1;
-        int j = 1;
-        int sum = 0;
-        for (i = 1; i < v; i++) {
-            for (j = 1; j < num - 1; j++) {
-                if (num % j == 0) {
-                    sum += j;
-                }
-            }
-            if (num == sum) {
-                System.out.println(sum);
-            }
-            sum = 0;
-            num -= 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
+    }    
+}
+*/
+
+// Rewrite this in Java
+
+public class Pyrotek45 {
+    public static void main(String[] args) {
+        benchmark();
+        long time = System.currentTimeMillis();
+        benchmark();
+        time = System.currentTimeMillis() - time;
+        System.out.println(time / 1000.0);
+    }
+
+    public static void benchmark() {
+        int num = 20000;
+        int v = num;
+        int i = 1;
+        int j = 1;
+        int sum = 0;
+        for (i = 1; i < v; i++) {
+            for (j = 1; j < num - 1; j++) {
+                if (num % j == 0) {
+                    sum += j;
+                }
+            }
+            if (num == sum) {
+                System.out.println(sum);
+            }
+            sum = 0;
+            num -= 1;
+        }
+    }
+}