@fncts/base 0.0.27 → 0.0.28

package/_src/data/Eq/api.ts

@@ -0,0 +1,8 @@
+/**
+ * @tsplus pipeable fncts.Eq contramap
+ */
+export function contramap<A, B>(f: (b: B) => A) {
+  return (self: Eq<A>): Eq<B> => {
+    return Eq({ equals: (b2) => (b1) => self.equals(f(b2))(f(b1)) });
+  };
+}

package/_src/data/Eq.ts

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

package/_src/data/Equatable/api.ts

@@ -1,3 +1,5 @@
+import type { EqualsContext } from "@fncts/base/data/Equatable/definition";
+
 import { isEquatable } from "@fncts/base/data/Equatable/definition";
 import {
   createCircularEqualCreator,
@@ -5,30 +7,45 @@ import {
   sameValueZeroEqual,
 } from "@fncts/base/data/Equatable/fast-equals";
 
-/**
- * @tsplus static fncts.EquatableOps deepEquals
- */
-export const deepEquals = createComparator(
+const deepEqualsComparator = createComparator(
   createCircularEqualCreator((eq) => (a, b, meta) => {
+    const equalsContext: EqualsContext = { comparator: deepEquals };
     if (isEquatable(a)) {
-      return a[Symbol.equals](b);
+      return a[Symbol.equals](b, equalsContext);
     } else if (isEquatable(b)) {
-      return b[Symbol.equals](a);
+      return b[Symbol.equals](a, equalsContext);
     } else {
       return eq(a, b, meta);
     }
   }),
 );
 
+/**
+ * @tsplus static fncts.EquatableOps deepEquals
+ */
+export function deepEquals<A>(a: A, b: unknown): boolean {
+  const context: EqualsContext = { comparator: deepEquals };
+  if (isEquatable(a)) {
+    return a[Symbol.equals](b, context);
+  } else if (isEquatable(b)) {
+    return b[Symbol.equals](a, context);
+  } else {
+    return deepEqualsComparator(a, b);
+  }
+}
+
 /**
  * @tsplus static fncts.EquatableOps strictEquals
  * @tsplus operator fncts.Equatable ==
  */
 export function strictEquals<A>(a: A, b: unknown): boolean {
+  const context: EqualsContext = {
+    comparator: strictEquals,
+  };
   if (isEquatable(a)) {
-    return a[Symbol.equals](b);
+    return a[Symbol.equals](b, context);
   } else if (isEquatable(b)) {
-    return b[Symbol.equals](a);
+    return b[Symbol.equals](a, context);
   }
   return sameValueZeroEqual(a, b);
 }
@@ -38,5 +55,5 @@ export function strictEquals<A>(a: A, b: unknown): boolean {
  * @tsplus operator fncts.Equatable !=
  */
 export function strictNotEquals<A>(a: A, b: unknown): boolean {
-  return !strictEquals(a, b)
-}
+  return !strictEquals(a, b);
+}

package/_src/data/Equatable/definition.ts

@@ -3,15 +3,19 @@
  */
 export const equalsSymbol: unique symbol = Symbol.for("fncts.Equatable");
 
+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 function isEquatable(u: unknown): u is Equatable {
-  return isObject(u) && Symbol.equals in u;
+  return isObject(u) && typeof u[Symbol.equals] === "function";
 }
 
 /**

package/_src/data/Exit/api.ts

@@ -1,3 +1,5 @@
+import { IOError } from "@fncts/base/data/exceptions";
+
 import { identity, tuple } from "../function.js";
 import { ExitTag } from "./definition.js";
 
@@ -201,3 +203,27 @@ export function zipWithCause<E, A, G, B, C>(
     }
   };
 }
+
+/**
+ * Returns the Exit's Success value if it exists
+ *
+ * @tsplus getter fncts.Exit value
+ */
+export function value<E, A>(self: Exit<E, A>): A | undefined {
+  if (self.isFailure()) {
+    return undefined;
+  }
+  return self.value;
+}
+
+/**
+ * Returns the Exit's Success value if it exists, or throws the pretty-printed Cause if it doesn't
+ *
+ * @tsplus getter fncts.Exit valueOrThrow
+ */
+export function valueOrThrow<E, A>(self: Exit<E, A>): A {
+  if (self.isFailure()) {
+    throw new IOError(self.cause);
+  }
+  return self.value;
+}

package/_src/data/Exit/constructors.ts

@@ -3,14 +3,14 @@ import { Failure, Success } from "./definition.js";
 /**
  * @tsplus static fncts.ExitOps halt
  */
-export function halt(defect: unknown): Exit<never, never> {
+export function halt(defect: unknown, __tsplusTrace?: string): Exit<never, never> {
   return failCause(Cause.halt(defect));
 }
 
 /**
  * @tsplus static fncts.ExitOps fail
  */
-export function fail<E = never, A = never>(e: E): Exit<E, A> {
+export function fail<E = never, A = never>(e: E, __tsplusTrace?: string): Exit<E, A> {
   return failCause(Cause.fail(e));
 }
 
@@ -31,22 +31,22 @@ export function fromMaybe<E, A>(fa: Maybe<A>, onNothing: () => E): Exit<E, A> {
 /**
  * @tsplus static fncts.ExitOps failCause
  */
-export function failCause<E = never, A = never>(cause: Cause<E>): Exit<E, A> {
-  return new Failure(cause);
+export function failCause<E = never, A = never>(cause: Cause<E>, __tsplusTrace?: string): Exit<E, A> {
+  return new Failure(cause, __tsplusTrace);
 }
 
 /**
  * @tsplus static fncts.ExitOps interrupt
  */
-export function interrupt(id: FiberId): Exit<never, never> {
+export function interrupt(id: FiberId, __tsplusTrace?: string): Exit<never, never> {
   return failCause(Cause.interrupt(id));
 }
 
 /**
  * @tsplus static fncts.ExitOps succeed
  */
-export function succeed<E = never, A = never>(value: A): Exit<E, A> {
-  return new Success(value);
+export function succeed<E = never, A = never>(value: A, __tsplusTrace?: string): Exit<E, A> {
+  return new Success(value, __tsplusTrace);
 }
 
 /**

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/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/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";