firefly-compiler 0.5.9 → 0.5.11

package/compiler/JsEmitter.ff

@@ -680,6 +680,62 @@ extend self: JsEmitter {
                 invokeImmediately(doWhileBody) | body
             } =>
                 Some("while(" + self.emitComma(body, async) + ") {}")
+            | "ff:core/List.List_each" {arguments | [
+                ECall(_, StaticCall(r, _, _), _, _, [start, end], _)
+                ELambda(_, Lambda(_, _, [MatchCase(_, [PVariable(_, name)], [], body)]))
+            ]} {r == "ff:core/Int.Int_until" || r == "ff:core/Int.Int_to"} =>
+                let startCode = self.emitTerm(start.value, async)
+                let endCode = self.emitTerm(end.value, async)
+                let op = if(r == "ff:core/Int.Int_until") {"<"} else {"<="}
+                Some(
+                    "for(let " +
+                    "for_i = " + startCode + ", for_e = " + endCode + "; for_i " + op + " for_e; for_i++) {\n" +
+                        name.map {"const " + escapeKeyword(_) + " = for_i;\n"}.else {""} +
+                        self.emitStatements(body, last, async) +
+                    "\n}"
+                )
+            | "ff:core/List.List_each" {arguments | [list, ELambda(_, Lambda(_, _, [
+                MatchCase(_, [PVariable(_, name)], [], body)
+            ]))]} =>
+                let fusion = self.emitLightFusion(list, async)
+                let start = fusion.second.first
+                let end = fusion.second.second
+                let listCode = fusion.first
+                Some(
+                    "for(let for_i = " + start + ", for_a = " + listCode + ", for_l = " + end + 
+                    "; for_i < for_l; for_i++) {\n" +
+                        name.map {"const " + escapeKeyword(_) + " = for_a[for_i];\n"}.else {""} +
+                        self.emitStatements(body, last, async) +
+                    "\n}"
+                )
+            | "ff:core/List.List_eachWhile" {arguments | [list, ELambda(_, Lambda(_, _, [
+                MatchCase(_, [PVariable(_, name)], [], ESequential(_, body, condition))
+            ]))]} =>
+                let fusion = self.emitLightFusion(list, async)
+                let start = fusion.second.first
+                let end = fusion.second.second
+                let listCode = fusion.first
+                Some(
+                    "for(let for_i = " + start + ", for_a = " + listCode + ", for_l = " + end + 
+                    "; for_i < for_l; for_i++) {\n" +
+                        name.map {"const " + escapeKeyword(_) + " = for_a[for_i];\n"}.else {""} +
+                        self.emitStatements(body, last, async) + ";\n" +
+                        "if(!" + self.emitComma(condition, async) + ") break" +
+                    "\n}"
+                )
+            | "ff:core/List.List_eachWhile" {arguments | [list, ELambda(_, Lambda(_, _, [
+                MatchCase(_, [PVariable(_, name)], [], condition)
+            ]))]} =>
+                let listCode = self.emitTerm(list, async)
+                Some(
+                    "for(let " +
+                    "for_i = 0, for_a = " + listCode + ", for_l = for_a.length" + "; for_i < for_l; for_i++) {\n" +
+                        name.map {"const " + escapeKeyword(_) + " = for_a[for_i];\n"}.else {""} +
+                        "if(!" + self.emitComma(condition, async) + ") break" +
+                    "\n}"
+                )
+            | "ff:core/Array.Array_push" {arguments | [array, value]} =>
+                Some(self.emitTerm(array, async) + ".array.push(" + self.emitTerm(value, async) + ")")
             | "ff:core/Core.if" {arguments | [condition, body]} =>
                 Some(
                     "if(" + self.emitComma(condition, async) + ") {\n" +
@@ -718,6 +774,45 @@ extend self: JsEmitter {
                 None
         }
     }
+    
+    emitLightFusion(list: Term, async: Bool): Pair[String, Pair[String, String]] {
+        mutable start = "0"
+        mutable end = "for_a.length"
+        let listCode = list.{
+            | ECall(_, StaticCall("ff:core/List.List_dropFirst", _, _), _, _, [a1, a2], _) =>
+                start = self.emitTerm(a2.value, async)
+                if(!start.all {_.isAsciiDigit()}) {
+                    start = "Math.max(" + start + ", 0)"
+                }
+                self.emitTerm(a1.value, async)
+            | ECall(_, StaticCall("ff:core/List.List_dropLast", _, _), _, _, [a1, a2], _) =>
+                let count = self.emitTerm(a2.value, async)
+                if(!count.all {_.isAsciiDigit()}) {
+                    end = end + " - Math.max(" + count + ", 0)"
+                } else {
+                    end = end + " - " + count
+                }
+                self.emitTerm(a1.value, async)
+            | ECall(_, StaticCall("ff:core/List.List_takeFirst", _, _), _, _, [a1, a2], _) =>
+                end = self.emitTerm(a2.value, async)
+                if(!end.all {_.isAsciiDigit()}) {
+                    end = "Math.max(" + end + ", 0)"
+                }
+                end = "Math.min(" + end + ", for_a.length)"
+                self.emitTerm(a1.value, async)
+            | ECall(_, StaticCall("ff:core/List.List_takeLast", _, _), _, _, [a1, a2], _) =>
+                let count = self.emitTerm(a2.value, async)
+                if(!count.all {_.isAsciiDigit()}) {
+                    start = "Math.max(for_a.length - Math.max(" + count + ", 0), 0)"
+                } else {
+                    start = "Math.max(for_a.length - " + count + ", 0)"
+                }
+                self.emitTerm(a1.value, async)
+            | _ => 
+                self.emitTerm(list, async)
+        } 
+        Pair(listCode, Pair(start, end))
+    }
 
     emitTryCatchFinally(term: Term, last: Bool, async: Bool): Option[String] {
         function emitCatch(catchEffect: Type, cases: List[MatchCase]): String {

package/output/js/ff/compiler/Builder.mjs

@@ -152,11 +152,12 @@ ff_core_Path.Path_renameTo(jsPathFile_, jsOutputPath_)
 }
 
 export function processIncludes_(jsPathFile_, packagePath_, info_) {
-ff_core_List.List_each(info_.includes_, ((include_) => {
+for(let for_i = 0, for_a = info_.includes_, for_l = for_a.length; for_i < for_l; for_i++) {
+const include_ = for_a[for_i];
 const fromPath_ = ff_core_Path.Path_slash(ff_core_Path.Path_slash(ff_core_Path.Path_slash(packagePath_, ".firefly"), "include"), include_.path_);
 const toPath_ = ff_core_Path.Path_slash(ff_core_Path.Path_slash(jsPathFile_, ff_compiler_Syntax.PackagePair_groupName(info_.package_.packagePair_, "/")), include_.path_);
 ff_core_Path.Path_copyTo(fromPath_, toPath_, 0, 100)
-}))
+}
 }
 
 export function buildViaBuildSystem_(system_, fireflyPath_, mainFile_, target_) {
@@ -185,9 +186,10 @@ return [ff_compiler_Builder.PackageFiles(ff_core_Option.Option_grab(ff_core_Path
 }
 }))(ff_core_Path.Path_isDirectory(path_));
 const errors_ = ff_core_Array.new_();
-ff_core_List.List_each(ff_core_List.List_filter(packages_, ((_w1) => {
+for(let for_i = 0, for_a = ff_core_List.List_filter(packages_, ((_w1) => {
 return (!ff_core_List.List_isEmpty(_w1.files_))
-})), ((package_) => {
+})), for_l = for_a.length; for_i < for_l; for_i++) {
+const package_ = for_a[for_i];
 const firstFile_ = ff_core_List.List_grabFirst(package_.files_);
 const resolvedDependencies_ = ff_compiler_Dependencies.process_(ff_core_NodeSystem.NodeSystem_httpClient(system_), dependencyLock_, firstFile_);
 const fixedPackagePaths_ = (ff_core_Map.Map_contains(resolvedDependencies_.packagePaths_, ff_compiler_Syntax.PackagePair("ff", "core"), ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair)
@@ -203,7 +205,8 @@ const files_ = (checkDependencies_
 : ff_core_List.List_filter(package_.files_, ((_w1) => {
 return (!ff_core_Path.Path_contains(_w1, [".firefly", "dependencies"]))
 })));
-ff_core_List.List_each(files_, ((file_) => {
+for(let for_i = 0, for_a = files_, for_l = for_a.length; for_i < for_l; for_i++) {
+const file_ = for_a[for_i];
 const localFile_ = ff_core_Path.Path_base(file_);
 ff_core_Try.Try_catch(ff_core_Try.Try_tryCatch(ff_core_Core.try_((() => {
 if(infer_) {
@@ -215,7 +218,7 @@ ff_compiler_Compiler.Compiler_resolve(compiler_, resolvedDependencies_.mainPacka
 {
 const c_ = _1;
 const error_ = _2;
-ff_core_Array.Array_push(errors_, c_)
+errors_.array.push(c_)
 return
 }
 }), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError), ((_1, _2) => {
@@ -226,9 +229,9 @@ ff_core_Array.Array_pushList(errors_, compileErrors_)
 return
 }
 }), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileErrors)
-}));
+};
 ff_compiler_ModuleCache.ModuleCache_mergeVersions(cache_, compiler_.cache_)
-}));
+};
 return ff_core_Array.Array_drain(errors_)
 }
 
@@ -346,11 +349,12 @@ if((await ff_core_Path.Path_exists$(jsOutputPath_, false, false, false, $task)))
 }
 
 export async function processIncludes_$(jsPathFile_, packagePath_, info_, $task) {
-(await ff_core_List.List_each$(info_.includes_, (async (include_, $task) => {
+for(let for_i = 0, for_a = info_.includes_, for_l = for_a.length; for_i < for_l; for_i++) {
+const include_ = for_a[for_i];
 const fromPath_ = (await ff_core_Path.Path_slash$((await ff_core_Path.Path_slash$((await ff_core_Path.Path_slash$(packagePath_, ".firefly", $task)), "include", $task)), include_.path_, $task));
 const toPath_ = (await ff_core_Path.Path_slash$((await ff_core_Path.Path_slash$(jsPathFile_, ff_compiler_Syntax.PackagePair_groupName(info_.package_.packagePair_, "/"), $task)), include_.path_, $task));
 (await ff_core_Path.Path_copyTo$(fromPath_, toPath_, 0, 100, $task))
-}), $task))
+}
 }
 
 export async function buildViaBuildSystem_$(system_, fireflyPath_, mainFile_, target_, $task) {
@@ -379,9 +383,10 @@ return [ff_compiler_Builder.PackageFiles(ff_core_Option.Option_grab((await ff_co
 }
 }))((await ff_core_Path.Path_isDirectory$(path_, $task)), $task));
 const errors_ = ff_core_Array.new_();
-(await ff_core_List.List_each$(ff_core_List.List_filter(packages_, ((_w1) => {
+for(let for_i = 0, for_a = ff_core_List.List_filter(packages_, ((_w1) => {
 return (!ff_core_List.List_isEmpty(_w1.files_))
-})), (async (package_, $task) => {
+})), for_l = for_a.length; for_i < for_l; for_i++) {
+const package_ = for_a[for_i];
 const firstFile_ = ff_core_List.List_grabFirst(package_.files_);
 const resolvedDependencies_ = (await ff_compiler_Dependencies.process_$((await ff_core_NodeSystem.NodeSystem_httpClient$(system_, $task)), dependencyLock_, firstFile_, $task));
 const fixedPackagePaths_ = (ff_core_Map.Map_contains(resolvedDependencies_.packagePaths_, ff_compiler_Syntax.PackagePair("ff", "core"), ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair)
@@ -397,7 +402,8 @@ const files_ = (checkDependencies_
 : (await ff_core_List.List_filter$(package_.files_, (async (_w1, $task) => {
 return (!(await ff_core_Path.Path_contains$(_w1, [".firefly", "dependencies"], $task)))
 }), $task)));
-(await ff_core_List.List_each$(files_, (async (file_, $task) => {
+for(let for_i = 0, for_a = files_, for_l = for_a.length; for_i < for_l; for_i++) {
+const file_ = for_a[for_i];
 const localFile_ = (await ff_core_Path.Path_base$(file_, $task));
 ff_core_Try.Try_catch(ff_core_Try.Try_tryCatch((await ff_core_Core.try_$((async ($task) => {
 if(infer_) {
@@ -409,7 +415,7 @@ if(infer_) {
 {
 const c_ = _1;
 const error_ = _2;
-ff_core_Array.Array_push(errors_, c_)
+errors_.array.push(c_)
 return
 }
 }), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError), ((_1, _2) => {
@@ -420,9 +426,9 @@ ff_core_Array.Array_pushList(errors_, compileErrors_)
 return
 }
 }), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileErrors)
-}), $task));
+};
 ff_compiler_ModuleCache.ModuleCache_mergeVersions(cache_, compiler_.cache_)
-}), $task));
+};
 return ff_core_Array.Array_drain(errors_)
 }
 

package/output/js/ff/compiler/Compiler.mjs

@@ -148,7 +148,7 @@ const stop_ = (ff_core_Task.Task_elapsed(self_.task_) - self_.phaseDurationDelta
 const duration_ = (stop_ - start_);
 self_.phaseDurationDelta_ = (self_.phaseDurationDelta_ + duration_);
 const text_ = ((((phase_ + " ") + ff_compiler_Syntax.PackagePair_groupName(packagePair_, ":")) + "/") + moduleName_);
-ff_core_Array.Array_push(self_.phaseDurations_, ff_core_Pair.Pair(text_, duration_));
+self_.phaseDurations_.array.push(ff_core_Pair.Pair(text_, duration_));
 return result_
 }
 
@@ -279,7 +279,7 @@ const stop_ = ((await ff_core_Task.Task_elapsed$(self_.task_, $task)) - self_.ph
 const duration_ = (stop_ - start_);
 self_.phaseDurationDelta_ = (self_.phaseDurationDelta_ + duration_);
 const text_ = ((((phase_ + " ") + ff_compiler_Syntax.PackagePair_groupName(packagePair_, ":")) + "/") + moduleName_);
-ff_core_Array.Array_push(self_.phaseDurations_, ff_core_Pair.Pair(text_, duration_));
+self_.phaseDurations_.array.push(ff_core_Pair.Pair(text_, duration_));
 return result_
 }
 

package/output/js/ff/compiler/Inference.mjs

@@ -217,17 +217,19 @@ if((ff_core_List.List_size(traitDefinition_.generics_) !== ff_core_List.List_siz
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(definition_.at_, ((((("Wrong number of type arguments for " + traitName_) + ", expected ") + (ff_core_List.List_size(traitDefinition_.generics_) - 1)) + ", got ") + (ff_core_List.List_size(definition_.typeArguments_) - 1))), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
 };
 const instantiationMap_ = ff_core_List.List_toMap(ff_core_List.List_zip(traitDefinition_.generics_, definition_.typeArguments_), ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String);
-ff_core_List.List_each(traitDefinition_.methods_, ((traitMethod_) => {
+for(let for_i = 0, for_a = traitDefinition_.methods_, for_l = for_a.length; for_i < for_l; for_i++) {
+const traitMethod_ = for_a[for_i];
 const found_ = ff_core_List.List_filter(definition_.methods_, ((_w1) => {
 return (_w1.signature_.name_ === traitMethod_.name_)
 }));
 if(ff_core_List.List_isEmpty(found_)) {
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(definition_.at_, ("Missing instance method: " + traitMethod_.name_)), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
 };
-ff_core_List.List_each(ff_core_List.List_dropFirst(found_, 1), ((duplicateMethod_) => {
+for(let for_i = 1, for_a = found_, for_l = for_a.length; for_i < for_l; for_i++) {
+const duplicateMethod_ = for_a[for_i];
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(duplicateMethod_.at_, ("Duplicated instance method: " + traitMethod_.name_)), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
-}))
-}));
+}
+};
 {
 const _1 = definition_;
 {
@@ -250,12 +252,14 @@ return ff_compiler_Syntax.Parameter(_c.at_, _c.mutable_, _c.name_, ff_compiler_U
 }
 }));
 const returnType_ = ff_compiler_Unification.Unification_instantiate(self_.unification_, instantiationMap_, traitMethodScheme_.signature_.returnType_);
-ff_core_List.List_each(ff_core_List.List_dropFirst(instanceFunction_.signature_.parameters_, ff_core_List.List_size(parameters_)), ((instanceParameter_) => {
+for(let for_i = Math.max(ff_core_List.List_size(parameters_), 0), for_a = instanceFunction_.signature_.parameters_, for_l = for_a.length; for_i < for_l; for_i++) {
+const instanceParameter_ = for_a[for_i];
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(instanceParameter_.at_, ("Unexpected parameter: " + instanceParameter_.name_)), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
-}));
-ff_core_List.List_each(ff_core_List.List_dropFirst(parameters_, ff_core_List.List_size(instanceFunction_.signature_.parameters_)), ((traitParameter_) => {
+};
+for(let for_i = Math.max(ff_core_List.List_size(instanceFunction_.signature_.parameters_), 0), for_a = parameters_, for_l = for_a.length; for_i < for_l; for_i++) {
+const traitParameter_ = for_a[for_i];
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(instanceFunction_.at_, ("Missing parameter: " + traitParameter_.name_)), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
-}));
+};
 ff_core_List.List_each(ff_core_List.List_zip(parameters_, instanceFunction_.signature_.parameters_), ((_1) => {
 {
 const traitParameter_ = _1.first_;
@@ -459,7 +463,7 @@ const noEffect_ = ff_compiler_Syntax.TConstructor(at_, "ff:core/Nothing.Nothing"
 return ff_compiler_Environment.Scheme(true, false, false, false, ff_compiler_Syntax.Signature(at_, name_, false, [], [], [], type_, noEffect_))
 }
 }), ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String);
-ff_core_Array.Array_push(guards_, (((_c) => {
+guards_.array.push((((_c) => {
 return ff_compiler_Syntax.MatchGuard(_c.at_, guardTerm_, _c.pattern_)
 }))(g_));
 {
@@ -1979,12 +1983,13 @@ return ff_compiler_Syntax.Parameter(_c.at_, _c.mutable_, _c.name_, ff_compiler_U
 }));
 const returnType_ = ff_compiler_Unification.Unification_instantiate(self_.unification_, instantiationMap_, scheme_.signature_.returnType_);
 const effect_ = ff_compiler_Unification.Unification_instantiate(self_.unification_, instantiationMap_, scheme_.signature_.effect_);
-ff_core_List.List_each(scheme_.signature_.constraints_, ((c_) => {
+for(let for_i = 0, for_a = scheme_.signature_.constraints_, for_l = for_a.length; for_i < for_l; for_i++) {
+const c_ = for_a[for_i];
 const generics_ = ff_core_List.List_map(c_.generics_, ((_w1) => {
 return ff_compiler_Unification.Unification_instantiate(self_.unification_, instantiationMap_, _w1)
 }));
 ff_compiler_Unification.Unification_constrain(self_.unification_, at_, ff_core_List.List_grabFirst(generics_), c_.name_, ff_core_List.List_dropFirst(generics_, 1))
-}));
+};
 const signature_ = (((_c) => {
 return ff_compiler_Syntax.Signature(_c.at_, _c.name_, _c.member_, [], [], parameters_, returnType_, effect_)
 }))(scheme_.signature_);
@@ -2064,17 +2069,19 @@ if((ff_core_List.List_size(traitDefinition_.generics_) !== ff_core_List.List_siz
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(definition_.at_, ((((("Wrong number of type arguments for " + traitName_) + ", expected ") + (ff_core_List.List_size(traitDefinition_.generics_) - 1)) + ", got ") + (ff_core_List.List_size(definition_.typeArguments_) - 1))), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
 };
 const instantiationMap_ = ff_core_List.List_toMap(ff_core_List.List_zip(traitDefinition_.generics_, definition_.typeArguments_), ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String);
-ff_core_List.List_each(traitDefinition_.methods_, ((traitMethod_) => {
+for(let for_i = 0, for_a = traitDefinition_.methods_, for_l = for_a.length; for_i < for_l; for_i++) {
+const traitMethod_ = for_a[for_i];
 const found_ = ff_core_List.List_filter(definition_.methods_, ((_w1) => {
 return (_w1.signature_.name_ === traitMethod_.name_)
 }));
 if(ff_core_List.List_isEmpty(found_)) {
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(definition_.at_, ("Missing instance method: " + traitMethod_.name_)), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
 };
-ff_core_List.List_each(ff_core_List.List_dropFirst(found_, 1), ((duplicateMethod_) => {
+for(let for_i = 1, for_a = found_, for_l = for_a.length; for_i < for_l; for_i++) {
+const duplicateMethod_ = for_a[for_i];
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(duplicateMethod_.at_, ("Duplicated instance method: " + traitMethod_.name_)), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
-}))
-}));
+}
+};
 {
 const _1 = definition_;
 {
@@ -2097,12 +2104,14 @@ return ff_compiler_Syntax.Parameter(_c.at_, _c.mutable_, _c.name_, ff_compiler_U
 }
 }));
 const returnType_ = ff_compiler_Unification.Unification_instantiate(self_.unification_, instantiationMap_, traitMethodScheme_.signature_.returnType_);
-ff_core_List.List_each(ff_core_List.List_dropFirst(instanceFunction_.signature_.parameters_, ff_core_List.List_size(parameters_)), ((instanceParameter_) => {
+for(let for_i = Math.max(ff_core_List.List_size(parameters_), 0), for_a = instanceFunction_.signature_.parameters_, for_l = for_a.length; for_i < for_l; for_i++) {
+const instanceParameter_ = for_a[for_i];
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(instanceParameter_.at_, ("Unexpected parameter: " + instanceParameter_.name_)), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
-}));
-ff_core_List.List_each(ff_core_List.List_dropFirst(parameters_, ff_core_List.List_size(instanceFunction_.signature_.parameters_)), ((traitParameter_) => {
+};
+for(let for_i = Math.max(ff_core_List.List_size(instanceFunction_.signature_.parameters_), 0), for_a = parameters_, for_l = for_a.length; for_i < for_l; for_i++) {
+const traitParameter_ = for_a[for_i];
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(instanceFunction_.at_, ("Missing parameter: " + traitParameter_.name_)), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
-}));
+};
 ff_core_List.List_each(ff_core_List.List_zip(parameters_, instanceFunction_.signature_.parameters_), ((_1) => {
 {
 const traitParameter_ = _1.first_;
@@ -2306,7 +2315,7 @@ const noEffect_ = ff_compiler_Syntax.TConstructor(at_, "ff:core/Nothing.Nothing"
 return ff_compiler_Environment.Scheme(true, false, false, false, ff_compiler_Syntax.Signature(at_, name_, false, [], [], [], type_, noEffect_))
 }
 }), ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String);
-ff_core_Array.Array_push(guards_, (((_c) => {
+guards_.array.push((((_c) => {
 return ff_compiler_Syntax.MatchGuard(_c.at_, guardTerm_, _c.pattern_)
 }))(g_));
 {
@@ -3826,12 +3835,13 @@ return ff_compiler_Syntax.Parameter(_c.at_, _c.mutable_, _c.name_, ff_compiler_U
 }));
 const returnType_ = ff_compiler_Unification.Unification_instantiate(self_.unification_, instantiationMap_, scheme_.signature_.returnType_);
 const effect_ = ff_compiler_Unification.Unification_instantiate(self_.unification_, instantiationMap_, scheme_.signature_.effect_);
-ff_core_List.List_each(scheme_.signature_.constraints_, ((c_) => {
+for(let for_i = 0, for_a = scheme_.signature_.constraints_, for_l = for_a.length; for_i < for_l; for_i++) {
+const c_ = for_a[for_i];
 const generics_ = ff_core_List.List_map(c_.generics_, ((_w1) => {
 return ff_compiler_Unification.Unification_instantiate(self_.unification_, instantiationMap_, _w1)
 }));
 ff_compiler_Unification.Unification_constrain(self_.unification_, at_, ff_core_List.List_grabFirst(generics_), c_.name_, ff_core_List.List_dropFirst(generics_, 1))
-}));
+};
 const signature_ = (((_c) => {
 return ff_compiler_Syntax.Signature(_c.at_, _c.name_, _c.member_, [], [], parameters_, returnType_, effect_)
 }))(scheme_.signature_);