@fncts/base 0.0.3 → 0.0.4

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

@@ -11,15 +11,18 @@ import * as tsplus_module_10 from "@fncts/base/collection/immutable/ImmutableNon
 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_14 from "@fncts/base/typeclass/Apply";
 import * as tsplus_module_15 from "@fncts/base/data/Either/destructors";
+import * as tsplus_module_16 from "@fncts/base/typeclass/Functor";
 export const alignWith_ = alignWith_1;
 export const append_ = append_1;
+export const crossWith_ = crossWith_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 elem_ = elem_1;
 export const everyWithIndex_ = everyWithIndex_1;
 export const filter_ = filter_1;
 export const filterWithIndex_ = filterWithIndex_1;
@@ -30,8 +33,8 @@ 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 fold = fold_1;
+export const foldMapWithIndex_ = foldMapWithIndex_1;
 export const foldRightWithIndex_ = foldRightWithIndex_1;
 export const foldRightWithIndexWhile_ = foldRightWithIndexWhile_1;
 export const forEach_ = forEach_1;
@@ -60,6 +63,7 @@ export const unsafeDeleteAt_ = unsafeDeleteAt_1;
 export const unsafeInsertAt_ = unsafeInsertAt_1;
 export const unsafeModifyAt_ = unsafeModifyAt_1;
 export const unsafeUpdateAt_ = unsafeUpdateAt_1;
+export const witherWithIndex_ = witherWithIndex_1;
 export const zipWith_ = zipWith_1;
 import { identity, tuple } from "@fncts/base/data/function";
 import * as P from "@fncts/base/typeclass";
@@ -135,9 +139,17 @@ function append_1(self, last) {
  */
 
 
-export function crossWith_(self, fb, f) {
+function crossWith_1(self, fb, f) {
   return flatMap_1(self, a => map_1(fb, b => f(a, b)));
 }
+/**
+ * @tsplus fluent fncts.ImmutableArray cross
+ */
+
+
+export function cross_(self, fb) {
+  return crossWith_1(self, fb, tuple);
+}
 /**
  * @tsplus static fncts.ImmutableArrayOps chainRecDepthFirst
  */
@@ -148,6 +160,7 @@ export function chainRecDepthFirst(a, f) {
 
   while (buffer.length > 0) {
     const e = buffer.shift();
+    void 0;
 
     if (e._tag === "Left"
     /* EitherTag.Left */
@@ -170,6 +183,8 @@ export function chainRecBreadthFirst(a, f) {
   const out = [];
 
   function go(e) {
+    void 0;
+
     if (e._tag === "Left") {
       forEach_1(f(e.left), v => buffer.push(v));
     } else {
@@ -292,7 +307,7 @@ 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));
+    return tsplus_module_7.map_(traverse_1(input[0], a => comprehensionLoop(append_1(scope, a), input.slice(1), f, g), tsplus_module_6.Applicative), rs => flatten_1(rs));
   }
 }
 
@@ -302,7 +317,6 @@ export function comprehension(input, f, g = () => true) {
 /**
  * @tsplus fluent fncts.ImmutableArray concat
  * @tsplus operator fncts.ImmutableArray +
- * @tsplus operator fncts.base.MutableArray +
  */
 
 function concat_1(self, that) {
@@ -339,19 +353,13 @@ export function deleteAt_(as, i) {
   return isOutOfBound_1(as, i) ? tsplus_module_9.nothing() : tsplus_module_9.just(unsafeDeleteAt_1(as, i));
 }
 /**
- * @constrained
+ * @tsplus fluent fncts.ImmutableArray difference
  */
 
-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);
+export function difference_(self, ys,
+/** @tsplus auto */
+E) {
+  return filter_1(self, a => !elem_1(ys, a, E));
 }
 /**
  * @tsplus fluent fncts.ImmutableArray drop
@@ -386,35 +394,25 @@ export function dropLastWhile_(as, p) {
  * argument which returns the function to use to search for a value of type `A` in
  * an array of type `ImmutableArray<A>`.
  *
- * @constrained
+ * @tsplus fluent fncts.ImmutableArray elem
  */
 
-export function elem_(E) {
-  return (as, a) => {
-    const predicate = element => E.equals_(element, a);
+function elem_1(as, a,
+/** @tsplus auto */
+E) {
+  const predicate = element => E.equals(element, a);
 
-    const len = length_1(as);
+  const len = length_1(as);
 
-    for (let i = 0; i < len; i++) {
-      if (predicate(as._array[i])) {
-        return true;
-      }
+  for (let i = 0; i < len; i++) {
+    if (predicate(as._array[i])) {
+      return true;
     }
+  }
 
-    return false;
-  };
+  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));
 }
@@ -630,57 +628,38 @@ function foldLeftWithIndexWhile_1(self, b, p, f) {
 
   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)));
-  };
+function fold_1(self,
+/** @tsplus auto */
+M) {
+  return foldLeft_1(self, M.nat, M.combine);
 }
 /**
- * @tsplus getter fncts.ImmutableArray foldMapWithIndex
- * @tsplus getter fncts.base.MutableArray foldMapWithIndex
- */
-
-function foldMapWithIndexSelf_1(self) {
-  return M => f => foldMapWithIndex_(M)(self, f);
-}
-/**
- * @constrained
+ * @tsplus fluent fncts.ImmutableArray foldMapWithIndex
  */
 
 
-export function foldMap_(M) {
-  return (self, f) => {
-    return foldMapWithIndexSelf_1(self)(M)((_, a) => f(a));
-  };
+function foldMapWithIndex_1(self, f,
+/** @tsplus auto */
+M) {
+  return foldLeftWithIndex_1(self, M.nat, (i, b, a) => M.combine(b, f(i, a)));
 }
 /**
- * @tsplus getter fncts.ImmutableArray foldMap
- * @tsplus getter fncts.base.MutableArray foldMap
+ * @tsplus fluent fncts.ImmutableArray foldMap
  */
 
-export function foldMapSelf(self) {
-  return M => f => foldMapWithIndexSelf_1(self)(M)((_, a) => f(a));
+
+export function foldMap_(self, f,
+/** @tsplus auto */
+M) {
+  return foldMapWithIndex_1(self, (_, a) => f(a), M);
 }
 /**
  * @tsplus fluent fncts.ImmutableArray foldRightWithIndex
- * @tsplus fluent fncts.base.MutableArray foldRightWithIndex
  */
 
 function foldRightWithIndex_1(self, b, f) {
@@ -694,7 +673,6 @@ function foldRightWithIndex_1(self, b, f) {
 }
 /**
  * @tsplus fluent fncts.ImmutableArray foldRight
- * @tsplus fluent fncts.base.MutableArray foldRight
  */
 
 
@@ -703,7 +681,6 @@ export function foldRight_(self, b, f) {
 }
 /**
  * @tsplus fluent fncts.ImmutableArray foldRighWhile
- * @tsplus fluent fncts.base.MutableArray foldRightWhile
  */
 
 export function foldRightWhile_(self, b, p, f) {
@@ -711,7 +688,6 @@ export function foldRightWhile_(self, b, p, f) {
 }
 /**
  * @tsplus fluent fncts.ImmutableArray foldRightWithIndexWhile
- * @tsplus fluent fncts.base.MutableArray foldRightWithIndexWhile
  */
 
 function foldRightWithIndexWhile_1(self, b, predicate, f) {
@@ -752,7 +728,7 @@ export function group(E) {
     for (; i < length_1(self); i++) {
       const a = self._array[i];
 
-      if (E.equals_(a, h)) {
+      if (E.equals(a, h)) {
         out.push(a);
       } else {
         break;
@@ -811,16 +787,14 @@ export function init(self) {
 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
+ * @tsplus fluent fncts.ImmutableArray intersection
  */
 
-export function intersectionSelf(self) {
-  return E => that => intersection_(E)(self, that);
+export function intersection_(self, that,
+/** @tsplus auto */
+E) {
+  return filter_1(self, a => elem_1(that, a, E));
 }
 export function intersperse_(self, a) {
   const len = length_1(self);
@@ -881,6 +855,7 @@ export function lefts(self) {
 
   for (let i = 0; i < length_1(self); i++) {
     const a = self._array[i];
+    void 0;
 
     if (a._tag === "Left"
     /* EitherTag.Left */
@@ -985,6 +960,7 @@ function partitionMapWithIndex_1(self, f) {
 
   for (let i = 0; i < length_1(self); i++) {
     const ea = f(i, self._array[i]);
+    void 0;
 
     switch (ea._tag) {
       case "Left"
@@ -1070,6 +1046,7 @@ export function rights(self) {
 
   for (let i = 0; i < length_1(self); i++) {
     const a = self._array[i];
+    void 0;
 
     if (a._tag === "Right"
     /* EitherTag.Right */
@@ -1130,8 +1107,10 @@ export function scanRight_(self, b, f) {
  * @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_));
+function sort_1(self,
+/** @tsplus auto */
+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
@@ -1139,7 +1118,7 @@ function sort_1(self, O) {
 
 
 export function sortBy(self, Os) {
-  return sort_1(self, foldSelf_1(Os, tsplus_module_13.getMonoid()));
+  return sort_1(self, fold_1(Os, tsplus_module_13.getMonoid()));
 }
 export function spanLeft_(self, p) {
   const i = spanIndexLeft_1(self, p);
@@ -1242,12 +1221,6 @@ export function splitWhere_(self, p) {
 
   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
  */
@@ -1279,63 +1252,52 @@ export function takeWhile_(self, p) {
 
   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_
+ * @tsplus fluent fncts.ImmutableArray traverseWithIndex
  */
 
-export const traverseWithIndex = A => f => self => traverseWithIndex_(A)(self, f);
+const traverseWithIndex_1 = (ta, f, G) => foldLeftWithIndex_1(ta, G.pure(tsplus_module_2.empty()), (i, fbs, a) => tsplus_module_14.zipWith(fbs, f(i, a), (bs, b) => append_1(bs, b), G));
+
+export const traverseWithIndex_ = traverseWithIndex_1;
 /**
- * @tsplus getter fncts.ImmutableArray traverseWithIndex
+ * @tsplus fluent fncts.ImmutableArray traverse
  */
 
-const traverseWithIndexSelf_1 = self => A => f => traverseWithIndex_(A)(self, f);
+const traverse_1 = (self, f, G) => traverseWithIndex_1(self, (_, a) => f(a), G);
 
-export const traverseWithIndexSelf = traverseWithIndexSelf_1;
-export const traverse_ = A => (self, f) => traverseWithIndexSelf_1(self)(A)((_, a) => f(a));
+export const traverse_ = traverse_1;
 /**
- * @tsplus dataFirst traverse_
+ * @tsplus fluent fncts.ImmutableArray union
  */
 
-export const traverse = A => f => self => traverseWithIndexSelf_1(self)(A)((_, a) => f(a));
+export function union_(self, that,
+/** @tsplus auto */
+E) {
+  return concat_1(self, filter_1(that, a => !elem_1(self, a, E)));
+}
 /**
- * @tsplus getter fncts.ImmutableArray traverse
+ * @tsplus fluent fncts.ImmutableArray uniq
  */
 
-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;
-    }
+export function uniq(self,
+/** @tsplus auto */
+E) {
+  if (length_1(self) === 1) {
+    return self;
+  }
 
-    const elemE_ = elem_(E);
-    const out = [];
-    const len = length_1(self);
+  const out = [];
+  const len = length_1(self);
 
-    for (let i = 0; i < len; i++) {
-      const a = self._array[i];
+  for (let i = 0; i < len; i++) {
+    const a = self._array[i];
 
-      if (!elemE_(tsplus_module_2.asImmutableArray(out), a)) {
-        out.push(a);
-      }
+    if (!elem_1(tsplus_module_2.asImmutableArray(out), a, E)) {
+      out.push(a);
     }
+  }
 
-    return tsplus_module_2.asImmutableArray(out);
-  };
-}
-/**
- * @tsplus fluent fncts.ImmutableArray uniq
- */
-
-export function uniqSelf(self, E) {
-  return uniq(E)(self);
+  return tsplus_module_2.asImmutableArray(out);
 }
 /**
  * @tsplus getter fncts.ImmutableArray unprepend
@@ -1432,68 +1394,64 @@ export function unzip(self) {
 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);
+export function wilt_(self, f,
+/** @tsplus auto */
+G) {
+  return tsplus_module_16.map(foldLeft_1(self, G.pure([[], []]), (fbs, a) => tsplus_module_14.zipWith(f(a), fbs, (eb, r) => tsplus_module_15.match_(eb, b1 => {
+    r[0].push(b1);
+    return r;
+  }, b2 => {
+    r[1].push(b2);
+    return r;
+  }), G)), ([b1s, b2s]) => [tsplus_module_2.asImmutableArray(b1s), tsplus_module_2.asImmutableArray(b2s)], G);
+}
+export function wiltWithIndex_(self, f,
+/** @tsplus auto */
+G) {
+  return tsplus_module_16.map(foldLeftWithIndex_1(self, G.pure([[], []]), (i, fbs, a) => tsplus_module_14.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;
+  }), G)), ([b1s, b2s]) => [tsplus_module_2.asImmutableArray(b1s), tsplus_module_2.asImmutableArray(b2s)], G);
+}
 /**
  * @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);
+export function wither_(self, f,
+/** @tsplus auto */
+G) {
+  const G_1 =
+  /** @tsplus auto */
+  G;
+  return witherWithIndex_1(self, (_, a) => f(a), G_1);
+}
 /**
  * @tsplus fluent fncts.ImmutableArray witherWithIndex
  */
 
-export const witherWithIndexSelf = self => A => f => witherWithIndex_(A)(self, f);
+function witherWithIndex_1(self, f,
+/** @tsplus auto */
+G) {
+  return tsplus_module_16.map(foldLeftWithIndex_1(self, G.pure([]), (i, b, a) => tsplus_module_14.zipWith(f(i, a), b, (maybeB, bs) => {
+    if (tsplus_module_4.isJust(maybeB)) {
+      bs.push(maybeB.value);
+    }
+
+    return bs;
+  }, G)), bs => tsplus_module_2.asImmutableArray(bs), G);
+}
 /**
  * @tsplus fluent fncts.ImmutableArray zip
  */
 
+
 export function zip_(self, that) {
   return zipWith_1(self, that, tuple);
 }