lite-fp 0.1.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025 lite-fp Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,178 @@
+# lite-fp
+
+Tiny, zero‑dependency FP helpers for TypeScript.
+
+- Algebraic data types: `Option`, `Either`, `Result`
+- Product types: `Pair`, `Triple`
+- Small, predictable API with discriminated unions
+- ESM and CJS builds, first‑class TypeScript types
+
+## Install
+
+```sh
+npm i lite-fp
+# or
+pnpm add lite-fp
+```
+
+## Import
+
+```ts
+// ESM
+import {
+  Option,
+  Either,
+  Result,
+  Pair,
+  Triple,
+  some,
+  none,
+  right,
+  left,
+} from "lite-fp";
+
+// CJS
+const {
+  Option,
+  Either,
+  Result,
+  Pair,
+  Triple,
+  some,
+  none,
+  right,
+  left,
+} = require("lite-fp");
+```
+
+## Quick Start
+
+### Option
+
+```ts
+import { Option, some, none } from "lite-fp";
+
+const o1 = Option.fromNullable("hello"); // Some("hello")
+const o2 = Option.fromNullable(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")
+```
+
+### Either (A | B)
+
+```ts
+import { Either, left, right } from "lite-fp";
+
+type Err = { message: string };
+
+const parseJson = (s: string) =>
+  Either.fromThrowable(
+    () => JSON.parse(s),
+    e => ({ message: String(e) }) as Err,
+  );
+
+const e1 = parseJson('{"a":1}'); // Right({ a: 1 })
+const e2 = parseJson("invalid"); // Left({ message: "..." })
+
+const msg = Either.fold(
+  e2,
+  l => `err: ${l.message}`,
+  r => `ok: ${Object.keys(r).length}`,
+); // => "err: ..."
+```
+
+Promise helper
+
+```ts
+// Adds Promise.prototype.toEither(onError)
+const user = await fetch("/api/user")
+  .then(r => r.json())
+  .toEither(e => new Error(String(e))); // Either<Error, User>
+```
+
+### Result (Done | Fail)
+
+```ts
+import { Result } from "lite-fp";
+
+const r1 = Result.fromNullable("data", "nope"); // Done("data")
+const r2 = await Result.fromPromise(
+  Promise.reject("x"),
+  e => new Error(String(e)),
+);
+
+const safe = Result.recover(r2, () => "default"); // Done("default")
+```
+
+### Pair / Triple
+
+```ts
+import { Pair, Triple, pair, triple } from "lite-fp";
+
+const p = pair(1, "a"); // Pair<number, string>
+const p2 = Pair.map(
+  p,
+  x => x + 1,
+  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
+
+- Option
+  - Constructors: `none`, `some`, `new`, `fromNullable`, `fromPredicate`, `fromThrowable`, `fromPromise`
+  - Type guards: `isSome`, `isNone`
+  - Ops: `map`, `flatMap`, `filter`, `match`
+  - Extract: `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`
+
+- 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.
+
+See `src/` for the full, well‑typed surface.
+
+## 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.
+
+## Contributing
+
+1. Fork the repository.
+2. Create a new branch: `git checkout -b feature-name`.
+3. Commit your changes: `git commit -m 'Add some feature'`.
+4. Push to the branch: `git push origin feature-name`.
+5. Open a pull request.
+
+## License
+
+Distributed under the MIT License. See the [LICENSE](LICENSE) file for more details.

package/dist/index.d.mts

@@ -0,0 +1,177 @@
+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 Fail<E> = {
+    readonly $: "Fail";
+    readonly error: E;
+};
+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 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>>;
+    }
+}
+
+type None = {
+    readonly $: "None";
+};
+type Some<T> = {
+    readonly $: "Some";
+    readonly value: 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>;
+    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>;
+    fromPredicate: <T>(value: T, predicate: (value: T) => boolean) => Option<T>;
+    fromThrowable: <T>(fn: () => T) => Option<T>;
+    fromPromise: <T>(promise: Promise<T>) => Promise<Option<T>>;
+    map: <T, U>(option: Option<T>, fn: (value: T) => U) => Option<U>;
+    flatMap: <T, U>(option: Option<T>, fn: (value: T) => Option<U>) => Option<U>;
+    filter: <T>(option: Option<T>, predicate: (value: T) => boolean) => Option<T>;
+    match: <T, U>(option: Option<T>, matcher: {
+        some: (value: T) => U;
+        none: () => U;
+    }) => U;
+    getOrElse: <T>(option: Option<T>, defaultValue: T) => T;
+    getOrUndefined: <T>(option: Option<T>) => T | undefined;
+    getOrThrow: <T>(option: Option<T>, error: Error) => T;
+    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>;
+    }
+}
+
+type Left<A> = {
+    readonly $: "Left";
+    readonly value: A;
+};
+type Right<B> = {
+    readonly $: "Right";
+    readonly value: 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>(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>;
+};
+declare global {
+    interface Promise<T> {
+        toEither<A>(onError: (e: unknown) => A): Promise<Either<A, T>>;
+    }
+}
+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 };

package/dist/index.d.ts

@@ -0,0 +1,177 @@
+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 Fail<E> = {
+    readonly $: "Fail";
+    readonly error: E;
+};
+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 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>>;
+    }
+}
+
+type None = {
+    readonly $: "None";
+};
+type Some<T> = {
+    readonly $: "Some";
+    readonly value: 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>;
+    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>;
+    fromPredicate: <T>(value: T, predicate: (value: T) => boolean) => Option<T>;
+    fromThrowable: <T>(fn: () => T) => Option<T>;
+    fromPromise: <T>(promise: Promise<T>) => Promise<Option<T>>;
+    map: <T, U>(option: Option<T>, fn: (value: T) => U) => Option<U>;
+    flatMap: <T, U>(option: Option<T>, fn: (value: T) => Option<U>) => Option<U>;
+    filter: <T>(option: Option<T>, predicate: (value: T) => boolean) => Option<T>;
+    match: <T, U>(option: Option<T>, matcher: {
+        some: (value: T) => U;
+        none: () => U;
+    }) => U;
+    getOrElse: <T>(option: Option<T>, defaultValue: T) => T;
+    getOrUndefined: <T>(option: Option<T>) => T | undefined;
+    getOrThrow: <T>(option: Option<T>, error: Error) => T;
+    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>;
+    }
+}
+
+type Left<A> = {
+    readonly $: "Left";
+    readonly value: A;
+};
+type Right<B> = {
+    readonly $: "Right";
+    readonly value: 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>(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>;
+};
+declare global {
+    interface Promise<T> {
+        toEither<A>(onError: (e: unknown) => A): Promise<Either<A, T>>;
+    }
+}
+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 };