@fncts/base 0.0.3 → 0.0.6

package/_src/collection/immutable/ImmutableArray/instances.ts

@@ -1,9 +1,10 @@
 import type { ImmutableArrayF } from "@fncts/base/collection/immutable/ImmutableArray/definition";
+import type * as P from "@fncts/base/typeclass";
 
 import {
   alignWith_,
   alt_,
-  ap_,
+  cross_,
   crossWith_,
   filter_,
   filterMap_,
@@ -28,141 +29,162 @@ import {
   witherWithIndex_,
 } from "@fncts/base/collection/immutable/ImmutableArray/api";
 import { empty } from "@fncts/base/collection/immutable/ImmutableArray/constructors";
-import * as P from "@fncts/base/typeclass";
 
-export const Align = P.Align<ImmutableArrayF>({
-  map_,
-  alignWith_,
+/**
+ * @tsplus implicit
+ */
+export const Align: P.Align<ImmutableArrayF> = {
+  map: map_,
+  alignWith: alignWith_,
   nil: empty,
-});
-
-export const Functor = P.Functor<ImmutableArrayF>({
-  map_,
-});
-
-export const FunctorWithIndex = P.FunctorWithIndex<ImmutableArrayF>({
-  map_,
-  mapWithIndex_,
-});
-
-export const Apply = P.Apply<ImmutableArrayF>({
-  map_,
-  ap_,
-  zipWith_: crossWith_,
-});
-
-export const Applicative = P.Applicative<ImmutableArrayF>({
-  map_,
-  ap_,
-  zipWith_: crossWith_,
+};
+
+/**
+ * @tsplus implicit
+ */
+export const Functor: P.Functor<ImmutableArrayF> = {
+  map: map_,
+};
+
+/**
+ * @tsplus implicit
+ */
+export const FunctorWithIndex: P.FunctorWithIndex<ImmutableArrayF> = {
+  map: map_,
+  mapWithIndex: mapWithIndex_,
+};
+
+/**
+ * @tsplus implicit
+ */
+export const Apply: P.Apply<ImmutableArrayF> = {
+  map: map_,
+  zip: cross_,
+  zipWith: crossWith_,
+};
+
+/**
+ * @tsplus implicit
+ */
+export const Applicative: P.Applicative<ImmutableArrayF> = {
+  map: map_,
+  zip: cross_,
+  zipWith: crossWith_,
   pure: (a) => ImmutableArray(a),
-});
-
-export const Alt = P.Alt<ImmutableArrayF>({
-  map_,
-  alt_,
-});
-
-export const Alternative = P.Alternative<ImmutableArrayF>({
-  map_,
-  ap_,
-  zipWith_: crossWith_,
+};
+
+/**
+ * @tsplus implicit
+ */
+export const Alt: P.Alt<ImmutableArrayF> = {
+  map: map_,
+  alt: alt_,
+};
+
+/**
+ * @tsplus implicit
+ */
+export const Alternative: P.Alternative<ImmutableArrayF> = {
+  map: map_,
+  zip: cross_,
+  zipWith: crossWith_,
   pure: (a) => ImmutableArray(a),
-  alt_,
+  alt: alt_,
   nil: empty,
-});
-
-export const Filterable = P.Filterable<ImmutableArrayF>({
-  map_,
-  filter_,
-  filterMap_,
-  partition_,
-  partitionMap_,
-});
-
-export const FilterableWithIndex = P.FilterableWithIndex<ImmutableArrayF>({
-  map_,
-  filter_,
-  filterMap_,
-  partition_,
-  partitionMap_,
-  mapWithIndex_,
-  filterWithIndex_,
-  filterMapWithIndex_,
-  partitionWithIndex_,
-  partitionMapWithIndex_,
-});
-
-export const Foldable = P.Foldable<ImmutableArrayF>({
-  foldLeft_,
-  foldRight_,
-});
-
-export const FoldableWithIndex = P.FoldableWithIndex<ImmutableArrayF>({
-  foldLeft_,
-  foldRight_,
-  foldLeftWithIndex_,
-  foldRightWithIndex_,
-});
-
-export const Monad = P.Monad<ImmutableArrayF>({
-  map_,
-  ap_,
-  zipWith_: crossWith_,
-  pure: (a) => ImmutableArray(a),
-  flatMap_: flatMap_,
-});
-
-export const Traversable = P.Traversable<ImmutableArrayF>({
-  map_,
-  foldLeft_,
-  foldRight_,
-  traverse_,
-});
-
-export const TraversableWithIndex = P.TraversableWithIndex<ImmutableArrayF>({
-  map_,
-  foldLeft_,
-  foldRight_,
-  traverse_,
-  mapWithIndex_,
-  foldLeftWithIndex_,
-  foldRightWithIndex_,
-  traverseWithIndex_,
-});
-
-export const Witherable = P.Witherable<ImmutableArrayF>({
-  map_,
-  foldLeft_,
-  foldRight_,
-  filter_,
-  filterMap_,
-  partition_,
-  partitionMap_,
-  traverse_,
-  wither_,
-  wilt_,
-});
-
-export const WitherableWithIndex = P.WitherableWithIndex<ImmutableArrayF>({
-  map_,
-  foldLeft_,
-  foldRight_,
-  filter_,
-  filterMap_,
-  partition_,
-  partitionMap_,
-  traverse_,
-  wither_,
-  wilt_,
-  mapWithIndex_,
-  foldLeftWithIndex_,
-  foldRightWithIndex_,
-  filterWithIndex_,
-  filterMapWithIndex_,
-  partitionWithIndex_,
-  partitionMapWithIndex_,
-  traverseWithIndex_,
-  witherWithIndex_,
-  wiltWithIndex_,
-});
+};
+
+/**
+ * @tsplus implicit
+ */
+export const Filterable: P.Filterable<ImmutableArrayF> = {
+  map: map_,
+  filter: filter_,
+  filterMap: filterMap_,
+  partition: partition_,
+  partitionMap: partitionMap_,
+};
+
+/**
+ * @tsplus implicit
+ */
+export const FilterableWithIndex: P.FilterableWithIndex<ImmutableArrayF> = {
+  ...FunctorWithIndex,
+  ...Filterable,
+  filterWithIndex: filterWithIndex_,
+  filterMapWithIndex: filterMapWithIndex_,
+  partitionWithIndex: partitionWithIndex_,
+  partitionMapWithIndex: partitionMapWithIndex_,
+};
+
+/**
+ * @tsplus implicit
+ */
+export const Foldable: P.Foldable<ImmutableArrayF> = {
+  foldLeft: foldLeft_,
+  foldRight: foldRight_,
+};
+
+/**
+ * @tsplus implicit
+ */
+export const FoldableWithIndex: P.FoldableWithIndex<ImmutableArrayF> = {
+  ...Foldable,
+  foldLeftWithIndex: foldLeftWithIndex_,
+  foldRightWithIndex: foldRightWithIndex_,
+};
+
+/**
+ * @tsplus implicit
+ */
+export const FlatMap: P.FlatMap<ImmutableArrayF> = {
+  ...Functor,
+  flatMap: flatMap_,
+};
+
+/**
+ * @tsplus implicit
+ */
+export const Monad: P.Monad<ImmutableArrayF> = {
+  ...Applicative,
+  ...FlatMap,
+};
+
+/**
+ * @tsplus implicit
+ */
+export const Traversable: P.Traversable<ImmutableArrayF> = {
+  ...Functor,
+  ...Foldable,
+  traverse: traverse_,
+};
+
+/**
+ * @tsplus implicit
+ */
+export const TraversableWithIndex: P.TraversableWithIndex<ImmutableArrayF> = {
+  ...Traversable,
+  ...FoldableWithIndex,
+  ...FunctorWithIndex,
+  traverseWithIndex: traverseWithIndex_,
+};
+
+/**
+ * @tsplus implicit
+ */
+export const Witherable: P.Witherable<ImmutableArrayF> = {
+  ...Traversable,
+  ...Filterable,
+  wither: wither_,
+  wilt: wilt_,
+};
+
+/**
+ * @tsplus implicit
+ */
+export const WitherableWithIndex: P.WitherableWithIndex<ImmutableArrayF> = {
+  ...TraversableWithIndex,
+  ...FilterableWithIndex,
+  ...Witherable,
+  witherWithIndex: witherWithIndex_,
+  wiltWithIndex: wiltWithIndex_,
+};

package/_src/collection/immutable/ImmutableArray.ts

@@ -4,3 +4,10 @@ export * from "./ImmutableArray/constructors.js";
 export * from "./ImmutableArray/definition.js";
 export * from "./ImmutableArray/instances.js";
 // codegen:end
+
+// codegen:start { preset: barrel, include: ./ImmutableArray/api/*.ts }
+export * from "./ImmutableArray/api/chunksOf.js";
+export * from "./ImmutableArray/api/slice.js";
+export * from "./ImmutableArray/api/splitAt.js";
+export * from "./ImmutableArray/api/splitWhere.js";
+// codegen:end

package/_src/collection/immutable/ImmutableNonEmptyArray/api.ts

@@ -1,6 +1,7 @@
 import type { ImmutableNonEmptyArrayF } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
 
 import { allocWithHead } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/constructors";
+import { ImmutableNonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
 import { identity } from "@fncts/base/data/function";
 import * as P from "@fncts/base/typeclass";
 
@@ -168,28 +169,27 @@ export function crossWith_<A, B, C>(
 }
 
 /**
- * @constrained
+ * @tsplus fluent fncts.ImmutableNonEmptyArray cross
  */
-export function elem_<A>(E: P.Eq<A>) {
-  return (self: ImmutableNonEmptyArray<A>, a: A): boolean => {
-    const p   = (element: A) => E.equals_(a, element);
-    const len = self.length;
-    for (let i = 0; i < len; i++) {
-      if (p(self._array[i]!)) {
-        return true;
-      }
-    }
-    return false;
-  };
+export function cross_<A, B>(
+  self: ImmutableNonEmptyArray<A>,
+  fb: ImmutableNonEmptyArray<B>,
+): ImmutableNonEmptyArray<readonly [A, B]> {
+  return self.crossWith(fb, (a, b) => [a, b]);
 }
 
 /**
- * @tsplus getter fncts.ImmutableNonEmptyArray elem
+ * @tsplus fluent fncts.ImmutableNonEmptyArray elem
  */
-export function elemSelf<A>(self: ImmutableNonEmptyArray<A>) {
-  return (E: P.Eq<A>) =>
-    (a: A): boolean =>
-      elem_(E)(self, a);
+export function elem_<A>(self: ImmutableNonEmptyArray<A>, a: A, /** @tsplus auto */ E: P.Eq<A>): boolean {
+  const p   = (element: A) => E.equals(a, element);
+  const len = self.length;
+  for (let i = 0; i < len; i++) {
+    if (p(self._array[i]!)) {
+      return true;
+    }
+  }
+  return false;
 }
 
 /**
@@ -199,18 +199,11 @@ export function flatten<A>(self: ImmutableNonEmptyArray<ImmutableNonEmptyArray<A
   return self.flatMap(identity);
 }
 
-/**
- * @constrained
- */
-export function fold_<A>(S: P.Semigroup<A>) {
-  return (self: ImmutableNonEmptyArray<A>): A => self.slice(1).foldLeft(self._array[0], S.combine_);
-}
-
 /**
  * @tsplus fluent fncts.ImmutableNonEmptyArray fold
  */
-export function foldSelf<A>(self: ImmutableNonEmptyArray<A>, S: P.Semigroup<A>): A {
-  return fold_(S)(self);
+export function fold_<A>(self: ImmutableNonEmptyArray<A>, /** @tsplus auto */ S: P.Semigroup<A>): A {
+  return self.slice(1).foldLeft(self._array[0], S.combine);
 }
 
 /**
@@ -233,39 +226,21 @@ export function foldLeftWithIndex_<A, B>(self: ImmutableNonEmptyArray<A>, b: B,
 }
 
 /**
- * @constrained
+ * @tsplus fluent fncts.ImmutableNonEmptyArray foldMapWithIndex
  */
-export function foldMapWithIndex_<M>(M: P.Monoid<M>) {
-  return <A>(self: ImmutableNonEmptyArray<A>, f: (i: number, a: A) => M): M => {
-    return self.foldLeftWithIndex(M.nat, (i, b, a) => M.combine_(b, f(i, a)));
-  };
-}
-
-/**
- * @tsplus getter fncts.ImmutableNonEmptyArray foldMapWithIndex
- */
-export function foldMapWithIndexSelf<A>(self: ImmutableNonEmptyArray<A>) {
-  return <M>(M: P.Monoid<M>) =>
-    (f: (i: number, a: A) => M): M =>
-      foldMapWithIndex_(M)(self, f);
-}
-
-/**
- * @constrained
- */
-export function foldMap_<M>(M: P.Monoid<M>) {
-  return <A>(self: ImmutableNonEmptyArray<A>, f: (a: A) => M): M => {
-    return self.foldMapWithIndex(M)((_, a) => f(a));
-  };
+export function foldMapWithIndex_<A, M>(
+  self: ImmutableNonEmptyArray<A>,
+  f: (i: number, a: A) => M,
+  /** @tsplus auto */ M: P.Monoid<M>,
+): M {
+  return self.foldLeftWithIndex(M.nat, (i, b, a) => M.combine(b, f(i, a)));
 }
 
 /**
- * @tsplus getter fncts.ImmutableNonEmptyArray foldMap
+ * @tsplus fluent fncts.ImmutableNonEmptyArray foldMap
  */
-export function foldMapSelf<A>(self: ImmutableNonEmptyArray<A>) {
-  return <M>(M: P.Monoid<M>) =>
-    (f: (a: A) => M): M =>
-      self.foldMapWithIndex(M)((_, a) => f(a));
+export function foldMap_<A, M>(self: ImmutableNonEmptyArray<A>, f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): M {
+  return self.foldMapWithIndex((_, a) => f(a), M);
 }
 
 /**
@@ -286,38 +261,34 @@ export function foldRightWithIndex_<A, B>(self: ImmutableNonEmptyArray<A>, b: B,
   return r;
 }
 
-export function group<A>(E: P.Eq<A>) {
-  return (self: ImmutableNonEmptyArray<A>): ImmutableNonEmptyArray<ImmutableNonEmptyArray<A>> => {
-    return self.chop((as) => {
-      const h   = as._array[0];
-      const out = [h];
-      let i     = 1;
-      for (; i < as.length; i++) {
-        const a = as._array[i]!;
-        if (E.equals_(a, h)) {
-          out.push(a);
-        } else {
-          break;
-        }
-      }
-      return [out.unsafeAsNonEmptyArray, as.slice(i)];
-    });
-  };
-}
-
 /**
- * @tsplus getter fncts.ImmutableNonEmptyArray group
+ * @tsplus fluent fncts.ImmutableNonEmptyArray group
  */
-export function groupSelf<A>(self: ImmutableNonEmptyArray<A>) {
-  return (E: P.Eq<A>): ImmutableNonEmptyArray<ImmutableNonEmptyArray<A>> => group(E)(self);
+export function group<A>(
+  self: ImmutableNonEmptyArray<A>,
+  /** @tsplus auto */ E: P.Eq<A>,
+): ImmutableNonEmptyArray<ImmutableNonEmptyArray<A>> {
+  return self.chop((as) => {
+    const h   = as._array[0];
+    const out = [h];
+    let i     = 1;
+    for (; i < as.length; i++) {
+      const a = as._array[i]!;
+      if (E.equals(a, h)) {
+        out.push(a);
+      } else {
+        break;
+      }
+    }
+    return [out.unsafeAsNonEmptyArray, as.slice(i)];
+  });
 }
 
 export function groupSort<A>(
-  O: P.Ord<A>,
-): (as: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<ImmutableNonEmptyArray<A>> {
-  const sortO  = sort(O);
-  const groupO = group(O);
-  return (as) => groupO(sortO(as));
+  as: ImmutableNonEmptyArray<A>,
+  /** @tsplus auto */ O: P.Ord<A>,
+): ImmutableNonEmptyArray<ImmutableNonEmptyArray<A>> {
+  return as.sort(O).group(O);
 }
 
 /**
@@ -348,34 +319,22 @@ export function mapWithIndex_<A, B>(
   return ImmutableNonEmptyArray.from(out);
 }
 
-export function max<A>(O: P.Ord<A>) {
-  const S = P.Semigroup.max(O);
-  return (self: ImmutableNonEmptyArray<A>): A => {
-    const [head, tail] = self.unprepend;
-    return tail.isNonEmpty() ? tail.foldLeft(head, S.combine_) : head;
-  };
-}
-
 /**
  * @tsplus fluent fncts.ImmutableNonEmptyArray max
  */
-export function maxSelf<A>(self: ImmutableNonEmptyArray<A>, O: P.Ord<A>): A {
-  return max(O)(self);
-}
-
-export function min<A>(O: P.Ord<A>) {
-  const S = P.Semigroup.min(O);
-  return (self: ImmutableNonEmptyArray<A>): A => {
-    const [head, tail] = self.unprepend;
-    return tail.isNonEmpty() ? tail.foldLeft(head, S.combine_) : head;
-  };
+export function max<A>(self: ImmutableNonEmptyArray<A>, /** @tsplus auto */ O: P.Ord<A>): A {
+  const S            = P.Semigroup.max(O);
+  const [head, tail] = self.unprepend;
+  return tail.isNonEmpty() ? tail.foldLeft(head, S.combine) : head;
 }
 
 /**
  * @tsplus fluent fncts.ImmutableNonEmptyArray max
  */
-export function minSelf<A>(self: ImmutableNonEmptyArray<A>, O: P.Ord<A>): A {
-  return max(O)(self);
+export function min<A>(self: ImmutableNonEmptyArray<A>, /** @tsplus auto */ O: P.Ord<A>): A {
+  const S            = P.Semigroup.min(O);
+  const [head, tail] = self.unprepend;
+  return tail.isNonEmpty() ? tail.foldLeft(head, S.combine) : head;
 }
 
 /**
@@ -412,14 +371,6 @@ export function reverse<A>(self: ImmutableNonEmptyArray<A>): ImmutableNonEmptyAr
   return ImmutableNonEmptyArray.from(out);
 }
 
-export const sequence: P.sequence<ImmutableNonEmptyArrayF> = (A) => (self) => self.traverse(A)(identity);
-
-/**
- * @tsplus getter fncts.ImmutableNonEmptyArray sequence
- */
-export const sequenceSelf: P.sequenceSelf<ImmutableNonEmptyArrayF> = (self) => (A) =>
-  unsafeCoerce(self.traverse(A)(unsafeCoerce(identity)));
-
 /**
  * @tsplus fluent fncts.ImmutableNonEmptyArray splitAt
  */
@@ -433,67 +384,46 @@ export function splitAt_<A>(
     : [self._array.slice(0, m).unsafeAsNonEmptyArray, self.slice(m)];
 }
 
-export function sort<B>(O: P.Ord<B>) {
-  return <A extends B>(self: ImmutableNonEmptyArray<A>): ImmutableNonEmptyArray<A> =>
-    self.length === 1
-      ? self
-      : self._array.slice().sort((first, second) => O.compare_(first, second)).unsafeAsNonEmptyArray;
-}
-
 /**
  * @tsplus fluent fncts.ImmutableNonEmptyArray sort
  */
-export function sortSelf<A extends B, B>(self: ImmutableNonEmptyArray<A>, O: P.Ord<B>): ImmutableNonEmptyArray<A> {
-  return sort(O)(self);
+export function sort<A>(self: ImmutableNonEmptyArray<A>, /** @tsplus auto */ O: P.Ord<A>): ImmutableNonEmptyArray<A> {
+  return self.length === 1
+    ? self
+    : self._array.slice().sort((first, second) => O.compare(first, second)).unsafeAsNonEmptyArray;
 }
 
-export const traverseWithIndex_: P.traverseWithIndex_<ImmutableNonEmptyArrayF> =
-  P.mkTraverseWithIndex_<ImmutableNonEmptyArrayF>()(
-    (_) => (A) => (self, f) =>
-      self.tail.foldLeftWithIndex(
-        A.map_(f(0, self.head), (b) => ImmutableNonEmptyArray(b)),
-        (i, fbs, a) => A.zipWith_(fbs, f(i + 1, a), (bs, b) => bs.append(b)),
-      ),
-  );
-
 /**
- * @tsplus getter fncts.ImmutableNonEmptyArray traverseWithIndex
+ * @tsplus fluent fncts.ImmutableNonEmptyArray traverseWithIndex
  */
-export const traverseWithIndexSelf: P.traverseWithIndexSelf<ImmutableNonEmptyArrayF> = (self) => (A) => (f) =>
-  traverseWithIndex_(A)(self, f);
-
-export const traverse_: P.traverse_<ImmutableNonEmptyArrayF> = (A) => (self, f) =>
-  self.traverseWithIndex(A)((_, a) => f(a));
+export const traverseWithIndex_: P.TraversableWithIndex<ImmutableNonEmptyArrayF>["traverseWithIndex"] = (self, f, G) =>
+  self.tail.foldLeftWithIndex(
+    f(0, self.head).map((b) => ImmutableNonEmptyArray(b), G),
+    (i, fbs, a) => fbs.zipWith(f(i + 1, a), (bs, b) => bs.append(b), G),
+  );
 
 /**
- * @tsplus getter fncts.ImmutableNonEmptyArray traverse
+ * @tsplus fluent fncts.ImmutableNonEmptyArray traverse
  */
-export const traverseSelf: P.traverseSelf<ImmutableNonEmptyArrayF> = (self) => (A) => (f) =>
-  self.traverseWithIndex(A)((_, a) => f(a));
-
-export function uniq<A>(E: P.Eq<A>) {
-  return (self: ImmutableNonEmptyArray<A>): ImmutableNonEmptyArray<A> => {
-    if (self.length === 1) {
-      return self;
-    }
-    const elemE_ = elem_(E);
-    const out    = [self._array[0]];
-    const len    = self.length;
-    for (let i = 1; i < len; i++) {
-      const a = self._array[i]!;
-      if (!elemE_(out.unsafeAsNonEmptyArray, a)) {
-        out.push(a);
-      }
-    }
-    return out.unsafeAsNonEmptyArray;
-  };
-}
+export const traverse_: P.Traversable<ImmutableNonEmptyArrayF>["traverse"] = (self, f, A) =>
+  self.traverseWithIndex((_, a) => f(a), A);
 
 /**
- * @tsplus getter fncts.ImmutableNonEmptyArray uniq
+ * @tsplus fluent fncts.ImmutableNonEmptyArray uniq
  */
-export function uniqSelf<A>(self: ImmutableNonEmptyArray<A>) {
-  return (E: P.Eq<A>): ImmutableNonEmptyArray<A> => uniq(E)(self);
+export function uniq<A>(self: ImmutableNonEmptyArray<A>, /** @tsplus auto */ E: P.Eq<A>): ImmutableNonEmptyArray<A> {
+  if (self.length === 1) {
+    return self;
+  }
+  const out = [self._array[0]];
+  const len = self.length;
+  for (let i = 1; i < len; i++) {
+    const a = self._array[i]!;
+    if (!out.unsafeAsNonEmptyArray.elem(a, E)) {
+      out.push(a);
+    }
+  }
+  return out.unsafeAsNonEmptyArray;
 }
 
 /**

package/_src/collection/immutable/ImmutableNonEmptyArray/constructors.ts

@@ -1,3 +1,5 @@
+import { ImmutableNonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
+
 export function allocWithHead<A>(head: A, length: number): Array<A> & { 0: A } {
   const as = new Array(length);
   as[0]    = head;