firefly-compiler 0.5.14 → 0.5.15

package/compiler/JsEmitter.ff

@@ -692,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/Inference.mjs

@@ -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_);
 {
@@ -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) => {
@@ -1503,9 +1507,11 @@ const arguments_ = ff_core_List.List_map(ff_core_List.List_zip(e_.arguments_, ar
 {
 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_)
 }
@@ -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_);
 {
@@ -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) => {
@@ -3355,9 +3369,11 @@ const arguments_ = ff_core_List.List_map(ff_core_List.List_zip(e_.arguments_, ar
 {
 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_)
 }

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

@@ -1971,6 +1971,20 @@ return ff_core_Option.Some((("while(" + ff_compiler_JsEmitter.JsEmitter_emitComm
 }
 }
 }
+if(_1 === "ff:core/Option.Option_each") {
+const _guard1 = arguments_;
+if(_guard1.length === 2 && _guard1[1].ELambda && _guard1[1].lambda_.cases_.length === 1 && _guard1[1].lambda_.cases_[0].patterns_.length === 1 && _guard1[1].lambda_.cases_[0].patterns_[0].PVariable && _guard1[1].lambda_.cases_[0].guards_.length === 0) {
+const list_ = _guard1[0];
+const name_ = _guard1[1].lambda_.cases_[0].patterns_[0].name_;
+const body_ = _guard1[1].lambda_.cases_[0].body_;
+return ff_core_Option.Some(((((("for(let for_o = " + ff_compiler_JsEmitter.JsEmitter_emitTerm(self_, list_, async_)) + "; for_o.Some;) {\n") + ff_core_Option.Option_else(ff_core_Option.Option_map(name_, ((_w1) => {
+return (("const " + ff_compiler_JsEmitter.escapeKeyword_(_w1)) + " = for_o.value_;\n")
+})), (() => {
+return ""
+}))) + ff_compiler_JsEmitter.JsEmitter_emitStatements(self_, body_, last_, async_)) + "\nbreak\n}"))
+return
+}
+}
 if(_1 === "ff:core/List.List_each") {
 const _guard2 = arguments_;
 if(_guard2.length === 2 && _guard2[0].ECall && _guard2[0].target_.StaticCall && _guard2[0].arguments_.length === 2 && _guard2[1].ELambda && _guard2[1].lambda_.cases_.length === 1 && _guard2[1].lambda_.cases_[0].patterns_.length === 1 && _guard2[1].lambda_.cases_[0].patterns_[0].PVariable && _guard2[1].lambda_.cases_[0].guards_.length === 0) {
@@ -3944,6 +3958,20 @@ return ff_core_Option.Some((("while(" + (await ff_compiler_JsEmitter.JsEmitter_e
 }
 }
 }
+if(_1 === "ff:core/Option.Option_each") {
+const _guard1 = arguments_;
+if(_guard1.length === 2 && _guard1[1].ELambda && _guard1[1].lambda_.cases_.length === 1 && _guard1[1].lambda_.cases_[0].patterns_.length === 1 && _guard1[1].lambda_.cases_[0].patterns_[0].PVariable && _guard1[1].lambda_.cases_[0].guards_.length === 0) {
+const list_ = _guard1[0];
+const name_ = _guard1[1].lambda_.cases_[0].patterns_[0].name_;
+const body_ = _guard1[1].lambda_.cases_[0].body_;
+return ff_core_Option.Some(((((("for(let for_o = " + (await ff_compiler_JsEmitter.JsEmitter_emitTerm$(self_, list_, async_, $task))) + "; for_o.Some;) {\n") + ff_core_Option.Option_else(ff_core_Option.Option_map(name_, ((_w1) => {
+return (("const " + ff_compiler_JsEmitter.escapeKeyword_(_w1)) + " = for_o.value_;\n")
+})), (() => {
+return ""
+}))) + (await ff_compiler_JsEmitter.JsEmitter_emitStatements$(self_, body_, last_, async_, $task))) + "\nbreak\n}"))
+return
+}
+}
 if(_1 === "ff:core/List.List_each") {
 const _guard2 = arguments_;
 if(_guard2.length === 2 && _guard2[0].ECall && _guard2[0].target_.StaticCall && _guard2[0].arguments_.length === 2 && _guard2[1].ELambda && _guard2[1].lambda_.cases_.length === 1 && _guard2[1].lambda_.cases_[0].patterns_.length === 1 && _guard2[1].lambda_.cases_[0].patterns_[0].PVariable && _guard2[1].lambda_.cases_[0].guards_.length === 0) {

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

@@ -324,9 +324,11 @@ return ff_compiler_Parser.Parser_skip(self_, kind_)
 
 export function Parser_parseModuleWithoutPackageInfo(self_) {
 const moduleWithPackageInfo_ = ff_compiler_Parser.Parser_parseModuleWithPackageInfo(self_);
-ff_core_Option.Option_each(moduleWithPackageInfo_.packageInfo_, ((info_) => {
+for(let for_o = moduleWithPackageInfo_.packageInfo_; for_o.Some;) {
+const info_ = for_o.value_;
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(info_.package_.at_, "Package and dependencies already declared in package.ff"), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
-}));
+break
+};
 return moduleWithPackageInfo_.module_
 }
 
@@ -1571,11 +1573,13 @@ const member_ = ff_compiler_Syntax.EString(ff_compiler_Token.Token_at(token_), (
 : (("\"" + ff_compiler_Token.Token_raw(token_)) + "\"")));
 if(ff_compiler_Token.Token_rawIs(ff_compiler_Parser.Parser_current(self_), "(")) {
 const arguments_ = ff_compiler_Parser.Parser_parseFunctionArguments(self_, record_.at_, false);
-ff_core_Option.Option_each(ff_core_List.List_find(arguments_.first_, ((_w1) => {
+for(let for_o = ff_core_List.List_find(arguments_.first_, ((_w1) => {
 return (!ff_core_Option.Option_isEmpty(_w1.name_))
-})), ((argument_) => {
+})); for_o.Some;) {
+const argument_ = for_o.value_;
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(argument_.at_, "Unexpected named argument"), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
-}));
+break
+};
 const effect_ = ff_compiler_Parser.Parser_freshUnificationVariable(self_, record_.at_);
 const target_ = ff_compiler_Syntax.DynamicCall(ff_compiler_Syntax.EField(ff_compiler_Token.Token_at(token_), false, record_, ("call" + arguments_.first_.length)), false);
 return ff_compiler_Syntax.ECall(record_.at_, target_, effect_, [], [ff_compiler_Syntax.Argument(member_.at_, ff_core_Option.None(), member_), ...arguments_.first_], [])
@@ -1906,9 +1910,11 @@ return ff_compiler_Parser.Parser_skip(self_, kind_)
 
 export async function Parser_parseModuleWithoutPackageInfo$(self_, $task) {
 const moduleWithPackageInfo_ = ff_compiler_Parser.Parser_parseModuleWithPackageInfo(self_);
-ff_core_Option.Option_each(moduleWithPackageInfo_.packageInfo_, ((info_) => {
+for(let for_o = moduleWithPackageInfo_.packageInfo_; for_o.Some;) {
+const info_ = for_o.value_;
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(info_.package_.at_, "Package and dependencies already declared in package.ff"), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
-}));
+break
+};
 return moduleWithPackageInfo_.module_
 }
 
@@ -3153,11 +3159,13 @@ const member_ = ff_compiler_Syntax.EString(ff_compiler_Token.Token_at(token_), (
 : (("\"" + ff_compiler_Token.Token_raw(token_)) + "\"")));
 if(ff_compiler_Token.Token_rawIs(ff_compiler_Parser.Parser_current(self_), "(")) {
 const arguments_ = ff_compiler_Parser.Parser_parseFunctionArguments(self_, record_.at_, false);
-ff_core_Option.Option_each(ff_core_List.List_find(arguments_.first_, ((_w1) => {
+for(let for_o = ff_core_List.List_find(arguments_.first_, ((_w1) => {
 return (!ff_core_Option.Option_isEmpty(_w1.name_))
-})), ((argument_) => {
+})); for_o.Some;) {
+const argument_ = for_o.value_;
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(argument_.at_, "Unexpected named argument"), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
-}));
+break
+};
 const effect_ = ff_compiler_Parser.Parser_freshUnificationVariable(self_, record_.at_);
 const target_ = ff_compiler_Syntax.DynamicCall(ff_compiler_Syntax.EField(ff_compiler_Token.Token_at(token_), false, record_, ("call" + arguments_.first_.length)), false);
 return ff_compiler_Syntax.ECall(record_.at_, target_, effect_, [], [ff_compiler_Syntax.Argument(member_.at_, ff_core_Option.None(), member_), ...arguments_.first_], [])

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

@@ -867,11 +867,13 @@ return ff_compiler_Syntax.Signature(_c.at_, _c.name_, _c.member_, ["Q$", ...sign
 : (((_c) => {
 return ff_compiler_Syntax.Signature(_c.at_, _c.name_, _c.member_, _c.generics_, _c.constraints_, _c.parameters_, _c.returnType_, ff_compiler_Resolver.Resolver_freshUnificationVariable(self_, signature_.at_))
 }))(signature_));
-ff_core_Option.Option_each(ff_core_List.List_find(newSignature_.generics_, ((name_) => {
+for(let for_o = ff_core_List.List_find(newSignature_.generics_, ((name_) => {
 return ff_core_Set.Set_contains(self_.typeParameters_, name_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String)
-})), ((name_) => {
+})); for_o.Some;) {
+const name_ = for_o.value_;
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(signature_.at_, (("Type parameter " + name_) + " is already in scope")), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
-}));
+break
+};
 const self2_ = ff_compiler_Resolver.Resolver_withSignature(self_, newSignature_);
 {
 const _1 = newSignature_;
@@ -1810,11 +1812,13 @@ return ff_compiler_Syntax.Signature(_c.at_, _c.name_, _c.member_, ["Q$", ...sign
 : (((_c) => {
 return ff_compiler_Syntax.Signature(_c.at_, _c.name_, _c.member_, _c.generics_, _c.constraints_, _c.parameters_, _c.returnType_, ff_compiler_Resolver.Resolver_freshUnificationVariable(self_, signature_.at_))
 }))(signature_));
-ff_core_Option.Option_each(ff_core_List.List_find(newSignature_.generics_, ((name_) => {
+for(let for_o = ff_core_List.List_find(newSignature_.generics_, ((name_) => {
 return ff_core_Set.Set_contains(self_.typeParameters_, name_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String)
-})), ((name_) => {
+})); for_o.Some;) {
+const name_ = for_o.value_;
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(signature_.at_, (("Type parameter " + name_) + " is already in scope")), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
-}));
+break
+};
 const self2_ = ff_compiler_Resolver.Resolver_withSignature(self_, newSignature_);
 {
 const _1 = newSignature_;

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

@@ -469,7 +469,8 @@ const t_ = ff_compiler_Unification.Unification_substitute(self_, type_);
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(at_, ((("Infinite type: " + ff_compiler_Syntax.Type_show(ff_compiler_Syntax.TVariable(at_, index_), [t_])) + " = ") + ff_compiler_Syntax.Type_show(t_, []))), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
 };
 self_.substitution_ = ff_core_Map.Map_add(self_.substitution_, index_, type_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_Int_Int);
-ff_core_Option.Option_each(ff_core_Map.Map_get(self_.constraints_, index_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_Int_Int), ((map_) => {
+for(let for_o = ff_core_Map.Map_get(self_.constraints_, index_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_Int_Int); for_o.Some;) {
+const map_ = for_o.value_;
 self_.constraints_ = ff_core_Map.Map_remove(self_.constraints_, index_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_Int_Int);
 ff_core_List.List_each(ff_core_Map.Map_pairs(map_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), ((_1) => {
 {
@@ -480,13 +481,16 @@ ff_compiler_Unification.Unification_constrain(self_, at2_, type_, name_, generic
 return
 }
 }))
-}));
-ff_core_Option.Option_each(ff_core_Map.Map_get(self_.affects_, index_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_Int_Int), ((affected_) => {
+break
+};
+for(let for_o = ff_core_Map.Map_get(self_.affects_, index_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_Int_Int); for_o.Some;) {
+const affected_ = for_o.value_;
 ff_core_Map.Map_remove(self_.affects_, index_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_Int_Int);
 ff_core_Set.Set_each(affected_, ((i_) => {
 ff_compiler_Unification.Unification_affect(self_, at_, type_, ff_compiler_Syntax.TVariable(at_, i_))
 }), ff_core_Ordering.ff_core_Ordering_Order$ff_core_Int_Int)
-}))
+break
+}
 }
 
 export function Unification_affect(self_, at_, source_, target_) {
@@ -846,7 +850,8 @@ const t_ = ff_compiler_Unification.Unification_substitute(self_, type_);
 throw Object.assign(new Error(), {ffException: ff_core_Any.toAny_(ff_compiler_Syntax.CompileError(at_, ((("Infinite type: " + ff_compiler_Syntax.Type_show(ff_compiler_Syntax.TVariable(at_, index_), [t_])) + " = ") + ff_compiler_Syntax.Type_show(t_, []))), ff_compiler_Syntax.ff_core_Any_HasAnyTag$ff_compiler_Syntax_CompileError)})
 };
 self_.substitution_ = ff_core_Map.Map_add(self_.substitution_, index_, type_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_Int_Int);
-ff_core_Option.Option_each(ff_core_Map.Map_get(self_.constraints_, index_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_Int_Int), ((map_) => {
+for(let for_o = ff_core_Map.Map_get(self_.constraints_, index_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_Int_Int); for_o.Some;) {
+const map_ = for_o.value_;
 self_.constraints_ = ff_core_Map.Map_remove(self_.constraints_, index_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_Int_Int);
 ff_core_List.List_each(ff_core_Map.Map_pairs(map_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_String_String), ((_1) => {
 {
@@ -857,13 +862,16 @@ ff_compiler_Unification.Unification_constrain(self_, at2_, type_, name_, generic
 return
 }
 }))
-}));
-ff_core_Option.Option_each(ff_core_Map.Map_get(self_.affects_, index_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_Int_Int), ((affected_) => {
+break
+};
+for(let for_o = ff_core_Map.Map_get(self_.affects_, index_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_Int_Int); for_o.Some;) {
+const affected_ = for_o.value_;
 ff_core_Map.Map_remove(self_.affects_, index_, ff_core_Ordering.ff_core_Ordering_Order$ff_core_Int_Int);
 ff_core_Set.Set_each(affected_, ((i_) => {
 ff_compiler_Unification.Unification_affect(self_, at_, type_, ff_compiler_Syntax.TVariable(at_, i_))
 }), ff_core_Ordering.ff_core_Ordering_Order$ff_core_Int_Int)
-}))
+break
+}
 }
 
 export async function Unification_affect$(self_, at_, source_, target_, $task) {

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

@@ -136,9 +136,10 @@ const rules_ = ff_core_List.List_collect(lines_, ((line_) => {
 const columns_ = ff_core_List.List_filter(ff_core_String.String_split(ff_core_String.String_replace(line_, "\t", " "), 32), ((_w1) => {
 return (ff_core_String.String_size(_w1) !== 0)
 }));
-ff_core_Option.Option_each(defaultLocation_, ((_) => {
+for(let for_o = defaultLocation_; for_o.Some;) {
 ff_core_Core.panic_(("Unexpected rule after the * rule: " + line_))
-}));
+break
+};
 if((columns_.length !== 2)) {
 ff_core_Core.panic_(("Could not parse workspace rule: " + line_))
 };
@@ -200,9 +201,10 @@ const rules_ = ff_core_List.List_collect(lines_, ((line_) => {
 const columns_ = ff_core_List.List_filter(ff_core_String.String_split(ff_core_String.String_replace(line_, "\t", " "), 32), ((_w1) => {
 return (ff_core_String.String_size(_w1) !== 0)
 }));
-ff_core_Option.Option_each(defaultLocation_, ((_) => {
+for(let for_o = defaultLocation_; for_o.Some;) {
 ff_core_Core.panic_(("Unexpected rule after the * rule: " + line_))
-}));
+break
+};
 if((columns_.length !== 2)) {
 ff_core_Core.panic_(("Could not parse workspace rule: " + line_))
 };

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

@@ -466,9 +466,11 @@ export function List_collect(self_, body_) {
 let result_ = ff_core_Array.new_();
 for(let for_i = 0, for_a = self_, for_l = for_a.length; for_i < for_l; for_i++) {
 const x_ = for_a[for_i];
-ff_core_Option.Option_each(body_(x_), ((_w1) => {
+for(let for_o = body_(x_); for_o.Some;) {
+const _w1 = for_o.value_;
 result_.array.push(_w1)
-}))
+break
+}
 };
 return ff_core_Array.Array_drain(result_)
 }
@@ -830,9 +832,11 @@ export async function List_collect$(self_, body_, $task) {
 let result_ = ff_core_Array.new_();
 for(let for_i = 0, for_a = self_, for_l = for_a.length; for_i < for_l; for_i++) {
 const x_ = for_a[for_i];
-ff_core_Option.Option_each((await body_(x_, $task)), ((_w1) => {
+for(let for_o = (await body_(x_, $task)); for_o.Some;) {
+const _w1 = for_o.value_;
 result_.array.push(_w1)
-}))
+break
+}
 };
 return ff_core_Array.Array_drain(result_)
 }

package/package.json

@@ -4,7 +4,7 @@
     "description": "Firefly compiler",
     "author": "Firefly team",
     "license": "MIT",
-    "version": "0.5.14",
+    "version": "0.5.15",
     "repository": {
         "type": "git",
         "url": "https://github.com/Ahnfelt/firefly-boot"

package/vscode/package.json

@@ -4,7 +4,7 @@
     "description": "Firefly language support",
     "author": "Firefly team",
     "license": "MIT",
-    "version": "0.5.14",
+    "version": "0.5.15",
     "repository": {
         "type": "git",
         "url": "https://github.com/Ahnfelt/firefly-boot"