firefly-compiler 0.4.79 → 0.4.80

package/core/Stream.ff

@@ -42,7 +42,7 @@ extend self[T]: Stream[T] {
                 self.close()
             } finally {
                 that.close()
-            } grab()
+            }
         }
     }
 
@@ -76,7 +76,7 @@ extend self[T]: Stream[T] {
                 inner.close()
             } finally {
                 self.close()
-            } grab()
+            }
         }
     }
 
@@ -111,7 +111,7 @@ extend self[T]: Stream[T] {
                 self.close()
             } finally {
                 that.close()
-            } grab()
+            }
         }
     }
 
@@ -224,7 +224,7 @@ extend self[T]: Stream[T] {
             body(self)
         } finally {
             self.close()
-        } grab()
+        }
     }
 
     each(body: T => Unit): Unit {
@@ -238,7 +238,7 @@ extend self[T]: Stream[T] {
             }
         } finally {
             self.close()
-        } grab()
+        }
     }
 
     eachWhile(body: T => Bool): Unit {
@@ -252,7 +252,7 @@ extend self[T]: Stream[T] {
             }
         } finally {
             self.close()
-        } grab()
+        }
     }
 
     all(body: T => Bool): Bool {
@@ -278,7 +278,7 @@ extend self[T]: Stream[T] {
             self.next()
         } finally {
             self.close()
-        } grab()
+        }
     }
 
     last(): Option[T] {
@@ -294,7 +294,7 @@ extend self[T]: Stream[T] {
             result
         } finally {
             self.close()
-        } grab()
+        }
     }
 
     grabFirst(): T {
@@ -324,7 +324,7 @@ extend self[T]: Stream[T] {
             result
         } finally {
             self.close()
-        } grab()
+        }
     }
 
     find(body: T => Bool): Option[T] {

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()
+            }
+        }
+        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/core/Try.ff

@@ -16,21 +16,42 @@ extend self[T]: Try[T] {
         self.map(body).flatten()
     }
 
-    catch[E: HasAnyTag](body: (E, Error) => T): Try[T] {
+    catch[E: HasAnyTag](body: (E, Error) => T): T {
+        self.{
+            | Failure(error) {error.exception().flatMap(Any.fromAny) | Some(e)} => body(e, error)
+            | _ => self.grab()
+        }
+    }
+
+    catchAny(body: Error => T): T {
+        self.{
+            | Failure(error) => body(error)
+            | _ => self.grab()
+        }
+    }
+
+    finally(body: () => Unit): T {
+        self.{
+            | Success(value) => body(); value
+            | Failure(_) => body(); self.grab()
+        }
+    }
+
+    tryCatch[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] {
+    tryCatchAny(body: Error => T): Try[T] {
         self.{
             | Failure(error) => try {body(error)}
             | _ => self
         }
     }
 
-    finally(body: () => Unit): Try[T] {
+    tryFinally(body: () => Unit): Try[T] {
         self.{
             | Success(value) => try {body(); value}
             | Failure(_) =>
@@ -40,7 +61,7 @@ extend self[T]: Try[T] {
                 }
         }
     }
-
+    
     else(body: () => T): T {
         self.{
             | Success(value) => value

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
+    }    
+}