@fncts/base 0.0.28 → 0.0.30

package/control/Pure/api.d.ts

@@ -0,0 +1,345 @@
+import { Pure } from "@fncts/base/control/Pure/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.Pure absolve
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function absolve<W, S1, S2, R, E, E1, A>(fa: Pure<W, S1, S2, R, E, Either<E1, A>>): Pure<W, S1, S2, R, E | E1, A>;
+/**
+ * @tsplus pipeable fncts.control.Pure ap
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function ap<W, S, A, R1, E1>(fb: Pure<W, S, S, R1, E1, A>): <R, E, B>(self: import("@fncts/base/control/Pure/definition").Pure<W, S, S, R, E, (a: A) => B>) => import("@fncts/base/control/Pure/definition").Pure<W, S, S, R & R1, E1 | E, B>;
+/**
+ * @tsplus pipeable fncts.control.Pure zipLeft
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function zipLeft<W, S, R1, E1, B>(fb: Pure<W, S, S, R1, E1, B>): <R, E, A>(fa: import("@fncts/base/control/Pure/definition").Pure<W, S, S, R, E, A>) => import("@fncts/base/control/Pure/definition").Pure<W, S, S, R & R1, E1 | E, A>;
+/**
+ * @tsplus pipeable fncts.control.Pure zipRight
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function zipRight<W, S, R1, E1, B>(fb: Pure<W, S, S, R1, E1, B>): <R, E, A>(fa: import("@fncts/base/control/Pure/definition").Pure<W, S, S, R, E, A>) => import("@fncts/base/control/Pure/definition").Pure<W, S, S, R & R1, E1 | E, B>;
+/**
+ * @tsplus pipeable fncts.control.Pure bimap
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function bimap<E, A, G, B>(f: (e: E) => G, g: (a: A) => B): <W, S1, S2, R>(pab: import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, R, E, A>) => import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, R, G, B>;
+/**
+ * Recovers from all errors.
+ * @tsplus pipeable fncts.control.Pure catchAll
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function catchAll<W, S1, E, S3, R1, E1, B>(onFailure: (e: E) => Pure<W, S1, S3, R1, E1, B>): <S2, R, A>(fa: import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, R, E, A>) => import("@fncts/base/control/Pure/definition").Pure<W, S1, S3, R1 | R, E1, B | A>;
+/**
+ * @tsplus pipeable fncts.control.Pure catchJust
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function catchJust<W, S1, E, S3, R1, E1, B>(f: (e: E) => Maybe<Pure<W, S1, S3, R1, E1, B>>): <S2, R, A>(fa: import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, R, E, A>) => import("@fncts/base/control/Pure/definition").Pure<W, S1, S3 | S2, R1 | R, E | E1, B | A>;
+/**
+ * @tsplus pipeable fncts.control.Pure flatMap
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function flatMap<S2, A, W1, S3, R1, E1, B>(f: (a: A) => Pure<W1, S2, S3, R1, E1, B>): <W, S1, R, E>(ma: import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, R, E, A>) => import("@fncts/base/control/Pure/definition").Pure<W1 | W, S1, S3, R1 & R, E1 | E, B>;
+/**
+ * @tsplus pipeable fncts.control.Pure contramapEnvironment
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function contramapEnvironment<R0, R>(f: (r0: Environment<R0>) => Environment<R>): <W, S1, S2, E, A>(ma: import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, R, E, A>) => import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, R0, E, A>;
+/**
+ * Transforms the initial state of this computation` with the specified
+ * function.
+ * @tsplus pipeable fncts.control.Pure contramapState
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function contramapState<S0, S1>(f: (s: S0) => S1): <W, S2, R, E, A>(fa: import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, R, E, A>) => import("@fncts/base/control/Pure/definition").Pure<W, S0, S2, R, E, A>;
+/**
+ * @tsplus pipeable fncts.control.Pure cross
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function cross<W, S, R1, E1, B>(fb: Pure<W, S, S, R1, E1, B>): <R, E, A>(fa: import("@fncts/base/control/Pure/definition").Pure<W, S, S, R, E, A>) => import("@fncts/base/control/Pure/definition").Pure<W, S, S, R & R1, E1 | E, readonly [A, B]>;
+/**
+ * @tsplus pipeable fncts.control.Pure crossWith
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function crossWith<W, S, A, R1, E1, B, C>(fb: Pure<W, S, S, R1, E1, B>, f: (a: A, b: B) => C): <R, E>(fa: import("@fncts/base/control/Pure/definition").Pure<W, S, S, R, E, A>) => import("@fncts/base/control/Pure/definition").Pure<W, S, S, R & R1, E1 | E, C>;
+/**
+ * @tsplus static fncts.control.PureOps defer
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function defer<W, S1, S2, R, E, A>(ma: Lazy<Pure<W, S1, S2, R, E, A>>, __tsplusTrace?: string): Pure<W, S1, S2, R, E, A>;
+/**
+ * Returns a computation whose failure and success have been lifted into an
+ * `Either`. The resulting computation cannot fail, because the failure case
+ * has been exposed as part of the `Either` success case.
+ * @tsplus getter fncts.control.Pure either
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function either<W, S1, S2, R, E, A>(fa: Pure<W, S1, S2, R, E, A>): Pure<W, S1, S1 | S2, R, never, Either<E, A>>;
+/**
+ * @tsplus static fncts.control.PureOps environment
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function environment<R>(): Pure<never, unknown, never, R, never, Environment<R>>;
+/**
+ * @tsplus static fncts.control.PureOps environmentWith
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function environmentWith<R0, A>(f: (r: Environment<R0>) => A): Pure<never, unknown, never, R0, never, A>;
+/**
+ * @tsplus static fncts.control.PureOps environmentWithPure
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function environmentWithPure<R0, W, S1, S2, R, E, A>(f: (r: Environment<R0>) => Pure<W, S1, S2, R, E, A>): Pure<W, S1, S2, R | R0, E, A>;
+/**
+ * Erases the current log
+ * @tsplus getter fncts.control.Pure erase
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function erase<W, S1, S2, R, E, A>(wa: Pure<W, S1, S2, R, E, A>): Pure<never, S1, S2, R, E, A>;
+/**
+ * @tsplus static fncts.control.PureOps fail
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function fail<E>(e: Lazy<E>, __tsplusTrace?: string): Pure<never, unknown, never, never, E, never>;
+/**
+ * @tsplus static fncts.control.PureOps failNow
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function failNow<E>(e: E, __tsplusTrace?: string): Pure<never, unknown, never, never, E, never>;
+/**
+ * @tsplus static fncts.control.PureOps failCause
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function failCause<E>(cause: Lazy<Cause<E>>, __tsplusTrace?: string): Pure<never, unknown, never, never, E, never>;
+/**
+ * @tsplus static fncts.control.PureOps failCauseNow
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function failCauseNow<E>(cause: Cause<E>, __tsplusTrace?: string): Pure<never, unknown, never, never, E, never>;
+/**
+ * @tsplus getter fncts.control.Pure flatten
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function flatten<W, S1, S2, R, E, A, W1, S3, R1, E1>(mma: Pure<W, S1, S2, R, E, Pure<W1, S2, S3, R1, E1, A>>): Pure<W | W1, S1, S3, R1 & R, E1 | E, A>;
+/**
+ * Constructs a computation that returns the initial state unchanged.
+ * @tsplus static fncts.control.PureOps get
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function get<S>(): Pure<never, S, S, never, never, S>;
+/**
+ * @tsplus static fncts.control.PureOps gets
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function gets<S, A>(f: (s: S) => A): Pure<never, S, S, never, never, A>;
+/**
+ * @tsplus static fncts.control.PureOps getsPure
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function getsPure<S, W, R, E, A>(f: (s: S) => Pure<W, S, S, R, E, A>): Pure<W, S, S, R, E, A>;
+/**
+ * @tsplus static fncts.control.PureOps halt
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function halt(defect: Lazy<unknown>, __tsplusTrace?: string): Pure<never, unknown, never, never, never, never>;
+/**
+ * @tsplus static fncts.control.PureOps haltNow
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function haltNow(defect: unknown, __tsplusTrace?: string): Pure<never, unknown, never, never, never, never>;
+/**
+ * @tsplus getter fncts.control.Pure listen
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function listen<W, S1, S2, R, E, A>(wa: Pure<W, S1, S2, R, E, A>): Pure<W, S1, S2, R, E, readonly [A, Conc<W>]>;
+/**
+ * @tsplus pipeable fncts.control.Pure listens
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function listens<W, B>(f: (log: Conc<W>) => B): <S1, S2, R, E, A>(wa: import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, R, E, A>) => import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, R, E, readonly [A, B]>;
+/**
+ * @tsplus pipeable fncts.control.Pure map
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function map<A, B>(f: (a: A) => B): <W, S1, S2, R, E>(fa: import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, R, E, A>) => import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, R, E, B>;
+/**
+ * @tsplus pipeable fncts.control.Pure mapError
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function mapError<E, G>(f: (e: E) => G): <W, S1, S2, R, A>(pab: import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, R, E, A>) => import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, R, G, A>;
+/**
+ * Modifies the current log with the specified function
+ * @tsplus pipeable fncts.control.Pure mapLog
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function mapLog<W, W1>(f: (ws: Conc<W>) => Conc<W1>): <S1, S2, R, E, A>(wa: import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, R, E, A>) => import("@fncts/base/control/Pure/definition").Pure<W1, S1, S2, R, E, A>;
+/**
+ * Modifies the current state with the specified function
+ * @tsplus pipeable fncts.control.Pure mapState
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function mapState<S2, S3>(f: (s: S2) => S3): <W, S1, R, E, A>(ma: import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, R, E, A>) => import("@fncts/base/control/Pure/definition").Pure<W, S1, S3, R, E, A>;
+/**
+ * Folds over the failed or successful results of this computation to yield
+ * a computation that does not fail, but succeeds with the value of the left
+ * or right function passed to `match`.
+ * @tsplus pipeable fncts.control.Pure match
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function match<E, A, B, C>(onFailure: (e: E) => B, onSuccess: (a: A) => C): <W, S1, S2, R>(fa: import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, R, E, A>) => import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, R, never, 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.
+ * @tsplus pipeable fncts.control.Pure matchPure
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function matchPure<S5, S2, E, A, W1, S3, R1, E1, B, W2, S4, R2, E2, C>(onFailure: (e: E) => Pure<W1, S5, S3, R1, E1, B>, onSuccess: (a: A) => Pure<W2, S2, S4, R2, E2, C>): <W, S1, R>(fa: import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, R, E, A>) => import("@fncts/base/control/Pure/definition").Pure<W1 | W2 | W, S1 & S5, S3 | S4, R1 | R2 | R, E1 | E2, B | C>;
+/**
+ * @tsplus pipeable fncts.control.Pure matchCausePure
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function matchCausePure<S2, E, A, W1, S0, S3, R1, E1, B, W2, S4, R2, E2, C>(onFailure: (e: Cause<E>) => Pure<W1, S0, S3, R1, E1, B>, onSuccess: (a: A) => Pure<W2, S2, S4, R2, E2, C>): <W, S1, R>(fa: import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, R, E, A>) => import("@fncts/base/control/Pure/definition").Pure<W1 | W2 | W, S0 & S1, S3 | S4, R1 | R2 | R, E1 | E2, B | C>;
+/**
+ * @tsplus pipeable fncts.control.Pure matchLogPure
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function matchLogPure<W, S5, S2, E, A, W1, S3, R1, E1, B, W2, S4, R2, E2, C>(onFailure: (ws: Conc<W>, e: E) => Pure<W1, S5, S3, R1, E1, B>, onSuccess: (ws: Conc<W>, a: A) => Pure<W2, S2, S4, R2, E2, C>): <S1, R>(fa: import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, R, E, A>) => import("@fncts/base/control/Pure/definition").Pure<W | W1 | W2, S1 & S5, S3 | S4, R1 | R2 | R, 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
+ * than `matchCauseM` by providing the current state of the log as an argument in
+ * each case
+ * @note the log is cleared after being provided
+ * @tsplus pipeable fncts.control.Pure matchLogCausePure
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function matchLogCausePure<W, S2, E, A, W1, S0, S3, R1, E1, B, W2, S4, R2, E2, C>(onFailure: (ws: Conc<W>, e: Cause<E>) => Pure<W1, S0, S3, R1, E1, B>, onSuccess: (ws: Conc<W>, a: A) => Pure<W2, S2, S4, R2, E2, C>): <S1, R>(fa: import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, R, E, A>) => import("@fncts/base/control/Pure/definition").Pure<W1 | W2, S0 & S1, S3 | S4, R & R1 & R2, E1 | E2, B | C>;
+/**
+ * Constructs a computation from the specified modify function
+ * @tsplus static fncts.control.PureOps modify
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function modify<S1, S2, A>(f: (s: S1) => readonly [A, S2]): Pure<never, S1, S2, never, never, A>;
+/**
+ * Constructs a computation that may fail from the specified modify function.
+ * @tsplus static fncts.control.PureOps modifyEither
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function modifyEither<S1, S2, E, A>(f: (s: S1) => Either<E, readonly [A, S2]>): Pure<never, S1, S2, never, E, A>;
+/**
+ * @tsplus pipeable fncts.control.Pure orElse
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function orElse<S1, W1, S3, R1, E1, A1>(fb: Lazy<Pure<W1, S1, S3, R1, E1, A1>>): <W, S2, R, E, A>(fa: import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, R, E, A>) => import("@fncts/base/control/Pure/definition").Pure<W1 | W, S1, S3 | S2, R1 | R, E1 | E, A1 | A>;
+/**
+ * Executes this computation and returns its value, if it succeeds, but
+ * otherwise executes the specified computation.
+ * @tsplus pipeable fncts.control.Pure orElseEither
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function orElseEither<W, S3, S4, R1, E1, A1>(that: Lazy<Pure<W, S3, S4, R1, E1, A1>>): <S1, S2, R, E, A>(fa: import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, R, E, A>) => import("@fncts/base/control/Pure/definition").Pure<W, S1 & S3, S4 | S2, R1 | R, E1, import("../../data/Either.js").Either<A, A1>>;
+/**
+ * @tsplus pipeable fncts.control.Pure provideEnvironment
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function provideEnvironment<R>(r: Environment<R>): <W, S1, S2, E, A>(fa: import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, R, E, A>) => import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, never, E, A>;
+/**
+ * Constructs a computation that sets the state to the specified value.
+ * @tsplus static fncts.control.PureOps put
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function put<S>(s: S): Pure<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.
+ * @tsplus pipeable fncts.control.Pure repeatN
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function repeatN(n: number): <W, S1, S2 extends S1, R, E, A>(ma: import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, R, E, A>) => import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, R, E, A>;
+/**
+ * Repeats this computation until its value satisfies the specified predicate
+ * (or until the first failure) passing the updated state to each successive repetition.
+ * @tsplus pipeable fncts.control.Pure repeatUntil
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function repeatUntil<A>(p: Predicate<A>): <W, S1, S2 extends S1, R, E>(ma: import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, R, E, A>) => import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, R, E, A>;
+/**
+ * @tsplus static fncts.control.PureOps succeed
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function succeed<A, W = never, S1 = unknown, S2 = never>(effect: Lazy<A>, __tsplusTrace?: string): Pure<W, S1, S2, never, never, A>;
+/**
+ * @tsplus static fncts.control.PureOps succeedNow
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function succeedNow<A, W = never, S1 = unknown, S2 = never>(a: A, __tsplusTrace?: string): Pure<W, S1, S2, never, never, A>;
+/**
+ * @tsplus pipeable fncts.control.Pure tap
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function tap<S2, A, W1, S3, R1, E1, B>(f: (a: A) => Pure<W1, S2, S3, R1, E1, B>): <W, S1, R, E>(ma: import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, R, E, A>) => import("@fncts/base/control/Pure/definition").Pure<W1 | W, S1, S3, R1 & R, E1 | E, A>;
+/**
+ * @tsplus static fncts.control.PureOps tell
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function tell<W>(w: W): Pure<W, unknown, never, never, never, void>;
+/**
+ * @tsplus static fncts.control.PureOps tellAll
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function tellAll<W>(ws: Conc<W>): Pure<W, unknown, never, never, never, void>;
+/**
+ * Like `map`, but also allows the state to be modified.
+ * @tsplus pipeable fncts.control.Pure transform
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function transform<S2, A, S3, B>(f: (s: S2, a: A) => readonly [B, S3]): <W, S1, R, E>(ma: import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, R, E, A>) => import("@fncts/base/control/Pure/definition").Pure<W, S1, S3, R, E, B>;
+/**
+ * @tsplus static fncts.control.PureOps unit
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare const unit: Pure<never, unknown, never, never, never, void>;
+/**
+ * Constructs a computation from the specified update function.
+ * @tsplus static fncts.control.PureOps update
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function update<S1, S2>(f: (s: S1) => S2): Pure<never, S1, S2, never, never, void>;
+/**
+ * @tsplus pipeable fncts.control.Pure write
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function write<W1>(w: W1): <W, S1, S2, R, E, A>(ma: import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, R, E, A>) => import("@fncts/base/control/Pure/definition").Pure<W1 | W, S1, S2, R, E, A>;
+/**
+ * @tsplus pipeable fncts.control.Pure writeAll
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function writeAll<W1>(log: Conc<W1>): <W, S1, S2, R, E, A>(ma: import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, R, E, A>) => import("@fncts/base/control/Pure/definition").Pure<W1 | W, S1, S2, R, E, A>;
+/**
+ * @tsplus pipeable fncts.control.Pure zip
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function zip<S2, W1, S3, Q, D, B>(fb: Pure<W1, S2, S3, Q, D, B>): <W, S1, R, E, A>(fa: import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, R, E, A>) => import("@fncts/base/control/Pure/definition").Pure<W1 | W, S1, S3, Q & R, D | E, import("../../data/Zipped.js").Zipped.Make<A, B>>;
+/**
+ * @tsplus pipeable fncts.control.Pure zipFirst
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function zipFirst<S2, W1, S3, Q, D, B>(fb: Pure<W1, S2, S3, Q, D, B>): <W, S1, R, E, A>(fa: import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, R, E, A>) => import("@fncts/base/control/Pure/definition").Pure<W1 | W, S1, S3, Q & R, D | E, A>;
+/**
+ * @tsplus pipeable fncts.control.Pure zipSecond
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function zipSecond<S2, W1, S3, Q, D, B>(fb: Pure<W1, S2, S3, Q, D, B>): <W, S1, R, E, A>(fa: import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, R, E, A>) => import("@fncts/base/control/Pure/definition").Pure<W1 | W, S1, S3, Q & R, D | E, B>;
+/**
+ * @tsplus pipeable fncts.control.Pure zipWith
+ * @tsplus location "@fncts/base/control/Pure/api"
+ */
+export declare function zipWith<S2, A, W1, S3, R1, E1, B, C>(fb: Pure<W1, S2, S3, R1, E1, B>, f: (a: A, b: B) => C): <W, S1, R, E>(fa: import("@fncts/base/control/Pure/definition").Pure<W, S1, S2, R, E, A>) => import("@fncts/base/control/Pure/definition").Pure<W1 | W, S1, S3, R1 & R, E1 | E, C>;

package/control/Pure/definition.d.ts

@@ -0,0 +1,156 @@
+import { HKT } from "@fncts/typelevel/HKT";
+import { Cause } from "@fncts/base/data/Cause/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { Environment } from "@fncts/base/data/Environment/definition";
+export interface PureF extends HKT {
+    type: Pure<this["W"], this["S"], this["S"], this["R"], this["E"], this["A"]>;
+    variance: {
+        W: "+";
+        S: "_";
+        R: "-";
+        E: "+";
+        A: "+";
+    };
+}
+export declare const PureVariance: unique symbol;
+export type PureVariance = typeof PureVariance;
+export declare const PureTypeId: unique symbol;
+export type PureTypeId = typeof PureTypeId;
+/**
+ * `Pure<W, S1, S2, R, E, A>` is a purely functional description of a synchronous computation
+ * that requires an environment `R` and an initial state `S1` and may either
+ * fail with an `E` or succeed with an updated state `S2` and an `A`. Because
+ * of its polymorphism `Z` can be used to model a variety of effects
+ * including context, state, failure, and logging.
+ *
+ * @tsplus type fncts.control.Pure
+ * @tsplus companion fncts.control.PureOps
+ */
+export declare abstract class Pure<W, S1, S2, R, E, A> {
+    readonly [PureTypeId]: PureTypeId;
+    [PureVariance]: {
+        readonly _W: (_: never) => W;
+        readonly _S1: (_: S1) => void;
+        readonly _S2: (_: never) => S2;
+        readonly _R: (_: never) => R;
+        readonly _E: (_: never) => E;
+        readonly _A: (_: never) => A;
+    };
+}
+/**
+ * @tsplus unify fncts.control.Pure
+ */
+export declare function unifyPure<X extends Pure<any, any, any, any, any, any>>(_: X): Pure<[
+    X
+] extends [Pure<infer W, any, any, any, any, any>] ? W : never, [
+    X
+] extends [Pure<any, infer S1, any, any, any, any>] ? S1 : never, [
+    X
+] extends [Pure<any, any, infer S2, any, any, any>] ? S2 : never, [
+    X
+] extends [Pure<any, any, any, infer R, any, any>] ? R : never, [
+    X
+] extends [Pure<any, any, any, any, infer E, any>] ? E : never, [
+    X
+] extends [Pure<any, any, any, any, any, infer A>] ? A : never>;
+export declare class PurePrimitive {
+    readonly _tag: unknown;
+    readonly [PureTypeId]: PureTypeId;
+    [PureVariance]: {
+        readonly _W: (_: never) => never;
+        readonly _S1: (_: unknown) => void;
+        readonly _S2: (_: never) => never;
+        readonly _R: (_: never) => never;
+        readonly _E: (_: never) => never;
+        readonly _A: (_: never) => never;
+    };
+    constructor(_tag: unknown);
+    readonly i0: unknown;
+    readonly i1: unknown;
+    readonly i2: unknown;
+}
+/**
+ * @tsplus static fncts.control.PureOps isPure
+ * @tsplus location "@fncts/base/control/Pure/definition"
+ */
+export declare function isPure(u: unknown): u is Pure<unknown, unknown, unknown, unknown, unknown, unknown>;
+export declare const enum PureTag {
+    SucceedNow = 0,
+    Succeed = 1,
+    Defer = 2,
+    Fail = 3,
+    Modify = 4,
+    Chain = 5,
+    Match = 6,
+    Access = 7,
+    Provide = 8,
+    Tell = 9,
+    Listen = 10,
+    MapLog = 11
+}
+export type PureOp<Tag extends number, Body = {}> = PurePrimitive & Body & {
+    _tag: Tag;
+};
+export interface SucceedNow extends PureOp<PureTag.SucceedNow, {
+    readonly i0: any;
+}> {
+}
+export interface Succeed extends PureOp<PureTag.Succeed, {
+    readonly i0: () => any;
+}> {
+}
+export interface Defer extends PureOp<PureTag.Defer, {
+    readonly i0: () => Primitive;
+}> {
+}
+export interface Fail extends PureOp<PureTag.Fail, {
+    readonly i0: Cause<unknown>;
+}> {
+}
+export interface Modify extends PureOp<PureTag.Modify, {
+    readonly i0: (s1: any) => readonly [any, any];
+}> {
+}
+export interface FlatMap extends PureOp<PureTag.Chain, {
+    readonly i0: Primitive;
+    readonly i1: (a: any) => Primitive;
+}> {
+}
+export interface Match extends PureOp<PureTag.Match, {
+    readonly i0: Primitive;
+    readonly i1: (ws: Conc<any>, e: Cause<unknown>) => Primitive;
+    readonly i2: (ws: Conc<any>, a: any) => Primitive;
+}> {
+}
+export interface Access extends PureOp<PureTag.Access, {
+    readonly i0: (r: Environment<any>) => Primitive;
+}> {
+}
+export interface Provide extends PureOp<PureTag.Provide, {
+    readonly i0: Primitive;
+    readonly i1: Environment<any>;
+}> {
+}
+export interface Tell extends PureOp<PureTag.Tell, {
+    readonly i0: Conc<any>;
+}> {
+}
+export interface MapLog extends PureOp<PureTag.MapLog, {
+    readonly i0: Primitive;
+    readonly i1: (ws: Conc<any>) => Conc<any>;
+}> {
+}
+export type Primitive = SucceedNow | Fail | Modify | FlatMap | Match | Access | Provide | Defer | Succeed | Tell | MapLog;
+/**
+ * @tsplus static fncts.control.PureOps concrete
+ * @tsplus location "@fncts/base/control/Pure/definition"
+ */
+export declare function concrete(_: Pure<any, any, any, any, any, any>): asserts _ is Primitive;
+export declare const PureErrorTypeId: unique symbol;
+export type PureErrorTypeId = typeof PureErrorTypeId;
+export declare class PureError<E> {
+    readonly cause: Cause<E>;
+    readonly [PureErrorTypeId]: PureErrorTypeId;
+    constructor(cause: Cause<E>);
+}
+export declare function isPureError(u: unknown): u is PureError<unknown>;

package/control/Pure/instances.d.ts

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

package/control/Pure/runtime.d.ts

@@ -0,0 +1,56 @@
+import { Pure } from "@fncts/base/control/Pure/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
+ * failure or the updated state and the result
+ * @tsplus pipeable fncts.control.Pure unsafeRunAll
+ * @tsplus location "@fncts/base/control/Pure/runtime"
+ */
+export declare function unsafeRunAll<S1>(s: S1): <W, S2, E, A>(ma: import("./definition.js").Pure<W, S1, S2, never, E, A>) => readonly [import("../../collection/immutable/Conc.js").Conc<W>, import("../../data/Exit.js").Exit<E, readonly [S2, A]>];
+/**
+ * Runs this computation with the specified initial state, returning both
+ * the updated state and the result.
+ * @tsplus pipeable fncts.control.Pure unsafeRun
+ * @tsplus location "@fncts/base/control/Pure/runtime"
+ */
+export declare function unsafeRun<S1>(s: S1): <W, S2, A>(ma: import("./definition.js").Pure<W, S1, S2, never, never, A>) => readonly [S2, A];
+/**
+ * Runs this computation, returning the result.
+ * @tsplus getter fncts.control.Pure unsafeRunResult
+ * @tsplus location "@fncts/base/control/Pure/runtime"
+ */
+export declare function unsafeRunResult<W, A>(ma: Pure<W, unknown, unknown, never, never, A>): A;
+/**
+ * Runs this computation with the given environment, returning the result.
+ * @tsplus pipeable fncts.control.Pure unsafeRunReader
+ * @tsplus location "@fncts/base/control/Pure/runtime"
+ */
+export declare function unsafeRunReader<R>(r: Environment<R>): <W, A>(ma: import("./definition.js").Pure<W, unknown, never, R, never, A>) => A;
+/**
+ * Runs this computation with the specified initial state, returning the
+ * updated state and discarding the result.
+ * @tsplus pipeable fncts.control.Pure unsafeRunState
+ * @tsplus location "@fncts/base/control/Pure/runtime"
+ */
+export declare function unsafeRunState<S1>(s: S1): <W, S2, A>(ma: import("./definition.js").Pure<W, S1, S2, never, never, A>) => S2;
+/**
+ * Runs this computation with the specified initial state, returning the
+ * result and discarding the updated state.
+ * @tsplus pipeable fncts.control.Pure unsafeRunStateResult
+ * @tsplus location "@fncts/base/control/Pure/runtime"
+ */
+export declare function unsafeRunStateResult<S1>(s: S1): <W, S2, A>(ma: import("./definition.js").Pure<W, S1, S2, never, never, A>) => A;
+/**
+ * Runs this computation returning either the result or error
+ * @tsplus getter fncts.control.Pure unsafeRunExit
+ * @tsplus location "@fncts/base/control/Pure/runtime"
+ */
+export declare function unsafeRunExit<E, A>(ma: Pure<never, unknown, unknown, never, E, A>): Exit<E, A>;
+/**
+ * @tsplus getter fncts.control.Pure unsafeRunWriter
+ * @tsplus location "@fncts/base/control/Pure/runtime"
+ */
+export declare function unsafeRunWriter<W, A>(ma: Pure<W, unknown, unknown, never, never, A>): readonly [Conc<W>, A];

package/control/Pure.d.ts

@@ -0,0 +1,4 @@
+export * from "./Pure/api.js";
+export * from "./Pure/definition.js";
+export * from "./Pure/instances.js";
+export * from "./Pure/runtime.js";

package/control.d.ts

@@ -1,4 +1,4 @@
 export type {} from "./control/CompletablePromise.js";
 export type {} from "./control/Eval.js";
 export type {} from "./control/LazyValue.js";
-export type {} from "./control/Z.js";
+export type {} from "./control/Pure.js";

package/data/Cause/api.d.ts

@@ -7,7 +7,7 @@ import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
 import { FiberId } from "@fncts/base/data/FiberId/definition";
 import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
-import { Both, Cause, Fail, Halt, Interrupt, Then } from "./definition.js";
+import { Cause, Fail, Halt, Interrupt, Parallel, Sequential } from "./definition.js";
 /**
  * @tsplus pipeable fncts.Cause as
  * @tsplus location "@fncts/base/data/Cause/api"
@@ -16,11 +16,11 @@ export declare function as<B>(b: Lazy<B>): <A>(self: Cause<A>) => Cause<B>;
 /**
  * Constructs a `Cause` from two `Cause`s, representing parallel failures.
  * @note If one of the `Cause`s is `Empty`, the non-empty `Cause` is returned
- * @tsplus static fncts.CauseOps both
- * @tsplus static fncts.Cause.BothOps __call
+ * @tsplus static fncts.CauseOps parallel
+ * @tsplus static fncts.Cause.ParallelOps __call
  * @tsplus location "@fncts/base/data/Cause/api"
  */
-export declare function both<E, E1>(left: Cause<E>, right: Cause<E1>): Cause<E | E1>;
+export declare function parallel<E, E1>(left: Cause<E>, right: Cause<E1>): Cause<E | E1>;
 /**
  * Composes computations in sequence, using the return value of one computation as input for the next
  * @tsplus pipeable fncts.Cause flatMap
@@ -164,7 +164,7 @@ export declare function interrupt(id: FiberId, trace?: Trace): Cause<never>;
  * @tsplus fluent fncts.Cause isBoth
  * @tsplus location "@fncts/base/data/Cause/api"
  */
-export declare function isBoth<E>(self: Cause<E>): self is Both<E>;
+export declare function isBoth<E>(self: Cause<E>): self is Parallel<E>;
 /**
  * A type-guard matching `Fail`
  * @tsplus fluent fncts.Cause isFail
@@ -181,7 +181,7 @@ export declare function isHalt<E>(self: Cause<E>): self is Halt;
  * @tsplus fluent fncts.Cause isThen
  * @tsplus location "@fncts/base/data/Cause/api"
  */
-export declare function isThen<E>(self: Cause<E>): self is Then<E>;
+export declare function isThen<E>(self: Cause<E>): self is Sequential<E>;
 /**
  * A type-guard matching `Interrupt`
  * @tsplus fluent fncts.Cause isInterrupt
@@ -297,11 +297,11 @@ export declare function squashWith<E>(f: (e: E) => unknown): (self: Cause<E>) =>
 /**
  * Constructs a `Cause` from two `Cause`s, representing sequential failures.
  * @note If one of the `Cause`s is `Empty`, the non-empty `Cause` is returned
- * @tsplus static fncts.CauseOps then
- * @tsplus static fncts.Cause.ThenOps __call
+ * @tsplus static fncts.CauseOps sequential
+ * @tsplus static fncts.Cause.SequentialOps __call
  * @tsplus location "@fncts/base/data/Cause/api"
  */
-export declare function then<E, E1>(left: Cause<E>, right: Cause<E1>): Cause<E | E1>;
+export declare function sequential<E, E1>(left: Cause<E>, right: Cause<E1>): Cause<E | E1>;
 /**
  * Constructs a `Cause` from a `Cause` and a stack trace.
  * @note If the stack trace is empty, the original `Cause` is returned.