aang 2.0.0-alpha.3 → 2.0.0-alpha.31

package/lib/order.d.ts

@@ -0,0 +1,18 @@
+import type { Option } from "./option.js";
+import type { Ordering } from "./ordering.js";
+export interface Setoid<in A> {
+    isSame: (this: A, that: A) => boolean;
+    isNotSame: (this: A, that: A) => boolean;
+}
+export interface PartialOrder<in A> extends Setoid<A> {
+    isLess: (this: A, that: A) => boolean;
+    isNotLess: (this: A, that: A) => boolean;
+    isMore: (this: A, that: A) => boolean;
+    isNotMore: (this: A, that: A) => boolean;
+    compare: (this: A, that: A) => Option<Ordering>;
+}
+export interface TotalOrder<in out A> extends PartialOrder<A> {
+    max: (this: A, that: A) => A;
+    min: (this: A, that: A) => A;
+    clamp: (this: A, lower: A, upper: A) => A;
+}

package/lib/order.js

@@ -0,0 +1 @@
+export {};

package/lib/ordering.d.ts

@@ -0,0 +1,7 @@
+export type Ordering = "<" | "=" | ">";
+export declare const isSame: (x: Ordering) => x is "=";
+export declare const isNotSame: (x: Ordering) => x is "<" | ">";
+export declare const isLess: (x: Ordering) => x is "<";
+export declare const isNotLess: (x: Ordering) => x is "=" | ">";
+export declare const isMore: (x: Ordering) => x is ">";
+export declare const isNotMore: (x: Ordering) => x is "<" | "=";

package/lib/ordering.js

@@ -0,0 +1,6 @@
+export const isSame = (x) => x === "=";
+export const isNotSame = (x) => x !== "=";
+export const isLess = (x) => x === "<";
+export const isNotLess = (x) => x !== "<";
+export const isMore = (x) => x === ">";
+export const isNotMore = (x) => x !== ">";

package/lib/pair.d.ts

@@ -0,0 +1,106 @@
+import type { Option } from "./option.js";
+import type { PartialOrder, Setoid, TotalOrder } from "./order.js";
+import type { Ordering } from "./ordering.js";
+import type { Result } from "./result.js";
+import type { Semigroup } from "./semigroup.js";
+import { Task } from "./task.js";
+export declare class Pair<out A, out B> {
+    readonly fst: A;
+    readonly snd: B;
+    constructor(fst: A, snd: B);
+    static of<A, B>(fst: A, snd: B): Pair<A, B>;
+    static from<A>(value: A): Pair<A, A>;
+    static fst<A>(value: A): Pair<A, void>;
+    static snd<B>(value: B): Pair<void, B>;
+    toString<A, B>(this: Pair<A, B>): string;
+    fold<A, B, C>(this: Pair<A, B>, morphism: (a: A, b: B) => C): C;
+    map<A, B, C, D>(this: Pair<A, B>, fstMorphism: (fst: A) => C, sndMorphism: (snd: B) => D): Pair<C, D>;
+    mapFst<A, B, C>(this: Pair<A, C>, morphism: (fst: A) => B): Pair<B, C>;
+    mapSnd<A, B, C>(this: Pair<A, B>, morphism: (snd: B) => C): Pair<A, C>;
+    replaceFst<A, B, C>(this: Pair<A, C>, fst: B): Pair<B, C>;
+    replaceSnd<A, B, C>(this: Pair<A, B>, snd: C): Pair<A, C>;
+    and<A, B, C, D>(this: Pair<A, B>, that: Pair<C, D>): Pair<Pair<A, C>, Pair<B, D>>;
+    andFst<A, B, C extends Semigroup<C>>(this: Pair<A, C>, that: Pair<B, C>): Pair<Pair<A, B>, C>;
+    andThenFst<A, B, C extends Semigroup<C>>(this: Pair<A, C>, that: Pair<B, C>): Pair<B, C>;
+    andWhenFst<A, B, C extends Semigroup<C>>(this: Pair<A, C>, that: Pair<B, C>): Pair<A, C>;
+    andSnd<A extends Semigroup<A>, B, C>(this: Pair<A, B>, that: Pair<A, C>): Pair<A, Pair<B, C>>;
+    andThenSnd<A extends Semigroup<A>, B, C>(this: Pair<A, B>, that: Pair<A, C>): Pair<A, C>;
+    andWhenSnd<A extends Semigroup<A>, B, C>(this: Pair<A, B>, that: Pair<A, C>): Pair<A, B>;
+    flatMapFst<A, B, C extends Semigroup<C>>(this: Pair<A, C>, arrow: (value: A) => Pair<B, C>): Pair<B, C>;
+    flatMapSnd<A extends Semigroup<A>, B, C>(this: Pair<A, B>, arrow: (value: B) => Pair<A, C>): Pair<A, C>;
+    flattenFst<A, B extends Semigroup<B>>(this: Pair<Pair<A, B>, B>): Pair<A, B>;
+    flattenSnd<A extends Semigroup<A>, B>(this: Pair<A, Pair<A, B>>): Pair<A, B>;
+    flatMapFstUntil<A, B, C extends Semigroup<C>>(this: Pair<A, C>, arrow: (value: A) => Pair<Result<B, A>, C>): Pair<B, C>;
+    flatMapSndUntil<A extends Semigroup<A>, B, C>(this: Pair<A, B>, arrow: (value: B) => Pair<A, Result<C, B>>): Pair<A, C>;
+    extendMapFst<A, B, C>(this: Pair<A, C>, arrow: (pair: Pair<A, C>) => B): Pair<B, C>;
+    extendMapSnd<A, B, C>(this: Pair<A, B>, arrow: (pair: Pair<A, B>) => C): Pair<A, C>;
+    extendFst<A, B>(this: Pair<A, B>): Pair<Pair<A, B>, B>;
+    extendSnd<A, B>(this: Pair<A, B>): Pair<A, Pair<A, B>>;
+    commute<A, B>(this: Pair<A, B>): Pair<B, A>;
+    andMapOption<X, Y, A, B>(this: Pair<X, Y>, fstMorphism: (value: X) => Option<A>, sndMorphism: (value: Y) => Option<B>): Option<Pair<A, B>>;
+    andMapFstOption<X, A, B>(this: Pair<X, B>, morphism: (value: X) => Option<A>): Option<Pair<A, B>>;
+    andMapSndOption<Y, A, B>(this: Pair<A, Y>, morphism: (value: Y) => Option<B>): Option<Pair<A, B>>;
+    andOption<A, B>(this: Pair<Option<A>, Option<B>>): Option<Pair<A, B>>;
+    andFstOption<A, B>(this: Pair<Option<A>, B>): Option<Pair<A, B>>;
+    andSndOption<A, B>(this: Pair<A, Option<B>>): Option<Pair<A, B>>;
+    andMapResult<X, Y, A, B, E>(this: Pair<X, Y>, fstMorphism: (value: X) => Result<A, E>, sndMorphism: (value: Y) => Result<B, E>): Result<Pair<A, B>, E>;
+    andMapFstResult<X, A, B, E>(this: Pair<X, B>, morphism: (value: X) => Result<A, E>): Result<Pair<A, B>, E>;
+    andMapSndResult<Y, A, B, E>(this: Pair<A, Y>, morphism: (value: Y) => Result<B, E>): Result<Pair<A, B>, E>;
+    andResult<A, B, E>(this: Pair<Result<A, E>, Result<B, E>>): Result<Pair<A, B>, E>;
+    andFstResult<A, B, E>(this: Pair<Result<A, E>, B>): Result<Pair<A, B>, E>;
+    andSndResult<A, B, E>(this: Pair<A, Result<B, E>>): Result<Pair<A, B>, E>;
+    orMapResult<X, Y, A, E, F>(this: Pair<X, Y>, fstMorphism: (value: X) => Result<A, E>, sndMorphism: (value: Y) => Result<A, F>): Result<A, Pair<E, F>>;
+    orMapFstResult<X, A, E, F>(this: Pair<X, F>, morphism: (value: X) => Result<A, E>): Result<A, Pair<E, F>>;
+    orMapSndResult<Y, A, E, F>(this: Pair<E, Y>, morphism: (value: Y) => Result<A, F>): Result<A, Pair<E, F>>;
+    orResult<A, E, F>(this: Pair<Result<A, E>, Result<A, F>>): Result<A, Pair<E, F>>;
+    orFstResult<A, E, F>(this: Pair<Result<A, E>, F>): Result<A, Pair<E, F>>;
+    orSndResult<A, E, F>(this: Pair<E, Result<A, F>>): Result<A, Pair<E, F>>;
+    andMapTask<X, Y, A, B, E>(this: Pair<X, Y>, fstMorphism: (value: X) => Task<A, E>, sndMorphism: (value: Y) => Task<B, E>): Task<Pair<A, B>, E>;
+    andMapFstTask<X, A, B, E>(this: Pair<X, B>, morphism: (value: X) => Task<A, E>): Task<Pair<A, B>, E>;
+    andMapSndTask<Y, A, B, E>(this: Pair<A, Y>, morphism: (value: Y) => Task<B, E>): Task<Pair<A, B>, E>;
+    andTask<A, B, E>(this: Pair<Task<A, E>, Task<B, E>>): Task<Pair<A, B>, E>;
+    andFstTask<A, B, E>(this: Pair<Task<A, E>, B>): Task<Pair<A, B>, E>;
+    andSndTask<A, B, E>(this: Pair<A, Task<B, E>>): Task<Pair<A, B>, E>;
+    orMapTask<X, Y, A, E, F>(this: Pair<X, Y>, fstMorphism: (value: X) => Task<A, E>, sndMorphism: (value: Y) => Task<A, F>): Task<A, Pair<E, F>>;
+    orMapFstTask<X, A, E, F>(this: Pair<X, F>, morphism: (value: X) => Task<A, E>): Task<A, Pair<E, F>>;
+    orMapSndTask<Y, A, E, F>(this: Pair<E, Y>, morphism: (value: Y) => Task<A, F>): Task<A, Pair<E, F>>;
+    orTask<A, E, F>(this: Pair<Task<A, E>, Task<A, F>>): Task<A, Pair<E, F>>;
+    orFstTask<A, E, F>(this: Pair<Task<A, E>, F>): Task<A, Pair<E, F>>;
+    orSndTask<A, E, F>(this: Pair<E, Task<A, F>>): Task<A, Pair<E, F>>;
+    distributeMap<X, Y, A, B, C, D>(this: Pair<X, Y>, fstMorphism: (value: X) => Pair<A, B>, sndMorphism: (value: Y) => Pair<C, D>): Pair<Pair<A, C>, Pair<B, D>>;
+    distributeMapFst<X, A, B, C>(this: Pair<X, C>, morphism: (value: X) => Pair<A, B>): Pair<Pair<A, C>, Pair<B, C>>;
+    distributeMapSnd<Y, A, B, C>(this: Pair<A, Y>, morphism: (value: Y) => Pair<B, C>): Pair<Pair<A, B>, Pair<A, C>>;
+    distribute<A, B, C, D>(this: Pair<Pair<A, B>, Pair<C, D>>): Pair<Pair<A, C>, Pair<B, D>>;
+    distributeFst<A, B, C>(this: Pair<Pair<A, B>, C>): Pair<Pair<A, C>, Pair<B, C>>;
+    distributeSnd<A, B, C>(this: Pair<A, Pair<B, C>>): Pair<Pair<A, B>, Pair<A, C>>;
+    exchangeMapSnd<X, A, B, C>(this: Pair<X, C>, morphism: (value: X) => Pair<A, B>): Pair<Pair<A, C>, B>;
+    associateMapLeft<Y, A, B, C>(this: Pair<A, Y>, morphism: (value: Y) => Pair<B, C>): Pair<Pair<A, B>, C>;
+    exchangeSnd<A, B, C>(this: Pair<Pair<A, B>, C>): Pair<Pair<A, C>, B>;
+    associateLeft<A, B, C>(this: Pair<A, Pair<B, C>>): Pair<Pair<A, B>, C>;
+    exchangeMapFst<Y, A, B, C>(this: Pair<A, Y>, morphism: (value: Y) => Pair<B, C>): Pair<B, Pair<A, C>>;
+    associateMapRight<X, A, B, C>(this: Pair<X, C>, morphism: (value: X) => Pair<A, B>): Pair<A, Pair<B, C>>;
+    exchangeFst<A, B, C>(this: Pair<A, Pair<B, C>>): Pair<B, Pair<A, C>>;
+    associateRight<A, B, C>(this: Pair<Pair<A, B>, C>): Pair<A, Pair<B, C>>;
+    distributeMapOkay<Y, A, B, C>(this: Pair<A, Y>, morphism: (value: Y) => Result<B, C>): Result<Pair<A, B>, Pair<A, C>>;
+    distributeOkay<A, B, C>(this: Pair<A, Result<B, C>>): Result<Pair<A, B>, Pair<A, C>>;
+    distributeMapFail<X, A, B, C>(this: Pair<X, C>, morphism: (value: X) => Result<A, B>): Result<Pair<A, C>, Pair<B, C>>;
+    distributeFail<A, B, C>(this: Pair<Result<A, B>, C>): Result<Pair<A, C>, Pair<B, C>>;
+    scatterMapOkay<Y, A, B, C>(this: Pair<A, Y>, morphism: (value: Y) => Task<B, C>): Task<Pair<A, B>, Pair<A, C>>;
+    scatterOkay<A, B, C>(this: Pair<A, Task<B, C>>): Task<Pair<A, B>, Pair<A, C>>;
+    scatterMapFail<X, A, B, C>(this: Pair<X, C>, morphism: (value: X) => Task<A, B>): Task<Pair<A, C>, Pair<B, C>>;
+    scatterFail<A, B, C>(this: Pair<Task<A, B>, C>): Task<Pair<A, C>, Pair<B, C>>;
+    isSame<A extends Setoid<A>, B extends Setoid<B>>(this: Pair<A, B>, that: Pair<A, B>): boolean;
+    isNotSame<A extends Setoid<A>, B extends Setoid<B>>(this: Pair<A, B>, that: Pair<A, B>): boolean;
+    isLess<A extends PartialOrder<A>, B extends PartialOrder<B>>(this: Pair<A, B>, that: Pair<A, B>): boolean;
+    isNotLess<A extends PartialOrder<A>, B extends PartialOrder<B>>(this: Pair<A, B>, that: Pair<A, B>): boolean;
+    isMore<A extends PartialOrder<A>, B extends PartialOrder<B>>(this: Pair<A, B>, that: Pair<A, B>): boolean;
+    isNotMore<A extends PartialOrder<A>, B extends PartialOrder<B>>(this: Pair<A, B>, that: Pair<A, B>): boolean;
+    compare<A extends PartialOrder<A>, B extends PartialOrder<B>>(this: Pair<A, B>, that: Pair<A, B>): Option<Ordering>;
+    max<A extends TotalOrder<A>, B extends TotalOrder<B>>(this: Pair<A, B>, that: Pair<A, B>): Pair<A, B>;
+    min<A extends TotalOrder<A>, B extends TotalOrder<B>>(this: Pair<A, B>, that: Pair<A, B>): Pair<A, B>;
+    clamp<A extends TotalOrder<A>, B extends TotalOrder<B>>(this: Pair<A, B>, lower: Pair<A, B>, upper: Pair<A, B>): Pair<A, B>;
+    values<A, B>(this: Pair<A, B>): [A, B];
+    effectMap<A, B, C>(this: Pair<A, C>, morphism: (value: A) => B): Generator<Pair<A, C>, B, A>;
+    effect<A, B>(this: Pair<A, B>): Generator<Pair<A, B>, A, A>;
+    static fromGenerator<A, B extends Semigroup<B>>(value: B, getGenerator: () => Generator<Pair<unknown, B>, A, unknown>): Pair<A, B>;
+}

package/lib/pair.js

@@ -0,0 +1,322 @@
+import { Some } from "./option.js";
+import { isLess, isMore, isNotLess, isNotMore, isSame } from "./ordering.js";
+import { Fail, Okay } from "./result.js";
+import { Task } from "./task.js";
+export class Pair {
+    fst;
+    snd;
+    constructor(fst, snd) {
+        this.fst = fst;
+        this.snd = snd;
+    }
+    static of(fst, snd) {
+        return new Pair(fst, snd);
+    }
+    static from(value) {
+        return new Pair(value, value);
+    }
+    static fst(value) {
+        return new Pair(value, undefined);
+    }
+    static snd(value) {
+        return new Pair(undefined, value);
+    }
+    toString() {
+        return `Pair(${String(this.fst)}, ${String(this.snd)})`;
+    }
+    fold(morphism) {
+        return morphism(this.fst, this.snd);
+    }
+    map(fstMorphism, sndMorphism) {
+        return new Pair(fstMorphism(this.fst), sndMorphism(this.snd));
+    }
+    mapFst(morphism) {
+        return new Pair(morphism(this.fst), this.snd);
+    }
+    mapSnd(morphism) {
+        return new Pair(this.fst, morphism(this.snd));
+    }
+    replaceFst(fst) {
+        return new Pair(fst, this.snd);
+    }
+    replaceSnd(snd) {
+        return new Pair(this.fst, snd);
+    }
+    and(that) {
+        return new Pair(new Pair(this.fst, that.fst), new Pair(this.snd, that.snd));
+    }
+    andFst(that) {
+        return new Pair(new Pair(this.fst, that.fst), this.snd.append(that.snd));
+    }
+    andThenFst(that) {
+        return new Pair(that.fst, this.snd.append(that.snd));
+    }
+    andWhenFst(that) {
+        return new Pair(this.fst, this.snd.append(that.snd));
+    }
+    andSnd(that) {
+        return new Pair(this.fst.append(that.fst), new Pair(this.snd, that.snd));
+    }
+    andThenSnd(that) {
+        return new Pair(this.fst.append(that.fst), that.snd);
+    }
+    andWhenSnd(that) {
+        return new Pair(this.fst.append(that.fst), this.snd);
+    }
+    flatMapFst(arrow) {
+        return arrow(this.fst).mapSnd((snd) => this.snd.append(snd));
+    }
+    flatMapSnd(arrow) {
+        return arrow(this.snd).mapFst((fst) => this.fst.append(fst));
+    }
+    flattenFst() {
+        return this.fst.mapSnd((snd) => this.snd.append(snd));
+    }
+    flattenSnd() {
+        return this.snd.mapFst((fst) => this.fst.append(fst));
+    }
+    flatMapFstUntil(arrow) {
+        let result = this.flatMapFst(arrow).distributeFail();
+        while (result.isFail)
+            result = result.value.flatMapFst(arrow).distributeFail();
+        return result.value;
+    }
+    flatMapSndUntil(arrow) {
+        let result = this.flatMapSnd(arrow).distributeOkay();
+        while (result.isFail)
+            result = result.value.flatMapSnd(arrow).distributeOkay();
+        return result.value;
+    }
+    extendMapFst(arrow) {
+        return new Pair(arrow(this), this.snd);
+    }
+    extendMapSnd(arrow) {
+        return new Pair(this.fst, arrow(this));
+    }
+    extendFst() {
+        return new Pair(this, this.snd);
+    }
+    extendSnd() {
+        return new Pair(this.fst, this);
+    }
+    commute() {
+        return new Pair(this.snd, this.fst);
+    }
+    andMapOption(fstMorphism, sndMorphism) {
+        return fstMorphism(this.fst).and(sndMorphism(this.snd));
+    }
+    andMapFstOption(morphism) {
+        return morphism(this.fst).and(new Some(this.snd));
+    }
+    andMapSndOption(morphism) {
+        return new Some(this.fst).and(morphism(this.snd));
+    }
+    andOption() {
+        return this.fst.and(this.snd);
+    }
+    andFstOption() {
+        return this.fst.and(new Some(this.snd));
+    }
+    andSndOption() {
+        return new Some(this.fst).and(this.snd);
+    }
+    andMapResult(fstMorphism, sndMorphism) {
+        return fstMorphism(this.fst).and(sndMorphism(this.snd));
+    }
+    andMapFstResult(morphism) {
+        return morphism(this.fst).and(new Okay(this.snd));
+    }
+    andMapSndResult(morphism) {
+        return new Okay(this.fst).and(morphism(this.snd));
+    }
+    andResult() {
+        return this.fst.and(this.snd);
+    }
+    andFstResult() {
+        return this.fst.and(new Okay(this.snd));
+    }
+    andSndResult() {
+        return new Okay(this.fst).and(this.snd);
+    }
+    orMapResult(fstMorphism, sndMorphism) {
+        return fstMorphism(this.fst).or(sndMorphism(this.snd));
+    }
+    orMapFstResult(morphism) {
+        return morphism(this.fst).or(new Fail(this.snd));
+    }
+    orMapSndResult(morphism) {
+        return new Fail(this.fst).or(morphism(this.snd));
+    }
+    orResult() {
+        return this.fst.or(this.snd);
+    }
+    orFstResult() {
+        return this.fst.or(new Fail(this.snd));
+    }
+    orSndResult() {
+        return new Fail(this.fst).or(this.snd);
+    }
+    andMapTask(fstMorphism, sndMorphism) {
+        return fstMorphism(this.fst).and(sndMorphism(this.snd));
+    }
+    andMapFstTask(morphism) {
+        return morphism(this.fst).and(Task.okay(this.snd));
+    }
+    andMapSndTask(morphism) {
+        return Task.okay(this.fst).and(morphism(this.snd));
+    }
+    andTask() {
+        return this.fst.and(this.snd);
+    }
+    andFstTask() {
+        return this.fst.and(Task.okay(this.snd));
+    }
+    andSndTask() {
+        return Task.okay(this.fst).and(this.snd);
+    }
+    orMapTask(fstMorphism, sndMorphism) {
+        return fstMorphism(this.fst).or(sndMorphism(this.snd));
+    }
+    orMapFstTask(morphism) {
+        return morphism(this.fst).or(Task.fail(this.snd));
+    }
+    orMapSndTask(morphism) {
+        return Task.fail(this.fst).or(morphism(this.snd));
+    }
+    orTask() {
+        return this.fst.or(this.snd);
+    }
+    orFstTask() {
+        return this.fst.or(Task.fail(this.snd));
+    }
+    orSndTask() {
+        return Task.fail(this.fst).or(this.snd);
+    }
+    distributeMap(fstMorphism, sndMorphism) {
+        const fst = fstMorphism(this.fst);
+        const snd = sndMorphism(this.snd);
+        return new Pair(new Pair(fst.fst, snd.fst), new Pair(fst.snd, snd.snd));
+    }
+    distributeMapFst(morphism) {
+        const fst = morphism(this.fst);
+        return new Pair(new Pair(fst.fst, this.snd), new Pair(fst.snd, this.snd));
+    }
+    distributeMapSnd(morphism) {
+        const snd = morphism(this.snd);
+        return new Pair(new Pair(this.fst, snd.fst), new Pair(this.fst, snd.snd));
+    }
+    distribute() {
+        return new Pair(new Pair(this.fst.fst, this.snd.fst), new Pair(this.fst.snd, this.snd.snd));
+    }
+    distributeFst() {
+        return new Pair(new Pair(this.fst.fst, this.snd), new Pair(this.fst.snd, this.snd));
+    }
+    distributeSnd() {
+        return new Pair(new Pair(this.fst, this.snd.fst), new Pair(this.fst, this.snd.snd));
+    }
+    exchangeMapSnd(morphism) {
+        const fst = morphism(this.fst);
+        return new Pair(new Pair(fst.fst, this.snd), fst.snd);
+    }
+    associateMapLeft(morphism) {
+        const snd = morphism(this.snd);
+        return new Pair(new Pair(this.fst, snd.fst), snd.snd);
+    }
+    exchangeSnd() {
+        return new Pair(new Pair(this.fst.fst, this.snd), this.fst.snd);
+    }
+    associateLeft() {
+        return new Pair(new Pair(this.fst, this.snd.fst), this.snd.snd);
+    }
+    exchangeMapFst(morphism) {
+        const snd = morphism(this.snd);
+        return new Pair(snd.fst, new Pair(this.fst, snd.snd));
+    }
+    associateMapRight(morphism) {
+        const fst = morphism(this.fst);
+        return new Pair(fst.fst, new Pair(fst.snd, this.snd));
+    }
+    exchangeFst() {
+        return new Pair(this.snd.fst, new Pair(this.fst, this.snd.snd));
+    }
+    associateRight() {
+        return new Pair(this.fst.fst, new Pair(this.fst.snd, this.snd));
+    }
+    distributeMapOkay(morphism) {
+        return morphism(this.snd).map((snd) => new Pair(this.fst, snd), (snd) => new Pair(this.fst, snd));
+    }
+    distributeOkay() {
+        return this.snd.map((snd) => new Pair(this.fst, snd), (snd) => new Pair(this.fst, snd));
+    }
+    distributeMapFail(morphism) {
+        return morphism(this.fst).map((fst) => new Pair(fst, this.snd), (fst) => new Pair(fst, this.snd));
+    }
+    distributeFail() {
+        return this.fst.map((fst) => new Pair(fst, this.snd), (fst) => new Pair(fst, this.snd));
+    }
+    scatterMapOkay(morphism) {
+        return morphism(this.snd).map((snd) => new Pair(this.fst, snd), (snd) => new Pair(this.fst, snd));
+    }
+    scatterOkay() {
+        return this.snd.map((snd) => new Pair(this.fst, snd), (snd) => new Pair(this.fst, snd));
+    }
+    scatterMapFail(morphism) {
+        return morphism(this.fst).map((fst) => new Pair(fst, this.snd), (fst) => new Pair(fst, this.snd));
+    }
+    scatterFail() {
+        return this.fst.map((fst) => new Pair(fst, this.snd), (fst) => new Pair(fst, this.snd));
+    }
+    isSame(that) {
+        return this.fst.isSame(that.fst) && this.snd.isSame(that.snd);
+    }
+    isNotSame(that) {
+        return this.fst.isNotSame(that.fst) || this.snd.isNotSame(that.snd);
+    }
+    isLess(that) {
+        return this.compare(that).isSomeAnd(isLess);
+    }
+    isNotLess(that) {
+        return this.compare(that).isSomeAnd(isNotLess);
+    }
+    isMore(that) {
+        return this.compare(that).isSomeAnd(isMore);
+    }
+    isNotMore(that) {
+        return this.compare(that).isSomeAnd(isNotMore);
+    }
+    compare(that) {
+        const option = this.fst.compare(that.fst);
+        return option.isSomeAnd(isSame) ? this.snd.compare(that.snd) : option;
+    }
+    max(that) {
+        return this.isNotLess(that) ? this : that;
+    }
+    min(that) {
+        return this.isNotMore(that) ? this : that;
+    }
+    clamp(lower, upper) {
+        return this.max(lower).min(upper);
+    }
+    values() {
+        return [this.fst, this.snd];
+    }
+    *effectMap(morphism) {
+        const value = yield this;
+        return morphism(value);
+    }
+    *effect() {
+        const value = yield this;
+        return value;
+    }
+    static fromGenerator(value, getGenerator) {
+        const generator = getGenerator();
+        let result = generator.next();
+        let snd = value;
+        while (!result.done) {
+            const pair = result.value;
+            snd = snd.append(pair.snd);
+            result = generator.next(pair.fst);
+        }
+        return new Pair(result.value, snd);
+    }
+}

package/lib/result.d.ts

@@ -0,0 +1,125 @@
+import type { Option } from "./option.js";
+import type { PartialOrder, Setoid, TotalOrder } from "./order.js";
+import type { Ordering } from "./ordering.js";
+import { Pair } from "./pair.js";
+import { Task } from "./task.js";
+export type Result<A, E> = Okay<A> | Fail<E>;
+declare abstract class ResultTrait {
+    abstract readonly isOkay: boolean;
+    abstract readonly isFail: boolean;
+    toString<A, E>(this: Result<A, E>): string;
+    fold<A, E, T>(this: Result<A, E>, okayMorphism: (value: A) => T, failMorphism: (value: E) => T): T;
+    map<A, B, E, F>(this: Result<A, E>, okayMorphism: (value: A) => B, failMorphism: (value: E) => F): Result<B, F>;
+    mapOkay<A, B, E>(this: Result<A, E>, morphism: (value: A) => B): Result<B, E>;
+    mapFail<A, E, F>(this: Result<A, E>, morphism: (value: E) => F): Result<A, F>;
+    replace<A, B, E, F>(this: Result<A, E>, okayValue: B, failValue: F): Result<B, F>;
+    replaceOkay<A, B, E>(this: Result<A, E>, value: B): Result<B, E>;
+    replaceFail<A, E, F>(this: Result<A, E>, value: F): Result<A, F>;
+    and<A, B, E>(this: Result<A, E>, that: Result<B, E>): Result<Pair<A, B>, E>;
+    andThen<A, B, E>(this: Result<A, E>, that: Result<B, E>): Result<B, E>;
+    andWhen<A, B, E>(this: Result<A, E>, that: Result<B, E>): Result<A, E>;
+    or<A, E, F>(this: Result<A, E>, that: Result<A, F>): Result<A, Pair<E, F>>;
+    orElse<A, E, F>(this: Result<A, E>, that: Result<A, F>): Result<A, F>;
+    orErst<A, E, F>(this: Result<A, E>, that: Result<A, F>): Result<A, E>;
+    flatMap<A, B, E, F>(this: Result<A, E>, okayArrow: (value: A) => Result<B, F>, failArrow: (value: E) => Result<B, F>): Result<B, F>;
+    flatMapOkay<A, B, E>(this: Result<A, E>, arrow: (value: A) => Result<B, E>): Result<B, E>;
+    flatMapFail<A, E, F>(this: Result<A, E>, arrow: (value: E) => Result<A, F>): Result<A, F>;
+    flattenOkay<A, E>(this: Result<Result<A, E>, E>): Result<A, E>;
+    flattenFail<A, E>(this: Result<A, Result<A, E>>): Result<A, E>;
+    flatMapUntil<A, B, E, F>(this: Result<A, E>, okayArrow: (value: A) => Result<Result<B, A>, Result<F, E>>, failArrow: (value: E) => Result<Result<B, A>, Result<F, E>>): Result<B, F>;
+    flatMapOkayUntil<A, B, E>(this: Result<A, E>, arrow: (value: A) => Result<Result<B, A>, E>): Result<B, E>;
+    flatMapFailUntil<A, E, F>(this: Result<A, E>, arrow: (value: E) => Result<A, Result<F, E>>): Result<A, F>;
+    commute<A>(this: Okay<A>): Fail<A>;
+    commute<A>(this: Fail<A>): Okay<A>;
+    commute<A, B>(this: Result<A, B>): Result<B, A>;
+    isOkayAnd<A, B extends A, E>(this: Result<A, E>, predicate: (value: A) => value is B): this is Okay<B>;
+    isOkayAnd<A, E>(this: Result<A, E>, predicate: (value: A) => boolean): this is Okay<A>;
+    isFailAnd<A, E, F extends E>(this: Result<A, E>, predicate: (value: E) => value is F): this is Fail<F>;
+    isFailAnd<A, E>(this: Result<A, E>, predicate: (value: E) => boolean): this is Fail<E>;
+    isOkayOr<A, E, F extends E>(this: Result<A, E>, predicate: (value: E) => value is F): this is Result<A, F>;
+    isOkayOr<A, E>(this: Result<A, E>, predicate: (value: E) => boolean): boolean;
+    isFailOr<A, B extends A, E>(this: Result<A, E>, predicate: (value: A) => value is B): this is Result<B, E>;
+    isFailOr<A, E>(this: Result<A, E>, predicate: (value: A) => boolean): boolean;
+    transposeMap<A, B, E, F>(this: Result<A, E>, transposeOkay: (value: A) => Option<B>, transposeFail: (value: E) => Option<F>): Option<Result<B, F>>;
+    transposeMapOkay<A, B, E>(this: Result<A, E>, transpose: (value: A) => Option<B>): Option<Result<B, E>>;
+    transposeMapFail<A, E, F>(this: Result<A, E>, transpose: (value: E) => Option<F>): Option<Result<A, F>>;
+    transpose<A, E>(this: Result<Option<A>, Option<E>>): Option<Result<A, E>>;
+    transposeOkay<A, E>(this: Result<Option<A>, E>): Option<Result<A, E>>;
+    transposeFail<A, E>(this: Result<A, Option<E>>): Option<Result<A, E>>;
+    unzipWith<X, Y, A, B, E, F>(this: Result<X, Y>, unzipOkay: (value: X) => Pair<A, B>, unzipFail: (value: Y) => Pair<E, F>): Pair<Result<A, E>, Result<B, F>>;
+    unzipWithOkay<X, A, B, E>(this: Result<X, E>, unzip: (value: X) => Pair<A, B>): Pair<Result<A, E>, Result<B, E>>;
+    unzipWithFail<Y, A, E, F>(this: Result<A, Y>, unzip: (value: Y) => Pair<E, F>): Pair<Result<A, E>, Result<A, F>>;
+    unzip<A, B, E, F>(this: Result<Pair<A, B>, Pair<E, F>>): Pair<Result<A, E>, Result<B, F>>;
+    unzipOkay<A, B, E>(this: Result<Pair<A, B>, E>): Pair<Result<A, E>, Result<B, E>>;
+    unzipFail<A, E, F>(this: Result<A, Pair<E, F>>): Pair<Result<A, E>, Result<A, F>>;
+    collectMapFst<X, Y, A, B, C>(this: Result<X, Y>, okayMorphism: (value: X) => Pair<A, C>, failMorphism: (value: Y) => Pair<B, C>): Pair<Result<A, B>, C>;
+    collectFst<A, B, C>(this: Result<Pair<A, C>, Pair<B, C>>): Pair<Result<A, B>, C>;
+    collectMapSnd<X, Y, A, B, C>(this: Result<X, Y>, okayMorphism: (value: X) => Pair<A, B>, failMorphism: (value: Y) => Pair<A, C>): Pair<A, Result<B, C>>;
+    collectSnd<A, B, C>(this: Result<Pair<A, B>, Pair<A, C>>): Pair<A, Result<B, C>>;
+    collectMapOkay<X, Y, A, B, E>(this: Result<X, Y>, okayMorphism: (value: X) => Result<A, E>, failMorphism: (value: Y) => Result<B, E>): Result<Result<A, B>, E>;
+    exchangeMapFail<X, A, E, F>(this: Result<X, F>, exchange: (value: X) => Result<A, E>): Result<Result<A, F>, E>;
+    associateMapLeft<Y, A, B, C>(this: Result<A, Y>, morphism: (value: Y) => Result<B, C>): Result<Result<A, B>, C>;
+    collectOkay<A, B, E>(this: Result<Result<A, E>, Result<B, E>>): Result<Result<A, B>, E>;
+    exchangeFail<A, E, F>(this: Result<Result<A, E>, F>): Result<Result<A, F>, E>;
+    associateLeft<A, B, C>(this: Result<A, Result<B, C>>): Result<Result<A, B>, C>;
+    collectMapFail<X, Y, A, E, F>(this: Result<X, Y>, okayMorphism: (value: X) => Result<A, E>, failMorphism: (value: Y) => Result<A, F>): Result<A, Result<E, F>>;
+    exchangeMapOkay<Y, A, B, E>(this: Result<A, Y>, exchange: (value: Y) => Result<B, E>): Result<B, Result<A, E>>;
+    associateMapRight<X, A, B, C>(this: Result<X, C>, morphism: (value: X) => Result<A, B>): Result<A, Result<B, C>>;
+    collectFail<A, E, F>(this: Result<Result<A, E>, Result<A, F>>): Result<A, Result<E, F>>;
+    exchangeOkay<A, B, E>(this: Result<A, Result<B, E>>): Result<B, Result<A, E>>;
+    associateRight<A, B, C>(this: Result<Result<A, B>, C>): Result<A, Result<B, C>>;
+    distributeMap<X, Y, A, B, E, F>(this: Result<X, Y>, okayMorphism: (value: X) => Result<A, B>, failMorphism: (value: Y) => Result<E, F>): Result<Result<A, E>, Result<B, F>>;
+    distribute<A, B, E, F>(this: Result<Result<A, B>, Result<E, F>>): Result<Result<A, E>, Result<B, F>>;
+    gatherMapOkay<X, Y, A, B, E>(this: Result<X, Y>, okayMorphism: (value: X) => Task<A, E>, failMorphism: (value: Y) => Task<B, E>): Task<Result<A, B>, E>;
+    swapMapFail<X, A, E, F>(this: Result<X, F>, morphism: (value: X) => Task<A, E>): Task<Result<A, F>, E>;
+    groupMapLeft<Y, A, B, C>(this: Result<A, Y>, morphism: (value: Y) => Task<B, C>): Task<Result<A, B>, C>;
+    gatherOkay<A, B, E>(this: Result<Task<A, E>, Task<B, E>>): Task<Result<A, B>, E>;
+    swapFail<A, E, F>(this: Result<Task<A, E>, F>): Task<Result<A, F>, E>;
+    groupLeft<A, B, C>(this: Result<A, Task<B, C>>): Task<Result<A, B>, C>;
+    gatherMapFail<X, Y, A, E, F>(this: Result<X, Y>, okayMorphism: (value: X) => Task<A, E>, failMorphism: (value: Y) => Task<A, F>): Task<A, Result<E, F>>;
+    swapMapOkay<Y, A, B, E>(this: Result<A, Y>, morphism: (value: Y) => Task<B, E>): Task<B, Result<A, E>>;
+    groupMapRight<X, A, B, C>(this: Result<X, C>, morphism: (value: X) => Task<A, B>): Task<A, Result<B, C>>;
+    gatherFail<A, E, F>(this: Result<Task<A, E>, Task<A, F>>): Task<A, Result<E, F>>;
+    swapOkay<A, B, E>(this: Result<A, Task<B, E>>): Task<B, Result<A, E>>;
+    groupRight<A, B, C>(this: Result<Task<A, B>, C>): Task<A, Result<B, C>>;
+    interchangeMap<X, Y, A, B, E, F>(this: Result<X, Y>, okayMorphism: (value: X) => Task<A, B>, failMorphism: (value: Y) => Task<E, F>): Task<Result<A, E>, Result<B, F>>;
+    interchange<A, B, E, F>(this: Result<Task<A, B>, Task<E, F>>): Task<Result<A, E>, Result<B, F>>;
+    extractOkay<A, E>(this: Result<A, E>, defaultValue: A): A;
+    extractFail<A, E>(this: Result<A, E>, defaultValue: E): E;
+    extractMapOkay<A, E>(this: Result<A, E>, getOkayValue: (value: E) => A): A;
+    extractMapFail<A, E>(this: Result<A, E>, getFailValue: (value: A) => E): E;
+    toOptionOkay<A, E>(this: Result<A, E>): Option<A>;
+    toOptionFail<A, E>(this: Result<A, E>): Option<E>;
+    toTask<A, E>(this: Result<A, E>): Task<A, E>;
+    isSame<A extends Setoid<A>, E extends Setoid<E>>(this: Result<A, E>, that: Result<A, E>): boolean;
+    isNotSame<A extends Setoid<A>, E extends Setoid<E>>(this: Result<A, E>, that: Result<A, E>): boolean;
+    isLess<A extends PartialOrder<A>, E extends PartialOrder<E>>(this: Result<A, E>, that: Result<A, E>): boolean;
+    isNotLess<A extends PartialOrder<A>, E extends PartialOrder<E>>(this: Result<A, E>, that: Result<A, E>): boolean;
+    isMore<A extends PartialOrder<A>, E extends PartialOrder<E>>(this: Result<A, E>, that: Result<A, E>): boolean;
+    isNotMore<A extends PartialOrder<A>, E extends PartialOrder<E>>(this: Result<A, E>, that: Result<A, E>): boolean;
+    compare<A extends PartialOrder<A>, E extends PartialOrder<E>>(this: Result<A, E>, that: Result<A, E>): Option<Ordering>;
+    max<A extends TotalOrder<A>, E extends TotalOrder<E>>(this: Result<A, E>, that: Result<A, E>): Result<A, E>;
+    min<A extends TotalOrder<A>, E extends TotalOrder<E>>(this: Result<A, E>, that: Result<A, E>): Result<A, E>;
+    clamp<A extends TotalOrder<A>, E extends TotalOrder<E>>(this: Result<A, E>, lower: Result<A, E>, upper: Result<A, E>): Result<A, E>;
+    okayValues<A, E>(this: Result<A, E>): Generator<A, void, undefined>;
+    failValues<A, E>(this: Result<A, E>): Generator<E, void, undefined>;
+    values<A, E>(this: Result<A, E>): Generator<A | E, void, undefined>;
+    effectMap<A, B, E>(this: Result<A, E>, morphism: (value: A) => B): Generator<Result<A, E>, B, A>;
+    effect<A, E>(this: Result<A, E>): Generator<Result<A, E>, A, A>;
+}
+export declare class Okay<out A> extends ResultTrait {
+    readonly value: A;
+    readonly isOkay = true;
+    readonly isFail = false;
+    constructor(value: A);
+    static of<A>(value: A): Okay<A>;
+    static fromGenerator<A>(getGenerator: () => Generator<Result<unknown, unknown>, A, unknown>): Result<A, unknown>;
+}
+export declare class Fail<out E> extends ResultTrait {
+    readonly value: E;
+    readonly isOkay = false;
+    readonly isFail = true;
+    constructor(value: E);
+    static of<E>(value: E): Fail<E>;
+}
+export {};