@fncts/base 0.0.32 → 0.0.34

package/control/Pure/api.d.ts

@@ -16,60 +16,60 @@ export declare function absolve<W, S1, S2, R, E, E1, A>(fa: Pure<W, S1, S2, R, E
  * @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>;
+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>) => Pure<W, S, S, R & R1, E | E1, 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>;
+export declare function zipLeft<W, S, R1, E1, B>(fb: Pure<W, S, S, R1, E1, B>): <R, E, A>(fa: Pure<W, S, S, R, E, A>) => Pure<W, S, S, R & R1, E | E1, 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>;
+export declare function zipRight<W, S, R1, E1, B>(fb: Pure<W, S, S, R1, E1, B>): <R, E, A>(fa: Pure<W, S, S, R, E, A>) => Pure<W, S, S, R & R1, E | E1, 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>;
+export declare function bimap<E, A, G, B>(f: (e: E) => G, g: (a: A) => B): <W, S1, S2, R>(pab: Pure<W, S1, S2, R, E, A>) => 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>;
+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: Pure<W, S1, S2, R, E, A>) => Pure<W, S1, S3, R | R1, E1, A | B>;
 /**
  * @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>;
+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: Pure<W, S1, S2, R, E, A>) => Pure<W, S1, S2 | S3, R | R1, E | E1, A | B>;
 /**
  * @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>;
+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: Pure<W, S1, S2, R, E, A>) => Pure<W | W1, 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>;
+export declare function contramapEnvironment<R0, R>(f: (r0: Environment<R0>) => Environment<R>): <W, S1, S2, E, A>(ma: Pure<W, S1, S2, R, E, A>) => 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>;
+export declare function contramapState<S0, S1>(f: (s: S0) => S1): <W, S2, R, E, A>(fa: Pure<W, S1, S2, R, E, A>) => 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]>;
+export declare function cross<W, S, R1, E1, B>(fb: Pure<W, S, S, R1, E1, B>): <R, E, A>(fa: Pure<W, S, S, R, E, A>) => Pure<W, S, S, R & R1, E | E1, 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>;
+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: Pure<W, S, S, R, E, A>) => Pure<W, S, S, R & R1, E | E1, C>;
 /**
  * @tsplus static fncts.control.PureOps defer
  * @tsplus location "@fncts/base/control/Pure/api"
@@ -164,29 +164,29 @@ export declare function listen<W, S1, S2, R, E, A>(wa: Pure<W, S1, S2, R, E, A>)
  * @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]>;
+export declare function listens<W, B>(f: (log: Conc<W>) => B): <S1, S2, R, E, A>(wa: Pure<W, S1, S2, R, E, A>) => 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>;
+export declare function map<A, B>(f: (a: A) => B): <W, S1, S2, R, E>(fa: Pure<W, S1, S2, R, E, A>) => 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>;
+export declare function mapError<E, G>(f: (e: E) => G): <W, S1, S2, R, A>(pab: Pure<W, S1, S2, R, E, A>) => 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>;
+export declare function mapLog<W, W1>(f: (ws: Conc<W>) => Conc<W1>): <S1, S2, R, E, A>(wa: Pure<W, S1, S2, R, E, A>) => 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>;
+export declare function mapState<S2, S3>(f: (s: S2) => S3): <W, S1, R, E, A>(ma: Pure<W, S1, S2, R, E, A>) => 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
@@ -194,24 +194,24 @@ export declare function mapState<S2, S3>(f: (s: S2) => S3): <W, S1, R, E, A>(ma:
  * @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>;
+export declare function match<E, A, B, C>(onFailure: (e: E) => B, onSuccess: (a: A) => C): <W, S1, S2, R>(fa: Pure<W, S1, S2, R, E, A>) => 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>;
+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: Pure<W, S1, S2, R, E, A>) => Pure<W | W1 | W2, S1 & S5, S3 | S4, R | R1 | R2, 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>;
+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: Pure<W, S1, S2, R, E, A>) => Pure<W | W1 | W2, S0 & S1, S3 | S4, R | R1 | R2, 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>;
+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: Pure<W, S1, S2, R, E, A>) => Pure<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
@@ -221,7 +221,7 @@ export declare function matchLogPure<W, S5, S2, E, A, W1, S3, R1, E1, B, W2, S4,
  * @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>;
+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: Pure<W, S1, S2, R, E, A>) => 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
@@ -238,19 +238,19 @@ export declare function modifyEither<S1, S2, E, A>(f: (s: S1) => Either<E, reado
  * @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>;
+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: Pure<W, S1, S2, R, E, A>) => Pure<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 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>>;
+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: Pure<W, S1, S2, R, E, A>) => Pure<W, S1 & S3, S2 | S4, R | R1, E1, 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>;
+export declare function provideEnvironment<R>(r: Environment<R>): <W, S1, S2, E, A>(fa: Pure<W, S1, S2, R, E, A>) => Pure<W, S1, S2, never, E, A>;
 /**
  * Constructs a computation that sets the state to the specified value.
  * @tsplus static fncts.control.PureOps put
@@ -263,14 +263,14 @@ export declare function put<S>(s: S): Pure<never, unknown, S, never, never, void
  * @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>;
+export declare function repeatN(n: number): <W, S1, S2 extends S1, R, E, A>(ma: Pure<W, S1, S2, R, E, A>) => 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>;
+export declare function repeatUntil<A>(p: Predicate<A>): <W, S1, S2 extends S1, R, E>(ma: Pure<W, S1, S2, R, E, A>) => Pure<W, S1, S2, R, E, A>;
 /**
  * @tsplus static fncts.control.PureOps succeed
  * @tsplus location "@fncts/base/control/Pure/api"
@@ -285,7 +285,7 @@ export declare function succeedNow<A, W = never, S1 = unknown, S2 = never>(a: 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>;
+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: Pure<W, S1, S2, R, E, A>) => Pure<W | W1, S1, S3, R1 & R, E1 | E, A>;
 /**
  * @tsplus static fncts.control.PureOps tell
  * @tsplus location "@fncts/base/control/Pure/api"
@@ -301,7 +301,7 @@ export declare function tellAll<W>(ws: Conc<W>): Pure<W, unknown, never, never,
  * @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>;
+export declare function transform<S2, A, S3, B>(f: (s: S2, a: A) => readonly [B, S3]): <W, S1, R, E>(ma: Pure<W, S1, S2, R, E, A>) => Pure<W, S1, S3, R, E, B>;
 /**
  * @tsplus static fncts.control.PureOps unit
  * @tsplus location "@fncts/base/control/Pure/api"
@@ -317,29 +317,29 @@ export declare function update<S1, S2>(f: (s: S1) => S2): Pure<never, S1, S2, ne
  * @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>;
+export declare function write<W1>(w: W1): <W, S1, S2, R, E, A>(ma: Pure<W, S1, S2, R, E, A>) => Pure<W | W1, 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>;
+export declare function writeAll<W1>(log: Conc<W1>): <W, S1, S2, R, E, A>(ma: Pure<W, S1, S2, R, E, A>) => Pure<W | W1, 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>>;
+export declare function zip<S2, W1, S3, Q, D, B>(fb: Pure<W1, S2, S3, Q, D, B>): <W, S1, R, E, A>(fa: Pure<W, S1, S2, R, E, A>) => Pure<W | W1, S1, S3, Q & R, D | E, 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>;
+export declare function zipFirst<S2, W1, S3, Q, D, B>(fb: Pure<W1, S2, S3, Q, D, B>): <W, S1, R, E, A>(fa: Pure<W, S1, S2, R, E, A>) => Pure<W | W1, 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>;
+export declare function zipSecond<S2, W1, S3, Q, D, B>(fb: Pure<W1, S2, S3, Q, D, B>): <W, S1, R, E, A>(fa: Pure<W, S1, S2, R, E, A>) => Pure<W | W1, 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>;
+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: Pure<W, S1, S2, R, E, A>) => Pure<W | W1, S1, S3, R1 & R, E1 | E, C>;

package/control/Pure/runtime.d.ts

@@ -9,14 +9,14 @@ import { Cause } from "@fncts/base/data/Cause/definition";
  * @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]>];
+export declare function unsafeRunAll<S1>(s: S1): <W, S2, E, A>(ma: Pure<W, S1, S2, never, E, A>) => 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 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];
+export declare function unsafeRun<S1>(s: S1): <W, S2, A>(ma: Pure<W, S1, S2, never, never, A>) => readonly [S2, A];
 /**
  * Runs this computation, returning the result.
  * @tsplus getter fncts.control.Pure unsafeRunResult
@@ -28,21 +28,21 @@ export declare function unsafeRunResult<W, A>(ma: Pure<W, unknown, unknown, neve
  * @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;
+export declare function unsafeRunReader<R>(r: Environment<R>): <W, A>(ma: 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;
+export declare function unsafeRunState<S1>(s: S1): <W, S2, A>(ma: 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;
+export declare function unsafeRunStateResult<S1>(s: S1): <W, S2, A>(ma: Pure<W, S1, S2, never, never, A>) => A;
 /**
  * Runs this computation returning either the result or error
  * @tsplus getter fncts.control.Pure unsafeRunExit

package/control/Pure.d.ts

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

package/control.d.ts

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

package/data/Cause/api.d.ts

@@ -101,7 +101,7 @@ export declare function failureMaybe<E>(self: Cause<E>): Maybe<E>;
  * @tsplus pipeable fncts.Cause filterDefects
  * @tsplus location "@fncts/base/data/Cause/api"
  */
-export declare function filterDefects(p: Predicate<unknown>): <E>(self: Cause<E>) => import("../Maybe.js").Maybe<Cause<E>>;
+export declare function filterDefects(p: Predicate<unknown>): <E>(self: Cause<E>) => Maybe<Cause<E>>;
 /**
  * Finds the first result matching `f`
  * @tsplus pipeable fncts.Cause find
@@ -274,7 +274,7 @@ export declare function stripFailures<A>(self: Cause<A>): Cause<never>;
  * @tsplus pipeable fncts.Cause stripSomeDefects
  * @tsplus location "@fncts/base/data/Cause/api"
  */
-export declare function stripSomeDefects(p: Predicate<unknown>): <E>(self: Cause<E>) => import("../Maybe.js").Maybe<Cause<E>>;
+export declare function stripSomeDefects(p: Predicate<unknown>): <E>(self: Cause<E>) => Maybe<Cause<E>>;
 /**
  * Converts the specified `Cause<Either<E, A>>` to an `Either<Cause<E>, A>`.
  * @tsplus getter fncts.Cause sequenceCauseEither
@@ -299,6 +299,7 @@ export declare function squashWith<E>(f: (e: E) => unknown): (self: Cause<E>) =>
  * @note If one of the `Cause`s is `Empty`, the non-empty `Cause` is returned
  * @tsplus static fncts.CauseOps sequential
  * @tsplus static fncts.Cause.SequentialOps __call
+ * @tsplus operator fncts.Cause +
  * @tsplus location "@fncts/base/data/Cause/api"
  */
 export declare function sequential<E, E1>(left: Cause<E>, right: Cause<E1>): Cause<E | E1>;

package/data/Cause.d.ts

@@ -1,7 +1,7 @@
-export * from "./Cause/api.js";
 export * from "./Cause/definition.js";
-export * from "./Cause/api/fold.js";
-export * from "./Cause/api/isEmpty.js";
-export * from "./Cause/api/linearize.js";
-export * from "./Cause/api/prettyPrint.js";
+export * from "./Cause/api.js";
 export * from "./Cause/api/unified.js";
+export * from "./Cause/api/prettyPrint.js";
+export * from "./Cause/api/linearize.js";
+export * from "./Cause/api/isEmpty.js";
+export * from "./Cause/api/fold.js";

package/data/Const.d.ts

@@ -1,3 +1,3 @@
-export * from "./Const/api.js";
-export * from "./Const/definition.js";
 export * from "./Const/instances.js";
+export * from "./Const/definition.js";
+export * from "./Const/api.js";

package/data/Data.d.ts

@@ -0,0 +1,31 @@
+import { Equatable } from "@fncts/base/data/Equatable";
+import { Hashable } from "@fncts/base/data/Hashable";
+import { isObject } from "@fncts/base/util/predicates";
+import type { Equals } from "@fncts/typelevel/Any";
+import type { True } from "@fncts/typelevel/Boolean";
+export interface Copy<T> {
+    copy(args: Equals<T, {}> extends True ? void : Partial<T>): this;
+}
+export interface DataClassConstructor {
+    new <T>(args: Equals<T, {}> extends True ? void : {
+        readonly [P in keyof T as P extends keyof Equatable ? never : P]: T[P];
+    }): Readonly<T> & Copy<T>;
+}
+export declare const DataClass: DataClassConstructor;
+export interface TaggedDataClassConstructor<Tag extends string | symbol, K extends string | symbol> {
+    new <T extends Record<string, any> = {}>(args: Equals<T, {}> extends True ? void : T): {
+        readonly [P in keyof T as P extends Tag ? never : P]: T[P];
+    } & Copy<T> & {
+        readonly [k in K]: Tag;
+    };
+}
+export declare const TaggedClass: <Tag extends string | symbol, Key extends string | symbol = "_tag">(tag: Tag, key?: Key) => TaggedDataClassConstructor<Tag, Key>;
+export declare function struct<As extends Readonly<Record<string, any>>>(as: As): As;
+export declare const Error: new <A extends Record<string, any> = {}>(args: Equals<A, {}> extends True ? void : {
+    readonly [P in keyof A]: A[P];
+}) => Error & Readonly<A>;
+export declare function TaggedError<Tag extends string>(tag: Tag): new <A extends Record<string, any> = {}>(args: Equals<A, {}> extends True ? void : {
+    readonly [P in keyof A as P extends "_tag" ? never : P]: A[P];
+}) => Error & {
+    readonly _tag: Tag;
+} & Readonly<A>;

package/data/Datum/api.d.ts

@@ -124,7 +124,7 @@ export declare function foldRight<A, B>(b: B, f: (a: A, b: B) => B): (self: Datu
  * @tsplus pipeable fncts.Datum getOrElse
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function getOrElse<B>(b: Lazy<B>): <A>(self: import("@fncts/base/data/Datum/definition").Datum<A>) => B | A;
+export declare function getOrElse<B>(b: Lazy<B>): <A>(self: Datum<A>) => A | B;
 /**
  * @tsplus pipeable fncts.Datum match
  * @tsplus location "@fncts/base/data/Datum/api"
@@ -149,7 +149,7 @@ export declare function map<A, B>(f: (a: A) => B): (self: Datum<A>) => Datum<B>;
  * @tsplus pipeable fncts.Datum orElse
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function orElse<B>(that: Lazy<Datum<B>>): <A>(self: import("@fncts/base/data/Datum/definition").Datum<A>) => import("@fncts/base/data/Datum/definition").Datum<B | A>;
+export declare function orElse<B>(that: Lazy<Datum<B>>): <A>(self: Datum<A>) => Datum<A | B>;
 /**
  * @tsplus pipeable fncts.Datum partition
  * @tsplus location "@fncts/base/data/Datum/api"
@@ -181,7 +181,7 @@ export declare const traverse: P.Traversable<DatumF>["traverse"];
  * @tsplus pipeable fncts.Datum zip
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function zip<B>(that: Datum<B>): <A>(self: import("@fncts/base/data/Datum/definition").Datum<A>) => import("@fncts/base/data/Datum/definition").Datum<Zipped.Make<A, B>>;
+export declare function zip<B>(that: Datum<B>): <A>(self: Datum<A>) => Datum<Zipped.Make<A, B>>;
 /**
  * @tsplus pipeable fncts.Datum zipWith
  * @tsplus location "@fncts/base/data/Datum/api"

package/data/DatumEither/api.d.ts

@@ -59,7 +59,7 @@ export declare function filter<A>(p: Predicate<A>): <E>(self: DatumEither<E, A>)
  * @tsplus pipeable fncts.DatumEither filterMap
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare function filterMap<A, B>(f: (a: A) => Maybe<B>): <E>(self: import("@fncts/base/data/DatumEither/definition").DatumEither<E, A>) => import("@fncts/base/data/DatumEither/definition").DatumEither<E, B>;
+export declare function filterMap<A, B>(f: (a: A) => Maybe<B>): <E>(self: DatumEither<E, A>) => DatumEither<E, B>;
 /**
  * @tsplus pipeable fncts.DatumEither flatMap
  * @tsplus location "@fncts/base/data/DatumEither/api"
@@ -69,22 +69,22 @@ export declare const flatMap: <A, E1, B>(f: (a: A) => DatumEither<E1, B>) => <E>
  * @tsplus pipeable fncts.DatumEither foldLeft
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare function foldLeft<A, B>(b: B, f: (b: B, a: A) => B): <E>(self: import("@fncts/base/data/DatumEither/definition").DatumEither<E, A>) => B;
+export declare function foldLeft<A, B>(b: B, f: (b: B, a: A) => B): <E>(self: DatumEither<E, A>) => B;
 /**
  * @tsplus pipeable fncts.DatumEither foldMap
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): <E>(self: import("@fncts/base/data/DatumEither/definition").DatumEither<E, A>) => M;
+export declare function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): <E>(self: DatumEither<E, A>) => M;
 /**
  * @tsplus pipeable fncts.DatumEither foldRight
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare function foldRight<A, B>(b: B, f: (a: A, b: B) => B): <E>(self: import("@fncts/base/data/DatumEither/definition").DatumEither<E, A>) => B;
+export declare function foldRight<A, B>(b: B, f: (a: A, b: B) => B): <E>(self: DatumEither<E, A>) => B;
 /**
  * @tsplus pipeable fncts.DatumEither getOrElse
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare function getOrElse<E, B, C>(onEmpty: () => B, onLeft: (e: E) => C): <A>(self: import("@fncts/base/data/DatumEither/definition").DatumEither<E, A>) => B | C | A;
+export declare function getOrElse<E, B, C>(onEmpty: () => B, onLeft: (e: E) => C): <A>(self: DatumEither<E, A>) => A | B | C;
 /**
  * @tsplus pipeable fncts.DatumEither map
  * @tsplus location "@fncts/base/data/DatumEither/api"
@@ -142,7 +142,7 @@ export declare function partition<A>(p: Predicate<A>): <E>(self: DatumEither<E,
  * @tsplus pipeable fncts.DatumEither partitionMap
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare function partitionMap<A, B, C>(f: (a: A) => Either<B, C>): <E>(self: import("@fncts/base/data/DatumEither/definition").DatumEither<E, A>) => [import("@fncts/base/data/DatumEither/definition").DatumEither<E, B>, import("@fncts/base/data/DatumEither/definition").DatumEither<E, C>];
+export declare function partitionMap<A, B, C>(f: (a: A) => Either<B, C>): <E>(self: DatumEither<E, A>) => [DatumEither<E, B>, DatumEither<E, C>];
 /**
  * @tsplus getter fncts.DatumEither toPending
  * @tsplus location "@fncts/base/data/DatumEither/api"
@@ -168,4 +168,4 @@ export declare const zipWith: <A, E1, B, C>(that: DatumEither<E1, B>, f: (a: A,
  * @tsplus pipeable fncts.DatumEither zip
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare function zip<E1, B>(that: DatumEither<E1, B>): <E, A>(self: import("@fncts/base/data/DatumEither/definition").DatumEither<E, A>) => import("@fncts/base/data/DatumEither/definition").DatumEither<E1 | E, import("../Zipped.js").Zipped.Make<A, B>>;
+export declare function zip<E1, B>(that: DatumEither<E1, B>): <E, A>(self: DatumEither<E, A>) => DatumEither<E | E1, Zipped.Make<A, B>>;

package/data/DatumEither.d.ts

@@ -1,2 +1,2 @@
-export * from "./DatumEither/api.js";
 export * from "./DatumEither/definition.js";
+export * from "./DatumEither/api.js";

package/data/DecodeError.d.ts

@@ -1,2 +1,2 @@
-export * from "./DecodeError/definition.js";
 export * from "./DecodeError/instances.js";
+export * from "./DecodeError/definition.js";

package/data/Decoder/api.d.ts

@@ -13,7 +13,7 @@ import { Decoder } from "@fncts/base/data/Decoder/definition";
  * @tsplus pipeable fncts.Decoder __call
  * @tsplus location "@fncts/base/data/Decoder/api"
  */
-export declare function decode(input: unknown): <A>(self: Decoder<A>) => import("../These").These<DecodeError, A>;
+export declare function decode(input: unknown): <A>(self: Decoder<A>) => These<DecodeError, A>;
 export declare function fromGuard<A>(guard: Guard<A>, onFalse: (i: unknown) => DecodeError, label: string): Decoder<A>;
 /**
  * @tsplus implicit

package/data/Decoder.d.ts

@@ -1,2 +1,2 @@
-export * from "./Decoder/api.js";
 export * from "./Decoder/definition.js";
+export * from "./Decoder/api.js";

package/data/Duration/api.d.ts

@@ -34,11 +34,6 @@ export declare function days(self: number): Duration;
  * @tsplus location "@fncts/base/data/Duration/api"
  */
 export declare function product(multiplicand: number): (self: Duration) => Duration;
-/**
- * @tsplus operator fncts.Duration *
- * @tsplus location "@fncts/base/data/Duration/api"
- */
-export declare function multiplyInverted(multiplicand: number, self: Duration): import("./definition").Duration;
 /**
  * @tsplus pipeable-operator fncts.Duration +
  * @tsplus location "@fncts/base/data/Duration/api"
@@ -65,3 +60,21 @@ export declare const zero: Duration;
  * @tsplus location "@fncts/base/data/Duration/api"
  */
 export declare function lessThanOrEqualTo(that: Duration): (self: Duration) => boolean;
+/**
+ * @tsplus fluent fncts.Duration greaterThanOrEqualTo
+ * @tsplus pipeable-operator fncts.Duration >=
+ * @tsplus location "@fncts/base/data/Duration/api"
+ */
+export declare function greaterThanOrEqualTo(that: Duration): (self: Duration) => boolean;
+/**
+ * @tsplus fluent fncts.Duration lessThan
+ * @tsplus pipeable-operator fncts.Duration <
+ * @tsplus location "@fncts/base/data/Duration/api"
+ */
+export declare function lessThan(that: Duration): (self: Duration) => boolean;
+/**
+ * @tsplus fluent fncts.Duration greaterThan
+ * @tsplus pipeable-operator fncts.Duration >
+ * @tsplus location "@fncts/base/data/Duration/api"
+ */
+export declare function greaterThan(that: Duration): (self: Duration) => boolean;

package/data/Duration.d.ts

@@ -1,2 +1,2 @@
-export * from "./Duration/api.js";
 export * from "./Duration/definition.js";
+export * from "./Duration/api.js";

package/data/Either/api/align.d.ts

@@ -4,4 +4,4 @@ import type { Either } from "../definition.js";
  * @tsplus pipeable fncts.Either align
  * @tsplus location "@fncts/base/data/Either/api/align"
  */
-export declare function align<E2, B>(fb: Either<E2, B>): <E1, A>(self: Either<E1, A>) => Either<E2 | E1, These<A, B>>;
+export declare function align<E2, B>(fb: Either<E2, B>): <E1, A>(self: Either<E1, A>) => Either<E1 | E2, These<A, B>>;

package/data/Either/api/alignWith.d.ts

@@ -4,4 +4,4 @@ import { These } from "../../These.js";
  * @tsplus pipeable fncts.Either alignWith
  * @tsplus location "@fncts/base/data/Either/api/alignWith"
  */
-export declare function alignWith<A, E2, B, C>(fb: Either<E2, B>, f: (_: These<A, B>) => C): <E1>(self: Either<E1, A>) => Either<E2 | E1, C>;
+export declare function alignWith<A, E2, B, C>(fb: Either<E2, B>, f: (_: These<A, B>) => C): <E1>(self: Either<E1, A>) => Either<E1 | E2, C>;