firefly-compiler 0.5.10 → 0.5.11

package/compiler/JsEmitter.ff

@@ -697,26 +697,10 @@ extend self: JsEmitter {
             | "ff:core/List.List_each" {arguments | [list, ELambda(_, Lambda(_, _, [
                 MatchCase(_, [PVariable(_, name)], [], body)
             ]))]} =>
-                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)
-                    | _ => 
-                        self.emitTerm(list, async)
-                } 
+                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" +
@@ -727,26 +711,10 @@ extend self: JsEmitter {
             | "ff:core/List.List_eachWhile" {arguments | [list, ELambda(_, Lambda(_, _, [
                 MatchCase(_, [PVariable(_, name)], [], ESequential(_, body, condition))
             ]))]} =>
-                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)
-                    | _ => 
-                        self.emitTerm(list, async)
-                } 
+                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" +
@@ -806,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/JsEmitter.mjs

@@ -1944,37 +1944,10 @@ if(_guard1.length === 2 && _guard1[1].ELambda && _guard1[1].lambda_.cases_.lengt
 const list_ = _guard1[0];
 const name_ = _guard1[1].lambda_.cases_[0].patterns_[0].name_;
 const body_ = _guard1[1].lambda_.cases_[0].body_;
-let start_ = "0";
-let end_ = "for_a.length";
-const listCode_ = (((_1) => {
-if(_1.ECall && _1.target_.StaticCall && _1.target_.name_ === "ff:core/List.List_dropFirst" && _1.arguments_.length === 2) {
-const a1_ = _1.arguments_[0];
-const a2_ = _1.arguments_[1];
-start_ = ff_compiler_JsEmitter.JsEmitter_emitTerm(self_, a2_.value_, async_);
-if((!ff_core_String.String_all(start_, ((_w1) => {
-return ff_core_Char.Char_isAsciiDigit(_w1)
-})))) {
-start_ = (("Math.max(" + start_) + ", 0)")
-};
-return ff_compiler_JsEmitter.JsEmitter_emitTerm(self_, a1_.value_, async_)
-}
-if(_1.ECall && _1.target_.StaticCall && _1.target_.name_ === "ff:core/List.List_dropLast" && _1.arguments_.length === 2) {
-const a1_ = _1.arguments_[0];
-const a2_ = _1.arguments_[1];
-const count_ = ff_compiler_JsEmitter.JsEmitter_emitTerm(self_, a2_.value_, async_);
-if((!ff_core_String.String_all(count_, ((_w1) => {
-return ff_core_Char.Char_isAsciiDigit(_w1)
-})))) {
-end_ = (((end_ + " - Math.max(") + count_) + ", 0)")
-} else {
-end_ = ((end_ + " - ") + count_)
-};
-return ff_compiler_JsEmitter.JsEmitter_emitTerm(self_, a1_.value_, async_)
-}
-{
-return ff_compiler_JsEmitter.JsEmitter_emitTerm(self_, list_, async_)
-}
-}))(list_);
+const fusion_ = ff_compiler_JsEmitter.JsEmitter_emitLightFusion(self_, list_, async_);
+const start_ = fusion_.second_.first_;
+const end_ = fusion_.second_.second_;
+const listCode_ = fusion_.first_;
 return ff_core_Option.Some(((((((((("for(let for_i = " + start_) + ", for_a = ") + listCode_) + ", for_l = ") + end_) + "; for_i < for_l; for_i++) {\n") + ff_core_Option.Option_else(ff_core_Option.Option_map(name_, ((_w1) => {
 return (("const " + ff_compiler_JsEmitter.escapeKeyword_(_w1)) + " = for_a[for_i];\n")
 })), (() => {
@@ -1990,37 +1963,10 @@ const list_ = _guard1[0];
 const name_ = _guard1[1].lambda_.cases_[0].patterns_[0].name_;
 const body_ = _guard1[1].lambda_.cases_[0].body_.before_;
 const condition_ = _guard1[1].lambda_.cases_[0].body_.after_;
-let start_ = "0";
-let end_ = "for_a.length";
-const listCode_ = (((_1) => {
-if(_1.ECall && _1.target_.StaticCall && _1.target_.name_ === "ff:core/List.List_dropFirst" && _1.arguments_.length === 2) {
-const a1_ = _1.arguments_[0];
-const a2_ = _1.arguments_[1];
-start_ = ff_compiler_JsEmitter.JsEmitter_emitTerm(self_, a2_.value_, async_);
-if((!ff_core_String.String_all(start_, ((_w1) => {
-return ff_core_Char.Char_isAsciiDigit(_w1)
-})))) {
-start_ = (("Math.max(" + start_) + ", 0)")
-};
-return ff_compiler_JsEmitter.JsEmitter_emitTerm(self_, a1_.value_, async_)
-}
-if(_1.ECall && _1.target_.StaticCall && _1.target_.name_ === "ff:core/List.List_dropLast" && _1.arguments_.length === 2) {
-const a1_ = _1.arguments_[0];
-const a2_ = _1.arguments_[1];
-const count_ = ff_compiler_JsEmitter.JsEmitter_emitTerm(self_, a2_.value_, async_);
-if((!ff_core_String.String_all(count_, ((_w1) => {
-return ff_core_Char.Char_isAsciiDigit(_w1)
-})))) {
-end_ = (((end_ + " - Math.max(") + count_) + ", 0)")
-} else {
-end_ = ((end_ + " - ") + count_)
-};
-return ff_compiler_JsEmitter.JsEmitter_emitTerm(self_, a1_.value_, async_)
-}
-{
-return ff_compiler_JsEmitter.JsEmitter_emitTerm(self_, list_, async_)
-}
-}))(list_);
+const fusion_ = ff_compiler_JsEmitter.JsEmitter_emitLightFusion(self_, list_, async_);
+const start_ = fusion_.second_.first_;
+const end_ = fusion_.second_.second_;
+const listCode_ = fusion_.first_;
 return ff_core_Option.Some(((((((((((((("for(let for_i = " + start_) + ", for_a = ") + listCode_) + ", for_l = ") + end_) + "; for_i < for_l; for_i++) {\n") + ff_core_Option.Option_else(ff_core_Option.Option_map(name_, ((_w1) => {
 return (("const " + ff_compiler_JsEmitter.escapeKeyword_(_w1)) + " = for_a[for_i];\n")
 })), (() => {
@@ -2188,6 +2134,66 @@ return ff_core_Option.None()
 }
 }
 
+export function JsEmitter_emitLightFusion(self_, list_, async_) {
+let start_ = "0";
+let end_ = "for_a.length";
+const listCode_ = (((_1) => {
+if(_1.ECall && _1.target_.StaticCall && _1.target_.name_ === "ff:core/List.List_dropFirst" && _1.arguments_.length === 2) {
+const a1_ = _1.arguments_[0];
+const a2_ = _1.arguments_[1];
+start_ = ff_compiler_JsEmitter.JsEmitter_emitTerm(self_, a2_.value_, async_);
+if((!ff_core_String.String_all(start_, ((_w1) => {
+return ff_core_Char.Char_isAsciiDigit(_w1)
+})))) {
+start_ = (("Math.max(" + start_) + ", 0)")
+};
+return ff_compiler_JsEmitter.JsEmitter_emitTerm(self_, a1_.value_, async_)
+}
+if(_1.ECall && _1.target_.StaticCall && _1.target_.name_ === "ff:core/List.List_dropLast" && _1.arguments_.length === 2) {
+const a1_ = _1.arguments_[0];
+const a2_ = _1.arguments_[1];
+const count_ = ff_compiler_JsEmitter.JsEmitter_emitTerm(self_, a2_.value_, async_);
+if((!ff_core_String.String_all(count_, ((_w1) => {
+return ff_core_Char.Char_isAsciiDigit(_w1)
+})))) {
+end_ = (((end_ + " - Math.max(") + count_) + ", 0)")
+} else {
+end_ = ((end_ + " - ") + count_)
+};
+return ff_compiler_JsEmitter.JsEmitter_emitTerm(self_, a1_.value_, async_)
+}
+if(_1.ECall && _1.target_.StaticCall && _1.target_.name_ === "ff:core/List.List_takeFirst" && _1.arguments_.length === 2) {
+const a1_ = _1.arguments_[0];
+const a2_ = _1.arguments_[1];
+end_ = ff_compiler_JsEmitter.JsEmitter_emitTerm(self_, a2_.value_, async_);
+if((!ff_core_String.String_all(end_, ((_w1) => {
+return ff_core_Char.Char_isAsciiDigit(_w1)
+})))) {
+end_ = (("Math.max(" + end_) + ", 0)")
+};
+end_ = (("Math.min(" + end_) + ", for_a.length)");
+return ff_compiler_JsEmitter.JsEmitter_emitTerm(self_, a1_.value_, async_)
+}
+if(_1.ECall && _1.target_.StaticCall && _1.target_.name_ === "ff:core/List.List_takeLast" && _1.arguments_.length === 2) {
+const a1_ = _1.arguments_[0];
+const a2_ = _1.arguments_[1];
+const count_ = ff_compiler_JsEmitter.JsEmitter_emitTerm(self_, a2_.value_, async_);
+if((!ff_core_String.String_all(count_, ((_w1) => {
+return ff_core_Char.Char_isAsciiDigit(_w1)
+})))) {
+start_ = (("Math.max(for_a.length - Math.max(" + count_) + ", 0), 0)")
+} else {
+start_ = (("Math.max(for_a.length - " + count_) + ", 0)")
+};
+return ff_compiler_JsEmitter.JsEmitter_emitTerm(self_, a1_.value_, async_)
+}
+{
+return ff_compiler_JsEmitter.JsEmitter_emitTerm(self_, list_, async_)
+}
+}))(list_);
+return ff_core_Pair.Pair(listCode_, ff_core_Pair.Pair(start_, end_))
+}
+
 export function JsEmitter_emitTryCatchFinally(self_, term_, last_, async_) {
 function emitCatch_(catchEffect_, cases_) {
 const catchAsync_ = (self_.emittingAsync_ && ff_compiler_JsEmitter.effectTypeIsAsync_(catchEffect_));
@@ -3882,37 +3888,10 @@ if(_guard1.length === 2 && _guard1[1].ELambda && _guard1[1].lambda_.cases_.lengt
 const list_ = _guard1[0];
 const name_ = _guard1[1].lambda_.cases_[0].patterns_[0].name_;
 const body_ = _guard1[1].lambda_.cases_[0].body_;
-let start_ = "0";
-let end_ = "for_a.length";
-const listCode_ = (await ((async (_1, $task) => {
-if(_1.ECall && _1.target_.StaticCall && _1.target_.name_ === "ff:core/List.List_dropFirst" && _1.arguments_.length === 2) {
-const a1_ = _1.arguments_[0];
-const a2_ = _1.arguments_[1];
-start_ = (await ff_compiler_JsEmitter.JsEmitter_emitTerm$(self_, a2_.value_, async_, $task));
-if((!ff_core_String.String_all(start_, ((_w1) => {
-return ff_core_Char.Char_isAsciiDigit(_w1)
-})))) {
-start_ = (("Math.max(" + start_) + ", 0)")
-};
-return (await ff_compiler_JsEmitter.JsEmitter_emitTerm$(self_, a1_.value_, async_, $task))
-}
-if(_1.ECall && _1.target_.StaticCall && _1.target_.name_ === "ff:core/List.List_dropLast" && _1.arguments_.length === 2) {
-const a1_ = _1.arguments_[0];
-const a2_ = _1.arguments_[1];
-const count_ = (await ff_compiler_JsEmitter.JsEmitter_emitTerm$(self_, a2_.value_, async_, $task));
-if((!ff_core_String.String_all(count_, ((_w1) => {
-return ff_core_Char.Char_isAsciiDigit(_w1)
-})))) {
-end_ = (((end_ + " - Math.max(") + count_) + ", 0)")
-} else {
-end_ = ((end_ + " - ") + count_)
-};
-return (await ff_compiler_JsEmitter.JsEmitter_emitTerm$(self_, a1_.value_, async_, $task))
-}
-{
-return (await ff_compiler_JsEmitter.JsEmitter_emitTerm$(self_, list_, async_, $task))
-}
-}))(list_, $task));
+const fusion_ = (await ff_compiler_JsEmitter.JsEmitter_emitLightFusion$(self_, list_, async_, $task));
+const start_ = fusion_.second_.first_;
+const end_ = fusion_.second_.second_;
+const listCode_ = fusion_.first_;
 return ff_core_Option.Some(((((((((("for(let for_i = " + start_) + ", for_a = ") + listCode_) + ", for_l = ") + end_) + "; for_i < for_l; for_i++) {\n") + ff_core_Option.Option_else(ff_core_Option.Option_map(name_, ((_w1) => {
 return (("const " + ff_compiler_JsEmitter.escapeKeyword_(_w1)) + " = for_a[for_i];\n")
 })), (() => {
@@ -3928,37 +3907,10 @@ const list_ = _guard1[0];
 const name_ = _guard1[1].lambda_.cases_[0].patterns_[0].name_;
 const body_ = _guard1[1].lambda_.cases_[0].body_.before_;
 const condition_ = _guard1[1].lambda_.cases_[0].body_.after_;
-let start_ = "0";
-let end_ = "for_a.length";
-const listCode_ = (await ((async (_1, $task) => {
-if(_1.ECall && _1.target_.StaticCall && _1.target_.name_ === "ff:core/List.List_dropFirst" && _1.arguments_.length === 2) {
-const a1_ = _1.arguments_[0];
-const a2_ = _1.arguments_[1];
-start_ = (await ff_compiler_JsEmitter.JsEmitter_emitTerm$(self_, a2_.value_, async_, $task));
-if((!ff_core_String.String_all(start_, ((_w1) => {
-return ff_core_Char.Char_isAsciiDigit(_w1)
-})))) {
-start_ = (("Math.max(" + start_) + ", 0)")
-};
-return (await ff_compiler_JsEmitter.JsEmitter_emitTerm$(self_, a1_.value_, async_, $task))
-}
-if(_1.ECall && _1.target_.StaticCall && _1.target_.name_ === "ff:core/List.List_dropLast" && _1.arguments_.length === 2) {
-const a1_ = _1.arguments_[0];
-const a2_ = _1.arguments_[1];
-const count_ = (await ff_compiler_JsEmitter.JsEmitter_emitTerm$(self_, a2_.value_, async_, $task));
-if((!ff_core_String.String_all(count_, ((_w1) => {
-return ff_core_Char.Char_isAsciiDigit(_w1)
-})))) {
-end_ = (((end_ + " - Math.max(") + count_) + ", 0)")
-} else {
-end_ = ((end_ + " - ") + count_)
-};
-return (await ff_compiler_JsEmitter.JsEmitter_emitTerm$(self_, a1_.value_, async_, $task))
-}
-{
-return (await ff_compiler_JsEmitter.JsEmitter_emitTerm$(self_, list_, async_, $task))
-}
-}))(list_, $task));
+const fusion_ = (await ff_compiler_JsEmitter.JsEmitter_emitLightFusion$(self_, list_, async_, $task));
+const start_ = fusion_.second_.first_;
+const end_ = fusion_.second_.second_;
+const listCode_ = fusion_.first_;
 return ff_core_Option.Some(((((((((((((("for(let for_i = " + start_) + ", for_a = ") + listCode_) + ", for_l = ") + end_) + "; for_i < for_l; for_i++) {\n") + ff_core_Option.Option_else(ff_core_Option.Option_map(name_, ((_w1) => {
 return (("const " + ff_compiler_JsEmitter.escapeKeyword_(_w1)) + " = for_a[for_i];\n")
 })), (() => {
@@ -4126,6 +4078,66 @@ return ff_core_Option.None()
 }
 }
 
+export async function JsEmitter_emitLightFusion$(self_, list_, async_, $task) {
+let start_ = "0";
+let end_ = "for_a.length";
+const listCode_ = (await ((async (_1, $task) => {
+if(_1.ECall && _1.target_.StaticCall && _1.target_.name_ === "ff:core/List.List_dropFirst" && _1.arguments_.length === 2) {
+const a1_ = _1.arguments_[0];
+const a2_ = _1.arguments_[1];
+start_ = (await ff_compiler_JsEmitter.JsEmitter_emitTerm$(self_, a2_.value_, async_, $task));
+if((!ff_core_String.String_all(start_, ((_w1) => {
+return ff_core_Char.Char_isAsciiDigit(_w1)
+})))) {
+start_ = (("Math.max(" + start_) + ", 0)")
+};
+return (await ff_compiler_JsEmitter.JsEmitter_emitTerm$(self_, a1_.value_, async_, $task))
+}
+if(_1.ECall && _1.target_.StaticCall && _1.target_.name_ === "ff:core/List.List_dropLast" && _1.arguments_.length === 2) {
+const a1_ = _1.arguments_[0];
+const a2_ = _1.arguments_[1];
+const count_ = (await ff_compiler_JsEmitter.JsEmitter_emitTerm$(self_, a2_.value_, async_, $task));
+if((!ff_core_String.String_all(count_, ((_w1) => {
+return ff_core_Char.Char_isAsciiDigit(_w1)
+})))) {
+end_ = (((end_ + " - Math.max(") + count_) + ", 0)")
+} else {
+end_ = ((end_ + " - ") + count_)
+};
+return (await ff_compiler_JsEmitter.JsEmitter_emitTerm$(self_, a1_.value_, async_, $task))
+}
+if(_1.ECall && _1.target_.StaticCall && _1.target_.name_ === "ff:core/List.List_takeFirst" && _1.arguments_.length === 2) {
+const a1_ = _1.arguments_[0];
+const a2_ = _1.arguments_[1];
+end_ = (await ff_compiler_JsEmitter.JsEmitter_emitTerm$(self_, a2_.value_, async_, $task));
+if((!ff_core_String.String_all(end_, ((_w1) => {
+return ff_core_Char.Char_isAsciiDigit(_w1)
+})))) {
+end_ = (("Math.max(" + end_) + ", 0)")
+};
+end_ = (("Math.min(" + end_) + ", for_a.length)");
+return (await ff_compiler_JsEmitter.JsEmitter_emitTerm$(self_, a1_.value_, async_, $task))
+}
+if(_1.ECall && _1.target_.StaticCall && _1.target_.name_ === "ff:core/List.List_takeLast" && _1.arguments_.length === 2) {
+const a1_ = _1.arguments_[0];
+const a2_ = _1.arguments_[1];
+const count_ = (await ff_compiler_JsEmitter.JsEmitter_emitTerm$(self_, a2_.value_, async_, $task));
+if((!ff_core_String.String_all(count_, ((_w1) => {
+return ff_core_Char.Char_isAsciiDigit(_w1)
+})))) {
+start_ = (("Math.max(for_a.length - Math.max(" + count_) + ", 0), 0)")
+} else {
+start_ = (("Math.max(for_a.length - " + count_) + ", 0)")
+};
+return (await ff_compiler_JsEmitter.JsEmitter_emitTerm$(self_, a1_.value_, async_, $task))
+}
+{
+return (await ff_compiler_JsEmitter.JsEmitter_emitTerm$(self_, list_, async_, $task))
+}
+}))(list_, $task));
+return ff_core_Pair.Pair(listCode_, ff_core_Pair.Pair(start_, end_))
+}
+
 export async function JsEmitter_emitTryCatchFinally$(self_, term_, last_, async_, $task) {
 async function emitCatch_$(catchEffect_, cases_, $task) {
 const catchAsync_ = (self_.emittingAsync_ && ff_compiler_JsEmitter.effectTypeIsAsync_(catchEffect_));

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

@@ -233,7 +233,7 @@ return ff_core_Array.Array_drain(array_)
 }
 
 export function Random_sampleArray(self_, count_, array_, body_) {
-for(let for_i = 0, for_a = ff_core_List.List_takeFirst(ff_core_Random.Random_shuffleList(self_, ff_core_Array.Array_toList(array_, 0, 9007199254740991)), count_), for_l = for_a.length; for_i < for_l; for_i++) {
+for(let for_i = 0, for_a = ff_core_Random.Random_shuffleList(self_, ff_core_Array.Array_toList(array_, 0, 9007199254740991)), for_l = Math.min(Math.max(count_, 0), for_a.length); for_i < for_l; for_i++) {
 const _w1 = for_a[for_i];
 body_(_w1)
 }
@@ -295,7 +295,7 @@ return ff_core_Array.Array_drain(array_)
 }
 
 export async function Random_sampleArray$(self_, count_, array_, body_, $task) {
-for(let for_i = 0, for_a = ff_core_List.List_takeFirst(ff_core_Random.Random_shuffleList(self_, ff_core_Array.Array_toList(array_, 0, 9007199254740991)), count_), for_l = for_a.length; for_i < for_l; for_i++) {
+for(let for_i = 0, for_a = ff_core_Random.Random_shuffleList(self_, ff_core_Array.Array_toList(array_, 0, 9007199254740991)), for_l = Math.min(Math.max(count_, 0), for_a.length); for_i < for_l; for_i++) {
 const _w1 = for_a[for_i];
 (await body_(_w1, $task))
 }

package/package.json

@@ -4,7 +4,7 @@
     "description": "Firefly compiler",
     "author": "Firefly team",
     "license": "MIT",
-    "version": "0.5.10",
+    "version": "0.5.11",
     "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.10",
+    "version": "0.5.11",
     "repository": {
         "type": "git",
         "url": "https://github.com/Ahnfelt/firefly-boot"