@fncts/base 0.0.1

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

@@ -0,0 +1,1514 @@
+import * as tsplus_module_1 from "@fncts/base/data/These/constructors";
+import * as tsplus_module_2 from "@fncts/base/collection/immutable/ImmutableArray/constructors";
+import * as tsplus_module_3 from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api";
+import * as tsplus_module_4 from "@fncts/base/data/Maybe/definition";
+import * as tsplus_module_5 from "@fncts/base/control/Eval/constructors";
+import * as tsplus_module_6 from "@fncts/base/control/Eval/instance";
+import * as tsplus_module_7 from "@fncts/base/control/Eval/api";
+import * as tsplus_module_8 from "@fncts/base/control/Eval/run";
+import * as tsplus_module_9 from "@fncts/base/data/Maybe/constructors";
+import * as tsplus_module_10 from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/constructors";
+import * as tsplus_module_11 from "@fncts/base/collection/immutable/Dictionary/api";
+import * as tsplus_module_12 from "@fncts/base/collection/immutable/Dictionary/definition";
+import * as tsplus_module_13 from "@fncts/base/typeclass/Ord/instances";
+import * as tsplus_module_14 from "@fncts/base/data/function/api";
+import * as tsplus_module_15 from "@fncts/base/data/Either/destructors";
+export const alignWith_ = alignWith_1;
+export const append_ = append_1;
+export const flatMapWithIndex_ = flatMapWithIndex_1;
+export const flatMap_ = flatMap_1;
+export const flatten = flatten_1;
+export const chop_ = chop_1;
+export const concat_ = concat_1;
+export const everyWithIndex_ = everyWithIndex_1;
+export const filter_ = filter_1;
+export const filterWithIndex_ = filterWithIndex_1;
+export const filterMapWithIndex_ = filterMapWithIndex_1;
+export const findWithIndex_ = findWithIndex_1;
+export const findMapWithIndex_ = findMapWithIndex_1;
+export const findLastMapWithIndex_ = findLastMapWithIndex_1;
+export const foldLeftWithIndex_ = foldLeftWithIndex_1;
+export const foldLeft_ = foldLeft_1;
+export const foldLeftWithIndexWhile_ = foldLeftWithIndexWhile_1;
+export const foldSelf = foldSelf_1;
+export const foldMapWithIndexSelf = foldMapWithIndexSelf_1;
+export const foldRightWithIndex_ = foldRightWithIndex_1;
+export const foldRightWithIndexWhile_ = foldRightWithIndexWhile_1;
+export const forEach_ = forEach_1;
+export const get_ = get_1;
+export const isEmpty = isEmpty_1;
+export const isNonEmpty = isNonEmpty_1;
+export const isOutOfBound_ = isOutOfBound_1;
+export const length = length_1;
+export const map_ = map_1;
+export const mapWithIndex_ = mapWithIndex_1;
+export const mutate_ = mutate_1;
+export const mutableClone = mutableClone_1;
+export const partitionWithIndex_ = partitionWithIndex_1;
+export const partitionMapWithIndex_ = partitionMapWithIndex_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 slice_ = slice_1;
+export const splitAt_ = splitAt_1;
+export const unsafeGet = unsafeGet_1;
+export const unsafeAsMutable = unsafeAsMutable_1;
+export const unsafeDeleteAt_ = unsafeDeleteAt_1;
+export const unsafeInsertAt_ = unsafeInsertAt_1;
+export const unsafeModifyAt_ = unsafeModifyAt_1;
+export const unsafeUpdateAt_ = unsafeUpdateAt_1;
+export const zipWith_ = zipWith_1;
+import { identity, tuple } from "@fncts/base/data/function";
+import * as P from "@fncts/base/typeclass";
+/**
+ * @tsplus fluent fncts.ImmutableArray alignWith
+ */
+
+function alignWith_1(self, fb, f) {
+  const selfArray = self._array;
+  const thatArray = fb._array;
+  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 tsplus_module_2.asImmutableArray(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 tsplus_module_2.asImmutableArray(ret);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray align
+ */
+
+
+export function align_(self, fb) {
+  return alignWith_1(self, fb, identity);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray alt
+ */
+
+export function alt_(self, that) {
+  return concat_1(self, that());
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray ap
+ */
+
+export function ap_(self, fa) {
+  return flatMap_1(self, f => map_1(fa, f));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray append
+ */
+
+function append_1(self, last) {
+  const selfArray = self._array;
+  const len = selfArray.length;
+  const r = Array(len + 1);
+  r[len] = last;
+
+  for (let i = 0; i < len; i++) {
+    r[i] = selfArray[i];
+  }
+
+  return tsplus_module_2.asImmutableArray(r);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray crossWith
+ */
+
+
+export function crossWith_(self, fb, f) {
+  return flatMap_1(self, a => map_1(fb, b => f(a, b)));
+}
+/**
+ * @tsplus static fncts.ImmutableArrayOps chainRecDepthFirst
+ */
+
+export function chainRecDepthFirst(a, f) {
+  const buffer = unsafeAsMutable_1(slice_1(f(a)));
+  const out = [];
+
+  while (buffer.length > 0) {
+    const e = buffer.shift();
+
+    if (e._tag === "Left"
+    /* EitherTag.Left */
+    ) {
+      buffer.unshift(...f(e.left));
+    } else {
+      out.push(e.right);
+    }
+  }
+
+  return tsplus_module_2.asImmutableArray(out);
+}
+/**
+ * @tsplus static fncts.ImmutableArrayOps chainRecBreadthFirst
+ */
+
+export function chainRecBreadthFirst(a, f) {
+  const initial = f(a);
+  const buffer = [];
+  const out = [];
+
+  function go(e) {
+    if (e._tag === "Left") {
+      forEach_1(f(e.left), v => buffer.push(v));
+    } else {
+      out.push(e.right);
+    }
+  }
+
+  for (const e of initial) {
+    go(e);
+  }
+
+  while (buffer.length > 0) {
+    go(buffer.shift());
+  }
+
+  return tsplus_module_2.asImmutableArray(out);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray flatMapWithIndex
+ */
+
+function flatMapWithIndex_1(self, f) {
+  let outLen = 0;
+  const selfArray = self._array;
+  const len = selfArray.length;
+  const temp = Array(len);
+
+  for (let i = 0; i < len; i++) {
+    const e = selfArray[i];
+
+    const arr = f(i, e)._array;
+
+    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 tsplus_module_2.asImmutableArray(out);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray flatMap
+ */
+
+
+function flatMap_1(self, f) {
+  return flatMapWithIndex_1(self, (_, a) => f(a));
+}
+/**
+ * @tsplus getter fncts.ImmutableArray flatten
+ */
+
+
+function flatten_1(self) {
+  return flatMap_1(self, identity);
+}
+/**
+ * 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 fluent fncts.ImmutableArray chop
+ */
+
+
+function chop_1(as, f) {
+  const result = [];
+  let cs = as;
+
+  while (isNonEmpty_1(cs)) {
+    const [b, c] = f(cs);
+    result.push(b);
+    cs = c;
+  }
+
+  return tsplus_module_2.asImmutableArray(result);
+}
+
+export const chop = f => as => chop_(as, f);
+/**
+ * @tsplus fluent fncts.ImmutableArray chunksOf
+ */
+
+export function chunksOf_(self, n) {
+  return chop_1(self, as => tsplus_module_3.splitAt_(as, n));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray collectWhile
+ */
+
+export function collectWhile_(as, f) {
+  const result = [];
+
+  for (let i = 0; i < length_1(as); i++) {
+    const o = f(as._array[i]);
+
+    if (tsplus_module_4.isJust(o)) {
+      result.push(o.value);
+    } else {
+      break;
+    }
+  }
+
+  return tsplus_module_2.asImmutableArray(result);
+}
+
+function comprehensionLoop(scope, input, f, g) {
+  if (input.length === 0) {
+    return g(...scope) ? tsplus_module_5.now(tsplus_module_2.make(f(...scope))) : tsplus_module_5.now(tsplus_module_2.empty());
+  } else {
+    return tsplus_module_7.map_(traverseSelf_1(input[0])(tsplus_module_6.Applicative)(a => comprehensionLoop(append_1(scope, a), input.slice(1), f, g)), rs => flatten_1(rs));
+  }
+}
+
+export function comprehension(input, f, g = () => true) {
+  return tsplus_module_8.run(comprehensionLoop(tsplus_module_2.empty(), input, f, g));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray concat
+ * @tsplus operator fncts.ImmutableArray +
+ * @tsplus operator fncts.base.MutableArray +
+ */
+
+function concat_1(self, that) {
+  const lenx = self._array.length;
+
+  if (lenx === 0) {
+    return that;
+  }
+
+  const leny = that._array.length;
+
+  if (leny === 0) {
+    return self;
+  }
+
+  const r = Array(lenx + leny);
+
+  for (let i = 0; i < lenx; i++) {
+    r[i] = self._array[i];
+  }
+
+  for (let i = 0; i < leny; i++) {
+    r[i + lenx] = that._array[i];
+  }
+
+  return tsplus_module_2.asImmutableArray(r);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray deleteAt
+ */
+
+
+export function deleteAt_(as, i) {
+  return isOutOfBound_1(as, i) ? tsplus_module_9.nothing() : tsplus_module_9.just(unsafeDeleteAt_1(as, i));
+}
+/**
+ * @constrained
+ */
+
+export function difference_(E) {
+  const elemE_ = elem_(E);
+  return (self, ys) => filter_1(self, a => !elemE_(ys, a));
+}
+/**
+ * @tsplus getter fncts.ImmutableArray difference
+ */
+
+export function differenceSelf(self) {
+  return E => that => difference_(E)(self, that);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray drop
+ */
+
+export function drop_(self, n) {
+  return slice_1(self, n);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray dropLast
+ */
+
+export function dropLast_(self, n) {
+  return slice_1(self, 0, length_1(self) - n);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray dropWhile
+ */
+
+export function dropWhile_(self, p) {
+  return slice_1(self, spanIndexLeft_1(self, p));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray dropLastWhile
+ */
+
+export function dropLastWhile_(as, p) {
+  return slice_1(as, 0, spanIndexRight_1(as, p) + 1);
+}
+/**
+ * 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 `ImmutableArray<A>`.
+ *
+ * @constrained
+ */
+
+export function elem_(E) {
+  return (as, a) => {
+    const predicate = element => E.equals_(element, a);
+
+    const len = length_1(as);
+
+    for (let i = 0; i < len; i++) {
+      if (predicate(as._array[i])) {
+        return true;
+      }
+    }
+
+    return false;
+  };
+}
+/**
+ * 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 `ImmutableArray<A>`.
+ *
+ * @tsplus getter fncts.ImmutableArray elem
+ */
+
+export function elemSelf(self) {
+  return E => a => elem_(E)(self, a);
+}
+export function every_(self, p) {
+  return everyWithIndex_1(self, (_, a) => p(a));
+}
+
+function everyWithIndex_1(self, p) {
+  let result = true;
+  let i = 0;
+
+  while (result && i < length_1(self)) {
+    result = p(i, self._array[i]);
+    i++;
+  }
+
+  return result;
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray exists
+ */
+
+
+export function exists_(self, p) {
+  let result = false;
+  let i = 0;
+
+  while (!result && i < length_1(self)) {
+    result = p(self._array[i]);
+    i++;
+  }
+
+  return result;
+}
+
+function filter_1(self, p) {
+  return filterWithIndex_1(self, (_, a) => p(a));
+}
+
+function filterWithIndex_1(self, p) {
+  const result = [];
+
+  for (let i = 0; i < length_1(self); i++) {
+    const a = self._array[i];
+
+    if (p(i, a)) {
+      result.push(a);
+    }
+  }
+
+  return tsplus_module_2.asImmutableArray(result);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray filterMapWithIndex
+ */
+
+
+function filterMapWithIndex_1(fa, f) {
+  const result = [];
+
+  for (let i = 0; i < length_1(fa); i++) {
+    const maybeB = f(i, unsafeGet_1(fa, i));
+
+    if (tsplus_module_4.isJust(maybeB)) {
+      result.push(maybeB.value);
+    }
+  }
+
+  return tsplus_module_2.asImmutableArray(result);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray filterMap
+ */
+
+
+export function filterMap_(self, f) {
+  return filterMapWithIndex_1(self, (_, a) => f(a));
+}
+export function find_(self, p) {
+  return findWithIndex_1(self, (_, a) => p(a));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray findIndex
+ */
+
+export function findIndex_(as, predicate) {
+  return findMapWithIndex_1(as, (i, a) => predicate(a) ? tsplus_module_9.just(i) : tsplus_module_9.nothing());
+}
+
+function findWithIndex_1(as, p) {
+  const len = length_1(as);
+
+  for (let i = 0; i < len; i++) {
+    if (p(i, as._array[i])) {
+      return tsplus_module_9.just(as._array[i]);
+    }
+  }
+
+  return tsplus_module_9.nothing();
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray findMap
+ */
+
+
+export function findMap_(as, f) {
+  return findMapWithIndex_1(as, (_, a) => f(a));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray findMapWithIndex
+ */
+
+function findMapWithIndex_1(as, f) {
+  const len = length_1(as);
+
+  for (let i = 0; i < len; i++) {
+    const v = f(i, as._array[i]);
+
+    if (tsplus_module_4.isJust(v)) {
+      return v;
+    }
+  }
+
+  return tsplus_module_9.nothing();
+}
+
+export function findLast_(as, p) {
+  const len = length_1(as);
+
+  for (let i = len - 1; i >= 0; i--) {
+    if (p(as._array[i])) {
+      return tsplus_module_9.just(as._array[i]);
+    }
+  }
+
+  return tsplus_module_9.nothing();
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray findLastIndex
+ */
+
+export function findLastIndex_(self, p) {
+  return findLastMapWithIndex_1(self, (i, a) => p(a) ? tsplus_module_9.just(i) : tsplus_module_9.nothing());
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray findLastMap
+ */
+
+export function findLastMap_(as, f) {
+  return findLastMapWithIndex_1(as, (_, a) => f(a));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray findLastMapWithIndex
+ */
+
+function findLastMapWithIndex_1(as, f) {
+  const len = length_1(as);
+
+  for (let i = len - 1; i >= 0; i--) {
+    const v = f(i, as._array[i]);
+
+    if (tsplus_module_4.isJust(v)) {
+      return v;
+    }
+  }
+
+  return tsplus_module_9.nothing();
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray foldLeftWithIndex
+ * @tsplus fluent fncts.base.MutableArray foldLeftWithIndex
+ */
+
+
+function foldLeftWithIndex_1(self, b, f) {
+  const len = length_1(self);
+  let r = b;
+
+  for (let i = 0; i < len; i++) {
+    r = f(i, r, self._array[i]);
+  }
+
+  return r;
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray foldLeft
+ * @tsplus fluent fncts.base.MutableArray foldLeft
+ */
+
+
+function foldLeft_1(self, b, f) {
+  return foldLeftWithIndex_1(self, b, (_, b, a) => f(b, a));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray foldLeftWhile
+ * @tsplus fluent fncts.base.MutableArray foldLeftWhile
+ */
+
+
+export function foldLeftWhile_(self, b, p, f) {
+  return foldLeftWithIndexWhile_1(self, b, p, (_, b, a) => f(b, a));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray foldLeftWithIndexWhile
+ * @tsplus fluent fncts.base.MutableArray foldLeftWithIndexWhile
+ */
+
+function foldLeftWithIndexWhile_1(self, b, p, f) {
+  let out = b;
+  let cont = p(out);
+
+  for (let i = 0; cont && i < length_1(self); i++) {
+    out = f(i, out, self._array[i]);
+    cont = p(out);
+  }
+
+  return out;
+}
+
+export function fold(M) {
+  return self => foldLeft_1(self, M.nat, M.combine_);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray fold
+ * @tsplus fluent fncts.base.MutableArray fold
+ */
+
+function foldSelf_1(self, M) {
+  return foldLeft_1(self, M.nat, M.combine_);
+}
+/**
+ * @constrained
+ */
+
+
+export function foldMapWithIndex_(M) {
+  return (self, f) => {
+    return foldLeftWithIndex_1(self, M.nat, (i, b, a) => M.combine_(b, f(i, a)));
+  };
+}
+/**
+ * @tsplus getter fncts.ImmutableArray foldMapWithIndex
+ * @tsplus getter fncts.base.MutableArray foldMapWithIndex
+ */
+
+function foldMapWithIndexSelf_1(self) {
+  return M => f => foldMapWithIndex_(M)(self, f);
+}
+/**
+ * @constrained
+ */
+
+
+export function foldMap_(M) {
+  return (self, f) => {
+    return foldMapWithIndexSelf_1(self)(M)((_, a) => f(a));
+  };
+}
+/**
+ * @tsplus getter fncts.ImmutableArray foldMap
+ * @tsplus getter fncts.base.MutableArray foldMap
+ */
+
+export function foldMapSelf(self) {
+  return M => f => foldMapWithIndexSelf_1(self)(M)((_, a) => f(a));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray foldRightWithIndex
+ * @tsplus fluent fncts.base.MutableArray foldRightWithIndex
+ */
+
+function foldRightWithIndex_1(self, b, f) {
+  let r = b;
+
+  for (let i = length_1(self) - 1; i >= 0; i--) {
+    r = f(i, self._array[i], r);
+  }
+
+  return r;
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray foldRight
+ * @tsplus fluent fncts.base.MutableArray foldRight
+ */
+
+
+export function foldRight_(self, b, f) {
+  return foldRightWithIndex_1(self, b, (_, a, b) => f(a, b));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray foldRighWhile
+ * @tsplus fluent fncts.base.MutableArray foldRightWhile
+ */
+
+export function foldRightWhile_(self, b, p, f) {
+  return foldRightWithIndexWhile_1(self, b, p, (_, a, b) => f(a, b));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray foldRightWithIndexWhile
+ * @tsplus fluent fncts.base.MutableArray foldRightWithIndexWhile
+ */
+
+function foldRightWithIndexWhile_1(self, b, predicate, f) {
+  let out = b;
+  let cont = predicate(out);
+
+  for (let i = length_1(self) - 1; cont && i >= 0; i--) {
+    out = f(i, self._array[i], out);
+    cont = predicate(out);
+  }
+
+  return out;
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray forEach
+ */
+
+
+function forEach_1(self, f) {
+  return forEach_1(self, f);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray get
+ * @tsplus fluent fncts.base.MutableArray get
+ */
+
+
+function get_1(self, i) {
+  return isOutOfBound_1(self, i) ? tsplus_module_9.nothing() : tsplus_module_9.just(self._array[i]);
+}
+
+export function group(E) {
+  return chop(self => {
+    const h = self._array[0];
+    const out = [h];
+    let i = 1;
+
+    for (; i < length_1(self); i++) {
+      const a = self._array[i];
+
+      if (E.equals_(a, h)) {
+        out.push(a);
+      } else {
+        break;
+      }
+    }
+
+    return [tsplus_module_10.unsafeAsNonEmptyArray(out), slice_1(self, i)];
+  });
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray group
+ */
+
+export function chopSelf(self, E) {
+  return group(E)(self);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray groupBy
+ */
+
+export function groupBy_(self, f) {
+  const out = {};
+
+  for (let i = 0; i < length_1(self); i++) {
+    const a = self._array[i];
+    const k = f(a);
+
+    if (Object.prototype.hasOwnProperty.call(out, k)) {
+      out[k].push(a);
+    } else {
+      out[k] = [a];
+    }
+  }
+
+  return tsplus_module_11.toRecord(tsplus_module_11.map_(tsplus_module_12.Dictionary.get(out), tsplus_module_10.from));
+}
+/**
+ * @tsplus getter fncts.ImmutableArray head
+ */
+
+export function head(self) {
+  return isNonEmpty_1(self) ? tsplus_module_9.just(self._array[0]) : tsplus_module_9.nothing();
+}
+/**
+ * @tsplus getter fncts.ImmutableArray init
+ */
+
+export function init(self) {
+  const len = length_1(self);
+  return len === 0 ? tsplus_module_9.nothing() : tsplus_module_9.just(slice_1(self, 0, len - 1));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray insertAt
+ */
+
+export function insertAt_(self, i, a) {
+  return isOutOfBound_1(self, i) ? tsplus_module_9.nothing() : tsplus_module_9.just(unsafeInsertAt_1(self, i, a));
+}
+export function intersection_(E) {
+  const elemE = elem_(E);
+  return (self, that) => filter_1(self, a => elemE(that, a));
+}
+/**
+ * @tsplus getter fncts.ImmutableArray intersection
+ */
+
+export function intersectionSelf(self) {
+  return E => that => intersection_(E)(self, that);
+}
+export function intersperse_(self, a) {
+  const len = length_1(self);
+  return len === 0 ? self : prepend_1(prependAll_1(slice_1(self, 1, len), a), unsafeGet_1(self, 0));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray isEmpty
+ */
+
+function isEmpty_1(self) {
+  return length_1(self) === 0;
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray isNonEmpty
+ */
+
+
+function isNonEmpty_1(self) {
+  return length_1(self) > 0;
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray isOutOfBound
+ */
+
+
+function isOutOfBound_1(self, i) {
+  return i < 0 || i >= length_1(self);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray join
+ */
+
+
+export function join(self, separator) {
+  return self._array.join(separator);
+}
+/**
+ * @tsplus getter fncts.ImmutableArray last
+ */
+
+export function last(self) {
+  return get_1(self, length_1(self) - 1);
+}
+/**
+ * @tsplus getter fncts.ImmutableArray length
+ */
+
+function length_1(self) {
+  return self._array.length;
+}
+/**
+ * @tsplus getter fncts.ImmutableArray lefts
+ */
+
+
+export function lefts(self) {
+  const ls = [];
+
+  for (let i = 0; i < length_1(self); i++) {
+    const a = self._array[i];
+
+    if (a._tag === "Left"
+    /* EitherTag.Left */
+    ) {
+      ls.push(a.left);
+    }
+  }
+
+  return tsplus_module_2.asImmutableArray(ls);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray map
+ */
+
+function map_1(self, f) {
+  return mapWithIndex_1(self, (_, a) => f(a));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray mapAccum
+ */
+
+
+export function mapAccum_(self, s, f) {
+  const bs = Array(length_1(self));
+  let state = s;
+
+  for (let i = 0; i < length_1(self); i++) {
+    const result = f(state, self._array[i]);
+    bs[i] = result[0];
+    state = result[1];
+  }
+
+  return [tsplus_module_2.asImmutableArray(bs), state];
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray mapWithIndex
+ */
+
+function mapWithIndex_1(self, f) {
+  const len = self._array.length;
+  const bs = Array(len);
+
+  for (let i = 0; i < len; i++) {
+    bs[i] = f(i, self._array[i]);
+  }
+
+  return tsplus_module_2.asImmutableArray(bs);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray modifyAt
+ */
+
+
+export function modifyAt_(self, i, f) {
+  return isOutOfBound_1(self, i) ? tsplus_module_9.nothing() : tsplus_module_9.just(unsafeModifyAt_1(self, i, f));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray mutate
+ */
+
+function mutate_1(self, f) {
+  const mut = mutableClone_1(self);
+  f(mut);
+  return tsplus_module_2.asImmutableArray(mut);
+}
+/**
+ * @tsplus getter fncts.ImmutableArray mutableClone
+ */
+
+
+function mutableClone_1(self) {
+  return slice_1(self, 0)._array;
+}
+
+function partitionWithIndex_1(self, p) {
+  const left = [];
+  const right = [];
+
+  for (let i = 0; i < length_1(self); i++) {
+    const a = self._array[i];
+
+    if (p(i, a)) {
+      right.push(a);
+    } else {
+      left.push(a);
+    }
+  }
+
+  return [tsplus_module_2.asImmutableArray(left), tsplus_module_2.asImmutableArray(right)];
+}
+
+export function partition_(self, p) {
+  return partitionWithIndex_1(self, (_, a) => p(a));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray partitionMapWithIndex
+ */
+
+function partitionMapWithIndex_1(self, f) {
+  const left = [];
+  const right = [];
+
+  for (let i = 0; i < length_1(self); i++) {
+    const ea = f(i, self._array[i]);
+
+    switch (ea._tag) {
+      case "Left"
+      /* EitherTag.Left */
+      :
+        left.push(ea.left);
+        break;
+
+      case "Right"
+      /* EitherTag.Right */
+      :
+        right.push(ea.right);
+        break;
+    }
+  }
+
+  return [tsplus_module_2.asImmutableArray(left), tsplus_module_2.asImmutableArray(right)];
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray partitionMap
+ */
+
+
+export function partitionMap_(self, f) {
+  return partitionMapWithIndex_1(self, (_, a) => f(a));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray prepend
+ */
+
+function prepend_1(self, head) {
+  const len = length_1(self);
+  const out = Array(len + 1);
+  out[0] = head;
+
+  for (let i = 0; i < len; i++) {
+    out[i + 1] = self._array[i];
+  }
+
+  return tsplus_module_2.asImmutableArray(out);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray prependAll
+ * @tsplus fluent fncts.base.MutableArray prependAll
+ */
+
+
+function prependAll_1(self, a) {
+  const out = [];
+
+  for (let i = 0; i < length_1(self); i++) {
+    out.push(a, self._array[i]);
+  }
+
+  return tsplus_module_2.asImmutableArray(out);
+}
+/**
+ * @tsplus getter fncts.ImmutableArray reverse
+ */
+
+
+export function reverse(self) {
+  if (isEmpty_1(self)) {
+    return self;
+  } else if (length_1(self) === 1) {
+    return tsplus_module_2.make(self._array[0]);
+  } else {
+    const out = Array(length_1(self));
+
+    for (let j = 0, i = length_1(self) - 1; i >= 0; i--, j++) {
+      out[j] = self._array[i];
+    }
+
+    return tsplus_module_2.asImmutableArray(out);
+  }
+}
+/**
+ * @tsplus getter fncts.ImmutableArray rights
+ */
+
+export function rights(self) {
+  const rs = [];
+
+  for (let i = 0; i < length_1(self); i++) {
+    const a = self._array[i];
+
+    if (a._tag === "Right"
+    /* EitherTag.Right */
+    ) {
+      rs.push(a.right);
+    }
+  }
+
+  return tsplus_module_2.asImmutableArray(rs);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray rotate
+ */
+
+function rotate_1(self, n) {
+  const len = length_1(self);
+
+  if (n === 0 || len <= 1 || len === Math.abs(n)) {
+    return self;
+  } else if (n < 0) {
+    return rotate_1(self, len + n);
+  } else {
+    return concat_1(slice_1(self, -n), slice_1(self, 0, len - n));
+  }
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray scanLeft
+ */
+
+
+export function scanLeft_(self, b, f) {
+  const l = length_1(self);
+  const r = Array(l + 1);
+  r[0] = b;
+
+  for (let i = 0; i < l; i++) {
+    r[i + 1] = f(r[i], self._array[i]);
+  }
+
+  return tsplus_module_2.asImmutableArray(r);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray scanRight
+ */
+
+export function scanRight_(self, b, f) {
+  const l = length_1(self);
+  const r = Array(l + 1);
+  r[l] = b;
+
+  for (let i = l - 1; i >= 0; i--) {
+    r[i] = f(self._array[i], r[i + 1]);
+  }
+
+  return tsplus_module_2.asImmutableArray(r);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray sort
+ */
+
+function sort_1(self, O) {
+  return isEmpty_1(self) || length_1(self) === 1 ? self : tsplus_module_2.asImmutableArray(self._array.slice().sort(O.compare_));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray sortBy
+ */
+
+
+export function sortBy(self, Os) {
+  return sort_1(self, foldSelf_1(Os, tsplus_module_13.getMonoid()));
+}
+export function spanLeft_(self, p) {
+  const i = spanIndexLeft_1(self, p);
+  const init = Array(i);
+
+  for (let j = 0; j < i; j++) {
+    init[j] = self._array[j];
+  }
+
+  const l = length_1(self);
+  const rest = Array(l - i);
+
+  for (let j = i; j < l; j++) {
+    rest[j - i] = self._array[j];
+  }
+
+  return [tsplus_module_2.asImmutableArray(init), tsplus_module_2.asImmutableArray(rest)];
+}
+export function spanRight_(self, p) {
+  const i = spanIndexRight_1(self, p);
+  const l = length_1(self);
+  const tail = Array(l - i - 1);
+
+  for (let j = l - 1; j > i; j--) {
+    tail[j - i - 1] = self._array[j];
+  }
+
+  const rest = Array(i);
+
+  for (let j = i; j >= 0; j--) {
+    rest[j] = self._array[j];
+  }
+
+  return [tsplus_module_2.asImmutableArray(rest), tsplus_module_2.asImmutableArray(tail)];
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray spanIndexLeft
+ */
+
+function spanIndexLeft_1(self, p) {
+  const l = length_1(self);
+  let i = 0;
+
+  for (; i < l; i++) {
+    if (!p(self._array[i])) {
+      break;
+    }
+  }
+
+  return i;
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray spanIndexRight
+ */
+
+
+function spanIndexRight_1(as, predicate) {
+  let i = length_1(as) - 1;
+
+  for (; i >= 0; i--) {
+    if (!predicate(as._array[i])) {
+      break;
+    }
+  }
+
+  return i;
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray slice
+ */
+
+
+function slice_1(self, start, end) {
+  return tsplus_module_2.asImmutableArray(self._array.slice(start, end));
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray splitAt
+ */
+
+
+function splitAt_1(as, n) {
+  return [slice_1(as, 0, n), slice_1(as, n)];
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray splitWhere
+ */
+
+
+export function splitWhere_(self, p) {
+  let cont = true;
+  let i = 0;
+
+  while (cont && i < length_1(self)) {
+    if (p(self._array[i])) {
+      cont = false;
+    } else {
+      i++;
+    }
+  }
+
+  return splitAt_1(self, i);
+}
+export const sequence = A => self => traverseSelf_1(self)(A)(identity);
+/**
+ * @tsplus getter fncts.ImmutableArray sequence
+ */
+
+export const sequenceSelf = self => A => traverseSelf_1(self)(A)(identity);
+/**
+ * @tsplus getter fncts.ImmutableArray tail
+ */
+
+export function tail(self) {
+  return isNonEmpty_1(self) ? tsplus_module_9.just(slice_1(self, 1)) : tsplus_module_9.nothing();
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray take
+ */
+
+export function take_(self, n) {
+  return slice_1(self, 0, n);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray takeLast
+ */
+
+export function takeLast_(as, n) {
+  return isEmpty_1(as) ? tsplus_module_2.empty() : slice_1(as, -n);
+}
+export function takeWhile_(self, p) {
+  const i = spanIndexLeft_1(self, p);
+  const init = Array(i);
+
+  for (let j = 0; j < i; j++) {
+    init[j] = self._array[j];
+  }
+
+  return tsplus_module_2.asImmutableArray(init);
+}
+export const traverseWithIndex_ = /*#__PURE__*/P.mkTraverseWithIndex_()(_ => A => (ta, f) => foldLeftWithIndex_1(ta, A.pure(tsplus_module_2.empty()), (i, fbs, a) => A.zipWith_(fbs, f(i, a), (bs, b) => append_1(bs, b))));
+/**
+ * @tsplus dataFirst traverseWithIndex_
+ */
+
+export const traverseWithIndex = A => f => self => traverseWithIndex_(A)(self, f);
+/**
+ * @tsplus getter fncts.ImmutableArray traverseWithIndex
+ */
+
+const traverseWithIndexSelf_1 = self => A => f => traverseWithIndex_(A)(self, f);
+
+export const traverseWithIndexSelf = traverseWithIndexSelf_1;
+export const traverse_ = A => (self, f) => traverseWithIndexSelf_1(self)(A)((_, a) => f(a));
+/**
+ * @tsplus dataFirst traverse_
+ */
+
+export const traverse = A => f => self => traverseWithIndexSelf_1(self)(A)((_, a) => f(a));
+/**
+ * @tsplus getter fncts.ImmutableArray traverse
+ */
+
+const traverseSelf_1 = self => A => f => traverseWithIndexSelf_1(self)(A)((_, a) => f(a));
+
+export const traverseSelf = traverseSelf_1;
+export function union_(E) {
+  const elemE = elem_(E);
+  return (self, that) => concat_1(self, filter_1(that, a => !elemE(self, a)));
+}
+export function uniq(E) {
+  return self => {
+    if (length_1(self) === 1) {
+      return self;
+    }
+
+    const elemE_ = elem_(E);
+    const out = [];
+    const len = length_1(self);
+
+    for (let i = 0; i < len; i++) {
+      const a = self._array[i];
+
+      if (!elemE_(tsplus_module_2.asImmutableArray(out), a)) {
+        out.push(a);
+      }
+    }
+
+    return tsplus_module_2.asImmutableArray(out);
+  };
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray uniq
+ */
+
+export function uniqSelf(self, E) {
+  return uniq(E)(self);
+}
+/**
+ * @tsplus getter fncts.ImmutableArray unprepend
+ */
+
+export function unprepend(self) {
+  return isNonEmpty_1(self) ? tsplus_module_9.just([unsafeGet_1(self, 0), slice_1(self, 1)]) : tsplus_module_9.nothing();
+}
+/**
+ * @tsplus index fncts.ImmutableArray
+ */
+
+function unsafeGet_1(self, i) {
+  return self._array[i];
+}
+/**
+ * @tsplus getter fncts.ImmutableArray unsafeAsMutable
+ */
+
+
+function unsafeAsMutable_1(self) {
+  return self._array;
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray unsafeDeleteAt
+ */
+
+
+function unsafeDeleteAt_1(self, i) {
+  return mutate_1(self, xs => {
+    xs.splice(i, 1);
+  });
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray unsafeInsertAt
+ */
+
+
+function unsafeInsertAt_1(as, i, a) {
+  return mutate_1(as, xs => {
+    xs.splice(i, 0, a);
+  });
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray unsafeModifyAt
+ */
+
+
+function unsafeModifyAt_1(as, i, f) {
+  const next = f(unsafeGet_1(as, i));
+
+  if (unsafeGet_1(as, i) === next) {
+    return as;
+  }
+
+  return mutate_1(as, xs => {
+    xs[i] = next;
+  });
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray unsafeUpdateAt
+ */
+
+
+function unsafeUpdateAt_1(as, i, a) {
+  if (unsafeGet_1(as, i) === a) {
+    return as;
+  } else {
+    return mutate_1(as, xs => {
+      xs[i] = a;
+    });
+  }
+}
+/**
+ * @tsplus getter fncts.ImmutableArray unzip
+ */
+
+
+export function unzip(self) {
+  const fa = Array(length_1(self));
+  const fb = Array(length_1(self));
+
+  for (let i = 0; i < length_1(self); i++) {
+    fa[i] = self._array[i][0];
+    fb[i] = self._array[i][1];
+  }
+
+  return [tsplus_module_2.asImmutableArray(fa), tsplus_module_2.asImmutableArray(fb)];
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray updateAt
+ */
+
+export function updateAt_(as, i, a) {
+  return isOutOfBound_1(as, i) ? tsplus_module_9.nothing() : tsplus_module_9.just(unsafeUpdateAt_1(as, i, a));
+}
+export const wilt_ = A => (self, f) => wiltWithIndexSelf_1(self)(A)((_, a) => f(a));
+/**
+ * @tsplus pipeable fncts.ImmutableArray wilt_
+ */
+
+export const wilt = A => f => self => wiltWithIndexSelf_1(self)(A)((_, a) => f(a));
+/**
+ * @tsplus fluent fncts.ImmutableArray wilt
+ */
+
+export const wiltSelf = self => A => f => wiltWithIndexSelf_1(self)(A)((_, a) => f(a));
+export const wiltWithIndex_ = /*#__PURE__*/P.mkWiltWithIndex_()(_ => A => (self, f) => A.map_(foldLeftWithIndex_1(self, A.pure([[], []]), (i, fbs, a) => A.zipWith_(f(i, a), fbs, (eb, r) => tsplus_module_15.match_(eb, b1 => {
+  r[0].push(b1);
+  return r;
+}, b2 => {
+  r[1].push(b2);
+  return r;
+}))), ([b1s, b2s]) => [tsplus_module_2.asImmutableArray(b1s), tsplus_module_2.asImmutableArray(b2s)]));
+/**
+ * @tsplus dataFirst wiltWithIndex_
+ */
+
+export const wiltWithIndex = A => f => self => wiltWithIndex_(A)(self, f);
+/**
+ * @tsplus getter fncts.ImmutableArray wiltWithIndex
+ */
+
+const wiltWithIndexSelf_1 = self => A => f => wiltWithIndex_(A)(self, f);
+
+export const wiltWithIndexSelf = wiltWithIndexSelf_1;
+export const wither_ = A => (self, f) => witherWithIndex_(A)(self, (_, a) => f(a));
+/**
+ * @tsplus dataFirst wither_
+ */
+
+export const wither = A => f => self => wither_(A)(self, f);
+/**
+ * @tsplus fluent fncts.ImmutableArray wither
+ */
+
+export const witherSelf = self => A => f => witherWithIndex_(A)(self, (_, a) => f(a));
+export const witherWithIndex_ = /*#__PURE__*/P.mkWitherWithIndex_()(_ => A => (self, f) => A.map_(foldLeftWithIndex_1(self, A.pure([]), (i, b, a) => A.zipWith_(f(i, a), b, (maybeB, bs) => {
+  if (tsplus_module_4.isJust(maybeB)) {
+    bs.push(maybeB.value);
+  }
+
+  return bs;
+})), bs => tsplus_module_2.asImmutableArray(bs)));
+/**
+ * @tsplus dataFirst witherWithIndex_
+ */
+
+export const witherWithIndex = A => f => self => witherWithIndex_(A)(self, f);
+/**
+ * @tsplus fluent fncts.ImmutableArray witherWithIndex
+ */
+
+export const witherWithIndexSelf = self => A => f => witherWithIndex_(A)(self, f);
+/**
+ * @tsplus fluent fncts.ImmutableArray zip
+ */
+
+export function zip_(self, that) {
+  return zipWith_1(self, that, tuple);
+}
+/**
+ * @tsplus fluent fncts.ImmutableArray zipWith
+ */
+
+function zipWith_1(self, fb, f) {
+  const len = Math.min(length_1(self), length_1(fb));
+  const fc = Array(len);
+
+  for (let i = 0; i < len; i++) {
+    fc[i] = f(self._array[i], fb._array[i]);
+  }
+
+  return tsplus_module_2.asImmutableArray(fc);
+}
+//# sourceMappingURL=api.mjs.map