@fncts/base 0.0.39 → 0.0.41

package/collection/immutable/Vector/api.d.ts

@@ -1,7 +1,7 @@
 import { Vector } from "@fncts/base/collection/immutable/Vector";
+import { Refinement, RefinementWithIndex } from "@fncts/base/data/Refinement/definition";
+import { Predicate, PredicateWithIndex } from "@fncts/base/data/Predicate/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";
 import { List } from "@fncts/base/collection/immutable/List/definition";
 import { HKT } from "@fncts/typelevel/HKT";
 import type { MutableVector, VectorF } from "@fncts/base/collection/immutable/Vector/definition";
@@ -16,21 +16,19 @@ import type * as P from "@fncts/base/typeclass";
  */
 export declare function append<A>(a: A): (self: Vector<A>) => Vector<A>;
 /**
- * @tsplus pipeable fncts.Vector filterMapWithIndex
- * @tsplus location "@fncts/base/collection/immutable/Vector/api"
- */
-export declare function filterMapWithIndex<A, B>(f: (i: number, a: A) => Maybe<B>): (self: Vector<A>) => Vector<B>;
-/**
- * @tsplus pipeable fncts.Vector filterMap
+ * Splits the Vector into chunks of the given size.
+ * @tsplus pipeable fncts.Vector chunksOf
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function filterMap<A, B>(f: (a: A) => Maybe<B>): (self: Vector<A>) => Vector<B>;
+export declare function chunksOf(size: number): <A>(self: Vector<A>) => Vector<Vector<A>>;
 /**
- * @tsplus pipeable fncts.Vector filterWithIndex
+ * Concatenates two Vectors.
+ * @complexity O(log(n))
+ * @tsplus pipeable fncts.Vector concat
+ * @tsplus pipeable-operator fncts.Vector + 1
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function filterWithIndex<A, B extends A>(refinement: RefinementWithIndex<number, A, B>): (self: Vector<A>) => Vector<B>;
-export declare function filterWithIndex<A>(predicate: PredicateWithIndex<number, A>): (self: Vector<A>) => Vector<A>;
+export declare function concat<B>(that: Vector<B>): <A>(self: Vector<A>) => Vector<A | B>;
 /**
  * @tsplus pipeable fncts.Vector filter
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
@@ -38,26 +36,28 @@ export declare function filterWithIndex<A>(predicate: PredicateWithIndex<number,
 export declare function filter<A, B extends A>(refinement: Refinement<A, B>): (self: Vector<A>) => Vector<B>;
 export declare function filter<A>(predicate: Predicate<A>): (self: Vector<A>) => Vector<A>;
 /**
- * Maps a function over a Vector and concatenates all the resulting
- * Vectors together.
- * @tsplus pipeable fncts.Vector flatMap
+ * @tsplus pipeable fncts.Vector filterMap
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function flatMap<A, B>(f: (a: A) => Vector<B>): (self: Vector<A>) => Vector<B>;
+export declare function filterMap<A, B>(f: (a: A) => Maybe<B>): (self: Vector<A>) => Vector<B>;
 /**
- * Splits the Vector into chunks of the given size.
- * @tsplus pipeable fncts.Vector chunksOf
+ * @tsplus pipeable fncts.Vector filterMapWithIndex
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function chunksOf(size: number): <A>(self: Vector<A>) => Vector<Vector<A>>;
+export declare function filterMapWithIndex<A, B>(f: (i: number, a: A) => Maybe<B>): (self: Vector<A>) => Vector<B>;
 /**
- * Concatenates two Vectors.
- * @complexity O(log(n))
- * @tsplus pipeable fncts.Vector concat
- * @tsplus pipeable-operator fncts.Vector + 1
+ * @tsplus pipeable fncts.Vector filterWithIndex
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function concat<B>(that: Vector<B>): <A>(self: Vector<A>) => Vector<A | B>;
+export declare function filterWithIndex<A, B extends A>(refinement: RefinementWithIndex<number, A, B>): (self: Vector<A>) => Vector<B>;
+export declare function filterWithIndex<A>(predicate: PredicateWithIndex<number, A>): (self: Vector<A>) => Vector<A>;
+/**
+ * Maps a function over a Vector and concatenates all the resulting
+ * Vectors together.
+ * @tsplus pipeable fncts.Vector flatMap
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function flatMap<A, B>(f: (a: A) => Vector<B>): (self: Vector<A>) => Vector<B>;
 /**
  * Returns `true` if the Vector contains the specified element.
  * Otherwise it returns `false`.
@@ -109,22 +109,6 @@ export declare function dropWhile<A>(predicate: Predicate<A>): (self: Vector<A>)
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
 export declare function elem<A>(a: A, /** @tsplus auto */ E: Eq<A>): (self: Vector<A>) => boolean;
-/**
- * Returns true if the two Vectors are equivalent.
- * @complexity O(n)
- * @tsplus pipeable fncts.Vector equals
- * @tsplus location "@fncts/base/collection/immutable/Vector/api"
- */
-export declare function equals<A>(that: Vector<A>): (self: Vector<A>) => boolean;
-/**
- * Returns `true` if and only if the predicate function returns `true`
- * for all elements in the given Vector.
- * @complexity O(n)
- * @tsplus pipeable fncts.Vector every
- * @tsplus location "@fncts/base/collection/immutable/Vector/api"
- */
-export declare function every<A, B extends A>(refinement: Refinement<A, B>): (self: Vector<A>) => self is Vector<B>;
-export declare function every<A>(predicate: Predicate<A>): (self: Vector<A>) => boolean;
 /**
  * Creates an empty Vector.
  * @complexity O(1)
@@ -138,13 +122,21 @@ export declare function empty<A = never>(): Vector<A>;
  */
 export declare function emptyPushable<A = never>(): MutableVector<A>;
 /**
- * Returns true if and only if there exists an element in the Vector for
- * which the predicate returns true.
+ * Returns true if the two Vectors are equivalent.
  * @complexity O(n)
- * @tsplus pipeable fncts.Vector some
+ * @tsplus pipeable fncts.Vector equals
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function some<A>(predicate: Predicate<A>): (self: Vector<A>) => boolean;
+export declare function equals<A>(that: Vector<A>): (self: Vector<A>) => boolean;
+/**
+ * Returns `true` if and only if the predicate function returns `true`
+ * for all elements in the given Vector.
+ * @complexity O(n)
+ * @tsplus pipeable fncts.Vector every
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function every<A, B extends A>(refinement: Refinement<A, B>): (self: Vector<A>) => self is Vector<B>;
+export declare function every<A>(predicate: Predicate<A>): (self: Vector<A>) => boolean;
 /**
  * Returns the _first_ element for which the predicate returns `true`.
  * If no such element is found the function returns `undefined`.
@@ -187,34 +179,22 @@ export declare function findLastIndex<A>(predicate: Predicate<A>): (self: Vector
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
 export declare function flatten<A>(self: Vector<Vector<A>>): Vector<A>;
-/**
- * Converts an array, an array-like, or an iterable into a Vector.
- * @complexity O(n)
- * @tsplus static fncts.VectorOps from
- * @tsplus location "@fncts/base/collection/immutable/Vector/api"
- */
-export declare function from<A>(sequence: A[] | ArrayLike<A> | Iterable<A>): Vector<A>;
 /**
  * Folds a function over a Vector. Left-associative.
  * @tsplus pipeable fncts.Vector foldLeft
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
 export declare function foldLeft<A, B>(initial: B, f: (acc: B, a: A) => B): (self: Vector<A>) => B;
-/**
- * @tsplus pipeable fncts.Vector foldLeftWithIndex
- * @tsplus location "@fncts/base/collection/immutable/Vector/api"
- */
-export declare function foldLeftWithIndex<A, B>(b: B, f: (i: number, b: B, a: A) => B): (self: Vector<A>) => B;
 /**
  * @tsplus pipeable fncts.Vector foldLeftWhile
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
 export declare function foldLeftWhile<A, B>(b: B, cont: Predicate<B>, f: (i: number, b: B, a: A) => B): (self: Vector<A>) => B;
 /**
- * @tsplus pipeable fncts.Vector foldRightWhile
+ * @tsplus pipeable fncts.Vector foldLeftWithIndex
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function foldRightWhile<A, B>(b: B, cont: Predicate<B>, f: (i: number, a: A, b: B) => B): (self: Vector<A>) => B;
+export declare function foldLeftWithIndex<A, B>(b: B, f: (i: number, b: B, a: A) => B): (self: Vector<A>) => B;
 /**
  * @tsplus pipeable fncts.Vector foldMap
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
@@ -232,6 +212,11 @@ export declare function foldMapWithIndex<A, M>(f: (i: number, a: A) => M, /** @t
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
 export declare function foldRight<A, B>(initial: B, f: (value: A, acc: B) => B): (self: Vector<A>) => B;
+/**
+ * @tsplus pipeable fncts.Vector foldRightWhile
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function foldRightWhile<A, B>(b: B, cont: Predicate<B>, f: (i: number, a: A, b: B) => B): (self: Vector<A>) => B;
 /**
  * Folds a function over a Vector. Right-associative.
  * @complexity O(n)
@@ -257,6 +242,13 @@ export declare function forEach<A>(f: (a: A) => void): (self: Vector<A>) => void
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
 export declare function forEachWithIndex<A>(f: (i: number, a: A) => void): (self: Vector<A>) => void;
+/**
+ * Converts an array, an array-like, or an iterable into a Vector.
+ * @complexity O(n)
+ * @tsplus static fncts.VectorOps from
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function from<A>(sequence: A[] | ArrayLike<A> | Iterable<A>): Vector<A>;
 /**
  * Gets the nth element of the Vector. If `n` is out of bounds
  * `undefined` is returned.
@@ -296,13 +288,6 @@ export declare function includes<A>(element: A): (self: Vector<A>) => boolean;
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
 export declare function indexOf<A>(element: A): (self: Vector<A>) => number;
-/**
- * Inserts the given element at the given index in the Vector.
- * @complexity O(log(n))
- * @tsplus pipeable fncts.Vector insertAt
- * @tsplus location "@fncts/base/collection/immutable/Vector/api"
- */
-export declare function insertAt<A>(index: number, element: A): (self: Vector<A>) => Vector<A>;
 /**
  * Inserts the given Vector of elements at the given index in the Vector.
  * @complexity `O(log(n))`
@@ -310,6 +295,13 @@ export declare function insertAt<A>(index: number, element: A): (self: Vector<A>
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
 export declare function insertAllAt<A>(index: number, elements: Vector<A>): (self: Vector<A>) => Vector<A>;
+/**
+ * Inserts the given element at the given index in the Vector.
+ * @complexity O(log(n))
+ * @tsplus pipeable fncts.Vector insertAt
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function insertAt<A>(index: number, element: A): (self: Vector<A>) => Vector<A>;
 /**
  * Inserts a separator between each element in a Vector.
  * @tsplus pipeable fncts.Vector intersperse
@@ -355,11 +347,6 @@ export declare function lastIndexOf<A>(element: A): (self: Vector<A>) => number;
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
 export declare function makeBy<A>(n: number, f: (index: number) => A): Vector<A>;
-/**
- * @tsplus pipeable fncts.Vector mapAccum
- * @tsplus location "@fncts/base/collection/immutable/Vector/api"
- */
-export declare function mapAccum<A, S, B>(s: S, f: (s: S, a: A) => readonly [B, S]): (self: Vector<A>) => readonly [Vector<B>, S];
 /**
  * Applies a function to each element in the given Vector and returns a
  * new Vector of the values that the function return.
@@ -368,6 +355,11 @@ export declare function mapAccum<A, S, B>(s: S, f: (s: S, a: A) => readonly [B,
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
 export declare function map<A, B>(f: (a: A) => B): (self: Vector<A>) => Vector<B>;
+/**
+ * @tsplus pipeable fncts.Vector mapAccum
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function mapAccum<A, S, B>(s: S, f: (s: S, a: A) => readonly [B, S]): (self: Vector<A>) => readonly [Vector<B>, S];
 /**
  * Applies a function to each element in the given Vector and returns a
  * new Vector of the values that the function return.
@@ -376,11 +368,6 @@ export declare function map<A, B>(f: (a: A) => B): (self: Vector<A>) => Vector<B
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
 export declare function mapWithIndex<A, B>(f: (i: number, a: A) => B): (self: Vector<A>) => Vector<B>;
-/**
- * @tsplus getter fncts.Vector mutableClone
- * @tsplus location "@fncts/base/collection/immutable/Vector/api"
- */
-export declare function mutableClone<A>(self: Vector<A>): MutableVector<A>;
 /**
  * Returns a Vector that has the entry specified by the index replaced with
  * the value returned by applying the function to the value.
@@ -392,6 +379,11 @@ export declare function mutableClone<A>(self: Vector<A>): MutableVector<A>;
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
 export declare function modifyAt<A>(i: number, f: (a: A) => A): (self: Vector<A>) => Vector<A>;
+/**
+ * @tsplus getter fncts.Vector mutableClone
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function mutableClone<A>(self: Vector<A>): MutableVector<A>;
 /**
  * Returns `true` if and only if the predicate function returns
  * `false` for every element in the given Vector.
@@ -479,6 +471,14 @@ export declare function single<A>(a: A): Vector<A>;
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
 export declare function slice(from: number, to: number): <A>(self: Vector<A>) => Vector<A>;
+/**
+ * Returns true if and only if there exists an element in the Vector for
+ * which the predicate returns true.
+ * @complexity O(n)
+ * @tsplus pipeable fncts.Vector some
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function some<A>(predicate: Predicate<A>): (self: Vector<A>) => boolean;
 /**
  * @tsplus pipeable fncts.Vector sort
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
@@ -528,15 +528,6 @@ export declare function tail<A>(self: Vector<A>): Vector<A>;
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
 export declare function take(n: number): <A>(self: Vector<A>) => Vector<A>;
-/**
- * Takes the first elements in the Vector for which the predicate returns
- * `true`.
- * @complexity `O(k + log(n))` where `k` is the number of elements satisfying
-the predicate.
- * @tsplus pipeable fncts.Vector takeWhile
- * @tsplus location "@fncts/base/collection/immutable/Vector/api"
- */
-export declare function takeWhile<A>(predicate: Predicate<A>): (self: Vector<A>) => Vector<A>;
 /**
  * Takes the last `n` elements from a Vector and returns them in a new
  * Vector.
@@ -554,6 +545,15 @@ satisfying the predicate.
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
 export declare function takeLastWhile<A>(predicate: Predicate<A>): (self: Vector<A>) => Vector<A>;
+/**
+ * Takes the first elements in the Vector for which the predicate returns
+ * `true`.
+ * @complexity `O(k + log(n))` where `k` is the number of elements satisfying
+the predicate.
+ * @tsplus pipeable fncts.Vector takeWhile
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function takeWhile<A>(predicate: Predicate<A>): (self: Vector<A>) => Vector<A>;
 /**
  * Converts a Vector into an array.
  * @complexity `O(n)`
@@ -569,17 +569,22 @@ export declare function toArray<A>(self: Vector<A>): ReadonlyArray<A>;
  */
 export declare function toList<A>(self: Vector<A>): List<A>;
 /**
- * @tsplus getter fncts.Vector traverseWithIndex
+ * @tsplus getter fncts.Vector traverse
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function _traverseWithIndex<A>(self: Vector<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, Vector<B>>;
+export declare function traverse_<A>(self: Vector<A>): <G extends HKT, GC = HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B>(f: (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, Vector<B>>;
 /**
- * @tsplus getter fncts.Vector traverse
+ * @tsplus getter fncts.Vector traverseWithIndex
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function _traverse<A>(self: Vector<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: (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, Vector<B>>;
+export declare function traverseWithIndex_<A>(self: Vector<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, Vector<B>>;
 export declare const traverseWithIndex: P.TraversableWithIndex<VectorF>["traverseWithIndex"];
 export declare const traverse: Traversable<VectorF>["traverse"];
+/**
+ * @tsplus static fncts.VectorOps unfold
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function unfold<A, B>(b: B, f: (b: B) => Maybe<readonly [A, B]>): Vector<A>;
 /**
  * Returns a new Vector without repeated elements by using the given
  * Eq instance to determine when elements are equal
@@ -588,11 +593,6 @@ export declare const traverse: Traversable<VectorF>["traverse"];
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
 export declare function uniq<A>(E: Eq<A>): (self: Vector<A>) => import("@fncts/base/collection/immutable/Vector/definition").Vector<A>;
-/**
- * @tsplus static fncts.VectorOps unfold
- * @tsplus location "@fncts/base/collection/immutable/Vector/api"
- */
-export declare function unfold<A, B>(b: B, f: (b: B) => Maybe<readonly [A, B]>): Vector<A>;
 /**
  * Returns the _first_ element for which the predicate returns `true`.
  * If no such element is found the function returns `undefined`.

package/collection/immutable.d.ts

@@ -1,10 +1,10 @@
 export type {} from "./immutable/Vector.js";
 export type {} from "./immutable/SortedMap.js";
 export type {} from "./immutable/RoseTree.js";
+export type {} from "./immutable/ReadonlyNonEmptyArray.js";
+export type {} from "./immutable/ReadonlyArray.js";
 export type {} from "./immutable/Queue.js";
 export type {} from "./immutable/List.js";
-export type {} from "./immutable/ImmutableNonEmptyArray.js";
-export type {} from "./immutable/ImmutableArray.js";
 export type {} from "./immutable/HashSet.js";
 export type {} from "./immutable/HashMap.js";
 export type {} from "./immutable/Dictionary.js";

package/collection.d.ts

@@ -3,3 +3,4 @@ export type {} from "./collection/mutable.js";
 export type {} from "./collection/immutable.js";
 export type {} from "./collection/compat.js";
 export type {} from "./collection/Iterable.js";
+export type {} from "./collection/AsyncIterable.js";

package/control/Eval/api.d.ts

@@ -1,6 +1,13 @@
 import { Eval } from "@fncts/base/control/Eval/definition";
+import { Lazy } from "@fncts/base/data/function/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
 import { Zipped } from "@fncts/base/data/Zipped";
 import type { _A } from "@fncts/base/types";
+/**
+ * @tsplus pipeable fncts.control.Eval ap
+ * @tsplus location "@fncts/base/control/Eval/api"
+ */
+export declare function ap<A>(fa: Eval<A>): <B>(self: Eval<(a: A) => B>) => Eval<B>;
 /**
  * @tsplus pipeable fncts.control.Eval and
  * @tsplus location "@fncts/base/control/Eval/api"
@@ -11,6 +18,16 @@ export declare function and(that: Eval<boolean>): (self: Eval<boolean>) => Eval<
  * @tsplus location "@fncts/base/control/Eval/api"
  */
 export declare function flatMap<A, B>(f: (a: A) => Eval<B>): (self: Eval<A>) => Eval<B>;
+/**
+ * @tsplus static fncts.control.EvalOps whileLoop
+ * @tsplus location "@fncts/base/control/Eval/api"
+ */
+export declare function whileLoop<A>(check: Lazy<boolean>, body: Lazy<Eval<A>>, process: (a: A) => void): Eval<void>;
+/**
+ * @tsplus static fncts.control.EvalOps forEach
+ * @tsplus location "@fncts/base/control/Eval/api"
+ */
+export declare function forEach<A, B>(as: Iterable<A>, f: (a: A) => Eval<B>): Eval<Conc<B>>;
 /**
  * @tsplus getter fncts.control.Eval flatten
  * @tsplus location "@fncts/base/control/Eval/api"
@@ -31,16 +48,21 @@ export declare function zipWith<A, B, C>(fb: Eval<B>, f: (a: A, b: B) => C): (se
  * @tsplus location "@fncts/base/control/Eval/api"
  */
 export declare function zip<B>(fb: Eval<B>): <A>(self: Eval<A>) => Eval<Zipped.Make<A, B>>;
+export declare function foreachWithIndex<A, B>(as: Iterable<A>, f: (index: number, a: A) => Eval<B>): Eval<ReadonlyArray<B>>;
 /**
- * @tsplus pipeable fncts.control.Eval ap
+ * @tsplus static fncts.control.EvalOps foreach
  * @tsplus location "@fncts/base/control/Eval/api"
  */
-export declare function ap<A>(fa: Eval<A>): <B>(self: Eval<(a: A) => B>) => Eval<B>;
+export declare function foreach<A, B>(as: Iterable<A>, f: (a: A) => Eval<B>): Eval<ReadonlyArray<B>>;
 /**
- * @tsplus static fncts.control.EvalOps sequenceT
+ * @tsplus static fncts.control.EvalOps all
  * @tsplus location "@fncts/base/control/Eval/api"
  */
-export declare function sequenceT<A extends Array<Eval<any>>>(...computations: A): Eval<{
+export declare function all<A extends ReadonlyArray<Eval<any>>>(...computations: A): Eval<{
+    [K in keyof A]: _A<A[K]>;
+}>;
+export declare function all<A extends Iterable<Eval<any>>>(computations: A): [A] extends [Iterable<infer A>] ? Eval<ReadonlyArray<_A<A>>> : never;
+export declare function all<A extends Record<string, Eval<any>>>(computations: A): Eval<{
     [K in keyof A]: _A<A[K]>;
 }>;
 declare class GenEval<A> {
@@ -56,4 +78,4 @@ declare class GenEval<A> {
 export declare function gen<T extends GenEval<any>, A>(f: (i: {
     <A>(_: Eval<A>): GenEval<A>;
 }) => Generator<T, A, any>): Eval<A>;
-export * from "./api/sequenceArray.js";
+export {};

package/control/Eval/constructors.d.ts

@@ -16,6 +16,11 @@ export declare function defer<A>(make: Lazy<Eval<A>>): Eval<A>;
  * @tsplus location "@fncts/base/control/Eval/constructors"
  */
 export declare function always<A>(make: Lazy<A>): Eval<A>;
+/**
+ * @tsplus static fncts.control.EvalOps unit
+ * @tsplus location "@fncts/base/control/Eval/constructors"
+ */
+export declare const unit: Eval<void>;
 /**
  * @tsplus static fncts.control.EvalOps later
  * @tsplus location "@fncts/base/control/Eval/constructors"

package/data/CaseClass.d.ts

@@ -1,4 +1,3 @@
-import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
 import { Hashable } from "@fncts/base/data/Hashable";
 import { Equatable } from "@fncts/base/data/Equatable";
 import type { Equals } from "@fncts/typelevel/Any";
@@ -6,13 +5,13 @@ import type { True } from "@fncts/typelevel/Boolean";
 export declare const CaseClassTypeId: unique symbol;
 export type CaseClassTypeId = typeof CaseClassTypeId;
 export interface CaseArgs {
-    readonly [CaseClassTypeId]: ImmutableArray<string>;
+    readonly [CaseClassTypeId]: ReadonlyArray<string>;
 }
 export interface Copy<T> {
     copy(args: Equals<T, {}> extends 1 ? void : Partial<T>): this;
 }
 export interface CaseConstructor {
-    [CaseClassTypeId]: ImmutableArray<string>;
+    [CaseClassTypeId]: ReadonlyArray<string>;
     new <T>(args: Equals<T, {}> extends True ? void : T): T & Copy<T> & CaseArgs;
 }
 export declare function isCaseClass(u: unknown): u is CaseConstructor;

package/data/Const/api.d.ts

@@ -1,12 +1,12 @@
 import { Const } from "./definition.js";
-/**
- * @tsplus pipeable fncts.Const map
- * @tsplus location "@fncts/base/data/Const/api"
- */
-export declare function map<A, B>(_f: (a: A) => B): <E>(self: Const<E, A>) => Const<E, B>;
 /**
  * @tsplus static fncts.ConstOps make
  * @tsplus static fncts.ConstOps __call
  * @tsplus location "@fncts/base/data/Const/api"
  */
 export declare function makeConst<E, A = never>(e: E): Const<E, A>;
+/**
+ * @tsplus pipeable fncts.Const map
+ * @tsplus location "@fncts/base/data/Const/api"
+ */
+export declare function map<A, B>(_f: (a: A) => B): <E>(self: Const<E, A>) => Const<E, B>;

package/data/Const/instances.d.ts

@@ -2,12 +2,12 @@ import { HKT } from "@fncts/typelevel/HKT";
 import type * as P from "../../typeclass.js";
 import type { ConstF } from "@fncts/base/data/Const/definition";
 /**
- * @tsplus static fncts.ConstOps getApply
+ * @tsplus static fncts.ConstOps getApplicative
  * @tsplus location "@fncts/base/data/Const/instances"
  */
-export declare function getApply<E>(S: P.Semigroup<E>): P.Apply<ConstF, import("@fncts/typelevel/HKT.js").HKT.Fix<"E", E>>;
+export declare function getApplicative<E>(M: P.Monoid<E>): P.Applicative<ConstF, HKT.Fix<"E", E>>;
 /**
- * @tsplus static fncts.ConstOps getApplicative
+ * @tsplus static fncts.ConstOps getApply
  * @tsplus location "@fncts/base/data/Const/instances"
  */
-export declare function getApplicative<E>(M: P.Monoid<E>): P.Applicative<ConstF, HKT.Fix<"E", E>>;
+export declare function getApply<E>(S: P.Semigroup<E>): P.Apply<ConstF, import("@fncts/typelevel/HKT.js").HKT.Fix<"E", E>>;