firefly-compiler 0.4.79 → 0.4.81

package/output/js/ff/core/Random.mjs

@@ -110,36 +110,36 @@ return ff_core_Random.newFromFloat_(seed_)
 }
 
 export function newFromBuffer_(buffer_) {
-
-        var n = 0xefc8249d;
-        function mash(data) {
-            for(var i = 0; i < data.byteLength; i++) {
-                n += data.getUint8(i);
-                var h = 0.02519603282416938 * n;
-                n = h >>> 0;
-                h -= n;
-                h *= n;
-                n = h >>> 0;
-                h -= n;
-                n += h * 0x100000000; // 2^32
-            }
-            return (n >>> 0) * 2.3283064365386963e-10; // 2^-32
-        }
-        var space = new DataView(new Uint8Array([32]).buffer);
-        var r = {
-            s0: mash(space),
-            s1: mash(space),
-            s2: mash(space),
-            c: 1,
-            spareGauss: NaN
-        };
-        r.s0 -= mash(buffer_);
-        if(r.s0 < 0) r.s0 += 1;
-        r.s1 -= mash(buffer_);
-        if(r.s1 < 0) r.s1 += 1;
-        r.s2 -= mash(buffer_);
-        if(r.s2 < 0) r.s2 += 1;
-        return r;
+
+        var n = 0xefc8249d;
+        function mash(data) {
+            for(var i = 0; i < data.byteLength; i++) {
+                n += data.getUint8(i);
+                var h = 0.02519603282416938 * n;
+                n = h >>> 0;
+                h -= n;
+                h *= n;
+                n = h >>> 0;
+                h -= n;
+                n += h * 0x100000000; // 2^32
+            }
+            return (n >>> 0) * 2.3283064365386963e-10; // 2^-32
+        }
+        var space = new DataView(new Uint8Array([32]).buffer);
+        var r = {
+            s0: mash(space),
+            s1: mash(space),
+            s2: mash(space),
+            c: 1,
+            spareGauss: NaN
+        };
+        r.s0 -= mash(buffer_);
+        if(r.s0 < 0) r.s0 += 1;
+        r.s1 -= mash(buffer_);
+        if(r.s1 < 0) r.s1 += 1;
+        r.s2 -= mash(buffer_);
+        if(r.s2 < 0) r.s2 += 1;
+        return r;
     
 }
 
@@ -162,24 +162,24 @@ throw new Error('Function newFromBuffer is missing on this target in async conte
 }
 
 export function Random_copy(self_) {
-
-            return {...self_};
+
+            return {...self_};
         
 }
 
 export function Random_nextInt(self_, from_, until_) {
-
-            return Random_nextFloat(self_, from_, until_) | 0;
+
+            return Random_nextFloat(self_, from_, until_) | 0;
         
 }
 
 export function Random_nextFloat(self_, from_, until_) {
-
-            var t = 2091639 * self_.s0 + self_.c * 2.3283064365386963e-10; // 2^-32
-            self_.s0 = self_.s1;
-            self_.s1 = self_.s2;
-            var uniform = self_.s2 = t - (self_.c = t | 0);
-            return from_ + uniform * (until_ - from_);
+
+            var t = 2091639 * self_.s0 + self_.c * 2.3283064365386963e-10; // 2^-32
+            self_.s0 = self_.s1;
+            self_.s1 = self_.s2;
+            var uniform = self_.s2 = t - (self_.c = t | 0);
+            return from_ + uniform * (until_ - from_);
         
 }
 
@@ -194,22 +194,22 @@ ff_core_Buffer.Buffer_setUint8(buffer_, i_, ff_core_Random.Random_nextInt(self_,
 }
 
 export function Random_nextGauss(self_, mean_, standardDeviation_) {
-
-            if(!isNaN(self_.spareGauss)) {
-                const result = self_.spareGauss * standardDeviation_ + mean_;
-                self_.spareGauss = NaN;
-                return result;
-            } else {
-                let u = 0.5, v = 0.5, s = 0.5;
-                do {
-                    u = Random_nextFloat(self_, 0.0, 1.0) * 2 - 1;
-                    v = Random_nextFloat(self_, 0.0, 1.0) * 2 - 1;
-                    s = u * u + v * v;
-                } while(s >= 1 || s == 0);
-                s = Math.sqrt(-2.0 * Math.log(s) / s);
-                self_.spareGauss = v * s;
-                return mean_ + standardDeviation_ * u * s;
-            }
+
+            if(!isNaN(self_.spareGauss)) {
+                const result = self_.spareGauss * standardDeviation_ + mean_;
+                self_.spareGauss = NaN;
+                return result;
+            } else {
+                let u = 0.5, v = 0.5, s = 0.5;
+                do {
+                    u = Random_nextFloat(self_, 0.0, 1.0) * 2 - 1;
+                    v = Random_nextFloat(self_, 0.0, 1.0) * 2 - 1;
+                    s = u * u + v * v;
+                } while(s >= 1 || s == 0);
+                s = Math.sqrt(-2.0 * Math.log(s) / s);
+                self_.spareGauss = v * s;
+                return mean_ + standardDeviation_ * u * s;
+            }
         
 }
 

package/output/js/ff/core/Task.mjs

@@ -100,39 +100,39 @@ import * as ff_core_Unit from "../../ff/core/Unit.mjs"
 
 
 export function Task_spawn(self_, body_) {
-
-            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
+
+            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
         
 }
 
 export function Task_throwIfAborted(self_) {
-
-            if(self_.controller.signal.aborted) {
-                const signal = self_.controller.signal
-                self_.controller = new AbortController()
-                signal.throwIfAborted()
-            }
+
+            if(self_.controller.signal.aborted) {
+                const signal = self_.controller.signal
+                self_.controller = new AbortController()
+                signal.throwIfAborted()
+            }
         
 }
 
 export function Task_abort(self_) {
-
-            self_.controller.abort()
+
+            self_.controller.abort()
         
 }
 
@@ -161,20 +161,20 @@ return ff_core_Pair.Pair(result_, duration_)
 }
 
 export async function Task_spawn$(self_, body_, $task) {
-
-            return ff_core_Task.Task_spawn(self_, body_)
+
+            return ff_core_Task.Task_spawn(self_, body_)
         
 }
 
 export async function Task_throwIfAborted$(self_, $task) {
-
-            ff_core_Task.Task_throwIfAborted(self_)
+
+            ff_core_Task.Task_throwIfAborted(self_)
         
 }
 
 export async function Task_abort$(self_, $task) {
-
-            self_.controller.abort()
+
+            self_.controller.abort()
         
 }
 
@@ -210,12 +210,28 @@ ff_core_Channel.ChannelAction_timeout(ff_core_Channel.readOr_(ff_core_Task.Task_
 }))
 }
 
+export function Task_mapList(self_, list_, body_) {
+return ff_core_Task.Task_all(self_, ff_core_List.List_map(list_, ((x_) => {
+return (() => {
+return body_(x_)
+})
+})))
+}
+
+export function Task_raceList(self_, list_, body_) {
+return ff_core_Task.Task_race(self_, ff_core_List.List_map(list_, ((x_) => {
+return (() => {
+return body_(x_)
+})
+})))
+}
+
 export function Task_all(self_, tasks_) {
 const successChannel_ = ff_core_Task.Task_channel(self_, 0);
 const failureChannel_ = ff_core_Task.Task_channel(self_, 0);
 ff_core_Task.Task_spawn(self_, ((t_) => {
 const channel_ = ff_core_Task.Task_channel(t_, 0);
-ff_core_Try.Try_grab(ff_core_Try.Try_catchAny(ff_core_Core.try_((() => {
+ff_core_Try.Try_catchAny(ff_core_Core.try_((() => {
 ff_core_List.List_each(ff_core_List.List_pairs(tasks_), ((_1) => {
 {
 const i_ = _1.first_;
@@ -237,7 +253,7 @@ ff_core_Channel.Channel_write(successChannel_, result_)
 })), ((error_) => {
 ff_core_Channel.Channel_write(failureChannel_, error_);
 ff_core_Task.Task_abort(t_)
-})))
+}))
 }));
 return ff_core_Channel.ChannelAction_wait(ff_core_Channel.ChannelAction_readOr(ff_core_Channel.readOr_(successChannel_, ((_w1) => {
 return _w1
@@ -252,14 +268,14 @@ const failureChannel_ = ff_core_Task.Task_channel(self_, 0);
 let live_ = ff_core_List.List_size(tasks_);
 const started_ = ff_core_List.List_map(tasks_, ((task_) => {
 return ff_core_Task.Task_spawn(self_, ((_) => {
-ff_core_Try.Try_grab(ff_core_Try.Try_catchAny(ff_core_Core.try_((() => {
+ff_core_Try.Try_catchAny(ff_core_Core.try_((() => {
 ff_core_Channel.Channel_write(successChannel_, task_())
 })), ((e_) => {
 live_ -= 1;
 if((live_ === 0)) {
 ff_core_Channel.Channel_write(failureChannel_, e_)
 }
-})))
+}))
 }))
 }));
 try {
@@ -283,12 +299,28 @@ export async function Task_sleep$(self_, duration_, $task) {
 }), $task))
 }
 
+export async function Task_mapList$(self_, list_, body_, $task) {
+return (await ff_core_Task.Task_all$(self_, ff_core_List.List_map(list_, ((x_) => {
+return (async ($task) => {
+return (await body_(x_, $task))
+})
+})), $task))
+}
+
+export async function Task_raceList$(self_, list_, body_, $task) {
+return (await ff_core_Task.Task_race$(self_, ff_core_List.List_map(list_, ((x_) => {
+return (async ($task) => {
+return (await body_(x_, $task))
+})
+})), $task))
+}
+
 export async function Task_all$(self_, tasks_, $task) {
 const successChannel_ = (await ff_core_Task.Task_channel$(self_, 0, $task));
 const failureChannel_ = (await ff_core_Task.Task_channel$(self_, 0, $task));
 (await ff_core_Task.Task_spawn$(self_, (async (t_, $task) => {
 const channel_ = (await ff_core_Task.Task_channel$(t_, 0, $task));
-ff_core_Try.Try_grab((await ff_core_Try.Try_catchAny$((await ff_core_Core.try_$((async ($task) => {
+(await ff_core_Try.Try_catchAny$((await ff_core_Core.try_$((async ($task) => {
 (await ff_core_List.List_each$(ff_core_List.List_pairs(tasks_), (async (_1, $task) => {
 {
 const i_ = _1.first_;
@@ -310,7 +342,7 @@ return _w1.second_
 }), $task)), (async (error_, $task) => {
 (await ff_core_Channel.Channel_write$(failureChannel_, error_, $task));
 (await ff_core_Task.Task_abort$(t_, $task))
-}), $task)))
+}), $task))
 }), $task));
 return (await ff_core_Channel.ChannelAction_wait$((await ff_core_Channel.ChannelAction_readOr$((await ff_core_Channel.readOr_$(successChannel_, (async (_w1, $task) => {
 return _w1
@@ -325,14 +357,14 @@ const failureChannel_ = (await ff_core_Task.Task_channel$(self_, 0, $task));
 let live_ = ff_core_List.List_size(tasks_);
 const started_ = (await ff_core_List.List_map$(tasks_, (async (task_, $task) => {
 return (await ff_core_Task.Task_spawn$(self_, (async (_, $task) => {
-ff_core_Try.Try_grab((await ff_core_Try.Try_catchAny$((await ff_core_Core.try_$((async ($task) => {
+(await ff_core_Try.Try_catchAny$((await ff_core_Core.try_$((async ($task) => {
 (await ff_core_Channel.Channel_write$(successChannel_, (await task_($task)), $task))
 }), $task)), (async (e_, $task) => {
 live_ -= 1;
 if((live_ === 0)) {
 (await ff_core_Channel.Channel_write$(failureChannel_, e_, $task))
 }
-}), $task)))
+}), $task))
 }), $task))
 }), $task));
 try {

package/output/js/ff/core/Try.mjs

@@ -139,6 +139,53 @@ return ff_core_Any.fromAny_(any_, ff_core_Any_HasAnyTag$E)
 }));
 if(_guard1.Some) {
 const e_ = _guard1.value_;
+return body_(e_, error_)
+}
+}
+{
+return ff_core_Try.Try_grab(self_)
+}
+}
+}
+
+export function Try_catchAny(self_, body_) {
+{
+const _1 = self_;
+if(_1.Failure) {
+const error_ = _1.error_;
+return body_(error_)
+}
+{
+return ff_core_Try.Try_grab(self_)
+}
+}
+}
+
+export function Try_finally(self_, body_) {
+{
+const _1 = self_;
+if(_1.Success) {
+const value_ = _1.value_;
+body_();
+return value_
+}
+if(_1.Failure) {
+body_();
+return ff_core_Try.Try_grab(self_)
+}
+}
+}
+
+export function Try_tryCatch(self_, body_, ff_core_Any_HasAnyTag$E) {
+{
+const _1 = self_;
+if(_1.Failure) {
+const error_ = _1.error_;
+const _guard1 = ff_core_Option.Option_flatMap(ff_core_Error.Error_exception(error_), ((any_) => {
+return ff_core_Any.fromAny_(any_, ff_core_Any_HasAnyTag$E)
+}));
+if(_guard1.Some) {
+const e_ = _guard1.value_;
 return ff_core_Core.try_((() => {
 return body_(e_, error_)
 }))
@@ -151,7 +198,7 @@ return self_
 }
 }
 
-export function Try_catchAny(self_, body_) {
+export function Try_tryCatchAny(self_, body_) {
 {
 const _1 = self_;
 if(_1.Failure) {
@@ -167,7 +214,7 @@ return self_
 }
 }
 
-export function Try_finally(self_, body_) {
+export function Try_tryFinally(self_, body_) {
 {
 const _1 = self_;
 if(_1.Success) {
@@ -267,6 +314,53 @@ return ff_core_Any.fromAny_(any_, ff_core_Any_HasAnyTag$E)
 }));
 if(_guard1.Some) {
 const e_ = _guard1.value_;
+return (await body_(e_, error_, $task))
+}
+}
+{
+return ff_core_Try.Try_grab(self_)
+}
+}
+}
+
+export async function Try_catchAny$(self_, body_, $task) {
+{
+const _1 = self_;
+if(_1.Failure) {
+const error_ = _1.error_;
+return (await body_(error_, $task))
+}
+{
+return ff_core_Try.Try_grab(self_)
+}
+}
+}
+
+export async function Try_finally$(self_, body_, $task) {
+{
+const _1 = self_;
+if(_1.Success) {
+const value_ = _1.value_;
+(await body_($task));
+return value_
+}
+if(_1.Failure) {
+(await body_($task));
+return ff_core_Try.Try_grab(self_)
+}
+}
+}
+
+export async function Try_tryCatch$(self_, body_, ff_core_Any_HasAnyTag$E, $task) {
+{
+const _1 = self_;
+if(_1.Failure) {
+const error_ = _1.error_;
+const _guard1 = ff_core_Option.Option_flatMap(ff_core_Error.Error_exception(error_), ((any_) => {
+return ff_core_Any.fromAny_(any_, ff_core_Any_HasAnyTag$E)
+}));
+if(_guard1.Some) {
+const e_ = _guard1.value_;
 return (await ff_core_Core.try_$((async ($task) => {
 return (await body_(e_, error_, $task))
 }), $task))
@@ -279,7 +373,7 @@ return self_
 }
 }
 
-export async function Try_catchAny$(self_, body_, $task) {
+export async function Try_tryCatchAny$(self_, body_, $task) {
 {
 const _1 = self_;
 if(_1.Failure) {
@@ -295,7 +389,7 @@ return self_
 }
 }
 
-export async function Try_finally$(self_, body_, $task) {
+export async function Try_tryFinally$(self_, body_, $task) {
 {
 const _1 = self_;
 if(_1.Success) {

package/package.json

@@ -4,7 +4,7 @@
     "description": "Firefly compiler",
     "author": "Firefly team",
     "license": "MIT",
-    "version": "0.4.79",
+    "version": "0.4.81",
     "repository": {
         "type": "git",
         "url": "https://github.com/Ahnfelt/firefly-boot"

package/postgresql/Pg.ff

@@ -98,7 +98,7 @@ extend self: PgPool {
         } finally {
             if(!done) {connection.statement("rollback").run()}
             connection.release()
-        } grab()
+        }
     }
 
 }

package/rpc/.firefly/package.ff

@@ -1 +1 @@
-package ff:rpc:0.0.0
+package ff:rpc:0.0.0

package/rpc/Rpc.ff

@@ -1,70 +1,70 @@
-trait I: Rpc[O] {}
-
-capability RpcServer[I, O, C](
-    handlers: StringMap[(C, I) => O]
-)
-
-newServer[I, O, C](): RpcServer[I, O, C] {
-    RpcServer(StringMap.new())
-}
-
-extend self[I, O, C]: RpcServer[I, O, C] {
-    handle(name: String, context: C, input: I): Option[O] {
-        self.handlers.get(name).map {handler =>
-            handler(context, input)
-        }
-    }
-    
-    addCustom(
-        handler: (C, I) => O
-    ): Unit {
-        let name = "TODO"
-        self.handlers.set(name) {context, input =>
-            handler(context, input)
-        }
-    }
-}
-
-extend self[C]: RpcServer[Buffer, Buffer, C] {
-    add[I: Rpc[O]: HasAnyTag: Serializable, O: Serializable](
-        handler: (C, I) => O
-    ): Unit {
-        let name = Any.anyTag[I]().show()
-        self.handlers.set(name) {context, message =>
-            let input = Serializable.deserialize(message)
-            let output = handler(context, input)
-            Serializable.serialize(output)
-        }
-    }
-}
-
-capability RpcClient(
-    binaryCall: (String, Buffer) => Buffer
-)
-
-extend self: RpcClient {
-    call[I: Rpc[O]: HasAnyTag: Serializable, O: Serializable](
-        message: I
-    ): O {
-        let name = Any.anyTag[I]().show()
-        let input = Serializable.serialize(message)
-        let response = self.binaryCall(name, input)
-        Serializable.deserialize(response)
-    }
-}
-
-newClient(
-    httpClient: HttpClient
-    prefix: String
-    method: String = "POST"
-): RpcClient {
-    RpcClient {name, buffer =>
-        httpClient.fetch(
-            method = method
-            url = prefix + name
-            headers = []
-            payload = Some(buffer)
-            options = FetchOptions()
-        ) {_.readBuffer()}
-    }
-}
+trait I: Rpc[O] {}
+
+capability RpcServer[I, O, C](
+    handlers: StringMap[(C, I) => O]
+)
+
+newServer[I, O, C](): RpcServer[I, O, C] {
+    RpcServer(StringMap.new())
+}
+
+extend self[I, O, C]: RpcServer[I, O, C] {
+    handle(name: String, context: C, input: I): Option[O] {
+        self.handlers.get(name).map {handler =>
+            handler(context, input)
+        }
+    }
+    
+    addCustom(
+        handler: (C, I) => O
+    ): Unit {
+        let name = "TODO"
+        self.handlers.set(name) {context, input =>
+            handler(context, input)
+        }
+    }
+}
+
+extend self[C]: RpcServer[Buffer, Buffer, C] {
+    add[I: Rpc[O]: HasAnyTag: Serializable, O: Serializable](
+        handler: (C, I) => O
+    ): Unit {
+        let name = Any.anyTag[I]().show()
+        self.handlers.set(name) {context, message =>
+            let input = Serializable.deserialize(message)
+            let output = handler(context, input)
+            Serializable.serialize(output)
+        }
+    }
+}
+
+capability RpcClient(
+    binaryCall: (String, Buffer) => Buffer
+)
+
+extend self: RpcClient {
+    call[I: Rpc[O]: HasAnyTag: Serializable, O: Serializable](
+        message: I
+    ): O {
+        let name = Any.anyTag[I]().show()
+        let input = Serializable.serialize(message)
+        let response = self.binaryCall(name, input)
+        Serializable.deserialize(response)
+    }
+}
+
+newClient(
+    httpClient: HttpClient
+    prefix: String
+    method: String = "POST"
+): RpcClient {
+    RpcClient {name, buffer =>
+        httpClient.fetch(
+            method = method
+            url = prefix + name
+            headers = []
+            payload = Some(buffer)
+            options = FetchOptions()
+        ) {_.readBuffer()}
+    }
+}

package/s3/.firefly/package.ff

@@ -1 +1 @@
-package ff:s3:0.0.0
+package ff:s3:0.0.0