@nfdi4plants/arctrl 3.1.1 → 3.2.0

package/dist/ts/node_modules/@fable-org/fable-library-ts/Seq.js

@@ -0,0 +1,1398 @@
+import { NotSupportedException_$ctor_Z721C83C5, InvalidOperationException_$ctor_Z721C83C5 } from './System.js';
+import { getEnumerator, disposeSafe, toIterator, isArrayLike, isDisposable, Exception, clear } from './Util.js';
+import { toString } from './Types.js';
+import { class_type } from './Reflection.js';
+import { value, some } from './Option.js';
+import { KeyNotFoundException_$ctor_Z721C83C5 } from './System.Collections.Generic.js';
+import { Operators_NullArgCheck, Operators_Lock } from './FSharp.Core.js';
+import { singleton as singleton$1, tryFindBack as tryFindBack$1, tryFindIndexBack as tryFindIndexBack$1, foldBack as foldBack$1, item as item$1, tryHead as tryHead$1, tryItem as tryItem$1, mapFold as mapFold$1, mapFoldBack as mapFoldBack$1, reverse as reverse$1, scanBack as scanBack$1, pairwise as pairwise$1, splitInto as splitInto$1, windowed as windowed$1, map as map$1, transpose as transpose$1, permute as permute$1, chunkBySize as chunkBySize$1, randomShuffleInPlaceBy, randomChoiceBy as randomChoiceBy$1, randomChoiceWith as randomChoiceWith$1, randomChoice as randomChoice$1, randomChoicesBy as randomChoicesBy$1, randomSampleBy as randomSampleBy$1 } from './Array.js';
+import { FSharpList, toArray as toArray$1, ofArray as ofArray$1, ofSeq as ofSeq$1, tryHead as tryHead$2, isEmpty as isEmpty$1, tryItem as tryItem$2, length as length$1 } from './List.js';
+import { min as min$1 } from './Double.js';
+import { SR_indexOutOfBounds } from './Global.js';
+import { nonSeeded } from './Random.js';
+
+const SR_enumerationAlreadyFinished = "Enumeration already finished.";
+const SR_enumerationNotStarted = "Enumeration has not started. Call MoveNext.";
+const SR_inputSequenceEmpty = "The input sequence was empty.";
+const SR_inputSequenceTooLong = "The input sequence contains more than one element.";
+const SR_keyNotFoundAlt = "An index satisfying the predicate was not found in the collection.";
+const SR_notEnoughElements = "The input sequence has an insufficient number of elements.";
+const SR_resetNotSupported = "Reset is not supported on this enumerator.";
+function Enumerator_noReset() {
+  throw NotSupportedException_$ctor_Z721C83C5(SR_resetNotSupported);
+}
+function Enumerator_notStarted() {
+  throw InvalidOperationException_$ctor_Z721C83C5(SR_enumerationNotStarted);
+}
+function Enumerator_alreadyFinished() {
+  throw InvalidOperationException_$ctor_Z721C83C5(SR_enumerationAlreadyFinished);
+}
+class Enumerator_Seq {
+  constructor(f) {
+    this.f = f;
+  }
+  toString() {
+    const xs = this;
+    let i = 0;
+    let str = "seq [";
+    const e = getEnumerator(xs);
+    try {
+      while (i < 4 && e["System.Collections.IEnumerator.MoveNext"]()) {
+        if (i > 0) {
+          str = str + "; ";
+        }
+        str = str + toString(e["System.Collections.Generic.IEnumerator`1.get_Current"]());
+        i = i + 1 | 0;
+      }
+      if (i === 4) {
+        str = str + "; ...";
+      }
+      return str + "]";
+    } finally {
+      disposeSafe(e);
+    }
+  }
+  GetEnumerator() {
+    const x = this;
+    return x.f();
+  }
+  [Symbol.iterator]() {
+    return toIterator(getEnumerator(this));
+  }
+  "System.Collections.IEnumerable.GetEnumerator"() {
+    const x = this;
+    return x.f();
+  }
+}
+function Enumerator_Seq_$reflection(gen0) {
+  return class_type("SeqModule.Enumerator.Seq", [gen0], Enumerator_Seq);
+}
+function Enumerator_Seq_$ctor_673A07F2(f) {
+  return new Enumerator_Seq(f);
+}
+class Enumerator_FromFunctions$1 {
+  constructor(current, next, dispose) {
+    this.current = current;
+    this.next = next;
+    this.dispose = dispose;
+  }
+  "System.Collections.Generic.IEnumerator`1.get_Current"() {
+    const _ = this;
+    return _.current();
+  }
+  "System.Collections.IEnumerator.get_Current"() {
+    const _ = this;
+    return _.current();
+  }
+  "System.Collections.IEnumerator.MoveNext"() {
+    const _ = this;
+    return _.next();
+  }
+  "System.Collections.IEnumerator.Reset"() {
+    Enumerator_noReset();
+  }
+  Dispose() {
+    const _ = this;
+    _.dispose();
+  }
+}
+function Enumerator_FromFunctions$1_$reflection(gen0) {
+  return class_type("SeqModule.Enumerator.FromFunctions`1", [gen0], Enumerator_FromFunctions$1);
+}
+function Enumerator_FromFunctions$1_$ctor_58C54629(current, next, dispose) {
+  return new Enumerator_FromFunctions$1(current, next, dispose);
+}
+function Enumerator_cast(e) {
+  return Enumerator_FromFunctions$1_$ctor_58C54629(() => e["System.Collections.Generic.IEnumerator`1.get_Current"](), () => e["System.Collections.IEnumerator.MoveNext"](), () => {
+    disposeSafe(e);
+  });
+}
+function Enumerator_concat(sources) {
+  let outerOpt = void 0;
+  let innerOpt = void 0;
+  let started = false;
+  let finished = false;
+  let curr = void 0;
+  const finish = () => {
+    finished = true;
+    if (innerOpt != null) {
+      const inner = value(innerOpt);
+      try {
+        disposeSafe(inner);
+      } finally {
+        innerOpt = void 0;
+      }
+    }
+    if (outerOpt != null) {
+      const outer = value(outerOpt);
+      try {
+        disposeSafe(outer);
+      } finally {
+        outerOpt = void 0;
+      }
+    }
+  };
+  return Enumerator_FromFunctions$1_$ctor_58C54629(() => {
+    if (!started) {
+      Enumerator_notStarted();
+    } else if (finished) {
+      Enumerator_alreadyFinished();
+    }
+    if (curr != null) {
+      return value(curr);
+    } else {
+      return Enumerator_alreadyFinished();
+    }
+  }, () => {
+    if (!started) {
+      started = true;
+    }
+    if (finished) {
+      return false;
+    } else {
+      let res = void 0;
+      while (res == null) {
+        let copyOfStruct = void 0;
+        const outerOpt_1 = outerOpt;
+        const innerOpt_1 = innerOpt;
+        if (outerOpt_1 != null) {
+          if (innerOpt_1 != null) {
+            const inner_1 = value(innerOpt_1);
+            if (inner_1["System.Collections.IEnumerator.MoveNext"]()) {
+              curr = some(inner_1["System.Collections.Generic.IEnumerator`1.get_Current"]());
+              res = true;
+            } else {
+              try {
+                disposeSafe(inner_1);
+              } finally {
+                innerOpt = void 0;
+              }
+            }
+          } else {
+            const outer_1 = value(outerOpt_1);
+            if (outer_1["System.Collections.IEnumerator.MoveNext"]()) {
+              const ie = outer_1["System.Collections.Generic.IEnumerator`1.get_Current"]();
+              innerOpt = (copyOfStruct = ie, getEnumerator(copyOfStruct));
+            } else {
+              finish();
+              res = false;
+            }
+          }
+        } else {
+          outerOpt = getEnumerator(sources);
+        }
+      }
+      return value(res);
+    }
+  }, () => {
+    if (!finished) {
+      finish();
+    }
+  });
+}
+function Enumerator_enumerateThenFinally(f, e) {
+  return Enumerator_FromFunctions$1_$ctor_58C54629(() => e["System.Collections.Generic.IEnumerator`1.get_Current"](), () => e["System.Collections.IEnumerator.MoveNext"](), () => {
+    try {
+      disposeSafe(e);
+    } finally {
+      f();
+    }
+  });
+}
+function Enumerator_generateWhileSome(openf, compute, closef) {
+  let started = false;
+  let curr = void 0;
+  let state = some(openf());
+  const dispose = () => {
+    if (state != null) {
+      const x_1 = value(state);
+      try {
+        closef(x_1);
+      } finally {
+        state = void 0;
+      }
+    }
+  };
+  const finish = () => {
+    try {
+      dispose();
+    } finally {
+      curr = void 0;
+    }
+  };
+  return Enumerator_FromFunctions$1_$ctor_58C54629(() => {
+    if (!started) {
+      Enumerator_notStarted();
+    }
+    if (curr != null) {
+      return value(curr);
+    } else {
+      return Enumerator_alreadyFinished();
+    }
+  }, () => {
+    if (!started) {
+      started = true;
+    }
+    if (state != null) {
+      const s = value(state);
+      let matchValue_1;
+      try {
+        matchValue_1 = compute(s);
+      } catch (matchValue) {
+        finish();
+        throw matchValue;
+      }
+      if (matchValue_1 != null) {
+        curr = matchValue_1;
+        return true;
+      } else {
+        finish();
+        return false;
+      }
+    } else {
+      return false;
+    }
+  }, dispose);
+}
+function Enumerator_unfold(f, state) {
+  let curr = void 0;
+  let acc = state;
+  return Enumerator_FromFunctions$1_$ctor_58C54629(() => {
+    if (curr != null) {
+      const x = value(curr)[0];
+      value(curr)[1];
+      return x;
+    } else {
+      return Enumerator_notStarted();
+    }
+  }, () => {
+    curr = f(acc);
+    if (curr != null) {
+      value(curr)[0];
+      const st_1 = value(curr)[1];
+      acc = st_1;
+      return true;
+    } else {
+      return false;
+    }
+  }, () => {
+  });
+}
+function indexNotFound() {
+  throw KeyNotFoundException_$ctor_Z721C83C5(SR_keyNotFoundAlt);
+}
+function mkSeq(f) {
+  return Enumerator_Seq_$ctor_673A07F2(f);
+}
+function ofSeq(xs) {
+  return getEnumerator(Operators_NullArgCheck("source", xs));
+}
+function delay(generator) {
+  return mkSeq(() => getEnumerator(generator()));
+}
+function concat(sources) {
+  return mkSeq(() => Enumerator_concat(sources));
+}
+function unfold(generator, state) {
+  return mkSeq(() => Enumerator_unfold(generator, state));
+}
+function empty() {
+  return delay(() => new Array(0));
+}
+function singleton(x) {
+  return delay(() => singleton$1(x));
+}
+function ofArray(arr) {
+  return arr;
+}
+function toArray(xs) {
+  if (xs instanceof FSharpList) {
+    const a = xs;
+    return toArray$1(a);
+  } else {
+    return Array.from(xs);
+  }
+}
+function ofList(xs) {
+  return xs;
+}
+function toList(xs) {
+  if (isArrayLike(xs)) {
+    return ofArray$1(xs);
+  } else if (xs instanceof FSharpList) {
+    return xs;
+  } else {
+    return ofSeq$1(xs);
+  }
+}
+function generate(create, compute, dispose) {
+  return mkSeq(() => Enumerator_generateWhileSome(create, compute, dispose));
+}
+function generateIndexed(create, compute, dispose) {
+  return mkSeq(() => {
+    let i = -1;
+    return Enumerator_generateWhileSome(create, (x) => {
+      i = i + 1 | 0;
+      return compute(i, x);
+    }, dispose);
+  });
+}
+function append(xs, ys) {
+  return concat([xs, ys]);
+}
+function cast(xs) {
+  return mkSeq(() => Enumerator_cast(getEnumerator(Operators_NullArgCheck("source", xs))));
+}
+function choose(chooser, xs) {
+  return generate(() => ofSeq(xs), (e) => {
+    let curr = void 0;
+    while (curr == null && e["System.Collections.IEnumerator.MoveNext"]()) {
+      curr = chooser(e["System.Collections.Generic.IEnumerator`1.get_Current"]());
+    }
+    return curr;
+  }, (e_1) => {
+    disposeSafe(e_1);
+  });
+}
+function compareWith(comparer, xs, ys) {
+  const e1 = ofSeq(xs);
+  try {
+    const e2 = ofSeq(ys);
+    try {
+      let c = 0;
+      let b1 = e1["System.Collections.IEnumerator.MoveNext"]();
+      let b2 = e2["System.Collections.IEnumerator.MoveNext"]();
+      while (c === 0 && b1 && b2) {
+        c = comparer(e1["System.Collections.Generic.IEnumerator`1.get_Current"](), e2["System.Collections.Generic.IEnumerator`1.get_Current"]()) | 0;
+        if (c === 0) {
+          b1 = e1["System.Collections.IEnumerator.MoveNext"]();
+          b2 = e2["System.Collections.IEnumerator.MoveNext"]();
+        }
+      }
+      return (c !== 0 ? c : b1 ? 1 : b2 ? -1 : 0) | 0;
+    } finally {
+      disposeSafe(e2);
+    }
+  } finally {
+    disposeSafe(e1);
+  }
+}
+function contains(value, xs, comparer) {
+  const e = ofSeq(xs);
+  try {
+    let found = false;
+    while (!found && e["System.Collections.IEnumerator.MoveNext"]()) {
+      found = comparer.Equals(value, e["System.Collections.Generic.IEnumerator`1.get_Current"]());
+    }
+    return found;
+  } finally {
+    disposeSafe(e);
+  }
+}
+function enumerateFromFunctions(create, moveNext, current) {
+  return generate(create, (x) => moveNext(x) ? some(current(x)) : void 0, (x_1) => {
+    const matchValue = x_1;
+    if (isDisposable(matchValue)) {
+      const id = matchValue;
+      disposeSafe(id);
+    }
+  });
+}
+function enumerateThenFinally(source, compensation) {
+  const compensation_1 = compensation;
+  return mkSeq(() => {
+    try {
+      return Enumerator_enumerateThenFinally(compensation_1, ofSeq(source));
+    } catch (matchValue) {
+      compensation_1();
+      throw matchValue;
+    }
+  });
+}
+function enumerateUsing(resource, source) {
+  const compensation = () => {
+    if (resource == null) {
+    } else {
+      let copyOfStruct = resource;
+      disposeSafe(copyOfStruct);
+    }
+  };
+  return mkSeq(() => {
+    try {
+      return Enumerator_enumerateThenFinally(compensation, ofSeq(source(resource)));
+    } catch (matchValue_1) {
+      compensation();
+      throw matchValue_1;
+    }
+  });
+}
+function enumerateWhile(guard, xs) {
+  return concat(unfold((i) => guard() ? [xs, i + 1] : void 0, 0));
+}
+function enumerateTryWith(source, catchFilter, catchHandler) {
+  return mkSeq(() => {
+    let e = void 0;
+    let caught = false;
+    let started = false;
+    let finished = false;
+    let curr = void 0;
+    const tryNext = () => {
+      try {
+        let en_2;
+        if (e == null) {
+          const en_1 = getEnumerator(source);
+          e = en_1;
+          en_2 = en_1;
+        } else {
+          en_2 = value(e);
+        }
+        if (en_2["System.Collections.IEnumerator.MoveNext"]()) {
+          curr = some(en_2["System.Collections.Generic.IEnumerator`1.get_Current"]());
+          return true;
+        } else {
+          finished = true;
+          return false;
+        }
+      } catch (matchValue) {
+        if (!caught) {
+          const ex_1 = matchValue;
+          if (catchFilter(ex_1) !== 0) {
+            caught = true;
+            if (e == null) {
+            } else {
+              const en_3 = value(e);
+              try {
+                disposeSafe(en_3);
+              } catch (matchValue_1) {
+              }
+              e = void 0;
+            }
+            e = getEnumerator(catchHandler(ex_1));
+            return tryNext();
+          } else {
+            throw matchValue;
+          }
+        } else {
+          throw matchValue;
+        }
+      }
+    };
+    return Enumerator_FromFunctions$1_$ctor_58C54629(() => {
+      if (!started) {
+        Enumerator_notStarted();
+      } else if (finished) {
+        Enumerator_alreadyFinished();
+      }
+      if (curr != null) {
+        return value(curr);
+      } else {
+        return Enumerator_alreadyFinished();
+      }
+    }, () => {
+      if (!started) {
+        started = true;
+      }
+      if (finished) {
+        return false;
+      } else {
+        return tryNext();
+      }
+    }, () => {
+      if (e == null) {
+      } else {
+        disposeSafe(value(e));
+      }
+    });
+  });
+}
+function filter(f, xs) {
+  return choose((x) => {
+    if (f(x)) {
+      return some(x);
+    } else {
+      return void 0;
+    }
+  }, xs);
+}
+function exists(predicate, xs) {
+  const e = ofSeq(xs);
+  try {
+    let found = false;
+    while (!found && e["System.Collections.IEnumerator.MoveNext"]()) {
+      found = predicate(e["System.Collections.Generic.IEnumerator`1.get_Current"]());
+    }
+    return found;
+  } finally {
+    disposeSafe(e);
+  }
+}
+function exists2(predicate, xs, ys) {
+  const e1 = ofSeq(xs);
+  try {
+    const e2 = ofSeq(ys);
+    try {
+      let found = false;
+      while (!found && e1["System.Collections.IEnumerator.MoveNext"]() && e2["System.Collections.IEnumerator.MoveNext"]()) {
+        found = predicate(e1["System.Collections.Generic.IEnumerator`1.get_Current"](), e2["System.Collections.Generic.IEnumerator`1.get_Current"]());
+      }
+      return found;
+    } finally {
+      disposeSafe(e2);
+    }
+  } finally {
+    disposeSafe(e1);
+  }
+}
+function exactlyOne(xs) {
+  const e = ofSeq(xs);
+  try {
+    if (e["System.Collections.IEnumerator.MoveNext"]()) {
+      const v = e["System.Collections.Generic.IEnumerator`1.get_Current"]();
+      if (e["System.Collections.IEnumerator.MoveNext"]()) {
+        throw new Exception(SR_inputSequenceTooLong + " (Parameter 'source')");
+      } else {
+        return v;
+      }
+    } else {
+      throw new Exception(SR_inputSequenceEmpty + " (Parameter 'source')");
+    }
+  } finally {
+    disposeSafe(e);
+  }
+}
+function tryExactlyOne(xs) {
+  const e = ofSeq(xs);
+  try {
+    if (e["System.Collections.IEnumerator.MoveNext"]()) {
+      const v = e["System.Collections.Generic.IEnumerator`1.get_Current"]();
+      return e["System.Collections.IEnumerator.MoveNext"]() ? void 0 : some(v);
+    } else {
+      return void 0;
+    }
+  } finally {
+    disposeSafe(e);
+  }
+}
+function tryFind(predicate, xs) {
+  const e = ofSeq(xs);
+  try {
+    let res = void 0;
+    while (res == null && e["System.Collections.IEnumerator.MoveNext"]()) {
+      const c = e["System.Collections.Generic.IEnumerator`1.get_Current"]();
+      if (predicate(c)) {
+        res = some(c);
+      }
+    }
+    return res;
+  } finally {
+    disposeSafe(e);
+  }
+}
+function find(predicate, xs) {
+  const matchValue = tryFind(predicate, xs);
+  if (matchValue == null) {
+    return indexNotFound();
+  } else {
+    return value(matchValue);
+  }
+}
+function tryFindBack(predicate, xs) {
+  return tryFindBack$1(predicate, toArray(xs));
+}
+function findBack(predicate, xs) {
+  const matchValue = tryFindBack(predicate, xs);
+  if (matchValue == null) {
+    return indexNotFound();
+  } else {
+    return value(matchValue);
+  }
+}
+function tryFindIndex(predicate, xs) {
+  const e = ofSeq(xs);
+  try {
+    const loop = (i_mut) => {
+      loop:
+        while (true) {
+          const i = i_mut;
+          if (e["System.Collections.IEnumerator.MoveNext"]()) {
+            if (predicate(e["System.Collections.Generic.IEnumerator`1.get_Current"]())) {
+              return i;
+            } else {
+              i_mut = i + 1;
+              continue loop;
+            }
+          } else {
+            return void 0;
+          }
+          break;
+        }
+    };
+    return loop(0);
+  } finally {
+    disposeSafe(e);
+  }
+}
+function findIndex(predicate, xs) {
+  const matchValue = tryFindIndex(predicate, xs);
+  if (matchValue == null) {
+    indexNotFound();
+    return -1;
+  } else {
+    return value(matchValue) | 0;
+  }
+}
+function tryFindIndexBack(predicate, xs) {
+  return tryFindIndexBack$1(predicate, toArray(xs));
+}
+function findIndexBack(predicate, xs) {
+  const matchValue = tryFindIndexBack(predicate, xs);
+  if (matchValue == null) {
+    indexNotFound();
+    return -1;
+  } else {
+    return value(matchValue) | 0;
+  }
+}
+function fold(folder, state, xs) {
+  const e = ofSeq(xs);
+  try {
+    let acc = state;
+    while (e["System.Collections.IEnumerator.MoveNext"]()) {
+      acc = folder(acc, e["System.Collections.Generic.IEnumerator`1.get_Current"]());
+    }
+    return acc;
+  } finally {
+    disposeSafe(e);
+  }
+}
+function foldBack(folder, xs, state) {
+  return foldBack$1(folder, toArray(xs), state);
+}
+function fold2(folder, state, xs, ys) {
+  const e1 = ofSeq(xs);
+  try {
+    const e2 = ofSeq(ys);
+    try {
+      let acc = state;
+      while (e1["System.Collections.IEnumerator.MoveNext"]() && e2["System.Collections.IEnumerator.MoveNext"]()) {
+        acc = folder(acc, e1["System.Collections.Generic.IEnumerator`1.get_Current"](), e2["System.Collections.Generic.IEnumerator`1.get_Current"]());
+      }
+      return acc;
+    } finally {
+      disposeSafe(e2);
+    }
+  } finally {
+    disposeSafe(e1);
+  }
+}
+function foldBack2(folder, xs, ys, state) {
+  const xs_1 = toArray(xs);
+  const ys_1 = toArray(ys);
+  const len = min$1(xs_1.length, ys_1.length) | 0;
+  let acc = state;
+  for (let i = len - 1; i >= 0; i--) {
+    acc = folder(item$1(i, xs_1), item$1(i, ys_1), acc);
+  }
+  return acc;
+}
+function forAll(predicate, xs) {
+  return !exists((x) => !predicate(x), xs);
+}
+function forAll2(predicate, xs, ys) {
+  return !exists2((x, y) => !predicate(x, y), xs, ys);
+}
+function tryHead(xs) {
+  if (isArrayLike(xs)) {
+    return tryHead$1(xs);
+  } else if (xs instanceof FSharpList) {
+    return tryHead$2(xs);
+  } else {
+    const e = ofSeq(xs);
+    try {
+      return e["System.Collections.IEnumerator.MoveNext"]() ? some(e["System.Collections.Generic.IEnumerator`1.get_Current"]()) : void 0;
+    } finally {
+      disposeSafe(e);
+    }
+  }
+}
+function head(xs) {
+  const matchValue = tryHead(xs);
+  if (matchValue == null) {
+    throw new Exception(SR_inputSequenceEmpty + " (Parameter 'source')");
+  } else {
+    return value(matchValue);
+  }
+}
+function initialize(count, f) {
+  return unfold((i) => i < count ? [f(i), i + 1] : void 0, 0);
+}
+function initializeInfinite(f) {
+  return initialize(2147483647, f);
+}
+function isEmpty(xs) {
+  if (isArrayLike(xs)) {
+    const a = xs;
+    return a.length === 0;
+  } else if (xs instanceof FSharpList) {
+    return isEmpty$1(xs);
+  } else {
+    const e = ofSeq(xs);
+    try {
+      return !e["System.Collections.IEnumerator.MoveNext"]();
+    } finally {
+      disposeSafe(e);
+    }
+  }
+}
+function tryItem(index, xs) {
+  if (isArrayLike(xs)) {
+    return tryItem$1(index, xs);
+  } else if (xs instanceof FSharpList) {
+    return tryItem$2(index, xs);
+  } else {
+    const e = ofSeq(xs);
+    try {
+      const loop = (index_1_mut) => {
+        loop:
+          while (true) {
+            const index_1 = index_1_mut;
+            if (!e["System.Collections.IEnumerator.MoveNext"]()) {
+              return void 0;
+            } else if (index_1 === 0) {
+              return some(e["System.Collections.Generic.IEnumerator`1.get_Current"]());
+            } else {
+              index_1_mut = index_1 - 1;
+              continue loop;
+            }
+            break;
+          }
+      };
+      return loop(index);
+    } finally {
+      disposeSafe(e);
+    }
+  }
+}
+function item(index, xs) {
+  const matchValue = tryItem(index, xs);
+  if (matchValue == null) {
+    throw new Exception(SR_notEnoughElements + " (Parameter 'index')");
+  } else {
+    return value(matchValue);
+  }
+}
+function iterate(action, xs) {
+  fold((unitVar, x) => {
+    action(x);
+  }, void 0, xs);
+}
+function iterate2(action, xs, ys) {
+  fold2((unitVar, x, y) => {
+    action(x, y);
+  }, void 0, xs, ys);
+}
+function iterateIndexed(action, xs) {
+  fold((i, x) => {
+    action(i, x);
+    return i + 1 | 0;
+  }, 0, xs);
+}
+function iterateIndexed2(action, xs, ys) {
+  fold2((i, x, y) => {
+    action(i, x, y);
+    return i + 1 | 0;
+  }, 0, xs, ys);
+}
+function tryLast(xs) {
+  const e = ofSeq(xs);
+  try {
+    const loop = (acc_mut) => {
+      loop:
+        while (true) {
+          const acc = acc_mut;
+          if (!e["System.Collections.IEnumerator.MoveNext"]()) {
+            return acc;
+          } else {
+            acc_mut = e["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            continue loop;
+          }
+          break;
+        }
+    };
+    return e["System.Collections.IEnumerator.MoveNext"]() ? some(loop(e["System.Collections.Generic.IEnumerator`1.get_Current"]())) : void 0;
+  } finally {
+    disposeSafe(e);
+  }
+}
+function last(xs) {
+  const matchValue = tryLast(xs);
+  if (matchValue == null) {
+    throw new Exception(SR_notEnoughElements + " (Parameter 'source')");
+  } else {
+    return value(matchValue);
+  }
+}
+function length(xs) {
+  if (isArrayLike(xs)) {
+    const a = xs;
+    return a.length | 0;
+  } else if (xs instanceof FSharpList) {
+    return length$1(xs) | 0;
+  } else {
+    const e = ofSeq(xs);
+    try {
+      let count = 0;
+      while (e["System.Collections.IEnumerator.MoveNext"]()) {
+        count = count + 1 | 0;
+      }
+      return count | 0;
+    } finally {
+      disposeSafe(e);
+    }
+  }
+}
+function map(mapping, xs) {
+  return generate(() => ofSeq(xs), (e) => e["System.Collections.IEnumerator.MoveNext"]() ? some(mapping(e["System.Collections.Generic.IEnumerator`1.get_Current"]())) : void 0, (e_1) => {
+    disposeSafe(e_1);
+  });
+}
+function mapIndexed(mapping, xs) {
+  return generateIndexed(() => ofSeq(xs), (i, e) => e["System.Collections.IEnumerator.MoveNext"]() ? some(mapping(i, e["System.Collections.Generic.IEnumerator`1.get_Current"]())) : void 0, (e_1) => {
+    disposeSafe(e_1);
+  });
+}
+function indexed(xs) {
+  return mapIndexed((i, x) => [i, x], xs);
+}
+function map2(mapping, xs, ys) {
+  return generate(() => [ofSeq(xs), ofSeq(ys)], (tupledArg) => {
+    const e1 = tupledArg[0];
+    const e2 = tupledArg[1];
+    return e1["System.Collections.IEnumerator.MoveNext"]() && e2["System.Collections.IEnumerator.MoveNext"]() ? some(mapping(e1["System.Collections.Generic.IEnumerator`1.get_Current"](), e2["System.Collections.Generic.IEnumerator`1.get_Current"]())) : void 0;
+  }, (tupledArg_1) => {
+    try {
+      disposeSafe(tupledArg_1[0]);
+    } finally {
+      disposeSafe(tupledArg_1[1]);
+    }
+  });
+}
+function mapIndexed2(mapping, xs, ys) {
+  return generateIndexed(() => [ofSeq(xs), ofSeq(ys)], (i, tupledArg) => {
+    const e1 = tupledArg[0];
+    const e2 = tupledArg[1];
+    return e1["System.Collections.IEnumerator.MoveNext"]() && e2["System.Collections.IEnumerator.MoveNext"]() ? some(mapping(i, e1["System.Collections.Generic.IEnumerator`1.get_Current"](), e2["System.Collections.Generic.IEnumerator`1.get_Current"]())) : void 0;
+  }, (tupledArg_1) => {
+    try {
+      disposeSafe(tupledArg_1[0]);
+    } finally {
+      disposeSafe(tupledArg_1[1]);
+    }
+  });
+}
+function map3(mapping, xs, ys, zs) {
+  return generate(() => [ofSeq(xs), ofSeq(ys), ofSeq(zs)], (tupledArg) => {
+    const e1 = tupledArg[0];
+    const e2 = tupledArg[1];
+    const e3 = tupledArg[2];
+    return e1["System.Collections.IEnumerator.MoveNext"]() && e2["System.Collections.IEnumerator.MoveNext"]() && e3["System.Collections.IEnumerator.MoveNext"]() ? some(mapping(e1["System.Collections.Generic.IEnumerator`1.get_Current"](), e2["System.Collections.Generic.IEnumerator`1.get_Current"](), e3["System.Collections.Generic.IEnumerator`1.get_Current"]())) : void 0;
+  }, (tupledArg_1) => {
+    try {
+      disposeSafe(tupledArg_1[0]);
+    } finally {
+      try {
+        disposeSafe(tupledArg_1[1]);
+      } finally {
+        disposeSafe(tupledArg_1[2]);
+      }
+    }
+  });
+}
+function readOnly(xs) {
+  return map((x) => x, Operators_NullArgCheck("source", xs));
+}
+class CachedSeq$1 {
+  constructor(cleanup, res) {
+    this.cleanup = cleanup;
+    this.res = res;
+  }
+  Dispose() {
+    const _ = this;
+    _.cleanup();
+  }
+  GetEnumerator() {
+    const _ = this;
+    return getEnumerator(_.res);
+  }
+  [Symbol.iterator]() {
+    return toIterator(getEnumerator(this));
+  }
+  "System.Collections.IEnumerable.GetEnumerator"() {
+    const _ = this;
+    return getEnumerator(_.res);
+  }
+}
+function CachedSeq$1_$reflection(gen0) {
+  return class_type("SeqModule.CachedSeq`1", [gen0], CachedSeq$1);
+}
+function CachedSeq$1_$ctor_Z7A8347D4(cleanup, res) {
+  return new CachedSeq$1(cleanup, res);
+}
+function CachedSeq$1__Clear(_) {
+  _.cleanup();
+}
+function cache(source) {
+  const source_1 = Operators_NullArgCheck("source", source);
+  const prefix = [];
+  let enumeratorR = void 0;
+  return CachedSeq$1_$ctor_Z7A8347D4(() => {
+    Operators_Lock(prefix, () => {
+      clear(prefix);
+      let matchResult = void 0, e = void 0;
+      if (enumeratorR != null) {
+        if (value(enumeratorR) != null) {
+          matchResult = 0;
+          e = value(value(enumeratorR));
+        } else {
+          matchResult = 1;
+        }
+      } else {
+        matchResult = 1;
+      }
+      switch (matchResult) {
+        case 0: {
+          disposeSafe(e);
+          break;
+        }
+      }
+      enumeratorR = void 0;
+    });
+  }, unfold((i_1) => Operators_Lock(prefix, () => {
+    if (i_1 < prefix.length) {
+      return [item$1(i_1, prefix), i_1 + 1];
+    } else {
+      if (i_1 >= prefix.length) {
+        let optEnumerator_2;
+        if (enumeratorR != null) {
+          optEnumerator_2 = value(enumeratorR);
+        } else {
+          const optEnumerator = getEnumerator(source_1);
+          enumeratorR = some(optEnumerator);
+          optEnumerator_2 = optEnumerator;
+        }
+        if (optEnumerator_2 == null) {
+        } else {
+          const enumerator = value(optEnumerator_2);
+          if (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            void prefix.push(enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]());
+          } else {
+            disposeSafe(enumerator);
+            enumeratorR = some(void 0);
+          }
+        }
+      }
+      if (i_1 < prefix.length) {
+        return [item$1(i_1, prefix), i_1 + 1];
+      } else {
+        return void 0;
+      }
+    }
+  }), 0));
+}
+function allPairs(xs, ys) {
+  const ysCache = cache(ys);
+  return delay(() => concat(map((x) => map((y) => [x, y], ysCache), xs)));
+}
+function mapFold(mapping, state, xs) {
+  const patternInput = mapFold$1(mapping, state, toArray(xs));
+  return [readOnly(patternInput[0]), patternInput[1]];
+}
+function mapFoldBack(mapping, xs, state) {
+  const patternInput = mapFoldBack$1(mapping, toArray(xs), state);
+  return [readOnly(patternInput[0]), patternInput[1]];
+}
+function tryPick(chooser, xs) {
+  const e = ofSeq(xs);
+  try {
+    let res = void 0;
+    while (res == null && e["System.Collections.IEnumerator.MoveNext"]()) {
+      res = chooser(e["System.Collections.Generic.IEnumerator`1.get_Current"]());
+    }
+    return res;
+  } finally {
+    disposeSafe(e);
+  }
+}
+function pick(chooser, xs) {
+  const matchValue = tryPick(chooser, xs);
+  if (matchValue == null) {
+    return indexNotFound();
+  } else {
+    return value(matchValue);
+  }
+}
+function reduce(folder, xs) {
+  const e = ofSeq(xs);
+  try {
+    const loop = (acc_mut) => {
+      loop:
+        while (true) {
+          const acc = acc_mut;
+          if (e["System.Collections.IEnumerator.MoveNext"]()) {
+            acc_mut = folder(acc, e["System.Collections.Generic.IEnumerator`1.get_Current"]());
+            continue loop;
+          } else {
+            return acc;
+          }
+          break;
+        }
+    };
+    if (e["System.Collections.IEnumerator.MoveNext"]()) {
+      return loop(e["System.Collections.Generic.IEnumerator`1.get_Current"]());
+    } else {
+      throw new Exception(SR_inputSequenceEmpty);
+    }
+  } finally {
+    disposeSafe(e);
+  }
+}
+function reduceBack(folder, xs) {
+  const arr = toArray(xs);
+  if (arr.length > 0) {
+    return arr.reduceRight(folder);
+  } else {
+    throw new Exception(SR_inputSequenceEmpty);
+  }
+}
+function replicate(n, x) {
+  return initialize(n, (_arg) => x);
+}
+function reverse(xs) {
+  return delay(() => ofArray(reverse$1(toArray(xs))));
+}
+function scan(folder, state, xs) {
+  return delay(() => {
+    let acc = state;
+    return concat([singleton(state), map((x) => {
+      acc = folder(acc, x);
+      return acc;
+    }, xs)]);
+  });
+}
+function scanBack(folder, xs, state) {
+  return delay(() => ofArray(scanBack$1(folder, toArray(xs), state)));
+}
+function skip(count, source) {
+  return mkSeq(() => {
+    const e = ofSeq(source);
+    try {
+      for (let _ = 1; _ <= count; _++) {
+        if (!e["System.Collections.IEnumerator.MoveNext"]()) {
+          throw new Exception(SR_notEnoughElements + " (Parameter 'source')");
+        }
+      }
+      return Enumerator_enumerateThenFinally(() => {
+      }, e);
+    } catch (matchValue) {
+      disposeSafe(e);
+      throw matchValue;
+    }
+  });
+}
+function skipWhile(predicate, xs) {
+  return delay(() => {
+    let skipped = true;
+    return filter((x) => {
+      if (skipped) {
+        skipped = predicate(x);
+      }
+      return !skipped;
+    }, xs);
+  });
+}
+function tail(xs) {
+  return skip(1, xs);
+}
+function take(count, xs) {
+  return generateIndexed(() => ofSeq(xs), (i, e) => {
+    if (i < count) {
+      if (e["System.Collections.IEnumerator.MoveNext"]()) {
+        return some(e["System.Collections.Generic.IEnumerator`1.get_Current"]());
+      } else {
+        throw new Exception(SR_notEnoughElements + " (Parameter 'source')");
+      }
+    } else {
+      return void 0;
+    }
+  }, (e_1) => {
+    disposeSafe(e_1);
+  });
+}
+function takeWhile(predicate, xs) {
+  return generate(() => ofSeq(xs), (e) => e["System.Collections.IEnumerator.MoveNext"]() && predicate(e["System.Collections.Generic.IEnumerator`1.get_Current"]()) ? some(e["System.Collections.Generic.IEnumerator`1.get_Current"]()) : void 0, (e_1) => {
+    disposeSafe(e_1);
+  });
+}
+function truncate(count, xs) {
+  return generateIndexed(() => ofSeq(xs), (i, e) => i < count && e["System.Collections.IEnumerator.MoveNext"]() ? some(e["System.Collections.Generic.IEnumerator`1.get_Current"]()) : void 0, (e_1) => {
+    disposeSafe(e_1);
+  });
+}
+function zip(xs, ys) {
+  return map2((x, y) => [x, y], xs, ys);
+}
+function zip3(xs, ys, zs) {
+  return map3((x, y, z) => [x, y, z], xs, ys, zs);
+}
+function collect(mapping, xs) {
+  return delay(() => concat(map(mapping, xs)));
+}
+function where(predicate, xs) {
+  return filter(predicate, xs);
+}
+function pairwise(xs) {
+  return delay(() => ofArray(pairwise$1(toArray(xs))));
+}
+function splitInto(chunks, xs) {
+  return delay(() => ofArray(splitInto$1(chunks, toArray(xs))));
+}
+function windowed(windowSize, xs) {
+  return delay(() => ofArray(windowed$1(windowSize, toArray(xs))));
+}
+function transpose(xss) {
+  return delay(() => ofArray(map$1(ofArray, transpose$1(map$1(toArray, toArray(xss))))));
+}
+function sortWith(comparer, xs) {
+  return delay(() => {
+    const arr = toArray(xs);
+    arr.sort(comparer);
+    return ofArray(arr);
+  });
+}
+function sort(xs, comparer) {
+  return sortWith((x, y) => comparer.Compare(x, y) | 0, xs);
+}
+function sortBy(projection, xs, comparer) {
+  return sortWith((x, y) => comparer.Compare(projection(x), projection(y)) | 0, xs);
+}
+function sortDescending(xs, comparer) {
+  return sortWith((x, y) => comparer.Compare(x, y) * -1 | 0, xs);
+}
+function sortByDescending(projection, xs, comparer) {
+  return sortWith((x, y) => comparer.Compare(projection(x), projection(y)) * -1 | 0, xs);
+}
+function sum(xs, adder) {
+  return fold((acc, x) => adder.Add(acc, x), adder.GetZero(), xs);
+}
+function sumBy(f, xs, adder) {
+  return fold((acc, x) => adder.Add(acc, f(x)), adder.GetZero(), xs);
+}
+function maxBy(projection, xs, comparer) {
+  return reduce((x, y) => comparer.Compare(projection(y), projection(x)) > 0 ? y : x, xs);
+}
+function max(xs, comparer) {
+  return reduce((x, y) => comparer.Compare(y, x) > 0 ? y : x, xs);
+}
+function minBy(projection, xs, comparer) {
+  return reduce((x, y) => comparer.Compare(projection(y), projection(x)) > 0 ? x : y, xs);
+}
+function min(xs, comparer) {
+  return reduce((x, y) => comparer.Compare(y, x) > 0 ? x : y, xs);
+}
+function average(xs, averager) {
+  let count = 0;
+  const total = fold((acc, x) => {
+    count = count + 1 | 0;
+    return averager.Add(acc, x);
+  }, averager.GetZero(), xs);
+  if (count === 0) {
+    throw new Exception(SR_inputSequenceEmpty + " (Parameter 'source')");
+  } else {
+    return averager.DivideByInt(total, count);
+  }
+}
+function averageBy(f, xs, averager) {
+  let count = 0;
+  const total = fold((acc, x) => {
+    count = count + 1 | 0;
+    return averager.Add(acc, f(x));
+  }, averager.GetZero(), xs);
+  if (count === 0) {
+    throw new Exception(SR_inputSequenceEmpty + " (Parameter 'source')");
+  } else {
+    return averager.DivideByInt(total, count);
+  }
+}
+function permute(f, xs) {
+  return delay(() => ofArray(permute$1(f, toArray(xs))));
+}
+function chunkBySize(chunkSize, xs) {
+  return delay(() => ofArray(chunkBySize$1(chunkSize, toArray(xs))));
+}
+function insertAt(index, y, xs) {
+  let isDone = false;
+  if (index < 0) {
+    throw new Exception(SR_indexOutOfBounds + " (Parameter 'index')");
+  }
+  return generateIndexed(() => ofSeq(xs), (i, e) => {
+    if ((isDone ? true : i < index) && e["System.Collections.IEnumerator.MoveNext"]()) {
+      return some(e["System.Collections.Generic.IEnumerator`1.get_Current"]());
+    } else if (i === index) {
+      isDone = true;
+      return some(y);
+    } else {
+      if (!isDone) {
+        throw new Exception(SR_indexOutOfBounds + " (Parameter 'index')");
+      }
+      return void 0;
+    }
+  }, (e_1) => {
+    disposeSafe(e_1);
+  });
+}
+function insertManyAt(index, ys, xs) {
+  let status = -1;
+  if (index < 0) {
+    throw new Exception(SR_indexOutOfBounds + " (Parameter 'index')");
+  }
+  return generateIndexed(() => [ofSeq(xs), ofSeq(ys)], (i, tupledArg) => {
+    const e1 = tupledArg[0];
+    const e2 = tupledArg[1];
+    if (i === index) {
+      status = 0;
+    }
+    let inserted;
+    if (status === 0) {
+      if (e2["System.Collections.IEnumerator.MoveNext"]()) {
+        inserted = some(e2["System.Collections.Generic.IEnumerator`1.get_Current"]());
+      } else {
+        status = 1;
+        inserted = void 0;
+      }
+    } else {
+      inserted = void 0;
+    }
+    if (inserted == null) {
+      if (e1["System.Collections.IEnumerator.MoveNext"]()) {
+        return some(e1["System.Collections.Generic.IEnumerator`1.get_Current"]());
+      } else {
+        if (status < 1) {
+          throw new Exception(SR_indexOutOfBounds + " (Parameter 'index')");
+        }
+        return void 0;
+      }
+    } else {
+      return some(value(inserted));
+    }
+  }, (tupledArg_1) => {
+    disposeSafe(tupledArg_1[0]);
+    disposeSafe(tupledArg_1[1]);
+  });
+}
+function removeAt(index, xs) {
+  let isDone = false;
+  if (index < 0) {
+    throw new Exception(SR_indexOutOfBounds + " (Parameter 'index')");
+  }
+  return generateIndexed(() => ofSeq(xs), (i, e) => {
+    if ((isDone ? true : i < index) && e["System.Collections.IEnumerator.MoveNext"]()) {
+      return some(e["System.Collections.Generic.IEnumerator`1.get_Current"]());
+    } else if (i === index && e["System.Collections.IEnumerator.MoveNext"]()) {
+      isDone = true;
+      return e["System.Collections.IEnumerator.MoveNext"]() ? some(e["System.Collections.Generic.IEnumerator`1.get_Current"]()) : void 0;
+    } else {
+      if (!isDone) {
+        throw new Exception(SR_indexOutOfBounds + " (Parameter 'index')");
+      }
+      return void 0;
+    }
+  }, (e_1) => {
+    disposeSafe(e_1);
+  });
+}
+function removeManyAt(index, count, xs) {
+  if (index < 0) {
+    throw new Exception(SR_indexOutOfBounds + " (Parameter 'index')");
+  }
+  return generateIndexed(() => ofSeq(xs), (i, e) => {
+    if (i < index) {
+      if (e["System.Collections.IEnumerator.MoveNext"]()) {
+        return some(e["System.Collections.Generic.IEnumerator`1.get_Current"]());
+      } else {
+        throw new Exception(SR_indexOutOfBounds + " (Parameter 'index')");
+      }
+    } else {
+      if (i === index) {
+        for (let _ = 1; _ <= count; _++) {
+          if (!e["System.Collections.IEnumerator.MoveNext"]()) {
+            throw new Exception(SR_indexOutOfBounds + " (Parameter 'count')");
+          }
+        }
+      }
+      return e["System.Collections.IEnumerator.MoveNext"]() ? some(e["System.Collections.Generic.IEnumerator`1.get_Current"]()) : void 0;
+    }
+  }, (e_1) => {
+    disposeSafe(e_1);
+  });
+}
+function updateAt(index, y, xs) {
+  let isDone = false;
+  if (index < 0) {
+    throw new Exception(SR_indexOutOfBounds + " (Parameter 'index')");
+  }
+  return generateIndexed(() => ofSeq(xs), (i, e) => {
+    if ((isDone ? true : i < index) && e["System.Collections.IEnumerator.MoveNext"]()) {
+      return some(e["System.Collections.Generic.IEnumerator`1.get_Current"]());
+    } else if (i === index && e["System.Collections.IEnumerator.MoveNext"]()) {
+      isDone = true;
+      return some(y);
+    } else {
+      if (!isDone) {
+        throw new Exception(SR_indexOutOfBounds + " (Parameter 'index')");
+      }
+      return void 0;
+    }
+  }, (e_1) => {
+    disposeSafe(e_1);
+  });
+}
+function randomShuffleBy(randomizer, xs) {
+  const arr = toArray(xs);
+  randomShuffleInPlaceBy(randomizer, arr);
+  return ofArray(arr);
+}
+function randomShuffleWith(random, xs) {
+  return randomShuffleBy(() => random.NextDouble(), xs);
+}
+function randomShuffle(xs) {
+  return randomShuffleWith(nonSeeded(), xs);
+}
+function randomChoiceBy(randomizer, xs) {
+  return randomChoiceBy$1(randomizer, toArray(xs));
+}
+function randomChoiceWith(random, xs) {
+  return randomChoiceWith$1(random, toArray(xs));
+}
+function randomChoice(xs) {
+  return randomChoice$1(toArray(xs));
+}
+function randomChoicesBy(randomizer, count, xs) {
+  return ofArray(randomChoicesBy$1(randomizer, count, toArray(xs)));
+}
+function randomChoicesWith(random, count, xs) {
+  return randomChoicesBy(() => random.NextDouble(), count, xs);
+}
+function randomChoices(count, xs) {
+  return randomChoicesWith(nonSeeded(), count, xs);
+}
+function randomSampleBy(randomizer, count, xs) {
+  return ofArray(randomSampleBy$1(randomizer, count, toArray(xs)));
+}
+function randomSampleWith(random, count, xs) {
+  return randomSampleBy(() => random.NextDouble(), count, xs);
+}
+function randomSample(count, xs) {
+  return randomSampleWith(nonSeeded(), count, xs);
+}
+
+export { CachedSeq$1, CachedSeq$1_$ctor_Z7A8347D4, CachedSeq$1_$reflection, CachedSeq$1__Clear, Enumerator_FromFunctions$1, Enumerator_FromFunctions$1_$ctor_58C54629, Enumerator_FromFunctions$1_$reflection, Enumerator_Seq, Enumerator_Seq_$ctor_673A07F2, Enumerator_Seq_$reflection, Enumerator_alreadyFinished, Enumerator_cast, Enumerator_concat, Enumerator_enumerateThenFinally, Enumerator_generateWhileSome, Enumerator_noReset, Enumerator_notStarted, Enumerator_unfold, SR_enumerationAlreadyFinished, SR_enumerationNotStarted, SR_inputSequenceEmpty, SR_inputSequenceTooLong, SR_keyNotFoundAlt, SR_notEnoughElements, SR_resetNotSupported, allPairs, append, average, averageBy, cache, cast, choose, chunkBySize, collect, compareWith, concat, contains, delay, empty, enumerateFromFunctions, enumerateThenFinally, enumerateTryWith, enumerateUsing, enumerateWhile, exactlyOne, exists, exists2, filter, find, findBack, findIndex, findIndexBack, fold, fold2, foldBack, foldBack2, forAll, forAll2, generate, generateIndexed, head, indexNotFound, indexed, initialize, initializeInfinite, insertAt, insertManyAt, isEmpty, item, iterate, iterate2, iterateIndexed, iterateIndexed2, last, length, map, map2, map3, mapFold, mapFoldBack, mapIndexed, mapIndexed2, max, maxBy, min, minBy, mkSeq, ofArray, ofList, ofSeq, pairwise, permute, pick, randomChoice, randomChoiceBy, randomChoiceWith, randomChoices, randomChoicesBy, randomChoicesWith, randomSample, randomSampleBy, randomSampleWith, randomShuffle, randomShuffleBy, randomShuffleWith, readOnly, reduce, reduceBack, removeAt, removeManyAt, replicate, reverse, scan, scanBack, singleton, skip, skipWhile, sort, sortBy, sortByDescending, sortDescending, sortWith, splitInto, sum, sumBy, tail, take, takeWhile, toArray, toList, transpose, truncate, tryExactlyOne, tryFind, tryFindBack, tryFindIndex, tryFindIndexBack, tryHead, tryItem, tryLast, tryPick, unfold, updateAt, where, windowed, zip, zip3 };