@fncts/base 0.0.12 → 0.0.13

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

@@ -4,84 +4,84 @@ 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>;
+export declare const Align: P.Align<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus implicit
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
  */
-export declare const Functor: P.Functor<ImmutableArrayF>;
+export declare const Functor: P.Functor<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus implicit
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
  */
-export declare const FunctorWithIndex: P.FunctorWithIndex<ImmutableArrayF>;
+export declare const FunctorWithIndex: P.FunctorWithIndex<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus implicit
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
  */
-export declare const Apply: P.Apply<ImmutableArrayF>;
+export declare const Apply: P.Apply<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus implicit
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
  */
-export declare const Applicative: P.Applicative<ImmutableArrayF>;
+export declare const Applicative: P.Applicative<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus implicit
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
  */
-export declare const Alt: P.Alt<ImmutableArrayF>;
+export declare const Alt: P.Alt<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus implicit
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
  */
-export declare const Alternative: P.Alternative<ImmutableArrayF>;
+export declare const Alternative: P.Alternative<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus implicit
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
  */
-export declare const Filterable: P.Filterable<ImmutableArrayF>;
+export declare const Filterable: P.Filterable<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus implicit
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
  */
-export declare const FilterableWithIndex: P.FilterableWithIndex<ImmutableArrayF>;
+export declare const FilterableWithIndex: P.FilterableWithIndex<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus implicit
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
  */
-export declare const Foldable: P.Foldable<ImmutableArrayF>;
+export declare const Foldable: P.Foldable<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus implicit
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
  */
-export declare const FoldableWithIndex: P.FoldableWithIndex<ImmutableArrayF>;
+export declare const FoldableWithIndex: P.FoldableWithIndex<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus implicit
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
  */
-export declare const FlatMap: P.FlatMap<ImmutableArrayF>;
+export declare const FlatMap: P.FlatMap<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus implicit
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
  */
-export declare const Monad: P.Monad<ImmutableArrayF>;
+export declare const Monad: P.Monad<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus implicit
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
  */
-export declare const Traversable: P.Traversable<ImmutableArrayF>;
+export declare const Traversable: P.Traversable<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus implicit
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
  */
-export declare const TraversableWithIndex: P.TraversableWithIndex<ImmutableArrayF>;
+export declare const TraversableWithIndex: P.TraversableWithIndex<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus implicit
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
  */
-export declare const Witherable: P.Witherable<ImmutableArrayF>;
+export declare const Witherable: P.Witherable<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus implicit
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/instances"
  */
-export declare const WitherableWithIndex: P.WitherableWithIndex<ImmutableArrayF>;
+export declare const WitherableWithIndex: P.WitherableWithIndex<ImmutableArrayF, import("@fncts/typelevel/HKT").HKT.None>;

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

@@ -1,5 +1,6 @@
 import { These } from "@fncts/base/data/These";
 import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
+import { Zipped } from "@fncts/base/data/Zipped";
 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";
@@ -57,7 +58,7 @@ export declare function crossWith_<A, B, C>(self: ImmutableNonEmptyArray<A>, fb:
  * @tsplus fluent fncts.ImmutableNonEmptyArray cross
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function cross_<A, B>(self: ImmutableNonEmptyArray<A>, fb: ImmutableNonEmptyArray<B>): ImmutableNonEmptyArray<readonly [A, B]>;
+export declare function cross_<A, B>(self: ImmutableNonEmptyArray<A>, fb: ImmutableNonEmptyArray<B>): ImmutableNonEmptyArray<Zipped.Make<A, B>>;
 /**
  * @tsplus fluent fncts.ImmutableNonEmptyArray elem
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
@@ -163,15 +164,15 @@ export declare function splitAt_<A>(self: ImmutableNonEmptyArray<A>, n: number):
  */
 export declare function sort<A>(self: ImmutableNonEmptyArray<A>, /** @tsplus auto */ O: P.Ord<A>): ImmutableNonEmptyArray<A>;
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray traverseWithIndex
+ * @tsplus getter fncts.ImmutableNonEmptyArray traverseWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare const traverseWithIndex_: P.TraversableWithIndex<ImmutableNonEmptyArrayF>["traverseWithIndex"];
+export declare const traverseWithIndex: <KF, QF, WF, XF, IF, SF, RF, EF, A>(ta: ImmutableNonEmptyArray<A>) => <G extends import("@fncts/typelevel/HKT").HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <KG, QG, WG, XG, IG, SG, RG, EG, B>(f: (i: number, a: A) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, B>) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, ImmutableNonEmptyArray<B>>;
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray traverse
+ * @tsplus getter fncts.ImmutableNonEmptyArray traverse
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare const traverse_: P.Traversable<ImmutableNonEmptyArrayF>["traverse"];
+export declare const traverse: P.Traversable<ImmutableNonEmptyArrayF>["traverse"];
 /**
  * @tsplus fluent fncts.ImmutableNonEmptyArray uniq
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"

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

@@ -1,6 +1,11 @@
 import { HKT } from "@fncts/typelevel/HKT";
 import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
-export interface ImmutableNonEmptyArrayF extends ImmutableNonEmptyArray<any> {
+export interface ImmutableNonEmptyArrayF extends HKT {
+    type: ImmutableNonEmptyArray<this["A"]>;
+    variance: {
+        A: "+";
+    };
+    index: number;
 }
 /**
  * @tsplus type fncts.ImmutableNonEmptyArray
@@ -8,8 +13,7 @@ export interface ImmutableNonEmptyArrayF extends ImmutableNonEmptyArray<any> {
  */
 export declare class ImmutableNonEmptyArray<A> extends ImmutableArray<A> {
     readonly _array: ReadonlyNonEmptyArray<A>;
-    [HKT.F]: ImmutableNonEmptyArrayF;
-    [HKT.T]: ImmutableNonEmptyArray<HKT._A<this>>;
+    readonly _A: () => A;
     constructor(_array: ReadonlyNonEmptyArray<A>);
 }
 /**

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

@@ -4,49 +4,49 @@ import type * as P from "@fncts/base/typeclass";
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Semialign
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/instances"
  */
-export declare const Semialign: P.Semialign<ImmutableNonEmptyArrayF>;
+export declare const Semialign: P.Semialign<ImmutableNonEmptyArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Functor
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/instances"
  */
-export declare const Functor: P.Functor<ImmutableNonEmptyArrayF>;
+export declare const Functor: P.Functor<ImmutableNonEmptyArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps FunctorWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/instances"
  */
-export declare const FunctorWithIndex: P.FunctorWithIndex<ImmutableNonEmptyArrayF>;
+export declare const FunctorWithIndex: P.FunctorWithIndex<ImmutableNonEmptyArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Apply
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/instances"
  */
-export declare const Apply: P.Apply<ImmutableNonEmptyArrayF>;
+export declare const Apply: P.Apply<ImmutableNonEmptyArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Applicative
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/instances"
  */
-export declare const Applicative: P.Applicative<ImmutableNonEmptyArrayF>;
+export declare const Applicative: P.Applicative<ImmutableNonEmptyArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Monad
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/instances"
  */
-export declare const Monad: P.Monad<ImmutableNonEmptyArrayF>;
+export declare const Monad: P.Monad<ImmutableNonEmptyArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Foldable
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/instances"
  */
-export declare const Foldable: P.Foldable<ImmutableNonEmptyArrayF>;
+export declare const Foldable: P.Foldable<ImmutableNonEmptyArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps FoldableWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/instances"
  */
-export declare const FoldableWithIndex: P.FoldableWithIndex<ImmutableNonEmptyArrayF>;
+export declare const FoldableWithIndex: P.FoldableWithIndex<ImmutableNonEmptyArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps Traversable
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/instances"
  */
-export declare const Traversable: P.Traversable<ImmutableNonEmptyArrayF>;
+export declare const Traversable: P.Traversable<ImmutableNonEmptyArrayF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus static fncts.ImmutableNonEmptyArrayOps TraversableWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/instances"
  */
-export declare const TraversableWithIndex: P.TraversableWithIndex<ImmutableNonEmptyArrayF>;
+export declare const TraversableWithIndex: P.TraversableWithIndex<ImmutableNonEmptyArrayF, import("@fncts/typelevel/HKT").HKT.None>;

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

@@ -1,10 +1,14 @@
+import { HKT } from "@fncts/typelevel/HKT";
 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> {
+export interface RoseTreeF extends HKT {
+    type: RoseTree<this["A"]>;
+    variance: {
+        A: "+";
+    };
 }
 /**
  * @tsplus type fncts.RoseTree
@@ -14,9 +18,7 @@ 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>>;
+    _A: () => A;
     constructor(value: A, forest: Vector<RoseTree<A>>);
     [Symbol.equals](that: unknown): boolean;
     get [Symbol.hash](): number;

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

@@ -4,7 +4,7 @@ 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, VectorF } from "@fncts/base/collection/immutable/Vector/definition";
-import type { Eq, Monoid, Ord, Ordering, Traversable, TraversableWithIndex } from "@fncts/base/typeclass";
+import type { Eq, Monoid, Ord, Ordering, Traversable } from "@fncts/base/typeclass";
 /**
  * Appends an element to the end of a Vector and returns the new Vector.
  * @complexity O(n)
@@ -541,12 +541,12 @@ export declare function toArray<A>(self: Vector<A>): ReadonlyArray<A>;
  */
 export declare function toList<A>(self: Vector<A>): List<A>;
 /**
- * @tsplus fluent fncts.Vector traverseWithIndex
+ * @tsplus getter fncts.Vector traverseWithIndex
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
-export declare const traverseWithIndex: TraversableWithIndex<VectorF>["traverseWithIndex"];
+export declare const traverseWithIndex: <KF, QF, WF, XF, IF, SF, RF, EF, A>(ta: import("@fncts/base/collection/immutable/Vector/definition").Vector<A>) => <G extends import("@fncts/typelevel/HKT").HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: import("@fncts/base/typeclass").Applicative<G, GC>) => <KG, QG, WG, XG, IG, SG, RG, EG, B>(f: (i: number, a: A) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, B>) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, import("@fncts/base/collection/immutable/Vector/definition").Vector<B>>;
 /**
- * @tsplus fluent fncts.Vector traverse
+ * @tsplus getter fncts.Vector traverse
  * @tsplus location "@fncts/base/collection/immutable/Vector/api"
  */
 export declare const traverse: Traversable<VectorF>["traverse"];

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

@@ -4,7 +4,12 @@ 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> {
+export interface VectorF extends HKT {
+    type: Vector<this["A"]>;
+    variance: {
+        A: "+";
+    };
+    index: number;
 }
 /**
  * Represents a Vector of elements.
@@ -25,10 +30,7 @@ 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;
+    readonly _A: () => A;
     constructor(
     /** @private */
     bits: number, 
@@ -49,10 +51,7 @@ 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;
+    readonly _A: () => A;
     bits: number;
     offset: number;
     length: number;

package/collection/weak/IterableWeakMap.d.ts

@@ -1,7 +1,7 @@
 /**
  * @tsplus type fncts.IterableWeakMap
  */
-export declare class IterableWeakMap<K extends object, V> implements Iterable<readonly [K, V]> {
+export declare class IterableWeakMap<K extends object, V> implements Iterable<readonly [K, V]>, Map<K, V> {
     private weakMap;
     private refSet;
     private finalizationGroup;
@@ -10,7 +10,13 @@ export declare class IterableWeakMap<K extends object, V> implements Iterable<re
     set(this: this, key: K, value: V): this;
     get(this: this, key: K): V | undefined;
     delete(this: this, key: K): boolean;
-    [Symbol.iterator](this: this): IterableIterator<readonly [K, V]>;
-    entries(this: this): IterableIterator<readonly [K, V]>;
     has(this: this, key: K): boolean;
+    clear(): void;
+    forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: IterableWeakMap<K, V>): void;
+    get size(): number;
+    [Symbol.iterator](this: this): IterableIterator<[K, V]>;
+    get [Symbol.toStringTag](): string;
+    entries(this: this): IterableIterator<[K, V]>;
+    keys(this: this): IterableIterator<K>;
+    values(): IterableIterator<V>;
 }

package/collection/weak/IterableWeakSet.d.ts

@@ -1,15 +1,21 @@
 /**
  * @tsplus type fncts.IterableWeakSet
  */
-export declare class IterableWeakSet<A extends object> implements Iterable<A> {
+export declare class IterableWeakSet<A extends object> implements Iterable<A>, Set<A> {
     private weakMap;
     private refSet;
     private finalizationGroup;
     private static cleanup;
-    constructor(iterable: Iterable<A>);
+    constructor(iterable?: Iterable<A>);
     add(this: this, value: A): this;
     delete(this: this, value: A): boolean;
-    [Symbol.iterator](this: this): IterableIterator<A>;
-    entries(this: this): IterableIterator<A>;
     has(this: this, value: A): boolean;
+    keys(): IterableIterator<A>;
+    values(): IterableIterator<A>;
+    forEach(f: (value: A, value2: A, set: Set<A>) => void, thisArg?: Set<A>): void;
+    clear(): void;
+    get size(): number;
+    [Symbol.iterator](this: this): IterableIterator<A>;
+    get [Symbol.toStringTag](): string;
+    entries(this: this): IterableIterator<[A, A]>;
 }

package/control/Eval/api.d.ts

@@ -1,4 +1,5 @@
 import { Eval } from "@fncts/base/control/Eval/definition";
+import { Zipped } from "@fncts/base/data/Zipped";
 import type { _A } from "@fncts/base/types";
 /**
  * @tsplus fluent fncts.control.Eval and
@@ -25,7 +26,11 @@ 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 zip
+ * @tsplus location "@fncts/base/control/Eval/api"
+ */
+export declare function zip_<A, B>(self: Eval<A>, fb: Eval<B>): Eval<Zipped.Make<A, B>>;
 /**
  * @tsplus fluent fncts.control.Eval ap
  * @tsplus location "@fncts/base/control/Eval/api"

package/control/Eval/definition.d.ts

@@ -1,16 +1,18 @@
 import { HKT } from "@fncts/typelevel/HKT";
 export declare const EvalTypeId: unique symbol;
 export declare type EvalTypeId = typeof EvalTypeId;
-export interface EvalF extends Eval<any> {
+export interface EvalF extends HKT {
+    type: Eval<this["A"]>;
+    variance: {
+        A: "+";
+    };
 }
 /**
  * @tsplus type fncts.control.Eval
  */
 export interface Eval<A> {
     readonly _typeId: EvalTypeId;
-    [HKT.F]?: EvalF;
-    [HKT.A]?: () => A;
-    [HKT.T]?: Eval<HKT._A<this>>;
+    readonly _A: () => A;
 }
 /**
  * @tsplus type fncts.control.EvalOps

package/control/Eval/instance.d.ts

@@ -5,16 +5,16 @@ import type * as P from "@fncts/base/typeclass";
  * @tsplus implicit
  * @tsplus location "@fncts/base/control/Eval/instance"
  */
-export declare const Functor: P.Functor<EvalF>;
+export declare const Functor: P.Functor<EvalF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus static fncts.control.EvalOps Apply
  * @tsplus implicit
  * @tsplus location "@fncts/base/control/Eval/instance"
  */
-export declare const Apply: P.Apply<EvalF>;
+export declare const Apply: P.Apply<EvalF, import("@fncts/typelevel/HKT").HKT.None>;
 /**
  * @tsplus static fncts.control.EvalOps Applicative
  * @tsplus implicit
  * @tsplus location "@fncts/base/control/Eval/instance"
  */
-export declare const Applicative: P.Applicative<EvalF>;
+export declare const Applicative: P.Applicative<EvalF, import("@fncts/typelevel/HKT").HKT.None>;

package/control/Z/api.d.ts

@@ -1,10 +1,12 @@
 import { Z } from "@fncts/base/control/Z/definition";
 import { Either } from "@fncts/base/data/Either/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Environment } from "@fncts/base/data/Environment/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
 import { Cause } from "@fncts/base/data/Cause/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
+import { Zipped } from "@fncts/base/data/Zipped";
 /**
  * @tsplus getter fncts.control.Z absolve
  * @tsplus location "@fncts/base/control/Z/api"
@@ -50,7 +52,7 @@ export declare function flatMap_<W, S1, S2, R, E, A, W1, S3, R1, E1, B>(ma: Z<W,
  * @tsplus fluent fncts.control.Z contramapEnvironment
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function contramapEnvironment_<R0, W, S1, S2, R, E, A>(ma: Z<W, S1, S2, R, E, A>, f: (r0: R0) => R): Z<W, S1, S2, R0, E, A>;
+export declare function contramapEnvironment_<R0, W, S1, S2, R, E, A>(ma: Z<W, S1, S2, R, E, A>, f: (r0: Environment<R0>) => Environment<R>): Z<W, S1, S2, R0, E, A>;
 /**
  * Transforms the initial state of this computation` with the specified
  * function.
@@ -85,17 +87,17 @@ export declare function either<W, S1, S2, R, E, A>(fa: Z<W, S1, S2, R, E, A>): Z
  * @tsplus static fncts.control.ZOps environment
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function environment<R>(): Z<never, unknown, never, R, never, R>;
+export declare function environment<R>(): Z<never, unknown, never, R, never, Environment<R>>;
 /**
  * @tsplus static fncts.control.ZOps environmentWith
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function environmentWith<R0, A>(f: (r: R0) => A): Z<never, unknown, never, R0, never, A>;
+export declare function environmentWith<R0, A>(f: (r: Environment<R0>) => A): Z<never, unknown, never, R0, never, A>;
 /**
  * @tsplus static fncts.control.ZOps environmentWithZ
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function environmentWithZ<R0, W, S1, S2, R, E, A>(f: (r: R0) => Z<W, S1, S2, R, E, A>): Z<W, S1, S2, R & R0, E, A>;
+export declare function environmentWithZ<R0, W, S1, S2, R, E, A>(f: (r: Environment<R0>) => Z<W, S1, S2, R, E, A>): Z<W, S1, S2, R | R0, E, A>;
 /**
  * Erases the current log
  * @tsplus getter fncts.control.Z erase
@@ -248,7 +250,7 @@ export declare function orElseEither_<W, S1, S2, R, E, A, S3, S4, R1, E1, A1>(fa
  * @tsplus fluent fncts.control.Z provideEnvironment
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function provideEnvironment_<W, S1, S2, R, E, A>(fa: Z<W, S1, S2, R, E, A>, r: R): Z<W, S1, S2, unknown, E, A>;
+export declare function provideEnvironment_<W, S1, S2, R, E, A>(fa: Z<W, S1, S2, R, E, A>, r: Environment<R>): Z<W, S1, S2, never, E, A>;
 /**
  * Constructs a computation that sets the state to the specified value.
  * @tsplus static fncts.control.ZOps put
@@ -325,7 +327,7 @@ export declare function writeAll_<W, S1, S2, R, E, A, W1>(ma: Z<W, S1, S2, R, E,
  * @tsplus fluent fncts.control.Z zip
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function zip_<W, S1, S2, R, E, A, W1, S3, Q, D, B>(fa: Z<W, S1, S2, R, E, A>, fb: Z<W1, S2, S3, Q, D, B>): Z<W | W1, S1, S3, Q & R, D | E, readonly [A, B]>;
+export declare function zip_<W, S1, S2, R, E, A, W1, S3, Q, D, B>(fa: Z<W, S1, S2, R, E, A>, fb: Z<W1, S2, S3, Q, D, B>): Z<W | W1, S1, S3, Q & R, D | E, Zipped.Make<A, B>>;
 /**
  * @tsplus fluent fncts.control.Z zipFirst
  * @tsplus location "@fncts/base/control/Z/api"

package/control/Z/definition.d.ts

@@ -1,9 +1,16 @@
 import { HKT } from "@fncts/typelevel/HKT";
 import { Cause } from "@fncts/base/data/Cause/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
-export interface ZF extends Z<any, any, any, any, any, any> {
-}
-export interface ZFixedF extends ZFixed<any, any, any, any, any> {
+import { Environment } from "@fncts/base/data/Environment/definition";
+export interface ZF extends HKT {
+    type: Z<this["W"], this["S"], this["S"], this["R"], this["E"], this["A"]>;
+    variance: {
+        W: "+";
+        S: "_";
+        R: "-";
+        E: "+";
+        A: "+";
+    };
 }
 export declare const ZTypeId: unique symbol;
 export declare type ZTypeId = typeof ZTypeId;
@@ -22,30 +29,29 @@ export declare type ZTypeId = typeof ZTypeId;
  */
 export declare abstract class Z<W, S1, S2, R, E, A> {
     readonly _typeId: ZTypeId;
-    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>>;
+    readonly _W: () => W;
+    readonly _S1: (_: S1) => void;
+    readonly _S2: () => S2;
+    readonly _R: (_: R) => void;
+    readonly _E: () => E;
+    readonly _A: () => A;
 }
 /**
  * @tsplus unify fncts.control.Z
  */
-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>>;
+export declare function unifyZ<X extends Z<any, any, any, any, any, any>>(_: X): Z<[
+    X
+] extends [Z<infer W, any, any, any, any, any>] ? W : never, [
+    X
+] extends [Z<any, infer S1, any, any, any, any>] ? S1 : never, [
+    X
+] extends [Z<any, any, infer S2, any, any, any>] ? S2 : never, [
+    X
+] extends [Z<any, any, any, infer R, any, any>] ? R : never, [
+    X
+] extends [Z<any, any, any, any, infer E, any>] ? E : never, [
+    X
+] extends [Z<any, any, any, any, any, infer A>] ? A : never>;
 /**
  * @tsplus static fncts.control.ZOps isZ
  * @tsplus location "@fncts/base/control/Z/definition"
@@ -59,7 +65,7 @@ export declare const enum ZTag {
     Modify = "Modify",
     Chain = "Chain",
     Match = "Match",
-    Environment = "Environment",
+    Access = "Access",
     Provide = "Provide",
     Tell = "Tell",
     Listen = "Listen",
@@ -103,16 +109,16 @@ export declare class Match<W, S1, S2, S5, R, E, A, W1, S3, R1, E1, B, W2, S4, R2
     readonly _tag = ZTag.Match;
     constructor(z: Z<W, S1, S2, R, E, A>, onFailure: (ws: Conc<W>, e: Cause<E>) => Z<W1, S5, S3, R1, E1, B>, onSuccess: (ws: Conc<W>, a: A) => Z<W2, S2, S4, R2, E2, C>);
 }
-export declare class Environment<W, R0, S1, S2, R, E, A> extends Z<W, S1, S2, R0 & R, E, A> {
-    readonly asks: (r: R0) => Z<W, S1, S2, R, E, A>;
-    readonly _tag = ZTag.Environment;
-    constructor(asks: (r: R0) => Z<W, S1, S2, R, E, A>);
+export declare class Access<W, R0, S1, S2, R, E, A> extends Z<W, S1, S2, R0 | R, E, A> {
+    readonly asks: (r: Environment<R0>) => Z<W, S1, S2, R, E, A>;
+    readonly _tag = ZTag.Access;
+    constructor(asks: (r: Environment<R0>) => Z<W, S1, S2, R, E, A>);
 }
-export declare class Provide<W, S1, S2, R, E, A> extends Z<W, S1, S2, unknown, E, A> {
+export declare class Provide<W, S1, S2, R, E, A> extends Z<W, S1, S2, never, E, A> {
     readonly ma: Z<W, S1, S2, R, E, A>;
-    readonly env: R;
+    readonly env: Environment<R>;
     readonly _tag = ZTag.Provide;
-    constructor(ma: Z<W, S1, S2, R, E, A>, env: R);
+    constructor(ma: Z<W, S1, S2, R, E, A>, env: Environment<R>);
 }
 export declare class Tell<W> extends Z<W, unknown, never, unknown, never, void> {
     readonly log: Conc<W>;
@@ -125,7 +131,7 @@ export declare class MapLog<W, S1, S2, R, E, A, W1> extends Z<W1, S1, S2, R, E,
     readonly _tag = ZTag.MapLog;
     constructor(ma: Z<W, S1, S2, R, E, A>, modifyLog: (ws: Conc<W>) => Conc<W1>);
 }
-export declare type Concrete = SucceedNow<any> | Fail<any> | Modify<any, any, any> | Chain<any, any, any, any, any, any, any, any, any, any, any> | Match<any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any> | Environment<any, any, any, any, any, any, any> | Provide<any, any, any, any, any, any> | Defer<any, any, any, any, any, any> | Succeed<any> | Tell<any> | MapLog<any, any, any, any, any, any, any>;
+export declare type Concrete = SucceedNow<any> | Fail<any> | Modify<any, any, any> | Chain<any, any, any, any, any, any, any, any, any, any, any> | Match<any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any> | Access<any, any, any, any, any, any, any> | Provide<any, any, any, any, any, any> | Defer<any, any, any, any, any, any> | Succeed<any> | Tell<any> | MapLog<any, any, any, any, any, any, any>;
 /**
  * @tsplus static fncts.control.ZOps concrete
  * @tsplus location "@fncts/base/control/Z/definition"

package/control/Z/instances.d.ts

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