@fncts/base 0.0.29 → 0.0.30

package/_src/control/Z/definition.ts

@@ -1,199 +0,0 @@
-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 const ZVariance = Symbol.for("fncts.Z.Variance");
-export type ZVariance = typeof ZVariance;
-
-export const ZTypeId = Symbol.for("fncts.Z");
-export type ZTypeId = typeof ZTypeId;
-
-/**
- * `Z<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.
- *
- * @note named `Z` in honor of `ZIO` and because it is, surely, the last synchronous effect type
- * one will ever need
- *
- * @tsplus type fncts.control.Z
- * @tsplus companion fncts.control.ZOps
- */
-export abstract class Z<W, S1, S2, R, E, A> {
-  readonly [ZTypeId]: ZTypeId = ZTypeId;
-  declare [ZVariance]: {
-    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.Z
- */
-export 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
-> {
-  return _;
-}
-
-/**
- * @tsplus static fncts.control.ZOps isZ
- */
-export function isZ(u: unknown): u is Z<unknown, unknown, unknown, unknown, unknown, unknown> {
-  return isObject(u) && ZTypeId in u;
-}
-
-export const enum ZTag {
-  SucceedNow = "SucceedNow",
-  Succeed = "Succeed",
-  Defer = "Defer",
-  Fail = "Fail",
-  Modify = "Modify",
-  Chain = "Chain",
-  Match = "Match",
-  Access = "Access",
-  Provide = "Provide",
-  Tell = "Tell",
-  Listen = "Listen",
-  MapLog = "MapLog",
-}
-
-export class SucceedNow<A> extends Z<never, unknown, never, never, never, A> {
-  readonly _tag = ZTag.SucceedNow;
-  constructor(readonly value: A) {
-    super();
-  }
-}
-
-export class Succeed<A> extends Z<never, unknown, never, never, never, A> {
-  readonly _tag = ZTag.Succeed;
-  constructor(readonly effect: () => A) {
-    super();
-  }
-}
-
-export class Defer<W, S1, S2, R, E, A> extends Z<W, S1, S2, R, E, A> {
-  readonly _tag = ZTag.Defer;
-  constructor(readonly make: () => Z<W, S1, S2, R, E, A>) {
-    super();
-  }
-}
-
-export class Fail<E> extends Z<never, unknown, never, never, E, never> {
-  readonly _tag = ZTag.Fail;
-  constructor(readonly cause: Cause<E>) {
-    super();
-  }
-}
-
-export class Modify<S1, S2, A> extends Z<never, S1, S2, never, never, A> {
-  readonly _tag = ZTag.Modify;
-  constructor(readonly run: (s1: S1) => readonly [A, S2]) {
-    super();
-  }
-}
-
-export class Chain<W, S1, S2, R, E, A, W1, S3, Q, D, B> extends Z<W | W1, S1, S3, Q & R, D | E, B> {
-  readonly _tag = ZTag.Chain;
-  constructor(readonly ma: Z<W, S1, S2, R, E, A>, readonly f: (a: A) => Z<W1, S2, S3, Q, D, B>) {
-    super();
-  }
-}
-
-export class Match<W, S1, S2, S5, R, E, A, W1, S3, R1, E1, B, W2, S4, R2, E2, C> extends Z<
-  W1 | W2,
-  S1 & S5,
-  S3 | S4,
-  R & R1 & R2,
-  E1 | E2,
-  B | C
-> {
-  readonly _tag = ZTag.Match;
-  constructor(
-    readonly z: Z<W, S1, S2, R, E, A>,
-    readonly onFailure: (ws: Conc<W>, e: Cause<E>) => Z<W1, S5, S3, R1, E1, B>,
-    readonly onSuccess: (ws: Conc<W>, a: A) => Z<W2, S2, S4, R2, E2, C>,
-  ) {
-    super();
-  }
-}
-
-export class Access<W, R0, S1, S2, R, E, A> extends Z<W, S1, S2, R0 | R, E, A> {
-  readonly _tag = ZTag.Access;
-  constructor(readonly asks: (r: Environment<R0>) => Z<W, S1, S2, R, E, A>) {
-    super();
-  }
-}
-
-export class Provide<W, S1, S2, R, E, A> extends Z<W, S1, S2, never, E, A> {
-  readonly _tag = ZTag.Provide;
-  constructor(readonly ma: Z<W, S1, S2, R, E, A>, readonly env: Environment<R>) {
-    super();
-  }
-}
-
-export class Tell<W> extends Z<W, unknown, never, never, never, void> {
-  readonly _tag = ZTag.Tell;
-  constructor(readonly log: Conc<W>) {
-    super();
-  }
-}
-
-export class MapLog<W, S1, S2, R, E, A, W1> extends Z<W1, S1, S2, R, E, A> {
-  readonly _tag = ZTag.MapLog;
-  constructor(readonly ma: Z<W, S1, S2, R, E, A>, readonly modifyLog: (ws: Conc<W>) => Conc<W1>) {
-    super();
-  }
-}
-
-export 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
- */
-export function concrete(_: Z<any, any, any, any, any, any>): asserts _ is Concrete {
-  //
-}
-
-export const ZErrorTypeId = Symbol.for("fncts.Z.ZError");
-export type ZErrorTypeId = typeof ZErrorTypeId;
-
-export class ZError<E> {
-  readonly [ZErrorTypeId]: ZErrorTypeId = ZErrorTypeId;
-  constructor(readonly cause: Cause<E>) {}
-}
-
-export function isZError(u: unknown): u is ZError<unknown> {
-  return isObject(u) && ZErrorTypeId in u;
-}

package/_src/control/Z.ts

@@ -1,6 +0,0 @@
-// codegen:start { preset: barrel, include: ./Z/*.ts }
-export * from "./Z/api.js";
-export * from "./Z/definition.js";
-export * from "./Z/instances.js";
-export * from "./Z/runtime.js";
-// codegen:end

package/control/Z/api.d.ts

@@ -1,345 +0,0 @@
-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"
- */
-export declare function absolve<W, S1, S2, R, E, E1, A>(fa: Z<W, S1, S2, R, E, Either<E1, A>>): Z<W, S1, S2, R, E | E1, A>;
-/**
- * @tsplus pipeable fncts.control.Z ap
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function ap<W, S, A, R1, E1>(fb: Z<W, S, S, R1, E1, A>): <R, E, B>(self: import("./definition.js").Z<W, S, S, R, E, (a: A) => B>) => import("./definition.js").Z<W, S, S, R & R1, E1 | E, B>;
-/**
- * @tsplus pipeable fncts.control.Z zipLeft
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function zipLeft<W, S, R1, E1, B>(fb: Z<W, S, S, R1, E1, B>): <R, E, A>(fa: import("./definition.js").Z<W, S, S, R, E, A>) => import("./definition.js").Z<W, S, S, R & R1, E1 | E, A>;
-/**
- * @tsplus pipeable fncts.control.Z zipRight
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function zipRight<W, S, R1, E1, B>(fb: Z<W, S, S, R1, E1, B>): <R, E, A>(fa: import("./definition.js").Z<W, S, S, R, E, A>) => import("./definition.js").Z<W, S, S, R & R1, E1 | E, B>;
-/**
- * @tsplus pipeable fncts.control.Z bimap
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function bimap<E, A, G, B>(f: (e: E) => G, g: (a: A) => B): <W, S1, S2, R>(pab: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W, S1, S2, R, G, B>;
-/**
- * Recovers from all errors.
- * @tsplus pipeable fncts.control.Z catchAll
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function catchAll<W, S1, E, S3, R1, E1, B>(onFailure: (e: E) => Z<W, S1, S3, R1, E1, B>): <S2, R, A>(fa: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W, S1, S3, R1 | R, E1, B | A>;
-/**
- * @tsplus pipeable fncts.control.Z catchJust
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function catchJust<W, S1, E, S3, R1, E1, B>(f: (e: E) => Maybe<Z<W, S1, S3, R1, E1, B>>): <S2, R, A>(fa: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W, S1, S3 | S2, R1 | R, E | E1, B | A>;
-/**
- * @tsplus pipeable fncts.control.Z flatMap
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function flatMap<S2, A, W1, S3, R1, E1, B>(f: (a: A) => Z<W1, S2, S3, R1, E1, B>): <W, S1, R, E>(ma: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W1 | W, S1, S3, R1 & R, E1 | E, B>;
-/**
- * @tsplus pipeable fncts.control.Z contramapEnvironment
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function contramapEnvironment<R0, R>(f: (r0: Environment<R0>) => Environment<R>): <W, S1, S2, E, A>(ma: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W, S1, S2, R0, E, A>;
-/**
- * Transforms the initial state of this computation` with the specified
- * function.
- * @tsplus pipeable fncts.control.Z contramapState
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function contramapState<S0, S1>(f: (s: S0) => S1): <W, S2, R, E, A>(fa: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W, S0, S2, R, E, A>;
-/**
- * @tsplus pipeable fncts.control.Z cross
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function cross<W, S, R1, E1, B>(fb: Z<W, S, S, R1, E1, B>): <R, E, A>(fa: import("./definition.js").Z<W, S, S, R, E, A>) => import("./definition.js").Z<W, S, S, R & R1, E1 | E, readonly [A, B]>;
-/**
- * @tsplus pipeable fncts.control.Z crossWith
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function crossWith<W, S, A, R1, E1, B, C>(fb: Z<W, S, S, R1, E1, B>, f: (a: A, b: B) => C): <R, E>(fa: import("./definition.js").Z<W, S, S, R, E, A>) => import("./definition.js").Z<W, S, S, R & R1, E1 | E, C>;
-/**
- * @tsplus static fncts.control.ZOps defer
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function defer<W, S1, S2, R, E, A>(ma: Lazy<Z<W, S1, S2, R, E, A>>, __tsplusTrace?: string): Z<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.Z either
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function either<W, S1, S2, R, E, A>(fa: Z<W, S1, S2, R, E, A>): Z<W, S1, S1 | S2, R, never, Either<E, A>>;
-/**
- * @tsplus static fncts.control.ZOps environment
- * @tsplus location "@fncts/base/control/Z/api"
- */
-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: 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: 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
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function erase<W, S1, S2, R, E, A>(wa: Z<W, S1, S2, R, E, A>): Z<never, S1, S2, R, E, A>;
-/**
- * @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, 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, 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, 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, never, E, never>;
-/**
- * @tsplus getter fncts.control.Z flatten
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function flatten<W, S1, S2, R, E, A, W1, S3, R1, E1>(mma: Z<W, S1, S2, R, E, Z<W1, S2, S3, R1, E1, A>>): Z<W | W1, S1, S3, R1 & R, E1 | E, A>;
-/**
- * Constructs a computation that returns the initial state unchanged.
- * @tsplus static fncts.control.ZOps get
- * @tsplus location "@fncts/base/control/Z/api"
- */
-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, never, never, A>;
-/**
- * @tsplus static fncts.control.ZOps getsZ
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function getsZ<S, W, R, E, A>(f: (s: S) => Z<W, S, S, R, E, A>): 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, 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, never, never, never>;
-/**
- * @tsplus getter fncts.control.Z listen
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function listen<W, S1, S2, R, E, A>(wa: Z<W, S1, S2, R, E, A>): Z<W, S1, S2, R, E, readonly [A, Conc<W>]>;
-/**
- * @tsplus pipeable fncts.control.Z listens
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function listens<W, B>(f: (log: Conc<W>) => B): <S1, S2, R, E, A>(wa: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W, S1, S2, R, E, readonly [A, B]>;
-/**
- * @tsplus pipeable fncts.control.Z map
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function map<A, B>(f: (a: A) => B): <W, S1, S2, R, E>(fa: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W, S1, S2, R, E, B>;
-/**
- * @tsplus pipeable fncts.control.Z mapError
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function mapError<E, G>(f: (e: E) => G): <W, S1, S2, R, A>(pab: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W, S1, S2, R, G, A>;
-/**
- * Modifies the current log with the specified function
- * @tsplus pipeable fncts.control.Z mapLog
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function mapLog<W, W1>(f: (ws: Conc<W>) => Conc<W1>): <S1, S2, R, E, A>(wa: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W1, S1, S2, R, E, A>;
-/**
- * Modifies the current state with the specified function
- * @tsplus pipeable fncts.control.Z mapState
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function mapState<S2, S3>(f: (s: S2) => S3): <W, S1, R, E, A>(ma: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<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.Z match
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function match<E, A, B, C>(onFailure: (e: E) => B, onSuccess: (a: A) => C): <W, S1, S2, R>(fa: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<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.Z matchZ
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function matchZ<S5, S2, E, A, W1, S3, R1, E1, B, W2, S4, R2, E2, C>(onFailure: (e: E) => Z<W1, S5, S3, R1, E1, B>, onSuccess: (a: A) => Z<W2, S2, S4, R2, E2, C>): <W, S1, R>(fa: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W1 | W2 | W, S1 & S5, S3 | S4, R1 | R2 | R, E1 | E2, B | C>;
-/**
- * @tsplus pipeable fncts.control.Z matchCauseZ
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function matchCauseZ<S2, E, A, W1, S0, S3, R1, E1, B, W2, S4, R2, E2, C>(onFailure: (e: Cause<E>) => Z<W1, S0, S3, R1, E1, B>, onSuccess: (a: A) => Z<W2, S2, S4, R2, E2, C>): <W, S1, R>(fa: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W1 | W2 | W, S0 & S1, S3 | S4, R1 | R2 | R, E1 | E2, B | C>;
-/**
- * @tsplus pipeable fncts.control.Z matchLogZ
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function matchLogZ<W, S5, S2, E, A, W1, S3, R1, E1, B, W2, S4, R2, E2, C>(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>): <S1, R>(fa: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<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.Z matchLogCauseZ
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function matchLogCauseZ<W, S2, E, A, W1, S0, S3, R1, E1, B, W2, S4, R2, E2, C>(onFailure: (ws: Conc<W>, e: Cause<E>) => Z<W1, S0, S3, R1, E1, B>, onSuccess: (ws: Conc<W>, a: A) => Z<W2, S2, S4, R2, E2, C>): <S1, R>(fa: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<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.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, 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, never, E, A>;
-/**
- * @tsplus pipeable fncts.control.Z orElse
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function orElse<S1, W1, S3, R1, E1, A1>(fb: Lazy<Z<W1, S1, S3, R1, E1, A1>>): <W, S2, R, E, A>(fa: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<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.Z orElseEither
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function orElseEither<W, S3, S4, R1, E1, A1>(that: Lazy<Z<W, S3, S4, R1, E1, A1>>): <S1, S2, R, E, A>(fa: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W, S1 & S3, S4 | S2, R1 | R, E1, import("../../data/Either.js").Either<A, A1>>;
-/**
- * @tsplus pipeable fncts.control.Z provideEnvironment
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function provideEnvironment<R>(r: Environment<R>): <W, S1, S2, E, A>(fa: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").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, 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.Z repeatN
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function repeatN(n: number): <W, S1, S2 extends S1, R, E, A>(ma: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<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.Z repeatUntil
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function repeatUntil<A>(p: Predicate<A>): <W, S1, S2 extends S1, R, E>(ma: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W, S1, S2, R, E, A>;
-/**
- * @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, 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, never, never, A>;
-/**
- * @tsplus pipeable fncts.control.Z tap
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function tap<S2, A, W1, S3, R1, E1, B>(f: (a: A) => Z<W1, S2, S3, R1, E1, B>): <W, S1, R, E>(ma: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W1 | W, S1, S3, R1 & R, E1 | E, A>;
-/**
- * @tsplus static fncts.control.ZOps tell
- * @tsplus location "@fncts/base/control/Z/api"
- */
-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, never, never, void>;
-/**
- * Like `map`, but also allows the state to be modified.
- * @tsplus pipeable fncts.control.Z transform
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function transform<S2, A, S3, B>(f: (s: S2, a: A) => readonly [B, S3]): <W, S1, R, E>(ma: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W, S1, S3, R, E, B>;
-/**
- * @tsplus static fncts.control.ZOps unit
- * @tsplus location "@fncts/base/control/Z/api"
- */
-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, never, never, void>;
-/**
- * @tsplus pipeable fncts.control.Z write
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function write<W1>(w: W1): <W, S1, S2, R, E, A>(ma: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W1 | W, S1, S2, R, E, A>;
-/**
- * @tsplus pipeable fncts.control.Z writeAll
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function writeAll<W1>(log: Conc<W1>): <W, S1, S2, R, E, A>(ma: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W1 | W, S1, S2, R, E, A>;
-/**
- * @tsplus pipeable fncts.control.Z zip
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function zip<S2, W1, S3, Q, D, B>(fb: Z<W1, S2, S3, Q, D, B>): <W, S1, R, E, A>(fa: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W1 | W, S1, S3, Q & R, D | E, import("../../data/Zipped.js").Zipped.Make<A, B>>;
-/**
- * @tsplus pipeable fncts.control.Z zipFirst
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function zipFirst<S2, W1, S3, Q, D, B>(fb: Z<W1, S2, S3, Q, D, B>): <W, S1, R, E, A>(fa: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W1 | W, S1, S3, Q & R, D | E, A>;
-/**
- * @tsplus pipeable fncts.control.Z zipSecond
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function zipSecond<S2, W1, S3, Q, D, B>(fb: Z<W1, S2, S3, Q, D, B>): <W, S1, R, E, A>(fa: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W1 | W, S1, S3, Q & R, D | E, B>;
-/**
- * @tsplus pipeable fncts.control.Z zipWith
- * @tsplus location "@fncts/base/control/Z/api"
- */
-export declare function zipWith<S2, A, W1, S3, R1, E1, B, C>(fb: Z<W1, S2, S3, R1, E1, B>, f: (a: A, b: B) => C): <W, S1, R, E>(fa: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W1 | W, S1, S3, R1 & R, E1 | E, C>;