@fncts/base 0.0.12 → 0.0.15

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

@@ -106,7 +106,7 @@ export declare function incrementDepth(bits: number): number;
 export declare function decrementDepth(bits: number): number;
 /**
  * Appends the value to the Vector by _mutating_ the Vector and its content.
- * @tsplus fluent fncts.base.MutableVector push
+ * @tsplus fluent fncts.MutableVector push
  * @tsplus location "@fncts/base/collection/immutable/Vector/internal"
  */
 export declare function push<A>(l: MutableVector<A>, value: A): MutableVector<A>;

package/collection/immutable.d.ts

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

package/collection/mutable/HashMap.d.ts

@@ -17,6 +17,7 @@ export declare class HashMap<K, V> implements Iterable<readonly [K, V]> {
     private contentSize;
     get size(): number;
     has(key: K): boolean;
+    unsafeGet(key: K): V | undefined;
     get(key: K): Maybe<V>;
     set(key: K, value: V): Maybe<V>;
     delete(key: K): Maybe<V>;

package/collection/mutable.d.ts

@@ -0,0 +1,4 @@
+export type {} from "./mutable/HashMap.js";
+export type {} from "./mutable/HashSet.js";
+export type {} from "./mutable/internal.js";
+export type {} from "./mutable/ListBuffer.js";

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/collection/weak.d.ts

@@ -0,0 +1,2 @@
+export type {} from "./weak/IterableWeakMap.js";
+export type {} from "./weak/IterableWeakSet.js";

package/collection.d.ts

@@ -0,0 +1,5 @@
+export type {} from "./collection/compat.js";
+export type {} from "./collection/immutable.js";
+export type {} from "./collection/Iterable.js";
+export type {} from "./collection/mutable.js";
+export type {} from "./collection/weak.js";

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"
@@ -35,12 +37,12 @@ export declare function bimap_<W, S1, S2, R, E, A, G, B>(pab: Z<W, S1, S2, R, E,
  * @tsplus fluent fncts.control.Z catchAll
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function catchAll_<W, S1, S2, R, E, A, S3, R1, E1, B>(fa: Z<W, S1, S2, R, E, A>, onFailure: (e: E) => Z<W, S1, S3, R1, E1, B>): Z<W, S1, S3, R & R1, E1, A | B>;
+export declare function catchAll_<W, S1, S2, R, E, A, S3, R1, E1, B>(fa: Z<W, S1, S2, R, E, A>, onFailure: (e: E) => Z<W, S1, S3, R1, E1, B>): Z<W, S1, S3, R | R1, E1, A | B>;
 /**
  * @tsplus fluent fncts.control.Z catchJust
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function catchJust_<W, S1, S2, R, E, A, S3, R1, E1, B>(fa: Z<W, S1, S2, R, E, A>, f: (e: E) => Maybe<Z<W, S1, S3, R1, E1, B>>): Z<W, S1, S2 | S3, R & R1, E | E1, A | B>;
+export declare function catchJust_<W, S1, S2, R, E, A, S3, R1, E1, B>(fa: Z<W, S1, S2, R, E, A>, f: (e: E) => Maybe<Z<W, S1, S3, R1, E1, B>>): Z<W, S1, S2 | S3, R | R1, E | E1, A | B>;
 /**
  * @tsplus fluent fncts.control.Z flatMap
  * @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
@@ -106,22 +108,22 @@ export declare function erase<W, S1, S2, R, E, A>(wa: Z<W, S1, S2, R, E, A>): Z<
  * @tsplus static fncts.control.ZOps fail
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function fail<E>(e: Lazy<E>, __tsplusTrace?: string): Z<never, unknown, never, unknown, E, never>;
+export declare function fail<E>(e: Lazy<E>, __tsplusTrace?: string): Z<never, unknown, never, never, E, never>;
 /**
  * @tsplus static fncts.control.ZOps failNow
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function failNow<E>(e: E, __tsplusTrace?: string): Z<never, unknown, never, unknown, E, never>;
+export declare function failNow<E>(e: E, __tsplusTrace?: string): Z<never, unknown, never, never, E, never>;
 /**
  * @tsplus static fncts.control.ZOps failCause
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function failCause<E>(cause: Lazy<Cause<E>>, __tsplusTrace?: string): Z<never, unknown, never, unknown, E, never>;
+export declare function failCause<E>(cause: Lazy<Cause<E>>, __tsplusTrace?: string): Z<never, unknown, never, never, E, never>;
 /**
  * @tsplus static fncts.control.ZOps failCauseNow
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function failCauseNow<E>(cause: Cause<E>, __tsplusTrace?: string): Z<never, unknown, never, unknown, E, never>;
+export declare function failCauseNow<E>(cause: Cause<E>, __tsplusTrace?: string): Z<never, unknown, never, never, E, never>;
 /**
  * @tsplus getter fncts.control.Z flatten
  * @tsplus location "@fncts/base/control/Z/api"
@@ -132,12 +134,12 @@ export declare function flatten<W, S1, S2, R, E, A, W1, S3, R1, E1>(mma: Z<W, S1
  * @tsplus static fncts.control.ZOps get
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function get<S>(): Z<never, S, S, unknown, never, S>;
+export declare function get<S>(): Z<never, S, S, never, never, S>;
 /**
  * @tsplus static fncts.control.ZOps gets
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function gets<S, A>(f: (s: S) => A): Z<never, S, S, unknown, never, A>;
+export declare function gets<S, A>(f: (s: S) => A): Z<never, S, S, never, never, A>;
 /**
  * @tsplus static fncts.control.ZOps getsZ
  * @tsplus location "@fncts/base/control/Z/api"
@@ -147,12 +149,12 @@ export declare function getsZ<S, W, R, E, A>(f: (s: S) => Z<W, S, S, R, E, A>):
  * @tsplus static fncts.control.ZOps halt
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function halt(defect: Lazy<unknown>, __tsplusTrace?: string): Z<never, unknown, never, unknown, never, never>;
+export declare function halt(defect: Lazy<unknown>, __tsplusTrace?: string): Z<never, unknown, never, never, never, never>;
 /**
  * @tsplus static fncts.control.ZOps haltNow
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function haltNow(defect: unknown, __tsplusTrace?: string): Z<never, unknown, never, unknown, never, never>;
+export declare function haltNow(defect: unknown, __tsplusTrace?: string): Z<never, unknown, never, never, never, never>;
 /**
  * @tsplus getter fncts.control.Z listen
  * @tsplus location "@fncts/base/control/Z/api"
@@ -199,17 +201,17 @@ export declare function match_<W, S1, S2, R, E, A, B, C>(fa: Z<W, S1, S2, R, E,
  * @tsplus fluent fncts.control.Z matchZ
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function matchZ_<W, S1, S5, S2, R, E, A, W1, S3, R1, E1, B, W2, S4, R2, E2, C>(fa: Z<W, S1, S2, R, E, A>, onFailure: (e: E) => Z<W1, S5, S3, R1, E1, B>, onSuccess: (a: A) => Z<W2, S2, S4, R2, E2, C>): Z<W | W1 | W2, S1 & S5, S3 | S4, R & R1 & R2, E1 | E2, B | C>;
+export declare function matchZ_<W, S1, S5, S2, R, E, A, W1, S3, R1, E1, B, W2, S4, R2, E2, C>(fa: Z<W, S1, S2, R, E, A>, onFailure: (e: E) => Z<W1, S5, S3, R1, E1, B>, onSuccess: (a: A) => Z<W2, S2, S4, R2, E2, C>): Z<W | W1 | W2, S1 & S5, S3 | S4, R | R1 | R2, E1 | E2, B | C>;
 /**
  * @tsplus fluent fncts.control.Z matchCauseZ
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function matchCauseZ_<W, S1, S2, R, E, A, W1, S0, S3, R1, E1, B, W2, S4, R2, E2, C>(fa: Z<W, S1, S2, R, E, A>, onFailure: (e: Cause<E>) => Z<W1, S0, S3, R1, E1, B>, onSuccess: (a: A) => Z<W2, S2, S4, R2, E2, C>): Z<W | W1 | W2, S0 & S1, S3 | S4, R & R1 & R2, E1 | E2, B | C>;
+export declare function matchCauseZ_<W, S1, S2, R, E, A, W1, S0, S3, R1, E1, B, W2, S4, R2, E2, C>(fa: Z<W, S1, S2, R, E, A>, onFailure: (e: Cause<E>) => Z<W1, S0, S3, R1, E1, B>, onSuccess: (a: A) => Z<W2, S2, S4, R2, E2, C>): Z<W | W1 | W2, S0 & S1, S3 | S4, R | R1 | R2, E1 | E2, B | C>;
 /**
  * @tsplus fluent fncts.control.Z matchLogZ
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function matchLogZ_<W, S1, S5, S2, R, E, A, W1, S3, R1, E1, B, W2, S4, R2, E2, C>(fa: Z<W, S1, S2, R, E, A>, onFailure: (ws: Conc<W>, e: E) => Z<W1, S5, S3, R1, E1, B>, onSuccess: (ws: Conc<W>, a: A) => Z<W2, S2, S4, R2, E2, C>): Z<W | W1 | W2, S1 & S5, S3 | S4, R & R1 & R2, E1 | E2, B | C>;
+export declare function matchLogZ_<W, S1, S5, S2, R, E, A, W1, S3, R1, E1, B, W2, S4, R2, E2, C>(fa: Z<W, S1, S2, R, E, A>, onFailure: (ws: Conc<W>, e: E) => Z<W1, S5, S3, R1, E1, B>, onSuccess: (ws: Conc<W>, a: A) => Z<W2, S2, S4, R2, E2, C>): Z<W | W1 | W2, S1 & S5, S3 | S4, R | R1 | R2, E1 | E2, B | C>;
 /**
  * Recovers from errors by accepting one computation to execute for the case
  * of an error, and one computation to execute for the case of success. More powerful
@@ -225,36 +227,36 @@ export declare function matchLogCauseZ_<W, S1, S2, R, E, A, W1, S0, S3, R1, E1,
  * @tsplus static fncts.control.ZOps modify
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function modify<S1, S2, A>(f: (s: S1) => readonly [A, S2]): Z<never, S1, S2, unknown, never, A>;
+export declare function modify<S1, S2, A>(f: (s: S1) => readonly [A, S2]): Z<never, S1, S2, never, never, A>;
 /**
  * Constructs a computation that may fail from the specified modify function.
  * @tsplus static fncts.control.ZOps modifyEither
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function modifyEither<S1, S2, E, A>(f: (s: S1) => Either<E, readonly [A, S2]>): Z<never, S1, S2, unknown, E, A>;
+export declare function modifyEither<S1, S2, E, A>(f: (s: S1) => Either<E, readonly [A, S2]>): Z<never, S1, S2, never, E, A>;
 /**
  * @tsplus fluent fncts.control.Z orElse
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function orElse_<W, S1, S2, R, E, A, W1, S3, R1, E1, A1>(fa: Z<W, S1, S2, R, E, A>, fb: Lazy<Z<W1, S1, S3, R1, E1, A1>>): Z<W | W1, S1, S2 | S3, R & R1, E | E1, A | A1>;
+export declare function orElse_<W, S1, S2, R, E, A, W1, S3, R1, E1, A1>(fa: Z<W, S1, S2, R, E, A>, fb: Lazy<Z<W1, S1, S3, R1, E1, A1>>): Z<W | W1, S1, S2 | S3, R | R1, E | E1, A | A1>;
 /**
  * Executes this computation and returns its value, if it succeeds, but
  * otherwise executes the specified computation.
  * @tsplus fluent fncts.control.Z orElseEither
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function orElseEither_<W, S1, S2, R, E, A, S3, S4, R1, E1, A1>(fa: Z<W, S1, S2, R, E, A>, that: Lazy<Z<W, S3, S4, R1, E1, A1>>): Z<W, S1 & S3, S2 | S4, R & R1, E1, Either<A, A1>>;
+export declare function orElseEither_<W, S1, S2, R, E, A, S3, S4, R1, E1, A1>(fa: Z<W, S1, S2, R, E, A>, that: Lazy<Z<W, S3, S4, R1, E1, A1>>): Z<W, S1 & S3, S2 | S4, R | R1, E1, Either<A, A1>>;
 /**
  * @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
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function put<S>(s: S): Z<never, unknown, S, unknown, never, void>;
+export declare function put<S>(s: S): Z<never, unknown, S, never, never, void>;
 /**
  * Repeats this computation the specified number of times (or until the first failure)
  * passing the updated state to each successive repetition.
@@ -273,12 +275,12 @@ export declare function repeatUntil_<W, S1, S2 extends S1, R, E, A>(ma: Z<W, S1,
  * @tsplus static fncts.control.ZOps succeed
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function succeed<A, W = never, S1 = unknown, S2 = never>(effect: Lazy<A>, __tsplusTrace?: string): Z<W, S1, S2, unknown, never, A>;
+export declare function succeed<A, W = never, S1 = unknown, S2 = never>(effect: Lazy<A>, __tsplusTrace?: string): Z<W, S1, S2, never, never, A>;
 /**
  * @tsplus static fncts.control.ZOps succeedNow
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function succeedNow<A, W = never, S1 = unknown, S2 = never>(a: A, __tsplusTrace?: string): Z<W, S1, S2, unknown, never, A>;
+export declare function succeedNow<A, W = never, S1 = unknown, S2 = never>(a: A, __tsplusTrace?: string): Z<W, S1, S2, never, never, A>;
 /**
  * @tsplus fluent fncts.control.Z tap
  * @tsplus location "@fncts/base/control/Z/api"
@@ -288,12 +290,12 @@ export declare function tap_<W, S1, S2, R, E, A, W1, S3, R1, E1, B>(ma: Z<W, S1,
  * @tsplus static fncts.control.ZOps tell
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function tell<W>(w: W): Z<W, unknown, never, unknown, never, void>;
+export declare function tell<W>(w: W): Z<W, unknown, never, never, never, void>;
 /**
  * @tsplus static fncts.control.ZOps tellAll
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function tellAll<W>(ws: Conc<W>): Z<W, unknown, never, unknown, never, void>;
+export declare function tellAll<W>(ws: Conc<W>): Z<W, unknown, never, never, never, void>;
 /**
  * Like `map`, but also allows the state to be modified.
  * @tsplus fluent fncts.control.Z transform
@@ -304,13 +306,13 @@ export declare function transform_<W, S1, S2, R, E, A, S3, B>(ma: Z<W, S1, S2, R
  * @tsplus static fncts.control.ZOps unit
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare const unit: Z<never, unknown, never, unknown, never, void>;
+export declare const unit: Z<never, unknown, never, never, never, void>;
 /**
  * Constructs a computation from the specified update function.
  * @tsplus static fncts.control.ZOps update
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function update<S1, S2>(f: (s: S1) => S2): Z<never, S1, S2, unknown, never, void>;
+export declare function update<S1, S2>(f: (s: S1) => S2): Z<never, S1, S2, never, never, void>;
 /**
  * @tsplus fluent fncts.control.Z write
  * @tsplus location "@fncts/base/control/Z/api"
@@ -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;
+    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,18 +65,18 @@ export declare const enum ZTag {
     Modify = "Modify",
     Chain = "Chain",
     Match = "Match",
-    Environment = "Environment",
+    Access = "Access",
     Provide = "Provide",
     Tell = "Tell",
     Listen = "Listen",
     MapLog = "MapLog"
 }
-export declare class SucceedNow<A> extends Z<never, unknown, never, unknown, never, A> {
+export declare class SucceedNow<A> extends Z<never, unknown, never, never, never, A> {
     readonly value: A;
     readonly _tag = ZTag.SucceedNow;
     constructor(value: A);
 }
-export declare class Succeed<A> extends Z<never, unknown, never, unknown, never, A> {
+export declare class Succeed<A> extends Z<never, unknown, never, never, never, A> {
     readonly effect: () => A;
     readonly _tag = ZTag.Succeed;
     constructor(effect: () => A);
@@ -80,12 +86,12 @@ export declare class Defer<W, S1, S2, R, E, A> extends Z<W, S1, S2, R, E, A> {
     readonly _tag = ZTag.Defer;
     constructor(make: () => Z<W, S1, S2, R, E, A>);
 }
-export declare class Fail<E> extends Z<never, unknown, never, unknown, E, never> {
+export declare class Fail<E> extends Z<never, unknown, never, never, E, never> {
     readonly cause: Cause<E>;
     readonly _tag = ZTag.Fail;
     constructor(cause: Cause<E>);
 }
-export declare class Modify<S1, S2, A> extends Z<never, S1, S2, unknown, never, A> {
+export declare class Modify<S1, S2, A> extends Z<never, S1, S2, never, never, A> {
     readonly run: (s1: S1) => readonly [A, S2];
     readonly _tag = ZTag.Modify;
     constructor(run: (s1: S1) => readonly [A, S2]);
@@ -103,18 +109,18 @@ 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> {
+export declare class Tell<W> extends Z<W, unknown, never, never, never, void> {
     readonly log: Conc<W>;
     readonly _tag = ZTag.Tell;
     constructor(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>;

package/control/Z/runtime.d.ts

@@ -1,6 +1,7 @@
 import { Z } from "@fncts/base/control/Z/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
 import { Exit } from "@fncts/base/data/Exit/definition";
+import { Environment } from "@fncts/base/data/Environment/definition";
 import { Cause } from "@fncts/base/data/Cause/definition";
 /**
  * Runs this computation with the specified initial state, returning either a
@@ -8,48 +9,48 @@ import { Cause } from "@fncts/base/data/Cause/definition";
  * @tsplus fluent fncts.control.Z unsafeRunAll
  * @tsplus location "@fncts/base/control/Z/runtime"
  */
-export declare function unsafeRunAll_<W, S1, S2, E, A>(ma: Z<W, S1, S2, unknown, E, A>, s: S1): readonly [Conc<W>, Exit<E, readonly [S2, A]>];
+export declare function unsafeRunAll_<W, S1, S2, E, A>(ma: Z<W, S1, S2, never, E, A>, s: S1): readonly [Conc<W>, Exit<E, readonly [S2, A]>];
 /**
  * Runs this computation with the specified initial state, returning both
  * the updated state and the result.
  * @tsplus fluent fncts.control.Z unsafeRun
  * @tsplus location "@fncts/base/control/Z/runtime"
  */
-export declare function unsafeRun_<W, S1, S2, A>(ma: Z<W, S1, S2, unknown, never, A>, s: S1): readonly [S2, A];
+export declare function unsafeRun_<W, S1, S2, A>(ma: Z<W, S1, S2, never, never, A>, s: S1): readonly [S2, A];
 /**
  * Runs this computation, returning the result.
  * @tsplus getter fncts.control.Z unsafeRunResult
  * @tsplus location "@fncts/base/control/Z/runtime"
  */
-export declare function unsafeRunResult<W, A>(ma: Z<W, unknown, unknown, unknown, never, A>): A;
+export declare function unsafeRunResult<W, A>(ma: Z<W, unknown, unknown, never, never, A>): A;
 /**
  * Runs this computation with the given environment, returning the result.
  * @tsplus fluent fncts.control.Z unsafeRunReader
  * @tsplus location "@fncts/base/control/Z/runtime"
  */
-export declare function unsafeRunReader_<W, R, A>(ma: Z<W, unknown, never, R, never, A>, r: R): A;
+export declare function unsafeRunReader_<W, R, A>(ma: Z<W, unknown, never, R, never, A>, r: Environment<R>): A;
 /**
  * Runs this computation with the specified initial state, returning the
  * updated state and discarding the result.
  * @tsplus fluent fncts.control.Z unsafeRunState
  * @tsplus location "@fncts/base/control/Z/runtime"
  */
-export declare function unsafeRunState_<W, S1, S2, A>(ma: Z<W, S1, S2, unknown, never, A>, s: S1): S2;
+export declare function unsafeRunState_<W, S1, S2, A>(ma: Z<W, S1, S2, never, never, A>, s: S1): S2;
 /**
  * Runs this computation with the specified initial state, returning the
  * result and discarding the updated state.
  * @tsplus fluent fncts.control.Z unsafeRunStateResult
  * @tsplus location "@fncts/base/control/Z/runtime"
  */
-export declare function unsafeRunStateResult_<W, S1, S2, A>(ma: Z<W, S1, S2, unknown, never, A>, s: S1): A;
+export declare function unsafeRunStateResult_<W, S1, S2, A>(ma: Z<W, S1, S2, never, never, A>, s: S1): A;
 /**
  * Runs this computation returning either the result or error
  * @tsplus getter fncts.control.Z unsafeRunExit
  * @tsplus location "@fncts/base/control/Z/runtime"
  */
-export declare function unsafeRunExit<E, A>(ma: Z<never, unknown, unknown, unknown, E, A>): Exit<E, A>;
+export declare function unsafeRunExit<E, A>(ma: Z<never, unknown, unknown, never, E, A>): Exit<E, A>;
 /**
  * @tsplus getter fncts.control.Z unsafeRunWriter
  * @tsplus location "@fncts/base/control/Z/runtime"
  */
-export declare function unsafeRunWriter<W, A>(ma: Z<W, unknown, unknown, unknown, never, A>): readonly [Conc<W>, A];
+export declare function unsafeRunWriter<W, A>(ma: Z<W, unknown, unknown, never, never, A>): readonly [Conc<W>, A];

package/control.d.ts

@@ -0,0 +1,3 @@
+export type {} from "./control/Eval.js";
+export type {} from "./control/LazyValue.js";
+export type {} from "./control/Z.js";