@fncts/base 0.0.1

package/data/Either/api.d.ts

@@ -0,0 +1,128 @@
+import { Either } from "@fncts/base/data/Either/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Lazy } from "@fncts/base/data/function/definition";
+import type * as P from "../../typeclass.js";
+import type { EitherF } from "./instances.js";
+import { Left, Right } from "./definition.js";
+/**
+ * @tsplus fluent fncts.Either ap
+ * @tsplus location "@fncts/base/data/Either/api"
+ */
+export declare function ap_<E1, A, E2, B>(self: Either<E1, (a: A) => B>, fa: Either<E2, A>): Either<E1 | E2, B>;
+/**
+ * @tsplus fluent fncts.Either bimap
+ * @tsplus location "@fncts/base/data/Either/api"
+ */
+export declare function bimap_<E1, A, E2, B>(self: Either<E1, A>, f: (e: E1) => E2, g: (a: A) => B): Either<E2, B>;
+/**
+ * @tsplus fluent fncts.Either catchAll
+ * @tsplus location "@fncts/base/data/Either/api"
+ */
+export declare function catchAll_<E1, A, E2, B>(self: Either<E1, A>, f: (e: E1) => Either<E2, B>): Either<E2, A | B>;
+/**
+ * @tsplus fluent fncts.Either catchJust
+ * @tsplus location "@fncts/base/data/Either/api"
+ */
+export declare function catchJust_<E1, A, E2, B>(self: Either<E1, A>, f: (e: E1) => Maybe<Either<E2, B>>): Either<E1 | E2, A | B>;
+/**
+ * @tsplus fluent fncts.Either catchMap
+ * @tsplus location "@fncts/base/data/Either/api"
+ */
+export declare function catchMap_<E, A, B>(self: Either<E, A>, f: (e: E) => B): Either<never, A | B>;
+/**
+ * @tsplus fluent fncts.Either flatMap
+ * @tsplus location "@fncts/base/data/Either/api"
+ */
+export declare function flatMap_<E1, A, E2, B>(self: Either<E1, A>, f: (a: A) => Either<E2, B>): Either<E1 | E2, B>;
+/**
+ * @tsplus fluent fncts.Either foldLeft
+ * @tsplus location "@fncts/base/data/Either/api"
+ */
+export declare function foldLeft_<E, A, B>(self: Either<E, A>, b: B, f: (b: B, a: A) => B): B;
+/**
+ * @tsplus fluent fncts.Either foldRight
+ * @tsplus location "@fncts/base/data/Either/api"
+ */
+export declare function foldRight_<E, A, B>(self: Either<E, A>, b: B, f: (a: A, b: B) => B): B;
+/**
+ * @constrained
+ */
+export declare function foldMap_<M>(M: P.Monoid<M>): <E, A>(self: import("./definition.js").Either<E, A>, f: (a: A) => M) => M;
+/**
+ * @tsplus getter fncts.Either foldMap
+ * @tsplus location "@fncts/base/data/Either/api"
+ */
+export declare function foldMapSelf<E, A>(self: Either<E, A>): <M>(M: P.Monoid<M>) => (f: (a: A) => M) => M;
+/**
+ * @tsplus getter fncts.Either getLeft
+ * @tsplus location "@fncts/base/data/Either/api"
+ */
+export declare function getLeft<E, A>(self: Either<E, A>): Maybe<E>;
+/**
+ * @tsplus getter fncts.Either getRight
+ * @tsplus location "@fncts/base/data/Either/api"
+ */
+export declare function getRight<E, A>(self: Either<E, A>): Maybe<A>;
+/**
+ * @tsplus fluent fncts.Either getOrElse
+ * @tsplus location "@fncts/base/data/Either/api"
+ */
+export declare function getOrElse_<E, A, B>(self: Either<E, A>, orElse: (e: E) => B): A | B;
+/**
+ * @tsplus static fncts.EitherOps isEither
+ * @tsplus location "@fncts/base/data/Either/api"
+ */
+export declare function isEither(u: unknown): u is Either<unknown, unknown>;
+/**
+ * @tsplus fluent fncts.Either isLeft
+ * @tsplus static fncts.EitherOps isLeft
+ * @tsplus location "@fncts/base/data/Either/api"
+ */
+export declare function isLeft<E, A>(self: Either<E, A>): self is Left<E>;
+/**
+ * @tsplus fluent fncts.Either isRight
+ * @tsplus static fncts.EitherOps isRight
+ * @tsplus location "@fncts/base/data/Either/api"
+ */
+export declare function isRight<E, A>(self: Either<E, A>): self is Right<A>;
+/**
+ * @tsplus fluent fncts.Either map
+ * @tsplus location "@fncts/base/data/Either/api"
+ */
+export declare function map_<E, A, B>(self: Either<E, A>, f: (a: A) => B): Either<E, B>;
+/**
+ * @tsplus fluent fncts.Either mapLeft
+ * @tsplus location "@fncts/base/data/Either/api"
+ */
+export declare function mapLeft_<E1, A, E2>(self: Either<E1, A>, f: (e: E1) => E2): Either<E2, A>;
+/**
+ * @tsplus getter fncts.Either value
+ * @tsplus location "@fncts/base/data/Either/api"
+ */
+export declare function merge<E, A>(self: Either<E, A>): E | A;
+/**
+ * @tsplus fluent fncts.Either orElse
+ * @tsplus location "@fncts/base/data/Either/api"
+ */
+export declare function orElse_<E1, A, E2, B>(self: Either<E1, A>, that: Lazy<Either<E2, B>>): Either<E1 | E2, A | B>;
+export declare const sequence: P.sequence<EitherF>;
+/**
+ * @tsplus getter fncts.Either sequence
+ * @tsplus location "@fncts/base/data/Either/api"
+ */
+export declare const sequenceSelf: P.sequenceSelf<EitherF>;
+/**
+ * @tsplus getter fncts.Either swap
+ * @tsplus location "@fncts/base/data/Either/api"
+ */
+export declare function swap<E, A>(self: Either<E, A>): Either<A, E>;
+export declare const traverse_: P.traverse_<EitherF>;
+export declare const traverse: P.traverse<EitherF>;
+/**
+ * @tsplus getter fncts.Either traverse
+ * @tsplus location "@fncts/base/data/Either/api"
+ */
+export declare const traverseSelf: P.traverseSelf<EitherF>;
+export declare function zipWith_<E1, A, E2, B, C>(self: Either<E1, A>, fb: Either<E2, B>, f: (a: A, b: B) => C): Either<E1 | E2, C>;
+export * from "./api/align.js";
+export * from "./api/alignWith.js";

package/data/Either/constructors.d.ts

@@ -0,0 +1,50 @@
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Lazy } from "@fncts/base/data/function/definition";
+import { Refinement } from "@fncts/base/data/Refinement/definition";
+import { Predicate } from "@fncts/base/data/Predicate/definition";
+import type { Nullable } from "@fncts/base/types";
+import { Either } from "./definition.js";
+/**
+ * @tsplus static fncts.EitherOps left
+ * @tsplus static fncts.Either.LeftOps __call
+ * @tsplus location "@fncts/base/data/Either/constructors"
+ */
+export declare function left<E = never, A = never>(e: E): Either<E, A>;
+/**
+ * @tsplus static fncts.EitherOps right
+ * @tsplus static fncts.Either.RightOps __call
+ * @tsplus location "@fncts/base/data/Either/constructors"
+ */
+export declare function right<E = never, A = never>(a: A): Either<E, A>;
+/**
+ * @tsplus static fncts.EitherOps fromMaybe
+ * @tsplus fluent fncts.Maybe toEither
+ * @tsplus location "@fncts/base/data/Either/constructors"
+ */
+export declare function fromMaybe_<E, A>(self: Maybe<A>, nothing: Lazy<E>): Either<E, A>;
+/**
+ * @tsplus static fncts.EitherOps fromNullable
+ * @tsplus location "@fncts/base/data/Either/constructors"
+ */
+export declare function fromNullable_<E, A>(value: A, nullable: Lazy<E>): Either<E, NonNullable<A>>;
+/**
+ * @tsplus static fncts.EitherOps fromNullableK
+ * @tsplus location "@fncts/base/data/Either/constructors"
+ */
+export declare function fromNullableK<E, P extends ReadonlyArray<unknown>, A>(f: (...params: P) => Nullable<A>, nullable: Lazy<E>): (...params: P) => Either<E, NonNullable<A>>;
+/**
+ * @tsplus static fncts.EitherOps fromPredicate
+ * @tsplus location "@fncts/base/data/Either/constructors"
+ */
+export declare function fromPredicate_<E, A, B extends A>(value: A, p: Refinement<A, B>, otherwise: (a: A) => E): Either<E, B>;
+export declare function fromPredicate_<E, A>(value: A, p: Predicate<A>, otherwise: (a: A) => E): Either<E, A>;
+/**
+ * @tsplus static fncts.EitherOps tryCatch
+ * @tsplus location "@fncts/base/data/Either/constructors"
+ */
+export declare function tryCatch<E, A>(thunk: () => A, exception: (e: unknown) => E): Either<E, A>;
+/**
+ * @tsplus static fncts.EitherOps tryCatchK
+ * @tsplus location "@fncts/base/data/Either/constructors"
+ */
+export declare function tryCatchK<P extends ReadonlyArray<unknown>, E, A>(f: (...params: P) => A, exception: (e: unknown) => E): (...params: P) => Either<E, A>;

package/data/Either/definition.d.ts

@@ -0,0 +1,40 @@
+export declare const enum EitherTag {
+    Left = "Left",
+    Right = "Right"
+}
+export declare const EitherTypeId: unique symbol;
+export declare type EitherTypeId = typeof EitherTypeId;
+/**
+ * @tsplus type fncts.Either.Left
+ * @tsplus companion fncts.Either.LeftOps
+ */
+export declare class Left<E> {
+    readonly left: E;
+    readonly _typeId: EitherTypeId;
+    readonly _tag = EitherTag.Left;
+    constructor(left: E);
+}
+/**
+ * @tsplus type fncts.Either.Right
+ * @tsplus companion fncts.Either.RightOps
+ */
+export declare class Right<A> {
+    readonly right: A;
+    readonly _typeId: EitherTypeId;
+    readonly _tag = EitherTag.Right;
+    constructor(right: A);
+}
+/**
+ * @tsplus type fncts.Either
+ */
+export declare type Either<E, A> = Left<E> | Right<A>;
+/**
+ * @tsplus type fncts.EitherOps
+ */
+export interface EitherOps {
+}
+export declare const Either: EitherOps;
+/**
+ * @tsplus unify fncts.Either
+ */
+export declare function unifyEither<X extends Either<any, any>>(self: X): Either<[X] extends [Either<infer E, any>] ? E : never, [X] extends [Either<any, infer A>] ? A : never>;

package/data/Either/destructors.d.ts

@@ -0,0 +1,6 @@
+import { Either } from "@fncts/base/data/Either/definition";
+/**
+ * @tsplus fluent fncts.Either match
+ * @tsplus location "@fncts/base/data/Either/destructors"
+ */
+export declare function match_<E, A, B, C>(self: Either<E, A>, left: (e: E) => B, right: (a: A) => C): B | C;

package/data/Either/instances.d.ts

@@ -0,0 +1,21 @@
+import { HKT } from "@fncts/typelevel/HKT";
+import { Either } from "@fncts/base/data/Either/definition";
+import { Predicate } from "@fncts/base/data/Predicate/definition";
+import * as P from "../../typeclass.js";
+export interface EitherF extends HKT {
+    readonly type: Either<this["E"], this["A"]>;
+    readonly variance: {
+        E: "+";
+        A: "+";
+    };
+}
+/**
+ * @tsplus static fncts.EitherOps getEq
+ * @tsplus location "@fncts/base/data/Either/instances"
+ */
+export declare function getEq<E, A>(EE: P.Eq<E>, EA: P.Eq<A>): P.Eq<Either<E, A>>;
+/**
+ * @tsplus static fncts.EitherOps getEq
+ * @tsplus location "@fncts/base/data/Either/instances"
+ */
+export declare function getFilerable<E>(ME: P.Monoid<E>): P.Filterable<EitherF, import("@fncts/typelevel/HKT.js").HKT.Fix<"E", E>>;

package/data/Either.d.ts

@@ -0,0 +1,5 @@
+export * from "./Either/api.js";
+export * from "./Either/constructors.js";
+export * from "./Either/definition.js";
+export * from "./Either/destructors.js";
+export * from "./Either/instances.js";

package/data/Environment/api.d.ts

@@ -0,0 +1,45 @@
+import { Environment } from "@fncts/base/data/Environment/definition";
+import { Tag } from "@fncts/base/data/Tag/definition";
+import { Has } from "@fncts/base/typeclass/Has";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+/**
+ * @tsplus fluent fncts.Environment add
+ * @tsplus location "@fncts/base/data/Environment/api"
+ */
+export declare function add<R, S, H extends S = S>(self: Environment<R>, service: H, tag: Tag<S>): Environment<R & Has<S>>;
+/**
+ * @tsplus static fncts.EnvironmentOps empty
+ * @tsplus location "@fncts/base/data/Environment/api"
+ */
+export declare const empty: import("./definition").Environment<unknown>;
+/**
+ * @tsplus fluent fncts.Environment get
+ * @tsplus location "@fncts/base/data/Environment/api"
+ */
+export declare function get<R extends Has<S>, S>(self: Environment<R>, tag: Tag<S>): S;
+/**
+ * @tsplus fluent fncts.Environment getMaybe
+ * @tsplus location "@fncts/base/data/Environment/api"
+ */
+export declare function getMaybe<R extends Has<S>, S>(self: Environment<R>, tag: Tag<S>): Maybe<S>;
+/**
+ * @tsplus static fncts.EnvironmentOps __call
+ * @tsplus location "@fncts/base/data/Environment/api"
+ */
+export declare function make(): Environment<unknown>;
+/**
+ * @tsplus operator fncts.Environment +
+ * @tsplus fluent fncts.Environment union
+ * @tsplus location "@fncts/base/data/Environment/api"
+ */
+export declare function union<R, R1>(self: Environment<R>, that: Environment<R1>): Environment<R & R1>;
+/**
+ * @tsplus fluent fncts.Environment unsafeGet
+ * @tsplus location "@fncts/base/data/Environment/api"
+ */
+export declare function unsafeGet<R, S>(self: Environment<R>, tag: Tag<S>): S;
+/**
+ * @tsplus fluent fncts.Environment update
+ * @tsplus location "@fncts/base/data/Environment/api"
+ */
+export declare function update<R extends Has<S>, S>(self: Environment<R>, f: (s: S) => S, tag: Tag<S>): Environment<R>;

package/data/Environment/definition.d.ts

@@ -0,0 +1,25 @@
+import { Hashable } from "@fncts/base/typeclass/Hashable";
+import { Equatable } from "@fncts/base/typeclass/Equatable";
+import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
+import { Tag } from "@fncts/base/data/Tag/definition";
+/**
+ * @tsplus static fncts.prelude.builtin.SymbolOps env
+ * @tsplus location "@fncts/base/data/Environment/definition"
+ */
+export declare const EnvSymbol: unique symbol;
+export declare type EnvSymbol = typeof EnvSymbol;
+/**
+ * @tsplus type fncts.Environment
+ * @tsplus companion fncts.EnvironmentOps
+ */
+export declare class Environment<R> implements Hashable, Equatable {
+    readonly map: HashMap<Tag<unknown>, readonly [unknown, number]>;
+    readonly index: number;
+    cache: HashMap<Tag<unknown>, unknown>;
+    readonly _typeId: EnvSymbol;
+    readonly [EnvSymbol]: (_: never) => R;
+    constructor(map: HashMap<Tag<unknown>, readonly [unknown, number]>, index: number, cache?: HashMap<Tag<unknown>, unknown>);
+    get [Symbol.hash](): number;
+    [Symbol.equals](that: unknown): boolean;
+}
+export declare function isEnvironment(u: unknown): u is Environment<unknown>;

package/data/Environment.d.ts

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

package/data/ExecutionStrategy.d.ts

@@ -0,0 +1,45 @@
+export interface Sequential {
+    readonly _tag: "Sequential";
+}
+export interface Concurrent {
+    readonly _tag: "Concurrent";
+}
+export interface ConcurrentBounded {
+    readonly _tag: "ConcurrentBounded";
+    readonly fiberBound: number;
+}
+/**
+ * @tsplus static fncts.ExecutionStrategyOps sequential
+ * @tsplus location "@fncts/base/data/ExecutionStrategy"
+ */
+export declare const sequential: Sequential;
+/**
+ * @tsplus static fncts.ExecutionStrategyOps concurrent
+ * @tsplus location "@fncts/base/data/ExecutionStrategy"
+ */
+export declare const concurrent: Concurrent;
+/**
+ * @tsplus static fncts.ExecutionStrategyOps concurrentBounded
+ * @tsplus location "@fncts/base/data/ExecutionStrategy"
+ */
+export declare function concurrentBounded(fiberBound: number): ConcurrentBounded;
+/**
+ * @tsplus type fncts.ExecutionStrategy
+ */
+export declare type ExecutionStrategy = Sequential | Concurrent | ConcurrentBounded;
+/**
+ * @tsplus type fncts.ExecutionStrategyOps
+ */
+export interface ExecutionStrategyOps {
+}
+export declare const ExecutionStrategy: ExecutionStrategyOps;
+/**
+ * @tsplus fluent fncts.ExecutionStrategy match
+ * @tsplus location "@fncts/base/data/ExecutionStrategy"
+ */
+export declare function match_<A, B, C>(strategy: ExecutionStrategy, sequential: () => A, concurrent: () => B, concurrentBounded: (fiberBound: number) => C): A | B | C;
+/**
+ * @tsplus pipeable fncts.ExecutionStrategy match
+ * @tsplus location "@fncts/base/data/ExecutionStrategy"
+ */
+export declare function match<A, B, C>(sequential: () => A, concurrent: () => B, concurrentBounded: (fiberBound: number) => C): (strategy: ExecutionStrategy) => A | B | C;

package/data/Exit/api.d.ts

@@ -0,0 +1,99 @@
+import { Exit } from "@fncts/base/data/Exit/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Cause } from "@fncts/base/data/Cause/definition";
+/**
+ * @tsplus fluent fncts.Exit ap
+ * @tsplus location "@fncts/base/data/Exit/api"
+ */
+export declare function ap_<E, A, G, B>(fab: Exit<G, (a: A) => B>, fa: Exit<E, A>): Exit<E | G, B>;
+/**
+ * @tsplus fluent fncts.Exit apFirst
+ * @tsplus location "@fncts/base/data/Exit/api"
+ */
+export declare function apFirst_<E, G, A, B>(fa: Exit<E, A>, fb: Exit<G, B>): Exit<E | G, A>;
+/**
+ * @tsplus fluent fncts.Exit apSecond
+ * @tsplus location "@fncts/base/data/Exit/api"
+ */
+export declare function apSecond_<E, G, A, B>(fa: Exit<E, A>, fb: Exit<G, B>): Exit<E | G, B>;
+/**
+ * @tsplus fluent fncts.Exit apFirstC
+ * @tsplus location "@fncts/base/data/Exit/api"
+ */
+export declare function apFirstC_<E, G, A, B>(fa: Exit<E, A>, fb: Exit<G, B>): Exit<E | G, A>;
+/**
+ * @tsplus fluent fncts.Exit apSecondC
+ * @tsplus location "@fncts/base/data/Exit/api"
+ */
+export declare function apSecondC_<E, G, A, B>(fa: Exit<E, A>, fb: Exit<G, B>): Exit<E | G, B>;
+/**
+ * @tsplus fluent fncts.Exit flatMap
+ * @tsplus location "@fncts/base/data/Exit/api"
+ */
+export declare function flatMap_<E, A, G, B>(ma: Exit<E, A>, f: (a: A) => Exit<G, B>): Exit<E | G, B>;
+/**
+ * @tsplus fluent fncts.Exit bimap
+ * @tsplus location "@fncts/base/data/Exit/api"
+ */
+export declare function bimap_<E1, A, E2, B>(self: Exit<E1, A>, f: (e: E1) => E2, g: (a: A) => B): Exit<E2, B>;
+/**
+ * @tsplus static fncts.ExitOps collectAll
+ * @tsplus location "@fncts/base/data/Exit/api"
+ */
+export declare function collectAll<E, A>(exits: Conc<Exit<E, A>>): Maybe<Exit<E, Conc<A>>>;
+/**
+ * @tsplus static fncts.ExitOps collectAllC
+ * @tsplus location "@fncts/base/data/Exit/api"
+ */
+export declare function collectAllC<E, A>(exits: Conc<Exit<E, A>>): Maybe<Exit<E, Conc<A>>>;
+/**
+ * @tsplus getter fncts.Exit flatten
+ * @tsplus location "@fncts/base/data/Exit/api"
+ */
+export declare function flatten<E, G, A>(mma: Exit<E, Exit<G, A>>): Exit<E | G, A>;
+/**
+ * @tsplus fluent fncts.Exit map
+ * @tsplus location "@fncts/base/data/Exit/api"
+ */
+export declare function map_<E, A, B>(fa: Exit<E, A>, f: (a: A) => B): Exit<E, B>;
+/**
+ * @tsplus fluent fncts.Exit mapError
+ * @tsplus location "@fncts/base/data/Exit/api"
+ */
+export declare function mapError_<E1, A, E2>(self: Exit<E1, A>, f: (e: E1) => E2): Exit<E2, A>;
+/**
+ * @tsplus fluent fncts.Exit mapErrorCause
+ * @tsplus location "@fncts/base/data/Exit/api"
+ */
+export declare function mapErrorCause_<E1, A, E2>(self: Exit<E1, A>, f: (e: Cause<E1>) => Cause<E2>): Exit<E2, A>;
+/**
+ * @tsplus fluent fncts.Exit match
+ * @tsplus location "@fncts/base/data/Exit/api"
+ */
+export declare function match_<E, A, B, C>(exit: Exit<E, A>, onFailure: (e: Cause<E>) => B, onSuccess: (a: A) => C): B | C;
+/**
+ * @tsplus fluent fncts.Exit zipWith
+ * @tsplus location "@fncts/base/data/Exit/api"
+ */
+export declare function zipWith_<EA, A, EB, B, C>(fa: Exit<EA, A>, fb: Exit<EB, B>, f: (a: A, b: B) => C): Exit<EA | EB, C>;
+/**
+ * @tsplus fluent fncts.Exit zip
+ * @tsplus location "@fncts/base/data/Exit/api"
+ */
+export declare function zip<EA, A, EB, B>(self: Exit<EA, A>, that: Exit<EB, B>): Exit<EA | EB, readonly [A, B]>;
+/**
+ * @tsplus fluent fncts.Exit zipWithC
+ * @tsplus location "@fncts/base/data/Exit/api"
+ */
+export declare function zipWithC_<EA, A, EB, B, C>(fa: Exit<EA, A>, fb: Exit<EB, B>, f: (a: A, b: B) => C): Exit<EA | EB, C>;
+/**
+ * @tsplus fluent fncts.Exit zipC
+ * @tsplus location "@fncts/base/data/Exit/api"
+ */
+export declare function zipC<EA, A, EB, B>(self: Exit<EA, A>, that: Exit<EB, B>): Exit<EA | EB, readonly [A, B]>;
+/**
+ * @tsplus fluent fncts.Exit zipWithCause
+ * @tsplus location "@fncts/base/data/Exit/api"
+ */
+export declare function zipWithCause_<E, A, G, B, C>(fa: Exit<E, A>, fb: Exit<G, B>, f: (a: A, b: B) => C, g: (ea: Cause<E>, eb: Cause<G>) => Cause<E | G>): Exit<E | G, C>;

package/data/Exit/constructors.d.ts

@@ -0,0 +1,45 @@
+import { Exit } from "@fncts/base/data/Exit/definition";
+import { Either } from "@fncts/base/data/Either/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Cause } from "@fncts/base/data/Cause/definition";
+import { FiberId } from "@fncts/base/data/FiberId/definition";
+/**
+ * @tsplus static fncts.ExitOps halt
+ * @tsplus location "@fncts/base/data/Exit/constructors"
+ */
+export declare function halt(defect: unknown): Exit<never, never>;
+/**
+ * @tsplus static fncts.ExitOps fail
+ * @tsplus location "@fncts/base/data/Exit/constructors"
+ */
+export declare function fail<E = never, A = never>(e: E): Exit<E, A>;
+/**
+ * @tsplus static fncts.ExitOps fromEither
+ * @tsplus location "@fncts/base/data/Exit/constructors"
+ */
+export declare function fromEither<E = never, A = never>(e: Either<E, A>): Exit<E, A>;
+/**
+ * @tsplus static fncts.ExitOps fromMaybe
+ * @tsplus location "@fncts/base/data/Exit/constructors"
+ */
+export declare function fromMaybe_<E, A>(fa: Maybe<A>, onNothing: () => E): Exit<E, A>;
+/**
+ * @tsplus static fncts.ExitOps failCause
+ * @tsplus location "@fncts/base/data/Exit/constructors"
+ */
+export declare function failCause<E = never, A = never>(cause: Cause<E>): Exit<E, A>;
+/**
+ * @tsplus static fncts.ExitOps interrupt
+ * @tsplus location "@fncts/base/data/Exit/constructors"
+ */
+export declare function interrupt(id: FiberId): import("./definition.js").Exit<never, never>;
+/**
+ * @tsplus static fncts.ExitOps succeed
+ * @tsplus location "@fncts/base/data/Exit/constructors"
+ */
+export declare function succeed<E = never, A = never>(value: A): Exit<E, A>;
+/**
+ * @tsplus static fncts.ExitOps unit
+ * @tsplus location "@fncts/base/data/Exit/constructors"
+ */
+export declare const unit: Exit<never, void>;

package/data/Exit/definition.d.ts

@@ -0,0 +1,70 @@
+import { Cause } from "@fncts/base/data/Cause/definition";
+import * as P from "../../typeclass.js";
+export declare const ExitTypeId: unique symbol;
+export declare type ExitTypeId = typeof ExitTypeId;
+/**
+ * @tsplus type fncts.Exit
+ */
+export declare type Exit<E, A> = Success<A> | Failure<E>;
+/**
+ * @tsplus type fncts.ExitOps
+ */
+export interface ExitOps {
+}
+export declare const Exit: ExitOps;
+export declare const enum ExitTag {
+    Success = "Success",
+    Failure = "Failure"
+}
+/**
+ * @tsplus type fncts.Exit.Failure
+ * @tsplus companion fncts.Exit.FailureOps
+ */
+export declare class Failure<E> {
+    readonly cause: Cause<E>;
+    readonly _E: () => E;
+    readonly _A: () => never;
+    readonly _typeId: ExitTypeId;
+    readonly _tag = ExitTag.Failure;
+    constructor(cause: Cause<E>);
+    get [Symbol.hash](): number;
+    [Symbol.equals](that: unknown): boolean;
+}
+/**
+ * @tsplus type fncts.Exit.Success
+ * @tsplus companion fncts.Exit.SuccessOps
+ */
+export declare class Success<A> implements P.Hashable, P.Equatable {
+    readonly value: A;
+    readonly _E: () => never;
+    readonly _A: () => A;
+    readonly _typeId: ExitTypeId;
+    readonly _tag = ExitTag.Success;
+    constructor(value: A);
+    get [Symbol.hash](): number;
+    [Symbol.equals](that: unknown): boolean;
+}
+/**
+ * @tsplus static fncts.ExitOps isExit
+ * @tsplus location "@fncts/base/data/Exit/definition"
+ */
+export declare function isExit(u: unknown): u is Exit<unknown, unknown>;
+/**
+ * @tsplus fluent fncts.Exit isFailure
+ * @tsplus location "@fncts/base/data/Exit/definition"
+ */
+export declare function isFailure<E, A>(exit: Exit<E, A>): exit is Failure<E>;
+/**
+ * @tsplus fluent fncts.Exit isInterrupt
+ * @tsplus location "@fncts/base/data/Exit/definition"
+ */
+export declare function isInterrupt<E, A>(exit: Exit<E, A>): exit is Failure<E>;
+/**
+ * @tsplus fluent fncts.Exit isSuccess
+ * @tsplus location "@fncts/base/data/Exit/definition"
+ */
+export declare function isSuccess<E, A>(exit: Exit<E, A>): exit is Success<A>;
+/**
+ * @tsplus unify fncts.Exit
+ */
+export declare function unifyExit<X extends Exit<any, any>>(_: X): Exit<[X] extends [Exit<infer E, any>] ? E : never, [X] extends [Exit<any, infer A>] ? A : never>;

package/data/Exit.d.ts

@@ -0,0 +1,3 @@
+export * from "./Exit/api.js";
+export * from "./Exit/constructors.js";
+export * from "./Exit/definition.js";

package/data/FiberId/api.d.ts

@@ -0,0 +1,17 @@
+import { FiberId } from "@fncts/base/data/FiberId/definition";
+import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
+/**
+ * @tsplus fluent fncts.FiberId combine
+ * @tsplus location "@fncts/base/data/FiberId/api"
+ */
+export declare function combine_(id0: FiberId, id1: FiberId): FiberId;
+/**
+ * @tsplus getter fncts.FiberId ids
+ * @tsplus location "@fncts/base/data/FiberId/api"
+ */
+export declare function ids(self: FiberId): HashSet<number>;
+/**
+ * @tsplus getter fncts.FiberId threadName
+ * @tsplus location "@fncts/base/data/FiberId/api"
+ */
+export declare function threadName(self: FiberId): string;

package/data/FiberId/constructors.d.ts

@@ -0,0 +1,17 @@
+import { TraceElement } from "@fncts/base/data/TraceElement/definition";
+import { None, Runtime } from "./definition.js";
+/**
+ * @tsplus static fncts.FiberIdOps none
+ * @tsplus location "@fncts/base/data/FiberId/constructors"
+ */
+export declare const none: None;
+/**
+ * @tsplus static fncts.FiberIdOps unsafeMake
+ * @tsplus location "@fncts/base/data/FiberId/constructors"
+ */
+export declare function unsafeMake(location: TraceElement): Runtime;
+/**
+ * @tsplus static fncts.FiberIdOps synthetic
+ * @tsplus location "@fncts/base/data/FiberId/constructors"
+ */
+export declare const synthetic: Runtime;