@jeengbe/prelude 0.0.0

package/dist/either.d.mts

@@ -0,0 +1,216 @@
+import { Maybe } from "./maybe.mjs";
+//#region src/either.d.ts
+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>;
+  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>;
+  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>;
+  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>;
+  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>;
+  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>;
+  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>;
+  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.
+   */
+  abstract fold<U1, U2>(leftFn: (l: L) => U1, rightFn: (r: R) => U2): U1 | U2;
+  /**
+   * Allows to deconstruct the Either using:
+   *
+   * @example
+   *
+   * ```ts
+   * declare const e: Either<string, number>;
+   *
+   * const [left, right] = e.pair();
+   * ```
+   *
+   */
+  pair(): [Maybe<L>, Maybe<R>];
+  /**
+   * Returns true if this Either is a Right, false otherwise.
+   */
+  isRight(): this is Right<R>;
+  /**
+   * Returns true if this Either is a Left, false otherwise.
+   */
+  isLeft(): this is Left<L>;
+  /**
+   * Gets the right value if this is a Right or undefined if it's a Left.
+   */
+  get(): Maybe<R>;
+  /**
+   * Returns the left value if this is a Left or undefined if it's a Right.
+   */
+  getLeft(): Maybe<L>;
+  /**
+   * Gets the right value if this is a Right or the result of the provided function if it's a Left.
+   */
+  getOrElse<T>(defaultValue: (l: L) => T): R | T;
+}
+declare class Left<L> extends EitherBase<L, never> {
+  private readonly value;
+  constructor(value: L);
+  fold<U1, U2>(leftFn: (l: L) => U1, _rightFn: (r: never) => U2): U1 | U2;
+  getLeft(): L;
+}
+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;
+}
+/**
+ * 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
+ * declare const e: Either<string, number>;
+ *
+ * if (e.isLeft()) {
+ *   e; // Left<string>
+ * } else {
+ *   e; // Right<number>
+ * }
+ * ```
+ */
+type Either<L, R> = Left<L> | Right<R>;
+declare namespace Either {
+  /**
+   * Creates a new Left Either with the provided value.
+   */
+  function left<L>(value: L): Either<L, never>;
+  /**
+   * Creates a new Right Either with the provided value.
+   */
+  function right<R>(value: R): Either<never, R>;
+  function fromMaybe<L, R>(value: Maybe<R>, leftValue: () => L): Either<L, R>;
+  function cond<L, R>(bool: boolean, rightFn: () => R, leftFn: () => L): Either<L, R>;
+}
+/**
+ * Mimics the [Cats EitherT[Future, L, R]](https://typelevel.org/cats/datatypes/eithert.html) type.
+ */
+declare class EitherP<L, R> implements PromiseLike<Either<L, R>> {
+  private readonly value;
+  private constructor();
+  /**
+   * 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>;
+  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>;
+  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>;
+  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>;
+  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>;
+  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>;
+  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>;
+  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.
+   */
+  fold<U1, U2>(leftFn: (l: L) => U1, rightFn: (r: R) => U2): Promise<U1 | U2>;
+  /**
+   * Allows to deconstruct the Either using:
+   *
+   * @example
+   *
+   * ```ts
+   * declare const e: EitherP<string, number>;
+   *
+   * const [left, right] = await e.pair();
+   * ```
+   *
+   */
+  pair(): Promise<[Maybe<L>, Maybe<R>]>;
+  /**
+   * Returns true if this Either is a Right, false otherwise.
+   */
+  isRight(): Promise<boolean>;
+  /**
+   * Returns true if this Either is a Left, false otherwise.
+   */
+  isLeft(): Promise<boolean>;
+  /**
+   * Gets the right value if this is a Right or undefined if it's a Left.
+   */
+  get(): Promise<Maybe<R>>;
+  /**
+   * Returns the left value if this is a Left or undefined if it's a Right.
+   */
+  getLeft(): Promise<Maybe<L>>;
+  /**
+   * Gets the right value if this is a Right or the result of the provided function if it's a Left.
+   */
+  getOrElse<T>(defaultValue: (l: L) => T): Promise<R | T>;
+  /**
+   * Creates a new Left EitherP with the provided value.
+   */
+  static left<L>(value: Promise<L>): EitherP<L, never>;
+  /**
+   * Creates a new Right EitherP with the provided value.
+   */
+  static right<R>(value: Promise<R>): EitherP<never, R>;
+  static fromMaybe<L, R>(value: Promise<Maybe<R>>, leftValue: () => Promise<L>): EitherP<L, R>;
+  /**
+   * @deprecated
+   */
+  static fromEither<L, R>(either: PromiseLike<Either<L, R>>): EitherP<L, R>;
+  static fromPromise<L, R>(either: PromiseLike<Either<L, R>>): EitherP<L, R>;
+  static cond<L, R>(bool: Promise<boolean>, rightFn: () => Promise<R>, leftFn: () => Promise<L>): EitherP<L, R>;
+  then<U>(onfulfilled?: (value: Either<L, R>) => U | PromiseLike<U>): PromiseLike<U>;
+}
+//#endregion
+export { Either, EitherP, Left, Right };
+//# sourceMappingURL=either.d.mts.map

package/dist/either.d.mts.map

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

package/dist/either.mjs

@@ -0,0 +1,326 @@
+import { isDefined } from "./maybe.mjs";
+
+//#region src/either.ts
+var EitherBase = class {
+	/**
+	* Maps the value of this Either if it is a Right, performs no operation if this is a Left.
+	*/
+	map(fn) {
+		return this.flatMap((value) => Either.right(fn(value)));
+	}
+	mapAsync(fn) {
+		return EitherP.fromPromise(toEitherPromise(this)).mapAsync(fn);
+	}
+	/**
+	* Flat maps the value of this Either if it is a Left, performs no operation if this is a Right.
+	*/
+	leftFlatMap(fn) {
+		return this.fold((l) => fn(l), (r) => Either.right(r));
+	}
+	leftFlatMapAsync(fn) {
+		return EitherP.fromPromise(toEitherPromise(this)).leftFlatMapAsync(fn);
+	}
+	/**
+	* Maps the value of this Either if it is a Left, performs no operation if this is a Right.
+	*/
+	leftMap(fn) {
+		return this.fold((l) => Either.left(fn(l)), (r) => Either.right(r));
+	}
+	leftMapAsync(fn) {
+		return EitherP.fromPromise(toEitherPromise(this)).leftMapAsync(fn);
+	}
+	/**
+	* 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(leftFn, rightFn) {
+		return this.fold((l) => Either.left(leftFn(l)), (r) => Either.right(rightFn(r)));
+	}
+	bimapAsync(leftFn, rightFn) {
+		return EitherP.fromPromise(toEitherPromise(this)).bimapAsync(leftFn, rightFn);
+	}
+	/**
+	* 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) {
+		return this.flatMap((value) => {
+			fn(value);
+			return Either.right(value);
+		});
+	}
+	tapAsync(fn) {
+		return EitherP.fromPromise(toEitherPromise(this)).tapAsync(fn);
+	}
+	/**
+	* 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(fn) {
+		return this.flatMap((value) => fn(value).map(() => value));
+	}
+	flatTapAsync(fn) {
+		return EitherP.fromPromise(toEitherPromise(this)).flatTapAsync(fn);
+	}
+	/**
+	* Flat maps the value of this Either if it is a Right, performs no operation if this is a Left.
+	*/
+	flatMap(fn) {
+		return this.fold((l) => Either.left(l), (r) => fn(r));
+	}
+	flatMapAsync(fn) {
+		return EitherP.fromPromise(toEitherPromise(this)).flatMapAsync(fn);
+	}
+	/**
+	* Allows to deconstruct the Either using:
+	*
+	* @example
+	*
+	* ```ts
+	* declare const e: Either<string, number>;
+	*
+	* const [left, right] = e.pair();
+	* ```
+	*
+	*/
+	pair() {
+		return [this.getLeft(), this.get()];
+	}
+	/**
+	* Returns true if this Either is a Right, false otherwise.
+	*/
+	isRight() {
+		return this.fold(() => false, () => true);
+	}
+	/**
+	* Returns true if this Either is a Left, false otherwise.
+	*/
+	isLeft() {
+		return this.fold(() => true, () => false);
+	}
+	/**
+	* Gets the right value if this is a Right or undefined if it's a Left.
+	*/
+	get() {
+		return this.fold(() => undefined, (r) => r);
+	}
+	/**
+	* Returns the left value if this is a Left or undefined if it's a Right.
+	*/
+	getLeft() {
+		return this.fold((l) => l, () => undefined);
+	}
+	/**
+	* Gets the right value if this is a Right or the result of the provided function if it's a Left.
+	*/
+	getOrElse(defaultValue) {
+		return this.fold((l) => defaultValue(l), (r) => r);
+	}
+};
+function toEitherPromise(e) {
+	return Promise.resolve(e);
+}
+var Left = class extends EitherBase {
+	value;
+	constructor(value) {
+		super();
+		this.value = value;
+	}
+	fold(leftFn, _rightFn) {
+		return leftFn(this.value);
+	}
+	getLeft() {
+		return this.value;
+	}
+};
+var Right = class extends EitherBase {
+	value;
+	constructor(value) {
+		super();
+		this.value = value;
+	}
+	fold(_leftFn, rightFn) {
+		return rightFn(this.value);
+	}
+	get() {
+		return this.value;
+	}
+};
+let Either;
+(function(_Either) {
+	function left(value) {
+		return new Left(value);
+	}
+	_Either.left = left;
+	function right(value) {
+		return new Right(value);
+	}
+	_Either.right = right;
+	function fromMaybe(value, leftValue) {
+		return isDefined(value) ? Either.right(value) : Either.left(leftValue());
+	}
+	_Either.fromMaybe = fromMaybe;
+	function cond(bool, rightFn, leftFn) {
+		return bool ? Either.right(rightFn()) : Either.left(leftFn());
+	}
+	_Either.cond = cond;
+})(Either || (Either = {}));
+/**
+* Mimics the [Cats EitherT[Future, L, R]](https://typelevel.org/cats/datatypes/eithert.html) type.
+*/
+var EitherP = class EitherP {
+	value;
+	constructor(value) {
+		this.value = value;
+	}
+	/**
+	* Maps the value of this Either if it is a Right, performs no operation if this is a Left.
+	*/
+	map(fn) {
+		return new EitherP(this.value.then((e) => e.map(fn)));
+	}
+	mapAsync(fn) {
+		return this.flatMapAsync(async (value) => Either.right(await fn(value)));
+	}
+	/**
+	* Maps the value of this Either if it is a Left, performs no operation if this is a Right.
+	*/
+	leftMap(fn) {
+		return new EitherP(this.value.then((e) => e.leftMap(fn)));
+	}
+	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))));
+	}
+	/**
+	* Flat maps the value of this Either if it is a Left, performs no operation if this is a Right.
+	*/
+	leftFlatMap(fn) {
+		return new EitherP(this.value.then((e) => e.leftFlatMap(fn)));
+	}
+	leftFlatMapAsync(fn) {
+		return new EitherP(this.value.then(async (e) => await e.fold(async (left) => await fn(left), async (right) => Either.right(right))));
+	}
+	/**
+	* 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(leftFn, rightFn) {
+		return new EitherP(this.value.then((e) => e.bimap(leftFn, rightFn)));
+	}
+	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)))));
+	}
+	/**
+	* 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) {
+		return new EitherP(this.value.then((e) => e.tap(fn)));
+	}
+	tapAsync(fn) {
+		return this.flatMapAsync(async (value) => {
+			await fn(value);
+			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.
+	* If the result of the function is a Left, it will be returned, otherwise the original Right value will be returned.
+	*/
+	flatTap(fn) {
+		return new EitherP(this.value.then((e) => e.flatTap(fn)));
+	}
+	flatTapAsync(fn) {
+		return this.flatMapAsync(async (value) => (await fn(value)).map(() => value));
+	}
+	/**
+	* Flat maps the value of this Either if it is a Right, performs no operation if this is a Left.
+	*/
+	flatMap(fn) {
+		return new EitherP(this.value.then((e) => e.flatMap(fn)));
+	}
+	flatMapAsync(fn) {
+		return new EitherP(this.value.then((e) => e.fold(async (left) => Either.left(left), (right) => fn(right))));
+	}
+	/**
+	* Applies the provided functions to the value of this Either, depending on whether it is a Right or a Left and returns the result.
+	*/
+	async fold(leftFn, rightFn) {
+		return (await this.value).fold(leftFn, rightFn);
+	}
+	/**
+	* Allows to deconstruct the Either using:
+	*
+	* @example
+	*
+	* ```ts
+	* declare const e: EitherP<string, number>;
+	*
+	* const [left, right] = await e.pair();
+	* ```
+	*
+	*/
+	async pair() {
+		return [await this.getLeft(), await this.get()];
+	}
+	/**
+	* Returns true if this Either is a Right, false otherwise.
+	*/
+	async isRight() {
+		return (await this.value).isRight();
+	}
+	/**
+	* Returns true if this Either is a Left, false otherwise.
+	*/
+	async isLeft() {
+		return !await this.isRight();
+	}
+	/**
+	* Gets the right value if this is a Right or undefined if it's a Left.
+	*/
+	async get() {
+		return (await this.value).get();
+	}
+	/**
+	* Returns the left value if this is a Left or undefined if it's a Right.
+	*/
+	async getLeft() {
+		return (await this.value).getLeft();
+	}
+	/**
+	* Gets the right value if this is a Right or the result of the provided function if it's a Left.
+	*/
+	async getOrElse(defaultValue) {
+		return (await this.value).getOrElse(defaultValue);
+	}
+	/**
+	* Creates a new Left EitherP with the provided value.
+	*/
+	static left(value) {
+		return new EitherP(value.then((v) => Either.left(v)));
+	}
+	/**
+	* Creates a new Right EitherP with the provided value.
+	*/
+	static right(value) {
+		return new EitherP(value.then((v) => Either.right(v)));
+	}
+	static fromMaybe(value, leftValue) {
+		return new EitherP(value.then(async (v) => isDefined(v) ? Either.right(v) : Either.left(await leftValue())));
+	}
+	/**
+	* @deprecated
+	*/
+	static fromEither(either) {
+		return new EitherP(either);
+	}
+	static fromPromise(either) {
+		return new EitherP(either);
+	}
+	static cond(bool, rightFn, leftFn) {
+		return new EitherP(bool.then(async (b) => b ? Either.right(await rightFn()) : Either.left(await leftFn())));
+	}
+	then(onfulfilled) {
+		return this.value.then(onfulfilled);
+	}
+};
+
+//#endregion
+export { Either, EitherP, Left, Right };
+//# sourceMappingURL=either.mjs.map

package/dist/either.mjs.map

@@ -0,0 +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\n// eslint-disable-next-line @typescript-eslint/no-namespace\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, rightFn: () => R, leftFn: () => L): 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    rightFn: () => Promise<R>,\n    leftFn: () => Promise<L>,\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  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

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

package/dist/index.mjs

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

package/dist/maybe.d.mts

@@ -0,0 +1,16 @@
+//#region src/maybe.d.ts
+type Maybe<T> = T | undefined;
+declare function mapMaybe<T, U>(value: Maybe<T>, fn: (value: T) => U): Maybe<U>;
+declare function isDefined<T>(value: Maybe<T>): value is T;
+declare function flattenMaybe<T>(value: Maybe<Maybe<T>>): Maybe<T>;
+declare function ifTrue<T>(value: boolean, fn: () => T): Maybe<T>;
+declare function ifFalse<T>(value: boolean, fn: () => T): Maybe<T>;
+declare function matchPair<A, B, R>([a, b]: [Maybe<A>, Maybe<B>], cases: {
+  neither: () => R;
+  a: (a: A) => R;
+  b: (b: B) => R;
+  both: (a: A, b: B) => R;
+}): R;
+//#endregion
+export { Maybe, flattenMaybe, ifFalse, ifTrue, isDefined, mapMaybe, matchPair };
+//# sourceMappingURL=maybe.d.mts.map

package/dist/maybe.d.mts.map

@@ -0,0 +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"}

package/dist/maybe.mjs

@@ -0,0 +1,32 @@
+//#region src/maybe.ts
+function mapMaybe(value, fn) {
+	return value === undefined ? undefined : fn(value);
+}
+function isDefined(value) {
+	return value !== undefined;
+}
+function flattenMaybe(value) {
+	return mapMaybe(value, (v) => v);
+}
+function ifTrue(value, fn) {
+	return value ? fn() : undefined;
+}
+function ifFalse(value, fn) {
+	return !value ? fn() : undefined;
+}
+function matchPair([a, b], cases) {
+	if (!isDefined(a)) {
+		if (!isDefined(b)) {
+			return cases.neither();
+		}
+		return cases.b(b);
+	}
+	if (!isDefined(b)) {
+		return cases.a(a);
+	}
+	return cases.both(a, b);
+}
+
+//#endregion
+export { flattenMaybe, ifFalse, ifTrue, isDefined, mapMaybe, matchPair };
+//# sourceMappingURL=maybe.mjs.map

package/dist/maybe.mjs.map

@@ -0,0 +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,YAAY,YAAY,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,GAAG;GACjB,OAAO,MAAM,QAAQ;EACvB;EAEA,OAAO,MAAM,EAAE,CAAC;CAClB;CAEA,IAAI,CAAC,UAAU,CAAC,GAAG;EACjB,OAAO,MAAM,EAAE,CAAC;CAClB;CAEA,OAAO,MAAM,KAAK,GAAG,CAAC;AACxB"}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@jeengbe/prelude",
+  "version": "0.0.0",
+  "license": "MIT",
+  "files": [
+    "dist",
+    "src",
+    "!src/**/*.spec.ts"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "oxfmt": "^0.60.0",
+    "oxlint": "^1.75.0",
+    "tsdown": "^0.22.14",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10",
+    "@jeengbe/scaffolding": "0.0.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "lint": "oxlint --fix . && oxfmt --write .",
+    "test": "vitest",
+    "typecheck": "tsc"
+  }
+}

package/src/either.ts

@@ -0,0 +1,477 @@
+import type { Maybe } from './maybe.js';
+import { isDefined } from './maybe.js';
+
+// Note that xxxAsync implementations in Either all look like:
+// EitherP.fromPromise(toEitherPromise(this)).xxxAsync(...)
+//
+// And conversely, xxx implementations in EitherP all look like:
+// new EitherP(this.value.then(e => e.xxx(...)))
+
+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> {
+    return this.flatMap((value) => Either.right(fn(value)));
+  }
+
+  mapAsync<R2>(fn: (t: R) => Promise<R2>): EitherP<L, R2> {
+    return EitherP.fromPromise(toEitherPromise(this)).mapAsync(fn);
+  }
+
+  /**
+   * 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> {
+    return this.fold(
+      (l) => fn(l),
+      (r) => Either.right(r),
+    );
+  }
+
+  leftFlatMapAsync<L2, R2>(fn: (t: L) => PromiseLike<Either<L2, R2>>): EitherP<L2, R | R2> {
+    return EitherP.fromPromise(toEitherPromise(this)).leftFlatMapAsync(fn);
+  }
+
+  /**
+   * 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> {
+    return this.fold(
+      (l) => Either.left(fn(l)),
+      (r) => Either.right(r),
+    );
+  }
+
+  leftMapAsync<L2>(fn: (t: L) => Promise<L2>): EitherP<L2, R> {
+    return EitherP.fromPromise(toEitherPromise(this)).leftMapAsync(fn);
+  }
+
+  /**
+   * 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> {
+    return this.fold(
+      (l) => Either.left(leftFn(l)),
+      (r) => Either.right(rightFn(r)),
+    );
+  }
+
+  bimapAsync<L2, R2>(
+    leftFn: (l: L) => Promise<L2>,
+    rightFn: (r: R) => Promise<R2>,
+  ): EitherP<L2, R2> {
+    return EitherP.fromPromise(toEitherPromise(this)).bimapAsync(leftFn, rightFn);
+  }
+
+  /**
+   * 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> {
+    return this.flatMap((value) => {
+      fn(value);
+      return Either.right(value);
+    });
+  }
+
+  tapAsync(fn: (t: R) => Promise<void>): EitherP<L, R> {
+    return EitherP.fromPromise(toEitherPromise(this)).tapAsync(fn);
+  }
+
+  /**
+   * 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> {
+    return this.flatMap((value) => fn(value).map(() => value));
+  }
+
+  flatTapAsync<L2>(fn: (t: R) => PromiseLike<Either<L2, void>>): EitherP<L | L2, R> {
+    return EitherP.fromPromise(toEitherPromise(this)).flatTapAsync(fn);
+  }
+
+  /**
+   * 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> {
+    return this.fold(
+      (l) => Either.left(l),
+      (r) => fn(r),
+    );
+  }
+
+  flatMapAsync<L2, R2>(fn: (t: R) => PromiseLike<Either<L2, R2>>): EitherP<L | L2, R2> {
+    return EitherP.fromPromise(toEitherPromise(this)).flatMapAsync(fn);
+  }
+
+  /**
+   * Applies the provided functions to the value of this Either, depending on whether it is a Right or a Left and returns the result.
+   */
+  abstract fold<U1, U2>(leftFn: (l: L) => U1, rightFn: (r: R) => U2): U1 | U2;
+
+  /**
+   * Allows to deconstruct the Either using:
+   *
+   * @example
+   *
+   * ```ts
+   * declare const e: Either<string, number>;
+   *
+   * const [left, right] = e.pair();
+   * ```
+   *
+   */
+  pair(): [Maybe<L>, Maybe<R>] {
+    return [this.getLeft(), this.get()];
+  }
+
+  /**
+   * Returns true if this Either is a Right, false otherwise.
+   */
+  isRight(): this is Right<R> {
+    return this.fold(
+      () => false,
+      () => true,
+    );
+  }
+
+  /**
+   * Returns true if this Either is a Left, false otherwise.
+   */
+  isLeft(): this is Left<L> {
+    return this.fold(
+      () => true,
+      () => false,
+    );
+  }
+
+  /**
+   * 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,
+    );
+  }
+
+  /**
+   * 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,
+    );
+  }
+
+  /**
+   * Gets the right value if this is a Right or the result of the provided function if it's a Left.
+   */
+  getOrElse<T>(defaultValue: (l: L) => T): R | T {
+    return this.fold(
+      (l) => defaultValue(l),
+      (r) => 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>> {
+  return Promise.resolve(e as unknown as Either<L, R>);
+}
+
+export class Left<L> extends EitherBase<L, never> {
+  constructor(private readonly value: L) {
+    super();
+  }
+
+  fold<U1, U2>(leftFn: (l: L) => U1, _rightFn: (r: never) => U2): U1 | U2 {
+    return leftFn(this.value);
+  }
+
+  override getLeft(): L {
+    return this.value;
+  }
+}
+
+export class Right<R> extends EitherBase<never, R> {
+  constructor(private readonly value: R) {
+    super();
+  }
+
+  fold<U1, U2>(_leftFn: (l: never) => U1, rightFn: (r: R) => U2): U1 | U2 {
+    return rightFn(this.value);
+  }
+
+  override get(): R {
+    return this.value;
+  }
+}
+
+/**
+ * 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
+ * declare const e: Either<string, number>;
+ *
+ * if (e.isLeft()) {
+ *   e; // Left<string>
+ * } else {
+ *   e; // Right<number>
+ * }
+ * ```
+ */
+export type Either<L, R> = Left<L> | Right<R>;
+
+export namespace Either {
+  /**
+   * Creates a new Left Either with the provided value.
+   */
+  export function left<L>(value: L): Either<L, never> {
+    return new Left(value);
+  }
+
+  /**
+   * Creates a new Right Either with the provided value.
+   */
+  export function right<R>(value: R): Either<never, R> {
+    return new Right(value);
+  }
+
+  export function fromMaybe<L, R>(value: Maybe<R>, leftValue: () => L): Either<L, R> {
+    return isDefined(value) ? Either.right(value) : Either.left(leftValue());
+  }
+
+  export function cond<L, R>(bool: boolean, rightFn: () => R, leftFn: () => L): 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.
+ */
+export class EitherP<L, R> implements PromiseLike<Either<L, R>> {
+  private constructor(private readonly value: 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> {
+    return new EitherP(this.value.then((e) => e.map(fn)));
+  }
+
+  mapAsync<R2>(fn: (t: R) => Promise<R2>): EitherP<L, R2> {
+    return this.flatMapAsync(async (value) => Either.right(await fn(value)));
+  }
+
+  /**
+   * 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> {
+    return new EitherP(this.value.then((e) => e.leftMap(fn)));
+  }
+
+  leftMapAsync<L2>(fn: (t: L) => Promise<L2>): EitherP<L2, R> {
+    return new EitherP(
+      this.value.then(
+        async (e) =>
+          await e.fold(
+            async (l) => Either.left(await fn(l)),
+            async (r) => Either.right(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> {
+    return new EitherP(this.value.then((e) => e.leftFlatMap(fn)));
+  }
+
+  leftFlatMapAsync<L2, R2>(fn: (t: L) => PromiseLike<Either<L2, R2>>): EitherP<L2, R | R2> {
+    return new EitherP(
+      this.value.then<Either<L2, R | R2>>(
+        async (e) =>
+          await e.fold(
+            async (left) => await fn(left),
+            async (right) => Either.right(right),
+          ),
+      ),
+    );
+  }
+
+  /**
+   * 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> {
+    return new EitherP(this.value.then((e) => e.bimap(leftFn, rightFn)));
+  }
+
+  bimapAsync<L2, R2>(
+    leftFn: (l: L) => Promise<L2>,
+    rightFn: (r: R) => Promise<R2>,
+  ): EitherP<L2, R2> {
+    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)),
+          ),
+      ),
+    );
+  }
+
+  /**
+   * 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> {
+    return new EitherP(this.value.then((e) => e.tap(fn)));
+  }
+
+  tapAsync(fn: (t: R) => Promise<void>): EitherP<L, R> {
+    return this.flatMapAsync(async (value) => {
+      await fn(value);
+      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.
+   * 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> {
+    return new EitherP(this.value.then((e) => e.flatTap(fn)));
+  }
+
+  flatTapAsync<L2>(fn: (t: R) => PromiseLike<Either<L2, void>>): EitherP<L | L2, R> {
+    return this.flatMapAsync(async (value) => (await fn(value)).map(() => value));
+  }
+
+  /**
+   * 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> {
+    return new EitherP(this.value.then((e) => e.flatMap(fn)));
+  }
+
+  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) =>
+        e.fold(
+          async (left) => Either.left(left),
+          (right) => fn(right),
+        ),
+      ),
+    );
+  }
+
+  /**
+   * Applies the provided functions to the value of this Either, depending on whether it is a Right or a Left and returns the result.
+   */
+  async fold<U1, U2>(leftFn: (l: L) => U1, rightFn: (r: R) => U2): Promise<U1 | U2> {
+    return (await this.value).fold(leftFn, rightFn);
+  }
+
+  /**
+   * Allows to deconstruct the Either using:
+   *
+   * @example
+   *
+   * ```ts
+   * declare const e: EitherP<string, number>;
+   *
+   * const [left, right] = await e.pair();
+   * ```
+   *
+   */
+  async pair(): Promise<[Maybe<L>, Maybe<R>]> {
+    return [await this.getLeft(), await this.get()];
+  }
+
+  /**
+   * Returns true if this Either is a Right, false otherwise.
+   */
+  async isRight(): Promise<boolean> {
+    return (await this.value).isRight();
+  }
+
+  /**
+   * Returns true if this Either is a Left, false otherwise.
+   */
+  async isLeft(): Promise<boolean> {
+    return !(await this.isRight());
+  }
+
+  /**
+   * Gets the right value if this is a Right or undefined if it's a Left.
+   */
+  async get(): Promise<Maybe<R>> {
+    return (await this.value).get();
+  }
+
+  /**
+   * Returns the left value if this is a Left or undefined if it's a Right.
+   */
+  async getLeft(): Promise<Maybe<L>> {
+    return (await this.value).getLeft();
+  }
+
+  /**
+   * Gets the right value if this is a Right or the result of the provided function if it's a Left.
+   */
+  async getOrElse<T>(defaultValue: (l: L) => T): Promise<R | T> {
+    return (await this.value).getOrElse(defaultValue);
+  }
+
+  /**
+   * Creates a new Left EitherP with the provided value.
+   */
+  static left<L>(value: Promise<L>): EitherP<L, never> {
+    return new EitherP(value.then((v) => Either.left(v)));
+  }
+
+  /**
+   * Creates a new Right EitherP with the provided value.
+   */
+  static right<R>(value: Promise<R>): EitherP<never, R> {
+    return new EitherP(value.then((v) => Either.right(v)));
+  }
+
+  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()))),
+    );
+  }
+
+  /**
+   * @deprecated
+   */
+  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);
+  }
+
+  static cond<L, R>(
+    bool: Promise<boolean>,
+    rightFn: () => Promise<R>,
+    leftFn: () => Promise<L>,
+  ): EitherP<L, R> {
+    return new EitherP(
+      bool.then(async (b) => (b ? Either.right(await rightFn()) : Either.left(await leftFn()))),
+    );
+  }
+
+  // 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/index.ts

@@ -0,0 +1,2 @@
+export * from './either.js';
+export * from './maybe.js';

package/src/maybe.ts

@@ -0,0 +1,45 @@
+export type Maybe<T> = T | undefined;
+
+export function mapMaybe<T, U>(value: Maybe<T>, fn: (value: T) => U): Maybe<U> {
+  return value === undefined ? undefined : fn(value);
+}
+
+export function isDefined<T>(value: Maybe<T>): value is T {
+  return value !== undefined;
+}
+
+export function flattenMaybe<T>(value: Maybe<Maybe<T>>): Maybe<T> {
+  return mapMaybe(value, (v) => v);
+}
+
+export function ifTrue<T>(value: boolean, fn: () => T): Maybe<T> {
+  return value ? fn() : undefined;
+}
+
+export function ifFalse<T>(value: boolean, fn: () => T): Maybe<T> {
+  return !value ? fn() : undefined;
+}
+
+export function matchPair<A, B, R>(
+  [a, b]: [Maybe<A>, Maybe<B>],
+  cases: {
+    neither: () => R;
+    a: (a: A) => R;
+    b: (b: B) => R;
+    both: (a: A, b: B) => R;
+  },
+): R {
+  if (!isDefined(a)) {
+    if (!isDefined(b)) {
+      return cases.neither();
+    }
+
+    return cases.b(b);
+  }
+
+  if (!isDefined(b)) {
+    return cases.a(a);
+  }
+
+  return cases.both(a, b);
+}