firefly-compiler 0.4.18 → 0.4.19

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

@@ -78,8 +78,6 @@ import * as ff_core_Show from "../../ff/core/Show.mjs"
 
 import * as ff_core_SourceLocation from "../../ff/core/SourceLocation.mjs"
 
-import * as ff_core_Stack from "../../ff/core/Stack.mjs"
-
 import * as ff_core_Stream from "../../ff/core/Stream.mjs"
 
 import * as ff_core_String from "../../ff/core/String.mjs"
@@ -93,306 +91,413 @@ import * as ff_core_Try from "../../ff/core/Try.mjs"
 import * as ff_core_Unit from "../../ff/core/Unit.mjs"
 
 // type List
-const Empty$ = {Empty: true};
-export function Empty() {
-return Empty$;
-}
-export function Link(head_, tail_) {
-return {Link: true, head_, tail_};
-}
 
 
 
-export function range_(size_) {
+
+export function empty_() {
 
-        let result = ff_core_List.Empty();
-        for(let i = size_ - 1; i >= 0; i--) {
-            result = ff_core_List.Link(i, result);
-        }
-        return result;
+        return [];
     
 }
 
-export function build_(initial_, body_) {
-function go_(state_, result_) {
-_tailcall: for(;;) {
-{
-const _1 = body_(state_);
-{
-if(_1.None) {
-return ff_core_List.List_reverse(result_)
-return
-}
-}
-{
-if(_1.Some) {
-const s_ = _1.value_.first_;
-const x_ = _1.value_.second_;
-{
-const state_r_ = s_;
-const result_r_ = ff_core_List.Link(x_, result_);
-state_ = state_r_
-result_ = result_r_
-continue _tailcall
+export function fill_(size_, value_) {
+
+        return new Array(size_).fill(value_);
+    
 }
-return
+
+export function fillBy_(size_, body_) {
+
+        return Array.from({length: size_}, (_, i) => body_(i));
+    
 }
+
+export function range_(size_) {
+
+        return Array.from({length: size_}, (_, i) => i);
+    
 }
+
+export function internalSame_(left_, right_) {
+return left_ === right_
 }
-return
+
+export async function empty_$($task) {
+throw new Error('Function empty is missing on this target in async context.');
 }
+
+export async function fill_$(size_, value_, $task) {
+throw new Error('Function fill is missing on this target in async context.');
 }
-return go_(initial_, ff_core_List.Empty())
+
+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.');
 }
 
-export async function build_$(initial_, body_, $task) {
-async function go_$(state_, result_, $task) {
-_tailcall: for(;;) {
-{
-const _1 = (await body_(state_, $task));
-{
-if(_1.None) {
-return ff_core_List.List_reverse(result_)
-return
-}
-}
-{
-if(_1.Some) {
-const s_ = _1.value_.first_;
-const x_ = _1.value_.second_;
-{
-const state_r_ = s_;
-const result_r_ = ff_core_List.Link(x_, result_);
-state_ = state_r_
-result_ = result_r_
-continue _tailcall
+export async function internalSame_$(left_, right_, $task) {
+throw new Error('Function internalSame is missing on this target in async context.');
 }
-return
-}
-}
-}
-return
+
+export function List_addAll(self_, that_) {
+return self_.concat(that_)
 }
+
+export function List_isEmpty(self_) {
+return self_.length === 0
 }
-return (await go_$(initial_, ff_core_List.Empty(), $task))
+
+export function List_size(self_) {
+return self_.length
 }
 
-export function List_addAll(self_, list_) {
-return ff_core_List.List_flatten(ff_core_List.Link(self_, ff_core_List.Link(list_, ff_core_List.Empty())))
+export function List_get(self_, index_) {
+
+            return index_ >= 0 && index_ < self_.length
+                ? ff_core_Option.Some(self_[index_])
+                : ff_core_Option.None()
+        
 }
 
-export function List_toStack(self_) {
+export function List_grab(self_, index_) {
 
-            let current = self_;
-            let result = [];
-            while(current.Link) {
-                result.push(current.head_);
-                current = current.tail_;
+            if(index_ < 0 || index_ >= self_.length) {
+                ff_core_Try.internalThrowGrabException_()
             }
-            return {array: result};
+            return self_[index_]
         
 }
 
-export function List_toArray(self_) {
-return ff_core_Stack.Stack_drain(ff_core_List.List_toStack(self_))
+export function List_first(self_) {
+return ff_core_List.List_get(self_, 0)
 }
 
-export function List_grab(self_, index_) {
-function go_(list_, i_) {
-_tailcall: for(;;) {
-{
-const _1 = list_;
-{
-if(_1.Empty) {
-return ff_core_Try.internalThrowGrabException_()
-return
-}
-}
-{
-if(_1.Link) {
-const head_ = _1.head_;
-const _guard1 = (i_ === 0);
-if(_guard1) {
-return head_
-return
+export function List_last(self_) {
+return ff_core_List.List_get(self_, (ff_core_List.List_size(self_) - 1))
 }
+
+export function List_grabFirst(self_) {
+return ff_core_List.List_grab(self_, 0)
 }
+
+export function List_grabLast(self_) {
+return ff_core_List.List_grab(self_, (ff_core_List.List_size(self_) - 1))
 }
-{
-if(_1.Link) {
-const tail_ = _1.tail_;
-{
-const list_r_ = tail_;
-const i_r_ = (i_ - 1);
-list_ = list_r_
-i_ = i_r_
-continue _tailcall
+
+export function List_takeFirst(self_, count_ = 1) {
+return self_.slice(0, count_)
 }
-return
+
+export function List_takeLast(self_, count_ = 1) {
+return self_.slice(-count_)
 }
+
+export function List_dropFirst(self_, count_ = 1) {
+return self_.slice(count_)
 }
+
+export function List_dropLast(self_, count_ = 1) {
+return self_.slice(0, self_.length - count_)
 }
-return
+
+export function List_pairs(self_) {
+let i_ = 0;
+return ff_core_List.List_map(self_, ((x_) => {
+const r_ = ff_core_Pair.Pair(i_, x_);
+i_ += 1;
+return r_
+}))
 }
+
+export function List_slice(self_, from_, until_) {
+return ff_core_List.List_takeFirst(ff_core_List.List_dropFirst(self_, from_), (until_ - from_))
 }
-return go_(self_, index_)
+
+export function List_foldLeft(self_, initial_, body_) {
+let result_ = initial_;
+ff_core_List.List_each(self_, ((x_) => {
+result_ = body_(result_, x_)
+}));
+return result_
 }
 
-export function List_first(self_) {
-{
-const _1 = self_;
-{
-if(_1.Empty) {
-return ff_core_Option.None()
-return
+export function List_update(self_, index_, value_) {
+return ff_core_List.List_modify(self_, index_, ((_) => {
+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(_1.Link) {
-const head_ = _1.head_;
-return ff_core_Option.Some(head_)
-return
+
+export function List_zip(self_, that_) {
+if((ff_core_List.List_size(self_) <= ff_core_List.List_size(that_))) {
+let i_ = (-1);
+return ff_core_List.List_map(self_, ((x_) => {
+i_ += 1;
+return ff_core_Pair.Pair(x_, 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(ff_core_List.List_grab(self_, i_), y_)
+}))
 }
 }
+
+export function List_chunk(self_, chunkSize_) {
+const results_ = ff_core_Array.make_();
+const result_ = ff_core_Array.make_();
+let added_ = 0;
+ff_core_List.List_each(self_, ((item_) => {
+if((added_ < chunkSize_)) {
+added_ += 1
+} else {
+ff_core_Array.Array_push(results_, ff_core_Array.Array_drain(result_));
+added_ = 1
+};
+ff_core_Array.Array_push(result_, item_)
+}));
+if((added_ !== 0)) {
+ff_core_Array.Array_push(results_, ff_core_Array.Array_drain(result_))
+};
+return ff_core_Array.Array_drain(results_)
 }
+
+export function List_toStream(self_, cycle_ = false) {
+let index_ = 0;
+return ff_core_Stream.make_((() => {
+if((index_ < ff_core_List.List_size(self_))) {
+return ff_core_Option.Some((function() {
+const result_ = ff_core_List.List_grab(self_, index_);
+index_ += 1;
+return result_
+})())
+} else if((cycle_ && (index_ !== 0))) {
+return ff_core_Option.Some((function() {
+const result_ = ff_core_List.List_grab(self_, 0);
+index_ = 1;
+return result_
+})())
+} else return ff_core_Option.None()
+}), (() => {
+
+}))
 }
 
-export function List_last(self_) {
-_tailcall: for(;;) {
-{
-const _1 = self_;
-{
-if(_1.Empty) {
-return ff_core_Option.None()
-return
+export function List_toArray(self_) {
+return {array: self_.slice()}
 }
+
+export function List_each(self_, body_) {
+
+            return self_.forEach(body_);
+        
 }
-{
-if(_1.Link) {
-const head_ = _1.head_;
-if(_1.tail_.Empty) {
-return ff_core_Option.Some(head_)
-return
+
+export function List_eachWhile(self_, body_) {
+for(const value of self_) if(!body_(value)) break
 }
+
+export function List_all(self_, body_) {
+let result_ = true;
+ff_core_List.List_eachWhile(self_, ((x_) => {
+result_ = (result_ && body_(x_));
+return result_
+}));
+return result_
 }
+
+export function List_any(self_, body_) {
+let result_ = false;
+ff_core_List.List_eachWhile(self_, ((x_) => {
+result_ = (result_ || body_(x_));
+return (!result_)
+}));
+return result_
 }
-{
-if(_1.Link) {
-const tail_ = _1.tail_;
-{
-const self_r_ = tail_;
-self_ = self_r_
-continue _tailcall
+
+export function List_find(self_, body_) {
+let result_ = ff_core_Option.None();
+ff_core_List.List_eachWhile(self_, ((x_) => {
+if(body_(x_)) {
+result_ = ff_core_Option.Some(x_);
+return false
+} else {
+return true
 }
-return
+}));
+return result_
 }
+
+export function List_filter(self_, body_) {
+const result_ = ff_core_Array.make_();
+ff_core_List.List_each(self_, ((x_) => {
+if(body_(x_)) {
+ff_core_Array.Array_push(result_, x_)
 }
+}));
+return ff_core_Array.Array_drain(result_)
 }
-return
+
+export function List_partition(self_, body_) {
+return ff_core_Pair.Pair(ff_core_List.List_filter(self_, body_), ff_core_List.List_filter(self_, ((_w1) => {
+return (!body_(_w1))
+})))
 }
+
+export function List_map(self_, body_) {
+
+            return self_.map(body_)
+        
 }
 
-export function List_grabFirst(self_) {
-return ff_core_Option.Option_else(ff_core_List.List_first(self_), (() => {
-return ff_core_Try.internalThrowGrabException_()
-}))
+export function List_flatMap(self_, body_) {
+const results_ = ff_core_Array.make_();
+ff_core_List.List_each(self_, ((x_) => {
+ff_core_Array.Array_pushList(results_, body_(x_))
+}));
+return ff_core_Array.Array_drain(results_)
 }
 
-export function List_grabLast(self_) {
-return ff_core_Option.Option_else(ff_core_List.List_last(self_), (() => {
-return ff_core_Try.internalThrowGrabException_()
+export function List_collect(self_, body_) {
+let result_ = ff_core_Array.make_();
+ff_core_List.List_each(self_, ((x_) => {
+ff_core_Option.Option_each(body_(x_), ((_w1) => {
+ff_core_Array.Array_push(result_, _w1)
 }))
+}));
+return ff_core_Array.Array_drain(result_)
 }
 
-export function List_dropFirst(self_, count_ = 1) {
-_tailcall: for(;;) {
+export function List_collectFirst(self_, body_) {
+let result_ = ff_core_Option.None();
+ff_core_List.List_eachWhile(self_, ((x_) => {
 {
-const _1 = self_;
+const _1 = body_(x_);
 {
-const _guard1 = (count_ <= 0);
-if(_guard1) {
-return self_
+if(_1.None) {
+return true
 return
 }
 }
 {
-if(_1.Empty) {
-return self_
+const o_ = _1;
+result_ = o_;
+return false
 return
 }
 }
-{
-if(_1.Link) {
-const tail_ = _1.tail_;
-{
-const self_r_ = tail_;
-const count_r_ = (count_ - 1);
-self_ = self_r_
-count_ = count_r_
-continue _tailcall
+}));
+return result_
 }
-return
+
+export function List_sortBy(self_, body_, ff_core_Ordering_Order$S) {
+return ff_core_List.List_sortWith(self_, ((_w1, _w2) => {
+return ff_core_Ordering_Order$S.compare_(body_(_w1), body_(_w2))
+}))
 }
+
+export function List_sortWith(self_, ordering_) {
+const array_ = ff_core_List.List_toArray(self_);
+ff_core_Array.Array_sortWith(array_, ordering_);
+return ff_core_Array.Array_drain(array_)
 }
+
+export function List_reverse(self_) {
+return ff_core_List.List_map(ff_core_Int.Int_to(1, ff_core_List.List_size(self_)), ((i_) => {
+return ff_core_List.List_grab(self_, (ff_core_List.List_size(self_) - i_))
+}))
 }
+
+export function List_separate(self_, separator_) {
+const array_ = ff_core_Array.make_();
+ff_core_List.List_each(ff_core_List.List_pairs(self_), ((_1) => {
+{
+const i_ = _1.first_;
+const x_ = _1.second_;
+if((i_ !== 0)) {
+ff_core_Array.Array_pushList(array_, separator_)
+};
+ff_core_Array.Array_push(array_, x_)
 return
 }
+}));
+return ff_core_Array.Array_drain(array_)
 }
 
-export function List_dropLast(self_, count_ = 1) {
-return ff_core_List.List_reverse(ff_core_List.List_dropFirst(ff_core_List.List_reverse(self_), count_))
+export async function List_addAll$(self_, that_, $task) {
+throw new Error('Function List_addAll is missing on this target in async context.');
 }
 
-export function List_takeFirst(self_, count_ = 1) {
-function go_(list_, count_, result_) {
-_tailcall: for(;;) {
-{
-const _1 = list_;
-{
-const _guard1 = (count_ <= 0);
-if(_guard1) {
-return ff_core_List.List_reverse(result_)
-return
+export async function List_isEmpty$(self_, $task) {
+throw new Error('Function List_isEmpty is missing on this target in async context.');
 }
+
+export async function List_size$(self_, $task) {
+throw new Error('Function List_size is missing on this target in async context.');
 }
-{
-if(_1.Empty) {
-return ff_core_List.List_reverse(result_)
-return
+
+export async function List_get$(self_, index_, $task) {
+throw new Error('Function List_get is missing on this target in async context.');
 }
+
+export async function List_grab$(self_, index_, $task) {
+throw new Error('Function List_grab is missing on this target in async context.');
 }
-{
-if(_1.Link) {
-const head_ = _1.head_;
-const tail_ = _1.tail_;
-{
-const list_r_ = tail_;
-const count_r_ = (count_ - 1);
-const result_r_ = ff_core_List.Link(head_, result_);
-list_ = list_r_
-count_ = count_r_
-result_ = result_r_
-continue _tailcall
+
+export async function List_first$(self_, $task) {
+return ff_core_List.List_get(self_, 0)
 }
-return
+
+export async function List_last$(self_, $task) {
+return ff_core_List.List_get(self_, (ff_core_List.List_size(self_) - 1))
 }
+
+export async function List_grabFirst$(self_, $task) {
+return ff_core_List.List_grab(self_, 0)
 }
+
+export async function List_grabLast$(self_, $task) {
+return ff_core_List.List_grab(self_, (ff_core_List.List_size(self_) - 1))
 }
-return
+
+export async function List_takeFirst$(self_, count_ = 1, $task) {
+throw new Error('Function List_takeFirst is missing on this target in async context.');
 }
+
+export async function List_takeLast$(self_, count_ = 1, $task) {
+throw new Error('Function List_takeLast is missing on this target in async context.');
 }
-return go_(self_, count_, ff_core_List.Empty())
+
+export async function List_dropFirst$(self_, count_ = 1, $task) {
+throw new Error('Function List_dropFirst is missing on this target in async context.');
 }
 
-export function List_takeLast(self_, count_ = 1) {
-return ff_core_List.List_reverse(ff_core_List.List_takeFirst(ff_core_List.List_reverse(self_), count_))
+export async function List_dropLast$(self_, count_ = 1, $task) {
+throw new Error('Function List_dropLast is missing on this target in async context.');
 }
 
-export function List_pairs(self_) {
+export async function List_pairs$(self_, $task) {
 let i_ = 0;
 return ff_core_List.List_map(self_, ((x_) => {
 const r_ = ff_core_Pair.Pair(i_, x_);
@@ -401,1552 +506,252 @@ return r_
 }))
 }
 
-export function List_slice(self_, from_, until_) {
+export async function List_slice$(self_, from_, until_, $task) {
 return ff_core_List.List_takeFirst(ff_core_List.List_dropFirst(self_, from_), (until_ - from_))
 }
 
-export function List_isEmpty(self_) {
-{
-const _1 = self_;
-{
-if(_1.Empty) {
-return true
-return
-}
-}
-{
-return false
-return
-}
-}
-}
-
-export function List_size(self_) {
-function go_(list_, result_) {
-_tailcall: for(;;) {
-{
-const _1 = list_;
-{
-if(_1.Empty) {
-return result_
-return
-}
-}
-{
-if(_1.Link) {
-const tail_ = _1.tail_;
-{
-const list_r_ = tail_;
-const result_r_ = (result_ + 1);
-list_ = list_r_
-result_ = result_r_
-continue _tailcall
-}
-return
-}
-}
-}
-return
-}
-}
-return go_(self_, 0)
-}
-
-export function List_each(self_, body_) {
-_tailcall: for(;;) {
-{
-const _1 = self_;
-{
-if(_1.Empty) {
-
-return
-}
-}
-{
-if(_1.Link) {
-const head_ = _1.head_;
-const tail_ = _1.tail_;
-body_(head_);
-{
-const self_r_ = tail_;
-const body_r_ = body_;
-self_ = self_r_
-body_ = body_r_
-continue _tailcall
-}
-return
-}
-}
-}
-return
-}
-}
-
-export function List_eachWhile(self_, body_) {
-return ff_core_List.List_all(self_, body_)
-}
-
-export function List_all(self_, body_) {
-_tailcall: for(;;) {
-{
-const _1 = self_;
-{
-if(_1.Empty) {
-return true
-return
-}
-}
-{
-if(_1.Link) {
-const head_ = _1.head_;
-const _guard1 = (!body_(head_));
-if(_guard1) {
-return false
-return
-}
-}
-}
-{
-if(_1.Link) {
-const tail_ = _1.tail_;
-{
-const self_r_ = tail_;
-const body_r_ = body_;
-self_ = self_r_
-body_ = body_r_
-continue _tailcall
-}
-return
-}
-}
-}
-return
-}
-}
-
-export function List_any(self_, body_) {
-_tailcall: for(;;) {
-{
-const _1 = self_;
-{
-if(_1.Empty) {
-return false
-return
-}
-}
-{
-if(_1.Link) {
-const head_ = _1.head_;
-const _guard1 = body_(head_);
-if(_guard1) {
-return true
-return
-}
-}
-}
-{
-if(_1.Link) {
-const tail_ = _1.tail_;
-{
-const self_r_ = tail_;
-const body_r_ = body_;
-self_ = self_r_
-body_ = body_r_
-continue _tailcall
-}
-return
-}
-}
-}
-return
-}
-}
-
-export function List_find(self_, body_) {
-_tailcall: for(;;) {
-{
-const _1 = self_;
-{
-if(_1.Empty) {
-return ff_core_Option.None()
-return
-}
-}
-{
-if(_1.Link) {
-const head_ = _1.head_;
-const _guard1 = body_(head_);
-if(_guard1) {
-return ff_core_Option.Some(head_)
-return
-}
-}
-}
-{
-if(_1.Link) {
-const tail_ = _1.tail_;
-{
-const self_r_ = tail_;
-const body_r_ = body_;
-self_ = self_r_
-body_ = body_r_
-continue _tailcall
-}
-return
-}
-}
-}
-return
-}
-}
-
-export function List_filter(self_, body_) {
-function go_(list_, result_) {
-_tailcall: for(;;) {
-{
-const _1 = list_;
-{
-if(_1.Empty) {
-return ff_core_List.List_reverse(result_)
-return
-}
-}
-{
-if(_1.Link) {
-const head_ = _1.head_;
-const tail_ = _1.tail_;
-const _guard1 = body_(head_);
-if(_guard1) {
-{
-const list_r_ = tail_;
-const result_r_ = ff_core_List.Link(head_, result_);
-list_ = list_r_
-result_ = result_r_
-continue _tailcall
-}
-return
-}
-}
-}
-{
-if(_1.Link) {
-const tail_ = _1.tail_;
-{
-const list_r_ = tail_;
-const result_r_ = result_;
-list_ = list_r_
-result_ = result_r_
-continue _tailcall
-}
-return
-}
-}
-}
-return
-}
-}
-return go_(self_, ff_core_List.Empty())
-}
-
-export function List_partition(self_, body_) {
-return ff_core_Pair.Pair(ff_core_List.List_filter(self_, body_), ff_core_List.List_filter(self_, ((_w1) => {
-return (!body_(_w1))
-})))
-}
-
-export function List_map(self_, body_) {
-function go_(list_, result_) {
-_tailcall: for(;;) {
-{
-const _1 = list_;
-{
-if(_1.Empty) {
-return ff_core_List.List_reverse(result_)
-return
-}
-}
-{
-if(_1.Link) {
-const head_ = _1.head_;
-const tail_ = _1.tail_;
-{
-const list_r_ = tail_;
-const result_r_ = ff_core_List.Link(body_(head_), result_);
-list_ = list_r_
-result_ = result_r_
-continue _tailcall
-}
-return
-}
-}
-}
-return
-}
-}
-return go_(self_, ff_core_List.Empty())
-}
-
-export function List_flatMap(self_, body_) {
-function go_(list_, result_) {
-_tailcall: for(;;) {
-{
-const _1 = list_;
-{
-if(_1.Empty) {
-return ff_core_List.List_flatten(ff_core_List.List_reverse(result_))
-return
-}
-}
-{
-if(_1.Link) {
-const head_ = _1.head_;
-const tail_ = _1.tail_;
-{
-const list_r_ = tail_;
-const result_r_ = ff_core_List.Link(body_(head_), result_);
-list_ = list_r_
-result_ = result_r_
-continue _tailcall
-}
-return
-}
-}
-}
-return
-}
-}
-return go_(self_, ff_core_List.Empty())
-}
-
-export function List_collect(self_, body_) {
-return ff_core_Stream.Stream_toList(ff_core_Stream.Stream_collect(ff_core_List.List_toStream(self_, false), body_))
-}
-
-export function List_collectFirst(self_, body_) {
-_tailcall: for(;;) {
-{
-const _1 = self_;
-{
-if(_1.Empty) {
-return ff_core_Option.None()
-return
-}
-}
-{
-if(_1.Link) {
-const head_ = _1.head_;
-const tail_ = _1.tail_;
-{
-const _1 = body_(head_);
-{
-if(_1.None) {
-{
-const self_r_ = tail_;
-const body_r_ = body_;
-self_ = self_r_
-body_ = body_r_
-continue _tailcall
-}
-return
-}
-}
-{
-if(_1.Some) {
-const value_ = _1.value_;
-return ff_core_Option.Some(value_)
-return
-}
-}
-}
-return
-}
-}
-}
-return
-}
-}
-
-export function List_foldLeft(self_, initial_, body_) {
-function go_(state_, list_) {
-_tailcall: for(;;) {
-{
-const _1 = list_;
-{
-if(_1.Empty) {
-return state_
-return
-}
-}
-{
-if(_1.Link) {
-const head_ = _1.head_;
-const tail_ = _1.tail_;
-{
-const state_r_ = body_(state_, head_);
-const list_r_ = tail_;
-state_ = state_r_
-list_ = list_r_
-continue _tailcall
-}
-return
-}
-}
-}
-return
-}
-}
-return go_(initial_, self_)
-}
-
-export function List_update(self_, index_, value_) {
-function go_(list_, i_, result_) {
-_tailcall: for(;;) {
-{
-const _1 = list_;
-{
-if(_1.Empty) {
-return ff_core_List.List_reverse(result_)
-return
-}
-}
-{
-if(_1.Link) {
-const head_ = _1.head_;
-const tail_ = _1.tail_;
-const _guard1 = (i_ === 0);
-if(_guard1) {
-{
-const list_r_ = tail_;
-const i_r_ = (i_ - 1);
-const result_r_ = ff_core_List.Link(value_, result_);
-list_ = list_r_
-i_ = i_r_
-result_ = result_r_
-continue _tailcall
-}
-return
-}
-}
-}
-{
-if(_1.Link) {
-const head_ = _1.head_;
-const tail_ = _1.tail_;
-{
-const list_r_ = tail_;
-const i_r_ = (i_ - 1);
-const result_r_ = ff_core_List.Link(head_, result_);
-list_ = list_r_
-i_ = i_r_
-result_ = result_r_
-continue _tailcall
-}
-return
-}
-}
-}
-return
-}
-}
-return go_(self_, index_, ff_core_List.Empty())
-}
-
-export function List_modify(self_, index_, body_) {
-function go_(list_, i_, result_) {
-_tailcall: for(;;) {
-{
-const _1 = list_;
-{
-if(_1.Empty) {
-return ff_core_List.List_reverse(result_)
-return
-}
-}
-{
-if(_1.Link) {
-const head_ = _1.head_;
-const tail_ = _1.tail_;
-const _guard1 = (i_ === 0);
-if(_guard1) {
-{
-const list_r_ = tail_;
-const i_r_ = (i_ - 1);
-const result_r_ = ff_core_List.Link(body_(head_), result_);
-list_ = list_r_
-i_ = i_r_
-result_ = result_r_
-continue _tailcall
-}
-return
-}
-}
-}
-{
-if(_1.Link) {
-const head_ = _1.head_;
-const tail_ = _1.tail_;
-{
-const list_r_ = tail_;
-const i_r_ = (i_ - 1);
-const result_r_ = ff_core_List.Link(head_, result_);
-list_ = list_r_
-i_ = i_r_
-result_ = result_r_
-continue _tailcall
-}
-return
-}
-}
-}
-return
-}
-}
-return go_(self_, index_, ff_core_List.Empty())
-}
-
-export function List_zip(self_, that_) {
-function go_(list1_, list2_, result_) {
-_tailcall: for(;;) {
-{
-const _1 = ff_core_Pair.Pair(list1_, list2_);
-{
-if(_1.first_.Link) {
-const x_ = _1.first_.head_;
-const xs_ = _1.first_.tail_;
-if(_1.second_.Link) {
-const y_ = _1.second_.head_;
-const ys_ = _1.second_.tail_;
-{
-const list1_r_ = xs_;
-const list2_r_ = ys_;
-const result_r_ = ff_core_List.Link(ff_core_Pair.Pair(x_, y_), result_);
-list1_ = list1_r_
-list2_ = list2_r_
-result_ = result_r_
-continue _tailcall
-}
-return
-}
-}
-}
-{
-return ff_core_List.List_reverse(result_)
-return
-}
-}
-return
-}
-}
-return go_(self_, that_, ff_core_List.Empty())
-}
-
-export function List_sortBy(self_, body_, ff_core_Ordering_Order$O) {
-if((ff_core_List.List_size(self_) <= 1)) {
-return self_
-} else {
-const stack_ = ff_core_List.List_toStack(self_);
-ff_core_Stack.Stack_sortBy(stack_, body_, ff_core_Ordering_Order$O);
-return ff_core_Stack.Stack_toList(stack_, 0, 9007199254740991)
-}
-}
-
-export function List_sortWith(self_, compare_) {
-if((ff_core_List.List_size(self_) <= 1)) {
-return self_
-} else {
-const stack_ = ff_core_List.List_toStack(self_);
-ff_core_Stack.Stack_sortWith(stack_, compare_);
-return ff_core_Stack.Stack_toList(stack_, 0, 9007199254740991)
-}
-}
-
-export function List_reverse(self_) {
-function go_(list_, result_) {
-_tailcall: for(;;) {
-{
-const _1 = list_;
-{
-if(_1.Empty) {
-return result_
-return
-}
-}
-{
-if(_1.Link) {
-const head_ = _1.head_;
-const tail_ = _1.tail_;
-{
-const list_r_ = tail_;
-const result_r_ = ff_core_List.Link(head_, result_);
-list_ = list_r_
-result_ = result_r_
-continue _tailcall
-}
-return
-}
-}
-}
-return
-}
-}
-return go_(self_, ff_core_List.Empty())
-}
-
-export function List_chunk(self_, chunkSize_) {
-let results_ = ff_core_List.Empty();
-let result_ = ff_core_List.Empty();
-let added_ = 0;
-ff_core_List.List_each(self_, ((item_) => {
-if((added_ < chunkSize_)) {
-result_ = ff_core_List.Link(item_, result_);
-added_ += 1
-} else {
-results_ = ff_core_List.Link(ff_core_List.List_reverse(result_), results_);
-result_ = ff_core_List.Link(item_, ff_core_List.Empty());
-added_ = 1
-}
-}));
-if((added_ !== 0)) {
-results_ = ff_core_List.Link(ff_core_List.List_reverse(result_), results_)
-};
-return ff_core_List.List_reverse(results_)
-}
-
-export function List_toStream(self_, cycle_ = false) {
-let remaining_ = self_;
-return ff_core_Stream.Stream((() => {
-{
-const _1 = remaining_;
-{
-if(_1.Link) {
-const head_ = _1.head_;
-const tail_ = _1.tail_;
-remaining_ = tail_;
-return ff_core_Option.Some(head_)
-return
-}
-}
-{
-if(_1.Empty) {
-const _guard2 = self_;
-if(_guard2.Link) {
-const head_ = _guard2.head_;
-const tail_ = _guard2.tail_;
-const _guard1 = cycle_;
-if(_guard1) {
-remaining_ = tail_;
-return ff_core_Option.Some(head_)
-return
-}
-}
-}
-}
-{
-if(_1.Empty) {
-return ff_core_Option.None()
-return
-}
-}
-}
-}), (() => {
-remaining_ = ff_core_List.Empty()
-}))
-}
-
-export function List_separate(self_, separator_) {
-return ff_core_List.List_dropFirst(ff_core_List.List_flatMap(self_, ((e_) => {
-return ff_core_List.List_addAll(separator_, ff_core_List.Link(e_, ff_core_List.Empty()))
-})), ff_core_List.List_size(separator_))
-}
-
-export async function List_addAll$(self_, list_, $task) {
-return ff_core_List.List_flatten(ff_core_List.Link(self_, ff_core_List.Link(list_, ff_core_List.Empty())))
-}
-
-export async function List_toStack$(self_, $task) {
-throw new Error('Function List_toStack is missing on this target in async context.');
-}
-
-export async function List_toArray$(self_, $task) {
-return ff_core_Stack.Stack_drain(ff_core_List.List_toStack(self_))
-}
-
-export async function List_grab$(self_, index_, $task) {
-function go_(list_, i_) {
-_tailcall: for(;;) {
-{
-const _1 = list_;
-{
-if(_1.Empty) {
-return ff_core_Try.internalThrowGrabException_()
-return
-}
-}
-{
-if(_1.Link) {
-const head_ = _1.head_;
-const _guard1 = (i_ === 0);
-if(_guard1) {
-return head_
-return
-}
-}
-}
-{
-if(_1.Link) {
-const tail_ = _1.tail_;
-{
-const list_r_ = tail_;
-const i_r_ = (i_ - 1);
-list_ = list_r_
-i_ = i_r_
-continue _tailcall
-}
-return
-}
-}
-}
-return
-}
-}
-return go_(self_, index_)
-}
-
-export async function List_first$(self_, $task) {
-{
-const _1 = self_;
-{
-if(_1.Empty) {
-return ff_core_Option.None()
-return
-}
-}
-{
-if(_1.Link) {
-const head_ = _1.head_;
-return ff_core_Option.Some(head_)
-return
-}
-}
-}
-}
-
-export async function List_last$(self_, $task) {
-_tailcall: for(;;) {
-{
-const _1 = self_;
-{
-if(_1.Empty) {
-return ff_core_Option.None()
-return
-}
-}
-{
-if(_1.Link) {
-const head_ = _1.head_;
-if(_1.tail_.Empty) {
-return ff_core_Option.Some(head_)
-return
-}
-}
-}
-{
-if(_1.Link) {
-const tail_ = _1.tail_;
-{
-const self_r_ = tail_;
-self_ = self_r_
-continue _tailcall
-}
-return
-}
-}
-}
-return
-}
-}
-
-export async function List_grabFirst$(self_, $task) {
-return ff_core_Option.Option_else(ff_core_List.List_first(self_), (() => {
-return ff_core_Try.internalThrowGrabException_()
-}))
-}
-
-export async function List_grabLast$(self_, $task) {
-return ff_core_Option.Option_else(ff_core_List.List_last(self_), (() => {
-return ff_core_Try.internalThrowGrabException_()
-}))
-}
-
-export async function List_dropFirst$(self_, count_ = 1, $task) {
-_tailcall: for(;;) {
-{
-const _1 = self_;
-{
-const _guard1 = (count_ <= 0);
-if(_guard1) {
-return self_
-return
-}
-}
-{
-if(_1.Empty) {
-return self_
-return
-}
-}
-{
-if(_1.Link) {
-const tail_ = _1.tail_;
-{
-const self_r_ = tail_;
-const count_r_ = (count_ - 1);
-self_ = self_r_
-count_ = count_r_
-continue _tailcall
-}
-return
-}
-}
-}
-return
-}
-}
-
-export async function List_dropLast$(self_, count_ = 1, $task) {
-return ff_core_List.List_reverse(ff_core_List.List_dropFirst(ff_core_List.List_reverse(self_), count_))
-}
-
-export async function List_takeFirst$(self_, count_ = 1, $task) {
-function go_(list_, count_, result_) {
-_tailcall: for(;;) {
-{
-const _1 = list_;
-{
-const _guard1 = (count_ <= 0);
-if(_guard1) {
-return ff_core_List.List_reverse(result_)
-return
-}
-}
-{
-if(_1.Empty) {
-return ff_core_List.List_reverse(result_)
-return
-}
-}
-{
-if(_1.Link) {
-const head_ = _1.head_;
-const tail_ = _1.tail_;
-{
-const list_r_ = tail_;
-const count_r_ = (count_ - 1);
-const result_r_ = ff_core_List.Link(head_, result_);
-list_ = list_r_
-count_ = count_r_
-result_ = result_r_
-continue _tailcall
-}
-return
-}
-}
-}
-return
-}
-}
-return go_(self_, count_, ff_core_List.Empty())
-}
-
-export async function List_takeLast$(self_, count_ = 1, $task) {
-return ff_core_List.List_reverse(ff_core_List.List_takeFirst(ff_core_List.List_reverse(self_), count_))
-}
-
-export async function List_pairs$(self_, $task) {
-let i_ = 0;
-return ff_core_List.List_map(self_, ((x_) => {
-const r_ = ff_core_Pair.Pair(i_, x_);
-i_ += 1;
-return r_
-}))
-}
-
-export async function List_slice$(self_, from_, until_, $task) {
-return ff_core_List.List_takeFirst(ff_core_List.List_dropFirst(self_, from_), (until_ - from_))
-}
-
-export async function List_isEmpty$(self_, $task) {
-{
-const _1 = self_;
-{
-if(_1.Empty) {
-return true
-return
-}
-}
-{
-return false
-return
-}
-}
-}
-
-export async function List_size$(self_, $task) {
-function go_(list_, result_) {
-_tailcall: for(;;) {
-{
-const _1 = list_;
-{
-if(_1.Empty) {
-return result_
-return
-}
-}
-{
-if(_1.Link) {
-const tail_ = _1.tail_;
-{
-const list_r_ = tail_;
-const result_r_ = (result_ + 1);
-list_ = list_r_
-result_ = result_r_
-continue _tailcall
-}
-return
-}
-}
-}
-return
-}
-}
-return go_(self_, 0)
-}
-
-export async function List_each$(self_, body_, $task) {
-_tailcall: for(;;) {
-{
-const _1 = self_;
-{
-if(_1.Empty) {
-
-return
-}
-}
-{
-if(_1.Link) {
-const head_ = _1.head_;
-const tail_ = _1.tail_;
-(await body_(head_, $task));
-{
-const self_r_ = tail_;
-const body_r_ = body_;
-self_ = self_r_
-body_ = body_r_
-continue _tailcall
-}
-return
-}
-}
-}
-return
-}
-}
-
-export async function List_eachWhile$(self_, body_, $task) {
-return (await ff_core_List.List_all$(self_, body_, $task))
-}
-
-export async function List_all$(self_, body_, $task) {
-_tailcall: for(;;) {
-{
-const _1 = self_;
-{
-if(_1.Empty) {
-return true
-return
-}
-}
-{
-if(_1.Link) {
-const head_ = _1.head_;
-const _guard1 = (!(await body_(head_, $task)));
-if(_guard1) {
-return false
-return
-}
-}
-}
-{
-if(_1.Link) {
-const tail_ = _1.tail_;
-{
-const self_r_ = tail_;
-const body_r_ = body_;
-self_ = self_r_
-body_ = body_r_
-continue _tailcall
-}
-return
-}
-}
-}
-return
-}
-}
-
-export async function List_any$(self_, body_, $task) {
-_tailcall: for(;;) {
-{
-const _1 = self_;
-{
-if(_1.Empty) {
-return false
-return
-}
-}
-{
-if(_1.Link) {
-const head_ = _1.head_;
-const _guard1 = (await body_(head_, $task));
-if(_guard1) {
-return true
-return
-}
-}
-}
-{
-if(_1.Link) {
-const tail_ = _1.tail_;
-{
-const self_r_ = tail_;
-const body_r_ = body_;
-self_ = self_r_
-body_ = body_r_
-continue _tailcall
-}
-return
-}
-}
-}
-return
-}
-}
-
-export async function List_find$(self_, body_, $task) {
-_tailcall: for(;;) {
-{
-const _1 = self_;
-{
-if(_1.Empty) {
-return ff_core_Option.None()
-return
-}
-}
-{
-if(_1.Link) {
-const head_ = _1.head_;
-const _guard1 = (await body_(head_, $task));
-if(_guard1) {
-return ff_core_Option.Some(head_)
-return
-}
-}
-}
-{
-if(_1.Link) {
-const tail_ = _1.tail_;
-{
-const self_r_ = tail_;
-const body_r_ = body_;
-self_ = self_r_
-body_ = body_r_
-continue _tailcall
-}
-return
-}
-}
-}
-return
-}
-}
-
-export async function List_filter$(self_, body_, $task) {
-async function go_$(list_, result_, $task) {
-_tailcall: for(;;) {
-{
-const _1 = list_;
-{
-if(_1.Empty) {
-return ff_core_List.List_reverse(result_)
-return
-}
-}
-{
-if(_1.Link) {
-const head_ = _1.head_;
-const tail_ = _1.tail_;
-const _guard1 = (await body_(head_, $task));
-if(_guard1) {
-{
-const list_r_ = tail_;
-const result_r_ = ff_core_List.Link(head_, result_);
-list_ = list_r_
-result_ = result_r_
-continue _tailcall
-}
-return
-}
-}
-}
-{
-if(_1.Link) {
-const tail_ = _1.tail_;
-{
-const list_r_ = tail_;
-const result_r_ = result_;
-list_ = list_r_
-result_ = result_r_
-continue _tailcall
-}
-return
-}
-}
-}
-return
-}
-}
-return (await go_$(self_, ff_core_List.Empty(), $task))
-}
-
-export async function List_partition$(self_, body_, $task) {
-return ff_core_Pair.Pair((await ff_core_List.List_filter$(self_, body_, $task)), (await ff_core_List.List_filter$(self_, (async (_w1, $task) => {
-return (!(await body_(_w1, $task)))
-}), $task)))
-}
-
-export async function List_map$(self_, body_, $task) {
-async function go_$(list_, result_, $task) {
-_tailcall: for(;;) {
-{
-const _1 = list_;
-{
-if(_1.Empty) {
-return ff_core_List.List_reverse(result_)
-return
-}
-}
-{
-if(_1.Link) {
-const head_ = _1.head_;
-const tail_ = _1.tail_;
-{
-const list_r_ = tail_;
-const result_r_ = ff_core_List.Link((await body_(head_, $task)), result_);
-list_ = list_r_
-result_ = result_r_
-continue _tailcall
-}
-return
-}
-}
-}
-return
-}
-}
-return (await go_$(self_, ff_core_List.Empty(), $task))
+export async function List_foldLeft$(self_, initial_, body_, $task) {
+let result_ = initial_;
+(await ff_core_List.List_each$(self_, (async (x_, $task) => {
+result_ = (await body_(result_, x_, $task))
+}), $task));
+return result_
 }
 
-export async function List_flatMap$(self_, body_, $task) {
-async function go_$(list_, result_, $task) {
-_tailcall: for(;;) {
-{
-const _1 = list_;
-{
-if(_1.Empty) {
-return ff_core_List.List_flatten(ff_core_List.List_reverse(result_))
-return
-}
-}
-{
-if(_1.Link) {
-const head_ = _1.head_;
-const tail_ = _1.tail_;
-{
-const list_r_ = tail_;
-const result_r_ = ff_core_List.Link((await body_(head_, $task)), result_);
-list_ = list_r_
-result_ = result_r_
-continue _tailcall
-}
-return
-}
-}
-}
-return
-}
-}
-return (await go_$(self_, ff_core_List.Empty(), $task))
+export async function List_update$(self_, index_, value_, $task) {
+return ff_core_List.List_modify(self_, index_, ((_) => {
+return value_
+}))
 }
 
-export async function List_collect$(self_, body_, $task) {
-return (await ff_core_Stream.Stream_toList$((await ff_core_Stream.Stream_collect$((await ff_core_List.List_toStream$(self_, false, $task)), body_, $task)), $task))
+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;
+        
 }
 
-export async function List_collectFirst$(self_, body_, $task) {
-_tailcall: for(;;) {
-{
-const _1 = self_;
-{
-if(_1.Empty) {
-return ff_core_Option.None()
-return
-}
-}
-{
-if(_1.Link) {
-const head_ = _1.head_;
-const tail_ = _1.tail_;
-{
-const _1 = (await body_(head_, $task));
-{
-if(_1.None) {
-{
-const self_r_ = tail_;
-const body_r_ = body_;
-self_ = self_r_
-body_ = body_r_
-continue _tailcall
-}
-return
-}
-}
-{
-if(_1.Some) {
-const value_ = _1.value_;
-return ff_core_Option.Some(value_)
-return
-}
-}
-}
-return
-}
-}
-}
-return
+export async function List_zip$(self_, that_, $task) {
+if((ff_core_List.List_size(self_) <= ff_core_List.List_size(that_))) {
+let i_ = (-1);
+return ff_core_List.List_map(self_, ((x_) => {
+i_ += 1;
+return ff_core_Pair.Pair(x_, 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(ff_core_List.List_grab(self_, i_), y_)
+}))
 }
 }
 
-export async function List_foldLeft$(self_, initial_, body_, $task) {
-async function go_$(state_, list_, $task) {
-_tailcall: for(;;) {
-{
-const _1 = list_;
-{
-if(_1.Empty) {
-return state_
-return
-}
-}
-{
-if(_1.Link) {
-const head_ = _1.head_;
-const tail_ = _1.tail_;
-{
-const state_r_ = (await body_(state_, head_, $task));
-const list_r_ = tail_;
-state_ = state_r_
-list_ = list_r_
-continue _tailcall
-}
-return
-}
-}
-}
-return
-}
-}
-return (await go_$(initial_, self_, $task))
+export async function List_chunk$(self_, chunkSize_, $task) {
+const results_ = ff_core_Array.make_();
+const result_ = ff_core_Array.make_();
+let added_ = 0;
+ff_core_List.List_each(self_, ((item_) => {
+if((added_ < chunkSize_)) {
+added_ += 1
+} else {
+ff_core_Array.Array_push(results_, ff_core_Array.Array_drain(result_));
+added_ = 1
+};
+ff_core_Array.Array_push(result_, item_)
+}));
+if((added_ !== 0)) {
+ff_core_Array.Array_push(results_, ff_core_Array.Array_drain(result_))
+};
+return ff_core_Array.Array_drain(results_)
 }
 
-export async function List_update$(self_, index_, value_, $task) {
-function go_(list_, i_, result_) {
-_tailcall: for(;;) {
-{
-const _1 = list_;
-{
-if(_1.Empty) {
-return ff_core_List.List_reverse(result_)
-return
-}
-}
-{
-if(_1.Link) {
-const head_ = _1.head_;
-const tail_ = _1.tail_;
-const _guard1 = (i_ === 0);
-if(_guard1) {
-{
-const list_r_ = tail_;
-const i_r_ = (i_ - 1);
-const result_r_ = ff_core_List.Link(value_, result_);
-list_ = list_r_
-i_ = i_r_
-result_ = result_r_
-continue _tailcall
-}
-return
-}
-}
-}
-{
-if(_1.Link) {
-const head_ = _1.head_;
-const tail_ = _1.tail_;
-{
-const list_r_ = tail_;
-const i_r_ = (i_ - 1);
-const result_r_ = ff_core_List.Link(head_, result_);
-list_ = list_r_
-i_ = i_r_
-result_ = result_r_
-continue _tailcall
-}
-return
-}
-}
-}
-return
-}
-}
-return go_(self_, index_, ff_core_List.Empty())
-}
+export async function List_toStream$(self_, cycle_ = false, $task) {
+let index_ = 0;
+return (await ff_core_Stream.make_$((async ($task) => {
+if((index_ < ff_core_List.List_size(self_))) {
+return ff_core_Option.Some((await (async function() {
+const result_ = 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_ = ff_core_List.List_grab(self_, 0);
+index_ = 1;
+return result_
+})()))
+} else return ff_core_Option.None()
+}), (async ($task) => {
 
-export async function List_modify$(self_, index_, body_, $task) {
-async function go_$(list_, i_, result_, $task) {
-_tailcall: for(;;) {
-{
-const _1 = list_;
-{
-if(_1.Empty) {
-return ff_core_List.List_reverse(result_)
-return
-}
-}
-{
-if(_1.Link) {
-const head_ = _1.head_;
-const tail_ = _1.tail_;
-const _guard1 = (i_ === 0);
-if(_guard1) {
-{
-const list_r_ = tail_;
-const i_r_ = (i_ - 1);
-const result_r_ = ff_core_List.Link((await body_(head_, $task)), result_);
-list_ = list_r_
-i_ = i_r_
-result_ = result_r_
-continue _tailcall
-}
-return
-}
-}
-}
-{
-if(_1.Link) {
-const head_ = _1.head_;
-const tail_ = _1.tail_;
-{
-const list_r_ = tail_;
-const i_r_ = (i_ - 1);
-const result_r_ = ff_core_List.Link(head_, result_);
-list_ = list_r_
-i_ = i_r_
-result_ = result_r_
-continue _tailcall
-}
-return
-}
-}
-}
-return
-}
-}
-return (await go_$(self_, index_, ff_core_List.Empty(), $task))
+}), $task))
 }
 
-export async function List_zip$(self_, that_, $task) {
-function go_(list1_, list2_, result_) {
-_tailcall: for(;;) {
-{
-const _1 = ff_core_Pair.Pair(list1_, list2_);
-{
-if(_1.first_.Link) {
-const x_ = _1.first_.head_;
-const xs_ = _1.first_.tail_;
-if(_1.second_.Link) {
-const y_ = _1.second_.head_;
-const ys_ = _1.second_.tail_;
-{
-const list1_r_ = xs_;
-const list2_r_ = ys_;
-const result_r_ = ff_core_List.Link(ff_core_Pair.Pair(x_, y_), result_);
-list1_ = list1_r_
-list2_ = list2_r_
-result_ = result_r_
-continue _tailcall
-}
-return
-}
-}
-}
-{
-return ff_core_List.List_reverse(result_)
-return
-}
-}
-return
-}
-}
-return go_(self_, that_, ff_core_List.Empty())
+export async function List_toArray$(self_, $task) {
+throw new Error('Function List_toArray is missing on this target in async context.');
 }
 
-export async function List_sortBy$(self_, body_, ff_core_Ordering_Order$O, $task) {
-if((ff_core_List.List_size(self_) <= 1)) {
-return self_
-} else {
-const stack_ = ff_core_List.List_toStack(self_);
-(await ff_core_Stack.Stack_sortBy$(stack_, body_, ff_core_Ordering_Order$O, $task));
-return ff_core_Stack.Stack_toList(stack_, 0, 9007199254740991)
-}
+export async function List_each$(self_, body_, $task) {
+
+            for(let i = 0; i < self_.length; i++) {
+                await body_(self_[i], $task)
+            }
+        
 }
 
-export async function List_sortWith$(self_, compare_, $task) {
-if((ff_core_List.List_size(self_) <= 1)) {
-return self_
-} else {
-const stack_ = ff_core_List.List_toStack(self_);
-(await ff_core_Stack.Stack_sortWith$(stack_, compare_, $task));
-return ff_core_Stack.Stack_toList(stack_, 0, 9007199254740991)
-}
+export async function List_eachWhile$(self_, body_, $task) {
+for(const value of self_) if(!await body_(value, $task)) break
 }
 
-export async function List_reverse$(self_, $task) {
-function go_(list_, result_) {
-_tailcall: for(;;) {
-{
-const _1 = list_;
-{
-if(_1.Empty) {
+export async function List_all$(self_, body_, $task) {
+let result_ = true;
+(await ff_core_List.List_eachWhile$(self_, (async (x_, $task) => {
+result_ = (result_ && (await body_(x_, $task)));
+return result_
+}), $task));
 return result_
-return
-}
 }
-{
-if(_1.Link) {
-const head_ = _1.head_;
-const tail_ = _1.tail_;
-{
-const list_r_ = tail_;
-const result_r_ = ff_core_List.Link(head_, result_);
-list_ = list_r_
-result_ = result_r_
-continue _tailcall
+
+export async function List_any$(self_, body_, $task) {
+let result_ = false;
+(await ff_core_List.List_eachWhile$(self_, (async (x_, $task) => {
+result_ = (result_ || (await body_(x_, $task)));
+return (!result_)
+}), $task));
+return result_
 }
-return
+
+export async function List_find$(self_, body_, $task) {
+let result_ = ff_core_Option.None();
+(await ff_core_List.List_eachWhile$(self_, (async (x_, $task) => {
+if((await body_(x_, $task))) {
+result_ = ff_core_Option.Some(x_);
+return false
+} else {
+return true
 }
+}), $task));
+return result_
 }
+
+export async function List_filter$(self_, body_, $task) {
+const result_ = ff_core_Array.make_();
+(await ff_core_List.List_each$(self_, (async (x_, $task) => {
+if((await body_(x_, $task))) {
+ff_core_Array.Array_push(result_, x_)
 }
-return
+}), $task));
+return ff_core_Array.Array_drain(result_)
 }
+
+export async function List_partition$(self_, body_, $task) {
+return ff_core_Pair.Pair((await ff_core_List.List_filter$(self_, body_, $task)), (await ff_core_List.List_filter$(self_, (async (_w1, $task) => {
+return (!(await body_(_w1, $task)))
+}), $task)))
 }
-return go_(self_, ff_core_List.Empty())
+
+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;
+        
 }
 
-export async function List_chunk$(self_, chunkSize_, $task) {
-let results_ = ff_core_List.Empty();
-let result_ = ff_core_List.Empty();
-let added_ = 0;
-ff_core_List.List_each(self_, ((item_) => {
-if((added_ < chunkSize_)) {
-result_ = ff_core_List.Link(item_, result_);
-added_ += 1
-} else {
-results_ = ff_core_List.Link(ff_core_List.List_reverse(result_), results_);
-result_ = ff_core_List.Link(item_, ff_core_List.Empty());
-added_ = 1
+export async function List_flatMap$(self_, body_, $task) {
+const results_ = ff_core_Array.make_();
+(await ff_core_List.List_each$(self_, (async (x_, $task) => {
+ff_core_Array.Array_pushList(results_, (await body_(x_, $task)))
+}), $task));
+return ff_core_Array.Array_drain(results_)
 }
-}));
-if((added_ !== 0)) {
-results_ = ff_core_List.Link(ff_core_List.List_reverse(result_), results_)
-};
-return ff_core_List.List_reverse(results_)
+
+export async function List_collect$(self_, body_, $task) {
+let result_ = ff_core_Array.make_();
+(await ff_core_List.List_each$(self_, (async (x_, $task) => {
+ff_core_Option.Option_each((await body_(x_, $task)), ((_w1) => {
+ff_core_Array.Array_push(result_, _w1)
+}))
+}), $task));
+return ff_core_Array.Array_drain(result_)
 }
 
-export async function List_toStream$(self_, cycle_ = false, $task) {
-let remaining_ = self_;
-return ff_core_Stream.Stream((async ($task) => {
+export async function List_collectFirst$(self_, body_, $task) {
+let result_ = ff_core_Option.None();
+(await ff_core_List.List_eachWhile$(self_, (async (x_, $task) => {
 {
-const _1 = remaining_;
+const _1 = (await body_(x_, $task));
 {
-if(_1.Link) {
-const head_ = _1.head_;
-const tail_ = _1.tail_;
-remaining_ = tail_;
-return ff_core_Option.Some(head_)
+if(_1.None) {
+return true
 return
 }
 }
 {
-if(_1.Empty) {
-const _guard2 = self_;
-if(_guard2.Link) {
-const head_ = _guard2.head_;
-const tail_ = _guard2.tail_;
-const _guard1 = cycle_;
-if(_guard1) {
-remaining_ = tail_;
-return ff_core_Option.Some(head_)
+const o_ = _1;
+result_ = o_;
+return false
 return
 }
 }
+}), $task));
+return result_
 }
+
+export async function List_sortBy$(self_, body_, ff_core_Ordering_Order$S, $task) {
+return (await ff_core_List.List_sortWith$(self_, (async (_w1, _w2, $task) => {
+return ff_core_Ordering_Order$S.compare_((await body_(_w1, $task)), (await body_(_w2, $task)))
+}), $task))
 }
-{
-if(_1.Empty) {
-return ff_core_Option.None()
-return
-}
-}
+
+export async function List_sortWith$(self_, ordering_, $task) {
+const array_ = ff_core_List.List_toArray(self_);
+(await ff_core_Array.Array_sortWith$(array_, ordering_, $task));
+return ff_core_Array.Array_drain(array_)
 }
-}), (async ($task) => {
-remaining_ = ff_core_List.Empty()
+
+export async function List_reverse$(self_, $task) {
+return ff_core_List.List_map(ff_core_Int.Int_to(1, ff_core_List.List_size(self_)), ((i_) => {
+return ff_core_List.List_grab(self_, (ff_core_List.List_size(self_) - i_))
 }))
 }
 
 export async function List_separate$(self_, separator_, $task) {
-return ff_core_List.List_dropFirst(ff_core_List.List_flatMap(self_, ((e_) => {
-return ff_core_List.List_addAll(separator_, ff_core_List.Link(e_, ff_core_List.Empty()))
-})), ff_core_List.List_size(separator_))
+const array_ = ff_core_Array.make_();
+ff_core_List.List_each(ff_core_List.List_pairs(self_), ((_1) => {
+{
+const i_ = _1.first_;
+const x_ = _1.second_;
+if((i_ !== 0)) {
+ff_core_Array.Array_pushList(array_, separator_)
+};
+ff_core_Array.Array_push(array_, x_)
+return
+}
+}));
+return ff_core_Array.Array_drain(array_)
 }
 
 export function List_sort(self_, ff_core_Ordering_Order$T) {
-if((ff_core_List.List_size(self_) <= 1)) {
-return self_
-} else {
-const stack_ = ff_core_List.List_toStack(self_);
-ff_core_Stack.Stack_sort(stack_, ff_core_Ordering_Order$T);
-return ff_core_Stack.Stack_toList(stack_, 0, 9007199254740991)
-}
+return ff_core_List.List_sortWith(self_, ((x_, y_) => {
+return ff_core_Ordering_Order$T.compare_(x_, y_)
+}))
 }
 
 export function List_toSet(self_, ff_core_Ordering_Order$T) {
-return ff_core_List.List_foldLeft(self_, ff_core_Set.empty_(), ((set_, value_) => {
-return ff_core_Set.Set_add(set_, value_, ff_core_Ordering_Order$T)
+return ff_core_List.List_foldLeft(self_, ff_core_Set.empty_(), ((_w1, _w2) => {
+return ff_core_Set.Set_add(_w1, _w2, ff_core_Ordering_Order$T)
 }))
 }
 
 export function List_distinct(self_, ff_core_Ordering_Order$T) {
-let seen_ = ff_core_List.List_toSet(ff_core_List.Empty(), ff_core_Ordering_Order$T);
+let seen_ = ff_core_List.List_toSet([], ff_core_Ordering_Order$T);
 return ff_core_List.List_filter(self_, ((_1) => {
 {
 const item_ = _1;
@@ -1965,23 +770,19 @@ return
 }
 
 export async function List_sort$(self_, ff_core_Ordering_Order$T, $task) {
-if((ff_core_List.List_size(self_) <= 1)) {
-return self_
-} else {
-const stack_ = ff_core_List.List_toStack(self_);
-ff_core_Stack.Stack_sort(stack_, ff_core_Ordering_Order$T);
-return ff_core_Stack.Stack_toList(stack_, 0, 9007199254740991)
-}
+return ff_core_List.List_sortWith(self_, ((x_, y_) => {
+return ff_core_Ordering_Order$T.compare_(x_, y_)
+}))
 }
 
 export async function List_toSet$(self_, ff_core_Ordering_Order$T, $task) {
-return ff_core_List.List_foldLeft(self_, ff_core_Set.empty_(), ((set_, value_) => {
-return ff_core_Set.Set_add(set_, value_, ff_core_Ordering_Order$T)
+return ff_core_List.List_foldLeft(self_, ff_core_Set.empty_(), ((_w1, _w2) => {
+return ff_core_Set.Set_add(_w1, _w2, ff_core_Ordering_Order$T)
 }))
 }
 
 export async function List_distinct$(self_, ff_core_Ordering_Order$T, $task) {
-let seen_ = ff_core_List.List_toSet(ff_core_List.Empty(), ff_core_Ordering_Order$T);
+let seen_ = ff_core_List.List_toSet([], ff_core_Ordering_Order$T);
 return ff_core_List.List_filter(self_, ((_1) => {
 {
 const item_ = _1;
@@ -1999,361 +800,219 @@ return
 }))
 }
 
-export function List_show(self_, ff_core_Show_Show$T) {
-return ff_core_Show.ff_core_Show_Show$ff_core_List_List(ff_core_Show_Show$T).show_(self_)
-}
-
-export async function List_show$(self_, ff_core_Show_Show$T, $task) {
-return ff_core_Show.ff_core_Show_Show$ff_core_List_List(ff_core_Show_Show$T).show_(self_)
-}
-
 export function List_flatten(self_) {
-function finish_(list_, result_) {
-_tailcall: for(;;) {
-{
-const list_a = list_;
-const result_a = result_;
-{
-const as_ = list_a;
-if(result_a.Empty) {
-return as_
-return
-}
-}
-{
-const as_ = list_a;
-if(result_a.Link) {
-const x_ = result_a.head_;
-const xs_ = result_a.tail_;
-{
-const list_r_ = ff_core_List.Link(x_, as_);
-const result_r_ = xs_;
-list_ = list_r_
-result_ = result_r_
-continue _tailcall
-}
-return
-}
-}
-}
-return
-}
-}
-function go_(lists_, result_) {
-_tailcall: for(;;) {
-{
-const _1 = lists_;
-{
-if(_1.Empty) {
-return ff_core_List.Empty()
-return
-}
-}
-{
-if(_1.Link) {
-const as_ = _1.head_;
-if(_1.tail_.Empty) {
-return finish_(as_, result_)
-return
-}
-}
-}
-{
-if(_1.Link) {
-if(_1.head_.Empty) {
-const aas_ = _1.tail_;
-{
-const lists_r_ = aas_;
-const result_r_ = result_;
-lists_ = lists_r_
-result_ = result_r_
-continue _tailcall
-}
-return
-}
-}
-}
-{
-if(_1.Link) {
-if(_1.head_.Link) {
-const a_ = _1.head_.head_;
-const as_ = _1.head_.tail_;
-const aas_ = _1.tail_;
-{
-const lists_r_ = ff_core_List.Link(as_, aas_);
-const result_r_ = ff_core_List.Link(a_, result_);
-lists_ = lists_r_
-result_ = result_r_
-continue _tailcall
-}
-return
-}
-}
-}
-}
-return
-}
-}
-return go_(self_, ff_core_List.Empty())
+const result_ = ff_core_Array.make_();
+ff_core_List.List_each(self_, ((xs_) => {
+ff_core_Array.Array_pushList(result_, xs_)
+}));
+return ff_core_Array.Array_drain(result_)
 }
 
 export async function List_flatten$(self_, $task) {
-function finish_(list_, result_) {
-_tailcall: for(;;) {
-{
-const list_a = list_;
-const result_a = result_;
-{
-const as_ = list_a;
-if(result_a.Empty) {
-return as_
-return
-}
-}
-{
-const as_ = list_a;
-if(result_a.Link) {
-const x_ = result_a.head_;
-const xs_ = result_a.tail_;
-{
-const list_r_ = ff_core_List.Link(x_, as_);
-const result_r_ = xs_;
-list_ = list_r_
-result_ = result_r_
-continue _tailcall
-}
-return
-}
-}
-}
-return
-}
-}
-function go_(lists_, result_) {
-_tailcall: for(;;) {
-{
-const _1 = lists_;
-{
-if(_1.Empty) {
-return ff_core_List.Empty()
-return
-}
+const result_ = ff_core_Array.make_();
+ff_core_List.List_each(self_, ((xs_) => {
+ff_core_Array.Array_pushList(result_, xs_)
+}));
+return ff_core_Array.Array_drain(result_)
 }
+
+export function List_toMap(self_, ff_core_Ordering_Order$K) {
+return ff_core_List.List_foldLeft(self_, ff_core_Map.empty_(), ((_1, _2) => {
 {
-if(_1.Link) {
-const as_ = _1.head_;
-if(_1.tail_.Empty) {
-return finish_(as_, result_)
+const map_ = _1;
+const key_ = _2.first_;
+const value_ = _2.second_;
+return ff_core_Map.Map_add(map_, key_, value_, ff_core_Ordering_Order$K)
 return
 }
+}))
 }
-}
-{
-if(_1.Link) {
-if(_1.head_.Empty) {
-const aas_ = _1.tail_;
+
+export function List_group(self_, ff_core_Ordering_Order$K) {
+let map_ = ff_core_Map.empty_();
+ff_core_List.List_each(self_, ((_1) => {
 {
-const lists_r_ = aas_;
-const result_r_ = result_;
-lists_ = lists_r_
-result_ = result_r_
-continue _tailcall
-}
+const k_ = _1.first_;
+const v_ = _1.second_;
+map_ = ff_core_Map.Map_push(map_, k_, v_, ff_core_Ordering_Order$K)
 return
 }
+}));
+return ff_core_Map.Map_mapValues(map_, ((_, v_) => {
+return ff_core_Array.Array_drain(v_)
+}), ff_core_Ordering_Order$K)
 }
-}
-{
-if(_1.Link) {
-if(_1.head_.Link) {
-const a_ = _1.head_.head_;
-const as_ = _1.head_.tail_;
-const aas_ = _1.tail_;
+
+export async function List_toMap$(self_, ff_core_Ordering_Order$K, $task) {
+return ff_core_List.List_foldLeft(self_, ff_core_Map.empty_(), ((_1, _2) => {
 {
-const lists_r_ = ff_core_List.Link(as_, aas_);
-const result_r_ = ff_core_List.Link(a_, result_);
-lists_ = lists_r_
-result_ = result_r_
-continue _tailcall
-}
-return
-}
-}
-}
-}
+const map_ = _1;
+const key_ = _2.first_;
+const value_ = _2.second_;
+return ff_core_Map.Map_add(map_, key_, value_, ff_core_Ordering_Order$K)
 return
 }
-}
-return go_(self_, ff_core_List.Empty())
-}
-
-export function List_toMap(self_, ff_core_Ordering_Order$K) {
-return ff_core_List.List_foldLeft(self_, ff_core_Map.empty_(), ((map_, pair_) => {
-return ff_core_Map.Map_add(map_, pair_.first_, pair_.second_, ff_core_Ordering_Order$K)
-}))
-}
-
-export function List_group(self_, ff_core_Ordering_Order$K) {
-const initial_ = ff_core_List.Empty();
-return ff_core_List.List_foldLeft(self_, ff_core_List.List_toMap(initial_, ff_core_Ordering_Order$K), ((map_, pair_) => {
-return ff_core_Map.Map_addToList(map_, pair_.first_, pair_.second_, ff_core_Ordering_Order$K)
-}))
-}
-
-export async function List_toMap$(self_, ff_core_Ordering_Order$K, $task) {
-return ff_core_List.List_foldLeft(self_, ff_core_Map.empty_(), ((map_, pair_) => {
-return ff_core_Map.Map_add(map_, pair_.first_, pair_.second_, ff_core_Ordering_Order$K)
 }))
 }
 
 export async function List_group$(self_, ff_core_Ordering_Order$K, $task) {
-const initial_ = ff_core_List.Empty();
-return ff_core_List.List_foldLeft(self_, ff_core_List.List_toMap(initial_, ff_core_Ordering_Order$K), ((map_, pair_) => {
-return ff_core_Map.Map_addToList(map_, pair_.first_, pair_.second_, ff_core_Ordering_Order$K)
-}))
-}
-
-export function List_unzip(self_) {
-function go_(pairs_, ks_, vs_) {
-_tailcall: for(;;) {
-{
-const _1 = pairs_;
+let map_ = ff_core_Map.empty_();
+ff_core_List.List_each(self_, ((_1) => {
 {
-if(_1.Empty) {
-return ff_core_Pair.Pair(ff_core_List.List_reverse(ks_), ff_core_List.List_reverse(vs_))
+const k_ = _1.first_;
+const v_ = _1.second_;
+map_ = ff_core_Map.Map_push(map_, k_, v_, ff_core_Ordering_Order$K)
 return
 }
+}));
+return ff_core_Map.Map_mapValues(map_, ((_, v_) => {
+return ff_core_Array.Array_drain(v_)
+}), ff_core_Ordering_Order$K)
 }
+
+export function List_unzip(self_) {
+const first_ = ff_core_Array.make_();
+const second_ = ff_core_Array.make_();
+ff_core_List.List_each(self_, ((_1) => {
 {
-if(_1.Link) {
-const k_ = _1.head_.first_;
-const v_ = _1.head_.second_;
-const tail_ = _1.tail_;
-{
-const pairs_r_ = tail_;
-const ks_r_ = ff_core_List.Link(k_, ks_);
-const vs_r_ = ff_core_List.Link(v_, vs_);
-pairs_ = pairs_r_
-ks_ = ks_r_
-vs_ = vs_r_
-continue _tailcall
-}
-return
-}
-}
-}
+const x_ = _1.first_;
+const y_ = _1.second_;
+ff_core_Array.Array_push(first_, x_);
+ff_core_Array.Array_push(second_, y_)
 return
 }
-}
-return go_(self_, ff_core_List.Empty(), ff_core_List.Empty())
+}));
+return ff_core_Pair.Pair(ff_core_Array.Array_drain(first_), ff_core_Array.Array_drain(second_))
 }
 
 export async function List_unzip$(self_, $task) {
-function go_(pairs_, ks_, vs_) {
-_tailcall: for(;;) {
-{
-const _1 = pairs_;
+const first_ = ff_core_Array.make_();
+const second_ = ff_core_Array.make_();
+ff_core_List.List_each(self_, ((_1) => {
 {
-if(_1.Empty) {
-return ff_core_Pair.Pair(ff_core_List.List_reverse(ks_), ff_core_List.List_reverse(vs_))
-return
-}
-}
-{
-if(_1.Link) {
-const k_ = _1.head_.first_;
-const v_ = _1.head_.second_;
-const tail_ = _1.tail_;
-{
-const pairs_r_ = tail_;
-const ks_r_ = ff_core_List.Link(k_, ks_);
-const vs_r_ = ff_core_List.Link(v_, vs_);
-pairs_ = pairs_r_
-ks_ = ks_r_
-vs_ = vs_r_
-continue _tailcall
-}
-return
-}
-}
-}
+const x_ = _1.first_;
+const y_ = _1.second_;
+ff_core_Array.Array_push(first_, x_);
+ff_core_Array.Array_push(second_, y_)
 return
 }
-}
-return go_(self_, ff_core_List.Empty(), ff_core_List.Empty())
+}));
+return ff_core_Pair.Pair(ff_core_Array.Array_drain(first_), ff_core_Array.Array_drain(second_))
 }
 
 export function List_join(self_, separator_ = "") {
-return ff_core_Array.Array_join(ff_core_List.List_toArray(self_), separator_)
+return self_.join(separator_)
 }
 
 export async function List_join$(self_, separator_ = "", $task) {
-return ff_core_Array.Array_join(ff_core_List.List_toArray(self_), separator_)
+throw new Error('Function List_join is missing on this target in async context.');
 }
 
-export function ff_core_Any_HasAnyTag$ff_core_List_List(ff_core_Any_HasAnyTag$T) { return {
-anyTag_() {
-return ff_core_Any.internalAnyTag_(((("ff:core/List.List" + "[") + ff_core_Any.AnyTag_show(ff_core_Any_HasAnyTag$T.anyTag_())) + "]"))
+export function ff_core_Show_Show$ff_core_List_List(ff_core_Show_Show$T) { return {
+show_(value_) {
+const array_ = ff_core_Array.make_();
+ff_core_Array.Array_push(array_, "[");
+ff_core_List.List_each(value_, ((x_) => {
+if((ff_core_Array.Array_size(array_) > 1)) {
+ff_core_Array.Array_push(array_, ", ")
+};
+ff_core_Array.Array_push(array_, ff_core_Show_Show$T.show_(x_))
+}));
+ff_core_Array.Array_push(array_, "]");
+return ff_core_Array.Array_join(array_, "")
 },
-async anyTag_$($task) {
-return ff_core_Any.internalAnyTag_(((("ff:core/List.List" + "[") + ff_core_Any.AnyTag_show(ff_core_Any_HasAnyTag$T.anyTag_())) + "]"))
+async show_$(value_, $task) {
+const array_ = ff_core_Array.make_();
+ff_core_Array.Array_push(array_, "[");
+ff_core_List.List_each(value_, ((x_) => {
+if((ff_core_Array.Array_size(array_) > 1)) {
+ff_core_Array.Array_push(array_, ", ")
+};
+ff_core_Array.Array_push(array_, ff_core_Show_Show$T.show_(x_))
+}));
+ff_core_Array.Array_push(array_, "]");
+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_) {
-{
-const x_a = x_;
-const y_a = y_;
-{
-const _guard1 = (x_ === y_);
-if(_guard1) {
+if(ff_core_List.internalSame_(x_, y_)) {
 return true
-return
-}
-}
-{
-if(x_a.Link) {
-const x_ = x_a;
-if(y_a.Link) {
-const y_ = y_a;
-return (ff_core_Equal_Equal$T.equals_(x_.head_, y_.head_) && ff_core_List.ff_core_Equal_Equal$ff_core_List_List(ff_core_Equal_Equal$T).equals_(x_.tail_, y_.tail_))
-return
-}
-}
-}
-{
+} else {
+if((ff_core_List.List_size(x_) !== ff_core_List.List_size(y_))) {
 return false
-return
+} else {
+let i_ = (-1);
+return ff_core_List.List_all(x_, ((l_) => {
+i_ += 1;
+return ff_core_Equal_Equal$T.equals_(l_, ff_core_List.List_grab(y_, i_))
+}))
 }
 }
 },
 async equals_$(x_, y_, $task) {
-{
-const x_a = x_;
-const y_a = y_;
-{
-const _guard1 = (x_ === y_);
-if(_guard1) {
+if(ff_core_List.internalSame_(x_, y_)) {
 return true
-return
+} else {
+if((ff_core_List.List_size(x_) !== ff_core_List.List_size(y_))) {
+return false
+} else {
+let i_ = (-1);
+return ff_core_List.List_all(x_, ((l_) => {
+i_ += 1;
+return ff_core_Equal_Equal$T.equals_(l_, ff_core_List.List_grab(y_, i_))
+}))
 }
 }
-{
-if(x_a.Link) {
-const x_ = x_a;
-if(y_a.Link) {
-const y_ = y_a;
-return (ff_core_Equal_Equal$T.equals_(x_.head_, y_.head_) && ff_core_List.ff_core_Equal_Equal$ff_core_List_List(ff_core_Equal_Equal$T).equals_(x_.tail_, y_.tail_))
-return
 }
+}}
+
+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_)) {
+return ff_core_Ordering.OrderingSame()
+} else {
+const size_ = ff_core_Int.Int_min(ff_core_List.List_size(x_), ff_core_List.List_size(y_));
+let i_ = 0;
+let ordering_ = ff_core_Ordering.OrderingSame();
+while(((ordering_ === ff_core_Ordering.OrderingSame()) && (i_ < size_))) {
+ordering_ = ff_core_Ordering_Order$T.compare_(ff_core_List.List_grab(x_, i_), ff_core_List.List_grab(y_, i_));
+i_ += 1
+};
+if((ordering_ !== ff_core_Ordering.OrderingSame())) {
+return ordering_
+} else {
+return ff_core_Ordering.ff_core_Ordering_Order$ff_core_Int_Int.compare_(ff_core_List.List_size(x_), ff_core_List.List_size(y_))
 }
 }
-{
-return false
-return
+},
+async compare_$(x_, y_, $task) {
+if(ff_core_List.internalSame_(x_, y_)) {
+return ff_core_Ordering.OrderingSame()
+} else {
+const size_ = ff_core_Int.Int_min(ff_core_List.List_size(x_), ff_core_List.List_size(y_));
+let i_ = 0;
+let ordering_ = ff_core_Ordering.OrderingSame();
+while(((ordering_ === ff_core_Ordering.OrderingSame()) && (i_ < size_))) {
+ordering_ = ff_core_Ordering_Order$T.compare_(ff_core_List.List_grab(x_, i_), ff_core_List.List_grab(y_, i_));
+i_ += 1
+};
+if((ordering_ !== ff_core_Ordering.OrderingSame())) {
+return ordering_
+} else {
+return ff_core_Ordering.ff_core_Ordering_Order$ff_core_Int_Int.compare_(ff_core_List.List_size(x_), ff_core_List.List_size(y_))
+}
 }
 }
+}}
+
+export function ff_core_Any_HasAnyTag$ff_core_List_List(ff_core_Any_HasAnyTag$T) { return {
+anyTag_() {
+return ff_core_Any.internalAnyTag_(((("ff:core/List.List" + "[") + ff_core_Any.AnyTag_show(ff_core_Any_HasAnyTag$T.anyTag_())) + "]"))
+},
+async anyTag_$($task) {
+return ff_core_Any.internalAnyTag_(((("ff:core/List.List" + "[") + ff_core_Any.AnyTag_show(ff_core_Any_HasAnyTag$T.anyTag_())) + "]"))
 }
 }}