@fncts/base 0.0.27 → 0.0.29

package/_src/data/Exit/definition.ts

@@ -23,6 +23,9 @@ export const enum ExitTag {
   Failure = "Failure",
 }
 
+const IOTypeId = Symbol.for("fncts.io.IO");
+type IOTypeId = typeof IOTypeId;
+
 const _failureHash = Hashable.string("fncts.Exit.Failure");
 const _successHash = Hashable.string("fncts.Exit.Success");
 
@@ -36,8 +39,9 @@ export class Failure<E> {
     readonly _E: (_: never) => E;
     readonly _A: (_: never) => never;
   };
-  readonly _tag = ExitTag.Failure;
-  constructor(readonly cause: Cause<E>) {}
+  readonly [IOTypeId]: IOTypeId = IOTypeId;
+  readonly _tag                 = ExitTag.Failure;
+  constructor(readonly cause: Cause<E>, readonly trace?: string) {}
 
   get [Symbol.hash](): number {
     return Hashable.combine(_failureHash, Hashable.unknown(this.cause));
@@ -57,8 +61,9 @@ export class Success<A> implements P.Hashable, P.Equatable {
     readonly _E: (_: never) => never;
     readonly _A: (_: never) => A;
   };
-  readonly _tag = ExitTag.Success;
-  constructor(readonly value: A) {}
+  readonly [IOTypeId]: IOTypeId = IOTypeId;
+  readonly _tag                 = ExitTag.Success;
+  constructor(readonly value: A, readonly trace?: string) {}
 
   get [Symbol.hash](): number {
     return Hashable.combine(_successHash, Hashable.unknown(this.value));

package/_src/data/Guard/api.ts

@@ -453,5 +453,5 @@ export function deriveTuple<A extends ReadonlyArray<unknown>>(
  * @tsplus static fncts.GuardOps tuple
  */
 export function tuple<A extends ReadonlyArray<unknown>>(...components: { [K in keyof A]: Guard<A[K]> }): Guard<A> {
-  return deriveTuple(components.unsafeCoerce()).unsafeCoerce();
+  return deriveTuple(components as [never]).unsafeCoerce();
 }

package/_src/data/Maybe/constructors.ts

@@ -4,18 +4,16 @@ import type { Nullable } from "@fncts/base/types";
  * @tsplus static fncts.MaybeOps just
  * @tsplus static fncts.JustOps __call
  */
-export function just<A>(a: A): Maybe<A> {
-  return new Just(a);
+export function just<A>(a: A, __tsplusTrace?: string): Maybe<A> {
+  return new Just(a, __tsplusTrace);
 }
 
-const _Nothing = new Nothing();
-
 /**
  * @tsplus static fncts.MaybeOps nothing
  * @tsplus static fncts.NothingOps __call
  */
-export function nothing<A = never>(): Maybe<A> {
-  return _Nothing;
+export function nothing<A = never>(__tsplusTrace?: string): Maybe<A> {
+  return new Nothing(__tsplusTrace);
 }
 
 /**

package/_src/data/Maybe/definition.ts

@@ -11,6 +11,9 @@ export type MaybeVariance = typeof MaybeVariance;
 export const MaybeTypeId = Symbol.for("fncts.Maybe");
 export type MaybeTypeId = typeof MaybeTypeId;
 
+const IOTypeId = Symbol.for("fncts.io.IO");
+type IOTypeId = typeof IOTypeId;
+
 export interface MaybeF extends HKT {
   type: Maybe<this["A"]>;
   variance: {
@@ -30,6 +33,8 @@ export abstract class Maybe<A> {
     readonly _A: (_: never) => A;
   };
   readonly [MaybeTypeId]: MaybeTypeId = MaybeTypeId;
+  readonly [IOTypeId]: IOTypeId       = IOTypeId;
+  readonly trace?: string | undefined = undefined;
 }
 
 /**
@@ -38,7 +43,7 @@ export abstract class Maybe<A> {
  */
 export class Just<A> extends Maybe<A> {
   readonly _tag = MaybeTag.Just;
-  constructor(readonly value: A) {
+  constructor(readonly value: A, readonly trace?: string) {
     super();
   }
   [Symbol.equals](that: unknown): boolean {
@@ -55,6 +60,9 @@ export class Just<A> extends Maybe<A> {
  */
 export class Nothing extends Maybe<never> {
   readonly _tag = MaybeTag.Nothing;
+  constructor(readonly trace?: string) {
+    super();
+  }
   [Symbol.equals](that: unknown): boolean {
     return isMaybe(that) && that.isNothing();
   }

package/_src/data/exceptions/IOError.ts

@@ -0,0 +1,11 @@
+export const IOErrorTypeId = Symbol.for("fncts.base.exceptions.IOError");
+export type IOErrorTypeId = typeof IOErrorTypeId;
+
+export class IOError<E> {
+  readonly [IOErrorTypeId]: IOErrorTypeId = IOErrorTypeId;
+  constructor(readonly cause: Cause<E>) {}
+}
+
+export function isIOError(u: unknown): u is IOError<unknown> {
+  return isObject(u) && IOErrorTypeId in u;
+}

package/_src/data/exceptions/NoSuchElementError.ts

@@ -2,7 +2,7 @@ export const NoSuchElementErrorTag = "NoSuchElementError";
 
 export class NoSuchElementError extends Error {
   readonly _tag = NoSuchElementErrorTag;
-  constructor(message: string) {
+  constructor(message?: string) {
     super(message);
     this.name = NoSuchElementErrorTag;
   }

package/_src/data/exceptions.ts

@@ -5,6 +5,7 @@ export * from "./exceptions/IllegalStateError.js";
 export * from "./exceptions/IndexOutOfBoundsError.js";
 export * from "./exceptions/InterruptedException.js";
 export * from "./exceptions/InvalidCapacityError.js";
+export * from "./exceptions/IOError.js";
 export * from "./exceptions/NoSuchElementError.js";
 export * from "./exceptions/RuntimeError.js";
 // codegen:end

package/_src/types.ts

@@ -1,5 +1,4 @@
 // codegen:start { preset: barrel, include: types/*.ts }
 export * from "./types/extractions.js";
-export * from "./types/test.js";
 export * from "./types/utility.js";
 // codegen:end

package/collection/immutable/Conc/api.d.ts

@@ -268,6 +268,11 @@ export declare function reverse<A>(self: Conc<A>): Iterable<A>;
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"
  */
 export declare function separate<E, A>(self: Conc<Either<E, A>>): readonly [Conc<E>, Conc<A>];
+/**
+ * @tsplus pipeable fncts.Conc slice
+ * @tsplus location "@fncts/base/collection/immutable/Conc/api"
+ */
+export declare function slice(from: number, to: number): <A>(self: import("@fncts/base/collection/immutable/Conc/definition").Conc<A>) => import("@fncts/base/collection/immutable/Conc/definition").Conc<A>;
 /**
  * @tsplus pipeable fncts.Conc splitAt
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"

package/control/CompletablePromise.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @tsplus type fncts.CompletablePromise
+ * @tsplus companion fncts.CompletablePromiseOps
+ */
+export interface CompletablePromise<A> extends Promise<A> {
+    resolve: (a: A) => void;
+    reject: (reason: unknown) => void;
+}
+/**
+ * @tsplus static fncts.CompletablePromiseOps __call
+ * @tsplus location "@fncts/base/control/CompletablePromise"
+ */
+export declare function make<A>(): CompletablePromise<A>;

package/control.d.ts

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

package/data/Cause/api.d.ts

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

package/data/Cause/definition.d.ts

@@ -1,3 +1,4 @@
+import { Equatable } from "@fncts/base/data/Equatable";
 import { Eval } from "@fncts/base/control/Eval/definition";
 import { Trace } from "@fncts/base/data/Trace/definition";
 import { FiberId } from "@fncts/base/data/FiberId/definition";
@@ -11,7 +12,7 @@ export type CauseTypeId = typeof CauseTypeId;
 /**
  * @tsplus type fncts.Cause
  */
-export type Cause<E> = Empty | Halt | Interrupt | Fail<E> | Then<E> | Both<E> | Stackless<E>;
+export type Cause<E> = Empty | Halt | Interrupt | Fail<E> | Sequential<E> | Parallel<E> | Stackless<E>;
 /**
  * @tsplus type fncts.CauseOps
  */
@@ -24,14 +25,14 @@ export declare const enum CauseTag {
     Fail = "Fail",
     Halt = "Halt",
     Interrupt = "Interrupt",
-    Then = "Then",
-    Both = "Both",
+    Sequential = "Sequential",
+    Parallel = "Parallel",
     Stackless = "Stackless"
 }
 /**
  * @tsplus companion fncts.Cause.EmptyOps
  */
-export declare class Empty {
+export declare class Empty implements Equatable {
     readonly [CauseTypeId]: CauseTypeId;
     [CauseVariance]: {
         readonly _E: (_: never) => never;
@@ -45,7 +46,7 @@ export declare const _Empty: Empty;
 /**
  * @tsplus companion fncts.Cause.FailOps
  */
-export declare class Fail<E> {
+export declare class Fail<E> implements Equatable {
     readonly value: E;
     readonly trace: Trace;
     readonly [CauseTypeId]: CauseTypeId;
@@ -61,7 +62,7 @@ export declare class Fail<E> {
 /**
  * @tsplus companion fncts.Cause.HaltOps
  */
-export declare class Halt {
+export declare class Halt implements Equatable {
     readonly value: unknown;
     readonly trace: Trace;
     readonly [CauseTypeId]: CauseTypeId;
@@ -77,7 +78,7 @@ export declare class Halt {
 /**
  * @tsplus companion fncts.Cause.InterruptOps
  */
-export declare class Interrupt {
+export declare class Interrupt implements Equatable {
     readonly id: FiberId;
     readonly trace: Trace;
     readonly [CauseTypeId]: CauseTypeId;
@@ -91,32 +92,32 @@ export declare class Interrupt {
     equalsEval(that: Cause<unknown>): Eval<boolean>;
 }
 /**
- * @tsplus companion fncts.Cause.ThenOps
+ * @tsplus companion fncts.Cause.SequentialOps
  */
-export declare class Then<E> {
+export declare class Sequential<E> implements Equatable {
     readonly left: Cause<E>;
     readonly right: Cause<E>;
     readonly [CauseTypeId]: CauseTypeId;
     [CauseVariance]: {
         readonly _E: (_: never) => E;
     };
-    readonly _tag = CauseTag.Then;
+    readonly _tag = CauseTag.Sequential;
     constructor(left: Cause<E>, right: Cause<E>);
     get [Symbol.hash](): number;
     [Symbol.equals](that: unknown): boolean;
     equalsEval(that: Cause<unknown>): Eval<boolean>;
 }
 /**
- * @tsplus companion fncts.Cause.BothOps
+ * @tsplus companion fncts.Cause.ParallelOps
  */
-export declare class Both<E> {
+export declare class Parallel<E> implements Equatable {
     readonly left: Cause<E>;
     readonly right: Cause<E>;
     readonly [CauseTypeId]: CauseTypeId;
     [CauseVariance]: {
         readonly _E: (_: never) => E;
     };
-    readonly _tag = CauseTag.Both;
+    readonly _tag = CauseTag.Parallel;
     constructor(left: Cause<E>, right: Cause<E>);
     get [Symbol.hash](): number;
     [Symbol.equals](that: unknown): boolean;
@@ -125,7 +126,7 @@ export declare class Both<E> {
 /**
  * @tsplus companion fncts.Cause.StacklessOps
  */
-export declare class Stackless<E> {
+export declare class Stackless<E> implements Equatable {
     readonly cause: Cause<E>;
     readonly stackless: boolean;
     readonly [CauseTypeId]: CauseTypeId;

package/data/Duration/api.d.ts

@@ -59,3 +59,9 @@ export declare function fromInterval(start: number, end: number): Duration;
  * @tsplus location "@fncts/base/data/Duration/api"
  */
 export declare const zero: Duration;
+/**
+ * @tsplus fluent fncts.Duration lessThanOrEqualTo
+ * @tsplus pipeable-operator fncts.Duration <=
+ * @tsplus location "@fncts/base/data/Duration/api"
+ */
+export declare function lessThanOrEqualTo(that: Duration): (self: Duration) => boolean;

package/data/Either/constructors.d.ts

@@ -9,13 +9,13 @@ import { Either } from "./definition.js";
  * @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>;
+export declare function left<E = never, A = never>(e: E, __tsplusTrace?: string): 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>;
+export declare function right<E = never, A = never>(a: A, __tsplusTrace?: string): Either<E, A>;
 /**
  * @tsplus static fncts.EitherOps fromMaybe
  * @tsplus pipeable fncts.Maybe toEither

package/data/Either/definition.d.ts

@@ -1,6 +1,6 @@
 import { HKT } from "@fncts/typelevel/HKT";
 import { Hashable } from "@fncts/base/data/Hashable";
-import { Equatable } from "@fncts/base/data/Equatable";
+import type { EqualsContext } from "@fncts/base/data/Equatable";
 export declare const enum EitherTag {
     Left = "Left",
     Right = "Right"
@@ -16,12 +16,16 @@ export interface EitherF extends HKT {
         A: "+";
     };
 }
+declare const IOTypeId: unique symbol;
+type IOTypeId = typeof IOTypeId;
 /**
  * @tsplus type fncts.Either
  * @tsplus companion fncts.EitherOps
  */
 export declare class Either<E, A> {
     readonly [EitherTypeId]: EitherTypeId;
+    readonly [IOTypeId]: IOTypeId;
+    readonly trace?: string | undefined;
     [EitherVariance]: {
         readonly _E: (_: never) => E;
         readonly _A: (_: never) => A;
@@ -33,10 +37,11 @@ export declare class Either<E, A> {
  */
 export declare class Left<E> extends Either<E, never> {
     readonly left: E;
+    readonly trace?: string | undefined;
     readonly _tag = EitherTag.Left;
-    constructor(left: E);
+    constructor(left: E, trace?: string | undefined);
     get [Symbol.hash](): number;
-    [Symbol.equals](that: unknown): boolean;
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus type fncts.Either.Right
@@ -44,10 +49,11 @@ export declare class Left<E> extends Either<E, never> {
  */
 export declare class Right<A> extends Either<never, A> {
     readonly right: A;
+    readonly trace?: string | undefined;
     readonly _tag = EitherTag.Right;
-    constructor(right: A);
+    constructor(right: A, trace?: string | undefined);
     get [Symbol.hash](): number;
-    [Symbol.equals](that: unknown): boolean;
+    [Symbol.equals](that: unknown, context: EqualsContext): boolean;
 }
 /**
  * @tsplus unify fncts.Either
@@ -60,3 +66,4 @@ export declare function unifyEither<X extends Either<any, any>>(self: X): Either
  * @tsplus location "@fncts/base/data/Either/definition"
  */
 export declare function concrete<E, A>(self: Either<E, A>): asserts self is Left<E> | Right<A>;
+export {};

package/data/Eq/api.d.ts

@@ -0,0 +1,6 @@
+import { Eq } from "@fncts/base/data/Eq/definition";
+/**
+ * @tsplus pipeable fncts.Eq contramap
+ * @tsplus location "@fncts/base/data/Eq/api"
+ */
+export declare function contramap<A, B>(f: (b: B) => A): (self: Eq<A>) => Eq<B>;

package/data/Eq.d.ts

@@ -1,2 +1,3 @@
+export * from "./Eq/api.js";
 export * from "./Eq/definition.js";
 export {} from "./Eq/derivations.js";

package/data/Equatable/api.d.ts

@@ -2,7 +2,7 @@
  * @tsplus static fncts.EquatableOps deepEquals
  * @tsplus location "@fncts/base/data/Equatable/api"
  */
-export declare const deepEquals: (a: any, b: any, meta?: any) => boolean;
+export declare function deepEquals<A>(a: A, b: unknown): boolean;
 /**
  * @tsplus static fncts.EquatableOps strictEquals
  * @tsplus operator fncts.Equatable ==

package/data/Equatable/definition.d.ts

@@ -3,11 +3,14 @@
  * @tsplus location "@fncts/base/data/Equatable/definition"
  */
 export declare const equalsSymbol: unique symbol;
+export interface EqualsContext {
+    comparator: (a: unknown, b: unknown) => boolean;
+}
 /**
  * @tsplus type fncts.Equatable
  */
 export interface Equatable {
-    [equalsSymbol](that: unknown): boolean;
+    [equalsSymbol](that: unknown, context: EqualsContext): boolean;
 }
 export declare function isEquatable(u: unknown): u is Equatable;
 /**

package/data/Exit/api.d.ts

@@ -97,3 +97,15 @@ export declare function zipConcurrent<EB, B>(that: Exit<EB, B>): <EA, A>(self: i
  * @tsplus location "@fncts/base/data/Exit/api"
  */
 export declare function zipWithCause<E, A, G, B, C>(fb: Exit<G, B>, f: (a: A, b: B) => C, g: (ea: Cause<E>, eb: Cause<G>) => Cause<E | G>): (fa: Exit<E, A>) => Exit<E | G, C>;
+/**
+ * Returns the Exit's Success value if it exists
+ * @tsplus getter fncts.Exit value
+ * @tsplus location "@fncts/base/data/Exit/api"
+ */
+export declare function value<E, A>(self: Exit<E, A>): A | undefined;
+/**
+ * Returns the Exit's Success value if it exists, or throws the pretty-printed Cause if it doesn't
+ * @tsplus getter fncts.Exit valueOrThrow
+ * @tsplus location "@fncts/base/data/Exit/api"
+ */
+export declare function valueOrThrow<E, A>(self: Exit<E, A>): A;

package/data/Exit/constructors.d.ts

@@ -7,12 +7,12 @@ 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>;
+export declare function halt(defect: unknown, __tsplusTrace?: string): 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>;
+export declare function fail<E = never, A = never>(e: E, __tsplusTrace?: string): Exit<E, A>;
 /**
  * @tsplus static fncts.ExitOps fromEither
  * @tsplus location "@fncts/base/data/Exit/constructors"
@@ -27,17 +27,17 @@ export declare function fromMaybe<E, A>(fa: Maybe<A>, onNothing: () => E): Exit<
  * @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>;
+export declare function failCause<E = never, A = never>(cause: Cause<E>, __tsplusTrace?: string): Exit<E, A>;
 /**
  * @tsplus static fncts.ExitOps interrupt
  * @tsplus location "@fncts/base/data/Exit/constructors"
  */
-export declare function interrupt(id: FiberId): Exit<never, never>;
+export declare function interrupt(id: FiberId, __tsplusTrace?: string): 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>;
+export declare function succeed<E = never, A = never>(value: A, __tsplusTrace?: string): Exit<E, A>;
 /**
  * @tsplus static fncts.ExitOps unit
  * @tsplus location "@fncts/base/data/Exit/constructors"

package/data/Exit/definition.d.ts

@@ -19,19 +19,23 @@ export declare const enum ExitTag {
     Success = "Success",
     Failure = "Failure"
 }
+declare const IOTypeId: unique symbol;
+type IOTypeId = typeof IOTypeId;
 /**
  * @tsplus type fncts.Exit.Failure
  * @tsplus companion fncts.Exit.FailureOps
  */
 export declare class Failure<E> {
     readonly cause: Cause<E>;
+    readonly trace?: string | undefined;
     readonly [ExitTypeId]: ExitTypeId;
     [ExitVariance]: {
         readonly _E: (_: never) => E;
         readonly _A: (_: never) => never;
     };
+    readonly [IOTypeId]: IOTypeId;
     readonly _tag = ExitTag.Failure;
-    constructor(cause: Cause<E>);
+    constructor(cause: Cause<E>, trace?: string | undefined);
     get [Symbol.hash](): number;
     [Symbol.equals](that: unknown): boolean;
 }
@@ -41,13 +45,15 @@ export declare class Failure<E> {
  */
 export declare class Success<A> implements P.Hashable, P.Equatable {
     readonly value: A;
+    readonly trace?: string | undefined;
     readonly [ExitTypeId]: ExitTypeId;
     [ExitVariance]: {
         readonly _E: (_: never) => never;
         readonly _A: (_: never) => A;
     };
+    readonly [IOTypeId]: IOTypeId;
     readonly _tag = ExitTag.Success;
-    constructor(value: A);
+    constructor(value: A, trace?: string | undefined);
     get [Symbol.hash](): number;
     [Symbol.equals](that: unknown): boolean;
 }
@@ -75,3 +81,4 @@ 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>;
+export {};

package/data/Maybe/constructors.d.ts

@@ -7,13 +7,13 @@ import type { Nullable } from "@fncts/base/types";
  * @tsplus static fncts.JustOps __call
  * @tsplus location "@fncts/base/data/Maybe/constructors"
  */
-export declare function just<A>(a: A): Maybe<A>;
+export declare function just<A>(a: A, __tsplusTrace?: string): Maybe<A>;
 /**
  * @tsplus static fncts.MaybeOps nothing
  * @tsplus static fncts.NothingOps __call
  * @tsplus location "@fncts/base/data/Maybe/constructors"
  */
-export declare function nothing<A = never>(): Maybe<A>;
+export declare function nothing<A = never>(__tsplusTrace?: string): Maybe<A>;
 /**
  * @tsplus static fncts.MaybeOps fromNullable
  * @tsplus location "@fncts/base/data/Maybe/constructors"

package/data/Maybe/definition.d.ts

@@ -9,6 +9,8 @@ export declare const MaybeVariance: unique symbol;
 export type MaybeVariance = typeof MaybeVariance;
 export declare const MaybeTypeId: unique symbol;
 export type MaybeTypeId = typeof MaybeTypeId;
+declare const IOTypeId: unique symbol;
+type IOTypeId = typeof IOTypeId;
 export interface MaybeF extends HKT {
     type: Maybe<this["A"]>;
     variance: {
@@ -24,6 +26,8 @@ export declare abstract class Maybe<A> {
         readonly _A: (_: never) => A;
     };
     readonly [MaybeTypeId]: MaybeTypeId;
+    readonly [IOTypeId]: IOTypeId;
+    readonly trace?: string | undefined;
 }
 /**
  * @tsplus type fncts.Just
@@ -31,8 +35,9 @@ export declare abstract class Maybe<A> {
  */
 export declare class Just<A> extends Maybe<A> {
     readonly value: A;
+    readonly trace?: string | undefined;
     readonly _tag = MaybeTag.Just;
-    constructor(value: A);
+    constructor(value: A, trace?: string | undefined);
     [Symbol.equals](that: unknown): boolean;
     get [Symbol.hash](): number;
 }
@@ -41,7 +46,9 @@ export declare class Just<A> extends Maybe<A> {
  * @tsplus companion fncts.NothingOps
  */
 export declare class Nothing extends Maybe<never> {
+    readonly trace?: string | undefined;
     readonly _tag = MaybeTag.Nothing;
+    constructor(trace?: string | undefined);
     [Symbol.equals](that: unknown): boolean;
     get [Symbol.hash](): number;
 }
@@ -77,3 +84,4 @@ export declare function isNothing<A>(self: Maybe<A>): self is Nothing;
  * @tsplus location "@fncts/base/data/Maybe/definition"
  */
 export declare function concrete<A>(self: Maybe<A>): asserts self is Just<A> | Nothing;
+export {};

package/data/exceptions/IOError.d.ts

@@ -0,0 +1,9 @@
+import { Cause } from "@fncts/base/data/Cause/definition";
+export declare const IOErrorTypeId: unique symbol;
+export type IOErrorTypeId = typeof IOErrorTypeId;
+export declare class IOError<E> {
+    readonly cause: Cause<E>;
+    readonly [IOErrorTypeId]: IOErrorTypeId;
+    constructor(cause: Cause<E>);
+}
+export declare function isIOError(u: unknown): u is IOError<unknown>;

package/data/exceptions/NoSuchElementError.d.ts

@@ -1,5 +1,5 @@
 export declare const NoSuchElementErrorTag = "NoSuchElementError";
 export declare class NoSuchElementError extends Error {
     readonly _tag = "NoSuchElementError";
-    constructor(message: string);
+    constructor(message?: string);
 }

package/data/exceptions.d.ts

@@ -4,5 +4,6 @@ export * from "./exceptions/IllegalStateError.js";
 export * from "./exceptions/IndexOutOfBoundsError.js";
 export * from "./exceptions/InterruptedException.js";
 export * from "./exceptions/InvalidCapacityError.js";
+export * from "./exceptions/IOError.js";
 export * from "./exceptions/NoSuchElementError.js";
 export * from "./exceptions/RuntimeError.js";