firefly-compiler 0.4.36 → 0.4.46

package/core/Task.ff

@@ -1,141 +1,141 @@
-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) {}
-    }
-
-    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()
-    }
-            
-}
+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) {}
+    }
+
+    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/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;
+        }
+    }
+}