firefly-compiler 0.4.40 → 0.4.48

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

@@ -96,26 +96,26 @@ import * as ff_core_Unit from "../../ff/core/Unit.mjs"
 
 
 export function new_() {
-
-        return [];
+
+        return [];
     
 }
 
 export function fill_(size_, value_) {
-
-        return new Array(size_).fill(value_);
+
+        return new Array(size_).fill(value_);
     
 }
 
 export function fillBy_(size_, body_) {
-
-        return Array.from({length: size_}, (_, i) => body_(i));
+
+        return Array.from({length: size_}, (_, i) => body_(i));
     
 }
 
 export function range_(size_) {
-
-        return Array.from({length: size_}, (_, i) => i);
+
+        return Array.from({length: size_}, (_, i) => i);
     
 }
 
@@ -124,8 +124,8 @@ return left_ === right_
 }
 
 export function internalGrab_(self_, index_) {
-
-        return index_ < 0 || index_ >= self_.length ? ff_core_Try.internalThrowGrabException_() : self_[index_];
+
+        return index_ < 0 || index_ >= self_.length ? ff_core_Try.internalThrowGrabException_() : self_[index_];
     
 }
 
@@ -138,12 +138,12 @@ throw new Error('Function fill is missing on this target in async context.');
 }
 
 export async function fillBy_$(size_, body_, $task) {
-
-        const array = new Array(size_);
-        for(let i = 0; i < size_; i++) {
-            array[i] = await(body_(_i));
-        }
-        return array;
+
+        const array = new Array(size_);
+        for(let i = 0; i < size_; i++) {
+            array[i] = await(body_(_i));
+        }
+        return array;
     
 }
 
@@ -172,16 +172,16 @@ return self_.length
 }
 
 export function List_get(self_, index_) {
-
-            return index_ >= 0 && index_ < self_.length
-                ? ff_core_Option.Some(self_[index_])
-                : ff_core_Option.None()
+
+            return index_ >= 0 && index_ < self_.length
+                ? ff_core_Option.Some(self_[index_])
+                : ff_core_Option.None()
         
 }
 
 export function List_grab(self_, index_) {
-
-            return self_[index_] ?? internalGrab_(self_, index_);
+
+            return self_[index_] ?? internalGrab_(self_, index_);
         
 }
 
@@ -217,6 +217,64 @@ export function List_dropLast(self_, count_ = 1) {
 return self_.slice(0, self_.length - count_)
 }
 
+export function List_count(self_, body_) {
+let result_ = 0;
+let i_ = 0;
+while((i_ < ff_core_List.List_size(self_))) {
+if(body_((self_[i_] ?? ff_core_List.internalGrab_(self_, i_)))) {
+result_ += 1
+};
+i_ += 1
+};
+return result_
+}
+
+export function List_countWhile(self_, body_) {
+let i_ = 0;
+while(((i_ < ff_core_List.List_size(self_)) && body_((self_[i_] ?? ff_core_List.internalGrab_(self_, i_))))) {
+i_ += 1
+};
+return i_
+}
+
+export function List_takeWhile(self_, body_) {
+const result_ = ff_core_Array.new_();
+let i_ = 0;
+while(((i_ < ff_core_List.List_size(self_)) && body_((self_[i_] ?? ff_core_List.internalGrab_(self_, i_))))) {
+ff_core_Array.Array_push(result_, (self_[i_] ?? ff_core_List.internalGrab_(self_, i_)));
+i_ += 1
+};
+return ff_core_Array.Array_drain(result_)
+}
+
+export function List_dropWhile(self_, body_) {
+const result_ = ff_core_Array.new_();
+let i_ = 0;
+while(((i_ < ff_core_List.List_size(self_)) && body_((self_[i_] ?? ff_core_List.internalGrab_(self_, i_))))) {
+i_ += 1
+};
+while((i_ < ff_core_List.List_size(self_))) {
+ff_core_Array.Array_push(result_, (self_[i_] ?? ff_core_List.internalGrab_(self_, i_)));
+i_ += 1
+};
+return ff_core_Array.Array_drain(result_)
+}
+
+export function List_partitionWhile(self_, body_) {
+const first_ = ff_core_Array.new_();
+const second_ = ff_core_Array.new_();
+let i_ = 0;
+while(((i_ < ff_core_List.List_size(self_)) && body_((self_[i_] ?? ff_core_List.internalGrab_(self_, i_))))) {
+ff_core_Array.Array_push(first_, (self_[i_] ?? ff_core_List.internalGrab_(self_, i_)));
+i_ += 1
+};
+while((i_ < ff_core_List.List_size(self_))) {
+ff_core_Array.Array_push(second_, (self_[i_] ?? ff_core_List.internalGrab_(self_, i_)));
+i_ += 1
+};
+return ff_core_Pair.Pair(ff_core_Array.Array_drain(first_), ff_core_Array.Array_drain(second_))
+}
+
 export function List_pairs(self_) {
 let i_ = 0;
 return ff_core_List.List_map(self_, ((x_) => {
@@ -245,13 +303,13 @@ return value_
 }
 
 export function List_modify(self_, index_, body_) {
-
-            if(index_ < 0 || index_ >= self_.length) {
-                ff_core_Try.internalThrowGrabException_()
-            }
-            let result = self_.slice();
-            result[index_] = body_(result[index_]);
-            return result;
+
+            if(index_ < 0 || index_ >= self_.length) {
+                ff_core_Try.internalThrowGrabException_()
+            }
+            let result = self_.slice();
+            result[index_] = body_(result[index_]);
+            return result;
         
 }
 
@@ -316,8 +374,8 @@ return {array: self_.slice()}
 }
 
 export function List_each(self_, body_) {
-
-            return self_.forEach(body_);
+
+            return self_.forEach(body_);
         
 }
 
@@ -343,6 +401,21 @@ return (!result_)
 return result_
 }
 
+export function List_indexWhere(self_, body_) {
+let result_ = ff_core_Option.None();
+let i_ = 0;
+ff_core_List.List_eachWhile(self_, ((x_) => {
+if(body_(x_)) {
+result_ = ff_core_Option.Some(i_);
+return false
+} else {
+i_ += 1;
+return true
+}
+}));
+return result_
+}
+
 export function List_find(self_, body_) {
 let result_ = ff_core_Option.None();
 ff_core_List.List_eachWhile(self_, ((x_) => {
@@ -373,8 +446,8 @@ return (!body_(_w1))
 }
 
 export function List_map(self_, body_) {
-
-            return self_.map(body_)
+
+            return self_.map(body_)
         
 }
 
@@ -500,6 +573,64 @@ export async function List_dropLast$(self_, count_ = 1, $task) {
 throw new Error('Function List_dropLast is missing on this target in async context.');
 }
 
+export async function List_count$(self_, body_, $task) {
+let result_ = 0;
+let i_ = 0;
+while((i_ < ff_core_List.List_size(self_))) {
+if((await body_((self_[i_] ?? ff_core_List.internalGrab_(self_, i_)), $task))) {
+result_ += 1
+};
+i_ += 1
+};
+return result_
+}
+
+export async function List_countWhile$(self_, body_, $task) {
+let i_ = 0;
+while(((i_ < ff_core_List.List_size(self_)) && (await body_((self_[i_] ?? ff_core_List.internalGrab_(self_, i_)), $task)))) {
+i_ += 1
+};
+return i_
+}
+
+export async function List_takeWhile$(self_, body_, $task) {
+const result_ = ff_core_Array.new_();
+let i_ = 0;
+while(((i_ < ff_core_List.List_size(self_)) && (await body_((self_[i_] ?? ff_core_List.internalGrab_(self_, i_)), $task)))) {
+ff_core_Array.Array_push(result_, (self_[i_] ?? ff_core_List.internalGrab_(self_, i_)));
+i_ += 1
+};
+return ff_core_Array.Array_drain(result_)
+}
+
+export async function List_dropWhile$(self_, body_, $task) {
+const result_ = ff_core_Array.new_();
+let i_ = 0;
+while(((i_ < ff_core_List.List_size(self_)) && (await body_((self_[i_] ?? ff_core_List.internalGrab_(self_, i_)), $task)))) {
+i_ += 1
+};
+while((i_ < ff_core_List.List_size(self_))) {
+ff_core_Array.Array_push(result_, (self_[i_] ?? ff_core_List.internalGrab_(self_, i_)));
+i_ += 1
+};
+return ff_core_Array.Array_drain(result_)
+}
+
+export async function List_partitionWhile$(self_, body_, $task) {
+const first_ = ff_core_Array.new_();
+const second_ = ff_core_Array.new_();
+let i_ = 0;
+while(((i_ < ff_core_List.List_size(self_)) && (await body_((self_[i_] ?? ff_core_List.internalGrab_(self_, i_)), $task)))) {
+ff_core_Array.Array_push(first_, (self_[i_] ?? ff_core_List.internalGrab_(self_, i_)));
+i_ += 1
+};
+while((i_ < ff_core_List.List_size(self_))) {
+ff_core_Array.Array_push(second_, (self_[i_] ?? ff_core_List.internalGrab_(self_, i_)));
+i_ += 1
+};
+return ff_core_Pair.Pair(ff_core_Array.Array_drain(first_), ff_core_Array.Array_drain(second_))
+}
+
 export async function List_pairs$(self_, $task) {
 let i_ = 0;
 return ff_core_List.List_map(self_, ((x_) => {
@@ -528,13 +659,13 @@ return value_
 }
 
 export async function List_modify$(self_, index_, body_, $task) {
-
-            if(index_ < 0 || index_ >= self_.length) {
-                ff_core_Try.internalThrowGrabException_()
-            }
-            let result = self_.slice();
-            result[index_] = await body_(result[index_], $task);
-            return result;
+
+            if(index_ < 0 || index_ >= self_.length) {
+                ff_core_Try.internalThrowGrabException_()
+            }
+            let result = self_.slice();
+            result[index_] = await body_(result[index_], $task);
+            return result;
         
 }
 
@@ -599,10 +730,10 @@ throw new Error('Function List_toArray is missing on this target in async contex
 }
 
 export async function List_each$(self_, body_, $task) {
-
-            for(let i = 0; i < self_.length; i++) {
-                await body_(self_[i], $task)
-            }
+
+            for(let i = 0; i < self_.length; i++) {
+                await body_(self_[i], $task)
+            }
         
 }
 
@@ -628,6 +759,21 @@ return (!result_)
 return result_
 }
 
+export async function List_indexWhere$(self_, body_, $task) {
+let result_ = ff_core_Option.None();
+let i_ = 0;
+(await ff_core_List.List_eachWhile$(self_, (async (x_, $task) => {
+if((await body_(x_, $task))) {
+result_ = ff_core_Option.Some(i_);
+return false
+} else {
+i_ += 1;
+return true
+}
+}), $task));
+return result_
+}
+
 export async function List_find$(self_, body_, $task) {
 let result_ = ff_core_Option.None();
 (await ff_core_List.List_eachWhile$(self_, (async (x_, $task) => {
@@ -658,12 +804,12 @@ return (!(await body_(_w1, $task)))
 }
 
 export async function List_map$(self_, body_, $task) {
-
-            let result = [];
-            for(let i = 0; i < self_.length; i++) {
-                result.push(await body_(self_[i], $task));
-            }
-            return result;
+
+            let result = [];
+            for(let i = 0; i < self_.length; i++) {
+                result.push(await body_(self_[i], $task));
+            }
+            return result;
         
 }
 

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

@@ -124,58 +124,58 @@ ff_core_Lock.Lock_release(self_)
 }
 
 export async function Lock_condition$(self_, $task) {
-
-            return {lock: self_, stack: [], queue: []}
+
+            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
-                }
-            }
+
+            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
+                }
+            }
         
 }
 
 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()
-                }
-            }
+
+            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()
+                }
+            }
         
 }
 
@@ -225,37 +225,37 @@ throw new Error('Function LockCondition_wakeAll is missing on this target in syn
 }
 
 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 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;
+            }
         
 }
 
@@ -284,32 +284,32 @@ 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()
-            }
+
+            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()
+            }
         
 }
 
 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()
-            }
+
+            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()
+            }
         
 }