lite-fp 0.1.0 → 0.4.0

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/package.json

@@ -1,43 +1,49 @@
 {
   "name": "lite-fp",
-  "version": "0.1.0",
+  "version": "0.4.0",
   "description": "Functional programming utilities.",
   "license": "MIT",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
-  "types": "./dist/index.d.ts",
-  "bugs": {
-    "url": "https://github.com/naoeosavio/lite-fp/issues"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/naoeosavio/lite-fp.git"
-  },
-  "author": "it is not savio",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs",
       "require": "./dist/index.js"
     },
     "./package.json": "./package.json"
   },
-  "sideEffects": false,
-  "files": [
-    "dist"
+  "bugs": {
+    "url": "https://github.com/naoeosavio/lite-fp/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/naoeosavio/lite-fp.git"
+  },
+  "author": "it is not savio",
+  "keywords": [
+    "functional-programming",
+    "fp",
+    "typescript",
+    "either",
+    "option",
+    "maybe",
+    "result",
+    "adt",
+    "algebraic-data-types",
+    "utilities"
   ],
   "scripts": {
-    "build": "tsup",
     "dev": "tsup --watch",
     "lint": "tsc",
-    "format": "prettier --write .",
-    "format:check": "prettier --check .",
-    "ci": "npm run build && npm run lint && npm run format:check",
-    "prepublishOnly": "npm run build"
+    "build": "tsup",
+    "format": "biome check --write src",
+    "check": "biome check src",
+    "ci": "npm run lint && npm run check && npm run build",
+    "prepublishOnly": "npm run ci"
   },
   "devDependencies": {
-    "prettier": "^3.3.3",
-    "tsup": "^8.0.1",
+    "@biomejs/biome": "2.2.6",
+    "tsup": "8.5.1",
     "typescript": "^5.4.5"
   }
 }

package/dist/index.d.mts

@@ -1,177 +0,0 @@
-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

@@ -1,177 +0,0 @@
-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 };