@fncts/base 0.0.3 → 0.0.6

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

@@ -1,18 +1,87 @@
 import type { ImmutableArrayF } from "@fncts/base/collection/immutable/ImmutableArray/definition";
-import * as P from "@fncts/base/typeclass";
-export declare const Align: P.Align<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-export declare const Functor: P.Functor<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-export declare const FunctorWithIndex: P.FunctorWithIndex<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-export declare const Apply: P.Apply<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-export declare const Applicative: P.Applicative<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-export declare const Alt: P.Alt<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-export declare const Alternative: P.Alternative<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-export declare const Filterable: P.Filterable<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-export declare const FilterableWithIndex: P.FilterableWithIndex<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-export declare const Foldable: P.Foldable<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-export declare const FoldableWithIndex: P.FoldableWithIndex<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-export declare const Monad: P.Monad<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-export declare const Traversable: P.Traversable<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-export declare const TraversableWithIndex: P.TraversableWithIndex<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-export declare const Witherable: P.Witherable<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
-export declare const WitherableWithIndex: P.WitherableWithIndex<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
+import type * as P from "@fncts/base/typeclass";
+/**
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
+ */
+export declare const Align: P.Align<ImmutableArrayF>;
+/**
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
+ */
+export declare const Functor: P.Functor<ImmutableArrayF>;
+/**
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
+ */
+export declare const FunctorWithIndex: P.FunctorWithIndex<ImmutableArrayF>;
+/**
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
+ */
+export declare const Apply: P.Apply<ImmutableArrayF>;
+/**
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
+ */
+export declare const Applicative: P.Applicative<ImmutableArrayF>;
+/**
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
+ */
+export declare const Alt: P.Alt<ImmutableArrayF>;
+/**
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
+ */
+export declare const Alternative: P.Alternative<ImmutableArrayF>;
+/**
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
+ */
+export declare const Filterable: P.Filterable<ImmutableArrayF>;
+/**
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
+ */
+export declare const FilterableWithIndex: P.FilterableWithIndex<ImmutableArrayF>;
+/**
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
+ */
+export declare const Foldable: P.Foldable<ImmutableArrayF>;
+/**
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
+ */
+export declare const FoldableWithIndex: P.FoldableWithIndex<ImmutableArrayF>;
+/**
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
+ */
+export declare const FlatMap: P.FlatMap<ImmutableArrayF>;
+/**
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
+ */
+export declare const Monad: P.Monad<ImmutableArrayF>;
+/**
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
+ */
+export declare const Traversable: P.Traversable<ImmutableArrayF>;
+/**
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
+ */
+export declare const TraversableWithIndex: P.TraversableWithIndex<ImmutableArrayF>;
+/**
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
+ */
+export declare const Witherable: P.Witherable<ImmutableArrayF>;
+/**
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
+ */
+export declare const WitherableWithIndex: P.WitherableWithIndex<ImmutableArrayF>;

package/collection/immutable/ImmutableArray.d.ts

@@ -2,3 +2,7 @@ export * from "./ImmutableArray/api.js";
 export * from "./ImmutableArray/constructors.js";
 export * from "./ImmutableArray/definition.js";
 export * from "./ImmutableArray/instances.js";
+export * from "./ImmutableArray/api/chunksOf.js";
+export * from "./ImmutableArray/api/slice.js";
+export * from "./ImmutableArray/api/splitAt.js";
+export * from "./ImmutableArray/api/splitWhere.js";

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

@@ -1,7 +1,7 @@
-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 { ImmutableNonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
 import * as P from "@fncts/base/typeclass";
 /**
  * @tsplus fluent fncts.ImmutableNonEmptyArray ap
@@ -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;
-/**
- * @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;
+export declare function foldMapWithIndex_<A, M>(self: ImmutableNonEmptyArray<A>, f: (i: number, a: A) => M, 
+/** @tsplus auto */ M: P.Monoid<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/constructors.d.ts

@@ -1,6 +1,7 @@
-import { ImmutableNonEmptyArray, NonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
 import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { NonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
+import { ImmutableNonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
 export declare function allocWithHead<A>(head: A, length: number): Array<A> & {
     0: A;
 };

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

@@ -1,10 +1,15 @@
 import { HKT } from "@fncts/typelevel/HKT";
+import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
+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 +24,13 @@ 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;
-}
+/**
+ * @tsplus getter fncts.ImmutableArray length
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition"
+ */
+export declare function length<A>(self: ImmutableArray<A>): number;
+/**
+ * @tsplus fluent fncts.ImmutableArray isNonEmpty
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition"
+ */
+export declare function isNonEmpty<A>(self: ImmutableArray<A>): self is ImmutableNonEmptyArray<A>;

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 { List } from "@fncts/base/collection/immutable/List/definition";
+import { RoseTree } from "./definition.js";
+/**
+ * @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,24 @@
+import { Hashable } from "@fncts/base/typeclass/Hashable";
+import { Equatable } from "@fncts/base/typeclass/Equatable";
+import { HKT } from "@fncts/typelevel/HKT";
+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/SortedMap/iterator.d.ts

@@ -1,5 +1,5 @@
 import { SortedMap } from "@fncts/base/collection/immutable/SortedMap/definition";
-import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Maybe, Nothing, Just } from "@fncts/base/data/Maybe/definition";
 import type { RBNode } from "@fncts/base/collection/immutable/SortedMap/node";
 import type { Ord } from "@fncts/base/typeclass";
 import { Node } from "@fncts/base/collection/immutable/SortedMap/node";

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,11 @@
+import { HKT } from "@fncts/typelevel/HKT";
+import { Hashable } from "@fncts/base/typeclass/Hashable";
+import { Equatable } from "@fncts/base/typeclass/Equatable";
 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 +25,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 +49,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/collection/mutable/HashMap.d.ts

@@ -1,4 +1,5 @@
-import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Maybe, Just, Nothing } from "@fncts/base/data/Maybe/definition";
+import { unsafeCoerce } from "@fncts/base/data/function/api";
 import { HashEq } from "@fncts/base/typeclass/HashEq";
 /**
  * @tsplus type fncts.MutableHashMap

package/collection/mutable/HashSet.d.ts

@@ -1,3 +1,4 @@
+import { unsafeCoerce } from "@fncts/base/data/function/api";
 import { HashEq } from "@fncts/base/typeclass/HashEq";
 /**
  * @tsplus type fncts.MutableHashSet

package/collection/mutable/ListBuffer.d.ts

@@ -1,4 +1,5 @@
 import { List, Cons } from "@fncts/base/collection/immutable/List/definition";
+import { NoSuchElementError, IndexOutOfBoundsError } from "@fncts/base/data/exceptions";
 export declare class ListBuffer<A> implements Iterable<A> {
     private first;
     private last0;

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"