@fncts/base 0.0.39 → 0.0.41

package/_mjs/collection/immutable/ReadonlyArray/api.mjs

@@ -0,0 +1,1302 @@
+const fileName_1 = "(@fncts/base) src/collection/immutable/ReadonlyArray/api.ts";
+import * as tsplus_module_1 from "@fncts/base/data/These/constructors";
+import * as tsplus_module_2 from "@fncts/base/data/Maybe/definition";
+import * as tsplus_module_3 from "@fncts/base/control/Eval/run";
+import * as tsplus_module_4 from "@fncts/base/control/Eval/constructors";
+import * as tsplus_module_5 from "@fncts/base/control/Eval/instance";
+import * as tsplus_module_6 from "@fncts/base/control/Eval/api";
+import * as tsplus_module_7 from "@fncts/base/data/Zipped";
+import * as tsplus_module_8 from "@fncts/base/data/Maybe/constructors";
+import * as tsplus_module_9 from "@fncts/base/collection/immutable/ReadonlyNonEmptyArray/constructors";
+import * as tsplus_module_10 from "@fncts/base/collection/immutable/Dictionary/definition";
+import * as tsplus_module_11 from "@fncts/base/collection/immutable/Dictionary/api";
+import * as tsplus_module_12 from "@fncts/base/data/Ord/instances";
+import * as tsplus_module_13 from "@fncts/base/collection/immutable/ReadonlyArray/constructors";
+import * as tsplus_module_14 from "@fncts/base/data/Either/destructors";
+export const alignWith = alignWith_1;
+export const append = append_1;
+export const chop = chop_1;
+export const crossWith = crossWith_1;
+export const elem = elem_1;
+export const everyWithIndex = everyWithIndex_1;
+export const filterMapWithIndex = filterMapWithIndex_1;
+export const filterWithIndex = filterWithIndex_1;
+export const findLastMapWithIndex = findLastMapWithIndex_1;
+export const findMapWithIndex = findMapWithIndex_1;
+export const findWithIndex = findWithIndex_1;
+export const flatMapWithIndex = flatMapWithIndex_1;
+export const flatten = flatten_1;
+export const fold = fold_1;
+export const foldLeft = foldLeft_1;
+export const foldLeftWithIndex = foldLeftWithIndex_1;
+export const foldLeftWithIndexWhile = foldLeftWithIndexWhile_1;
+export const foldMapWithIndex = foldMapWithIndex_1;
+export const foldRightWithIndex = foldRightWithIndex_1;
+export const foldRightWithIndexWhile = foldRightWithIndexWhile_1;
+export const get = get_1;
+export const isEmpty = isEmpty_1;
+export const isNonEmpty = isNonEmpty_1;
+export const isOutOfBound = isOutOfBound_1;
+export const mapWithIndex = mapWithIndex_1;
+export const mutableClone = mutableClone_1;
+export const mutate = mutate_1;
+export const partitionMapWithIndex = partitionMapWithIndex_1;
+export const partitionWithIndex = partitionWithIndex_1;
+export const prepend = prepend_1;
+export const prependAll = prependAll_1;
+export const rotate = rotate_1;
+export const sort = sort_1;
+export const spanIndexLeft = spanIndexLeft_1;
+export const spanIndexRight = spanIndexRight_1;
+export const traverse_ = traverse_1;
+export const traverseWithIndex_ = traverseWithIndex_1;
+export const unsafeDeleteAt = unsafeDeleteAt_1;
+export const unsafeInsertAt = unsafeInsertAt_1;
+export const unsafeModifyAt = unsafeModifyAt_1;
+export const unsafeUpdateAt = unsafeUpdateAt_1;
+export const wiltWithIndex_ = wiltWithIndex_1;
+export const witherWithIndex_ = witherWithIndex_1;
+export const zipWith = zipWith_1;
+import { identity, pipe, tuple } from "@fncts/base/data/function";
+import * as P from "@fncts/base/typeclass";
+/**
+ * @tsplus pipeable fncts.ReadonlyArray align
+ */
+export function align(fb) {
+  return self => {
+    return alignWith_1(fb, identity)(self);
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray alignWith
+ */
+function alignWith_1(fb, f) {
+  return self => {
+    const selfArray = self;
+    const thatArray = fb;
+    const minlen = Math.min(selfArray.length, thatArray.length);
+    const maxlen = Math.max(selfArray.length, thatArray.length);
+    const ret = Array(maxlen);
+    for (let i = 0; i < minlen; i++) {
+      ret[i] = f(tsplus_module_1.both(selfArray[i], thatArray[i]));
+    }
+    if (minlen === maxlen) {
+      return ret;
+    } else if (selfArray.length > thatArray.length) {
+      for (let i = minlen; i < maxlen; i++) {
+        ret[i] = f(tsplus_module_1.left(selfArray[i]));
+      }
+    } else {
+      for (let i = minlen; i < maxlen; i++) {
+        ret[i] = f(tsplus_module_1.right(thatArray[i]));
+      }
+    }
+    return ret;
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray alt
+ */
+export function alt(that) {
+  return self => {
+    return self.concat(that());
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray ap
+ */
+export function ap(fa) {
+  return self => {
+    return self.flatMap(f => fa.map(f));
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray append
+ */
+function append_1(last) {
+  return self => {
+    const selfArray = self;
+    const len = selfArray.length;
+    const r = Array(len + 1);
+    r[len] = last;
+    for (let i = 0; i < len; i++) {
+      r[i] = selfArray[i];
+    }
+    return r;
+  };
+}
+/**
+ * @tsplus static fncts.ReadonlyArrayOps chainRecBreadthFirst
+ */
+export function chainRecBreadthFirst(a, f) {
+  const initial = f(a);
+  const buffer = [];
+  const out = [];
+  function go(e) {
+    void 0;
+    if (e._tag === "Left") {
+      f(e.left).forEach(v => buffer.push(v));
+    } else {
+      out.push(e.right);
+    }
+  }
+  for (const e of initial) {
+    go(e);
+  }
+  while (buffer.length > 0) {
+    go(buffer.shift());
+  }
+  return out;
+}
+/**
+ * @tsplus static fncts.ReadonlyArrayOps chainRecDepthFirst
+ */
+export function chainRecDepthFirst(a, f) {
+  const buffer = f(a).slice();
+  const out = [];
+  while (buffer.length > 0) {
+    const e = buffer.shift();
+    void 0;
+    if (e._tag === "Left" /* EitherTag.Left */) {
+      buffer.unshift(...f(e.left));
+    } else {
+      out.push(e.right);
+    }
+  }
+  return out;
+}
+/**
+ * A useful recursion pattern for processing a `Array` to produce a new `Array`,
+ * often used for "chopping" up the input `Array`. Typically chop is called with some function
+ * that will consume an initial prefix of the `Array` and produce a value and the rest of the `Array`.
+ *
+ * @tsplus pipeable fncts.ReadonlyArray chop
+ */
+function chop_1(f) {
+  return as => {
+    const result = [];
+    let cs = as;
+    while (isNonEmpty_1(cs)) {
+      const [b, c] = f(cs);
+      result.push(b);
+      cs = c;
+    }
+    return result;
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray collectWhile
+ */
+export function collectWhile(f) {
+  return as => {
+    const result = [];
+    for (let i = 0; i < as.length; i++) {
+      const o = f(as[i]);
+      if (tsplus_module_2.isJust(o)) {
+        result.push(o.value);
+      } else {
+        break;
+      }
+    }
+    return result;
+  };
+}
+export function comprehension(input, f, g = () => true) {
+  return tsplus_module_3.run(comprehensionLoop([], input, f, g));
+}
+function comprehensionLoop(scope, input, f, g) {
+  if (input.length === 0) {
+    return g(...scope) ? tsplus_module_4.now([f(...scope)]) : tsplus_module_4.now([]);
+  } else {
+    return tsplus_module_6.map(rs => flatten_1(rs))(traverse_1(input[0])(tsplus_module_5.Applicative)(a => comprehensionLoop(append_1(a)(scope), input.slice(1), f, g)));
+  }
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray concat
+ * @tsplus pipeable-operator fncts.ReadonlyArray +
+ */
+export function concat(that) {
+  return self => {
+    const lenx = self.length;
+    if (lenx === 0) {
+      return that;
+    }
+    const leny = that.length;
+    if (leny === 0) {
+      return self;
+    }
+    const r = Array(lenx + leny);
+    for (let i = 0; i < lenx; i++) {
+      r[i] = self[i];
+    }
+    for (let i = 0; i < leny; i++) {
+      r[i + lenx] = that[i];
+    }
+    return r;
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray cross
+ */
+export function cross(fb) {
+  return self => {
+    return crossWith_1(fb, (a, b) => tsplus_module_7.make(a, b))(self);
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray crossWith
+ */
+function crossWith_1(fb, f) {
+  return self => {
+    return self.flatMap(a => fb.map(b => f(a, b)));
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray deleteAt
+ */
+export function deleteAt(i) {
+  return as => {
+    return isOutOfBound_1(i)(as) ? tsplus_module_8.nothing(fileName_1 + ":255:40") : tsplus_module_8.just(unsafeDeleteAt_1(i)(as), fileName_1 + ":255:49");
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray difference
+ */
+export function difference(ys, /** @tsplus auto */E) {
+  return self => {
+    return self.filter(a => !elem_1(a, E)(ys));
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray drop
+ */
+export function drop(n) {
+  return self => {
+    return self.slice(n);
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray dropLast
+ */
+export function dropLast(n) {
+  return self => {
+    return self.slice(0, self.length - n);
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray dropLastWhile
+ */
+export function dropLastWhile(p) {
+  return as => {
+    return as.slice(0, spanIndexRight_1(p)(as) + 1);
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray dropWhile
+ */
+export function dropWhile(p) {
+  return self => {
+    return self.slice(spanIndexLeft_1(p)(self));
+  };
+}
+/**
+ * Test if a value is a member of an array. Takes an `Eq<A>` as a single
+ * argument which returns the function to use to search for a value of type `A` in
+ * an array of type `ReadonlyArray<A>`.
+ *
+ * @tsplus pipeable fncts.ReadonlyArray elem
+ * @tsplus pipeable fncts.Array elem
+ */
+function elem_1(a, /** @tsplus auto */E) {
+  return as => {
+    const predicate = element => E.equals(a)(element);
+    const len = as.length;
+    for (let i = 0; i < len; i++) {
+      if (predicate(as[i])) {
+        return true;
+      }
+    }
+    return false;
+  };
+}
+export function every(p) {
+  return self => {
+    return everyWithIndex_1((_, a) => p(a))(self);
+  };
+}
+function everyWithIndex_1(p) {
+  return self => {
+    let result = true;
+    let i = 0;
+    while (result && i < self.length) {
+      result = p(i, self[i]);
+      i++;
+    }
+    return result;
+  };
+}
+export function filter(p) {
+  return self => {
+    return filterWithIndex_1((_, a) => p(a))(self);
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray filterMap
+ */
+export function filterMap(f) {
+  return self => {
+    return filterMapWithIndex_1((_, a) => f(a))(self);
+  };
+}
+/**
+ * @tsplus pipeable fncts.Array filterMap
+ * @tsplus pipeable fncts.ReadonlyArray filterMap
+ */
+export function filterMapUndefined(f) {
+  return self => {
+    const out = [];
+    for (let i = 0; i < self.length; i++) {
+      const v = f(self[i]);
+      if (v !== undefined) {
+        out.push(v);
+      }
+    }
+    return out;
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray filterMapWithIndex
+ */
+function filterMapWithIndex_1(f) {
+  return fa => {
+    const result = [];
+    for (let i = 0; i < fa.length; i++) {
+      const maybeB = f(i, fa[i]);
+      if (tsplus_module_2.isJust(maybeB)) {
+        result.push(maybeB.value);
+      }
+    }
+    return result;
+  };
+}
+function filterWithIndex_1(p) {
+  return self => {
+    const result = [];
+    for (let i = 0; i < self.length; i++) {
+      const a = self[i];
+      if (p(i, a)) {
+        result.push(a);
+      }
+    }
+    return result;
+  };
+}
+export function find(p) {
+  return self => {
+    return findWithIndex_1((_, a) => p(a))(self);
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray findIndex
+ */
+export function findIndex(predicate) {
+  return as => {
+    return findMapWithIndex_1((i, a) => predicate(a) ? tsplus_module_8.just(i, fileName_1 + ":443:62") : tsplus_module_8.nothing(fileName_1 + ":443:75"))(as);
+  };
+}
+export function findLast(p) {
+  return as => {
+    const len = as.length;
+    for (let i = len - 1; i >= 0; i--) {
+      if (p(as[i])) {
+        return tsplus_module_8.just(as[i], fileName_1 + ":457:20");
+      }
+    }
+    return tsplus_module_8.nothing(fileName_1 + ":460:19");
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray findLastIndex
+ */
+export function findLastIndex(p) {
+  return self => {
+    return findLastMapWithIndex_1((i, a) => p(a) ? tsplus_module_8.just(i, fileName_1 + ":468:60") : tsplus_module_8.nothing(fileName_1 + ":468:73"))(self);
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray findLastMap
+ */
+export function findLastMap(f) {
+  return as => {
+    return findLastMapWithIndex_1((_, a) => f(a))(as);
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray findLastMapWithIndex
+ */
+function findLastMapWithIndex_1(f) {
+  return as => {
+    const len = as.length;
+    for (let i = len - 1; i >= 0; i--) {
+      const v = f(i, as[i]);
+      if (tsplus_module_2.isJust(v)) {
+        return v;
+      }
+    }
+    return tsplus_module_8.nothing(fileName_1 + ":493:19");
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray findMap
+ */
+export function findMap(f) {
+  return as => {
+    return findMapWithIndex_1((_, a) => f(a))(as);
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray findMapWithIndex
+ */
+function findMapWithIndex_1(f) {
+  return as => {
+    const len = as.length;
+    for (let i = 0; i < len; i++) {
+      const v = f(i, as[i]);
+      if (tsplus_module_2.isJust(v)) {
+        return v;
+      }
+    }
+    return tsplus_module_8.nothing(fileName_1 + ":516:19");
+  };
+}
+function findWithIndex_1(p) {
+  return as => {
+    const len = as.length;
+    for (let i = 0; i < len; i++) {
+      if (p(i, as[i])) {
+        return tsplus_module_8.just(as[i], fileName_1 + ":530:20");
+      }
+    }
+    return tsplus_module_8.nothing(fileName_1 + ":533:19");
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray flatMap
+ */
+export function flatMap(f) {
+  return self => {
+    return flatMapWithIndex_1((_, a) => f(a))(self);
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray flatMapWithIndex
+ */
+function flatMapWithIndex_1(f) {
+  return self => {
+    let outLen = 0;
+    const len = self.length;
+    const temp = Array(len);
+    for (let i = 0; i < len; i++) {
+      const e = self[i];
+      const arr = f(i, e);
+      outLen += arr.length;
+      temp[i] = arr;
+    }
+    const out = Array(outLen);
+    let start = 0;
+    for (let i = 0; i < len; i++) {
+      const arr = temp[i];
+      const l = arr.length;
+      for (let j = 0; j < l; j++) {
+        out[j + start] = arr[j];
+      }
+      start += l;
+    }
+    return out;
+  };
+}
+/**
+ * @tsplus getter fncts.ReadonlyArray flatten
+ */
+function flatten_1(self) {
+  return self.flatMap(identity);
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray fold
+ */
+function fold_1(/** @tsplus auto */M) {
+  return self => {
+    return foldLeft_1(M.nat, (b, a) => M.combine(a)(b))(self);
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray foldLeft
+ * @tsplus pipeable fncts.Array foldLeft
+ */
+function foldLeft_1(b, f) {
+  return self => {
+    return foldLeftWithIndex_1(b, (_, b, a) => f(b, a))(self);
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray foldLeftWhile
+ * @tsplus pipeable fncts.Array foldLeftWhile
+ */
+export function foldLeftWhile(b, p, f) {
+  return self => {
+    return foldLeftWithIndexWhile_1(b, p, (_, b, a) => f(b, a))(self);
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray foldLeftWithIndex
+ * @tsplus pipeable fncts.Array foldLeftWithIndex
+ */
+function foldLeftWithIndex_1(b, f) {
+  return self => {
+    const len = self.length;
+    let r = b;
+    for (let i = 0; i < len; i++) {
+      r = f(i, r, self[i]);
+    }
+    return r;
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray foldLeftWithIndexWhile
+ * @tsplus pipeable fncts.Array foldLeftWithIndexWhile
+ */
+function foldLeftWithIndexWhile_1(b, p, f) {
+  return self => {
+    let out = b;
+    let cont = p(out);
+    for (let i = 0; cont && i < self.length; i++) {
+      out = f(i, out, self[i]);
+      cont = p(out);
+    }
+    return out;
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray foldMap
+ */
+export function foldMap(f, /** @tsplus auto */M) {
+  return self => {
+    return foldMapWithIndex_1((_, a) => f(a), M)(self);
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray foldMapWithIndex
+ */
+function foldMapWithIndex_1(f, /** @tsplus auto */M) {
+  return self => {
+    return foldLeftWithIndex_1(M.nat, (i, b, a) => M.combine(f(i, a))(b))(self);
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray foldRight
+ */
+export function foldRight(b, f) {
+  return self => {
+    return foldRightWithIndex_1(b, (_, a, b) => f(a, b))(self);
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray foldRighWhile
+ */
+export function foldRightWhile(b, p, f) {
+  return self => {
+    return foldRightWithIndexWhile_1(b, p, (_, a, b) => f(a, b))(self);
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray foldRightWithIndex
+ */
+function foldRightWithIndex_1(b, f) {
+  return self => {
+    let r = b;
+    for (let i = self.length - 1; i >= 0; i--) {
+      r = f(i, self[i], r);
+    }
+    return r;
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray foldRightWithIndexWhile
+ */
+function foldRightWithIndexWhile_1(b, predicate, f) {
+  return self => {
+    let out = b;
+    let cont = predicate(out);
+    for (let i = self.length - 1; cont && i >= 0; i--) {
+      out = f(i, self[i], out);
+      cont = predicate(out);
+    }
+    return out;
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray forEach
+ */
+export function forEach(f) {
+  return self => {
+    return self.forEach(f);
+  };
+}
+/**
+ * @tsplus static fncts.ArrayOps fromValue
+ */
+export function fromValue(value) {
+  if (Array.isArray(value)) {
+    return value;
+  } else {
+    return [value];
+  }
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray get
+ * @tsplus pipeable fncts.MutableArray get
+ */
+function get_1(i) {
+  return self => {
+    return isOutOfBound_1(i)(self) ? tsplus_module_8.nothing(fileName_1 + ":729:42") : tsplus_module_8.just(self[i], fileName_1 + ":729:51");
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray group
+ */
+export function group(E) {
+  return chop_1(self => {
+    const h = self[0];
+    const out = [h];
+    let i = 1;
+    for (; i < self.length; i++) {
+      const a = self[i];
+      if (E.equals(h)(a)) {
+        out.push(a);
+      } else {
+        break;
+      }
+    }
+    return [tsplus_module_9.unsafeAsNonEmptyArray(out), self.slice(i)];
+  });
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray groupBy
+ */
+export function groupBy(f) {
+  return self => {
+    const out = {};
+    for (let i = 0; i < self.length; i++) {
+      const a = self[i];
+      const k = f(a);
+      if (Object.prototype.hasOwnProperty.call(out, k)) {
+        out[k].push(a);
+      } else {
+        out[k] = [a];
+      }
+    }
+    return tsplus_module_11.map(tsplus_module_9.from)(tsplus_module_10.Dictionary.get(out));
+  };
+}
+/**
+ * @tsplus getter fncts.ReadonlyArray head
+ */
+export function head(self) {
+  return isNonEmpty_1(self) ? tsplus_module_8.just(self[0], fileName_1 + ":776:34") : tsplus_module_8.nothing(fileName_1 + ":776:53");
+}
+/**
+ * @tsplus getter fncts.ReadonlyArray init
+ */
+export function init(self) {
+  const len = self.length;
+  return len === 0 ? tsplus_module_8.nothing(fileName_1 + ":784:29") : tsplus_module_8.just(self.slice(0, len - 1), fileName_1 + ":784:38");
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray insertAt
+ */
+export function insertAt(i, a) {
+  return self => {
+    return isOutOfBound_1(i)(self) ? tsplus_module_8.nothing(fileName_1 + ":792:42") : tsplus_module_8.just(unsafeInsertAt_1(i, a)(self), fileName_1 + ":792:51");
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray intersection
+ */
+export function intersection(that, /** @tsplus auto */E) {
+  return self => {
+    return self.filter(a => elem_1(a, E)(that));
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray intersperse
+ */
+export function intersperse(a) {
+  return self => {
+    const len = self.length;
+    return len === 0 ? self : prepend_1(self[0])(prependAll_1(a)(self.slice(1, len)));
+  };
+}
+/**
+ * @tsplus fluent fncts.ReadonlyArray isEmpty
+ */
+function isEmpty_1(self) {
+  return self.length === 0;
+}
+/**
+ * @tsplus fluent fncts.ReadonlyArray isNonEmpty
+ */
+function isNonEmpty_1(self) {
+  return self.length > 0;
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray isOutOfBound
+ */
+function isOutOfBound_1(i) {
+  return self => {
+    return i < 0 || i >= self.length;
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray join
+ */
+export function join(separator) {
+  return self => {
+    return self.join(separator);
+  };
+}
+/**
+ * @tsplus getter fncts.ReadonlyArray last
+ */
+export function last(self) {
+  return get_1(self.length - 1)(self);
+}
+/**
+ * @tsplus getter fncts.ReadonlyArray lefts
+ */
+export function lefts(self) {
+  const ls = [];
+  for (let i = 0; i < self.length; i++) {
+    const a = self[i];
+    void 0;
+    if (a._tag === "Left" /* EitherTag.Left */) {
+      ls.push(a.left);
+    }
+  }
+  return ls;
+}
+/**
+ * @tsplus getter fncts.ReadonlyArray length
+ */
+export function length(self) {
+  return self.length;
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray map
+ */
+export function map(f) {
+  return self => {
+    return mapWithIndex_1((_, a) => f(a))(self);
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray mapAccum
+ */
+export function mapAccum(s, f) {
+  return self => {
+    const bs = Array(self.length);
+    let state = s;
+    for (let i = 0; i < self.length; i++) {
+      const result = f(state, self[i]);
+      bs[i] = result[0];
+      state = result[1];
+    }
+    return [bs, state];
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray mapWithIndex
+ */
+function mapWithIndex_1(f) {
+  return self => {
+    const len = self.length;
+    const bs = Array(len);
+    for (let i = 0; i < len; i++) {
+      bs[i] = f(i, self[i]);
+    }
+    return bs;
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray modifyAt
+ */
+export function modifyAt(i, f) {
+  return self => {
+    return isOutOfBound_1(i)(self) ? tsplus_module_8.nothing(fileName_1 + ":920:42") : tsplus_module_8.just(unsafeModifyAt_1(i, f)(self), fileName_1 + ":920:51");
+  };
+}
+/**
+ * @tsplus getter fncts.ReadonlyArray mutableClone
+ */
+function mutableClone_1(self) {
+  return self.slice(0);
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray mutate
+ */
+function mutate_1(f) {
+  return self => {
+    const mut = mutableClone_1(self);
+    f(mut);
+    return mut;
+  };
+}
+export function partition(p) {
+  return self => {
+    return partitionWithIndex_1((_, a) => p(a))(self);
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray partitionMap
+ */
+export function partitionMap(f) {
+  return self => {
+    return partitionMapWithIndex_1((_, a) => f(a))(self);
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray partitionMapWithIndex
+ */
+function partitionMapWithIndex_1(f) {
+  return self => {
+    const left = [];
+    const right = [];
+    for (let i = 0; i < self.length; i++) {
+      const ea = f(i, self[i]);
+      void 0;
+      switch (ea._tag) {
+        case "Left" /* EitherTag.Left */:
+          left.push(ea.left);
+          break;
+        case "Right" /* EitherTag.Right */:
+          right.push(ea.right);
+          break;
+      }
+    }
+    return [left, right];
+  };
+}
+function partitionWithIndex_1(p) {
+  return self => {
+    const left = [];
+    const right = [];
+    for (let i = 0; i < self.length; i++) {
+      const a = self[i];
+      if (p(i, a)) {
+        right.push(a);
+      } else {
+        left.push(a);
+      }
+    }
+    return [left, right];
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray prepend
+ */
+function prepend_1(head) {
+  return self => {
+    const len = self.length;
+    const out = Array(len + 1);
+    out[0] = head;
+    for (let i = 0; i < len; i++) {
+      out[i + 1] = self[i];
+    }
+    return out;
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray prependAll
+ * @tsplus pipeable fncts.Array prependAll
+ */
+function prependAll_1(a) {
+  return self => {
+    const out = [];
+    for (let i = 0; i < self.length; i++) {
+      out.push(a, self[i]);
+    }
+    return out;
+  };
+}
+/**
+ * @tsplus getter fncts.ReadonlyArray reverse
+ */
+export function reverse(self) {
+  if (isEmpty_1(self)) {
+    return self;
+  } else if (self.length === 1) {
+    return [self[0]];
+  } else {
+    const out = Array(self.length);
+    for (let j = 0, i = self.length - 1; i >= 0; i--, j++) {
+      out[j] = self[i];
+    }
+    return out;
+  }
+}
+/**
+ * @tsplus getter fncts.ReadonlyArray rights
+ */
+export function rights(self) {
+  const rs = [];
+  for (let i = 0; i < self.length; i++) {
+    const a = self[i];
+    void 0;
+    if (a._tag === "Right" /* EitherTag.Right */) {
+      rs.push(a.right);
+    }
+  }
+  return rs;
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray rotate
+ */
+function rotate_1(n) {
+  return self => {
+    const len = self.length;
+    if (n === 0 || len <= 1 || len === Math.abs(n)) {
+      return self;
+    } else if (n < 0) {
+      return rotate_1(len + n)(self);
+    } else {
+      return self.slice(-n).concat(self.slice(0, len - n));
+    }
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray scanLeft
+ */
+export function scanLeft(b, f) {
+  return self => {
+    const l = self.length;
+    const r = Array(l + 1);
+    r[0] = b;
+    for (let i = 0; i < l; i++) {
+      r[i + 1] = f(r[i], self[i]);
+    }
+    return r;
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray scanRight
+ */
+export function scanRight(b, f) {
+  return self => {
+    const l = self.length;
+    const r = Array(l + 1);
+    r[l] = b;
+    for (let i = l - 1; i >= 0; i--) {
+      r[i] = f(self[i], r[i + 1]);
+    }
+    return r;
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray some
+ */
+export function some(p) {
+  return self => {
+    let result = false;
+    let i = 0;
+    while (!result && i < self.length) {
+      result = p(self[i]);
+      i++;
+    }
+    return result;
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray sort
+ */
+function sort_1(/** @tsplus auto */O) {
+  return self => {
+    return isEmpty_1(self) || self.length === 1 ? self : self.slice().sort((a, b) => O.compare(b)(a));
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray sortBy
+ */
+export function sortBy(Os) {
+  return self => {
+    return sort_1(fold_1(tsplus_module_12.getMonoid())(Os))(self);
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray spanIndexLeft
+ */
+function spanIndexLeft_1(p) {
+  return self => {
+    const l = self.length;
+    let i = 0;
+    for (; i < l; i++) {
+      if (!p(self[i])) {
+        break;
+      }
+    }
+    return i;
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray spanIndexRight
+ */
+function spanIndexRight_1(predicate) {
+  return as => {
+    let i = as.length - 1;
+    for (; i >= 0; i--) {
+      if (!predicate(as[i])) {
+        break;
+      }
+    }
+    return i;
+  };
+}
+export function spanLeft(p) {
+  return self => {
+    const i = spanIndexLeft_1(p)(self);
+    const init = Array(i);
+    for (let j = 0; j < i; j++) {
+      init[j] = self[j];
+    }
+    const l = self.length;
+    const rest = Array(l - i);
+    for (let j = i; j < l; j++) {
+      rest[j - i] = self[j];
+    }
+    return [init, rest];
+  };
+}
+export function spanRight(p) {
+  return self => {
+    const i = spanIndexRight_1(p)(self);
+    const l = self.length;
+    const tail = Array(l - i - 1);
+    for (let j = l - 1; j > i; j--) {
+      tail[j - i - 1] = self[j];
+    }
+    const rest = Array(i);
+    for (let j = i; j >= 0; j--) {
+      rest[j] = self[j];
+    }
+    return [rest, tail];
+  };
+}
+/**
+ * @tsplus getter fncts.ReadonlyArray tail
+ */
+export function tail(self) {
+  return isNonEmpty_1(self) ? tsplus_module_8.just(self.slice(1), fileName_1 + ":1234:34") : tsplus_module_8.nothing(fileName_1 + ":1234:59");
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray take
+ */
+export function take(n) {
+  return self => {
+    return self.slice(0, n);
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray takeLast
+ */
+export function takeLast(n) {
+  return as => {
+    return isEmpty_1(as) ? [] : as.slice(-n);
+  };
+}
+export function takeWhile(p) {
+  return self => {
+    const i = spanIndexLeft_1(p)(self);
+    const init = Array(i);
+    for (let j = 0; j < i; j++) {
+      init[j] = self[j];
+    }
+    return init;
+  };
+}
+/**
+ * @tsplus getter fncts.ReadonlyArray traverse
+ */
+function traverse_1(self) {
+  return G => f => traverseWithIndex_1(self)(G)((_, a) => f(a));
+}
+function traverseWithIndex_1(self) {
+  return G => f => foldLeftWithIndex_1(G.pure(tsplus_module_13.empty()), (i, fbs, a) => G.zipWith(f(i, a), (bs, b) => append_1(b)(bs))(fbs))(self);
+}
+export const traverseWithIndex = G => f => self => traverseWithIndex_1(self)(G)(f);
+export const traverse = G => f => self => traverseWithIndex_1(self)(G)((_, a) => f(a));
+/**
+ * @tsplus pipeable fncts.ReadonlyArray union
+ */
+export function union(that, /** @tsplus auto */E) {
+  return self => {
+    return self.concat(that.filter(a => !elem_1(a, E)(self)));
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray uniq
+ */
+export function uniq(/** @tsplus auto */E) {
+  return self => {
+    if (self.length === 1) {
+      return self;
+    }
+    const out = [];
+    const len = self.length;
+    for (let i = 0; i < len; i++) {
+      const a = self[i];
+      if (!elem_1(a, E)(out)) {
+        out.push(a);
+      }
+    }
+    return out;
+  };
+}
+/**
+ * @tsplus getter fncts.ReadonlyArray unprepend
+ */
+export function unprepend(self) {
+  return isNonEmpty_1(self) ? tsplus_module_8.just([self[0], self.slice(1)], fileName_1 + ":1345:34") : tsplus_module_8.nothing(fileName_1 + ":1345:71");
+}
+/**
+ * @tsplus getter fncts.ReadonlyArray unsafeAsMutable
+ */
+export function unsafeAsMutable(self) {
+  return self;
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray unsafeDeleteAt
+ */
+function unsafeDeleteAt_1(i) {
+  return self => {
+    return mutate_1(xs => {
+      xs.splice(i, 1);
+    })(self);
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray unsafeInsertAt
+ */
+function unsafeInsertAt_1(i, a) {
+  return as => {
+    return mutate_1(xs => {
+      xs.splice(i, 0, a);
+    })(as);
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray unsafeModifyAt
+ */
+function unsafeModifyAt_1(i, f) {
+  return as => {
+    const next = f(as[i]);
+    if (as[i] === next) {
+      return as;
+    }
+    return mutate_1(xs => {
+      xs[i] = next;
+    })(as);
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray unsafeUpdateAt
+ */
+function unsafeUpdateAt_1(i, a) {
+  return as => {
+    if (as[i] === a) {
+      return as;
+    } else {
+      return mutate_1(xs => {
+        xs[i] = a;
+      })(as);
+    }
+  };
+}
+/**
+ * @tsplus getter fncts.ReadonlyArray unzip
+ */
+export function unzip(self) {
+  const fa = Array(self.length);
+  const fb = Array(self.length);
+  for (let i = 0; i < self.length; i++) {
+    fa[i] = self[i][0];
+    fb[i] = self[i][1];
+  }
+  return [fa, fb];
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray updateAt
+ */
+export function updateAt(i, a) {
+  return as => {
+    return isOutOfBound_1(i)(as) ? tsplus_module_8.nothing(fileName_1 + ":1427:40") : tsplus_module_8.just(unsafeUpdateAt_1(i, a)(as), fileName_1 + ":1427:49");
+  };
+}
+/**
+ * @tsplus getter fncts.ReadonlyArray wilt
+ */
+export function wilt_(self) {
+  return G => f => wiltWithIndex_1(self)(G)((_, a) => f(a));
+}
+/**
+ * @tsplus getter fncts.ReadonlyArray wiltWithIndex
+ */
+function wiltWithIndex_1(self) {
+  return G => f => G.map(([b1s, b2s]) => [b1s, b2s])(foldLeftWithIndex_1(G.pure([[], []]), (i, fbs, a) => G.zipWith(fbs, (eb, r) => tsplus_module_14.match(b1 => {
+    r[0].push(b1);
+    return r;
+  }, b2 => {
+    r[1].push(b2);
+    return r;
+  })(eb))(f(i, a)))(self));
+}
+/**
+ * @tsplus getter fncts.ReadonlyArray wither
+ */
+export function wither_(self) {
+  return G => f => witherWithIndex_1(self)(G)((_, a) => f(a));
+}
+/**
+ * @tsplus getter fncts.ReadonlyArray witherWithIndex
+ */
+function witherWithIndex_1(self) {
+  return G => f => G.map(bs => bs)(foldLeftWithIndex_1(G.pure([]), (i, b, a) => G.zipWith(b, (maybeB, bs) => {
+    if (tsplus_module_2.isJust(maybeB)) {
+      bs.push(maybeB.value);
+    }
+    return bs;
+  })(f(i, a)))(self));
+}
+export const wiltWithIndex = G => f => self => wiltWithIndex_1(self)(G)(f);
+export const wilt = G => f => self => wiltWithIndex_1(self)(G)((_, a) => f(a));
+export const witherWithIndex = G => f => self => witherWithIndex_1(self)(G)(f);
+export const wither = G => f => self => witherWithIndex_1(self)(G)((_, a) => f(a));
+/**
+ * @tsplus pipeable fncts.ReadonlyArray zip
+ */
+export function zip(that) {
+  return self => {
+    return zipWith_1(that, tuple)(self);
+  };
+}
+/**
+ * @tsplus pipeable fncts.ReadonlyArray zipWith
+ */
+function zipWith_1(fb, f) {
+  return self => {
+    const len = Math.min(self.length, fb.length);
+    const fc = Array(len);
+    for (let i = 0; i < len; i++) {
+      fc[i] = f(self[i], fb[i]);
+    }
+    return fc;
+  };
+}
+//# sourceMappingURL=api.mjs.map