firefly-compiler 0.5.35 → 0.5.37

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

@@ -42,6 +42,8 @@ import * as ff_core_Int from "../../ff/core/Int.mjs"
 
 import * as ff_core_IntMap from "../../ff/core/IntMap.mjs"
 
+import * as ff_core_Js from "../../ff/core/Js.mjs"
+
 import * as ff_core_JsSystem from "../../ff/core/JsSystem.mjs"
 
 import * as ff_core_JsValue from "../../ff/core/JsValue.mjs"
@@ -68,6 +70,8 @@ import * as ff_core_Pair from "../../ff/core/Pair.mjs"
 
 import * as ff_core_Path from "../../ff/core/Path.mjs"
 
+import * as ff_core_Queue from "../../ff/core/Queue.mjs"
+
 import * as ff_core_Random from "../../ff/core/Random.mjs"
 
 import * as ff_core_Serializable from "../../ff/core/Serializable.mjs"
@@ -90,13 +94,15 @@ import * as ff_core_Try from "../../ff/core/Try.mjs"
 
 import * as ff_core_Unit from "../../ff/core/Unit.mjs"
 
-import * as ff_core_UnsafeJs from "../../ff/core/UnsafeJs.mjs"
-
 // type Lock
-
+export function Lock(owner_, level_, queue_) {
+return {owner_, level_, queue_};
+}
 
 // type LockCondition
-
+export function LockCondition(lock_, queue_) {
+return {lock_, queue_};
+}
 
 
 
@@ -105,19 +111,42 @@ import * as ff_core_UnsafeJs from "../../ff/core/UnsafeJs.mjs"
 
 
 export function Lock_condition(self_) {
-throw new Error('Function Lock_condition is missing on this target in sync context.');
+return ff_core_Lock.LockCondition(self_, ff_core_Queue.new_())
 }
 
-export function Lock_acquire(self_, reentrant_) {
-throw new Error('Function Lock_acquire is missing on this target in sync context.');
+export function Lock_acquire(self_) {
+if(((self_.level_ === 0) || (self_.owner_ === $task))) {
+self_.owner_ = $task;
+self_.level_ += 1
+} else {
+ff_core_Js.awaitCancellablePromise_(((resolve_, reject_, onSettle_) => {
+const key_ = ff_core_Queue.Queue_push(self_.queue_, ff_core_Pair.Pair($task, resolve_));
+onSettle_(((_) => {
+ff_core_Queue.Queue_remove(self_.queue_, key_)
+}))
+}))
+}
 }
 
 export function Lock_release(self_) {
-throw new Error('Function Lock_release is missing on this target in sync context.');
+if((self_.owner_ !== $task)) {
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_core_Core.GrabException(), ff_core_Core.ff_core_Any_HasAnyTag$ff_core_Core_GrabException)})
+} else if((self_.level_ > 1)) {
+self_.level_ -= 1
+} else {
+self_.owner_ = (void 0);
+self_.level_ = 0;
+if((!ff_core_Queue.Queue_isEmpty(self_.queue_))) {
+const pending_ = ff_core_Option.Option_grab(ff_core_Queue.Queue_pop(self_.queue_));
+self_.owner_ = pending_.first_;
+self_.level_ = 1;
+pending_.second_((void 0))
+}
+}
 }
 
-export function Lock_do(self_, reentrant_, body_) {
-ff_core_Lock.Lock_acquire(self_, reentrant_);
+export function Lock_do(self_, body_) {
+ff_core_Lock.Lock_acquire(self_);
 try {
 return body_()
 } finally {
@@ -126,63 +155,42 @@ ff_core_Lock.Lock_release(self_)
 }
 
 export async function Lock_condition$(self_, $task) {
-
-            return {lock: self_, stack: [], queue: []}
-        
-}
-
-export async function Lock_acquire$(self_, reentrant_, $task) {
-
-            if(self_.level === 0) {
-                self_.owner = $task
-                self_.level += 1
-            } else {
-                if(self_.owner !== $task || !reentrant_) {
-                    try {
-                        await new Promise((resolve, reject) => {
-                            $task.controller.signal.addEventListener('abort', reject)
-                            try {
-                                self_.queue.push({owner: $task, resolve: resolve})
-                            } finally {
-                                $task.controller.signal.removeEventListener('abort', reject)
-                            }
-                        })
-                    } finally {
-                        if($task.controller.signal.aborted) $task.controller = new AbortController()
-                    }
-                } else {
-                    self_.level += 1
-                }
-            }
-        
+return ff_core_Lock.LockCondition(self_, ff_core_Queue.new_())
+}
+
+export async function Lock_acquire$(self_, $task) {
+if(((self_.level_ === 0) || (self_.owner_ === $task))) {
+self_.owner_ = $task;
+self_.level_ += 1
+} else {
+(await ff_core_Js.awaitCancellablePromise_$((async (resolve_, reject_, onSettle_, $task) => {
+const key_ = ff_core_Queue.Queue_push(self_.queue_, ff_core_Pair.Pair($task, resolve_));
+(await onSettle_((async (_, $task) => {
+ff_core_Queue.Queue_remove(self_.queue_, key_)
+}), $task))
+}), $task))
+}
 }
 
 export async function Lock_release$(self_, $task) {
-
-            if(self_.owner !== $task) {
-                throw new Error("Tried to release a lock without acquiring it first.")
-            } else if(self_.level > 1) {
-                self_.level -= 1
-            } else {
-                self_.owner = null
-                self_.level = 0
-                if(self_.stack.length === 0) {
-                    const empty = self_.stack
-                    self_.stack = self_.queue.reverse()
-                    self_.queue = empty
-                }
-                if(self_.stack.length !== 0) {
-                    const pending = self_.stack.pop()
-                    self_.owner = pending.owner
-                    self_.level = 1
-                    pending.resolve()
-                }
-            }
-        
-}
-
-export async function Lock_do$(self_, reentrant_, body_, $task) {
-(await ff_core_Lock.Lock_acquire$(self_, reentrant_, $task));
+if((self_.owner_ !== $task)) {
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_core_Core.GrabException(), ff_core_Core.ff_core_Any_HasAnyTag$ff_core_Core_GrabException)})
+} else if((self_.level_ > 1)) {
+self_.level_ -= 1
+} else {
+self_.owner_ = (void 0);
+self_.level_ = 0;
+if((!ff_core_Queue.Queue_isEmpty(self_.queue_))) {
+const pending_ = ff_core_Option.Option_grab(ff_core_Queue.Queue_pop(self_.queue_));
+self_.owner_ = pending_.first_;
+self_.level_ = 1;
+(await pending_.second_((void 0), $task))
+}
+}
+}
+
+export async function Lock_do$(self_, body_, $task) {
+(await ff_core_Lock.Lock_acquire$(self_, $task));
 try {
 return (await body_($task))
 } finally {
@@ -191,7 +199,36 @@ return (await body_($task))
 }
 
 export function LockCondition_sleep(self_) {
-throw new Error('Function LockCondition_sleep is missing on this target in sync context.');
+if((self_.lock_.owner_ !== $task)) {
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_core_Core.GrabException(), ff_core_Core.ff_core_Any_HasAnyTag$ff_core_Core_GrabException)})
+};
+;
+const level_ = self_.lock_.level_;
+self_.lock_.level_ = 1;
+ff_core_Lock.Lock_release(self_.lock_);
+try {
+ff_core_Js.awaitCancellablePromise_(((resolve_, reject_, onSettle_) => {
+const key_ = ff_core_Queue.Queue_push(self_.queue_, resolve_);
+onSettle_(((_) => {
+ff_core_Queue.Queue_remove(self_.queue_, key_)
+}))
+}))
+} finally {
+let error_;
+let acquired_ = false;
+while((!acquired_)) {
+try {
+ff_core_Lock.Lock_acquire(self_.lock_);
+self_.lock_.level_ = level_;
+acquired_ = true
+} catch(e_) {
+error_ = e_
+}
+};
+if(ff_core_JsValue.JsValue_isUndefined(error_)) {
+throw error_
+}
+}
 }
 
 export function LockCondition_sleepUntil(self_, body_) {
@@ -202,7 +239,7 @@ if(_1.Some) {
 const value_ = _1.value_;
 return value_
 }
-if(_1.None) {
+{
 ff_core_Lock.LockCondition_sleep(self_);
 {
 const self_r_ = self_;
@@ -219,46 +256,53 @@ return
 }
 
 export function LockCondition_wakeOne(self_) {
-throw new Error('Function LockCondition_wakeOne is missing on this target in sync context.');
+{
+const if_o = ff_core_Queue.Queue_pop(self_.queue_)
+if(if_o.Some) {
+const resolve_ = if_o.value_;
+resolve_((void 0))
+}
+}
 }
 
 export function LockCondition_wakeAll(self_) {
-throw new Error('Function LockCondition_wakeAll is missing on this target in sync context.');
+ff_core_Queue.Queue_each(self_.queue_, ((_, resolve_) => {
+resolve_((void 0))
+}));
+ff_core_Queue.Queue_clear(self_.queue_)
 }
 
 export async function LockCondition_sleep$(self_, $task) {
-
-            if(self_.lock.owner !== $task) {
-                throw new Error("Tried to sleep on a condition without acquiring it first.")
-            }
-            const level = self_.lock.level
-            self_.lock.level = 1
-            await ff_core_Lock.Lock_release$(self_.lock)
-            try {
-                await new Promise((resolve, reject) => {
-                    $task.controller.signal.addEventListener('abort', reject)
-                    try {
-                        self_.queue.push(resolve)
-                    } finally {
-                        $task.controller.signal.removeEventListener('abort', reject)
-                        if($task.controller.signal.aborted) $task.controller = new AbortController()
-                    }
-                })
-            } finally {
-                let exception = null
-                let acquired = false
-                while(!acquired) {
-                    try {
-                        await ff_core_Lock.Lock_acquire$(self_.lock)
-                        self_.lock.level = level
-                        acquired = true
-                    } catch(e) {
-                        exception = e
-                    }
-                }
-                if(e !== null) throw e;
-            }
-        
+if((self_.lock_.owner_ !== $task)) {
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_core_Core.GrabException(), ff_core_Core.ff_core_Any_HasAnyTag$ff_core_Core_GrabException)})
+};
+ff_core_Task.Task_throwIfAborted($task);
+const level_ = self_.lock_.level_;
+self_.lock_.level_ = 1;
+(await ff_core_Lock.Lock_release$(self_.lock_, $task));
+try {
+(await ff_core_Js.awaitCancellablePromise_$((async (resolve_, reject_, onSettle_, $task) => {
+const key_ = ff_core_Queue.Queue_push(self_.queue_, resolve_);
+(await onSettle_((async (_, $task) => {
+ff_core_Queue.Queue_remove(self_.queue_, key_)
+}), $task))
+}), $task))
+} finally {
+let error_;
+let acquired_ = false;
+while((!acquired_)) {
+try {
+(await ff_core_Lock.Lock_acquire$(self_.lock_, $task));
+self_.lock_.level_ = level_;
+acquired_ = true
+} catch(e_) {
+error_ = e_
+}
+};
+if(ff_core_JsValue.JsValue_isUndefined(error_)) {
+throw error_
+}
+}
 }
 
 export async function LockCondition_sleepUntil$(self_, body_, $task) {
@@ -269,7 +313,7 @@ if(_1.Some) {
 const value_ = _1.value_;
 return value_
 }
-if(_1.None) {
+{
 (await ff_core_Lock.LockCondition_sleep$(self_, $task));
 {
 const self_r_ = self_;
@@ -286,33 +330,20 @@ return
 }
 
 export async function LockCondition_wakeOne$(self_, $task) {
-
-            if(self_.stack.length === 0) {
-                const empty = self_.stack
-                self_.stack = self_.queue.reverse()
-                self_.queue = empty
-            }
-            if(self_.stack.length !== 0) {
-                const resolve = self_.stack.pop()
-                resolve()
-            }
-        
+{
+const if_o = ff_core_Queue.Queue_pop(self_.queue_)
+if(if_o.Some) {
+const resolve_ = if_o.value_;
+(await resolve_((void 0), $task))
+}
+}
 }
 
 export async function LockCondition_wakeAll$(self_, $task) {
-
-            while(self_.stack.length !== 0) {
-                const resolve = self_.stack.pop()
-                resolve()
-            }
-            const empty = self_.stack
-            self_.stack = self_.queue.reverse()
-            self_.queue = empty
-            while(self_.stack.length !== 0) {
-                const resolve = self_.stack.pop()
-                resolve()
-            }
-        
+(await ff_core_Queue.Queue_each$(self_.queue_, (async (_, resolve_, $task) => {
+(await resolve_((void 0), $task))
+}), $task));
+ff_core_Queue.Queue_clear(self_.queue_)
 }
 
 

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

@@ -42,6 +42,8 @@ import * as ff_core_Int from "../../ff/core/Int.mjs"
 
 import * as ff_core_IntMap from "../../ff/core/IntMap.mjs"
 
+import * as ff_core_Js from "../../ff/core/Js.mjs"
+
 import * as ff_core_JsSystem from "../../ff/core/JsSystem.mjs"
 
 import * as ff_core_JsValue from "../../ff/core/JsValue.mjs"
@@ -68,6 +70,8 @@ import * as ff_core_Pair from "../../ff/core/Pair.mjs"
 
 import * as ff_core_Path from "../../ff/core/Path.mjs"
 
+import * as ff_core_Queue from "../../ff/core/Queue.mjs"
+
 import * as ff_core_Random from "../../ff/core/Random.mjs"
 
 import * as ff_core_Serializable from "../../ff/core/Serializable.mjs"
@@ -90,8 +94,6 @@ import * as ff_core_Try from "../../ff/core/Try.mjs"
 
 import * as ff_core_Unit from "../../ff/core/Unit.mjs"
 
-import * as ff_core_UnsafeJs from "../../ff/core/UnsafeJs.mjs"
-
 
 
 
@@ -125,7 +127,11 @@ console.error(value_)
 }
 
 export function trace_(value_) {
-process.stderr.write(value_ + String.fromCharCode(10))
+if(false) {
+console.debug(value_)
+} else {
+process.stderr.write((value_ + "\n"))
+}
 }
 
 export async function show_$(value_, ff_core_Show_Show$T, $task) {
@@ -133,31 +139,35 @@ ff_core_Log.trace_(ff_core_Show_Show$T.show_(value_))
 }
 
 export async function debugDynamic_$(value_, $task) {
-throw new Error('Function debugDynamic is missing on this target in async context.');
+console.debug(value_)
 }
 
 export async function debug_$(value_, $task) {
-throw new Error('Function debug is missing on this target in async context.');
+console.debug(value_)
 }
 
 export async function verbose_$(value_, $task) {
-throw new Error('Function verbose is missing on this target in async context.');
+console.log(value_)
 }
 
 export async function info_$(value_, $task) {
-throw new Error('Function info is missing on this target in async context.');
+console.info(value_)
 }
 
 export async function warn_$(value_, $task) {
-throw new Error('Function warn is missing on this target in async context.');
+console.warn(value_)
 }
 
 export async function error_$(value_, $task) {
-throw new Error('Function error is missing on this target in async context.');
+console.error(value_)
 }
 
 export async function trace_$(value_, $task) {
-throw new Error('Function trace is missing on this target in async context.');
+if(false) {
+console.debug(value_)
+} else {
+process.stderr.write((value_ + "\n"))
+}
 }
 
 

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

@@ -42,6 +42,8 @@ import * as ff_core_Int from "../../ff/core/Int.mjs"
 
 import * as ff_core_IntMap from "../../ff/core/IntMap.mjs"
 
+import * as ff_core_Js from "../../ff/core/Js.mjs"
+
 import * as ff_core_JsSystem from "../../ff/core/JsSystem.mjs"
 
 import * as ff_core_JsValue from "../../ff/core/JsValue.mjs"
@@ -68,6 +70,8 @@ import * as ff_core_Pair from "../../ff/core/Pair.mjs"
 
 import * as ff_core_Path from "../../ff/core/Path.mjs"
 
+import * as ff_core_Queue from "../../ff/core/Queue.mjs"
+
 import * as ff_core_Random from "../../ff/core/Random.mjs"
 
 import * as ff_core_RbMap from "../../ff/core/RbMap.mjs"
@@ -92,8 +96,6 @@ import * as ff_core_Try from "../../ff/core/Try.mjs"
 
 import * as ff_core_Unit from "../../ff/core/Unit.mjs"
 
-import * as ff_core_UnsafeJs from "../../ff/core/UnsafeJs.mjs"
-
 // newtype Map
 
 
@@ -149,7 +151,7 @@ return result_
 
 export function Map_removeList(self_, keys_, ff_core_Ordering_Order$K) {
 let result_ = self_;
-for(let for_i = 0, for_a = keys_, for_l = for_a.length; for_i < for_l; for_i++) {
+for(let for_a = keys_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const k_ = for_a[for_i];
 result_ = ff_core_RbMap.delete_(k_, result_, ff_core_Ordering_Order$K)
 };
@@ -206,7 +208,7 @@ const _1 = ff_core_Map.Map_get(self_, key_, ff_core_Ordering_Order$K);
 if(_1.None) {
 return ff_core_Map.Map_add(self_, key_, default_(), ff_core_Ordering_Order$K)
 }
-if(_1.Some) {
+{
 const v_ = _1.value_;
 return ff_core_Map.Map_add(self_, key_, update_(v_), ff_core_Ordering_Order$K)
 }
@@ -268,7 +270,7 @@ return result_
 
 export async function Map_removeList$(self_, keys_, ff_core_Ordering_Order$K, $task) {
 let result_ = self_;
-for(let for_i = 0, for_a = keys_, for_l = for_a.length; for_i < for_l; for_i++) {
+for(let for_a = keys_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const k_ = for_a[for_i];
 result_ = ff_core_RbMap.delete_(k_, result_, ff_core_Ordering_Order$K)
 };
@@ -325,7 +327,7 @@ const _1 = ff_core_Map.Map_get(self_, key_, ff_core_Ordering_Order$K);
 if(_1.None) {
 return ff_core_Map.Map_add(self_, key_, (await default_($task)), ff_core_Ordering_Order$K)
 }
-if(_1.Some) {
+{
 const v_ = _1.value_;
 return ff_core_Map.Map_add(self_, key_, (await update_(v_, $task)), ff_core_Ordering_Order$K)
 }
@@ -366,7 +368,7 @@ const _1 = ff_core_Map.Map_get(self_, key_, ff_core_Ordering_Order$K);
 if(_1.None) {
 return ff_core_Map.Map_add(self_, key_, ff_core_List.List_toArray([value_]), ff_core_Ordering_Order$K)
 }
-if(_1.Some) {
+{
 const array_ = _1.value_;
 array_.array.push(value_);
 return self_
@@ -380,7 +382,7 @@ const _1 = ff_core_Map.Map_get(self_, key_, ff_core_Ordering_Order$K);
 if(_1.None) {
 return ff_core_Map.Map_add(self_, key_, ff_core_List.List_toArray([value_]), ff_core_Ordering_Order$K)
 }
-if(_1.Some) {
+{
 const array_ = _1.value_;
 array_.array.push(value_);
 return self_