@fncts/base 0.0.1

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

@@ -0,0 +1,1340 @@
+import * as tsplus_module_1 from "@fncts/base/data/These/constructors";
+import * as tsplus_module_2 from "@fncts/base/collection/immutable/Conc/api/empty";
+import * as tsplus_module_3 from "@fncts/base/collection/immutable/Conc/constructors";
+import * as tsplus_module_4 from "@fncts/base/data/Maybe/destructors";
+import * as tsplus_module_5 from "@fncts/base/data/Maybe/definition";
+import * as tsplus_module_6 from "@fncts/base/data/Maybe/constructors";
+import * as tsplus_module_7 from "@fncts/base/internal/Stack";
+import * as tsplus_module_8 from "@fncts/base/data/Either/destructors";
+import * as tsplus_module_9 from "@fncts/base/collection/Iterable/constructors";
+import * as tsplus_module_10 from "@fncts/base/data/exceptions";
+export const alignWith_ = alignWith_1;
+export const append_ = append_1;
+export const builder = builder_1;
+export const flatMap_ = flatMap_1;
+export const chop_ = chop_1;
+export const collectWhile_ = collectWhile_1;
+export const concat_ = concat_1;
+export const exists_ = exists_1;
+export const drop_ = drop_1;
+export const filterMap_ = filterMap_1;
+export const filterMapWithIndex_ = filterMapWithIndex_1;
+export const filterWithIndex_ = filterWithIndex_1;
+export const foldLeft_ = foldLeft_1;
+export const foldLeftWithIndex_ = foldLeftWithIndex_1;
+export const foldMapWithIndexSelf = foldMapWithIndexSelf_1;
+export const foldRightWithIndex_ = foldRightWithIndex_1;
+export const forEach_ = forEach_1;
+export const mapWithIndex_ = mapWithIndex_1;
+export const isEmpty = isEmpty_1;
+export const isNonEmpty = isNonEmpty_1;
+export const partitionMap_ = partitionMap_1;
+export const partitionMapWithIndex_ = partitionMapWithIndex_1;
+export const partitionWithIndex_ = partitionWithIndex_1;
+export const splitAt_ = splitAt_1;
+export const take_ = take_1;
+export const unsafeGet_ = unsafeGet_1;
+export const unsafeHead = unsafeHead_1;
+export const unsafeTail = unsafeTail_1;
+export const unsafeUpdateAt_ = unsafeUpdateAt_1;
+export const zipWith_ = zipWith_1;
+export const zipWithIndexOffset_ = zipWithIndexOffset_1;
+import { _Empty, BUFFER_SIZE, Chunk, concrete, Singleton, Slice } from "@fncts/base/collection/immutable/Conc/definition";
+import { identity, tuple } from "@fncts/base/data/function";
+import * as P from "@fncts/base/typeclass";
+/**
+ * @tsplus fluent fncts.Conc align
+ */
+
+export function align_(self, fb) {
+  return alignWith_1(self, fb, identity);
+}
+/**
+ * @tsplus fluent fncts.Conc alignWith
+ */
+
+function alignWith_1(self, fb, f) {
+  void 0;
+  void 0;
+  const out = builder_1();
+  const minlen = Math.min(self.length, fb.length);
+  const maxlen = Math.max(self.length, fb.length);
+
+  for (let i = 0; i < minlen; i++) {
+    out.append(f(tsplus_module_1.both(self.get(i), fb.get(i))));
+  }
+
+  if (minlen === maxlen) {
+    return out.result();
+  } else if (self.length > fb.length) {
+    for (let i = minlen; i < maxlen; i++) {
+      out.append(f(tsplus_module_1.left(self.get(i))));
+    }
+  } else {
+    for (let i = minlen; i < maxlen; i++) {
+      out.append(f(tsplus_module_1.right(fb.get(i))));
+    }
+  }
+
+  return out.result();
+}
+/**
+ * @tsplus fluent fncts.Conc append
+ */
+
+
+function append_1(self, a) {
+  void 0;
+  return self.append(a);
+}
+
+export class ConcBuilder {
+  constructor(conc) {
+    this.conc = conc;
+  }
+
+  append(a) {
+    this.conc = append_1(this.conc, a);
+    return this;
+  }
+
+  result() {
+    return this.conc;
+  }
+
+}
+/**
+ * @tsplus static fncts.ConcOps builder
+ */
+
+function builder_1() {
+  return new ConcBuilder(tsplus_module_2.empty());
+}
+/**
+ * @tsplus fluent fncts.Conc flatMap
+ */
+
+
+function flatMap_1(ma, f) {
+  void 0;
+  const iterator = ma.arrayIterator();
+  let result;
+  let out = tsplus_module_2.empty();
+
+  while (!(result = iterator.next()).done) {
+    const arr = result.value;
+    const length = arr.length;
+
+    for (let i = 0; i < length; i++) {
+      const a = arr[i];
+      out = concat_1(out, f(a));
+    }
+  }
+
+  return out;
+}
+/**
+ * @tsplus static fncts.ConcOps chainRecDepthFirst
+ */
+
+
+export function chainRecDepthFirst(a, f) {
+  let buffer = f(a);
+  let out = tsplus_module_2.empty();
+
+  while (buffer.length > 0) {
+    const e = unsafeHead_1(buffer);
+    buffer = unsafeTail_1(buffer);
+
+    if (e._tag === "Left"
+    /* EitherTag.Left */
+    ) {
+      buffer = concat_1(f(e.left), buffer);
+    } else {
+      out = append_1(out, e.right);
+    }
+  }
+
+  return out;
+}
+/**
+ * @tsplus static fncts.ConcOps chainRecBreadthFirst
+ */
+
+export function chainRecBreadthFirst(a, f) {
+  const initial = f(a);
+  let buffer = tsplus_module_2.empty();
+  let out = tsplus_module_2.empty();
+
+  function go(e) {
+    if (e._tag === "Left"
+    /* EitherTag.Left */
+    ) {
+      forEach_1(f(e.left), ab => (buffer = append_1(buffer, ab), undefined));
+    } else {
+      out = append_1(out, e.right);
+    }
+  }
+
+  for (const e of initial) {
+    go(e);
+  }
+
+  while (buffer.length > 0) {
+    const ab = unsafeHead_1(buffer);
+    buffer = unsafeTail_1(buffer);
+    go(ab);
+  }
+
+  return out;
+}
+/**
+ * @tsplus fluent fncts.Conc chop
+ */
+
+function chop_1(self, f) {
+  const out = builder_1();
+  let cs = self;
+
+  while (isNonEmpty_1(cs)) {
+    const [b, c] = f(cs);
+    out.append(b);
+    cs = c;
+  }
+
+  return out.result();
+}
+/**
+ * @tsplus fluent fncts.Conc chunksOf
+ */
+
+
+export function chunksOf_(self, n) {
+  return chop_1(self, as => splitAt_1(as, n));
+}
+/**
+ * Transforms all elements of the Conc for as long as the specified partial function is defined.
+ *
+ * @tsplus fluent fncts.Conc collectWhile
+ */
+
+function collectWhile_1(as, f) {
+  void 0;
+
+  switch (as._tag) {
+    case "Singleton"
+    /* ConcTag.Singleton */
+    :
+      {
+        return tsplus_module_4.match_(f(as.value), () => tsplus_module_2.empty(), tsplus_module_3.single);
+      }
+
+    case "Chunk"
+    /* ConcTag.Chunk */
+    :
+      {
+        const array = as.arrayLike();
+        let dest = tsplus_module_2.empty();
+
+        for (let i = 0; i < array.length; i++) {
+          const rhs = f(array[i]);
+
+          if (tsplus_module_5.isJust(rhs)) {
+            dest = append_1(dest, rhs.value);
+          } else {
+            return dest;
+          }
+        }
+
+        return dest;
+      }
+
+    default:
+      {
+        return collectWhile_1(as.materialize(), f);
+      }
+  }
+}
+/**
+ * @tsplus getter fncts.Conc compact
+ */
+
+
+export function compact(self) {
+  return filterMap_1(self, identity);
+}
+/**
+ * @tsplus fluent fncts.Conc concat
+ */
+
+function concat_1(self, that) {
+  void 0;
+  void 0;
+  return self.concat(that);
+}
+/**
+ * @tsplus getter fncts.Conc elem
+ */
+
+
+export function elem_(self) {
+  return E => a => exists_1(self, el => E.equals_(el, a));
+}
+/**
+ * @tsplus fluent fncts.Conc exists
+ */
+
+function exists_1(as, predicate) {
+  void 0;
+  const iterator = as.arrayIterator();
+  let exists = false;
+  let result;
+
+  while (!exists && !(result = iterator.next()).done) {
+    const array = result.value;
+
+    for (let i = 0; !exists && i < array.length; i++) {
+      exists = predicate(array[i]);
+    }
+  }
+
+  return exists;
+}
+/**
+ * @tsplus fluent fncts.Conc drop
+ */
+
+
+function drop_1(self, n) {
+  void 0;
+  const len = self.length;
+
+  if (len <= 0) {
+    return self;
+  } else if (n >= len) {
+    return tsplus_module_2.empty();
+  } else {
+    switch (self._tag) {
+      case "Slice"
+      /* ConcTag.Slice */
+      :
+        return new Slice(self.conc, self.offset + n, self.l - n);
+
+      case "Singleton"
+      /* ConcTag.Singleton */
+      :
+        return n > 0 ? tsplus_module_2.empty() : self;
+
+      case "Empty"
+      /* ConcTag.Empty */
+      :
+        return tsplus_module_2.empty();
+
+      default:
+        return new Slice(self, n, len - n);
+    }
+  }
+}
+/**
+ * @tsplus fluent fncts.Conc dropWhile
+ */
+
+
+export function dropWhile_(self, p) {
+  void 0;
+
+  switch (self._tag) {
+    case "Chunk"
+    /* ConcTag.Chunk */
+    :
+      {
+        const arr = self.arrayLike();
+        let i = 0;
+
+        while (i < arr.length && p(arr[i])) {
+          i++;
+        }
+
+        return drop_1(self, i);
+      }
+
+    default:
+      {
+        const iterator = self.arrayIterator();
+        let result;
+        let cont = true;
+        let i = 0;
+
+        while (cont && !(result = iterator.next()).done) {
+          const array = result.value;
+          let j = 0;
+
+          while (cont && j < array.length) {
+            if (p(array[j])) {
+              i++;
+              j++;
+            } else {
+              cont = false;
+            }
+          }
+        }
+
+        return drop_1(self, i);
+      }
+  }
+}
+export function filter_(self, p) {
+  return filterWithIndex_1(self, (_, a) => p(a));
+}
+/**
+ * @tsplus fluent fncts.Conc filterMap
+ */
+
+function filterMap_1(self, f) {
+  return filterMapWithIndex_1(self, (_, a) => f(a));
+}
+/**
+ * @tsplus fluent fncts.Conc filterMapWithIndex
+ */
+
+
+function filterMapWithIndex_1(self, f) {
+  void 0;
+  const iterator = self.arrayIterator();
+  const out = builder_1();
+  let result;
+  let i = 0;
+
+  while (!(result = iterator.next()).done) {
+    const array = result.value;
+
+    for (let j = 0; j < array.length; j++) {
+      const ob = f(i, array[j]);
+
+      if (tsplus_module_5.isJust(ob)) {
+        out.append(ob.value);
+      }
+
+      i++;
+    }
+  }
+
+  return out.result();
+}
+
+function filterWithIndex_1(self, p) {
+  void 0;
+
+  switch (self._tag) {
+    case "Empty"
+    /* ConcTag.Empty */
+    :
+      {
+        return _Empty;
+      }
+
+    case "Chunk"
+    /* ConcTag.Chunk */
+    :
+      {
+        const arr = self.arrayLike();
+        let builder = tsplus_module_2.empty();
+
+        for (let i = 0; i < arr.length; i++) {
+          const a = arr[i];
+
+          if (p(i, a)) {
+            builder = append_1(builder, a);
+          }
+        }
+
+        return builder;
+      }
+
+    case "Singleton"
+    /* ConcTag.Singleton */
+    :
+      {
+        if (p(0, self.value)) {
+          return self;
+        }
+
+        return _Empty;
+      }
+
+    default:
+      {
+        const iterator = self.arrayIterator();
+        let out = tsplus_module_2.empty();
+        let result;
+        let i = 0;
+
+        while (!(result = iterator.next()).done) {
+          const array = result.value;
+
+          for (let j = 0; j < array.length; j++) {
+            const a = array[j];
+
+            if (p(i, a)) {
+              out = append_1(out, a);
+            }
+
+            i++;
+          }
+        }
+
+        return out;
+      }
+  }
+}
+/**
+ * @tsplus fluent fncts.Conc find
+ */
+
+
+export function find_(self, f) {
+  void 0;
+  const iterator = self.arrayIterator();
+  let out = tsplus_module_6.nothing();
+  let result;
+
+  while (tsplus_module_5.isNothing(out) && !(result = iterator.next()).done) {
+    const array = result.value;
+    const length = array.length;
+
+    for (let i = 0; tsplus_module_5.isNothing(out) && i < length; i++) {
+      const a = array[i];
+
+      if (f(a)) {
+        out = tsplus_module_6.just(a);
+      }
+    }
+  }
+
+  return out;
+}
+/**
+ * @tsplus getter fncts.Conc flatten
+ */
+
+export function flatten(self) {
+  return flatMap_1(self, identity);
+}
+/**
+ * Folds over the elements in this Conc from the left.
+ * Stops the fold early when the condition is not fulfilled.
+ *
+ * @tsplus fluent fncts.Conc foldLeftWhile
+ */
+
+export function foldLeftWhile_(as, b, p, f) {
+  void 0;
+  const iterator = as.arrayIterator();
+  let s = b;
+  let cont = p(s);
+  let result;
+
+  while (cont && !(result = iterator.next()).done) {
+    const array = result.value;
+
+    for (let i = 0; cont && i < array.length; i++) {
+      s = f(s, array[i]);
+      cont = p(s);
+    }
+  }
+
+  return s;
+}
+/**
+ * @tsplus fluent fncts.Conc foldLeft
+ */
+
+function foldLeft_1(self, b, f) {
+  return foldLeftWithIndex_1(self, b, (_, b, a) => f(b, a));
+}
+/**
+ * @tsplus fluent fncts.Conc foldLeftWithIndex
+ */
+
+
+function foldLeftWithIndex_1(self, b, f) {
+  void 0;
+  const iterator = self.arrayIterator();
+  let out = b;
+  let result;
+  let i = 0;
+
+  while (!(result = iterator.next()).done) {
+    const array = result.value;
+
+    for (let j = 0; j < array.length; j++) {
+      out = f(i, out, array[j]);
+      i++;
+    }
+  }
+
+  return out;
+}
+/**
+ * @constrained
+ */
+
+
+export function foldMap_(M) {
+  return (fa, f) => foldMapWithIndexSelf_1(fa)(M)((_, a) => f(a));
+}
+/**
+ * @tsplus getter fncts.Conc foldMap
+ */
+
+export function foldMapSelf(self) {
+  return M => f => foldMapWithIndexSelf_1(self)(M)((_, a) => f(a));
+}
+/**
+ * @constrained
+ */
+
+export function foldMapWithIndex_(M) {
+  return (fa, f) => foldLeftWithIndex_1(fa, M.nat, (i, b, a) => M.combine_(b, f(i, a)));
+}
+/**
+ * @tsplus getter fncts.Conc foldMapWithIndex
+ */
+
+function foldMapWithIndexSelf_1(self) {
+  return M => f => foldMapWithIndex_(M)(self, f);
+}
+/**
+ * @tsplus fluent fncts.Conc foldRight
+ */
+
+
+export function foldRight_(fa, b, f) {
+  return foldRightWithIndex_1(fa, b, (_, a, b) => f(a, b));
+}
+/**
+ * @tsplus fluent fncts.Conc foldRightWithIndex
+ */
+
+function foldRightWithIndex_1(self, b, f) {
+  void 0;
+  const iterator = self.reverseArrayIterator();
+  let out = b;
+  let result;
+  let i = self.length - 1;
+
+  while (!(result = iterator.next()).done) {
+    const array = result.value;
+
+    for (let j = array.length - 1; j >= 0; j--) {
+      out = f(i, array[i], out);
+      i--;
+    }
+  }
+
+  return out;
+}
+/**
+ * @tsplus fluent fncts.Conc forEach
+ */
+
+
+function forEach_1(self, f) {
+  void 0;
+  return self.forEach(0, (_, a) => f(a));
+}
+/**
+ * @tsplus fluent fncts.Conc forEachWithIndex
+ */
+
+
+export function forEachWithIndex_(self, f) {
+  void 0;
+  self.forEach(0, f);
+}
+/**
+ * @tsplus fluent fncts.Conc get
+ */
+
+export function get_(as, n) {
+  return tsplus_module_6.tryCatch(() => unsafeGet_1(as, n));
+}
+/**
+ * @tsplus getter fncts.Conc head
+ */
+
+export function head(self) {
+  void 0;
+
+  if (isEmpty_1(self)) {
+    return tsplus_module_6.nothing();
+  }
+
+  return tsplus_module_6.just(self.get(0));
+}
+/**
+ * @tsplus getter fncts.Conc init
+ */
+
+export function init(self) {
+  if (isEmpty_1(self)) {
+    return tsplus_module_6.nothing();
+  }
+
+  return tsplus_module_6.just(take_1(self, self.length - 1));
+}
+/**
+ * @tsplus fluent fncts.Conc join
+ */
+
+export function join_(self, separator) {
+  if (self.length === 0) {
+    return "";
+  }
+
+  return foldLeft_1(unsafeTail_1(self), unsafeGet_1(self, 0), (b, s) => b + separator + s);
+}
+/**
+ * @tsplus getter fncts.Conc last
+ */
+
+export function last(self) {
+  void 0;
+
+  if (isEmpty_1(self)) {
+    return tsplus_module_6.nothing();
+  }
+
+  return tsplus_module_6.just(self.get(self.length - 1));
+}
+/**
+ * @tsplus fluent fncts.Conc map
+ */
+
+export function map_(self, f) {
+  return mapWithIndex_1(self, (_, a) => f(a));
+}
+/**
+ * Statefully maps over the Conc, producing new elements of type `B`.
+ *
+ * @tsplus fluent fncts.Conc mapAccum
+ */
+
+export function mapAccum_(self, s, f) {
+  void 0;
+  const iterator = self.arrayIterator();
+  const out = builder_1();
+  let state = s;
+  let result;
+
+  while (!(result = iterator.next()).done) {
+    const array = result.value;
+    const length = array.length;
+
+    for (let i = 0; i < length; i++) {
+      const a = array[i];
+      const tup = f(state, a);
+      out.append(tup[0]);
+      state = tup[1];
+    }
+  }
+
+  return tuple(out.result(), s);
+}
+
+function mapArrayLike(as, len, startIndex, f) {
+  let bs = tsplus_module_2.empty();
+
+  for (let i = 0; i < len; i++) {
+    bs = append_1(bs, f(i + startIndex, as[i]));
+  }
+
+  return bs;
+}
+
+function mapArrayLikeReverse(as, len, endIndex, f) {
+  let bs = tsplus_module_2.empty();
+
+  for (let i = BUFFER_SIZE - len, j = len - 1; i < BUFFER_SIZE; i++, j--) {
+    bs = append_1(bs, f(endIndex - j, as[i]));
+  }
+
+  return bs;
+}
+
+class DoneFrame {
+  constructor() {
+    this._tag = "Done";
+  }
+
+}
+
+class ConcatLeftFrame {
+  constructor(conc, currentIndex) {
+    this.conc = conc;
+    this.currentIndex = currentIndex;
+    this._tag = "ConcatLeft";
+  }
+
+}
+
+class ConcatRightFrame {
+  constructor(leftResult) {
+    this.leftResult = leftResult;
+    this._tag = "ConcatRight";
+  }
+
+}
+
+class AppendFrame {
+  constructor(buffer, bufferUsed, startIndex) {
+    this.buffer = buffer;
+    this.bufferUsed = bufferUsed;
+    this.startIndex = startIndex;
+    this._tag = "Append";
+  }
+
+}
+
+class PrependFrame {
+  constructor(pre, end) {
+    this.pre = pre;
+    this.end = end;
+    this._tag = "Prepend";
+  }
+
+}
+/**
+ * @tsplus fluent fncts.Conc mapWithIndex
+ */
+
+
+function mapWithIndex_1(self, f) {
+  let current = self;
+  let index = 0;
+  const stack = tsplus_module_7.mkStack();
+  stack.push(new DoneFrame());
+  let result = tsplus_module_2.empty();
+
+  recursion: while (stack.hasNext) {
+    // eslint-disable-next-line no-constant-condition
+    pushing: while (true) {
+      void 0;
+
+      switch (current._tag) {
+        case "Singleton"
+        /* ConcTag.Singleton */
+        :
+          {
+            result = new Singleton(f(index++, current.value));
+            break pushing;
+          }
+
+        case "Empty"
+        /* ConcTag.Empty */
+        :
+          {
+            result = _Empty;
+            break pushing;
+          }
+
+        case "Chunk"
+        /* ConcTag.Chunk */
+        :
+          {
+            result = new Chunk(current._array.map((a, i) => f(i + index, a)));
+            index += current.length;
+            break pushing;
+          }
+
+        case "Concat"
+        /* ConcTag.Concat */
+        :
+          {
+            stack.push(new ConcatLeftFrame(current, index));
+            current = current.left;
+            continue pushing;
+          }
+
+        case "AppendN"
+        /* ConcTag.AppendN */
+        :
+          {
+            stack.push(new AppendFrame(current.buffer, current.bufferUsed, index));
+            current = current.start;
+            continue pushing;
+          }
+
+        case "PrependN"
+        /* ConcTag.PrependN */
+        :
+          {
+            stack.push(new PrependFrame(mapArrayLikeReverse(current.buffer, current.bufferUsed, index + current.bufferUsed - 1, f), current.end));
+            index += current.bufferUsed;
+            break pushing;
+          }
+
+        case "Slice"
+        /* ConcTag.Slice */
+        :
+          {
+            let r = tsplus_module_2.empty();
+
+            for (let i = 0; i < current.length; i++) {
+              r = append_1(r, f(i + index, unsafeGet_1(current, i)));
+            }
+
+            result = r;
+            index += current.length;
+            break pushing;
+          }
+      }
+    } // eslint-disable-next-line no-constant-condition
+
+
+    popping: while (true) {
+      const top = stack.pop();
+
+      switch (top._tag) {
+        case "Done":
+          {
+            return result;
+          }
+
+        case "ConcatLeft":
+          {
+            current = top.conc.right;
+            stack.push(new ConcatRightFrame(result));
+            continue recursion;
+          }
+
+        case "ConcatRight":
+          {
+            result = concat_1(top.leftResult, result);
+            continue popping;
+          }
+
+        case "Append":
+          {
+            result = concat_1(result, mapArrayLike(top.buffer, top.bufferUsed, index, f));
+            continue popping;
+          }
+
+        case "Prepend":
+          {
+            current = top.end;
+            stack.push(new ConcatRightFrame(top.pre));
+            continue recursion;
+          }
+      }
+    }
+  }
+
+  throw new Error("bug");
+}
+/**
+ * @tsplus getter fncts.Conc isEmpty
+ */
+
+
+function isEmpty_1(self) {
+  void 0;
+  return self.length === 0;
+}
+/**
+ * @tsplus getter fncts.Conc isNonEmpty
+ */
+
+
+function isNonEmpty_1(conc) {
+  return !isEmpty_1(conc);
+}
+
+export function partition_(self, p) {
+  return partitionWithIndex_1(self, (_, a) => p(a));
+}
+/**
+ * @tsplus fluent fncts.Conc partitionMap
+ */
+
+function partitionMap_1(self, f) {
+  return partitionMapWithIndex_1(self, (_, a) => f(a));
+}
+/**
+ * @tsplus fluent fncts.Conc partitionMapWithIndex
+ */
+
+
+function partitionMapWithIndex_1(fa, f) {
+  void 0;
+  const iterator = fa.arrayIterator();
+  const left = builder_1();
+  const right = builder_1();
+  let result;
+  let i = 0;
+
+  while (!(result = iterator.next()).done) {
+    const array = result.value;
+
+    for (let j = 0; j < array.length; j++) {
+      const eab = f(i, array[j]);
+      tsplus_module_8.match_(eab, b => left.append(b), c => right.append(c));
+      i++;
+    }
+  }
+
+  return [left.result(), right.result()];
+}
+
+function partitionWithIndex_1(self, p) {
+  void 0;
+  const iterator = self.arrayIterator();
+  const left = builder_1();
+  const right = builder_1();
+  let result;
+  let i = 0;
+
+  while (!(result = iterator.next()).done) {
+    const array = result.value;
+
+    for (let j = 0; j < array.length; j++) {
+      const a = array[j];
+
+      if (p(i, a)) {
+        right.append(a);
+      } else {
+        left.append(a);
+      }
+
+      i++;
+    }
+  }
+
+  return [left.result(), right.result()];
+}
+/**
+ * @tsplus fluent fncts.Conc prepend
+ */
+
+
+export function prepend_(self, a) {
+  void 0;
+  return self.prepend(a);
+}
+/**
+ * @tsplus getter fncts.Conc reverse
+ */
+
+export function reverse(self) {
+  void 0;
+  const arr = self.arrayLike();
+  return tsplus_module_9.mkIterable(() => {
+    let i = arr.length - 1;
+    return {
+      next: () => {
+        if (i >= 0 && i < arr.length) {
+          const k = arr[i];
+          i--;
+          return {
+            value: k,
+            done: false
+          };
+        } else {
+          return {
+            value: undefined,
+            done: true
+          };
+        }
+      }
+    };
+  });
+}
+/**
+ * @tsplus getter fncts.Conc separate
+ */
+
+export function separate(self) {
+  return partitionMap_1(self, identity);
+}
+/**
+ * @tsplus fluent fncts.Conc splitAt
+ */
+
+function splitAt_1(self, n) {
+  return [take_1(self, n), drop_1(self, n)];
+}
+/**
+ * Splits this Conc on the first element that matches this predicate.
+ *
+ * @tsplus fluent fncts.Conc splitWhere
+ */
+
+
+export function splitWhere_(self, f) {
+  void 0;
+  const iterator = self.arrayIterator();
+  let next;
+  let cont = true;
+  let i = 0;
+
+  while (cont && (next = iterator.next()) && !next.done) {
+    const array = next.value;
+    const len = array.length;
+    let j = 0;
+
+    while (cont && j < len) {
+      const a = array[j];
+
+      if (f(a)) {
+        cont = false;
+      } else {
+        i++;
+        j++;
+      }
+    }
+  }
+
+  return splitAt_1(self, i);
+}
+/**
+ * @tsplus getter fncts.Conc tail
+ */
+
+export function tail(conc) {
+  if (isEmpty_1(conc)) {
+    return tsplus_module_6.nothing();
+  }
+
+  return tsplus_module_6.just(drop_1(conc, 1));
+}
+/**
+ * @tsplus fluent fncts.Conc take
+ */
+
+function take_1(self, n) {
+  void 0;
+  return self.take(n);
+}
+/**
+ * @tsplus fluent fncts.Conc takeWhile
+ */
+
+
+export function takeWhile_(self, p) {
+  void 0;
+
+  switch (self._tag) {
+    case "Chunk"
+    /* ConcTag.Chunk */
+    :
+      {
+        const arr = self.arrayLike();
+        let i = 0;
+
+        while (i < arr.length && p(arr[i])) {
+          i++;
+        }
+
+        return take_1(self, i);
+      }
+
+    default:
+      {
+        const iterator = self.arrayIterator();
+        let result;
+        let cont = true;
+        let i = 0;
+
+        while (cont && !(result = iterator.next()).done) {
+          const array = result.value;
+          let j = 0;
+
+          while (cont && j < array.length) {
+            if (!p(array[j])) {
+              cont = false;
+            } else {
+              i++;
+              j++;
+            }
+          }
+        }
+
+        return take_1(self, i);
+      }
+  }
+}
+export const traverse_ = A => (ta, f) => traverseWithIndex_(A)(ta, (_, a) => f(a));
+/**
+ * @tsplus getter fncts.Conc traverse
+ */
+
+export const traverseSelf = ta => A => f => traverseWithIndex_(A)(ta, (_, a) => f(a));
+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 getter fncts.Conc traverseWithIndex
+ */
+
+export const traverseSelfWithIndex = ta => A => f => traverseWithIndex_(A)(ta, f);
+/**
+ * @tsplus fluent fncts.ConcOps unfold
+ */
+
+export function unfold(b, f) {
+  const out = builder_1();
+  let bb = b;
+
+  while (true) {
+    const mt = f(bb);
+
+    if (tsplus_module_5.isJust(mt)) {
+      const [a, b] = mt.value;
+      out.append(a);
+      bb = b;
+    } else {
+      return out.result();
+    }
+  }
+}
+/**
+ * @tsplus fluent fncts.Conc unsafeGet
+ * @tsplus index fncts.Conc
+ */
+
+function unsafeGet_1(self, n) {
+  void 0;
+  return self.get(n);
+}
+/**
+ * Returns the first element of this Conc. Note that this method is partial
+ * in that it will throw an exception if the Conc is empty. Consider using
+ * `head` to explicitly handle the possibility that the Conc is empty
+ * or iterating over the elements of the Conc in lower level, performance
+ * sensitive code unless you really only need the first element of the Conc.
+ *
+ * @tsplus getter fncts.Conc unsafeHead
+ */
+
+
+function unsafeHead_1(as) {
+  void 0;
+  return as.get(0);
+}
+/**
+ * Returns every element after the first. Note that this method is partial
+ * in that it will throw an exception if the Conc is empty. Consider using
+ * `tail` to explicitly handle the possibility that the Conc is empty
+ *
+ * @tsplus getter fncts.Conc unsafeTail
+ */
+
+
+function unsafeTail_1(self) {
+  if (self.length === 0) {
+    throw new tsplus_module_10.ArrayIndexOutOfBoundsError("Chunk.unsafeTail access to 1");
+  }
+
+  return drop_1(self, 1);
+}
+/**
+ * @tsplus fluent fncts.Conc unsafeUpdateAt
+ */
+
+
+function unsafeUpdateAt_1(self, i, a) {
+  void 0;
+  return self.update(i, a);
+}
+/**
+ * @tsplus fluent fncts.Conc updateAt
+ */
+
+
+export function updateAt_(self, i, a) {
+  try {
+    return tsplus_module_6.just(unsafeUpdateAt_1(self, i, a));
+  } catch {
+    return tsplus_module_6.nothing();
+  }
+}
+/**
+ * @tsplus fluent fncts.Conc zip
+ */
+
+export function zip_(self, fb) {
+  return zipWith_1(self, fb, tuple);
+}
+/**
+ * @tsplus fluent fncts.Conc zipWith
+ */
+
+function zipWith_1(self, fb, f) {
+  void 0;
+  void 0;
+  const length = Math.min(self.length, fb.length);
+
+  if (length === 0) {
+    return tsplus_module_2.empty();
+  } else {
+    const leftIterator = self.arrayIterator();
+    const rightIterator = fb.arrayIterator();
+    const out = builder_1();
+    let left = null;
+    let right = null;
+    let leftLength = 0;
+    let rightLength = 0;
+    let i = 0;
+    let j = 0;
+    let k = 0;
+
+    while (i < length) {
+      if (j < leftLength && k < rightLength) {
+        const a = left.value[j];
+        const b = right.value[k];
+        const c = f(a, b);
+        out.append(c);
+        i++;
+        j++;
+        k++;
+      } else if (j === leftLength && !(left = leftIterator.next()).done) {
+        leftLength = left.value.length;
+        j = 0;
+      } else if (k === rightLength && !(right = rightIterator.next()).done) {
+        rightLength = right.value.length;
+        k = 0;
+      }
+    }
+
+    return out.result();
+  }
+}
+/**
+ * @tsplus getter fncts.Conc zipWithIndex
+ */
+
+
+export function zipWithIndex(self) {
+  return zipWithIndexOffset_1(self, 0);
+}
+/**
+ * @tsplus fluent fncts.Conc zipWithIndexOffset
+ */
+
+function zipWithIndexOffset_1(as, offset) {
+  void 0;
+  const iterator = as.arrayIterator();
+  let next;
+  let i = offset;
+  const out = builder_1();
+
+  while (!(next = iterator.next()).done) {
+    const array = next.value;
+    const len = array.length;
+
+    for (let j = 0; i < len; j++, i++) {
+      out.append([array[j], i]);
+    }
+  }
+
+  return out.result();
+}
+//# sourceMappingURL=api.mjs.map