@fncts/base 0.0.39 → 0.0.41

package/_src/typeclass/Apply.ts

@@ -339,9 +339,7 @@ export function sequenceT<F extends HKT, FC = HKT.None>(
  * internal
  * -------------------------------------------------------------------------------------------------
  */
-/**
- * @internal
- */
+
 function curried(f: Function, n: number, acc: ReadonlyArray<unknown>) {
   return function (x: unknown) {
     const combined = Array(acc.length + 1);
@@ -353,9 +351,7 @@ function curried(f: Function, n: number, acc: ReadonlyArray<unknown>) {
     return n === 0 ? f.apply(null, combined) : curried(f, n - 1, combined);
   };
 }
-/**
- * @internal
- */
+
 const tupleConstructors: Record<number, (a: unknown) => any> = {
   1: (a) => [a],
   2: (a) => (b: any) => [a, b],
@@ -363,18 +359,14 @@ const tupleConstructors: Record<number, (a: unknown) => any> = {
   4: (a) => (b: any) => (c: any) => (d: any) => [a, b, c, d],
   5: (a) => (b: any) => (c: any) => (d: any) => (e: any) => [a, b, c, d, e],
 };
-/**
- * @internal
- */
+
 function getTupleConstructor(len: number): (a: unknown) => any {
   if (!tupleConstructors.hasOwnProperty(len)) {
     tupleConstructors[len] = curried(tuple, len - 1, []);
   }
   return tupleConstructors[len]!;
 }
-/**
- * @internal
- */
+
 function getRecordConstructor(keys: ReadonlyArray<string>) {
   const len = keys.length;
   return curried(
@@ -389,9 +381,7 @@ function getRecordConstructor(keys: ReadonlyArray<string>) {
     [],
   );
 }
-/**
- * @internal
- */
+
 type InferMixStruct<F extends HKT, FC, P extends HKT.ParamName, T, KS> = HKT.MixStruct<
   F,
   P,
@@ -400,9 +390,7 @@ type InferMixStruct<F extends HKT, FC, P extends HKT.ParamName, T, KS> = HKT.Mix
     [K in keyof KS]: HKT.Infer<F, FC, P, KS[K]>;
   }
 >;
-/**
- * @internal
- */
+
 type InferMixTuple<F extends HKT, FC, P extends HKT.ParamName, T, KT> = HKT.MixStruct<
   F,
   P,

package/_src/util/assert.ts

@@ -3,8 +3,8 @@ export class AssertionError extends Error {
     super(`Assertion Failed: ${message}`);
   }
 }
-export function assert(assertion: boolean, message: string): asserts assertion {
+export function assert(assertion: boolean, message?: string): asserts assertion {
   if (!assertion) {
-    throw new AssertionError(message);
+    throw new AssertionError(message ?? "");
   }
 }

package/_src/util/pattern.ts

@@ -1,114 +1,32 @@
 export const pattern_: <N extends string>(
   n: N,
 ) => {
-  <
-    X extends {
-      [k in N]: string;
-    },
-    K extends {
-      [k in X[N]]: (
-        _: Extract<
-          X,
-          {
-            [_tag in N]: k;
-          }
-        >,
-      ) => any;
-    },
-  >(
+  <X extends { [k in N]: string }, K extends { [k in X[N]]: (_: Extract<X, { [_tag in N]: k }>) => any }>(
     m: X,
     _: K,
   ): ReturnType<K[keyof K]>;
-  <
-    X extends {
-      [k in N]: string;
-    },
-    K extends {
-      [k in X[N]]?: (
-        _: Extract<
-          X,
-          {
-            [_tag in N]: k;
-          }
-        >,
-      ) => any;
-    },
-    H,
-  >(
+  <X extends { [k in N]: string }, K extends { [k in X[N]]?: (_: Extract<X, { [_tag in N]: k }>) => any }, H>(
     m: X,
     _: K,
-    __: (
-      _: Exclude<
-        X,
-        {
-          _tag: keyof K;
-        }
-      >,
-    ) => H,
-  ):
-    | {
-        [k in keyof K]: ReturnType<NonNullable<K[k]>>;
-      }[keyof K]
-    | H;
+    __: (_: Exclude<X, { _tag: keyof K }>) => H,
+  ): { [k in keyof K]: ReturnType<NonNullable<K[k]>> }[keyof K] | H;
 } = (n) =>
   ((m: any, _: any, d: any) => {
     return (_[m[n]] ? _[m[n]](m) : d(m)) as any;
   }) as any;
-
 export const pattern: <N extends string>(
   n: N,
 ) => {
-  <
-    X extends {
-      [k in N]: string;
-    },
-    K extends {
-      [k in X[N]]: (
-        _: Extract<
-          X,
-          {
-            [_tag in N]: k;
-          }
-        >,
-      ) => any;
-    },
-  >(
+  <X extends { [k in N]: string }, K extends { [k in X[N]]: (_: Extract<X, { [_tag in N]: k }>) => any }>(
     _: K,
   ): (m: X) => ReturnType<K[keyof K]>;
-  <
-    X extends {
-      [k in N]: string;
-    },
-    K extends {
-      [k in X[N]]?: (
-        _: Extract<
-          X,
-          {
-            [_tag in N]: k;
-          }
-        >,
-      ) => any;
-    },
-    H,
-  >(
+  <X extends { [k in N]: string }, K extends { [k in X[N]]?: (_: Extract<X, { [_tag in N]: k }>) => any }, H>(
     _: K,
-    __: (
-      _: Exclude<
-        X,
-        {
-          _tag: keyof K;
-        }
-      >,
-    ) => H,
-  ): (m: X) =>
-    | {
-        [k in keyof K]: ReturnType<NonNullable<K[k]>>;
-      }[keyof K]
-    | H;
+    __: (_: Exclude<X, { _tag: keyof K }>) => H,
+  ): (m: X) => { [k in keyof K]: ReturnType<NonNullable<K[k]>> }[keyof K] | H;
 } = (n) =>
   ((_: any, d: any) => (m: any) => {
     return (_[m[n]] ? _[m[n]](m) : d(m)) as any;
   }) as any;
-
 export const matchTag_ = pattern_("_tag");
 export const matchTag  = pattern("_tag");

package/_src/util/rand/generator/RandomGenerator.ts

@@ -5,6 +5,7 @@ export default interface RandomGenerator {
   min(): number; //inclusive
   max(): number; //inclusive
 }
+
 function generateN(rng: RandomGenerator, num: number): number[] {
   const out: number[] = [];
   for (let idx = 0; idx != num; ++idx) {

package/collection/AsyncIterable/api.d.ts

@@ -0,0 +1,71 @@
+import { Lazy } from "@fncts/base/data/function/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { RefinementWithIndex, Refinement } from "@fncts/base/data/Refinement/definition";
+import { PredicateWithIndex, Predicate } from "@fncts/base/data/Predicate/definition";
+/**
+ * @tsplus static fncts.AsyncIterableOps __call
+ * @tsplus location "@fncts/base/collection/AsyncIterable/api"
+ */
+export declare function asyncIterable<A>(iterator: Lazy<AsyncIterator<A>>): AsyncIterable<A>;
+/**
+ * @tsplus static fncts.AsyncIterableOps from
+ * @tsplus location "@fncts/base/collection/AsyncIterable/api"
+ */
+export declare function from<A>(iterable: Iterable<A>): AsyncIterable<A>;
+/**
+ * @tsplus static fncts.AsyncIterableOps fromValues
+ * @tsplus location "@fncts/base/collection/AsyncIterable/api"
+ */
+export declare function fromValues<A extends ReadonlyArray<any>>(...values: A): AsyncIterable<A[number]>;
+/**
+ * @tsplus pipeable fncts.AsyncIterable filterMapWithIndex
+ * @tsplus location "@fncts/base/collection/AsyncIterable/api"
+ */
+export declare function filterMapWithIndex<A, B>(f: (index: number, a: A) => Maybe<B>): (self: AsyncIterable<A>) => AsyncIterable<B>;
+/**
+ * @tsplus pipeable fncts.AsyncIterable filterWithIndex
+ * @tsplus location "@fncts/base/collection/AsyncIterable/api"
+ */
+export declare function filterWithIndex<A, B extends A>(refinement: RefinementWithIndex<number, A, B>): (self: AsyncIterable<A>) => AsyncIterable<B>;
+export declare function filterWithIndex<A>(predicate: PredicateWithIndex<number, A>): (self: AsyncIterable<A>) => AsyncIterable<A>;
+/**
+ * @tsplus pipeable fncts.AsyncIterable filter
+ * @tsplus location "@fncts/base/collection/AsyncIterable/api"
+ */
+export declare function filter<A, B extends A>(refinement: Refinement<A, B>): (self: AsyncIterable<A>) => AsyncIterable<B>;
+export declare function filter<A>(predicate: Predicate<A>): (self: AsyncIterable<A>) => AsyncIterable<A>;
+/**
+ * @tsplus pipeable fncts.AsyncIterable mapWithIndex
+ * @tsplus location "@fncts/base/collection/AsyncIterable/api"
+ */
+export declare function mapWithIndex<A, B>(f: (i: number, a: A) => B): (self: AsyncIterable<A>) => AsyncIterable<B>;
+/**
+ * @tsplus pipeable fncts.AsyncIterable map
+ * @tsplus location "@fncts/base/collection/AsyncIterable/api"
+ */
+export declare function map<A, B>(f: (a: A) => B): (self: AsyncIterable<A>) => AsyncIterable<B>;
+/**
+ * @tsplus pipeable fncts.AsyncIterable mapPromiseWithIndex
+ * @tsplus location "@fncts/base/collection/AsyncIterable/api"
+ */
+export declare function mapPromiseWithIndex<A, B>(f: (i: number, a: A) => Promise<B>): (self: AsyncIterable<A>) => AsyncIterable<B>;
+/**
+ * @tsplus pipeable fncts.AsyncIterable mapPromise
+ * @tsplus location "@fncts/base/collection/AsyncIterable/api"
+ */
+export declare function mapPromise<A, B>(f: (a: A) => Promise<B>): (self: AsyncIterable<A>) => AsyncIterable<B>;
+/**
+ * @tsplus pipeable fncts.AsyncIterable zipWith
+ * @tsplus location "@fncts/base/collection/AsyncIterable/api"
+ */
+export declare function zipWith<A, B, C>(that: AsyncIterable<B>, f: (a: A, b: B) => C): (self: AsyncIterable<A>) => AsyncIterable<C>;
+/**
+ * @tsplus pipeable fncts.AsyncIterable zipWithPromise
+ * @tsplus location "@fncts/base/collection/AsyncIterable/api"
+ */
+export declare function zipWithPromise<A, B, C>(that: AsyncIterable<B>, f: (a: A, b: B) => Promise<C>): (self: AsyncIterable<A>) => AsyncIterable<C>;
+/**
+ * @tsplus pipeable fncts.AsyncIterable foldLeftWithIndex
+ * @tsplus location "@fncts/base/collection/AsyncIterable/api"
+ */
+export declare function foldLeftWithIndex<A, B>(b: B, f: (i: number, b: B, a: A) => B | PromiseLike<B>): (self: AsyncIterable<A>) => Promise<B>;

package/collection/AsyncIterable/definition.d.ts

@@ -0,0 +1,9 @@
+declare global {
+    /**
+     * @tsplus type fncts.AsyncIterable
+     * @tsplus companion fncts.AsyncIterableOps
+     */
+    export interface AsyncIterable<T, TReturn = any, TNext = any> {
+    }
+}
+export {};

package/collection/AsyncIterable.d.ts

@@ -0,0 +1,2 @@
+export * from "./AsyncIterable/api.js";
+export * from "./AsyncIterable/definition.js";

package/collection/Iterable/api/traverseConc.d.ts

@@ -5,7 +5,7 @@ import type * as P from "@fncts/base/typeclass";
  * @tsplus getter fncts.Iterable traverseToConcWithIndex
  * @tsplus location "@fncts/base/collection/Iterable/api/traverseConc"
  */
-export declare function _traverseToConcWithIndex<A>(ta: Iterable<A>): <G extends HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B>(f: (i: number, a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, B>) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, Conc<B>>;
+export declare function _traverseToConcWithIndex<A>(ta: Iterable<A>): <G extends HKT, GC = HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B>(f: (i: number, a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, B>) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, Conc<B>>;
 /**
  * @tsplus getter fncts.Iterable traverseToConc
  * @tsplus location "@fncts/base/collection/Iterable/api/traverseConc"

package/collection/Iterable/api.d.ts

@@ -14,21 +14,6 @@ export declare function ap<A>(fa: Iterable<A>): <B>(self: Iterable<(a: A) => B>)
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
 export declare function append<B>(b: B): <A>(self: Iterable<A>) => Iterable<A | B>;
-/**
- * @tsplus getter fncts.Iterable toIterable
- * @tsplus location "@fncts/base/collection/Iterable/api"
- */
-export declare function toIterable<A>(self: Iterable<A>): Iterable<A>;
-/**
- * @tsplus getter fncts.Iterable toArray
- * @tsplus location "@fncts/base/collection/Iterable/api"
- */
-export declare function toArray<A>(self: Iterable<A>): Array<A>;
-/**
- * @tsplus pipeable fncts.Iterable flatMap
- * @tsplus location "@fncts/base/collection/Iterable/api"
- */
-export declare function flatMap<A, B>(f: (a: A) => Iterable<B>): (self: Iterable<A>) => Iterable<B>;
 /**
  * @tsplus pipeable fncts.Iterable concat
  * @tsplus location "@fncts/base/collection/Iterable/api"
@@ -90,15 +75,20 @@ export declare function find<A>(predicate: Predicate<A>): (self: Iterable<A>) =>
  */
 export declare function findIndex<A>(p: Predicate<A>): (self: Iterable<A>) => number;
 /**
- * @tsplus pipeable fncts.Iterable foldLeftWithIndex
+ * @tsplus pipeable fncts.Iterable flatMap
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function foldLeftWithIndex<A, B>(b: B, f: (i: number, b: B, a: A) => B): (self: Iterable<A>) => B;
+export declare function flatMap<A, B>(f: (a: A) => Iterable<B>): (self: Iterable<A>) => Iterable<B>;
 /**
  * @tsplus pipeable fncts.Iterable foldLeft
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
 export declare function foldLeft<A, B>(b: B, f: (b: B, a: A) => B): (self: Iterable<A>) => B;
+/**
+ * @tsplus pipeable fncts.Iterable foldLeftWithIndex
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function foldLeftWithIndex<A, B>(b: B, f: (i: number, b: B, a: A) => B): (self: Iterable<A>) => B;
 /**
  * @tsplus pipeable fncts.Iterable foldMap
  * @tsplus location "@fncts/base/collection/Iterable/api"
@@ -109,16 +99,31 @@ export declare function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: P.M
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
 export declare function foldMapWithIndex<A, M>(f: (i: number, a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): (self: Iterable<A>) => M;
+/**
+ * @tsplus pipeable fncts.Iterable foldRight
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function foldRight<A, B>(b: Eval<B>, f: (a: A, b: Eval<B>) => Eval<B>): (self: Iterable<A>) => Eval<B>;
 /**
  * @tsplus pipeable fncts.Iterable foldRightWithIndex
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
 export declare function foldRightWithIndex<A, B>(b: Eval<B>, f: (i: number, a: A, b: Eval<B>) => Eval<B>): (self: Iterable<A>) => Eval<B>;
 /**
- * @tsplus pipeable fncts.Iterable foldRight
+ * @tsplus getter fncts.Iterable intrinsicSize
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function foldRight<A, B>(b: Eval<B>, f: (a: A, b: Eval<B>) => Eval<B>): (self: Iterable<A>) => Eval<B>;
+export declare function intrinsicSize<A>(self: Iterable<A>): Maybe<number>;
+/**
+ * @tsplus getter fncts.Iterable isEmpty
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function isEmpty<A>(self: Iterable<A>): boolean;
+/**
+ * @tsplus getter fncts.Iterable isNonEmpty
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function isNonEmpty<A>(self: Iterable<A>): boolean;
 /**
  * @tsplus pipeable fncts.Iterable map
  * @tsplus location "@fncts/base/collection/Iterable/api"
@@ -129,6 +134,12 @@ export declare function map<A, B>(f: (a: A) => B): (self: Iterable<A>) => Iterab
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
 export declare function mapWithIndex<A, B>(f: (i: number, a: A) => B): (self: Iterable<A>) => Iterable<B>;
+/**
+ * @tsplus pipeable fncts.Iterable partition
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function partition<A, B extends A>(p: Refinement<A, B>): (self: Iterable<A>) => readonly [Iterable<A>, Iterable<B>];
+export declare function partition<A>(p: Predicate<A>): (self: Iterable<A>) => readonly [Iterable<A>, Iterable<A>];
 /**
  * @tsplus pipeable fncts.Iterable partitionMap
  * @tsplus location "@fncts/base/collection/Iterable/api"
@@ -139,12 +150,6 @@ export declare function partitionMap<A, B, C>(f: (a: A) => Either<B, C>): (self:
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
 export declare function partitionMapWithIndex<A, B, C>(f: (i: number, a: A) => Either<B, C>): (self: Iterable<A>) => readonly [Iterable<B>, Iterable<C>];
-/**
- * @tsplus pipeable fncts.Iterable partition
- * @tsplus location "@fncts/base/collection/Iterable/api"
- */
-export declare function partition<A, B extends A>(p: Refinement<A, B>): (self: Iterable<A>) => readonly [Iterable<A>, Iterable<B>];
-export declare function partition<A>(p: Predicate<A>): (self: Iterable<A>) => readonly [Iterable<A>, Iterable<A>];
 /**
  * @tsplus pipeable fncts.Iterable partitionWithIndex
  * @tsplus location "@fncts/base/collection/Iterable/api"
@@ -171,6 +176,16 @@ export declare function sum(self: Iterable<number>): number;
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
 export declare function take(n: number): <A>(self: Iterable<A>) => Iterable<A>;
+/**
+ * @tsplus getter fncts.Iterable toArray
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function toArray<A>(self: Iterable<A>): Array<A>;
+/**
+ * @tsplus getter fncts.Iterable toIterable
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function toIterable<A>(self: Iterable<A>): Iterable<A>;
 /**
  * @tsplus pipeable fncts.Iterable zipWith
  * @tsplus location "@fncts/base/collection/Iterable/api"

package/collection/compat/ArrayLike/definition.d.ts

@@ -2,12 +2,12 @@ declare global {
     /**
      * @tsplus type fncts.ArrayLike
      */
-    interface ArrayLike<T> {
+    export interface ArrayLike<T> {
     }
     /**
      * @tsplus type fncts.ArrayLike
      */
-    interface RelativeIndexable<T> {
+    export interface RelativeIndexable<T> {
     }
 }
 export {};

package/collection/compat.d.ts

@@ -1,3 +1,2 @@
 export type {} from "./compat/Set.js";
 export type {} from "./compat/Map.js";
-export type {} from "./compat/Array.js";

package/collection/immutable/Conc/definition.d.ts

@@ -118,7 +118,7 @@ declare class AppendN<A> extends ConcImplementation<A> {
     copyToArray(n: number, dest: Array<A> | Uint8Array): void;
     forEach<B>(startIndex: number, f: (i: number, a: A) => B): void;
 }
-declare class PrependN<A> extends ConcImplementation<A> {
+export declare class PrependN<A> extends ConcImplementation<A> {
     readonly end: ConcImplementation<A>;
     readonly buffer: Array<unknown> | Uint8Array;
     readonly bufferUsed: number;

package/collection/immutable/ReadonlyArray/api/chunksOf.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @tsplus pipeable fncts.ReadonlyArray chunksOf
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api/chunksOf"
+ */
+export declare function chunksOf(n: number): <A>(self: ReadonlyArray<A>) => ReadonlyArray<ReadonlyArray<A>>;

package/collection/immutable/ReadonlyArray/api/splitAt.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @tsplus pipeable fncts.ReadonlyArray splitAt
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api/splitAt"
+ */
+export declare function splitAt(n: number): <A>(as: ReadonlyArray<A>) => readonly [ReadonlyArray<A>, ReadonlyArray<A>];

package/collection/immutable/ReadonlyArray/api/splitWhere.d.ts

@@ -0,0 +1,6 @@
+import { Predicate } from "@fncts/base/data/Predicate/definition";
+/**
+ * @tsplus pipeable fncts.ReadonlyArray splitWhere
+ * @tsplus location "@fncts/base/collection/immutable/ReadonlyArray/api/splitWhere"
+ */
+export declare function splitWhere<A>(p: Predicate<A>): (self: ReadonlyArray<A>) => readonly [ReadonlyArray<A>, ReadonlyArray<A>];