firefly-compiler 0.5.35 → 0.5.37

package/output/js/ff/core/List.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,75 +94,67 @@ 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 List
 
 
 
 
 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));
-    
-}
-
-export function range_(size_) {
-
-        return Array.from({length: size_}, (_, i) => i);
-    
+if(false) {
+const array_ = (new Array(size_));
+for(let for_i = 1, for_e = size_; for_i < for_e; for_i++) {
+const i_ = for_i;
+array_[i_] = body_(i_)
+};
+return array_
+} else {
+return Array.from({length: size_}, ((_, i_) => {
+return body_(i_)
+}))
 }
-
-export function internalSame_(left_, right_) {
-return left_ === right_
 }
 
-export function internalGrab_(self_, index_) {
-
-        return index_ < 0 || index_ >= self_.length ? ff_core_Try.internalThrowGrabException_() : self_[index_];
-    
+export function range_(size_) {
+return Array.from({length: size_}, ((_, i_) => {
+return i_
+}))
 }
 
 export async function new_$($task) {
-throw new Error('Function new is missing on this target in async context.');
+return []
 }
 
 export async function fill_$(size_, value_, $task) {
-throw new Error('Function fill is missing on this target in async context.');
+return (new Array(size_)).fill(value_)
 }
 
 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;
-    
-}
-
-export async function range_$(size_, $task) {
-throw new Error('Function range is missing on this target in async context.');
+if(true) {
+const array_ = (new Array(size_));
+for(let for_i = 1, for_e = size_; for_i < for_e; for_i++) {
+const i_ = for_i;
+array_[i_] = (await body_(i_, $task))
+};
+return array_
+} else {
+return Array.from({length: size_}, (async (a_1, a_2) => await (async (_, i_, $task) => {
+return (await body_(i_, $task))
+})(a_1, a_2, $task)))
 }
-
-export async function internalSame_$(left_, right_, $task) {
-throw new Error('Function internalSame is missing on this target in async context.');
 }
 
-export async function internalGrab_$(self_, index_, $task) {
-throw new Error('Function internalGrab is missing on this target in async context.');
+export async function range_$(size_, $task) {
+return Array.from({length: size_}, ((_, i_) => {
+return i_
+}))
 }
 
 export function List_addAll(self_, that_) {
@@ -166,7 +162,7 @@ return self_.concat(that_)
 }
 
 export function List_isEmpty(self_) {
-return self_.length === 0
+return (self_.length === 0)
 }
 
 export function List_size(self_) {
@@ -174,17 +170,18 @@ 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()
-        
+if(((index_ >= 0) && (index_ < self_.length))) {
+return ff_core_Option.Some(self_[index_])
+} else {
+return ff_core_Option.None()
+}
 }
 
 export function List_grab(self_, index_) {
-
-            return self_[index_] ?? internalGrab_(self_, index_);
-        
+if(((index_ < 0) || (index_ >= self_.length))) {
+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)})
+};
+return self_[index_]
 }
 
 export function List_first(self_) {
@@ -196,7 +193,7 @@ return ff_core_List.List_get(self_, (self_.length - 1))
 }
 
 export function List_grabFirst(self_) {
-return (self_[0] ?? ff_core_List.internalGrab_(self_, 0))
+return (self_[0] ?? ff_core_List.List_grab(self_, 0))
 }
 
 export function List_grabLast(self_) {
@@ -208,7 +205,7 @@ return self_.slice(0, count_)
 }
 
 export function List_takeLast(self_, count_ = 1) {
-return self_.slice(-count_)
+return self_.slice((-count_))
 }
 
 export function List_dropFirst(self_, count_ = 1) {
@@ -216,14 +213,14 @@ return self_.slice(count_)
 }
 
 export function List_dropLast(self_, count_ = 1) {
-return self_.slice(0, self_.length - count_)
+return self_.slice(0, (self_.length - count_))
 }
 
 export function List_count(self_, body_) {
 let result_ = 0;
 let i_ = 0;
 while((i_ < self_.length)) {
-if(body_((self_[i_] ?? ff_core_List.internalGrab_(self_, i_)))) {
+if(body_((self_[i_] ?? ff_core_List.List_grab(self_, i_)))) {
 result_ += 1
 };
 i_ += 1
@@ -233,7 +230,7 @@ return result_
 
 export function List_countWhile(self_, body_) {
 let i_ = 0;
-while(((i_ < self_.length) && body_((self_[i_] ?? ff_core_List.internalGrab_(self_, i_))))) {
+while(((i_ < self_.length) && body_((self_[i_] ?? ff_core_List.List_grab(self_, i_))))) {
 i_ += 1
 };
 return i_
@@ -242,8 +239,8 @@ return i_
 export function List_takeWhile(self_, body_) {
 const result_ = ff_core_Array.new_();
 let i_ = 0;
-while(((i_ < self_.length) && body_((self_[i_] ?? ff_core_List.internalGrab_(self_, i_))))) {
-result_.array.push((self_[i_] ?? ff_core_List.internalGrab_(self_, i_)));
+while(((i_ < self_.length) && body_((self_[i_] ?? ff_core_List.List_grab(self_, i_))))) {
+result_.array.push((self_[i_] ?? ff_core_List.List_grab(self_, i_)));
 i_ += 1
 };
 return ff_core_Array.Array_drain(result_)
@@ -252,11 +249,11 @@ return ff_core_Array.Array_drain(result_)
 export function List_dropWhile(self_, body_) {
 const result_ = ff_core_Array.new_();
 let i_ = 0;
-while(((i_ < self_.length) && body_((self_[i_] ?? ff_core_List.internalGrab_(self_, i_))))) {
+while(((i_ < self_.length) && body_((self_[i_] ?? ff_core_List.List_grab(self_, i_))))) {
 i_ += 1
 };
 while((i_ < self_.length)) {
-result_.array.push((self_[i_] ?? ff_core_List.internalGrab_(self_, i_)));
+result_.array.push((self_[i_] ?? ff_core_List.List_grab(self_, i_)));
 i_ += 1
 };
 return ff_core_Array.Array_drain(result_)
@@ -266,12 +263,12 @@ export function List_partitionWhile(self_, body_) {
 const first_ = ff_core_Array.new_();
 const second_ = ff_core_Array.new_();
 let i_ = 0;
-while(((i_ < self_.length) && body_((self_[i_] ?? ff_core_List.internalGrab_(self_, i_))))) {
-first_.array.push((self_[i_] ?? ff_core_List.internalGrab_(self_, i_)));
+while(((i_ < self_.length) && body_((self_[i_] ?? ff_core_List.List_grab(self_, i_))))) {
+first_.array.push((self_[i_] ?? ff_core_List.List_grab(self_, i_)));
 i_ += 1
 };
 while((i_ < self_.length)) {
-second_.array.push((self_[i_] ?? ff_core_List.internalGrab_(self_, i_)));
+second_.array.push((self_[i_] ?? ff_core_List.List_grab(self_, i_)));
 i_ += 1
 };
 return ff_core_Pair.Pair(ff_core_Array.Array_drain(first_), ff_core_Array.Array_drain(second_))
@@ -292,7 +289,7 @@ return ff_core_List.List_takeFirst(ff_core_List.List_dropFirst(self_, from_), (u
 
 export function List_foldLeft(self_, initial_, body_) {
 let result_ = initial_;
-for(let for_i = 0, for_a = self_, for_l = for_a.length; for_i < for_l; for_i++) {
+for(let for_a = self_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const x_ = for_a[for_i];
 result_ = body_(result_, x_)
 };
@@ -306,14 +303,12 @@ 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))) {
+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 result_ = self_.slice();
+result_[index_] = body_(result_[index_]);
+return result_
 }
 
 export function List_zip(self_, that_) {
@@ -321,13 +316,13 @@ if((self_.length <= that_.length)) {
 let i_ = (-1);
 return ff_core_List.List_map(self_, ((x_) => {
 i_ += 1;
-return ff_core_Pair.Pair(x_, (that_[i_] ?? ff_core_List.internalGrab_(that_, i_)))
+return ff_core_Pair.Pair(x_, (that_[i_] ?? ff_core_List.List_grab(that_, i_)))
 }))
 } else {
 let i_ = (-1);
 return ff_core_List.List_map(that_, ((y_) => {
 i_ += 1;
-return ff_core_Pair.Pair((self_[i_] ?? ff_core_List.internalGrab_(self_, i_)), y_)
+return ff_core_Pair.Pair((self_[i_] ?? ff_core_List.List_grab(self_, i_)), y_)
 }))
 }
 }
@@ -336,7 +331,7 @@ export function List_chunk(self_, chunkSize_) {
 const results_ = ff_core_Array.new_();
 const result_ = ff_core_Array.new_();
 let added_ = 0;
-for(let for_i = 0, for_a = self_, for_l = for_a.length; for_i < for_l; for_i++) {
+for(let for_a = self_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const item_ = for_a[for_i];
 if((added_ < chunkSize_)) {
 added_ += 1
@@ -357,13 +352,13 @@ let index_ = 0;
 return ff_core_Stream.new_((() => {
 if((index_ < self_.length)) {
 return ff_core_Option.Some((function() {
-const result_ = (self_[index_] ?? ff_core_List.internalGrab_(self_, index_));
+const result_ = (self_[index_] ?? ff_core_List.List_grab(self_, index_));
 index_ += 1;
 return result_
 })())
 } else if((cycle_ && (index_ !== 0))) {
 return ff_core_Option.Some((function() {
-const result_ = (self_[0] ?? ff_core_List.internalGrab_(self_, 0));
+const result_ = (self_[0] ?? ff_core_List.List_grab(self_, 0));
 index_ = 1;
 return result_
 })())
@@ -377,21 +372,39 @@ export function List_toArray(self_) {
 return {array: self_.slice()}
 }
 
+export function List_toQueue(self_) {
+const queue_ = ff_core_Queue.new_();
+for(let for_a = self_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
+const v_ = for_a[for_i];
+ff_core_Queue.Queue_push(queue_, v_)
+};
+return queue_
+}
+
 export function List_each(self_, body_) {
-
-            return self_.forEach(body_);
-        
+let i_ = 0;
+while((i_ < self_.length)) {
+body_(self_[i_]);
+i_ += 1
+}
 }
 
 export function List_eachWhile(self_, body_) {
-for(const value of self_) if(!body_(value)) break
+let i_ = 0;
+while((i_ < self_.length)) {
+if(body_(self_[i_])) {
+i_ += 1
+} else {
+i_ = self_.length
+}
+}
 }
 
 export function List_all(self_, body_) {
 let result_ = true;
-for(let for_i = 0, for_a = self_, for_l = for_a.length; for_i < for_l; for_i++) {
+for(let for_a = self_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const x_ = for_a[for_i];
-result_ = (result_ && body_(x_));
+result_ = body_(x_);
 if(!result_) break
 };
 return result_
@@ -399,40 +412,45 @@ return result_
 
 export function List_any(self_, body_) {
 let result_ = false;
-for(let for_i = 0, for_a = self_, for_l = for_a.length; for_i < for_l; for_i++) {
+for(let for_a = self_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const x_ = for_a[for_i];
-result_ = (result_ || body_(x_));
+result_ = body_(x_);
 if(!(!result_)) break
 };
 return result_
 }
 
-export function List_indexWhere(self_, body_) {
+export function List_find(self_, body_) {
 let result_ = ff_core_Option.None();
-let i_ = 0;
-for(let for_i = 0, for_a = self_, for_l = for_a.length; for_i < for_l; for_i++) {
+for(let for_a = self_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const x_ = for_a[for_i];
-if(!(body_(x_)
-? (result_ = ff_core_Option.Some(i_), false)
-: (i_ += 1, true))) break
+if(body_(x_)) {
+result_ = ff_core_Option.Some(x_);
+if(!false) break
+} else {
+if(!true) break
+}
 };
 return result_
 }
 
-export function List_find(self_, body_) {
-let result_ = ff_core_Option.None();
-for(let for_i = 0, for_a = self_, for_l = for_a.length; for_i < for_l; for_i++) {
+export function List_indexWhere(self_, body_) {
+let i_ = (-1);
+let result_ = false;
+for(let for_a = self_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const x_ = for_a[for_i];
-if(!(body_(x_)
-? (result_ = ff_core_Option.Some(x_), false)
-: true)) break
+i_ += 1;
+result_ = body_(x_);
+if(!(!result_)) break
 };
-return result_
+if(result_) {
+return ff_core_Option.Some(i_)
+} else return ff_core_Option.None()
 }
 
 export function List_filter(self_, body_) {
 const result_ = ff_core_Array.new_();
-for(let for_i = 0, for_a = self_, for_l = for_a.length; for_i < for_l; for_i++) {
+for(let for_a = self_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const x_ = for_a[for_i];
 if(body_(x_)) {
 result_.array.push(x_)
@@ -448,14 +466,17 @@ return (!body_(_w1))
 }
 
 export function List_map(self_, body_) {
-
-            return self_.map(body_)
-        
+const array_ = ff_core_Array.new_();
+for(let for_a = self_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
+const e_ = for_a[for_i];
+array_.array.push(body_(e_))
+};
+return ff_core_Array.Array_drain(array_)
 }
 
 export function List_flatMap(self_, body_) {
 const results_ = ff_core_Array.new_();
-for(let for_i = 0, for_a = self_, for_l = for_a.length; for_i < for_l; for_i++) {
+for(let for_a = self_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const x_ = for_a[for_i];
 ff_core_Array.Array_pushList(results_, body_(x_))
 };
@@ -464,12 +485,14 @@ return ff_core_Array.Array_drain(results_)
 
 export function List_collect(self_, body_) {
 let result_ = ff_core_Array.new_();
-for(let for_i = 0, for_a = self_, for_l = for_a.length; for_i < for_l; for_i++) {
+for(let for_a = self_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const x_ = for_a[for_i];
-for(const for_o = body_(x_); for_o.Some;) {
-const _w1 = for_o.value_;
+{
+const if_o = body_(x_)
+if(if_o.Some) {
+const _w1 = if_o.value_;
 result_.array.push(_w1)
-break
+}
 }
 };
 return ff_core_Array.Array_drain(result_)
@@ -477,18 +500,20 @@ return ff_core_Array.Array_drain(result_)
 
 export function List_collectFirst(self_, body_) {
 let result_ = ff_core_Option.None();
-for(let for_i = 0, for_a = self_, for_l = for_a.length; for_i < for_l; for_i++) {
+for(let for_a = self_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const x_ = for_a[for_i];
-if(!(((_1) => {
+{
+const _1 = body_(x_);
 if(_1.None) {
-return true
+if(!true) break
+continue
 }
 {
 const o_ = _1;
 result_ = o_;
-return false
+if(!false) break
+}
 }
-}))(body_(x_))) break
 };
 return result_
 }
@@ -513,38 +538,42 @@ return ff_core_List.List_grab(self_, (self_.length - i_))
 
 export function List_separate(self_, separator_) {
 const array_ = ff_core_Array.new_();
-ff_core_List.List_each(ff_core_List.List_pairs(self_), ((_1) => {
-{
-const i_ = _1.first_;
-const x_ = _1.second_;
+for(let for_a = self_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
+const i_ = for_i;
+const x_ = for_a[for_i];
 if((i_ !== 0)) {
 ff_core_Array.Array_pushList(array_, separator_)
 };
 array_.array.push(x_)
-return
-}
-}));
+};
 return ff_core_Array.Array_drain(array_)
 }
 
 export async function List_addAll$(self_, that_, $task) {
-throw new Error('Function List_addAll is missing on this target in async context.');
+return self_.concat(that_)
 }
 
 export async function List_isEmpty$(self_, $task) {
-throw new Error('Function List_isEmpty is missing on this target in async context.');
+return (self_.length === 0)
 }
 
 export async function List_size$(self_, $task) {
-throw new Error('Function List_size is missing on this target in async context.');
+return self_.length
 }
 
 export async function List_get$(self_, index_, $task) {
-throw new Error('Function List_get is missing on this target in async context.');
+if(((index_ >= 0) && (index_ < self_.length))) {
+return ff_core_Option.Some(self_[index_])
+} else {
+return ff_core_Option.None()
+}
 }
 
 export async function List_grab$(self_, index_, $task) {
-throw new Error('Function List_grab is missing on this target in async context.');
+if(((index_ < 0) || (index_ >= self_.length))) {
+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)})
+};
+return self_[index_]
 }
 
 export async function List_first$(self_, $task) {
@@ -556,7 +585,7 @@ return ff_core_List.List_get(self_, (self_.length - 1))
 }
 
 export async function List_grabFirst$(self_, $task) {
-return (self_[0] ?? ff_core_List.internalGrab_(self_, 0))
+return (self_[0] ?? ff_core_List.List_grab(self_, 0))
 }
 
 export async function List_grabLast$(self_, $task) {
@@ -564,26 +593,26 @@ return ff_core_List.List_grab(self_, (self_.length - 1))
 }
 
 export async function List_takeFirst$(self_, count_ = 1, $task) {
-throw new Error('Function List_takeFirst is missing on this target in async context.');
+return self_.slice(0, count_)
 }
 
 export async function List_takeLast$(self_, count_ = 1, $task) {
-throw new Error('Function List_takeLast is missing on this target in async context.');
+return self_.slice((-count_))
 }
 
 export async function List_dropFirst$(self_, count_ = 1, $task) {
-throw new Error('Function List_dropFirst is missing on this target in async context.');
+return self_.slice(count_)
 }
 
 export async function List_dropLast$(self_, count_ = 1, $task) {
-throw new Error('Function List_dropLast is missing on this target in async context.');
+return self_.slice(0, (self_.length - count_))
 }
 
 export async function List_count$(self_, body_, $task) {
 let result_ = 0;
 let i_ = 0;
 while((i_ < self_.length)) {
-if((await body_((self_[i_] ?? ff_core_List.internalGrab_(self_, i_)), $task))) {
+if((await body_((self_[i_] ?? ff_core_List.List_grab(self_, i_)), $task))) {
 result_ += 1
 };
 i_ += 1
@@ -593,7 +622,7 @@ return result_
 
 export async function List_countWhile$(self_, body_, $task) {
 let i_ = 0;
-while(((i_ < self_.length) && (await body_((self_[i_] ?? ff_core_List.internalGrab_(self_, i_)), $task)))) {
+while(((i_ < self_.length) && (await body_((self_[i_] ?? ff_core_List.List_grab(self_, i_)), $task)))) {
 i_ += 1
 };
 return i_
@@ -602,8 +631,8 @@ return i_
 export async function List_takeWhile$(self_, body_, $task) {
 const result_ = ff_core_Array.new_();
 let i_ = 0;
-while(((i_ < self_.length) && (await body_((self_[i_] ?? ff_core_List.internalGrab_(self_, i_)), $task)))) {
-result_.array.push((self_[i_] ?? ff_core_List.internalGrab_(self_, i_)));
+while(((i_ < self_.length) && (await body_((self_[i_] ?? ff_core_List.List_grab(self_, i_)), $task)))) {
+result_.array.push((self_[i_] ?? ff_core_List.List_grab(self_, i_)));
 i_ += 1
 };
 return ff_core_Array.Array_drain(result_)
@@ -612,11 +641,11 @@ 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_ < self_.length) && (await body_((self_[i_] ?? ff_core_List.internalGrab_(self_, i_)), $task)))) {
+while(((i_ < self_.length) && (await body_((self_[i_] ?? ff_core_List.List_grab(self_, i_)), $task)))) {
 i_ += 1
 };
 while((i_ < self_.length)) {
-result_.array.push((self_[i_] ?? ff_core_List.internalGrab_(self_, i_)));
+result_.array.push((self_[i_] ?? ff_core_List.List_grab(self_, i_)));
 i_ += 1
 };
 return ff_core_Array.Array_drain(result_)
@@ -626,12 +655,12 @@ 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_ < self_.length) && (await body_((self_[i_] ?? ff_core_List.internalGrab_(self_, i_)), $task)))) {
-first_.array.push((self_[i_] ?? ff_core_List.internalGrab_(self_, i_)));
+while(((i_ < self_.length) && (await body_((self_[i_] ?? ff_core_List.List_grab(self_, i_)), $task)))) {
+first_.array.push((self_[i_] ?? ff_core_List.List_grab(self_, i_)));
 i_ += 1
 };
 while((i_ < self_.length)) {
-second_.array.push((self_[i_] ?? ff_core_List.internalGrab_(self_, i_)));
+second_.array.push((self_[i_] ?? ff_core_List.List_grab(self_, i_)));
 i_ += 1
 };
 return ff_core_Pair.Pair(ff_core_Array.Array_drain(first_), ff_core_Array.Array_drain(second_))
@@ -652,7 +681,7 @@ return ff_core_List.List_takeFirst(ff_core_List.List_dropFirst(self_, from_), (u
 
 export async function List_foldLeft$(self_, initial_, body_, $task) {
 let result_ = initial_;
-for(let for_i = 0, for_a = self_, for_l = for_a.length; for_i < for_l; for_i++) {
+for(let for_a = self_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const x_ = for_a[for_i];
 result_ = (await body_(result_, x_, $task))
 };
@@ -666,14 +695,12 @@ 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))) {
+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 result_ = self_.slice();
+result_[index_] = (await body_(result_[index_], $task));
+return result_
 }
 
 export async function List_zip$(self_, that_, $task) {
@@ -681,13 +708,13 @@ if((self_.length <= that_.length)) {
 let i_ = (-1);
 return ff_core_List.List_map(self_, ((x_) => {
 i_ += 1;
-return ff_core_Pair.Pair(x_, (that_[i_] ?? ff_core_List.internalGrab_(that_, i_)))
+return ff_core_Pair.Pair(x_, (that_[i_] ?? ff_core_List.List_grab(that_, i_)))
 }))
 } else {
 let i_ = (-1);
 return ff_core_List.List_map(that_, ((y_) => {
 i_ += 1;
-return ff_core_Pair.Pair((self_[i_] ?? ff_core_List.internalGrab_(self_, i_)), y_)
+return ff_core_Pair.Pair((self_[i_] ?? ff_core_List.List_grab(self_, i_)), y_)
 }))
 }
 }
@@ -696,7 +723,7 @@ export async function List_chunk$(self_, chunkSize_, $task) {
 const results_ = ff_core_Array.new_();
 const result_ = ff_core_Array.new_();
 let added_ = 0;
-for(let for_i = 0, for_a = self_, for_l = for_a.length; for_i < for_l; for_i++) {
+for(let for_a = self_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const item_ = for_a[for_i];
 if((added_ < chunkSize_)) {
 added_ += 1
@@ -717,13 +744,13 @@ let index_ = 0;
 return (await ff_core_Stream.new_$((async ($task) => {
 if((index_ < self_.length)) {
 return ff_core_Option.Some((await (async function() {
-const result_ = (self_[index_] ?? ff_core_List.internalGrab_(self_, index_));
+const result_ = (self_[index_] ?? ff_core_List.List_grab(self_, index_));
 index_ += 1;
 return result_
 })()))
 } else if((cycle_ && (index_ !== 0))) {
 return ff_core_Option.Some((await (async function() {
-const result_ = (self_[0] ?? ff_core_List.internalGrab_(self_, 0));
+const result_ = (self_[0] ?? ff_core_List.List_grab(self_, 0));
 index_ = 1;
 return result_
 })()))
@@ -734,26 +761,42 @@ return result_
 }
 
 export async function List_toArray$(self_, $task) {
-throw new Error('Function List_toArray is missing on this target in async context.');
+return {array: self_.slice()}
+}
+
+export async function List_toQueue$(self_, $task) {
+const queue_ = ff_core_Queue.new_();
+for(let for_a = self_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
+const v_ = for_a[for_i];
+ff_core_Queue.Queue_push(queue_, v_)
+};
+return queue_
 }
 
 export async function List_each$(self_, body_, $task) {
-
-            for(let i = 0; i < self_.length; i++) {
-                await body_(self_[i], $task)
-            }
-        
+let i_ = 0;
+while((i_ < self_.length)) {
+(await body_(self_[i_], $task));
+i_ += 1
+}
 }
 
 export async function List_eachWhile$(self_, body_, $task) {
-for(const value of self_) if(!await body_(value, $task)) break
+let i_ = 0;
+while((i_ < self_.length)) {
+if((await body_(self_[i_], $task))) {
+i_ += 1
+} else {
+i_ = self_.length
+}
+}
 }
 
 export async function List_all$(self_, body_, $task) {
 let result_ = true;
-for(let for_i = 0, for_a = self_, for_l = for_a.length; for_i < for_l; for_i++) {
+for(let for_a = self_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const x_ = for_a[for_i];
-result_ = (result_ && (await body_(x_, $task)));
+result_ = (await body_(x_, $task));
 if(!result_) break
 };
 return result_
@@ -761,40 +804,45 @@ return result_
 
 export async function List_any$(self_, body_, $task) {
 let result_ = false;
-for(let for_i = 0, for_a = self_, for_l = for_a.length; for_i < for_l; for_i++) {
+for(let for_a = self_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const x_ = for_a[for_i];
-result_ = (result_ || (await body_(x_, $task)));
+result_ = (await body_(x_, $task));
 if(!(!result_)) break
 };
 return result_
 }
 
-export async function List_indexWhere$(self_, body_, $task) {
+export async function List_find$(self_, body_, $task) {
 let result_ = ff_core_Option.None();
-let i_ = 0;
-for(let for_i = 0, for_a = self_, for_l = for_a.length; for_i < for_l; for_i++) {
+for(let for_a = self_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const x_ = for_a[for_i];
-if(!((await body_(x_, $task))
-? (result_ = ff_core_Option.Some(i_), false)
-: (i_ += 1, true))) break
+if((await body_(x_, $task))) {
+result_ = ff_core_Option.Some(x_);
+if(!false) break
+} else {
+if(!true) break
+}
 };
 return result_
 }
 
-export async function List_find$(self_, body_, $task) {
-let result_ = ff_core_Option.None();
-for(let for_i = 0, for_a = self_, for_l = for_a.length; for_i < for_l; for_i++) {
+export async function List_indexWhere$(self_, body_, $task) {
+let i_ = (-1);
+let result_ = false;
+for(let for_a = self_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const x_ = for_a[for_i];
-if(!((await body_(x_, $task))
-? (result_ = ff_core_Option.Some(x_), false)
-: true)) break
+i_ += 1;
+result_ = (await body_(x_, $task));
+if(!(!result_)) break
 };
-return result_
+if(result_) {
+return ff_core_Option.Some(i_)
+} else return ff_core_Option.None()
 }
 
 export async function List_filter$(self_, body_, $task) {
 const result_ = ff_core_Array.new_();
-for(let for_i = 0, for_a = self_, for_l = for_a.length; for_i < for_l; for_i++) {
+for(let for_a = self_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const x_ = for_a[for_i];
 if((await body_(x_, $task))) {
 result_.array.push(x_)
@@ -810,18 +858,17 @@ 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;
-        
+const array_ = ff_core_Array.new_();
+for(let for_a = self_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
+const e_ = for_a[for_i];
+array_.array.push((await body_(e_, $task)))
+};
+return ff_core_Array.Array_drain(array_)
 }
 
 export async function List_flatMap$(self_, body_, $task) {
 const results_ = ff_core_Array.new_();
-for(let for_i = 0, for_a = self_, for_l = for_a.length; for_i < for_l; for_i++) {
+for(let for_a = self_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const x_ = for_a[for_i];
 ff_core_Array.Array_pushList(results_, (await body_(x_, $task)))
 };
@@ -830,12 +877,14 @@ return ff_core_Array.Array_drain(results_)
 
 export async function List_collect$(self_, body_, $task) {
 let result_ = ff_core_Array.new_();
-for(let for_i = 0, for_a = self_, for_l = for_a.length; for_i < for_l; for_i++) {
+for(let for_a = self_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const x_ = for_a[for_i];
-for(const for_o = (await body_(x_, $task)); for_o.Some;) {
-const _w1 = for_o.value_;
+{
+const if_o = (await body_(x_, $task))
+if(if_o.Some) {
+const _w1 = if_o.value_;
 result_.array.push(_w1)
-break
+}
 }
 };
 return ff_core_Array.Array_drain(result_)
@@ -843,18 +892,20 @@ return ff_core_Array.Array_drain(result_)
 
 export async function List_collectFirst$(self_, body_, $task) {
 let result_ = ff_core_Option.None();
-for(let for_i = 0, for_a = self_, for_l = for_a.length; for_i < for_l; for_i++) {
+for(let for_a = self_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const x_ = for_a[for_i];
-if(!(((_1) => {
+{
+const _1 = (await body_(x_, $task));
 if(_1.None) {
-return true
+if(!true) break
+continue
 }
 {
 const o_ = _1;
 result_ = o_;
-return false
+if(!false) break
+}
 }
-}))((await body_(x_, $task)))) break
 };
 return result_
 }
@@ -879,17 +930,14 @@ return ff_core_List.List_grab(self_, (self_.length - i_))
 
 export async function List_separate$(self_, separator_, $task) {
 const array_ = ff_core_Array.new_();
-ff_core_List.List_each(ff_core_List.List_pairs(self_), ((_1) => {
-{
-const i_ = _1.first_;
-const x_ = _1.second_;
+for(let for_a = self_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
+const i_ = for_i;
+const x_ = for_a[for_i];
 if((i_ !== 0)) {
 ff_core_Array.Array_pushList(array_, separator_)
 };
 array_.array.push(x_)
-return
-}
-}));
+};
 return ff_core_Array.Array_drain(array_)
 }
 
@@ -951,7 +999,7 @@ return false
 
 export function List_flatten(self_) {
 const result_ = ff_core_Array.new_();
-for(let for_i = 0, for_a = self_, for_l = for_a.length; for_i < for_l; for_i++) {
+for(let for_a = self_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const xs_ = for_a[for_i];
 ff_core_Array.Array_pushList(result_, xs_)
 };
@@ -960,7 +1008,7 @@ return ff_core_Array.Array_drain(result_)
 
 export async function List_flatten$(self_, $task) {
 const result_ = ff_core_Array.new_();
-for(let for_i = 0, for_a = self_, for_l = for_a.length; for_i < for_l; for_i++) {
+for(let for_a = self_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const xs_ = for_a[for_i];
 ff_core_Array.Array_pushList(result_, xs_)
 };
@@ -1054,14 +1102,14 @@ return self_.join(separator_)
 }
 
 export async function List_join$(self_, separator_ = "", $task) {
-throw new Error('Function List_join is missing on this target in async context.');
+return self_.join(separator_)
 }
 
 export function ff_core_Show_Show$ff_core_List_List(ff_core_Show_Show$T) { return {
 show_(value_) {
 const array_ = ff_core_Array.new_();
 array_.array.push("[");
-for(let for_i = 0, for_a = value_, for_l = for_a.length; for_i < for_l; for_i++) {
+for(let for_a = value_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const x_ = for_a[for_i];
 if((array_.array.length > 1)) {
 array_.array.push(", ")
@@ -1074,7 +1122,7 @@ return ff_core_Array.Array_join(array_, "")
 async show_$(value_, $task) {
 const array_ = ff_core_Array.new_();
 array_.array.push("[");
-for(let for_i = 0, for_a = value_, for_l = for_a.length; for_i < for_l; for_i++) {
+for(let for_a = value_, for_i = 0, for_l = for_a.length; for_i < for_l; for_i++) {
 const x_ = for_a[for_i];
 if((array_.array.length > 1)) {
 array_.array.push(", ")
@@ -1088,7 +1136,7 @@ return ff_core_Array.Array_join(array_, "")
 
 export function ff_core_Equal_Equal$ff_core_List_List(ff_core_Equal_Equal$T) { return {
 equals_(x_, y_) {
-if(ff_core_List.internalSame_(x_, y_)) {
+if((x_ === y_)) {
 return true
 } else {
 if((x_.length !== y_.length)) {
@@ -1097,13 +1145,13 @@ return false
 let i_ = (-1);
 return ff_core_List.List_all(x_, ((l_) => {
 i_ += 1;
-return ff_core_Equal_Equal$T.equals_(l_, (y_[i_] ?? ff_core_List.internalGrab_(y_, i_)))
+return ff_core_Equal_Equal$T.equals_(l_, (y_[i_] ?? ff_core_List.List_grab(y_, i_)))
 }))
 }
 }
 },
 async equals_$(x_, y_, $task) {
-if(ff_core_List.internalSame_(x_, y_)) {
+if((x_ === y_)) {
 return true
 } else {
 if((x_.length !== y_.length)) {
@@ -1112,7 +1160,7 @@ return false
 let i_ = (-1);
 return ff_core_List.List_all(x_, ((l_) => {
 i_ += 1;
-return ff_core_Equal_Equal$T.equals_(l_, (y_[i_] ?? ff_core_List.internalGrab_(y_, i_)))
+return ff_core_Equal_Equal$T.equals_(l_, (y_[i_] ?? ff_core_List.List_grab(y_, i_)))
 }))
 }
 }
@@ -1121,14 +1169,14 @@ return ff_core_Equal_Equal$T.equals_(l_, (y_[i_] ?? ff_core_List.internalGrab_(y
 
 export function ff_core_Ordering_Order$ff_core_List_List(ff_core_Ordering_Order$T) { return {
 compare_(x_, y_) {
-if(ff_core_List.internalSame_(x_, y_)) {
+if((x_ === y_)) {
 return ff_core_Ordering.OrderingSame()
 } else {
 const size_ = ff_core_Int.Int_min(x_.length, y_.length);
 let i_ = 0;
 let ordering_ = ff_core_Ordering.OrderingSame();
 while(((ordering_ === ff_core_Ordering.OrderingSame()) && (i_ < size_))) {
-ordering_ = ff_core_Ordering_Order$T.compare_((x_[i_] ?? ff_core_List.internalGrab_(x_, i_)), (y_[i_] ?? ff_core_List.internalGrab_(y_, i_)));
+ordering_ = ff_core_Ordering_Order$T.compare_((x_[i_] ?? ff_core_List.List_grab(x_, i_)), (y_[i_] ?? ff_core_List.List_grab(y_, i_)));
 i_ += 1
 };
 if((ordering_ !== ff_core_Ordering.OrderingSame())) {
@@ -1139,14 +1187,14 @@ return ff_core_Ordering.ff_core_Ordering_Order$ff_core_Int_Int.compare_(x_.lengt
 }
 },
 async compare_$(x_, y_, $task) {
-if(ff_core_List.internalSame_(x_, y_)) {
+if((x_ === y_)) {
 return ff_core_Ordering.OrderingSame()
 } else {
 const size_ = ff_core_Int.Int_min(x_.length, y_.length);
 let i_ = 0;
 let ordering_ = ff_core_Ordering.OrderingSame();
 while(((ordering_ === ff_core_Ordering.OrderingSame()) && (i_ < size_))) {
-ordering_ = ff_core_Ordering_Order$T.compare_((x_[i_] ?? ff_core_List.internalGrab_(x_, i_)), (y_[i_] ?? ff_core_List.internalGrab_(y_, i_)));
+ordering_ = ff_core_Ordering_Order$T.compare_((x_[i_] ?? ff_core_List.List_grab(x_, i_)), (y_[i_] ?? ff_core_List.List_grab(y_, i_)));
 i_ += 1
 };
 if((ordering_ !== ff_core_Ordering.OrderingSame())) {