firefly-compiler 0.5.13 → 0.5.15

package/compiler/JsEmitter.ff

@@ -516,15 +516,27 @@ extend self: JsEmitter {
                 Some("(" + operator + self.emitTerm(value, async) + ")")
             | operator {!operator.grabFirst().isAsciiLetter()} {arguments | [left, right]}  =>
                 Some("(" + self.emitTerm(left, async) + " " + operator + " " + self.emitTerm(right, async) + ")")
-            | "ff:core/List.List_grab" {arguments | [EVariable(_, x1), EVariable(_, x2)]} =>
+            | "ff:core/List.List_grab" {arguments | [e1, e2]} {noSideEffects(e1) && noSideEffects(e2)} =>
+                let code1 = self.emitTerm(e1, async)
+                let code2 = self.emitTerm(e2, async)
                 Some(
-                    "(" + escapeResolved(x1) + "[" + escapeResolved(x2) + "] ?? " + 
-                    "ff_core_List.internalGrab_(" + escapeResolved(x1) + ", " + escapeResolved(x2) + "))"
+                    "(" + code1 + "[" + code2 + "] ?? " + 
+                    "ff_core_List.internalGrab_(" + code1 + ", " + code2 + "))"
                 )
-            | "ff:core/Array.Array_grab" {arguments | [EVariable(_, x1), EVariable(_, x2)]} =>
+            | "ff:core/Array.Array_grab" {arguments | [e1, e2]} =>
+                let code1 = self.emitTerm(e1, async)
+                let code2 = self.emitTerm(e2, async)
                 Some(
-                    "(" + escapeResolved(x1) + ".array[" + escapeResolved(x2) + "] ?? " + 
-                    "ff_core_Array.internalGrab_(" + escapeResolved(x1) + ", " + escapeResolved(x2) + "))"
+                    "(" + code1 + ".array[" + code2 + "] ?? " + 
+                    "ff_core_Array.internalGrab_(" + code1 + ", " + code2 + "))"
+                )
+            | "ff:core/List.List_size" {arguments | [e]} =>
+                Some(
+                    self.emitTerm(e, async) + ".length"
+                )
+            | "ff:core/Array.Array_size" {arguments | [e]} =>
+                Some(
+                    self.emitTerm(e, async) + ".array.length"
                 )
             | "ff:core/Equal.equals" {arguments | [left, right]} {dictionaries | [Dictionary(_, _, _, typeName, [])]} {
                 primitiveTypes.contains(typeName) || typeName == "ff:core/Ordering.Ordering"
@@ -680,6 +692,15 @@ extend self: JsEmitter {
                 invokeImmediately(doWhileBody) | body
             } =>
                 Some("while(" + self.emitComma(body, async) + ") {}")
+            | "ff:core/Option.Option_each" {arguments | [list, ELambda(_, Lambda(_, _, [
+                MatchCase(_, [PVariable(_, name)], [], body)
+            ]))]} =>
+                Some(
+                    "for(let for_o = " + self.emitTerm(list, async) + "; for_o.Some;) {\n" +
+                        name.map {"const " + escapeKeyword(_) + " = for_o.value_;\n"}.else {""} +
+                        self.emitStatements(body, last, async) +
+                    "\nbreak\n}"
+                )
             | "ff:core/List.List_each" {arguments | [
                 ECall(_, StaticCall(r, _, _), _, _, [start, end], _)
                 ELambda(_, Lambda(_, _, [MatchCase(_, [PVariable(_, name)], [], body)]))

package/fireflysite/Test.ff

@@ -27,12 +27,18 @@ nodeMain(system: NodeSystem) {
     let foo = {{_ + 1}(_)}
     Log.show(foo(1))
     
+    /*
     let x1 = work(initial = 3) {i => 
         i + 1
     } {s => 
         "*" + s + "*"
-    }
+    }*/
     //let x2 = work(initial = 3, {i => i + 1}, {s => s + "*"}) 
+    
+    let array = Array.new()
+    while {array.size() < 5} {
+        array.push("X")
+    }
 }
 
 factorial(n: Int): Int {
@@ -53,4 +59,4 @@ factorialTail(n: Int, acc: Int = 1): Int {
 
 work(f: Int => Int, g: String => String, initial: Int = 0): String {
     g("" + f(initial))
-}
+}

package/fireflysite/assets/markdown/reference/FunctionsAndMethods.md

@@ -240,51 +240,70 @@ let f: Int => Int = {{_ + 1}(_)}
 In this code, there is an outer and an inner anonymous function, both taking one argument. The first underscore belongs to the inner function, which is called immediately by the outer function with the outer function's anonymous parameter as the argument.
 
 
-# Trailing lambda calls
+# Trailing Anonymous Function Arguments
 
-Firefly has special syntax for passing an anonymous function as the last argument in a function call. Consider the `if` function from the standard library, with this signature:
+Firefly has a special syntax for calling functions with function arguments. When a call has a sequence of literal anonymous functions as the last arguments, these arguments may be given using this special syntax. Consider the `if` function from the standard library, with this signature:
 
 ```firefly
 if[T](condition: Bool, body: () => T): Option[T]
 ```
 
-The `if` function takes two parameters, where the last is a function. Calling `if` with the standard syntax looks like this:
+The `if` function takes two parameters, where the last is a function. Calling `if` with the standard syntax could look like this:
 
 ```firefly
 if(x == 0, {"Zero"}) 
 ```
 
-Using the special syntax for trailing lambda calls, it looks like this:
+Using the special syntax for trailing anonymous function arguments, it looks like this:
 
 ```firefly
 if(x == 0) {"Zero"}
 ```
 
-With this trailing lambda call syntax, the anonymous function is written after the call parentheses. This syntax is available for multiple trailing function arguments in sequence.
+With this syntax, the anonymous function is written after the call parentheses. Multiple trailing function arguments may be given in sequence. Consider the `while` function from the standard library, with this signature:
 
-The function below takes three parameters. Two functions and one `Int` with a default value:
+```firefly
+while(condition: () => Bool, body: () => Unit): Unit
+```
+
+The `while` function takes two parameters, both functions. Using the special syntax, a call to `while` may look like this:
 
 ```firefly
-work(f: Int => Int, g: String => String, initial: Int = 0): String {
-    g("" + f(initial))
+while {array.size() < 5} {
+    array.push("X")
 }
 ```
 
-This function may be called with two trailling lambda arguments, like this:
+The code above will push a string to an array while the size of the array is less than 5.
+
+This syntax for trailing anonymous function arguments allows the use of `if` and `while` to resemble constructs in languages such as C and JavaScript, where these constructs are built-in keywords rather than functions.
+
+# Trailing Colon Function Argument
+
+Firefly has a variation of the trailing anonymous function argument syntax. The very last anonymous function argument may be written after a colon, without curly braces. The purpose of this syntax is to avoid aditional indentation.
+
+The example below calls `if` with a trailing colon function argument:
 
 ```firefly
-work(initial = 3) {i => 
-    i + 1
-} {s => 
-    "*" + s + "*"
+safeFactorial(n: Int, acc: Int = 1): Option[Int] {
+    if(n >= 0): 
+    factorial(n)
 }
 ```
 
+In this example, the `if` function is called with the condition `n >= 0` and an anonymous function that computes `factorial(n)`. If `n` is negative, the `if` function returns `None` and so does `safeFactorial`. Using the colon syntax, the `safeFactorial` functions continues unindented otherwise.
+
 
 # Local functions
 
 Local functions are declared exactly like top-level functions but with the `function` keyword in front of the signature, like this:
 
+```firefly
+function square(n: Int): Int {
+    n * n
+}
+```
+
 The above local function definition is a statement, similar to local variables declared with `let`. The function name `square` will be in scope for the rest of the code block.
 
 Furthermore, local functions declared in sequence are in scope within each other's bodies, allowing them to be mutually recursive.
@@ -323,6 +342,7 @@ extend self[T]: Option[T] {
 }
 ```
 
+
 Methods can be defined for a more narrow targer type, like `flatten` below:
 
 ```firefly

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

@@ -137,9 +137,11 @@ if(printMeasurements_) {
 ff_compiler_Compiler.Compiler_printMeasurements(compiler_)
 };
 ff_core_Map.Map_each(resolvedDependencies_.packagePaths_, ((packagePair_, packagePath_) => {
-ff_core_Option.Option_each(ff_core_Map.Map_get(resolvedDependencies_.packages_, packagePair_, ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair), ((packageInfo_) => {
+for(let for_o = ff_core_Map.Map_get(resolvedDependencies_.packages_, packagePair_, ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair); for_o.Some;) {
+const packageInfo_ = for_o.value_;
 ff_compiler_Builder.processIncludes_(jsPathFile_, packagePath_, packageInfo_)
-}))
+break
+}
 }), ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair);
 return true
 }));
@@ -334,9 +336,11 @@ if(printMeasurements_) {
 (await ff_compiler_Compiler.Compiler_printMeasurements$(compiler_, $task))
 };
 (await ff_core_Map.Map_each$(resolvedDependencies_.packagePaths_, (async (packagePair_, packagePath_, $task) => {
-(await ff_core_Option.Option_each$(ff_core_Map.Map_get(resolvedDependencies_.packages_, packagePair_, ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair), (async (packageInfo_, $task) => {
+for(let for_o = ff_core_Map.Map_get(resolvedDependencies_.packages_, packagePair_, ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair); for_o.Some;) {
+const packageInfo_ = for_o.value_;
 (await ff_compiler_Builder.processIncludes_$(jsPathFile_, packagePath_, packageInfo_, $task))
-}), $task))
+break
+}
 }), ff_compiler_Syntax.ff_core_Ordering_Order$ff_compiler_Syntax_PackagePair, $task));
 return true
 }), $task));

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

@@ -171,11 +171,13 @@ return ff_compiler_ModuleCache.ModuleCache_cacheParsedModule(self_.cache_, self_
 const packageName_ = ff_compiler_Syntax.PackagePair_groupName(packagePair_, ":");
 return ff_compiler_Compiler.Compiler_measure(self_, "Parse", packagePair_, moduleName_, (() => {
 const code_ = ff_core_Option.Option_else(ff_core_Map.Map_get(self_.virtualFiles_, ff_core_Path.Path_absolute(path_), ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), (() => {
-ff_core_Option.Option_each(importedAt_, ((at_) => {
+for(let for_o = importedAt_; for_o.Some;) {
+const at_ = for_o.value_;
 if((!ff_core_Path.Path_exists(path_, false, false, false))) {
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(at_, ((("Imported module not found: " + packageName_) + "/") + moduleName_)), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
 }
-}));
+break
+};
 return ff_core_Path.Path_readText(path_)
 }));
 const completionAt_ = ((ff_compiler_LspHook.LspHook_isEnabled(self_.lspHook_) && self_.lspHook_.insertIdentifier_)
@@ -302,11 +304,13 @@ return (await ff_compiler_ModuleCache.ModuleCache_cacheParsedModule$(self_.cache
 const packageName_ = ff_compiler_Syntax.PackagePair_groupName(packagePair_, ":");
 return (await ff_compiler_Compiler.Compiler_measure$(self_, "Parse", packagePair_, moduleName_, (async ($task) => {
 const code_ = (await ff_core_Option.Option_else$(ff_core_Map.Map_get(self_.virtualFiles_, (await ff_core_Path.Path_absolute$(path_, $task)), ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), (async ($task) => {
-(await ff_core_Option.Option_each$(importedAt_, (async (at_, $task) => {
+for(let for_o = importedAt_; for_o.Some;) {
+const at_ = for_o.value_;
 if((!(await ff_core_Path.Path_exists$(path_, false, false, false, $task)))) {
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(at_, ((("Imported module not found: " + packageName_) + "/") + moduleName_)), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
 }
-}), $task));
+break
+};
 return (await ff_core_Path.Path_readText$(path_, $task))
 }), $task));
 const completionAt_ = ((ff_compiler_LspHook.LspHook_isEnabled(self_.lspHook_) && self_.lspHook_.insertIdentifier_)

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

@@ -203,7 +203,7 @@ const variants_ = _1;
 return ff_core_List.List_map(variants_, ((variant_) => {
 const variantName_ = ((modulePrefix_ + ".") + variant_.name_);
 const fields_ = [...declaration_.commonFields_, ...variant_.fields_];
-const strings_ = ((ff_core_List.List_size(fields_) === 0)
+const strings_ = ((fields_.length === 0)
 ? []
 : [ff_compiler_Syntax.EString(at_, "\"(\""), ...ff_core_List.List_separate(ff_core_List.List_map(fields_, ((field_) => {
 return ff_compiler_Deriver.Deriver_makeSimpleCall(self_, at_, "ff:core/Show.show", [ff_compiler_Syntax.EField(at_, false, ff_compiler_Syntax.EVariable(at_, "z"), field_.name_)], [])
@@ -605,7 +605,7 @@ const variants_ = _1;
 return ff_core_List.List_map(variants_, ((variant_) => {
 const variantName_ = ((modulePrefix_ + ".") + variant_.name_);
 const fields_ = [...declaration_.commonFields_, ...variant_.fields_];
-const strings_ = ((ff_core_List.List_size(fields_) === 0)
+const strings_ = ((fields_.length === 0)
 ? []
 : [ff_compiler_Syntax.EString(at_, "\"(\""), ...ff_core_List.List_separate(ff_core_List.List_map(fields_, ((field_) => {
 return ff_compiler_Deriver.Deriver_makeSimpleCall(self_, at_, "ff:core/Show.show", [ff_compiler_Syntax.EField(at_, false, ff_compiler_Syntax.EVariable(at_, "z"), field_.name_)], [])

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

@@ -213,8 +213,8 @@ const traitName_ = definition_.traitName_;
 const traitDefinition_ = ff_core_Option.Option_else(ff_core_Map.Map_get(environment_.traits_, traitName_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), (() => {
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(definition_.at_, ("No such trait: " + traitName_)), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
 }));
-if((ff_core_List.List_size(traitDefinition_.generics_) !== ff_core_List.List_size(definition_.typeArguments_))) {
-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)})
+if((traitDefinition_.generics_.length !== definition_.typeArguments_.length)) {
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(definition_.at_, ((((("Wrong number of type arguments for " + traitName_) + ", expected ") + (traitDefinition_.generics_.length - 1)) + ", got ") + (definition_.typeArguments_.length - 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);
 for(let for_i = 0, for_a = traitDefinition_.methods_, for_l = for_a.length; for_i < for_l; for_i++) {
@@ -252,11 +252,11 @@ 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_);
-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++) {
+for(let for_i = Math.max(parameters_.length, 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)})
 };
-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++) {
+for(let for_i = Math.max(instanceFunction_.signature_.parameters_.length, 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)})
 };
@@ -353,7 +353,7 @@ return ff_compiler_Environment.Environment(_c.modulePrefix_, ff_core_Map.Map_add
 const parameterTypes_ = ff_core_List.List_map(parameters_, ((_w1) => {
 return _w1.second_.signature_.returnType_
 }));
-const functionType_ = ff_compiler_Syntax.TConstructor(definition_.at_, ("Function$" + ff_core_List.List_size(parameterTypes_)), [definition_.signature_.effect_, ...parameterTypes_, definition_.signature_.returnType_]);
+const functionType_ = ff_compiler_Syntax.TConstructor(definition_.at_, ("Function$" + parameterTypes_.length), [definition_.signature_.effect_, ...parameterTypes_, definition_.signature_.returnType_]);
 const instances_ = ff_compiler_Inference.constraintsToInstances_(definition_.signature_.constraints_);
 return ff_compiler_Unification.Unification_withLocalInstances(self_.unification_, instances_, (() => {
 {
@@ -424,7 +424,7 @@ const parameterTypes_ = ff_core_List.List_map(case_.patterns_, ((_w1) => {
 return ff_compiler_Unification.Unification_freshUnificationVariable(self_.unification_, _w1.at_)
 }));
 const returnType_ = ff_compiler_Unification.Unification_freshUnificationVariable(self_.unification_, case_.at_);
-const functionType_ = ff_compiler_Syntax.TConstructor(case_.at_, ("Function$" + ff_core_List.List_size(case_.patterns_)), [environment_.effect_, ...parameterTypes_, returnType_]);
+const functionType_ = ff_compiler_Syntax.TConstructor(case_.at_, ("Function$" + case_.patterns_.length), [environment_.effect_, ...parameterTypes_, returnType_]);
 ff_compiler_Unification.Unification_unify(self_.unification_, case_.at_, expected_, functionType_);
 const environment1_ = ff_core_List.List_foldLeft(ff_core_List.List_zip(parameterTypes_, case_.patterns_), environment_, ((_1, _2) => {
 {
@@ -608,8 +608,8 @@ const instantiated_ = ff_core_Option.Option_else(ff_compiler_Inference.Inference
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(at_, ("No such variant: " + name_)), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
 }));
 ff_compiler_Unification.Unification_unify(self_.unification_, at_, expected_, instantiated_.scheme_.signature_.returnType_);
-if(((ff_core_List.List_size(patterns_) !== ff_core_List.List_size(instantiated_.scheme_.signature_.parameters_)) && (!ff_compiler_LspHook.LspHook_isEnabled(self_.lspHook_)))) {
-throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(at_, (((("Wrong number of subpatterns, expected " + ff_core_List.List_size(instantiated_.scheme_.signature_.parameters_)) + ", got ") + ff_core_List.List_size(patterns_)) + ".")), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
+if(((patterns_.length !== instantiated_.scheme_.signature_.parameters_.length) && (!ff_compiler_LspHook.LspHook_isEnabled(self_.lspHook_)))) {
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(at_, (((("Wrong number of subpatterns, expected " + instantiated_.scheme_.signature_.parameters_.length) + ", got ") + patterns_.length) + ".")), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
 };
 return ff_core_List.List_foldLeft(ff_core_List.List_map(ff_core_List.List_zip(patterns_, instantiated_.scheme_.signature_.parameters_), ((_1) => {
 {
@@ -669,9 +669,11 @@ if(_1.EField) {
 const e_ = _1;
 const recordType_ = ff_compiler_Unification.Unification_freshUnificationVariable(self_.unification_, e_.at_);
 if(ff_compiler_LspHook.LspHook_isAt(self_.lspHook_, term_.at_)) {
-ff_core_Option.Option_each(hookRecordTypeBox_, ((_w1) => {
+for(let for_o = hookRecordTypeBox_; for_o.Some;) {
+const _w1 = for_o.value_;
 _w1.value_ = ff_core_Option.Some(recordType_)
-}))
+break
+}
 };
 const record_ = ff_compiler_Inference.Inference_inferTerm(self_, environment_, recordType_, e_.record_);
 {
@@ -737,7 +739,7 @@ if((!instantiated_.scheme_.isVariable_)) {
 const signature_ = (((_c) => {
 return ff_compiler_Syntax.Signature(_c.at_, _c.name_, _c.member_, _c.generics_, _c.constraints_, ff_core_List.List_dropFirst(instantiated_.scheme_.signature_.parameters_, 1), _c.returnType_, _c.effect_)
 }))(instantiated_.scheme_.signature_);
-ff_compiler_Unification.Unification_unify(self_.unification_, e_.at_, recordType_, ff_core_List.List_grab(instantiated_.scheme_.signature_.parameters_, 0).valueType_);
+ff_compiler_Unification.Unification_unify(self_.unification_, e_.at_, recordType_, (instantiated_.scheme_.signature_.parameters_[0] ?? ff_core_List.internalGrab_(instantiated_.scheme_.signature_.parameters_, 0)).valueType_);
 return ff_compiler_Inference.Inference_inferEtaExpansion(self_, environment_, expected_, e_.at_, signature_, term_)
 }
 }
@@ -1201,9 +1203,11 @@ if(_1.EField) {
 const f_ = _1;
 const recordType_ = ff_compiler_Unification.Unification_freshUnificationVariable(self_.unification_, f_.at_);
 if(ff_compiler_LspHook.LspHook_isAt(self_.lspHook_, term_.at_)) {
-ff_core_Option.Option_each(hookRecordTypeBox_, ((_w1) => {
+for(let for_o = hookRecordTypeBox_; for_o.Some;) {
+const _w1 = for_o.value_;
 _w1.value_ = ff_core_Option.Some(recordType_)
-}))
+break
+}
 };
 const record_ = ff_compiler_Inference.Inference_inferTerm(self_, environment_, recordType_, f_.record_);
 const e2_ = (((_c) => {
@@ -1497,15 +1501,17 @@ const effect_ = ff_compiler_Unification.Unification_freshUnificationVariable(sel
 const argumentTypes_ = ff_core_List.List_map(e_.arguments_, ((_w1) => {
 return ff_compiler_Unification.Unification_freshUnificationVariable(self_.unification_, _w1.at_)
 }));
-const functionType_ = ff_compiler_Syntax.TConstructor(e_.at_, ("Function$" + ff_core_List.List_size(e_.arguments_)), [effect_, ...argumentTypes_, expected_]);
+const functionType_ = ff_compiler_Syntax.TConstructor(e_.at_, ("Function$" + e_.arguments_.length), [effect_, ...argumentTypes_, expected_]);
 const function_ = ff_compiler_Inference.Inference_inferTerm(self_, environment_, functionType_, call_.function_);
 const arguments_ = ff_core_List.List_map(ff_core_List.List_zip(e_.arguments_, argumentTypes_), ((_1) => {
 {
 const argument_ = _1.first_;
 const t_ = _1.second_;
-ff_core_Option.Option_each(argument_.name_, ((name_) => {
+for(let for_o = argument_.name_; for_o.Some;) {
+const name_ = for_o.value_;
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(argument_.at_, ("Named argument not allowed here: " + name_)), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
-}));
+break
+};
 {
 const _1 = argument_;
 {
@@ -1516,9 +1522,11 @@ return ff_compiler_Syntax.Argument(_c.at_, _c.name_, ff_compiler_Inference.Infer
 return
 }
 }));
-ff_core_Option.Option_each(ff_core_List.List_first(e_.typeArguments_), ((typeArgument_) => {
+for(let for_o = ff_core_List.List_first(e_.typeArguments_); for_o.Some;) {
+const typeArgument_ = for_o.value_;
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(typeArgument_.at_, "Type arguments not allowed here"), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
-}));
+break
+};
 ff_compiler_Unification.Unification_affect(self_.unification_, term_.at_, effect_, environment_.effect_);
 {
 const _1 = e_;
@@ -1881,11 +1889,13 @@ return ff_core_Option.Option_contains(_w1.name_, p_.name_, ff_core_Equal.ff_core
 {
 const at_ = _1.at_;
 const e_ = _1.value_;
-ff_core_Option.Option_each(ff_core_Array.Array_indexWhere(remainingArguments_, ((_w1) => {
+for(let for_o = ff_core_Array.Array_indexWhere(remainingArguments_, ((_w1) => {
 return ff_core_Option.Option_contains(_w1.name_, p_.name_, ff_core_Equal.ff_core_Equal_Equal$ff_core_String_String)
-})), ((_w1) => {
+})); for_o.Some;) {
+const _w1 = for_o.value_;
 ff_core_Array.Array_delete(remainingArguments_, _w1, 1)
-}));
+break
+};
 const e2_ = ff_compiler_Inference.Inference_inferTerm(self_, environment_, t_, e_);
 return ff_compiler_Syntax.Argument(at_, ff_core_Option.Some(p_.name_), e2_)
 }
@@ -1962,9 +1972,9 @@ return (_w1 === "Q$")
 })))
 ? [ff_compiler_Unification.Unification_freshUnificationVariable(self_.unification_, at_), ...typeArguments_]
 : typeArguments_);
-if(((ff_core_List.List_size(scheme_.signature_.generics_) !== ff_core_List.List_size(newTypeArguments_)) && (!ff_compiler_LspHook.LspHook_isEnabled(self_.lspHook_)))) {
-const extra_ = (ff_core_List.List_size(newTypeArguments_) - ff_core_List.List_size(typeArguments_));
-throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(at_, ((((("Wrong number of type arguments for " + symbol_) + ", expected ") + (ff_core_List.List_size(scheme_.signature_.generics_) - extra_)) + ", got ") + (ff_core_List.List_size(newTypeArguments_) - extra_))), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
+if(((scheme_.signature_.generics_.length !== newTypeArguments_.length) && (!ff_compiler_LspHook.LspHook_isEnabled(self_.lspHook_)))) {
+const extra_ = (newTypeArguments_.length - typeArguments_.length);
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(at_, ((((("Wrong number of type arguments for " + symbol_) + ", expected ") + (scheme_.signature_.generics_.length - extra_)) + ", got ") + (newTypeArguments_.length - extra_))), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
 };
 return ff_core_List.List_zip(scheme_.signature_.generics_, newTypeArguments_)
 })()
@@ -2065,8 +2075,8 @@ const traitName_ = definition_.traitName_;
 const traitDefinition_ = ff_core_Option.Option_else(ff_core_Map.Map_get(environment_.traits_, traitName_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), (() => {
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(definition_.at_, ("No such trait: " + traitName_)), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
 }));
-if((ff_core_List.List_size(traitDefinition_.generics_) !== ff_core_List.List_size(definition_.typeArguments_))) {
-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)})
+if((traitDefinition_.generics_.length !== definition_.typeArguments_.length)) {
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(definition_.at_, ((((("Wrong number of type arguments for " + traitName_) + ", expected ") + (traitDefinition_.generics_.length - 1)) + ", got ") + (definition_.typeArguments_.length - 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);
 for(let for_i = 0, for_a = traitDefinition_.methods_, for_l = for_a.length; for_i < for_l; for_i++) {
@@ -2104,11 +2114,11 @@ 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_);
-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++) {
+for(let for_i = Math.max(parameters_.length, 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)})
 };
-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++) {
+for(let for_i = Math.max(instanceFunction_.signature_.parameters_.length, 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)})
 };
@@ -2205,7 +2215,7 @@ return ff_compiler_Environment.Environment(_c.modulePrefix_, ff_core_Map.Map_add
 const parameterTypes_ = ff_core_List.List_map(parameters_, ((_w1) => {
 return _w1.second_.signature_.returnType_
 }));
-const functionType_ = ff_compiler_Syntax.TConstructor(definition_.at_, ("Function$" + ff_core_List.List_size(parameterTypes_)), [definition_.signature_.effect_, ...parameterTypes_, definition_.signature_.returnType_]);
+const functionType_ = ff_compiler_Syntax.TConstructor(definition_.at_, ("Function$" + parameterTypes_.length), [definition_.signature_.effect_, ...parameterTypes_, definition_.signature_.returnType_]);
 const instances_ = ff_compiler_Inference.constraintsToInstances_(definition_.signature_.constraints_);
 return ff_compiler_Unification.Unification_withLocalInstances(self_.unification_, instances_, (() => {
 {
@@ -2276,7 +2286,7 @@ const parameterTypes_ = ff_core_List.List_map(case_.patterns_, ((_w1) => {
 return ff_compiler_Unification.Unification_freshUnificationVariable(self_.unification_, _w1.at_)
 }));
 const returnType_ = ff_compiler_Unification.Unification_freshUnificationVariable(self_.unification_, case_.at_);
-const functionType_ = ff_compiler_Syntax.TConstructor(case_.at_, ("Function$" + ff_core_List.List_size(case_.patterns_)), [environment_.effect_, ...parameterTypes_, returnType_]);
+const functionType_ = ff_compiler_Syntax.TConstructor(case_.at_, ("Function$" + case_.patterns_.length), [environment_.effect_, ...parameterTypes_, returnType_]);
 ff_compiler_Unification.Unification_unify(self_.unification_, case_.at_, expected_, functionType_);
 const environment1_ = ff_core_List.List_foldLeft(ff_core_List.List_zip(parameterTypes_, case_.patterns_), environment_, ((_1, _2) => {
 {
@@ -2460,8 +2470,8 @@ const instantiated_ = ff_core_Option.Option_else(ff_compiler_Inference.Inference
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(at_, ("No such variant: " + name_)), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
 }));
 ff_compiler_Unification.Unification_unify(self_.unification_, at_, expected_, instantiated_.scheme_.signature_.returnType_);
-if(((ff_core_List.List_size(patterns_) !== ff_core_List.List_size(instantiated_.scheme_.signature_.parameters_)) && (!ff_compiler_LspHook.LspHook_isEnabled(self_.lspHook_)))) {
-throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(at_, (((("Wrong number of subpatterns, expected " + ff_core_List.List_size(instantiated_.scheme_.signature_.parameters_)) + ", got ") + ff_core_List.List_size(patterns_)) + ".")), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
+if(((patterns_.length !== instantiated_.scheme_.signature_.parameters_.length) && (!ff_compiler_LspHook.LspHook_isEnabled(self_.lspHook_)))) {
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(at_, (((("Wrong number of subpatterns, expected " + instantiated_.scheme_.signature_.parameters_.length) + ", got ") + patterns_.length) + ".")), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
 };
 return ff_core_List.List_foldLeft(ff_core_List.List_map(ff_core_List.List_zip(patterns_, instantiated_.scheme_.signature_.parameters_), ((_1) => {
 {
@@ -2521,9 +2531,11 @@ if(_1.EField) {
 const e_ = _1;
 const recordType_ = ff_compiler_Unification.Unification_freshUnificationVariable(self_.unification_, e_.at_);
 if(ff_compiler_LspHook.LspHook_isAt(self_.lspHook_, term_.at_)) {
-ff_core_Option.Option_each(hookRecordTypeBox_, ((_w1) => {
+for(let for_o = hookRecordTypeBox_; for_o.Some;) {
+const _w1 = for_o.value_;
 _w1.value_ = ff_core_Option.Some(recordType_)
-}))
+break
+}
 };
 const record_ = ff_compiler_Inference.Inference_inferTerm(self_, environment_, recordType_, e_.record_);
 {
@@ -2589,7 +2601,7 @@ if((!instantiated_.scheme_.isVariable_)) {
 const signature_ = (((_c) => {
 return ff_compiler_Syntax.Signature(_c.at_, _c.name_, _c.member_, _c.generics_, _c.constraints_, ff_core_List.List_dropFirst(instantiated_.scheme_.signature_.parameters_, 1), _c.returnType_, _c.effect_)
 }))(instantiated_.scheme_.signature_);
-ff_compiler_Unification.Unification_unify(self_.unification_, e_.at_, recordType_, ff_core_List.List_grab(instantiated_.scheme_.signature_.parameters_, 0).valueType_);
+ff_compiler_Unification.Unification_unify(self_.unification_, e_.at_, recordType_, (instantiated_.scheme_.signature_.parameters_[0] ?? ff_core_List.internalGrab_(instantiated_.scheme_.signature_.parameters_, 0)).valueType_);
 return ff_compiler_Inference.Inference_inferEtaExpansion(self_, environment_, expected_, e_.at_, signature_, term_)
 }
 }
@@ -3053,9 +3065,11 @@ if(_1.EField) {
 const f_ = _1;
 const recordType_ = ff_compiler_Unification.Unification_freshUnificationVariable(self_.unification_, f_.at_);
 if(ff_compiler_LspHook.LspHook_isAt(self_.lspHook_, term_.at_)) {
-ff_core_Option.Option_each(hookRecordTypeBox_, ((_w1) => {
+for(let for_o = hookRecordTypeBox_; for_o.Some;) {
+const _w1 = for_o.value_;
 _w1.value_ = ff_core_Option.Some(recordType_)
-}))
+break
+}
 };
 const record_ = ff_compiler_Inference.Inference_inferTerm(self_, environment_, recordType_, f_.record_);
 const e2_ = (((_c) => {
@@ -3349,15 +3363,17 @@ const effect_ = ff_compiler_Unification.Unification_freshUnificationVariable(sel
 const argumentTypes_ = ff_core_List.List_map(e_.arguments_, ((_w1) => {
 return ff_compiler_Unification.Unification_freshUnificationVariable(self_.unification_, _w1.at_)
 }));
-const functionType_ = ff_compiler_Syntax.TConstructor(e_.at_, ("Function$" + ff_core_List.List_size(e_.arguments_)), [effect_, ...argumentTypes_, expected_]);
+const functionType_ = ff_compiler_Syntax.TConstructor(e_.at_, ("Function$" + e_.arguments_.length), [effect_, ...argumentTypes_, expected_]);
 const function_ = ff_compiler_Inference.Inference_inferTerm(self_, environment_, functionType_, call_.function_);
 const arguments_ = ff_core_List.List_map(ff_core_List.List_zip(e_.arguments_, argumentTypes_), ((_1) => {
 {
 const argument_ = _1.first_;
 const t_ = _1.second_;
-ff_core_Option.Option_each(argument_.name_, ((name_) => {
+for(let for_o = argument_.name_; for_o.Some;) {
+const name_ = for_o.value_;
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(argument_.at_, ("Named argument not allowed here: " + name_)), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
-}));
+break
+};
 {
 const _1 = argument_;
 {
@@ -3368,9 +3384,11 @@ return ff_compiler_Syntax.Argument(_c.at_, _c.name_, ff_compiler_Inference.Infer
 return
 }
 }));
-ff_core_Option.Option_each(ff_core_List.List_first(e_.typeArguments_), ((typeArgument_) => {
+for(let for_o = ff_core_List.List_first(e_.typeArguments_); for_o.Some;) {
+const typeArgument_ = for_o.value_;
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(typeArgument_.at_, "Type arguments not allowed here"), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
-}));
+break
+};
 ff_compiler_Unification.Unification_affect(self_.unification_, term_.at_, effect_, environment_.effect_);
 {
 const _1 = e_;
@@ -3733,11 +3751,13 @@ return ff_core_Option.Option_contains(_w1.name_, p_.name_, ff_core_Equal.ff_core
 {
 const at_ = _1.at_;
 const e_ = _1.value_;
-ff_core_Option.Option_each(ff_core_Array.Array_indexWhere(remainingArguments_, ((_w1) => {
+for(let for_o = ff_core_Array.Array_indexWhere(remainingArguments_, ((_w1) => {
 return ff_core_Option.Option_contains(_w1.name_, p_.name_, ff_core_Equal.ff_core_Equal_Equal$ff_core_String_String)
-})), ((_w1) => {
+})); for_o.Some;) {
+const _w1 = for_o.value_;
 ff_core_Array.Array_delete(remainingArguments_, _w1, 1)
-}));
+break
+};
 const e2_ = ff_compiler_Inference.Inference_inferTerm(self_, environment_, t_, e_);
 return ff_compiler_Syntax.Argument(at_, ff_core_Option.Some(p_.name_), e2_)
 }
@@ -3814,9 +3834,9 @@ return (_w1 === "Q$")
 })))
 ? [ff_compiler_Unification.Unification_freshUnificationVariable(self_.unification_, at_), ...typeArguments_]
 : typeArguments_);
-if(((ff_core_List.List_size(scheme_.signature_.generics_) !== ff_core_List.List_size(newTypeArguments_)) && (!ff_compiler_LspHook.LspHook_isEnabled(self_.lspHook_)))) {
-const extra_ = (ff_core_List.List_size(newTypeArguments_) - ff_core_List.List_size(typeArguments_));
-throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(at_, ((((("Wrong number of type arguments for " + symbol_) + ", expected ") + (ff_core_List.List_size(scheme_.signature_.generics_) - extra_)) + ", got ") + (ff_core_List.List_size(newTypeArguments_) - extra_))), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
+if(((scheme_.signature_.generics_.length !== newTypeArguments_.length) && (!ff_compiler_LspHook.LspHook_isEnabled(self_.lspHook_)))) {
+const extra_ = (newTypeArguments_.length - typeArguments_.length);
+throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(at_, ((((("Wrong number of type arguments for " + symbol_) + ", expected ") + (scheme_.signature_.generics_.length - extra_)) + ", got ") + (newTypeArguments_.length - extra_))), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
 };
 return ff_core_List.List_zip(scheme_.signature_.generics_, newTypeArguments_)
 })()