@fncts/base 0.0.1 → 0.0.4

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

@@ -1,5 +1,5 @@
 import { ImmutableNonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
-import { These } from "@fncts/base/data/These/definition";
+import { These } from "@fncts/base/data/These";
 import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
 import type { ImmutableNonEmptyArrayF } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
 import * as P from "@fncts/base/typeclass";
@@ -54,28 +54,25 @@ export declare function concat_<A, B>(self: ImmutableNonEmptyArray<A>, that: Imm
  */
 export declare function crossWith_<A, B, C>(self: ImmutableNonEmptyArray<A>, fb: ImmutableNonEmptyArray<B>, f: (a: A, b: B) => C): ImmutableNonEmptyArray<C>;
 /**
- * @constrained
+ * @tsplus fluent fncts.ImmutableNonEmptyArray cross
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function elem_<A>(E: P.Eq<A>): (self: ImmutableNonEmptyArray<A>, a: A) => boolean;
+export declare function cross_<A, B>(self: ImmutableNonEmptyArray<A>, fb: ImmutableNonEmptyArray<B>): ImmutableNonEmptyArray<readonly [A, B]>;
 /**
- * @tsplus getter fncts.ImmutableNonEmptyArray elem
+ * @tsplus fluent fncts.ImmutableNonEmptyArray elem
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function elemSelf<A>(self: ImmutableNonEmptyArray<A>): (E: P.Eq<A>) => (a: A) => boolean;
+export declare function elem_<A>(self: ImmutableNonEmptyArray<A>, a: A, /** @tsplus auto */ E: P.Eq<A>): boolean;
 /**
  * @tsplus getter fncts.ImmutableNonEmptyArray flatten
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
 export declare function flatten<A>(self: ImmutableNonEmptyArray<ImmutableNonEmptyArray<A>>): ImmutableNonEmptyArray<A>;
-/**
- * @constrained
- */
-export declare function fold_<A>(S: P.Semigroup<A>): (self: ImmutableNonEmptyArray<A>) => A;
 /**
  * @tsplus fluent fncts.ImmutableNonEmptyArray fold
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function foldSelf<A>(self: ImmutableNonEmptyArray<A>, S: P.Semigroup<A>): A;
+export declare function fold_<A>(self: ImmutableNonEmptyArray<A>, /** @tsplus auto */ S: P.Semigroup<A>): A;
 /**
  * @tsplus fluent fncts.ImmutableNonEmptyArray foldLeft
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
@@ -87,23 +84,16 @@ export declare function foldLeft_<A, B>(self: ImmutableNonEmptyArray<A>, b: B, f
  */
 export declare function foldLeftWithIndex_<A, B>(self: ImmutableNonEmptyArray<A>, b: B, f: (i: number, b: B, a: A) => B): B;
 /**
- * @constrained
- */
-export declare function foldMapWithIndex_<M>(M: P.Monoid<M>): <A>(self: import("@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition").ImmutableNonEmptyArray<A>, f: (i: number, a: A) => M) => M;
-/**
- * @tsplus getter fncts.ImmutableNonEmptyArray foldMapWithIndex
+ * @tsplus fluent fncts.ImmutableNonEmptyArray foldMapWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function foldMapWithIndexSelf<A>(self: ImmutableNonEmptyArray<A>): <M>(M: P.Monoid<M>) => (f: (i: number, a: A) => M) => M;
+export declare function foldMapWithIndex_<A, M>(self: ImmutableNonEmptyArray<A>, f: (i: number, a: A) => M, 
+/** @tsplus auto */ M: P.Monoid<M>): M;
 /**
- * @constrained
- */
-export declare function foldMap_<M>(M: P.Monoid<M>): <A>(self: import("@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition").ImmutableNonEmptyArray<A>, f: (a: A) => M) => M;
-/**
- * @tsplus getter fncts.ImmutableNonEmptyArray foldMap
+ * @tsplus fluent fncts.ImmutableNonEmptyArray foldMap
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function foldMapSelf<A>(self: ImmutableNonEmptyArray<A>): <M>(M: P.Monoid<M>) => (f: (a: A) => M) => M;
+export declare function foldMap_<A, M>(self: ImmutableNonEmptyArray<A>, f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): M;
 /**
  * @tsplus fluent fncts.ImmutableNonEmptyArray foldRight
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
@@ -114,13 +104,14 @@ export declare function foldRight_<A, B>(self: ImmutableNonEmptyArray<A>, b: B,
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
 export declare function foldRightWithIndex_<A, B>(self: ImmutableNonEmptyArray<A>, b: B, f: (i: number, a: A, b: B) => B): B;
-export declare function group<A>(E: P.Eq<A>): (self: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<ImmutableNonEmptyArray<A>>;
 /**
- * @tsplus getter fncts.ImmutableNonEmptyArray group
+ * @tsplus fluent fncts.ImmutableNonEmptyArray group
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function groupSelf<A>(self: ImmutableNonEmptyArray<A>): (E: P.Eq<A>) => ImmutableNonEmptyArray<ImmutableNonEmptyArray<A>>;
-export declare function groupSort<A>(O: P.Ord<A>): (as: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<ImmutableNonEmptyArray<A>>;
+export declare function group<A>(self: ImmutableNonEmptyArray<A>, 
+/** @tsplus auto */ E: P.Eq<A>): ImmutableNonEmptyArray<ImmutableNonEmptyArray<A>>;
+export declare function groupSort<A>(as: ImmutableNonEmptyArray<A>, 
+/** @tsplus auto */ O: P.Ord<A>): ImmutableNonEmptyArray<ImmutableNonEmptyArray<A>>;
 /**
  * @tsplus fluent fncts.ImmutableNonEmptyArray isOutOfBound
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
@@ -136,18 +127,16 @@ export declare function map_<A, B>(self: ImmutableNonEmptyArray<A>, f: (a: A) =>
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
 export declare function mapWithIndex_<A, B>(self: ImmutableNonEmptyArray<A>, f: (i: number, a: A) => B): ImmutableNonEmptyArray<B>;
-export declare function max<A>(O: P.Ord<A>): (self: ImmutableNonEmptyArray<A>) => A;
 /**
  * @tsplus fluent fncts.ImmutableNonEmptyArray max
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function maxSelf<A>(self: ImmutableNonEmptyArray<A>, O: P.Ord<A>): A;
-export declare function min<A>(O: P.Ord<A>): (self: ImmutableNonEmptyArray<A>) => A;
+export declare function max<A>(self: ImmutableNonEmptyArray<A>, /** @tsplus auto */ O: P.Ord<A>): A;
 /**
  * @tsplus fluent fncts.ImmutableNonEmptyArray max
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function minSelf<A>(self: ImmutableNonEmptyArray<A>, O: P.Ord<A>): A;
+export declare function min<A>(self: ImmutableNonEmptyArray<A>, /** @tsplus auto */ O: P.Ord<A>): A;
 /**
  * @tsplus getter fncts.ImmutableNonEmptyArray mutableClone
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
@@ -163,41 +152,31 @@ export declare function prepend_<A, B>(self: ImmutableNonEmptyArray<A>, head: B)
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
 export declare function reverse<A>(self: ImmutableNonEmptyArray<A>): ImmutableNonEmptyArray<A>;
-export declare const sequence: P.sequence<ImmutableNonEmptyArrayF>;
-/**
- * @tsplus getter fncts.ImmutableNonEmptyArray sequence
- * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
- */
-export declare const sequenceSelf: P.sequenceSelf<ImmutableNonEmptyArrayF>;
 /**
  * @tsplus fluent fncts.ImmutableNonEmptyArray splitAt
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
 export declare function splitAt_<A>(self: ImmutableNonEmptyArray<A>, n: number): readonly [ImmutableNonEmptyArray<A>, ImmutableArray<A>];
-export declare function sort<B>(O: P.Ord<B>): <A extends B>(self: import("@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition").ImmutableNonEmptyArray<A>) => import("@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition").ImmutableNonEmptyArray<A>;
 /**
  * @tsplus fluent fncts.ImmutableNonEmptyArray sort
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function sortSelf<A extends B, B>(self: ImmutableNonEmptyArray<A>, O: P.Ord<B>): ImmutableNonEmptyArray<A>;
-export declare const traverseWithIndex_: P.traverseWithIndex_<ImmutableNonEmptyArrayF>;
+export declare function sort<A>(self: ImmutableNonEmptyArray<A>, /** @tsplus auto */ O: P.Ord<A>): ImmutableNonEmptyArray<A>;
 /**
- * @tsplus getter fncts.ImmutableNonEmptyArray traverseWithIndex
+ * @tsplus fluent fncts.ImmutableNonEmptyArray traverseWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare const traverseWithIndexSelf: P.traverseWithIndexSelf<ImmutableNonEmptyArrayF>;
-export declare const traverse_: P.traverse_<ImmutableNonEmptyArrayF>;
+export declare const traverseWithIndex_: P.TraversableWithIndex<ImmutableNonEmptyArrayF>["traverseWithIndex"];
 /**
- * @tsplus getter fncts.ImmutableNonEmptyArray traverse
+ * @tsplus fluent fncts.ImmutableNonEmptyArray traverse
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare const traverseSelf: P.traverseSelf<ImmutableNonEmptyArrayF>;
-export declare function uniq<A>(E: P.Eq<A>): (self: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<A>;
+export declare const traverse_: P.Traversable<ImmutableNonEmptyArrayF>["traverse"];
 /**
- * @tsplus getter fncts.ImmutableNonEmptyArray uniq
+ * @tsplus fluent fncts.ImmutableNonEmptyArray uniq
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function uniqSelf<A>(self: ImmutableNonEmptyArray<A>): (E: P.Eq<A>) => ImmutableNonEmptyArray<A>;
+export declare function uniq<A>(self: ImmutableNonEmptyArray<A>, /** @tsplus auto */ E: P.Eq<A>): ImmutableNonEmptyArray<A>;
 /**
  * @tsplus fluent fncts.ImmutableNonEmptyArray zipWith
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"

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

@@ -1,10 +1,13 @@
-import { HKT } from "@fncts/typelevel/HKT";
+export interface ImmutableNonEmptyArrayF extends ImmutableNonEmptyArray<any> {
+}
 /**
  * @tsplus type fncts.ImmutableNonEmptyArray
  * @tsplus companion fncts.ImmutableNonEmptyArrayOps
  */
 export declare class ImmutableNonEmptyArray<A> extends ImmutableArray<A> {
     readonly _array: ReadonlyNonEmptyArray<A>;
+    [HKT.F]: ImmutableNonEmptyArrayF;
+    [HKT.T]: ImmutableNonEmptyArray<HKT._A<this>>;
     constructor(_array: ReadonlyNonEmptyArray<A>);
 }
 /**
@@ -19,10 +22,3 @@ export interface NonEmptyArray<T> extends Array<T> {
 export interface ReadonlyNonEmptyArray<T> extends ReadonlyArray<T> {
     readonly 0: T;
 }
-export interface ImmutableNonEmptyArrayF extends HKT {
-    readonly type: ImmutableNonEmptyArray<this["A"]>;
-    readonly variance: {
-        readonly A: "+";
-    };
-    readonly index: number;
-}

package/collection/immutable/ImmutableNonEmptyArray/instances.d.ts

@@ -1,5 +1,5 @@
 import type { ImmutableNonEmptyArrayF } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
-import * as P from "@fncts/base/typeclass";
+import type * as P from "@fncts/base/typeclass";
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Semialign
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/instances"

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

@@ -67,12 +67,11 @@ export declare function prependAll_<A, B>(self: List<A>, prefix: List<B>): List<
  * @tsplus location "@fncts/base/collection/immutable/List/api"
  */
 export declare function reverse<A>(self: List<A>): List<A>;
-export declare function sort<A>(O: P.Ord<A>): (self: List<A>) => List<A>;
 /**
  * @tsplus fluent fncts.List sort
  * @tsplus location "@fncts/base/collection/immutable/List/api"
  */
-export declare function sortSelf<A>(self: List<A>, O: P.Ord<A>): List<A>;
+export declare function sort<A>(self: List<A>, /** @tsplus auto */ O: P.Ord<A>): List<A>;
 /**
  * @tsplus fluent fncts.List sortWith
  * @tsplus location "@fncts/base/collection/immutable/List/api"

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

@@ -0,0 +1,63 @@
+import { Vector } from "@fncts/base/collection/immutable/Vector";
+import { RoseTree } from "@fncts/base/collection/immutable/RoseTree";
+import { List } from "@fncts/base/collection/immutable/List/definition";
+/**
+ * @tsplus static fncts.RoseTreeOps __call
+ * @tsplus location "@fncts/base/collection/immutable/RoseTree/api"
+ */
+export declare function make<A>(value: A, forest?: Vector<RoseTree<A>>): RoseTree<A>;
+/**
+ * @tsplus fluent fncts.RoseTree foldLeft
+ * @tsplus location "@fncts/base/collection/immutable/RoseTree/api"
+ */
+export declare function foldLeft<A, B>(self: RoseTree<A>, b: B, f: (b: B, a: A) => B): B;
+/**
+ * @tsplus fluent fncts.RoseTree foldRight
+ * @tsplus location "@fncts/base/collection/immutable/RoseTree/api"
+ */
+export declare function foldRight<A, B>(self: RoseTree<A>, b: B, f: (a: A, b: B) => B): B;
+/**
+ * @tsplus fluent fncts.RoseTree map
+ * @tsplus location "@fncts/base/collection/immutable/RoseTree/api"
+ */
+export declare function map<A, B>(self: RoseTree<A>, f: (a: A) => B): RoseTree<B>;
+/**
+ * @tsplus fluent fncts.RoseTree mapAccum
+ * @tsplus location "@fncts/base/collection/immutable/RoseTree/api"
+ */
+export declare function mapAccum<A, S, B>(self: RoseTree<A>, s: S, f: (s: S, a: A) => readonly [S, B]): readonly [S, RoseTree<B>];
+/**
+ * @tsplus fluent fncts.RoseTree mapWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/RoseTree/api"
+ */
+export declare function mapWithIndex<A, B>(self: RoseTree<A>, f: (i: number, a: A) => B): RoseTree<B>;
+/**
+ * @tsplus static fncts.RoseTreeOps unfold
+ * @tsplus location "@fncts/base/collection/immutable/RoseTree/api"
+ */
+export declare function unfold<A, B>(b: B, f: (b: B) => readonly [A, Vector<B>]): RoseTree<A>;
+/**
+ * @tsplus fluent fncts.RoseTree zipWith
+ * @tsplus location "@fncts/base/collection/immutable/RoseTree/api"
+ */
+export declare function zipWith<A, B, C>(self: RoseTree<A>, that: RoseTree<B>, f: (a: A, b: B) => C): RoseTree<C>;
+/**
+ * @tsplus fluent fncts.RoseTree zipWithAccum
+ * @tsplus location "@fncts/base/collection/immutable/RoseTree/api"
+ */
+export declare function zipWithAccum<A, S, B, C>(self: RoseTree<A>, that: RoseTree<B>, s: S, f: (s: S, a: A, b: B) => readonly [S, C]): readonly [S, RoseTree<C>];
+export interface ZipWithAcc<A, B, C> {
+    readonly todoL: Vector<RoseTree<A>>;
+    readonly todoR: Vector<RoseTree<B>>;
+    readonly done: Vector<RoseTree<C>>;
+    readonly label: C;
+}
+/**
+ * @tsplus tailRec
+ */
+export declare function zipWithAccumLoop<S, A, B, C>(f: (s: S, a: A, b: B) => readonly [S, C], state: S, acc: ZipWithAcc<A, B, C>, stack: List<ZipWithAcc<A, B, C>>): readonly [S, RoseTree<C>];
+/**
+ * @tsplus getter fncts.RoseTree draw
+ * @tsplus location "@fncts/base/collection/immutable/RoseTree/api"
+ */
+export declare function draw(tree: RoseTree<string>): string;

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

@@ -0,0 +1,23 @@
+import { Hashable } from "@fncts/base/typeclass/Hashable";
+import { Equatable } from "@fncts/base/typeclass/Equatable";
+import { Vector } from "@fncts/base/collection/immutable/Vector";
+export declare const RoseTreeTypeId: unique symbol;
+export declare type RoseTreeTypeId = typeof RoseTreeTypeId;
+export interface RoseTreeF extends RoseTree<any> {
+}
+/**
+ * @tsplus type fncts.RoseTree
+ * @tsplus companion fncts.RoseTreeOps
+ */
+export declare class RoseTree<A> implements Hashable, Equatable {
+    readonly value: A;
+    readonly forest: Vector<RoseTree<A>>;
+    readonly _typeId: RoseTreeTypeId;
+    readonly [HKT.F]: RoseTreeF;
+    readonly [HKT.A]: () => A;
+    readonly [HKT.T]: RoseTree<HKT._A<this>>;
+    constructor(value: A, forest: Vector<RoseTree<A>>);
+    [Symbol.equals](that: unknown): boolean;
+    get [Symbol.hash](): number;
+}
+export declare function isRoseTree(u: unknown): u is RoseTree<unknown>;

package/collection/immutable/RoseTree.d.ts

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

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

@@ -80,7 +80,8 @@ export declare function insert_<K, V>(m: SortedMap<K, V>, key: K, value: V): Sor
  * Inserts an element into the correct position in the map, combining the values of keys of equal ordering
  * with a `Semigroup` instance
  */
-export declare function insertWith_<V>(S: Semigroup<V>): <K>(m: SortedMap<K, V>, key: K, value: V) => SortedMap<K, V>;
+export declare function insertWith_<K, V>(m: SortedMap<K, V>, key: K, value: V, 
+/** @tsplus auto */ S: Semigroup<V>): SortedMap<K, V>;
 /**
  * @tsplus getter fncts.SortedMap isEmpty
  * @tsplus location "@fncts/base/collection/immutable/SortedMap/api"

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

@@ -3,12 +3,13 @@ import { Predicate } from "@fncts/base/data/Predicate/definition";
 import { Refinement } from "@fncts/base/data/Refinement/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { List } from "@fncts/base/collection/immutable/List/definition";
-import type { MutableVector } from "@fncts/base/collection/immutable/Vector/definition";
-import type { Eq, Monoid, Ord, Ordering } from "@fncts/base/typeclass";
+import type { MutableVector, VectorF } from "@fncts/base/collection/immutable/Vector/definition";
+import type { Eq, Monoid, Ord, Ordering, Traversable, TraversableWithIndex } from "@fncts/base/typeclass";
 /**
  * Appends an element to the end of a Vector and returns the new Vector.
  * @complexity O(n)
  * @tsplus fluent fncts.Vector append
+ * @tsplus operator fncts.Vector +
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
 export declare function append_<A>(as: Vector<A>, a: A): Vector<A>;
@@ -29,6 +30,7 @@ export declare function chunksOf_<A>(as: Vector<A>, size: number): Vector<Vector
  * Concatenates two Vectors.
  * @complexity O(log(n))
  * @tsplus fluent fncts.Vector concat
+ * @tsplus operator fncts.Vector + 1
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
 export declare function concat_<A, B>(self: Vector<A>, that: Vector<B>): Vector<A | B>;
@@ -190,15 +192,16 @@ export declare function foldLeftWhile_<A, B>(fa: Vector<A>, b: B, cont: Predicat
  */
 export declare function foldRightWhile_<A, B>(fa: Vector<A>, b: B, cont: Predicate<B>, f: (i: number, a: A, b: B) => B): B;
 /**
- * @tsplus getter fncts.Vector foldMap
+ * @tsplus fluent fncts.Vector foldMap
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function foldMap_<A>(self: Vector<A>): <M>(M: Monoid<M>) => (f: (a: A) => M) => M;
+export declare function foldMap_<A, M>(self: Vector<A>, f: (a: A) => M, /** @tsplus auto */ M: Monoid<M>): M;
 /**
- * @tsplus getter fncts.Vector foldMapWithIndex
+ * @tsplus fluent fncts.Vector foldMapWithIndex
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function foldMapWithIndex_<A>(self: Vector<A>): <M>(M: Monoid<M>) => (f: (i: number, a: A) => M) => M;
+export declare function foldMapWithIndex_<A, M>(self: Vector<A>, f: (i: number, a: A) => M, 
+/** @tsplus auto */ M: Monoid<M>): M;
 /**
  * Folds a function over a Vector. Right-associative.
  * @complexity O(n)
@@ -391,6 +394,11 @@ export declare function pop<A>(as: Vector<A>): Vector<A>;
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
 export declare function prepend_<A>(as: Vector<A>, a: A): Vector<A>;
+/**
+ * @tsplus operator fncts.Vector +
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function prependOperator<A>(a: A, as: Vector<A>): Vector<A>;
 /**
  * Returns a Vector of numbers between an inclusive lower bound and an exclusive upper bound.
  * @complexity O(n)
@@ -415,6 +423,11 @@ export declare function remove_<A>(as: Vector<A>, from: number, amount: number):
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
 export declare function replicate<A>(n: number, a: A): Vector<A>;
+/**
+ * @tsplus getter fncts.Vector reverse
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare function reverse<A>(self: Vector<A>): Vector<A>;
 /**
  * Folds a function over a Vector from left to right while collecting
  * all the intermediate steps in a resulting Vector.
@@ -439,10 +452,10 @@ export declare function single<A>(a: A): Vector<A>;
  */
 export declare function slice_<A>(as: Vector<A>, from: number, to: number): Vector<A>;
 /**
- * @tsplus getter fncts.Vector sort
+ * @tsplus fluent fncts.Vector sort
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare function sort_<A>(self: Vector<A>): (O: Ord<A>) => Vector<A>;
+export declare function sort_<A>(self: Vector<A>, /** @tsplus auto */ O: Ord<A>): Vector<A>;
 /**
  * Sort the given Vector by comparing values using the given function.
  * The function receieves two values and should return `-1` if the
@@ -527,6 +540,16 @@ export declare function toArray<A>(self: Vector<A>): ReadonlyArray<A>;
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
 export declare function toList<A>(self: Vector<A>): List<A>;
+/**
+ * @tsplus fluent fncts.Vector traverseWithIndex
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare const traverseWithIndex: TraversableWithIndex<VectorF>["traverseWithIndex"];
+/**
+ * @tsplus fluent fncts.Vector traverse
+ * @tsplus location "@fncts/base/collection/immutable/Vector/api"
+ */
+export declare const traverse: Traversable<VectorF>["traverse"];
 /**
  * Returns a new Vector without repeated elements by using the given
  * Eq instance to determine when elements are equal

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

@@ -1,6 +1,8 @@
 import type { Node } from "@fncts/base/collection/immutable/Vector/internal";
 export declare const VectorTypeId: unique symbol;
 export declare type VectorTypeId = typeof VectorTypeId;
+export interface VectorF extends Vector<any> {
+}
 /**
  * Represents a Vector of elements.
  *
@@ -20,6 +22,10 @@ export declare class Vector<A> implements Iterable<A> {
     /** @private */
     readonly suffix: A[];
     readonly _typeId: VectorTypeId;
+    readonly [HKT.F]: VectorF;
+    readonly [HKT.A]: () => A;
+    readonly [HKT.T]: Vector<HKT._A<this>>;
+    readonly [HKT.Ix]: number;
     constructor(
     /** @private */
     bits: number, 
@@ -40,6 +46,10 @@ export declare class Vector<A> implements Iterable<A> {
  */
 export interface MutableVector<A> {
     readonly _typeId: VectorTypeId;
+    readonly [HKT.F]: VectorF;
+    readonly [HKT.A]: () => A;
+    readonly [HKT.T]: Vector<HKT._A<this>>;
+    readonly [HKT.Ix]: number;
     bits: number;
     offset: number;
     length: number;

package/control/Eval/api.d.ts

@@ -25,6 +25,7 @@ export declare function map_<A, B>(self: Eval<A>, f: (a: A) => B): Eval<B>;
  * @tsplus location "@fncts/base/control/Eval/api"
  */
 export declare function zipWith_<A, B, C>(self: Eval<A>, fb: Eval<B>, f: (a: A, b: B) => C): Eval<C>;
+export declare function zip_<A, B>(self: Eval<A>, fb: Eval<B>): Eval<readonly [A, B]>;
 /**
  * @tsplus fluent fncts.control.Eval ap
  * @tsplus location "@fncts/base/control/Eval/api"

package/control/Eval/definition.d.ts

@@ -1,12 +1,15 @@
-import { HKT } from "@fncts/typelevel/HKT";
 export declare const EvalTypeId: unique symbol;
 export declare type EvalTypeId = typeof EvalTypeId;
+export interface EvalF extends Eval<any> {
+}
 /**
  * @tsplus type fncts.control.Eval
  */
 export interface Eval<A> {
     readonly _typeId: EvalTypeId;
-    readonly _A: () => A;
+    [HKT.F]?: EvalF;
+    [HKT.A]?: () => A;
+    [HKT.T]?: Eval<HKT._A<this>>;
 }
 /**
  * @tsplus type fncts.control.EvalOps
@@ -50,10 +53,4 @@ export declare function concrete(_: Eval<any>): asserts _ is Concrete;
  * @tsplus unify fncts.control.Eval
  */
 export declare function unifyEval<X extends Eval<any>>(self: X): Eval<[X] extends [Eval<infer A>] ? A : never>;
-export interface EvalF extends HKT {
-    readonly type: Eval<this["A"]>;
-    readonly variance: {
-        readonly A: "-";
-    };
-}
 export {};

package/control/Eval/instance.d.ts

@@ -1,17 +1,20 @@
 import type { EvalF } from "@fncts/base/control/Eval/definition";
-import * as P from "@fncts/base/typeclass";
+import type * as P from "@fncts/base/typeclass";
 /**
  * @tsplus static fncts.control.EvalOps Functor
+ * @tsplus implicit
  * @tsplus location "@fncts/base/control/Eval/instance"
  */
 export declare const Functor: P.Functor<EvalF>;
 /**
  * @tsplus static fncts.control.EvalOps Apply
+ * @tsplus implicit
  * @tsplus location "@fncts/base/control/Eval/instance"
  */
 export declare const Apply: P.Apply<EvalF>;
 /**
  * @tsplus static fncts.control.EvalOps Applicative
+ * @tsplus implicit
  * @tsplus location "@fncts/base/control/Eval/instance"
  */
 export declare const Applicative: P.Applicative<EvalF>;

package/control/Z/definition.d.ts

@@ -1,16 +1,8 @@
-import { HKT } from "@fncts/typelevel/HKT";
 import { Cause } from "@fncts/base/data/Cause/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
-import type { _A, _E, _R, _S1, _S2, _W } from "../../types.js";
-export interface ZF extends HKT {
-    readonly type: Z<this["W"], this["S"], this["S"], this["R"], this["E"], this["A"]>;
-    readonly variance: {
-        readonly W: "_";
-        readonly S: "_";
-        readonly R: "-";
-        readonly E: "+";
-        readonly A: "+";
-    };
+export interface ZF extends Z<any, any, any, any, any, any> {
+}
+export interface ZFixedF extends ZFixed<any, any, any, any, any> {
 }
 export declare const ZTypeId: unique symbol;
 export declare type ZTypeId = typeof ZTypeId;
@@ -29,17 +21,30 @@ export declare type ZTypeId = typeof ZTypeId;
  */
 export declare abstract class Z<W, S1, S2, R, E, A> {
     readonly _typeId: ZTypeId;
-    readonly _W: () => W;
-    readonly _S1: (_: S1) => void;
-    readonly _S2: () => S2;
-    readonly _R: (_: R) => void;
-    readonly _E: () => E;
-    readonly _A: () => A;
+    readonly [HKT.F]: ZF;
+    readonly [HKT.W]: () => W;
+    readonly [HKT.Q]: (_: S1) => void;
+    readonly [HKT.S]: () => S2;
+    readonly [HKT.R]: (_: R) => void;
+    readonly [HKT.E]: () => E;
+    readonly [HKT.A]: () => A;
+    readonly [HKT.T]: Z<HKT._W<this>, HKT._Q<this>, HKT._S<this>, HKT._R<this>, HKT._E<this>, HKT._A<this>>;
+}
+export interface ZFixed<W, S, R, E, A> {
+    readonly _typeId: ZTypeId;
+    readonly [HKT.F]: ZF;
+    readonly [HKT.W]: () => W;
+    readonly [HKT.Q]: (_: S) => void;
+    readonly [HKT.S]: () => S;
+    readonly [HKT.R]: (_: R) => void;
+    readonly [HKT.E]: () => E;
+    readonly [HKT.A]: () => A;
+    readonly [HKT.T]: Z<HKT._W<this>, HKT._S<this>, HKT._S<this>, HKT._R<this>, HKT._E<this>, HKT._A<this>>;
 }
 /**
  * @tsplus unify fncts.control.Z
  */
-export declare function unifyZ<X extends Z<any, any, any, any, any, any>>(_: X): Z<_W<X>, _S1<X>, _S2<X>, _R<X>, _E<X>, _A<X>>;
+export declare function unifyZ<X extends Z<any, any, any, any, any, any>>(_: X): Z<HKT._W<X>, HKT._Q<X>, HKT._S<X>, HKT._R<X>, HKT._E<X>, HKT._A<X>>;
 /**
  * @tsplus static fncts.control.ZOps isZ
  * @tsplus location "@fncts/base/control/Z/definition"

package/control/Z/instances.d.ts

@@ -1,7 +1,8 @@
-import type { ZF } from "./definition.js";
-import * as P from "../../typeclass.js";
+import type * as P from "../../typeclass.js";
+import type { ZFixedF } from "./definition.js";
 /**
  * @tsplus static fncts.control.ZOps Applicative
+ * @tsplus implicit
  * @tsplus location "@fncts/base/control/Z/instances"
  */
-export declare const Applicative: P.Applicative<ZF>;
+export declare const Applicative: P.Applicative<ZFixedF>;

package/data/Branded/definition.d.ts

@@ -0,0 +1,36 @@
+import { Refinement } from "@fncts/base/data/Refinement/definition";
+import { Predicate } from "@fncts/base/data/Predicate/definition";
+import type { Union } from "@fncts/typelevel";
+declare type Brand_<A, K extends string> = Brand<A, K>;
+export declare namespace Branded {
+    const Symbol: unique symbol;
+    type Symbol = typeof Symbol;
+    interface Brand<A, K extends string> {
+        readonly [Branded.Symbol]: {
+            [_ in K]: A;
+        };
+    }
+    type Type<A extends Brand_<any, any>> = [A] extends [Brand_<infer A, infer K>] ? Validated<A, K> : never;
+    type Validated<A, K extends string> = A & Brand<A, K>;
+    type IsValidated<P extends Brand<any, any>> = {
+        [K in keyof P[Branded.Symbol]]: P extends P[Branded.Symbol][K] ? 0 : 1;
+    }[keyof P[Branded.Symbol]] extends 0 ? unknown : never;
+    type Unbrand<P extends Brand<any, any>> = P extends infer Q & Brands<P> ? Q : P;
+    type Brands<P extends Brand<any, any>> = Union.IntersectionOf<{
+        [K in keyof P[Branded.Symbol]]: P extends P[Branded.Symbol][K] ? K extends string ? Brand<P[Branded.Symbol][K], K> : never : never;
+    }[keyof P[Branded.Symbol]]>;
+}
+/**
+ * @tsplus type fncts.Brand
+ * @tsplus companion fncts.BrandOps
+ */
+export declare class Brand<A, K extends string> {
+    readonly validate: Refinement<A, A & Branded.Brand<A, K>>;
+    constructor(validate: Refinement<A, A & Branded.Brand<A, K>>);
+}
+/**
+ * @tsplus static fncts.BrandOps __call
+ * @tsplus location "@fncts/base/data/Branded/definition"
+ */
+export declare function makeBrand<A, K extends string>(p: Predicate<A>): Brand<A, K>;
+export {};

package/data/Branded/derivations.d.ts

@@ -0,0 +1,24 @@
+import { Guard } from "@fncts/base/typeclass/Guard";
+import type { Brand, Branded } from "@fncts/base/data/Branded/definition";
+import type { Check } from "@fncts/typelevel/Check";
+import { Decoder } from "@fncts/base/data/Decoder/definition";
+/**
+ * @tsplus derive fncts.Guard<_> 10
+ * @tsplus location "@fncts/base/data/Branded/derivations"
+ */
+export declare function deriveGuard<A extends Branded.Brand<any, any>>(...[base, brands]: Check<Branded.IsValidated<A>> extends Check.True ? [
+    base: Guard<Branded.Unbrand<A>>,
+    brands: {
+        [K in keyof A[Branded.Symbol] & string]: Brand<A[Branded.Symbol][K], K>;
+    }
+] : never): Guard<A>;
+/**
+ * @tsplus derive fncts.Decoder<_> 10
+ * @tsplus location "@fncts/base/data/Branded/derivations"
+ */
+export declare function deriveDecoder<A extends Branded.Brand<any, any>>(...[base, brands]: Check<Branded.IsValidated<A>> extends Check.True ? [
+    base: Decoder<Branded.Unbrand<A>>,
+    brands: {
+        [K in keyof A[Branded.Symbol] & string]: Brand<A[Branded.Symbol][K], K>;
+    }
+] : never): Decoder<A>;