@jeengbe/prelude 0.1.2 → 0.1.4

package/README.md

@@ -1,9 +1,135 @@
 <h1 align="center">@jeengbe/prelude</h1>
 <div align="center">
 
+A small, dependency-free functional programming toolkit for TypeScript.
+
 [![License](https://img.shields.io/npm/l/@jeengbe/prelude)](https://github.com/jeengbe/ts-packages/blob/master/packages/prelude/LICENSE)
 [![Version](https://img.shields.io/npm/v/@jeengbe/prelude)](https://www.npmjs.com/package/@jeengbe/prelude)
 [![JSR](https://jsr.io/badges/@jeengbe/prelude)](https://jsr.io/@jeengbe/prelude)
 [![Coverage](https://codecov.io/gh/jeengbe/ts-packages/branch/master/graph/badge.svg?component=prelude)](https://app.codecov.io/gh/jeengbe/ts-packages/tree/master/packages/prelude)
 
 </div>
+
+It provides an `Either` type for representing a value that's either a success or a failure (with an async-aware `EitherP` counterpart for `Promise`-returning pipelines), and a handful of small `Maybe` helpers for working with values that may be `undefined`.
+
+## Installation
+
+The package is published to [npm](https://www.npmjs.com/package/@jeengbe/prelude) and [JSR](https://jsr.io/@jeengbe/prelude) as `@jeengbe/prelude`. Versions follow Semantic Versioning.
+
+## Usage
+
+### `Either`
+
+`Either<L, R>` is a union of `Left<L>` and `Right<R>`, conventionally used to represent a failure (`Left`) or a success (`Right`).
+
+```ts
+import { Either } from '@jeengbe/prelude';
+
+const ok: Either<string, number> = Either.right(42);
+const err: Either<string, number> = Either.left('something went wrong');
+```
+
+Because `Either<L, R>` is a plain union type, `isLeft()`/`isRight()` narrow it in both directions:
+
+```ts
+declare const e: Either<string, number>;
+
+if (e.isLeft()) {
+  e; // Left<string>
+} else {
+  e; // Right<number>
+}
+```
+
+Use `map`/`leftMap`/`bimap` to transform the contained value without unwrapping it:
+
+```ts
+Either.right(2).map((n) => n * 2); // Right(4)
+Either.left('oops').leftMap((e) => e.toUpperCase()); // Left('OOPS')
+```
+
+Use `flatMap`/`leftFlatMap` to chain further `Either`-returning operations:
+
+```ts
+declare function parseAge(input: string): Either<string, number>;
+
+Either.right('42').flatMap(parseAge);
+```
+
+Use `tap`/`flatTap` to run a side effect on the right value without altering the `Either`:
+
+```ts
+Either.right(user).tap((u) => console.log(`loaded user ${u.id}`));
+```
+
+To get the values back out, `get()`/`getLeft()` return a `Maybe<T>` (i.e. `undefined` if this is the other side), `getOrElse` takes a fallback function for the right value, and `pair()` deconstructs the `Either` into a `[Maybe<L>, Maybe<R>]` tuple:
+
+```ts
+const [error, value] = result.pair();
+const value2 = result.getOrElse(() => defaultValue);
+```
+
+`Either.fromMaybe` and `Either.cond` build an `Either` out of a `Maybe` or a boolean condition, respectively:
+
+```ts
+Either.fromMaybe(maybeUser, () => 'user not found');
+Either.cond(
+  items.length > 0,
+  () => 'no items',
+  () => items[0],
+);
+```
+
+### `EitherP`
+
+`EitherP<L, R>` it wraps a `PromiseLike<Either<L, R>>`: It exposes the same API as `Either`, and is itself directly awaitable.
+
+```ts
+import { EitherP } from '@jeengbe/prelude';
+
+declare function fetchUser(id: string): Promise<Either<string, User>>;
+
+const name = await EitherP.fromPromise(fetchUser('1'))
+  .map((u) => u.name)
+  .getOrElse(() => 'anonymous');
+```
+
+Every `Either` method has an `Async` counterpart (`mapAsync`, `flatMapAsync`, `tapAsync`, etc.) that accepts a function returning a `Promise` and returns an `EitherP`, letting you chain asynchronous steps without leaving the `Either` world:
+
+```ts
+Either.right(orderId)
+  .flatMapAsync(async (id) =>
+    (await isValid(id)) ? Either.right(id) : Either.left('invalid order'),
+  )
+  .tapAsync(async (id) => audit.log(id))
+  .then((result) => result.get());
+```
+
+### `Maybe`
+
+`Maybe<T>` is a type alias for `T | undefined`, along with a few helpers for working with values that may be missing:
+
+- `isDefined` narrows a `Maybe<T>` to `T`.
+- `mapMaybe` transforms the value if present, and passes `undefined` through otherwise.
+- `flattenMaybe` collapses a `Maybe<Maybe<T>>` into a single level.
+- `ifTrue`/`ifFalse` run a function conditionally, returning its result or `undefined`.
+- `matchPair` pattern-matches a `[Maybe<A>, Maybe<B>]` tuple against all four presence combinations.
+
+```ts
+import { ifTrue, isDefined, mapMaybe, matchPair } from '@jeengbe/prelude';
+
+const upper = mapMaybe(name, (n) => n.toUpperCase());
+
+if (isDefined(upper)) {
+  // upper: string
+}
+
+const warning = ifTrue(retries > 3, () => 'too many retries');
+
+matchPair([error, value], {
+  neither: () => 'nothing to report',
+  a: (e) => `error: ${e}`,
+  b: (v) => `value: ${v}`,
+  both: (e, v) => `error ${e}, but got a partial value: ${v}`,
+});
+```

package/dist/either.d.mts

@@ -5,37 +5,59 @@ declare abstract class EitherBase<L, R> {
    * Maps the value of this Either if it is a Right, performs no operation if this is a Left.
    */
   map<R2>(fn: (t: R) => R2): Either<L, R2>;
+  /**
+   * Maps the value of this Either if it is a Right, performs no operation if this is a Left, asynchronously.
+   */
   mapAsync<R2>(fn: (t: R) => Promise<R2>): EitherP<L, R2>;
   /**
    * Flat maps the value of this Either if it is a Left, performs no operation if this is a Right.
    */
   leftFlatMap<L2, R2>(fn: (t: L) => Either<L2, R2>): Either<L2, R | R2>;
+  /**
+   * Flat maps the value of this Either if it is a Left, performs no operation if this is a Right, asynchronously.
+   */
   leftFlatMapAsync<L2, R2>(fn: (t: L) => PromiseLike<Either<L2, R2>>): EitherP<L2, R | R2>;
   /**
    * Maps the value of this Either if it is a Left, performs no operation if this is a Right.
    */
   leftMap<L2>(fn: (t: L) => L2): Either<L2, R>;
+  /**
+   * Maps the value of this Either if it is a Left, performs no operation if this is a Right, asynchronously.
+   */
   leftMapAsync<L2>(fn: (t: L) => Promise<L2>): EitherP<L2, R>;
   /**
    * Applies the provided functions to the value of this Either, depending on whether it is a Right or a Left and returns a new Either.
    */
   bimap<L2, R2>(leftFn: (l: L) => L2, rightFn: (r: R) => R2): Either<L2, R2>;
+  /**
+   * Applies the provided functions to the value of this Either, depending on whether it is a Right or a Left and returns a new Either, asynchronously.
+   */
   bimapAsync<L2, R2>(leftFn: (l: L) => Promise<L2>, rightFn: (r: R) => Promise<R2>): EitherP<L2, R2>;
   /**
    * Runs the provided function with the value of this Either if it is a Right, performs no operation if this is a Left.
    */
   tap(fn: (t: R) => void): Either<L, R>;
+  /**
+   * Runs the provided function with the value of this Either if it is a Right, performs no operation if this is a Left, asynchronously.
+   */
   tapAsync(fn: (t: R) => Promise<void>): EitherP<L, R>;
   /**
    * Runs the provided function with the value of this Either if it is a Right, performs no operation if this is a Left.
    * If the result of the function is a Left, it will be returned, otherwise the original Right value will be returned.
    */
   flatTap<L2>(fn: (t: R) => Either<L2, void>): Either<L | L2, R>;
+  /**
+   * Runs the provided function with the value of this Either if it is a Right, performs no operation if this is a Left, asynchronously.
+   * If the result of the function is a Left, it will be returned, otherwise the original Right value will be returned.
+   */
   flatTapAsync<L2>(fn: (t: R) => PromiseLike<Either<L2, void>>): EitherP<L | L2, R>;
   /**
    * Flat maps the value of this Either if it is a Right, performs no operation if this is a Left.
    */
   flatMap<L2, R2>(fn: (t: R) => Either<L2, R2>): Either<L | L2, R2>;
+  /**
+   * Flat maps the value of this Either if it is a Right, performs no operation if this is a Left, asynchronously.
+   */
   flatMapAsync<L2, R2>(fn: (t: R) => PromiseLike<Either<L2, R2>>): EitherP<L | L2, R2>;
   /**
    * Applies the provided functions to the value of this Either, depending on whether it is a Right or a Left and returns the result.
@@ -80,16 +102,18 @@ declare class Left<L> extends EitherBase<L, never> {
   constructor(value: L);
   fold<U1, U2>(leftFn: (l: L) => U1, _rightFn: (r: never) => U2): U1 | U2;
   getLeft(): L;
+  toString(): string;
+  get [Symbol.toStringTag](): string;
 }
 declare class Right<R> extends EitherBase<never, R> {
   private readonly value;
   constructor(value: R);
   fold<U1, U2>(_leftFn: (l: never) => U1, rightFn: (r: R) => U2): U1 | U2;
   get(): R;
+  toString(): string;
+  get [Symbol.toStringTag](): string;
 }
 /**
- * Mimics the [Cats Either[L, R]](https://typelevel.org/cats/datatypes/either.html) type.
- *
  * Either<L, R> is a union of Left<L> and Right<R>, so narrowing works in both directions:
  *
  * ```ts
@@ -112,11 +136,22 @@ declare namespace Either {
    * Creates a new Right Either with the provided value.
    */
   function right<R>(value: R): Either<never, R>;
+  /**
+   * Creates a Right Either from a Maybe if it is defined, or a Left Either from the result of the provided function otherwise.
+   */
   function fromMaybe<L, R>(value: Maybe<R>, leftValue: () => L): Either<L, R>;
+  /**
+   * Creates a Right Either from the result of `rightFn` if `bool` is true, or a Left Either from the result of `leftFn` otherwise.
+   */
   function cond<L, R>(bool: boolean, leftFn: () => L, rightFn: () => R): Either<L, R>;
 }
 /**
- * Mimics the [Cats EitherT[Future, L, R]](https://typelevel.org/cats/datatypes/eithert.html) type.
+ * Asynchronous version of @{link Either}, allowing for asynchronous operations on the values of the Either.
+ *
+ * ```ts
+ * declare const e: EitherP<string, number>;
+ *
+ * const result = await e.get(); // result is of type Maybe<number>
  */
 declare class EitherP<L, R> implements PromiseLike<Either<L, R>> {
   private readonly value;
@@ -125,37 +160,59 @@ declare class EitherP<L, R> implements PromiseLike<Either<L, R>> {
    * Maps the value of this Either if it is a Right, performs no operation if this is a Left.
    */
   map<R2>(fn: (t: R) => R2): EitherP<L, R2>;
+  /**
+   * Maps the value of this Either if it is a Right, performs no operation if this is a Left, asynchronously.
+   */
   mapAsync<R2>(fn: (t: R) => Promise<R2>): EitherP<L, R2>;
   /**
    * Maps the value of this Either if it is a Left, performs no operation if this is a Right.
    */
   leftMap<L2>(fn: (t: L) => L2): EitherP<L2, R>;
+  /**
+   * Maps the value of this Either if it is a Left, performs no operation if this is a Right, asynchronously.
+   */
   leftMapAsync<L2>(fn: (t: L) => Promise<L2>): EitherP<L2, R>;
   /**
    * Flat maps the value of this Either if it is a Left, performs no operation if this is a Right.
    */
   leftFlatMap<L2, R2>(fn: (t: L) => Either<L2, R2>): EitherP<L2, R | R2>;
+  /**
+   * Flat maps the value of this Either if it is a Left, performs no operation if this is a Right, asynchronously.
+   */
   leftFlatMapAsync<L2, R2>(fn: (t: L) => PromiseLike<Either<L2, R2>>): EitherP<L2, R | R2>;
   /**
    * Applies the provided functions to the value of this Either, depending on whether it is a Right or a Left and returns a new Either.
    */
   bimap<L2, R2>(leftFn: (l: L) => L2, rightFn: (r: R) => R2): EitherP<L2, R2>;
+  /**
+   * Applies the provided functions to the value of this Either, depending on whether it is a Right or a Left and returns a new Either, asynchronously.
+   */
   bimapAsync<L2, R2>(leftFn: (l: L) => Promise<L2>, rightFn: (r: R) => Promise<R2>): EitherP<L2, R2>;
   /**
    * Runs the provided function with the value of this Either if it is a Right, performs no operation if this is a Left.
    */
   tap(fn: (t: R) => void): EitherP<L, R>;
+  /**
+   * Runs the provided function with the value of this Either if it is a Right, performs no operation if this is a Left, asynchronously.
+   */
   tapAsync(fn: (t: R) => Promise<void>): EitherP<L, R>;
   /**
    * Runs the provided function with the value of this Either if it is a Right, performs no operation if this is a Left.
    * If the result of the function is a Left, it will be returned, otherwise the original Right value will be returned.
    */
   flatTap<L2>(fn: (t: R) => Either<L2, void>): EitherP<L | L2, R>;
+  /**
+   * Runs the provided function with the value of this Either if it is a Right, performs no operation if this is a Left, asynchronously.
+   * If the result of the function is a Left, it will be returned, otherwise the original Right value will be returned.
+   */
   flatTapAsync<L2>(fn: (t: R) => PromiseLike<Either<L2, void>>): EitherP<L | L2, R>;
   /**
    * Flat maps the value of this Either if it is a Right, performs no operation if this is a Left.
    */
   flatMap<L2, R2>(fn: (t: R) => Either<L2, R2>): EitherP<L | L2, R2>;
+  /**
+   * Flat maps the value of this Either if it is a Right, performs no operation if this is a Left, asynchronously.
+   */
   flatMapAsync<L2, R2>(fn: (t: R) => PromiseLike<Either<L2, R2>>): EitherP<L | L2, R2>;
   /**
    * Applies the provided functions to the value of this Either, depending on whether it is a Right or a Left and returns the result.
@@ -202,15 +259,23 @@ declare class EitherP<L, R> implements PromiseLike<Either<L, R>> {
    * Creates a new Right EitherP with the provided value.
    */
   static right<R>(value: Promise<R>): EitherP<never, R>;
+  /**
+   * Creates a Right EitherP from a Promise of a Maybe if it resolves to a defined value, or a Left EitherP from the result of the provided function otherwise.
+   */
   static fromMaybe<L, R>(value: Promise<Maybe<R>>, leftValue: () => Promise<L>): EitherP<L, R>;
   /**
-   * @deprecated
+   * Creates a new EitherP from a Promise of an Either.
    */
-  static fromEither<L, R>(either: PromiseLike<Either<L, R>>): EitherP<L, R>;
   static fromPromise<L, R>(either: PromiseLike<Either<L, R>>): EitherP<L, R>;
+  /**
+   * Creates a new Right EitherP if the provided Promise resolves to true, or a new Left EitherP otherwise.
+   */
   static cond<L, R>(bool: Promise<boolean>, leftFn: () => Promise<L>, rightFn: () => Promise<R>): EitherP<L, R>;
+  /**
+   * Resolves this EitherP to its underlying Either, allowing `await` usage on EitherP instances.
+   */
   then<U>(onfulfilled?: (value: Either<L, R>) => U | PromiseLike<U>): PromiseLike<U>;
 }
 //#endregion
-export { Either, EitherP, Left, Right };
+export { Either, EitherBase, EitherP, Left, Right };
 //# sourceMappingURL=either.d.mts.map

package/dist/either.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"either.d.mts","names":[],"sources":["../src/either.ts"],"mappings":"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"}
+{"version":3,"file":"either.d.mts","names":[],"sources":["../src/either.ts"],"mappings":"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"}

package/dist/either.mjs

@@ -8,6 +8,9 @@ var EitherBase = class {
 	map(fn) {
 		return this.flatMap((value) => Either.right(fn(value)));
 	}
+	/**
+	* Maps the value of this Either if it is a Right, performs no operation if this is a Left, asynchronously.
+	*/
 	mapAsync(fn) {
 		return EitherP.fromPromise(toEitherPromise(this)).mapAsync(fn);
 	}
@@ -17,6 +20,9 @@ var EitherBase = class {
 	leftFlatMap(fn) {
 		return this.fold((l) => fn(l), (r) => Either.right(r));
 	}
+	/**
+	* Flat maps the value of this Either if it is a Left, performs no operation if this is a Right, asynchronously.
+	*/
 	leftFlatMapAsync(fn) {
 		return EitherP.fromPromise(toEitherPromise(this)).leftFlatMapAsync(fn);
 	}
@@ -26,6 +32,9 @@ var EitherBase = class {
 	leftMap(fn) {
 		return this.fold((l) => Either.left(fn(l)), (r) => Either.right(r));
 	}
+	/**
+	* Maps the value of this Either if it is a Left, performs no operation if this is a Right, asynchronously.
+	*/
 	leftMapAsync(fn) {
 		return EitherP.fromPromise(toEitherPromise(this)).leftMapAsync(fn);
 	}
@@ -35,6 +44,9 @@ var EitherBase = class {
 	bimap(leftFn, rightFn) {
 		return this.fold((l) => Either.left(leftFn(l)), (r) => Either.right(rightFn(r)));
 	}
+	/**
+	* Applies the provided functions to the value of this Either, depending on whether it is a Right or a Left and returns a new Either, asynchronously.
+	*/
 	bimapAsync(leftFn, rightFn) {
 		return EitherP.fromPromise(toEitherPromise(this)).bimapAsync(leftFn, rightFn);
 	}
@@ -47,6 +59,9 @@ var EitherBase = class {
 			return Either.right(value);
 		});
 	}
+	/**
+	* Runs the provided function with the value of this Either if it is a Right, performs no operation if this is a Left, asynchronously.
+	*/
 	tapAsync(fn) {
 		return EitherP.fromPromise(toEitherPromise(this)).tapAsync(fn);
 	}
@@ -57,6 +72,10 @@ var EitherBase = class {
 	flatTap(fn) {
 		return this.flatMap((value) => fn(value).map(() => value));
 	}
+	/**
+	* Runs the provided function with the value of this Either if it is a Right, performs no operation if this is a Left, asynchronously.
+	* If the result of the function is a Left, it will be returned, otherwise the original Right value will be returned.
+	*/
 	flatTapAsync(fn) {
 		return EitherP.fromPromise(toEitherPromise(this)).flatTapAsync(fn);
 	}
@@ -66,6 +85,9 @@ var EitherBase = class {
 	flatMap(fn) {
 		return this.fold((l) => Either.left(l), (r) => fn(r));
 	}
+	/**
+	* Flat maps the value of this Either if it is a Right, performs no operation if this is a Left, asynchronously.
+	*/
 	flatMapAsync(fn) {
 		return EitherP.fromPromise(toEitherPromise(this)).flatMapAsync(fn);
 	}
@@ -99,15 +121,11 @@ var EitherBase = class {
 	/**
 	* Gets the right value if this is a Right or undefined if it's a Left.
 	*/
-	get() {
-		return this.fold(() => void 0, (r) => r);
-	}
+	get() {}
 	/**
 	* Returns the left value if this is a Left or undefined if it's a Right.
 	*/
-	getLeft() {
-		return this.fold((l) => l, () => void 0);
-	}
+	getLeft() {}
 	/**
 	* Gets the right value if this is a Right or the result of the provided function if it's a Left.
 	*/
@@ -130,6 +148,12 @@ var Left = class extends EitherBase {
 	getLeft() {
 		return this.value;
 	}
+	toString() {
+		return `Left(${String(this.value)})`;
+	}
+	get [Symbol.toStringTag]() {
+		return "Left";
+	}
 };
 var Right = class extends EitherBase {
 	value;
@@ -143,6 +167,12 @@ var Right = class extends EitherBase {
 	get() {
 		return this.value;
 	}
+	toString() {
+		return `Right(${String(this.value)})`;
+	}
+	get [Symbol.toStringTag]() {
+		return "Right";
+	}
 };
 let Either;
 (function(_Either) {
@@ -164,7 +194,12 @@ let Either;
 	_Either.cond = cond;
 })(Either || (Either = {}));
 /**
-* Mimics the [Cats EitherT[Future, L, R]](https://typelevel.org/cats/datatypes/eithert.html) type.
+* Asynchronous version of @{link Either}, allowing for asynchronous operations on the values of the Either.
+*
+* ```ts
+* declare const e: EitherP<string, number>;
+*
+* const result = await e.get(); // result is of type Maybe<number>
 */
 var EitherP = class EitherP {
 	value;
@@ -177,6 +212,9 @@ var EitherP = class EitherP {
 	map(fn) {
 		return new EitherP(this.value.then((e) => e.map(fn)));
 	}
+	/**
+	* Maps the value of this Either if it is a Right, performs no operation if this is a Left, asynchronously.
+	*/
 	mapAsync(fn) {
 		return this.flatMapAsync(async (value) => Either.right(await fn(value)));
 	}
@@ -186,6 +224,9 @@ var EitherP = class EitherP {
 	leftMap(fn) {
 		return new EitherP(this.value.then((e) => e.leftMap(fn)));
 	}
+	/**
+	* Maps the value of this Either if it is a Left, performs no operation if this is a Right, asynchronously.
+	*/
 	leftMapAsync(fn) {
 		return new EitherP(this.value.then(async (e) => await e.fold(async (l) => Either.left(await fn(l)), async (r) => Either.right(r))));
 	}
@@ -195,6 +236,9 @@ var EitherP = class EitherP {
 	leftFlatMap(fn) {
 		return new EitherP(this.value.then((e) => e.leftFlatMap(fn)));
 	}
+	/**
+	* Flat maps the value of this Either if it is a Left, performs no operation if this is a Right, asynchronously.
+	*/
 	leftFlatMapAsync(fn) {
 		return new EitherP(this.value.then(async (e) => await e.fold(async (left) => await fn(left), async (right) => Either.right(right))));
 	}
@@ -204,6 +248,9 @@ var EitherP = class EitherP {
 	bimap(leftFn, rightFn) {
 		return new EitherP(this.value.then((e) => e.bimap(leftFn, rightFn)));
 	}
+	/**
+	* Applies the provided functions to the value of this Either, depending on whether it is a Right or a Left and returns a new Either, asynchronously.
+	*/
 	bimapAsync(leftFn, rightFn) {
 		return new EitherP(this.value.then(async (e) => await e.fold(async (l) => Either.left(await leftFn(l)), async (r) => Either.right(await rightFn(r)))));
 	}
@@ -213,6 +260,9 @@ var EitherP = class EitherP {
 	tap(fn) {
 		return new EitherP(this.value.then((e) => e.tap(fn)));
 	}
+	/**
+	* Runs the provided function with the value of this Either if it is a Right, performs no operation if this is a Left, asynchronously.
+	*/
 	tapAsync(fn) {
 		return this.flatMapAsync(async (value) => {
 			await fn(value);
@@ -226,6 +276,10 @@ var EitherP = class EitherP {
 	flatTap(fn) {
 		return new EitherP(this.value.then((e) => e.flatTap(fn)));
 	}
+	/**
+	* Runs the provided function with the value of this Either if it is a Right, performs no operation if this is a Left, asynchronously.
+	* If the result of the function is a Left, it will be returned, otherwise the original Right value will be returned.
+	*/
 	flatTapAsync(fn) {
 		return this.flatMapAsync(async (value) => (await fn(value)).map(() => value));
 	}
@@ -235,6 +289,9 @@ var EitherP = class EitherP {
 	flatMap(fn) {
 		return new EitherP(this.value.then((e) => e.flatMap(fn)));
 	}
+	/**
+	* Flat maps the value of this Either if it is a Right, performs no operation if this is a Left, asynchronously.
+	*/
 	flatMapAsync(fn) {
 		return new EitherP(this.value.then((e) => e.fold(async (left) => Either.left(left), (right) => fn(right))));
 	}
@@ -301,26 +358,32 @@ var EitherP = class EitherP {
 	static right(value) {
 		return new EitherP(value.then((v) => Either.right(v)));
 	}
+	/**
+	* Creates a Right EitherP from a Promise of a Maybe if it resolves to a defined value, or a Left EitherP from the result of the provided function otherwise.
+	*/
 	static fromMaybe(value, leftValue) {
 		return new EitherP(value.then(async (v) => isDefined(v) ? Either.right(v) : Either.left(await leftValue())));
 	}
 	/**
-	* @deprecated
+	* Creates a new EitherP from a Promise of an Either.
 	*/
-	static fromEither(either) {
-		return new EitherP(either);
-	}
 	static fromPromise(either) {
 		return new EitherP(either);
 	}
+	/**
+	* Creates a new Right EitherP if the provided Promise resolves to true, or a new Left EitherP otherwise.
+	*/
 	static cond(bool, leftFn, rightFn) {
 		return new EitherP(bool.then(async (b) => b ? Either.right(await rightFn()) : Either.left(await leftFn())));
 	}
+	/**
+	* Resolves this EitherP to its underlying Either, allowing `await` usage on EitherP instances.
+	*/
 	then(onfulfilled) {
 		return this.value.then(onfulfilled);
 	}
 };
 
 //#endregion
-export { Either, EitherP, Left, Right };
+export { Either, EitherBase, EitherP, Left, Right };
 //# sourceMappingURL=either.mjs.map

package/dist/either.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"either.mjs","names":[],"sources":["../src/either.ts"],"sourcesContent":["import type { Maybe } from './maybe.js';\nimport { isDefined } from './maybe.js';\n\n// Note that xxxAsync implementations in Either all look like:\n// EitherP.fromPromise(toEitherPromise(this)).xxxAsync(...)\n//\n// And conversely, xxx implementations in EitherP all look like:\n// new EitherP(this.value.then(e => e.xxx(...)))\n\nabstract class EitherBase<L, R> {\n  /**\n   * Maps the value of this Either if it is a Right, performs no operation if this is a Left.\n   */\n  map<R2>(fn: (t: R) => R2): Either<L, R2> {\n    return this.flatMap((value) => Either.right(fn(value)));\n  }\n\n  mapAsync<R2>(fn: (t: R) => Promise<R2>): EitherP<L, R2> {\n    return EitherP.fromPromise(toEitherPromise(this)).mapAsync(fn);\n  }\n\n  /**\n   * Flat maps the value of this Either if it is a Left, performs no operation if this is a Right.\n   */\n  leftFlatMap<L2, R2>(fn: (t: L) => Either<L2, R2>): Either<L2, R | R2> {\n    return this.fold(\n      (l) => fn(l),\n      (r) => Either.right(r),\n    );\n  }\n\n  leftFlatMapAsync<L2, R2>(fn: (t: L) => PromiseLike<Either<L2, R2>>): EitherP<L2, R | R2> {\n    return EitherP.fromPromise(toEitherPromise(this)).leftFlatMapAsync(fn);\n  }\n\n  /**\n   * Maps the value of this Either if it is a Left, performs no operation if this is a Right.\n   */\n  leftMap<L2>(fn: (t: L) => L2): Either<L2, R> {\n    return this.fold(\n      (l) => Either.left(fn(l)),\n      (r) => Either.right(r),\n    );\n  }\n\n  leftMapAsync<L2>(fn: (t: L) => Promise<L2>): EitherP<L2, R> {\n    return EitherP.fromPromise(toEitherPromise(this)).leftMapAsync(fn);\n  }\n\n  /**\n   * Applies the provided functions to the value of this Either, depending on whether it is a Right or a Left and returns a new Either.\n   */\n  bimap<L2, R2>(leftFn: (l: L) => L2, rightFn: (r: R) => R2): Either<L2, R2> {\n    return this.fold(\n      (l) => Either.left(leftFn(l)),\n      (r) => Either.right(rightFn(r)),\n    );\n  }\n\n  bimapAsync<L2, R2>(\n    leftFn: (l: L) => Promise<L2>,\n    rightFn: (r: R) => Promise<R2>,\n  ): EitherP<L2, R2> {\n    return EitherP.fromPromise(toEitherPromise(this)).bimapAsync(leftFn, rightFn);\n  }\n\n  /**\n   * Runs the provided function with the value of this Either if it is a Right, performs no operation if this is a Left.\n   */\n  tap(fn: (t: R) => void): Either<L, R> {\n    return this.flatMap((value) => {\n      fn(value);\n      return Either.right(value);\n    });\n  }\n\n  tapAsync(fn: (t: R) => Promise<void>): EitherP<L, R> {\n    return EitherP.fromPromise(toEitherPromise(this)).tapAsync(fn);\n  }\n\n  /**\n   * Runs the provided function with the value of this Either if it is a Right, performs no operation if this is a Left.\n   * If the result of the function is a Left, it will be returned, otherwise the original Right value will be returned.\n   */\n  flatTap<L2>(fn: (t: R) => Either<L2, void>): Either<L | L2, R> {\n    return this.flatMap((value) => fn(value).map(() => value));\n  }\n\n  flatTapAsync<L2>(fn: (t: R) => PromiseLike<Either<L2, void>>): EitherP<L | L2, R> {\n    return EitherP.fromPromise(toEitherPromise(this)).flatTapAsync(fn);\n  }\n\n  /**\n   * Flat maps the value of this Either if it is a Right, performs no operation if this is a Left.\n   */\n  flatMap<L2, R2>(fn: (t: R) => Either<L2, R2>): Either<L | L2, R2> {\n    return this.fold(\n      (l) => Either.left(l),\n      (r) => fn(r),\n    );\n  }\n\n  flatMapAsync<L2, R2>(fn: (t: R) => PromiseLike<Either<L2, R2>>): EitherP<L | L2, R2> {\n    return EitherP.fromPromise(toEitherPromise(this)).flatMapAsync(fn);\n  }\n\n  /**\n   * Applies the provided functions to the value of this Either, depending on whether it is a Right or a Left and returns the result.\n   */\n  abstract fold<U1, U2>(leftFn: (l: L) => U1, rightFn: (r: R) => U2): U1 | U2;\n\n  /**\n   * Allows to deconstruct the Either using:\n   *\n   * @example\n   *\n   * ```ts\n   * declare const e: Either<string, number>;\n   *\n   * const [left, right] = e.pair();\n   * ```\n   *\n   */\n  pair(): [Maybe<L>, Maybe<R>] {\n    return [this.getLeft(), this.get()];\n  }\n\n  /**\n   * Returns true if this Either is a Right, false otherwise.\n   */\n  isRight(): this is Right<R> {\n    return this.fold(\n      () => false,\n      () => true,\n    );\n  }\n\n  /**\n   * Returns true if this Either is a Left, false otherwise.\n   */\n  isLeft(): this is Left<L> {\n    return this.fold(\n      () => true,\n      () => false,\n    );\n  }\n\n  /**\n   * Gets the right value if this is a Right or undefined if it's a Left.\n   */\n  get(): Maybe<R> {\n    return this.fold(\n      () => undefined,\n      (r) => r,\n    );\n  }\n\n  /**\n   * Returns the left value if this is a Left or undefined if it's a Right.\n   */\n  getLeft(): Maybe<L> {\n    return this.fold(\n      (l) => l,\n      () => undefined,\n    );\n  }\n\n  /**\n   * Gets the right value if this is a Right or the result of the provided function if it's a Left.\n   */\n  getOrElse<T>(defaultValue: (l: L) => T): R | T {\n    return this.fold(\n      (l) => defaultValue(l),\n      (r) => r,\n    );\n  }\n}\n\n// EitherBase is abstract with only Left/Right as concrete subclasses; the cast is always valid.\nfunction toEitherPromise<L, R>(e: EitherBase<L, R>): Promise<Either<L, R>> {\n  return Promise.resolve(e as unknown as Either<L, R>);\n}\n\nexport class Left<L> extends EitherBase<L, never> {\n  constructor(private readonly value: L) {\n    super();\n  }\n\n  fold<U1, U2>(leftFn: (l: L) => U1, _rightFn: (r: never) => U2): U1 | U2 {\n    return leftFn(this.value);\n  }\n\n  override getLeft(): L {\n    return this.value;\n  }\n}\n\nexport class Right<R> extends EitherBase<never, R> {\n  constructor(private readonly value: R) {\n    super();\n  }\n\n  fold<U1, U2>(_leftFn: (l: never) => U1, rightFn: (r: R) => U2): U1 | U2 {\n    return rightFn(this.value);\n  }\n\n  override get(): R {\n    return this.value;\n  }\n}\n\n/**\n * Mimics the [Cats Either[L, R]](https://typelevel.org/cats/datatypes/either.html) type.\n *\n * Either<L, R> is a union of Left<L> and Right<R>, so narrowing works in both directions:\n *\n * ```ts\n * declare const e: Either<string, number>;\n *\n * if (e.isLeft()) {\n *   e; // Left<string>\n * } else {\n *   e; // Right<number>\n * }\n * ```\n */\nexport type Either<L, R> = Left<L> | Right<R>;\n\nexport namespace Either {\n  /**\n   * Creates a new Left Either with the provided value.\n   */\n  export function left<L>(value: L): Either<L, never> {\n    return new Left(value);\n  }\n\n  /**\n   * Creates a new Right Either with the provided value.\n   */\n  export function right<R>(value: R): Either<never, R> {\n    return new Right(value);\n  }\n\n  export function fromMaybe<L, R>(value: Maybe<R>, leftValue: () => L): Either<L, R> {\n    return isDefined(value) ? Either.right(value) : Either.left(leftValue());\n  }\n\n  export function cond<L, R>(bool: boolean, leftFn: () => L, rightFn: () => R): Either<L, R> {\n    return bool ? Either.right(rightFn()) : Either.left(leftFn());\n  }\n}\n\n/**\n * Mimics the [Cats EitherT[Future, L, R]](https://typelevel.org/cats/datatypes/eithert.html) type.\n */\nexport class EitherP<L, R> implements PromiseLike<Either<L, R>> {\n  private constructor(private readonly value: PromiseLike<Either<L, R>>) {}\n\n  /**\n   * Maps the value of this Either if it is a Right, performs no operation if this is a Left.\n   */\n  map<R2>(fn: (t: R) => R2): EitherP<L, R2> {\n    return new EitherP(this.value.then((e) => e.map(fn)));\n  }\n\n  mapAsync<R2>(fn: (t: R) => Promise<R2>): EitherP<L, R2> {\n    return this.flatMapAsync(async (value) => Either.right(await fn(value)));\n  }\n\n  /**\n   * Maps the value of this Either if it is a Left, performs no operation if this is a Right.\n   */\n  leftMap<L2>(fn: (t: L) => L2): EitherP<L2, R> {\n    return new EitherP(this.value.then((e) => e.leftMap(fn)));\n  }\n\n  leftMapAsync<L2>(fn: (t: L) => Promise<L2>): EitherP<L2, R> {\n    return new EitherP(\n      this.value.then(\n        async (e) =>\n          await e.fold(\n            async (l) => Either.left(await fn(l)),\n            async (r) => Either.right(r),\n          ),\n      ),\n    );\n  }\n\n  /**\n   * Flat maps the value of this Either if it is a Left, performs no operation if this is a Right.\n   */\n  leftFlatMap<L2, R2>(fn: (t: L) => Either<L2, R2>): EitherP<L2, R | R2> {\n    return new EitherP(this.value.then((e) => e.leftFlatMap(fn)));\n  }\n\n  leftFlatMapAsync<L2, R2>(fn: (t: L) => PromiseLike<Either<L2, R2>>): EitherP<L2, R | R2> {\n    return new EitherP(\n      this.value.then<Either<L2, R | R2>>(\n        async (e) =>\n          await e.fold(\n            async (left) => await fn(left),\n            async (right) => Either.right(right),\n          ),\n      ),\n    );\n  }\n\n  /**\n   * Applies the provided functions to the value of this Either, depending on whether it is a Right or a Left and returns a new Either.\n   */\n  bimap<L2, R2>(leftFn: (l: L) => L2, rightFn: (r: R) => R2): EitherP<L2, R2> {\n    return new EitherP(this.value.then((e) => e.bimap(leftFn, rightFn)));\n  }\n\n  bimapAsync<L2, R2>(\n    leftFn: (l: L) => Promise<L2>,\n    rightFn: (r: R) => Promise<R2>,\n  ): EitherP<L2, R2> {\n    return new EitherP(\n      this.value.then(\n        async (e) =>\n          await e.fold(\n            async (l) => Either.left(await leftFn(l)),\n            async (r) => Either.right(await rightFn(r)),\n          ),\n      ),\n    );\n  }\n\n  /**\n   * Runs the provided function with the value of this Either if it is a Right, performs no operation if this is a Left.\n   */\n  tap(fn: (t: R) => void): EitherP<L, R> {\n    return new EitherP(this.value.then((e) => e.tap(fn)));\n  }\n\n  tapAsync(fn: (t: R) => Promise<void>): EitherP<L, R> {\n    return this.flatMapAsync(async (value) => {\n      await fn(value);\n      return Either.right(value);\n    });\n  }\n\n  /**\n   * Runs the provided function with the value of this Either if it is a Right, performs no operation if this is a Left.\n   * If the result of the function is a Left, it will be returned, otherwise the original Right value will be returned.\n   */\n  flatTap<L2>(fn: (t: R) => Either<L2, void>): EitherP<L | L2, R> {\n    return new EitherP(this.value.then((e) => e.flatTap(fn)));\n  }\n\n  flatTapAsync<L2>(fn: (t: R) => PromiseLike<Either<L2, void>>): EitherP<L | L2, R> {\n    return this.flatMapAsync(async (value) => (await fn(value)).map(() => value));\n  }\n\n  /**\n   * Flat maps the value of this Either if it is a Right, performs no operation if this is a Left.\n   */\n  flatMap<L2, R2>(fn: (t: R) => Either<L2, R2>): EitherP<L | L2, R2> {\n    return new EitherP(this.value.then((e) => e.flatMap(fn)));\n  }\n\n  flatMapAsync<L2, R2>(fn: (t: R) => PromiseLike<Either<L2, R2>>): EitherP<L | L2, R2> {\n    return new EitherP(\n      this.value.then<Either<L | L2, R2>>((e) =>\n        e.fold(\n          async (left) => Either.left(left),\n          (right) => fn(right),\n        ),\n      ),\n    );\n  }\n\n  /**\n   * Applies the provided functions to the value of this Either, depending on whether it is a Right or a Left and returns the result.\n   */\n  async fold<U1, U2>(leftFn: (l: L) => U1, rightFn: (r: R) => U2): Promise<U1 | U2> {\n    return (await this.value).fold(leftFn, rightFn);\n  }\n\n  /**\n   * Allows to deconstruct the Either using:\n   *\n   * @example\n   *\n   * ```ts\n   * declare const e: EitherP<string, number>;\n   *\n   * const [left, right] = await e.pair();\n   * ```\n   *\n   */\n  async pair(): Promise<[Maybe<L>, Maybe<R>]> {\n    return [await this.getLeft(), await this.get()];\n  }\n\n  /**\n   * Returns true if this Either is a Right, false otherwise.\n   */\n  async isRight(): Promise<boolean> {\n    return (await this.value).isRight();\n  }\n\n  /**\n   * Returns true if this Either is a Left, false otherwise.\n   */\n  async isLeft(): Promise<boolean> {\n    return !(await this.isRight());\n  }\n\n  /**\n   * Gets the right value if this is a Right or undefined if it's a Left.\n   */\n  async get(): Promise<Maybe<R>> {\n    return (await this.value).get();\n  }\n\n  /**\n   * Returns the left value if this is a Left or undefined if it's a Right.\n   */\n  async getLeft(): Promise<Maybe<L>> {\n    return (await this.value).getLeft();\n  }\n\n  /**\n   * Gets the right value if this is a Right or the result of the provided function if it's a Left.\n   */\n  async getOrElse<T>(defaultValue: (l: L) => T): Promise<R | T> {\n    return (await this.value).getOrElse(defaultValue);\n  }\n\n  /**\n   * Creates a new Left EitherP with the provided value.\n   */\n  static left<L>(value: Promise<L>): EitherP<L, never> {\n    return new EitherP(value.then((v) => Either.left(v)));\n  }\n\n  /**\n   * Creates a new Right EitherP with the provided value.\n   */\n  static right<R>(value: Promise<R>): EitherP<never, R> {\n    return new EitherP(value.then((v) => Either.right(v)));\n  }\n\n  static fromMaybe<L, R>(value: Promise<Maybe<R>>, leftValue: () => Promise<L>): EitherP<L, R> {\n    return new EitherP(\n      value.then(async (v) => (isDefined(v) ? Either.right(v) : Either.left(await leftValue()))),\n    );\n  }\n\n  /**\n   * @deprecated\n   */\n  static fromEither<L, R>(either: PromiseLike<Either<L, R>>): EitherP<L, R> {\n    return new EitherP(either);\n  }\n\n  static fromPromise<L, R>(either: PromiseLike<Either<L, R>>): EitherP<L, R> {\n    return new EitherP(either);\n  }\n\n  static cond<L, R>(\n    bool: Promise<boolean>,\n    leftFn: () => Promise<L>,\n    rightFn: () => Promise<R>,\n  ): EitherP<L, R> {\n    return new EitherP(\n      bool.then(async (b) => (b ? Either.right(await rightFn()) : Either.left(await leftFn()))),\n    );\n  }\n\n  // oxlint-disable-next-line unicorn/no-thenable -- Deliberately implementing PromiseLike to allow for `await` usage on EitherP instances.\n  then<U>(onfulfilled?: (value: Either<L, R>) => U | PromiseLike<U>): PromiseLike<U> {\n    return this.value.then(onfulfilled);\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"either.mjs","names":[],"sources":["../src/either.ts"],"sourcesContent":["import type { Maybe } from './maybe.js';\nimport { isDefined } from './maybe.js';\n\n// Note that xxxAsync implementations in Either all look like:\n// EitherP.fromPromise(toEitherPromise(this)).xxxAsync(...)\n//\n// And conversely, xxx implementations in EitherP all look like:\n// new EitherP(this.value.then(e => e.xxx(...)))\n\nexport abstract class EitherBase<L, R> {\n  /**\n   * Maps the value of this Either if it is a Right, performs no operation if this is a Left.\n   */\n  map<R2>(fn: (t: R) => R2): Either<L, R2> {\n    return this.flatMap((value) => Either.right(fn(value)));\n  }\n\n  /**\n   * Maps the value of this Either if it is a Right, performs no operation if this is a Left, asynchronously.\n   */\n  mapAsync<R2>(fn: (t: R) => Promise<R2>): EitherP<L, R2> {\n    return EitherP.fromPromise(toEitherPromise(this)).mapAsync(fn);\n  }\n\n  /**\n   * Flat maps the value of this Either if it is a Left, performs no operation if this is a Right.\n   */\n  leftFlatMap<L2, R2>(fn: (t: L) => Either<L2, R2>): Either<L2, R | R2> {\n    return this.fold(\n      (l) => fn(l),\n      (r) => Either.right(r),\n    );\n  }\n\n  /**\n   * Flat maps the value of this Either if it is a Left, performs no operation if this is a Right, asynchronously.\n   */\n  leftFlatMapAsync<L2, R2>(fn: (t: L) => PromiseLike<Either<L2, R2>>): EitherP<L2, R | R2> {\n    return EitherP.fromPromise(toEitherPromise(this)).leftFlatMapAsync(fn);\n  }\n\n  /**\n   * Maps the value of this Either if it is a Left, performs no operation if this is a Right.\n   */\n  leftMap<L2>(fn: (t: L) => L2): Either<L2, R> {\n    return this.fold(\n      (l) => Either.left(fn(l)),\n      (r) => Either.right(r),\n    );\n  }\n\n  /**\n   * Maps the value of this Either if it is a Left, performs no operation if this is a Right, asynchronously.\n   */\n  leftMapAsync<L2>(fn: (t: L) => Promise<L2>): EitherP<L2, R> {\n    return EitherP.fromPromise(toEitherPromise(this)).leftMapAsync(fn);\n  }\n\n  /**\n   * Applies the provided functions to the value of this Either, depending on whether it is a Right or a Left and returns a new Either.\n   */\n  bimap<L2, R2>(leftFn: (l: L) => L2, rightFn: (r: R) => R2): Either<L2, R2> {\n    return this.fold(\n      (l) => Either.left(leftFn(l)),\n      (r) => Either.right(rightFn(r)),\n    );\n  }\n\n  /**\n   * Applies the provided functions to the value of this Either, depending on whether it is a Right or a Left and returns a new Either, asynchronously.\n   */\n  bimapAsync<L2, R2>(\n    leftFn: (l: L) => Promise<L2>,\n    rightFn: (r: R) => Promise<R2>,\n  ): EitherP<L2, R2> {\n    return EitherP.fromPromise(toEitherPromise(this)).bimapAsync(leftFn, rightFn);\n  }\n\n  /**\n   * Runs the provided function with the value of this Either if it is a Right, performs no operation if this is a Left.\n   */\n  tap(fn: (t: R) => void): Either<L, R> {\n    return this.flatMap((value) => {\n      fn(value);\n      return Either.right(value);\n    });\n  }\n\n  /**\n   * Runs the provided function with the value of this Either if it is a Right, performs no operation if this is a Left, asynchronously.\n   */\n  tapAsync(fn: (t: R) => Promise<void>): EitherP<L, R> {\n    return EitherP.fromPromise(toEitherPromise(this)).tapAsync(fn);\n  }\n\n  /**\n   * Runs the provided function with the value of this Either if it is a Right, performs no operation if this is a Left.\n   * If the result of the function is a Left, it will be returned, otherwise the original Right value will be returned.\n   */\n  flatTap<L2>(fn: (t: R) => Either<L2, void>): Either<L | L2, R> {\n    return this.flatMap((value) => fn(value).map(() => value));\n  }\n\n  /**\n   * Runs the provided function with the value of this Either if it is a Right, performs no operation if this is a Left, asynchronously.\n   * If the result of the function is a Left, it will be returned, otherwise the original Right value will be returned.\n   */\n  flatTapAsync<L2>(fn: (t: R) => PromiseLike<Either<L2, void>>): EitherP<L | L2, R> {\n    return EitherP.fromPromise(toEitherPromise(this)).flatTapAsync(fn);\n  }\n\n  /**\n   * Flat maps the value of this Either if it is a Right, performs no operation if this is a Left.\n   */\n  flatMap<L2, R2>(fn: (t: R) => Either<L2, R2>): Either<L | L2, R2> {\n    return this.fold(\n      (l) => Either.left(l),\n      (r) => fn(r),\n    );\n  }\n\n  /**\n   * Flat maps the value of this Either if it is a Right, performs no operation if this is a Left, asynchronously.\n   */\n  flatMapAsync<L2, R2>(fn: (t: R) => PromiseLike<Either<L2, R2>>): EitherP<L | L2, R2> {\n    return EitherP.fromPromise(toEitherPromise(this)).flatMapAsync(fn);\n  }\n\n  /**\n   * Applies the provided functions to the value of this Either, depending on whether it is a Right or a Left and returns the result.\n   */\n  abstract fold<U1, U2>(leftFn: (l: L) => U1, rightFn: (r: R) => U2): U1 | U2;\n\n  /**\n   * Allows to deconstruct the Either using:\n   *\n   * @example\n   *\n   * ```ts\n   * declare const e: Either<string, number>;\n   *\n   * const [left, right] = e.pair();\n   * ```\n   *\n   */\n  pair(): [Maybe<L>, Maybe<R>] {\n    return [this.getLeft(), this.get()];\n  }\n\n  /**\n   * Returns true if this Either is a Right, false otherwise.\n   */\n  isRight(): this is Right<R> {\n    return this.fold(\n      () => false,\n      () => true,\n    );\n  }\n\n  /**\n   * Returns true if this Either is a Left, false otherwise.\n   */\n  isLeft(): this is Left<L> {\n    return this.fold(\n      () => true,\n      () => false,\n    );\n  }\n\n  /**\n   * Gets the right value if this is a Right or undefined if it's a Left.\n   */\n  get(): Maybe<R> {\n    // Overridden in Right#get\n    return undefined;\n  }\n\n  /**\n   * Returns the left value if this is a Left or undefined if it's a Right.\n   */\n  getLeft(): Maybe<L> {\n    // Overridden in Left#getLeft\n    return undefined;\n  }\n\n  /**\n   * Gets the right value if this is a Right or the result of the provided function if it's a Left.\n   */\n  getOrElse<T>(defaultValue: (l: L) => T): R | T {\n    return this.fold(\n      (l) => defaultValue(l),\n      (r) => r,\n    );\n  }\n}\n\nfunction toEitherPromise<L, R>(e: EitherBase<L, R>): Promise<Either<L, R>> {\n  // EitherBase is abstract with only Left/Right as concrete subclasses; the cast is always valid.\n  return Promise.resolve(e as unknown as Either<L, R>);\n}\n\nexport class Left<L> extends EitherBase<L, never> {\n  constructor(private readonly value: L) {\n    super();\n  }\n\n  fold<U1, U2>(leftFn: (l: L) => U1, _rightFn: (r: never) => U2): U1 | U2 {\n    return leftFn(this.value);\n  }\n\n  override getLeft(): L {\n    return this.value;\n  }\n\n  override toString(): string {\n    return `Left(${String(this.value)})`;\n  }\n\n  get [Symbol.toStringTag](): string {\n    return 'Left';\n  }\n}\n\nexport class Right<R> extends EitherBase<never, R> {\n  constructor(private readonly value: R) {\n    super();\n  }\n\n  fold<U1, U2>(_leftFn: (l: never) => U1, rightFn: (r: R) => U2): U1 | U2 {\n    return rightFn(this.value);\n  }\n\n  override get(): R {\n    return this.value;\n  }\n\n  override toString(): string {\n    return `Right(${String(this.value)})`;\n  }\n\n  get [Symbol.toStringTag](): string {\n    return 'Right';\n  }\n}\n\n/**\n * Either<L, R> is a union of Left<L> and Right<R>, so narrowing works in both directions:\n *\n * ```ts\n * declare const e: Either<string, number>;\n *\n * if (e.isLeft()) {\n *   e; // Left<string>\n * } else {\n *   e; // Right<number>\n * }\n * ```\n */\nexport type Either<L, R> = Left<L> | Right<R>;\n\nexport namespace Either {\n  /**\n   * Creates a new Left Either with the provided value.\n   */\n  export function left<L>(value: L): Either<L, never> {\n    return new Left(value);\n  }\n\n  /**\n   * Creates a new Right Either with the provided value.\n   */\n  export function right<R>(value: R): Either<never, R> {\n    return new Right(value);\n  }\n\n  /**\n   * Creates a Right Either from a Maybe if it is defined, or a Left Either from the result of the provided function otherwise.\n   */\n  export function fromMaybe<L, R>(value: Maybe<R>, leftValue: () => L): Either<L, R> {\n    return isDefined(value) ? Either.right(value) : Either.left(leftValue());\n  }\n\n  /**\n   * Creates a Right Either from the result of `rightFn` if `bool` is true, or a Left Either from the result of `leftFn` otherwise.\n   */\n  export function cond<L, R>(bool: boolean, leftFn: () => L, rightFn: () => R): Either<L, R> {\n    return bool ? Either.right(rightFn()) : Either.left(leftFn());\n  }\n}\n\n/**\n * Asynchronous version of @{link Either}, allowing for asynchronous operations on the values of the Either.\n *\n * ```ts\n * declare const e: EitherP<string, number>;\n *\n * const result = await e.get(); // result is of type Maybe<number>\n */\nexport class EitherP<L, R> implements PromiseLike<Either<L, R>> {\n  private constructor(private readonly value: PromiseLike<Either<L, R>>) {}\n\n  /**\n   * Maps the value of this Either if it is a Right, performs no operation if this is a Left.\n   */\n  map<R2>(fn: (t: R) => R2): EitherP<L, R2> {\n    return new EitherP(this.value.then((e) => e.map(fn)));\n  }\n\n  /**\n   * Maps the value of this Either if it is a Right, performs no operation if this is a Left, asynchronously.\n   */\n  mapAsync<R2>(fn: (t: R) => Promise<R2>): EitherP<L, R2> {\n    return this.flatMapAsync(async (value) => Either.right(await fn(value)));\n  }\n\n  /**\n   * Maps the value of this Either if it is a Left, performs no operation if this is a Right.\n   */\n  leftMap<L2>(fn: (t: L) => L2): EitherP<L2, R> {\n    return new EitherP(this.value.then((e) => e.leftMap(fn)));\n  }\n\n  /**\n   * Maps the value of this Either if it is a Left, performs no operation if this is a Right, asynchronously.\n   */\n  leftMapAsync<L2>(fn: (t: L) => Promise<L2>): EitherP<L2, R> {\n    return new EitherP(\n      this.value.then(\n        async (e) =>\n          await e.fold(\n            async (l) => Either.left(await fn(l)),\n            async (r) => Either.right(r),\n          ),\n      ),\n    );\n  }\n\n  /**\n   * Flat maps the value of this Either if it is a Left, performs no operation if this is a Right.\n   */\n  leftFlatMap<L2, R2>(fn: (t: L) => Either<L2, R2>): EitherP<L2, R | R2> {\n    return new EitherP(this.value.then((e) => e.leftFlatMap(fn)));\n  }\n\n  /**\n   * Flat maps the value of this Either if it is a Left, performs no operation if this is a Right, asynchronously.\n   */\n  leftFlatMapAsync<L2, R2>(fn: (t: L) => PromiseLike<Either<L2, R2>>): EitherP<L2, R | R2> {\n    return new EitherP(\n      this.value.then<Either<L2, R | R2>>(\n        async (e) =>\n          await e.fold(\n            async (left) => await fn(left),\n            async (right) => Either.right(right),\n          ),\n      ),\n    );\n  }\n\n  /**\n   * Applies the provided functions to the value of this Either, depending on whether it is a Right or a Left and returns a new Either.\n   */\n  bimap<L2, R2>(leftFn: (l: L) => L2, rightFn: (r: R) => R2): EitherP<L2, R2> {\n    return new EitherP(this.value.then((e) => e.bimap(leftFn, rightFn)));\n  }\n\n  /**\n   * Applies the provided functions to the value of this Either, depending on whether it is a Right or a Left and returns a new Either, asynchronously.\n   */\n  bimapAsync<L2, R2>(\n    leftFn: (l: L) => Promise<L2>,\n    rightFn: (r: R) => Promise<R2>,\n  ): EitherP<L2, R2> {\n    return new EitherP(\n      this.value.then(\n        async (e) =>\n          await e.fold(\n            async (l) => Either.left(await leftFn(l)),\n            async (r) => Either.right(await rightFn(r)),\n          ),\n      ),\n    );\n  }\n\n  /**\n   * Runs the provided function with the value of this Either if it is a Right, performs no operation if this is a Left.\n   */\n  tap(fn: (t: R) => void): EitherP<L, R> {\n    return new EitherP(this.value.then((e) => e.tap(fn)));\n  }\n\n  /**\n   * Runs the provided function with the value of this Either if it is a Right, performs no operation if this is a Left, asynchronously.\n   */\n  tapAsync(fn: (t: R) => Promise<void>): EitherP<L, R> {\n    return this.flatMapAsync(async (value) => {\n      await fn(value);\n      return Either.right(value);\n    });\n  }\n\n  /**\n   * Runs the provided function with the value of this Either if it is a Right, performs no operation if this is a Left.\n   * If the result of the function is a Left, it will be returned, otherwise the original Right value will be returned.\n   */\n  flatTap<L2>(fn: (t: R) => Either<L2, void>): EitherP<L | L2, R> {\n    return new EitherP(this.value.then((e) => e.flatTap(fn)));\n  }\n\n  /**\n   * Runs the provided function with the value of this Either if it is a Right, performs no operation if this is a Left, asynchronously.\n   * If the result of the function is a Left, it will be returned, otherwise the original Right value will be returned.\n   */\n  flatTapAsync<L2>(fn: (t: R) => PromiseLike<Either<L2, void>>): EitherP<L | L2, R> {\n    return this.flatMapAsync(async (value) => (await fn(value)).map(() => value));\n  }\n\n  /**\n   * Flat maps the value of this Either if it is a Right, performs no operation if this is a Left.\n   */\n  flatMap<L2, R2>(fn: (t: R) => Either<L2, R2>): EitherP<L | L2, R2> {\n    return new EitherP(this.value.then((e) => e.flatMap(fn)));\n  }\n\n  /**\n   * Flat maps the value of this Either if it is a Right, performs no operation if this is a Left, asynchronously.\n   */\n  flatMapAsync<L2, R2>(fn: (t: R) => PromiseLike<Either<L2, R2>>): EitherP<L | L2, R2> {\n    return new EitherP(\n      this.value.then<Either<L | L2, R2>>((e) =>\n        e.fold(\n          async (left) => Either.left(left),\n          (right) => fn(right),\n        ),\n      ),\n    );\n  }\n\n  /**\n   * Applies the provided functions to the value of this Either, depending on whether it is a Right or a Left and returns the result.\n   */\n  async fold<U1, U2>(leftFn: (l: L) => U1, rightFn: (r: R) => U2): Promise<U1 | U2> {\n    return (await this.value).fold(leftFn, rightFn);\n  }\n\n  /**\n   * Allows to deconstruct the Either using:\n   *\n   * @example\n   *\n   * ```ts\n   * declare const e: EitherP<string, number>;\n   *\n   * const [left, right] = await e.pair();\n   * ```\n   *\n   */\n  async pair(): Promise<[Maybe<L>, Maybe<R>]> {\n    return [await this.getLeft(), await this.get()];\n  }\n\n  /**\n   * Returns true if this Either is a Right, false otherwise.\n   */\n  async isRight(): Promise<boolean> {\n    return (await this.value).isRight();\n  }\n\n  /**\n   * Returns true if this Either is a Left, false otherwise.\n   */\n  async isLeft(): Promise<boolean> {\n    return !(await this.isRight());\n  }\n\n  /**\n   * Gets the right value if this is a Right or undefined if it's a Left.\n   */\n  async get(): Promise<Maybe<R>> {\n    return (await this.value).get();\n  }\n\n  /**\n   * Returns the left value if this is a Left or undefined if it's a Right.\n   */\n  async getLeft(): Promise<Maybe<L>> {\n    return (await this.value).getLeft();\n  }\n\n  /**\n   * Gets the right value if this is a Right or the result of the provided function if it's a Left.\n   */\n  async getOrElse<T>(defaultValue: (l: L) => T): Promise<R | T> {\n    return (await this.value).getOrElse(defaultValue);\n  }\n\n  /**\n   * Creates a new Left EitherP with the provided value.\n   */\n  static left<L>(value: Promise<L>): EitherP<L, never> {\n    return new EitherP(value.then((v) => Either.left(v)));\n  }\n\n  /**\n   * Creates a new Right EitherP with the provided value.\n   */\n  static right<R>(value: Promise<R>): EitherP<never, R> {\n    return new EitherP(value.then((v) => Either.right(v)));\n  }\n\n  /**\n   * Creates a Right EitherP from a Promise of a Maybe if it resolves to a defined value, or a Left EitherP from the result of the provided function otherwise.\n   */\n  static fromMaybe<L, R>(value: Promise<Maybe<R>>, leftValue: () => Promise<L>): EitherP<L, R> {\n    return new EitherP(\n      value.then(async (v) => (isDefined(v) ? Either.right(v) : Either.left(await leftValue()))),\n    );\n  }\n\n  /**\n   * Creates a new EitherP from a Promise of an Either.\n   */\n  static fromPromise<L, R>(either: PromiseLike<Either<L, R>>): EitherP<L, R> {\n    return new EitherP(either);\n  }\n\n  /**\n   * Creates a new Right EitherP if the provided Promise resolves to true, or a new Left EitherP otherwise.\n   */\n  static cond<L, R>(\n    bool: Promise<boolean>,\n    leftFn: () => Promise<L>,\n    rightFn: () => Promise<R>,\n  ): EitherP<L, R> {\n    return new EitherP(\n      bool.then(async (b) => (b ? Either.right(await rightFn()) : Either.left(await leftFn()))),\n    );\n  }\n\n  /**\n   * Resolves this EitherP to its underlying Either, allowing `await` usage on EitherP instances.\n   */\n  // oxlint-disable-next-line unicorn/no-thenable -- Deliberately implementing PromiseLike to allow for `await` usage on EitherP instances.\n  then<U>(onfulfilled?: (value: Either<L, R>) => U | PromiseLike<U>): PromiseLike<U> {\n    return this.value.then(onfulfilled);\n  }\n}\n"],"mappings":"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"}

package/dist/index.d.mts

@@ -1,3 +1,3 @@
 import { Maybe, flattenMaybe, ifFalse, ifTrue, isDefined, mapMaybe, matchPair } from "./maybe.mjs";
-import { Either, EitherP, Left, Right } from "./either.mjs";
-export { Either, EitherP, Left, Maybe, Right, flattenMaybe, ifFalse, ifTrue, isDefined, mapMaybe, matchPair };
+import { Either, EitherBase, EitherP, Left, Right } from "./either.mjs";
+export { Either, EitherBase, EitherP, Left, Maybe, Right, flattenMaybe, ifFalse, ifTrue, isDefined, mapMaybe, matchPair };

package/dist/index.mjs

@@ -1,4 +1,4 @@
 import { flattenMaybe, ifFalse, ifTrue, isDefined, mapMaybe, matchPair } from "./maybe.mjs";
-import { Either, EitherP, Left, Right } from "./either.mjs";
+import { Either, EitherBase, EitherP, Left, Right } from "./either.mjs";
 
-export { Either, EitherP, Left, Right, flattenMaybe, ifFalse, ifTrue, isDefined, mapMaybe, matchPair };
+export { Either, EitherBase, EitherP, Left, Right, flattenMaybe, ifFalse, ifTrue, isDefined, mapMaybe, matchPair };

package/dist/maybe.d.mts

@@ -1,10 +1,74 @@
 //#region src/maybe.d.ts
+/**
+ * Represents a value that may be absent.
+ */
 type Maybe<T> = T | undefined;
+/**
+ * Maps the value if it is defined, performs no operation if it is undefined.
+ *
+ * @example
+ *
+ * ```ts
+ * const value: Maybe<number> = 5;
+ * const result: Maybe<string> = mapMaybe(value, (v) => `Value is ${v}`); // "Value is 5"
+ *
+ * const undefinedValue: Maybe<number> = undefined;
+ * const undefinedResult: Maybe<string> = mapMaybe(undefinedValue, (v) => `Value is ${v}`); // undefined
+ * ```
+ */
 declare function mapMaybe<T, U>(value: Maybe<T>, fn: (value: T) => U): Maybe<U>;
+/**
+ * Returns true if the value is defined, false if it is undefined.
+ *
+ * @example
+ *
+ * ```ts
+ * const definedValue: Maybe<number> = 5;
+ *
+ * if (isDefined(definedValue)) {
+ *   console.log(definedValue + 1); // Output: 6
+ * }
+ * ```
+ */
 declare function isDefined<T>(value: Maybe<T>): value is T;
+/**
+ * Flattens a nested Maybe into a single Maybe.
+ *
+ * @example
+ *
+ * ```ts
+ * const nested: Maybe<Maybe<number>> = 5;
+ * const flattened: Maybe<number> = flattenMaybe(nested); // 5
+ * ```
+ */
 declare function flattenMaybe<T>(value: Maybe<Maybe<T>>): Maybe<T>;
+/**
+ * Returns the result of the provided function if the value is true, undefined otherwise.
+ */
 declare function ifTrue<T>(value: boolean, fn: () => T): Maybe<T>;
+/**
+ * Returns the result of the provided function if the value is false, undefined otherwise.
+ */
 declare function ifFalse<T>(value: boolean, fn: () => T): Maybe<T>;
+/**
+ * Matches a pair of Maybe values against the provided cases, depending on which of them are defined.
+ *
+ * @example
+ *
+ * ```ts
+ * const a: Maybe<number> = 5;
+ * const b: Maybe<string> = undefined;
+ *
+ * const result = matchPair([a, b], {
+ *   neither: () => 'neither',
+ *   a: (a) => `a is ${a}`,
+ *   b: (b) => `b is ${b}`,
+ *   both: (a, b) => `both are ${a} and ${b}`,
+ * });
+ *
+ * console.log(result); // Output: "a is 5"
+ * ```
+ */
 declare function matchPair<A, B, R>([a, b]: [Maybe<A>, Maybe<B>], cases: {
   neither: () => R;
   a: (a: A) => R;

package/dist/maybe.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"maybe.d.mts","names":[],"sources":["../src/maybe.ts"],"mappings":";KAAY,MAAM,KAAK;iBAEP,SAAS,GAAG,GAAG,OAAO,MAAM,IAAI,KAAK,OAAO,MAAM,IAAI,MAAM;iBAI5D,UAAU,GAAG,OAAO,MAAM,KAAK,SAAS;iBAIxC,aAAa,GAAG,OAAO,MAAM,MAAM,MAAM,MAAM;iBAI/C,OAAO,GAAG,gBAAgB,UAAU,IAAI,MAAM;iBAI9C,QAAQ,GAAG,gBAAgB,UAAU,IAAI,MAAM;iBAI/C,UAAU,GAAG,GAAG,IAC7B,GAAG,KAAK,MAAM,IAAI,MAAM,KACzB;EACE,eAAe;EACf,IAAI,GAAG,MAAM;EACb,IAAI,GAAG,MAAM;EACb,OAAO,GAAG,GAAG,GAAG,MAAM;IAEvB"}
+{"version":3,"file":"maybe.d.mts","names":[],"sources":["../src/maybe.ts"],"mappings":";;;;KAGY,MAAM,KAAK;;;;;;;;;;;;;;iBAeP,SAAS,GAAG,GAAG,OAAO,MAAM,IAAI,KAAK,OAAO,MAAM,IAAI,MAAM;;;;;;;;;;;;;;iBAiB5D,UAAU,GAAG,OAAO,MAAM,KAAK,SAAS;;;;;;;;;;;iBAcxC,aAAa,GAAG,OAAO,MAAM,MAAM,MAAM,MAAM;;;;iBAO/C,OAAO,GAAG,gBAAgB,UAAU,IAAI,MAAM;;;;iBAO9C,QAAQ,GAAG,gBAAgB,UAAU,IAAI,MAAM;;;;;;;;;;;;;;;;;;;;iBAuB/C,UAAU,GAAG,GAAG,IAC7B,GAAG,KAAK,MAAM,IAAI,MAAM,KACzB;EACE,eAAe;EACf,IAAI,GAAG,MAAM;EACb,IAAI,GAAG,MAAM;EACb,OAAO,GAAG,GAAG,GAAG,MAAM;IAEvB"}

package/dist/maybe.mjs

@@ -1,19 +1,80 @@
 //#region src/maybe.ts
+/**
+* Maps the value if it is defined, performs no operation if it is undefined.
+*
+* @example
+*
+* ```ts
+* const value: Maybe<number> = 5;
+* const result: Maybe<string> = mapMaybe(value, (v) => `Value is ${v}`); // "Value is 5"
+*
+* const undefinedValue: Maybe<number> = undefined;
+* const undefinedResult: Maybe<string> = mapMaybe(undefinedValue, (v) => `Value is ${v}`); // undefined
+* ```
+*/
 function mapMaybe(value, fn) {
 	return value === void 0 ? void 0 : fn(value);
 }
+/**
+* Returns true if the value is defined, false if it is undefined.
+*
+* @example
+*
+* ```ts
+* const definedValue: Maybe<number> = 5;
+*
+* if (isDefined(definedValue)) {
+*   console.log(definedValue + 1); // Output: 6
+* }
+* ```
+*/
 function isDefined(value) {
 	return value !== void 0;
 }
+/**
+* Flattens a nested Maybe into a single Maybe.
+*
+* @example
+*
+* ```ts
+* const nested: Maybe<Maybe<number>> = 5;
+* const flattened: Maybe<number> = flattenMaybe(nested); // 5
+* ```
+*/
 function flattenMaybe(value) {
 	return mapMaybe(value, (v) => v);
 }
+/**
+* Returns the result of the provided function if the value is true, undefined otherwise.
+*/
 function ifTrue(value, fn) {
 	return value ? fn() : void 0;
 }
+/**
+* Returns the result of the provided function if the value is false, undefined otherwise.
+*/
 function ifFalse(value, fn) {
 	return !value ? fn() : void 0;
 }
+/**
+* Matches a pair of Maybe values against the provided cases, depending on which of them are defined.
+*
+* @example
+*
+* ```ts
+* const a: Maybe<number> = 5;
+* const b: Maybe<string> = undefined;
+*
+* const result = matchPair([a, b], {
+*   neither: () => 'neither',
+*   a: (a) => `a is ${a}`,
+*   b: (b) => `b is ${b}`,
+*   both: (a, b) => `both are ${a} and ${b}`,
+* });
+*
+* console.log(result); // Output: "a is 5"
+* ```
+*/
 function matchPair([a, b], cases) {
 	if (!isDefined(a)) {
 		if (!isDefined(b)) return cases.neither();

package/dist/maybe.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"maybe.mjs","names":[],"sources":["../src/maybe.ts"],"sourcesContent":["export type Maybe<T> = T | undefined;\n\nexport function mapMaybe<T, U>(value: Maybe<T>, fn: (value: T) => U): Maybe<U> {\n  return value === undefined ? undefined : fn(value);\n}\n\nexport function isDefined<T>(value: Maybe<T>): value is T {\n  return value !== undefined;\n}\n\nexport function flattenMaybe<T>(value: Maybe<Maybe<T>>): Maybe<T> {\n  return mapMaybe(value, (v) => v);\n}\n\nexport function ifTrue<T>(value: boolean, fn: () => T): Maybe<T> {\n  return value ? fn() : undefined;\n}\n\nexport function ifFalse<T>(value: boolean, fn: () => T): Maybe<T> {\n  return !value ? fn() : undefined;\n}\n\nexport function matchPair<A, B, R>(\n  [a, b]: [Maybe<A>, Maybe<B>],\n  cases: {\n    neither: () => R;\n    a: (a: A) => R;\n    b: (b: B) => R;\n    both: (a: A, b: B) => R;\n  },\n): R {\n  if (!isDefined(a)) {\n    if (!isDefined(b)) {\n      return cases.neither();\n    }\n\n    return cases.b(b);\n  }\n\n  if (!isDefined(b)) {\n    return cases.a(a);\n  }\n\n  return cases.both(a, b);\n}\n"],"mappings":";AAEA,SAAgB,SAAe,OAAiB,IAA+B;CAC7E,OAAO,UAAU,SAAY,SAAY,GAAG,KAAK;AACnD;AAEA,SAAgB,UAAa,OAA6B;CACxD,OAAO,UAAU;AACnB;AAEA,SAAgB,aAAgB,OAAkC;CAChE,OAAO,SAAS,QAAQ,MAAM,CAAC;AACjC;AAEA,SAAgB,OAAU,OAAgB,IAAuB;CAC/D,OAAO,QAAQ,GAAG,IAAI;AACxB;AAEA,SAAgB,QAAW,OAAgB,IAAuB;CAChE,OAAO,CAAC,QAAQ,GAAG,IAAI;AACzB;AAEA,SAAgB,UACd,CAAC,GAAG,IACJ,OAMG;CACH,IAAI,CAAC,UAAU,CAAC,GAAG;EACjB,IAAI,CAAC,UAAU,CAAC,GACd,OAAO,MAAM,QAAQ;EAGvB,OAAO,MAAM,EAAE,CAAC;CAClB;CAEA,IAAI,CAAC,UAAU,CAAC,GACd,OAAO,MAAM,EAAE,CAAC;CAGlB,OAAO,MAAM,KAAK,GAAG,CAAC;AACxB"}
+{"version":3,"file":"maybe.mjs","names":[],"sources":["../src/maybe.ts"],"sourcesContent":["/**\n * Represents a value that may be absent.\n */\nexport type Maybe<T> = T | undefined;\n\n/**\n * Maps the value if it is defined, performs no operation if it is undefined.\n *\n * @example\n *\n * ```ts\n * const value: Maybe<number> = 5;\n * const result: Maybe<string> = mapMaybe(value, (v) => `Value is ${v}`); // \"Value is 5\"\n *\n * const undefinedValue: Maybe<number> = undefined;\n * const undefinedResult: Maybe<string> = mapMaybe(undefinedValue, (v) => `Value is ${v}`); // undefined\n * ```\n */\nexport function mapMaybe<T, U>(value: Maybe<T>, fn: (value: T) => U): Maybe<U> {\n  return value === undefined ? undefined : fn(value);\n}\n\n/**\n * Returns true if the value is defined, false if it is undefined.\n *\n * @example\n *\n * ```ts\n * const definedValue: Maybe<number> = 5;\n *\n * if (isDefined(definedValue)) {\n *   console.log(definedValue + 1); // Output: 6\n * }\n * ```\n */\nexport function isDefined<T>(value: Maybe<T>): value is T {\n  return value !== undefined;\n}\n\n/**\n * Flattens a nested Maybe into a single Maybe.\n *\n * @example\n *\n * ```ts\n * const nested: Maybe<Maybe<number>> = 5;\n * const flattened: Maybe<number> = flattenMaybe(nested); // 5\n * ```\n */\nexport function flattenMaybe<T>(value: Maybe<Maybe<T>>): Maybe<T> {\n  return mapMaybe(value, (v) => v);\n}\n\n/**\n * Returns the result of the provided function if the value is true, undefined otherwise.\n */\nexport function ifTrue<T>(value: boolean, fn: () => T): Maybe<T> {\n  return value ? fn() : undefined;\n}\n\n/**\n * Returns the result of the provided function if the value is false, undefined otherwise.\n */\nexport function ifFalse<T>(value: boolean, fn: () => T): Maybe<T> {\n  return !value ? fn() : undefined;\n}\n\n/**\n * Matches a pair of Maybe values against the provided cases, depending on which of them are defined.\n *\n * @example\n *\n * ```ts\n * const a: Maybe<number> = 5;\n * const b: Maybe<string> = undefined;\n *\n * const result = matchPair([a, b], {\n *   neither: () => 'neither',\n *   a: (a) => `a is ${a}`,\n *   b: (b) => `b is ${b}`,\n *   both: (a, b) => `both are ${a} and ${b}`,\n * });\n *\n * console.log(result); // Output: \"a is 5\"\n * ```\n */\nexport function matchPair<A, B, R>(\n  [a, b]: [Maybe<A>, Maybe<B>],\n  cases: {\n    neither: () => R;\n    a: (a: A) => R;\n    b: (b: B) => R;\n    both: (a: A, b: B) => R;\n  },\n): R {\n  if (!isDefined(a)) {\n    if (!isDefined(b)) {\n      return cases.neither();\n    }\n\n    return cases.b(b);\n  }\n\n  if (!isDefined(b)) {\n    return cases.a(a);\n  }\n\n  return cases.both(a, b);\n}\n"],"mappings":";;;;;;;;;;;;;;AAkBA,SAAgB,SAAe,OAAiB,IAA+B;CAC7E,OAAO,UAAU,SAAY,SAAY,GAAG,KAAK;AACnD;;;;;;;;;;;;;;AAeA,SAAgB,UAAa,OAA6B;CACxD,OAAO,UAAU;AACnB;;;;;;;;;;;AAYA,SAAgB,aAAgB,OAAkC;CAChE,OAAO,SAAS,QAAQ,MAAM,CAAC;AACjC;;;;AAKA,SAAgB,OAAU,OAAgB,IAAuB;CAC/D,OAAO,QAAQ,GAAG,IAAI;AACxB;;;;AAKA,SAAgB,QAAW,OAAgB,IAAuB;CAChE,OAAO,CAAC,QAAQ,GAAG,IAAI;AACzB;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,UACd,CAAC,GAAG,IACJ,OAMG;CACH,IAAI,CAAC,UAAU,CAAC,GAAG;EACjB,IAAI,CAAC,UAAU,CAAC,GACd,OAAO,MAAM,QAAQ;EAGvB,OAAO,MAAM,EAAE,CAAC;CAClB;CAEA,IAAI,CAAC,UAAU,CAAC,GACd,OAAO,MAAM,EAAE,CAAC;CAGlB,OAAO,MAAM,KAAK,GAAG,CAAC;AACxB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jeengbe/prelude",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "A small, dependency-free functional programming toolkit for TypeScript.",
   "keywords": [
     "either",

package/src/either.ts

@@ -7,7 +7,7 @@ import { isDefined } from './maybe.js';
 // And conversely, xxx implementations in EitherP all look like:
 // new EitherP(this.value.then(e => e.xxx(...)))
 
-abstract class EitherBase<L, R> {
+export abstract class EitherBase<L, R> {
   /**
    * Maps the value of this Either if it is a Right, performs no operation if this is a Left.
    */
@@ -15,6 +15,9 @@ abstract class EitherBase<L, R> {
     return this.flatMap((value) => Either.right(fn(value)));
   }
 
+  /**
+   * Maps the value of this Either if it is a Right, performs no operation if this is a Left, asynchronously.
+   */
   mapAsync<R2>(fn: (t: R) => Promise<R2>): EitherP<L, R2> {
     return EitherP.fromPromise(toEitherPromise(this)).mapAsync(fn);
   }
@@ -29,6 +32,9 @@ abstract class EitherBase<L, R> {
     );
   }
 
+  /**
+   * Flat maps the value of this Either if it is a Left, performs no operation if this is a Right, asynchronously.
+   */
   leftFlatMapAsync<L2, R2>(fn: (t: L) => PromiseLike<Either<L2, R2>>): EitherP<L2, R | R2> {
     return EitherP.fromPromise(toEitherPromise(this)).leftFlatMapAsync(fn);
   }
@@ -43,6 +49,9 @@ abstract class EitherBase<L, R> {
     );
   }
 
+  /**
+   * Maps the value of this Either if it is a Left, performs no operation if this is a Right, asynchronously.
+   */
   leftMapAsync<L2>(fn: (t: L) => Promise<L2>): EitherP<L2, R> {
     return EitherP.fromPromise(toEitherPromise(this)).leftMapAsync(fn);
   }
@@ -57,6 +66,9 @@ abstract class EitherBase<L, R> {
     );
   }
 
+  /**
+   * Applies the provided functions to the value of this Either, depending on whether it is a Right or a Left and returns a new Either, asynchronously.
+   */
   bimapAsync<L2, R2>(
     leftFn: (l: L) => Promise<L2>,
     rightFn: (r: R) => Promise<R2>,
@@ -74,6 +86,9 @@ abstract class EitherBase<L, R> {
     });
   }
 
+  /**
+   * Runs the provided function with the value of this Either if it is a Right, performs no operation if this is a Left, asynchronously.
+   */
   tapAsync(fn: (t: R) => Promise<void>): EitherP<L, R> {
     return EitherP.fromPromise(toEitherPromise(this)).tapAsync(fn);
   }
@@ -86,6 +101,10 @@ abstract class EitherBase<L, R> {
     return this.flatMap((value) => fn(value).map(() => value));
   }
 
+  /**
+   * Runs the provided function with the value of this Either if it is a Right, performs no operation if this is a Left, asynchronously.
+   * If the result of the function is a Left, it will be returned, otherwise the original Right value will be returned.
+   */
   flatTapAsync<L2>(fn: (t: R) => PromiseLike<Either<L2, void>>): EitherP<L | L2, R> {
     return EitherP.fromPromise(toEitherPromise(this)).flatTapAsync(fn);
   }
@@ -100,6 +119,9 @@ abstract class EitherBase<L, R> {
     );
   }
 
+  /**
+   * Flat maps the value of this Either if it is a Right, performs no operation if this is a Left, asynchronously.
+   */
   flatMapAsync<L2, R2>(fn: (t: R) => PromiseLike<Either<L2, R2>>): EitherP<L | L2, R2> {
     return EitherP.fromPromise(toEitherPromise(this)).flatMapAsync(fn);
   }
@@ -149,20 +171,16 @@ abstract class EitherBase<L, R> {
    * Gets the right value if this is a Right or undefined if it's a Left.
    */
   get(): Maybe<R> {
-    return this.fold(
-      () => undefined,
-      (r) => r,
-    );
+    // Overridden in Right#get
+    return undefined;
   }
 
   /**
    * Returns the left value if this is a Left or undefined if it's a Right.
    */
   getLeft(): Maybe<L> {
-    return this.fold(
-      (l) => l,
-      () => undefined,
-    );
+    // Overridden in Left#getLeft
+    return undefined;
   }
 
   /**
@@ -176,8 +194,8 @@ abstract class EitherBase<L, R> {
   }
 }
 
-// EitherBase is abstract with only Left/Right as concrete subclasses; the cast is always valid.
 function toEitherPromise<L, R>(e: EitherBase<L, R>): Promise<Either<L, R>> {
+  // EitherBase is abstract with only Left/Right as concrete subclasses; the cast is always valid.
   return Promise.resolve(e as unknown as Either<L, R>);
 }
 
@@ -193,6 +211,14 @@ export class Left<L> extends EitherBase<L, never> {
   override getLeft(): L {
     return this.value;
   }
+
+  override toString(): string {
+    return `Left(${String(this.value)})`;
+  }
+
+  get [Symbol.toStringTag](): string {
+    return 'Left';
+  }
 }
 
 export class Right<R> extends EitherBase<never, R> {
@@ -207,11 +233,17 @@ export class Right<R> extends EitherBase<never, R> {
   override get(): R {
     return this.value;
   }
+
+  override toString(): string {
+    return `Right(${String(this.value)})`;
+  }
+
+  get [Symbol.toStringTag](): string {
+    return 'Right';
+  }
 }
 
 /**
- * Mimics the [Cats Either[L, R]](https://typelevel.org/cats/datatypes/either.html) type.
- *
  * Either<L, R> is a union of Left<L> and Right<R>, so narrowing works in both directions:
  *
  * ```ts
@@ -241,17 +273,28 @@ export namespace Either {
     return new Right(value);
   }
 
+  /**
+   * Creates a Right Either from a Maybe if it is defined, or a Left Either from the result of the provided function otherwise.
+   */
   export function fromMaybe<L, R>(value: Maybe<R>, leftValue: () => L): Either<L, R> {
     return isDefined(value) ? Either.right(value) : Either.left(leftValue());
   }
 
+  /**
+   * Creates a Right Either from the result of `rightFn` if `bool` is true, or a Left Either from the result of `leftFn` otherwise.
+   */
   export function cond<L, R>(bool: boolean, leftFn: () => L, rightFn: () => R): Either<L, R> {
     return bool ? Either.right(rightFn()) : Either.left(leftFn());
   }
 }
 
 /**
- * Mimics the [Cats EitherT[Future, L, R]](https://typelevel.org/cats/datatypes/eithert.html) type.
+ * Asynchronous version of @{link Either}, allowing for asynchronous operations on the values of the Either.
+ *
+ * ```ts
+ * declare const e: EitherP<string, number>;
+ *
+ * const result = await e.get(); // result is of type Maybe<number>
  */
 export class EitherP<L, R> implements PromiseLike<Either<L, R>> {
   private constructor(private readonly value: PromiseLike<Either<L, R>>) {}
@@ -263,6 +306,9 @@ export class EitherP<L, R> implements PromiseLike<Either<L, R>> {
     return new EitherP(this.value.then((e) => e.map(fn)));
   }
 
+  /**
+   * Maps the value of this Either if it is a Right, performs no operation if this is a Left, asynchronously.
+   */
   mapAsync<R2>(fn: (t: R) => Promise<R2>): EitherP<L, R2> {
     return this.flatMapAsync(async (value) => Either.right(await fn(value)));
   }
@@ -274,6 +320,9 @@ export class EitherP<L, R> implements PromiseLike<Either<L, R>> {
     return new EitherP(this.value.then((e) => e.leftMap(fn)));
   }
 
+  /**
+   * Maps the value of this Either if it is a Left, performs no operation if this is a Right, asynchronously.
+   */
   leftMapAsync<L2>(fn: (t: L) => Promise<L2>): EitherP<L2, R> {
     return new EitherP(
       this.value.then(
@@ -293,6 +342,9 @@ export class EitherP<L, R> implements PromiseLike<Either<L, R>> {
     return new EitherP(this.value.then((e) => e.leftFlatMap(fn)));
   }
 
+  /**
+   * Flat maps the value of this Either if it is a Left, performs no operation if this is a Right, asynchronously.
+   */
   leftFlatMapAsync<L2, R2>(fn: (t: L) => PromiseLike<Either<L2, R2>>): EitherP<L2, R | R2> {
     return new EitherP(
       this.value.then<Either<L2, R | R2>>(
@@ -312,6 +364,9 @@ export class EitherP<L, R> implements PromiseLike<Either<L, R>> {
     return new EitherP(this.value.then((e) => e.bimap(leftFn, rightFn)));
   }
 
+  /**
+   * Applies the provided functions to the value of this Either, depending on whether it is a Right or a Left and returns a new Either, asynchronously.
+   */
   bimapAsync<L2, R2>(
     leftFn: (l: L) => Promise<L2>,
     rightFn: (r: R) => Promise<R2>,
@@ -334,6 +389,9 @@ export class EitherP<L, R> implements PromiseLike<Either<L, R>> {
     return new EitherP(this.value.then((e) => e.tap(fn)));
   }
 
+  /**
+   * Runs the provided function with the value of this Either if it is a Right, performs no operation if this is a Left, asynchronously.
+   */
   tapAsync(fn: (t: R) => Promise<void>): EitherP<L, R> {
     return this.flatMapAsync(async (value) => {
       await fn(value);
@@ -349,6 +407,10 @@ export class EitherP<L, R> implements PromiseLike<Either<L, R>> {
     return new EitherP(this.value.then((e) => e.flatTap(fn)));
   }
 
+  /**
+   * Runs the provided function with the value of this Either if it is a Right, performs no operation if this is a Left, asynchronously.
+   * If the result of the function is a Left, it will be returned, otherwise the original Right value will be returned.
+   */
   flatTapAsync<L2>(fn: (t: R) => PromiseLike<Either<L2, void>>): EitherP<L | L2, R> {
     return this.flatMapAsync(async (value) => (await fn(value)).map(() => value));
   }
@@ -360,6 +422,9 @@ export class EitherP<L, R> implements PromiseLike<Either<L, R>> {
     return new EitherP(this.value.then((e) => e.flatMap(fn)));
   }
 
+  /**
+   * Flat maps the value of this Either if it is a Right, performs no operation if this is a Left, asynchronously.
+   */
   flatMapAsync<L2, R2>(fn: (t: R) => PromiseLike<Either<L2, R2>>): EitherP<L | L2, R2> {
     return new EitherP(
       this.value.then<Either<L | L2, R2>>((e) =>
@@ -443,6 +508,9 @@ export class EitherP<L, R> implements PromiseLike<Either<L, R>> {
     return new EitherP(value.then((v) => Either.right(v)));
   }
 
+  /**
+   * Creates a Right EitherP from a Promise of a Maybe if it resolves to a defined value, or a Left EitherP from the result of the provided function otherwise.
+   */
   static fromMaybe<L, R>(value: Promise<Maybe<R>>, leftValue: () => Promise<L>): EitherP<L, R> {
     return new EitherP(
       value.then(async (v) => (isDefined(v) ? Either.right(v) : Either.left(await leftValue()))),
@@ -450,16 +518,15 @@ export class EitherP<L, R> implements PromiseLike<Either<L, R>> {
   }
 
   /**
-   * @deprecated
+   * Creates a new EitherP from a Promise of an Either.
    */
-  static fromEither<L, R>(either: PromiseLike<Either<L, R>>): EitherP<L, R> {
-    return new EitherP(either);
-  }
-
   static fromPromise<L, R>(either: PromiseLike<Either<L, R>>): EitherP<L, R> {
     return new EitherP(either);
   }
 
+  /**
+   * Creates a new Right EitherP if the provided Promise resolves to true, or a new Left EitherP otherwise.
+   */
   static cond<L, R>(
     bool: Promise<boolean>,
     leftFn: () => Promise<L>,
@@ -470,6 +537,9 @@ export class EitherP<L, R> implements PromiseLike<Either<L, R>> {
     );
   }
 
+  /**
+   * Resolves this EitherP to its underlying Either, allowing `await` usage on EitherP instances.
+   */
   // oxlint-disable-next-line unicorn/no-thenable -- Deliberately implementing PromiseLike to allow for `await` usage on EitherP instances.
   then<U>(onfulfilled?: (value: Either<L, R>) => U | PromiseLike<U>): PromiseLike<U> {
     return this.value.then(onfulfilled);

package/src/maybe.ts

@@ -1,25 +1,89 @@
+/**
+ * Represents a value that may be absent.
+ */
 export type Maybe<T> = T | undefined;
 
+/**
+ * Maps the value if it is defined, performs no operation if it is undefined.
+ *
+ * @example
+ *
+ * ```ts
+ * const value: Maybe<number> = 5;
+ * const result: Maybe<string> = mapMaybe(value, (v) => `Value is ${v}`); // "Value is 5"
+ *
+ * const undefinedValue: Maybe<number> = undefined;
+ * const undefinedResult: Maybe<string> = mapMaybe(undefinedValue, (v) => `Value is ${v}`); // undefined
+ * ```
+ */
 export function mapMaybe<T, U>(value: Maybe<T>, fn: (value: T) => U): Maybe<U> {
   return value === undefined ? undefined : fn(value);
 }
 
+/**
+ * Returns true if the value is defined, false if it is undefined.
+ *
+ * @example
+ *
+ * ```ts
+ * const definedValue: Maybe<number> = 5;
+ *
+ * if (isDefined(definedValue)) {
+ *   console.log(definedValue + 1); // Output: 6
+ * }
+ * ```
+ */
 export function isDefined<T>(value: Maybe<T>): value is T {
   return value !== undefined;
 }
 
+/**
+ * Flattens a nested Maybe into a single Maybe.
+ *
+ * @example
+ *
+ * ```ts
+ * const nested: Maybe<Maybe<number>> = 5;
+ * const flattened: Maybe<number> = flattenMaybe(nested); // 5
+ * ```
+ */
 export function flattenMaybe<T>(value: Maybe<Maybe<T>>): Maybe<T> {
   return mapMaybe(value, (v) => v);
 }
 
+/**
+ * Returns the result of the provided function if the value is true, undefined otherwise.
+ */
 export function ifTrue<T>(value: boolean, fn: () => T): Maybe<T> {
   return value ? fn() : undefined;
 }
 
+/**
+ * Returns the result of the provided function if the value is false, undefined otherwise.
+ */
 export function ifFalse<T>(value: boolean, fn: () => T): Maybe<T> {
   return !value ? fn() : undefined;
 }
 
+/**
+ * Matches a pair of Maybe values against the provided cases, depending on which of them are defined.
+ *
+ * @example
+ *
+ * ```ts
+ * const a: Maybe<number> = 5;
+ * const b: Maybe<string> = undefined;
+ *
+ * const result = matchPair([a, b], {
+ *   neither: () => 'neither',
+ *   a: (a) => `a is ${a}`,
+ *   b: (b) => `b is ${b}`,
+ *   both: (a, b) => `both are ${a} and ${b}`,
+ * });
+ *
+ * console.log(result); // Output: "a is 5"
+ * ```
+ */
 export function matchPair<A, B, R>(
   [a, b]: [Maybe<A>, Maybe<B>],
   cases: {