lite-fp 0.1.0 → 0.4.1

package/README.md

@@ -2,8 +2,8 @@
 
 Tiny, zero‑dependency FP helpers for TypeScript.
 
-- Algebraic data types: `Option`, `Either`, `Result`
-- Product types: `Pair`, `Triple`
+- Algebraic data types: `Option`, `Either`, `Result`, `Maybe`
+- Product types: `Pair`
 - Small, predictable API with discriminated unions
 - ESM and CJS builds, first‑class TypeScript types
 
@@ -24,7 +24,6 @@ import {
   Either,
   Result,
   Pair,
-  Triple,
   some,
   none,
   right,
@@ -37,7 +36,6 @@ const {
   Either,
   Result,
   Pair,
-  Triple,
   some,
   none,
   right,
@@ -52,16 +50,29 @@ const {
 ```ts
 import { Option, some, none } from "lite-fp";
 
-const o1 = Option.fromNullable("hello"); // Some("hello")
-const o2 = Option.fromNullable(null); // None
+const o1 = Option.new("hello"); // Some("hello")
+const o2 = Option.new(null); // None
 
 const upper = Option.map(o1, s => s.toUpperCase()); // Some("HELLO")
 
 const value = Option.getOrElse(o2, "fallback"); // "fallback"
 
-// Convert
-import { done, fail } from "lite-fp";
-const asResult = Option.toResult(o1, new Error("missing")); // Done("hello")
+```
+
+### Maybe (T | null | undefined)
+
+```ts
+import { Maybe } from "lite-fp";
+
+const m1 = Maybe.new(42); // 42
+const m2 = Maybe.new(null); // undefined (None)
+
+const doubled = Maybe.map(m1, x => x * 2); // 84
+const value = Maybe.getOrElse(m2, 0); // 0
+
+if (Maybe.isSome(m1)) {
+  // m1 is number here
+}
 ```
 
 ### Either (A | B)
@@ -101,7 +112,7 @@ const user = await fetch("/api/user")
 ```ts
 import { Result } from "lite-fp";
 
-const r1 = Result.fromNullable("data", "nope"); // Done("data")
+const r1 = Result.new("data", "nope"); // Done("data")
 const r2 = await Result.fromPromise(
   Promise.reject("x"),
   e => new Error(String(e)),
@@ -110,10 +121,11 @@ const r2 = await Result.fromPromise(
 const safe = Result.recover(r2, () => "default"); // Done("default")
 ```
 
-### Pair / Triple
+ 
+### Pair 
 
 ```ts
-import { Pair, Triple, pair, triple } from "lite-fp";
+import { Pair, pair } from "lite-fp";
 
 const p = pair(1, "a"); // Pair<number, string>
 const p2 = Pair.map(
@@ -122,13 +134,6 @@ const p2 = Pair.map(
   s => s.toUpperCase(),
 ); // [2, "A"]
 
-const t = triple(1, 2, 3);
-const t2 = Triple.map(
-  t,
-  x => x + 1,
-  y => y * 2,
-  z => z - 1,
-); // [2, 4, 2]
 ```
 
 ## API Overview
@@ -136,34 +141,50 @@ const t2 = Triple.map(
 - Option
   - Constructors: `none`, `some`, `new`, `fromNullable`, `fromPredicate`, `fromThrowable`, `fromPromise`
   - Type guards: `isSome`, `isNone`
-  - Ops: `map`, `flatMap`, `filter`, `match`
-  - Extract: `getOrElse`, `getOrUndefined`, `getOrThrow`
+  - Ops: `map`, `flatMap`, `filter`, `match`,  `getOrElse`, `getOrUndefined`, `getOrThrow`
   - Combine: `zip`, `apply`, `orElse`
-  - Convert: `toResult`
 
 - Either
   - Constructors: `left`, `right`, `new`, `fromNullable`, `fromThrowable`, `fromPromise`
   - Type guards: `isLeft`, `isRight`
-  - Ops: `map`, `mapLeft`, `bimap`, `flatMap`, `chain`, `fold`, `match`, `getOrElse`, `zip`, `apply`, `tap`, `tapLeft`
+  - Ops: `map`, `mapLeft`, `bimap`, `flatMap`, `chain`, `fold`, `match`, `swap`, `getOrElse`, `zip`, `apply`, `tap`, `tapLeft`
 
 - Result
   - Constructors: `done`, `fail`, `new`, `fromNullable`, `fromThrowable`, `fromPromise`
   - Type guards: `isDone`, `isFail`
   - Ops: `map`, `mapError`, `flatMap`, `match`, `recover`, `getOrElse`, `getOrThrow`, `zip`, `apply`
-  - Convert: `toOption`
 
-- Pair / Triple
-  - `pair`, `triple`, and utilities to map, zip, convert to/from arrays/objects.
+- Maybe (T | null | undefined)
+  - Constructors: `new`, `just`, `nothing`/`nothingNull`/`nothingUndefined`, `fromNullable`, `fromPredicate`, `fromThrowable`, `fromPromise`
+  - Type guards: `isSome`, `isNothing`
+  - Ops: `map`, `flatMap`, `filter`, `match`, `zip`, `apply`, `orElse`
+  - Extract: `getOrElse`, `getOrUndefined`, `getOrThrow`
+
+- Pair 
+  - `pair`, and utilities to map, zip, convert to/from arrays/objects.
 
 See `src/` for the full, well‑typed surface.
 
+## Differences: Result/Either vs Maybe/Option
+
+- Either vs Result
+  - Both are discriminated unions with rich operations.
+  - Either represents two generic branches (Left/Right) and is often used for domain errors (Left) vs success (Right).
+  - Result represents success (`Done`) or failure (`Fail`) explicitly and includes helpers like `recover` and `getOrUndefined`.
+  - Choose based on semantics and style; the APIs are similar.
+
+- Maybe vs Option
+  - Maybe is `T | null | undefined` (lightweight and idiomatic in JS). No runtime tag; use `== null` or the provided guards to narrow.
+  - Option is a discriminated union (`{ $: "Some" } | { $: "None" }`) with stable guards (`isSome`, `isNone`) and utility functions.
+  - Use Maybe when interoperating with APIs that naturally return `null/undefined`; use Option when you want an explicit ADT and consistent operations.
+
 ## Notes
 
 - Prototype additions
   - `Promise.prototype.toEither(onError)` is provided when `Either` is imported.
   - `Promise.prototype.toResult(onError)` is provided when `Result` is imported.
   - `Array.prototype.firstOption()` is provided when `Option` is imported.
-- No runtime dependencies. Fully typed. Tree‑shakeable.
+  - No runtime dependencies. Fully typed. Tree‑shakeable.
 
 ## Contributing
 

package/dist/index.d.mts

@@ -1,74 +1,82 @@
-type Pair<A, B> = readonly [A, B];
-declare const Pair: {
-    fst: <A, B>(p: Pair<A, B>) => A;
-    snd: <A, B>(p: Pair<A, B>) => B;
-    new: <A, B>(fst: A, snd: B) => Pair<A, B>;
-    fromArray: <A, B>([fst, snd]: [A, B]) => Pair<A, B>;
-    fromObject: <A, B>(obj: {
-        fst: A;
-        snd: B;
-    }) => Pair<A, B>;
-    curry: <A>(fst: A) => <B>(snd: B) => Pair<A, B>;
-    mapFirst: <A, B, C>(p: Pair<A, B>, fn: (a: A) => C) => Pair<C, B>;
-    mapSecond: <A, B, C>(p: Pair<A, B>, fn: (b: B) => C) => Pair<A, C>;
-    map: <A, B, C, D>(p: Pair<A, B>, fnA: (a: A) => C, fnB: (b: B) => D) => Pair<C, D>;
-    swap: <A, B>(p: Pair<A, B>) => Pair<B, A>;
-    apply: <A, B, C>(p: Pair<(a: A) => B, C>, value: A) => Pair<B, C>;
-    apply2: <A, B, C>(fnPair: Pair<(a: A) => B, (b: B) => C>, vPair: Pair<A, B>) => Pair<A, C>;
-    reduce: <A, B, C>(p: Pair<A, B>, fn: (a: A, b: B) => C) => C;
-    toArray: <A, B>(p: Pair<A, B>) => [A, B];
-    toObject: <A, B>(p: Pair<A, B>) => {
-        fst: A;
-        snd: B;
-    };
-    eq: <A, B>(p1: Pair<A, B>, p2: Pair<A, B>) => boolean;
-    equals: <A, B>(p1: Pair<A, B>, p2: Pair<A, B>, eqA: (a1: A, a2: A) => boolean, eqB: (b1: B, b2: B) => boolean) => boolean;
-    traverseOption: <A, B, C>(p: Pair<A, Option<B>>, fn: (a: A, b: B) => C) => Option<Pair<A, C>>;
-    traverseResult: <A, B, C, E>(p: Pair<A, Result<B, E>>, fn: (a: A, b: B) => C) => Result<Pair<A, C>, E>;
-    zip: <A, B, C, D>(p1: Pair<A, B>, p2: Pair<C, D>) => Pair<A & C, Pair<B, D>>;
-};
-declare const pair: <A, B>(fst: A, snd: B) => Pair<A, B>;
-
-type Done<T> = {
-    readonly $: "Done";
-    readonly value: T;
+type Left<A> = {
+    readonly $: "Left";
+    readonly value: A;
 };
-type Fail<E> = {
-    readonly $: "Fail";
-    readonly error: E;
+type Right<B> = {
+    readonly $: "Right";
+    readonly value: B;
 };
-type Result<T, E> = Done<T> | Fail<E>;
-declare const Result: {
-    done: <T>(value: T) => Done<T>;
-    fail: <E>(error: E) => Fail<E>;
-    new: <T, E = unknown>(value: T, error: E) => Result<T, E>;
-    isDone: <T, E>(result: Result<T, E>) => result is Done<T>;
-    isFail: <T, E>(result: Result<T, E>) => result is Fail<E>;
-    fromNullable: <T, E = unknown>(value: T | null | undefined, error: E) => Result<T, E>;
-    fromThrowable: <T, E = unknown>(fn: () => T, onError: (e: unknown) => E) => Result<T, E>;
-    fromPromise: <T, E = unknown>(promise: Promise<T>, onError: (e: unknown) => E) => Promise<Result<T, E>>;
-    map: <T, U, E>(result: Result<T, E>, fn: (value: T) => U) => Result<U, E>;
-    mapError: <T, E, F>(result: Result<T, E>, fn: (error: E) => F) => Result<T, F>;
-    flatMap: <T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>) => Result<U, E>;
-    match: <T, E, U>(result: Result<T, E>, matcher: {
-        done: (value: T) => U;
-        fail: (error: E) => U;
-    }) => U;
-    recover: <T, E>(result: Result<T, E>, fn: (error: E) => T) => Result<T, never>;
-    getOrElse: <T, E>(result: Result<T, E>, defaultValue: T) => T;
-    getOrThrow: <T, E>(result: Result<T, E>, onError: (error: E) => never) => T;
-    zip: <A, B, E>(a: Result<A, E>, b: Result<B, E>) => Result<Pair<A, B>, E>;
-    apply: <T, U, E>(fn: Result<(value: T) => U, E>, arg: Result<T, E>) => Result<U, E>;
-    toOption: <T, E>(result: Result<T, E>) => Option<T>;
+declare const left: <A>(value: A) => Left<A>;
+declare const right: <B>(value: B) => Right<B>;
+type Either<A, B> = Left<A> | Right<B>;
+declare const Either: {
+    left: <A>(value: A) => Left<A>;
+    right: <B>(value: B) => Right<B>;
+    new: <A, B>(value: B | null | undefined, error: A) => Either<A, B>;
+    isLeft: <A, B>(e: Either<A, B>) => e is Left<A>;
+    isRight: <A, B>(e: Either<A, B>) => e is Right<B>;
+    fromNullable: <A, B>(value: B | null | undefined, error: A) => Either<A, B>;
+    fromThrowable: <A, B>(fn: () => B, onError: (e: unknown) => A) => Either<A, B>;
+    fromPromise: <A, B>(promise: Promise<B>, onError: (e: unknown) => A) => Promise<Either<A, B>>;
+    map: <A, B, C>(e: Either<A, B>, fn: (r: B) => C) => Either<A, C>;
+    mapLeft: <A, B, C>(e: Either<A, B>, fn: (l: A) => C) => Either<C, B>;
+    bimap: <A, B, C, D>(e: Either<A, B>, fl: (l: A) => C, fr: (r: B) => D) => Either<C, D>;
+    flatMap: <A, B, C>(e: Either<A, B>, fn: (value: B) => Either<A, C>) => Either<A, C>;
+    chain: <A, B, C>(e: Either<A, B>, fn: (r: B) => Either<A, C>) => Either<A, C>;
+    fold: <A, B, C>(e: Either<A, B>, onLeft: (l: A) => C, onRight: (r: B) => C) => C;
+    match: <A, B, C>(e: Either<A, B>, matcher: {
+        right: (value: B) => C;
+        left: (value: A) => C;
+    }) => C;
+    swap: <A, B>(e: Either<A, B>) => Either<B, A>;
+    getOrElse: <A, B>(e: Either<A, B>, defaultValue: B) => B;
+    zip: <E, A, B>(a: Either<E, A>, b: Either<E, B>) => Either<E, [A, B]>;
+    apply: <E, A, B>(fn: Either<E, (value: A) => B>, arg: Either<E, A>) => Either<E, B>;
+    tap: <A, B>(e: Either<A, B>, f: (r: B) => void) => Either<A, B>;
+    tapLeft: <A, B>(e: Either<A, B>, f: (l: A) => void) => Either<A, B>;
 };
-declare const done: <T>(value: T) => Done<T>;
-declare const fail: <E>(error: E) => Fail<E>;
 declare global {
     interface Promise<T> {
-        toResult<E = unknown>(onError?: (e: unknown) => E): Promise<Result<T, E>>;
+        toEither<A>(onError: (e: unknown) => A): Promise<Either<A, T>>;
     }
 }
 
+type NothingNull = null;
+type NothingUndefined = undefined;
+type Nothing = NothingNull | NothingUndefined;
+declare const just: <T>(value: T) => Maybe<T>;
+declare const nothing: () => Nothing;
+type Maybe<T> = T | Nothing;
+declare const Maybe: {
+    just: <T>(value: T) => Maybe<T>;
+    nothing: () => Nothing;
+    new: <T>(v: T | null | undefined) => Maybe<T>;
+    nothingNull: () => NothingNull;
+    nothingUndefined: () => NothingUndefined;
+    isSome: <T>(m: Maybe<T>) => m is T;
+    isNothing: <T>(m: Maybe<T>) => m is Nothing;
+    isNothingNull: <T>(m: Maybe<T>) => m is NothingNull;
+    isNothingUndefined: <T>(m: Maybe<T>) => m is NothingUndefined;
+    fromNullable: <T>(v: T | null | undefined) => Maybe<T>;
+    toNullable: <T>(m: Maybe<T>) => T | null;
+    toUndefined: <T>(m: Maybe<T>) => T | undefined;
+    map: <T, U>(m: Maybe<T>, fn: (v: T) => U) => Maybe<U>;
+    flatMap: <T, U>(m: Maybe<T>, fn: (v: T) => Maybe<U>) => Maybe<U>;
+    filter: <T>(m: Maybe<T>, predicate: (value: T) => boolean) => Maybe<T>;
+    match: <T, U>(m: Maybe<T>, matcher: {
+        some: (v: T) => U;
+        nothing: () => U;
+    }) => U;
+    getOrElse: <T>(m: Maybe<T>, d: T) => T;
+    getOrUndefined: <T>(m: Maybe<T>) => T | undefined;
+    getOrThrow: <T>(m: Maybe<T>, error: Error) => T;
+    fromThrowable: <T>(fn: () => T) => Maybe<T>;
+    fromPromise: <T>(promise: Promise<T>) => Promise<Maybe<T>>;
+    zip: <T, U>(a: Maybe<T>, b: Maybe<U>) => Maybe<[T, U]>;
+    apply: <T, U>(fn: Maybe<(value: T) => U>, opt: Maybe<T>) => Maybe<U>;
+    orElse: <T>(opt: Maybe<T>, other: Maybe<T>) => Maybe<T>;
+};
+
 type None = {
     readonly $: "None";
 };
@@ -76,11 +84,13 @@ type Some<T> = {
     readonly $: "Some";
     readonly value: T;
 };
+declare const none: <T>() => Option<T>;
+declare const some: <T>(value: T) => Option<T>;
 type Option<T> = None | Some<T>;
 declare const Option: {
     none: <T>() => Option<T>;
     some: <T>(value: T) => Option<T>;
-    new: <T>(value: T) => Option<T>;
+    new: <T>(value: T | null | undefined) => Option<T>;
     isSome: <T>(option: Option<T>) => option is Some<T>;
     isNone: <T>(option: Option<T>) => option is None;
     fromNullable: <T>(value: T | null | undefined) => Option<T>;
@@ -100,78 +110,90 @@ declare const Option: {
     zip: <T, U>(a: Option<T>, b: Option<U>) => Option<[T, U]>;
     apply: <T, U>(fn: Option<(value: T) => U>, opt: Option<T>) => Option<U>;
     orElse: <T>(opt: Option<T>, other: Option<T>) => Option<T>;
-    toResult: <T, E>(option: Option<T>, error: E) => Result<T, E>;
 };
-declare const none: <T>() => Option<T>;
-declare const some: <T>(value: T) => Option<T>;
 declare global {
     interface Array<T> {
         firstOption(): Option<T>;
     }
+    interface Promise<T> {
+        toOption(): Promise<Option<T>>;
+    }
 }
 
-type Left<A> = {
-    readonly $: "Left";
-    readonly value: A;
+type Pair<A, B> = readonly [A, B];
+declare const Pair: {
+    fst: <A, B>(p: Pair<A, B>) => A;
+    snd: <A, B>(p: Pair<A, B>) => B;
+    new: <A, B>(a: A, b: B) => Pair<A, B>;
+    fromArray: <A, B>([a, b]: [A, B]) => Pair<A, B>;
+    fromObject: <A, B>(obj: {
+        fst: A;
+        snd: B;
+    }) => Pair<A, B>;
+    curry: <A>(a: A) => <B>(b: B) => Pair<A, B>;
+    mapFirst: <A, B, C>(p: Pair<A, B>, fn: (a: A) => C) => Pair<C, B>;
+    mapSecond: <A, B, C>(p: Pair<A, B>, fn: (b: B) => C) => Pair<A, C>;
+    map: <A, B, C, D>(p: Pair<A, B>, fnA: (a: A) => C, fnB: (b: B) => D) => Pair<C, D>;
+    swap: <A, B>(p: Pair<A, B>) => Pair<B, A>;
+    apply: <A, B, C>(p: Pair<(a: A) => B, C>, value: A) => Pair<B, C>;
+    apply2: <A, B, C>(fnPair: Pair<(a: A) => B, (b: B) => C>, vPair: Pair<A, B>) => Pair<A, C>;
+    reduce: <A, B, C>(p: Pair<A, B>, fn: (a: A, b: B) => C) => C;
+    toArray: <A, B>(p: Pair<A, B>) => [A, B];
+    toObject: <A, B>(p: Pair<A, B>) => {
+        fst: A;
+        snd: B;
+    };
+    eq: <A, B>(p1: Pair<A, B>, p2: Pair<A, B>) => boolean;
+    equals: <A, B>(p1: Pair<A, B>, p2: Pair<A, B>, eqA: (a1: A, a2: A) => boolean, eqB: (b1: B, b2: B) => boolean) => boolean;
+    zip: <A, B, C, D>(p1: Pair<A, B>, p2: Pair<C, D>) => Pair<Pair<A, C>, Pair<B, D>>;
 };
-type Right<B> = {
-    readonly $: "Right";
-    readonly value: B;
+declare const pair: <A, B>(a: A, b: B) => Pair<A, B>;
+
+type Done<T> = {
+    readonly v: T;
 };
-type Either<A, B> = Left<A> | Right<B>;
-declare const Either: {
-    left: <A>(value: A) => Left<A>;
-    right: <B>(value: B) => Right<B>;
-    new: <A, B>(rgt: B, lft: A) => Either<A, B>;
-    isLeft: <A, B>(e: Either<A, B>) => e is Left<A>;
-    isRight: <A, B>(e: Either<A, B>) => e is Right<B>;
-    fromNullable: <A, B>(value: B | null | undefined, error: A) => Either<A, B>;
-    fromThrowable: <A, B>(fn: () => B, onError: (e: unknown) => A) => Either<A, B>;
-    fromPromise: <A, B>(promise: Promise<B>, onError: (e: unknown) => A) => Promise<Either<A, B>>;
-    map: <A, B, C>(e: Either<A, B>, fn: (r: B) => C) => Either<A, C>;
-    mapLeft: <A, B, C>(e: Either<A, B>, fn: (l: A) => C) => Either<C, B>;
-    bimap: <A, B, C, D>(e: Either<A, B>, fl: (l: A) => C, fr: (r: B) => D) => Either<C, D>;
-    flatMap: <A, B, C>(e: Either<A, B>, fn: (value: B) => Either<A, C>) => Either<A, C>;
-    chain: <A, B, C>(e: Either<A, B>, fn: (r: B) => Either<A, C>) => Either<A, C>;
-    fold: <A, B, C>(e: Either<A, B>, onLeft: (l: A) => C, onRight: (r: B) => C) => C;
-    match: <A, B, C>(e: Either<A, B>, matcher: {
-        right: (value: B) => C;
-        left: (value: A) => C;
-    }) => C;
-    swap: <A, B>(e: Either<A, B>) => Either<B, A>;
-    getOrElse: <A, B>(e: Either<A, B>, defaultValue: B) => B;
-    zip: <E, A, B>(a: Either<E, A>, b: Either<E, B>) => Either<E, Pair<A, B>>;
-    apply: <E, A, B>(fn: Either<E, (value: A) => B>, arg: Either<E, A>) => Either<E, B>;
-    tap: <A, B>(e: Either<A, B>, f: (r: B) => void) => Either<A, B>;
-    tapLeft: <A, B>(e: Either<A, B>, f: (l: A) => void) => Either<A, B>;
+type Fail<E> = {
+    readonly e: E;
+};
+declare const done: <T>(value: T) => Done<T>;
+declare const fail: <E>(error: E) => Fail<E>;
+type Result<T, E> = Done<T> | Fail<E>;
+declare const Result: {
+    done: <T>(value: T) => Done<T>;
+    fail: <E>(error: E) => Fail<E>;
+    OK: <T>(value: T) => Done<T>;
+    Err: <E>(error: E) => Fail<E>;
+    new: <T, E>(value: T | null | undefined, error: E) => Result<T, E>;
+    isDone: <T, E>(r: Result<T, E>) => r is Done<T>;
+    isFail: <T, E>(r: Result<T, E>) => r is Fail<E>;
+    isOk: <T, E>(r: Result<T, E>) => r is Done<T>;
+    isErr: <T, E>(r: Result<T, E>) => r is Fail<E>;
+    fromNullable: <T, E>(value: T | null | undefined, error: E) => Result<T, E>;
+    fromThrowable: <T, E>(fn: () => T, onError: (e: unknown) => E) => Result<T, E>;
+    fromPromise: <T, E>(promise: Promise<T>, onError: (e: unknown) => E) => Promise<Result<T, E>>;
+    map: <T, E, U>(r: Result<T, E>, fn: (a: T) => U) => Result<U, E>;
+    mapErr: <T, E, F>(r: Result<T, E>, fn: (b: E) => F) => Result<T, F>;
+    bimap: <T, E, U, F>(r: Result<T, E>, onDone: (a: T) => U, onFail: (b: E) => F) => Result<U, F>;
+    flatMap: <T, E, C>(r: Result<T, E>, fn: (a: T) => Result<C, E>) => Result<C, E>;
+    match: <T, E, U>(r: Result<T, E>, matcher: {
+        done: (a: T) => U;
+        fail: (b: E) => U;
+    }) => U;
+    fold: <T, E, U>(r: Result<T, E>, onFail: (error: E) => U, onDone: (value: T) => U) => U;
+    recover: <T, E>(r: Result<T, E>, fn: (error: E) => T) => Result<T, E>;
+    getOrElse: <T, E>(r: Result<T, E>, d: T) => T;
+    getOrThrow: <T, E>(r: Result<T, E>, onError: (b: E) => never) => T;
+    zip: <T, U, E>(a: Result<T, E>, b: Result<U, E>) => Result<[T, U], E>;
+    apply: <T, U, E>(fn: Result<(a: T) => U, E>, arg: Result<T, E>) => Result<U, E>;
+    orElse: <T, E>(a: Result<T, E>, b: Result<T, E>) => Result<T, E>;
+    filter: <T, E>(r: Result<T, E>, predicate: (a: T) => boolean, onFalse: E) => Result<T, E>;
+    tap: <T, E>(r: Result<T, E>, f: (a: T) => void) => Result<T, E>;
+    tapErr: <T, E>(r: Result<T, E>, f: (b: E) => void) => Result<T, E>;
 };
 declare global {
     interface Promise<T> {
-        toEither<A>(onError: (e: unknown) => A): Promise<Either<A, T>>;
+        toResult<E = unknown>(onError: (e: unknown) => E): Promise<Result<T, E>>;
     }
 }
-declare const left: <A>(value: A) => Left<A>;
-declare const right: <B>(value: B) => Right<B>;
-
-type Triple<A, B, C> = readonly [A, B, C];
-declare const Triple: {
-    fst: <A, B, C>(t: Triple<A, B, C>) => A;
-    snd: <A, B, C>(t: Triple<A, B, C>) => B;
-    thd: <A, B, C>(t: Triple<A, B, C>) => C;
-    new: <A, B, C>(fst: A, snd: B, thd: C) => Triple<A, B, C>;
-    fromArray: <A, B, C>([fst, snd, thd]: [A, B, C]) => Triple<A, B, C>;
-    toArray: <A, B, C>(t: Triple<A, B, C>) => [A, B, C];
-    fromObject: <A, B, C>(obj: {
-        fst: A;
-        snd: B;
-        thd: C;
-    }) => Triple<A, B, C>;
-    curry: <A>(fst: A) => <B>(snd: B) => <C>(thd: C) => Triple<A, B, C>;
-    equals: <A, B, C>(t1: Triple<A, B, C>, t2: Triple<A, B, C>, eqA: (a1: A, a2: A) => boolean, eqB: (b1: B, b2: B) => boolean, eqC: (c1: C, c2: C) => boolean) => boolean;
-    map: <A, B, C, D, E, F>(t: Triple<A, B, C>, fnA: (a: A) => D, fnB: (b: B) => E, fnC: (c: C) => F) => Triple<D, E, F>;
-    zip: <A, B, C, D, E, F>(t1: Triple<A, B, C>, t2: Triple<D, E, F>) => Triple<A & D, B & E, C & F>;
-    apply: <A, B, C, D>(t: Triple<(a: A) => B, (b: B) => C, (c: C) => D>, value: A) => Triple<B, C, D>;
-};
-declare const triple: <A, B, C>(fst: A, snd: B, thd: C) => Triple<A, B, C>;
 
-export { type Done, Either, type Fail, type Left, type None, Option, Pair, Result, type Right, type Some, Triple, done, fail, left, none, pair, right, some, triple };
+export { type Done, Either, type Fail, type Left, Maybe, type None, type Nothing, type NothingNull, type NothingUndefined, Option, Pair, Result, type Right, type Some, done, fail, just, left, none, nothing, pair, right, some };