@fncts/base 0.0.28 → 0.0.30

package/control/Z/definition.d.ts

@@ -1,151 +0,0 @@
-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 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 ZVariance: unique symbol;
-export type ZVariance = typeof ZVariance;
-export declare const ZTypeId: unique symbol;
-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 declare abstract class Z<W, S1, S2, R, E, A> {
-    readonly [ZTypeId]: ZTypeId;
-    [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 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"
- */
-export declare function isZ(u: unknown): u is Z<unknown, unknown, unknown, unknown, unknown, unknown>;
-export declare 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 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, never, never, A> {
-    readonly effect: () => A;
-    readonly _tag = ZTag.Succeed;
-    constructor(effect: () => A);
-}
-export declare class Defer<W, S1, S2, R, E, A> extends Z<W, S1, S2, R, E, A> {
-    readonly make: () => 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, 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, never, never, A> {
-    readonly run: (s1: S1) => readonly [A, S2];
-    readonly _tag = ZTag.Modify;
-    constructor(run: (s1: S1) => readonly [A, S2]);
-}
-export declare 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 ma: Z<W, S1, S2, R, E, A>;
-    readonly f: (a: A) => Z<W1, S2, S3, Q, D, B>;
-    readonly _tag = ZTag.Chain;
-    constructor(ma: Z<W, S1, S2, R, E, A>, f: (a: A) => Z<W1, S2, S3, Q, D, B>);
-}
-export declare 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 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>;
-    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 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, never, E, A> {
-    readonly ma: Z<W, S1, S2, R, E, A>;
-    readonly env: Environment<R>;
-    readonly _tag = ZTag.Provide;
-    constructor(ma: Z<W, S1, S2, R, E, A>, env: Environment<R>);
-}
-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>);
-}
-export declare class MapLog<W, S1, S2, R, E, A, W1> extends Z<W1, S1, S2, R, E, A> {
-    readonly ma: Z<W, S1, S2, R, E, A>;
-    readonly modifyLog: (ws: Conc<W>) => Conc<W1>;
-    readonly _tag = ZTag.MapLog;
-    constructor(ma: Z<W, S1, S2, R, E, A>, modifyLog: (ws: Conc<W>) => Conc<W1>);
-}
-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
- * @tsplus location "@fncts/base/control/Z/definition"
- */
-export declare function concrete(_: Z<any, any, any, any, any, any>): asserts _ is Concrete;
-export declare const ZErrorTypeId: unique symbol;
-export type ZErrorTypeId = typeof ZErrorTypeId;
-export declare class ZError<E> {
-    readonly cause: Cause<E>;
-    readonly [ZErrorTypeId]: ZErrorTypeId;
-    constructor(cause: Cause<E>);
-}
-export declare function isZError(u: unknown): u is ZError<unknown>;

package/control/Z/instances.d.ts

@@ -1,8 +0,0 @@
-import type * as P from "../../typeclass.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<ZF, import("@fncts/typelevel/HKT.js").HKT.None>;

package/control/Z/runtime.d.ts

@@ -1,56 +0,0 @@
-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
- * failure or the updated state and the result
- * @tsplus pipeable fncts.control.Z unsafeRunAll
- * @tsplus location "@fncts/base/control/Z/runtime"
- */
-export declare function unsafeRunAll<S1>(s: S1): <W, S2, E, A>(ma: import("./definition.js").Z<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.Z unsafeRun
- * @tsplus location "@fncts/base/control/Z/runtime"
- */
-export declare function unsafeRun<S1>(s: S1): <W, S2, A>(ma: import("./definition.js").Z<W, S1, S2, never, never, A>) => 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, never, never, A>): A;
-/**
- * Runs this computation with the given environment, returning the result.
- * @tsplus pipeable fncts.control.Z unsafeRunReader
- * @tsplus location "@fncts/base/control/Z/runtime"
- */
-export declare function unsafeRunReader<R>(r: Environment<R>): <W, A>(ma: import("./definition.js").Z<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.Z unsafeRunState
- * @tsplus location "@fncts/base/control/Z/runtime"
- */
-export declare function unsafeRunState<S1>(s: S1): <W, S2, A>(ma: import("./definition.js").Z<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.Z unsafeRunStateResult
- * @tsplus location "@fncts/base/control/Z/runtime"
- */
-export declare function unsafeRunStateResult<S1>(s: S1): <W, S2, A>(ma: import("./definition.js").Z<W, S1, S2, never, never, A>) => 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, 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, never, never, A>): readonly [Conc<W>, A];

package/control/Z.d.ts

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