aang 2.0.0-alpha.3 → 2.0.0-alpha.30

package/lib/result.js

@@ -0,0 +1,439 @@
+import { None, Some } from "./option.js";
+import { Pair } from "./pair.js";
+import { Task } from "./task.js";
+class ResultTrait {
+    toString() {
+        return this.isOkay
+            ? `Okay(${String(this.value)})`
+            : `Fail(${String(this.value)})`;
+    }
+    fold(okayMorphism, failMorphism) {
+        return this.isOkay ? okayMorphism(this.value) : failMorphism(this.value);
+    }
+    map(okayMorphism, failMorphism) {
+        return this.isOkay
+            ? new Okay(okayMorphism(this.value))
+            : new Fail(failMorphism(this.value));
+    }
+    mapOkay(morphism) {
+        return this.isOkay ? new Okay(morphism(this.value)) : this;
+    }
+    mapFail(morphism) {
+        return this.isFail ? new Fail(morphism(this.value)) : this;
+    }
+    replace(okayValue, failValue) {
+        return this.isOkay ? new Okay(okayValue) : new Fail(failValue);
+    }
+    replaceOkay(value) {
+        return this.isOkay ? new Okay(value) : this;
+    }
+    replaceFail(value) {
+        return this.isFail ? new Fail(value) : this;
+    }
+    and(that) {
+        if (this.isFail)
+            return this;
+        if (that.isFail)
+            return that;
+        return new Okay(new Pair(this.value, that.value));
+    }
+    andThen(that) {
+        return this.isOkay ? that : this;
+    }
+    andWhen(that) {
+        return this.isOkay && that.isFail ? that : this;
+    }
+    or(that) {
+        if (this.isOkay)
+            return this;
+        if (that.isOkay)
+            return that;
+        return new Fail(new Pair(this.value, that.value));
+    }
+    orElse(that) {
+        return this.isOkay ? this : that;
+    }
+    orErst(that) {
+        return this.isOkay || that.isFail ? this : that;
+    }
+    flatMap(okayArrow, failArrow) {
+        return this.isOkay ? okayArrow(this.value) : failArrow(this.value);
+    }
+    flatMapOkay(arrow) {
+        return this.isOkay ? arrow(this.value) : this;
+    }
+    flatMapFail(arrow) {
+        return this.isFail ? arrow(this.value) : this;
+    }
+    flattenOkay() {
+        return this.isOkay ? this.value : this;
+    }
+    flattenFail() {
+        return this.isFail ? this.value : this;
+    }
+    flatMapUntil(okayArrow, failArrow) {
+        let result = this.flatMap(okayArrow, failArrow).distribute();
+        while (result.isFail)
+            result = result.value.flatMap(okayArrow, failArrow).distribute();
+        return result.value;
+    }
+    flatMapOkayUntil(arrow) {
+        let result = this.flatMapOkay(arrow).exchangeFail();
+        while (result.isFail)
+            result = arrow(result.value).exchangeFail();
+        return result.value;
+    }
+    flatMapFailUntil(arrow) {
+        let result = this.flatMapFail(arrow).associateLeft();
+        while (result.isFail)
+            result = arrow(result.value).associateLeft();
+        return result.value;
+    }
+    commute() {
+        return this.isOkay ? new Fail(this.value) : new Okay(this.value);
+    }
+    isOkayAnd(predicate) {
+        return this.isOkay && predicate(this.value);
+    }
+    isFailAnd(predicate) {
+        return this.isFail && predicate(this.value);
+    }
+    isOkayOr(predicate) {
+        return this.isOkay || predicate(this.value);
+    }
+    isFailOr(predicate) {
+        return this.isFail || predicate(this.value);
+    }
+    transposeMap(transposeOkay, transposeFail) {
+        return this.isOkay
+            ? transposeOkay(this.value).map(Okay.of)
+            : transposeFail(this.value).map(Fail.of);
+    }
+    transposeMapOkay(transpose) {
+        return this.isFail ? new Some(this) : transpose(this.value).map(Okay.of);
+    }
+    transposeMapFail(transpose) {
+        return this.isOkay ? new Some(this) : transpose(this.value).map(Fail.of);
+    }
+    transpose() {
+        return this.isOkay ? this.value.map(Okay.of) : this.value.map(Fail.of);
+    }
+    transposeOkay() {
+        return this.isFail ? new Some(this) : this.value.map(Okay.of);
+    }
+    transposeFail() {
+        return this.isOkay ? new Some(this) : this.value.map(Fail.of);
+    }
+    unzipWith(unzipOkay, unzipFail) {
+        return this.isOkay
+            ? unzipOkay(this.value).map(Okay.of, Okay.of)
+            : unzipFail(this.value).map(Fail.of, Fail.of);
+    }
+    unzipWithOkay(unzip) {
+        return this.isFail
+            ? Pair.from(this)
+            : unzip(this.value).map(Okay.of, Okay.of);
+    }
+    unzipWithFail(unzip) {
+        return this.isOkay
+            ? Pair.from(this)
+            : unzip(this.value).map(Fail.of, Fail.of);
+    }
+    unzip() {
+        return this.isOkay
+            ? this.value.map(Okay.of, Okay.of)
+            : this.value.map(Fail.of, Fail.of);
+    }
+    unzipOkay() {
+        return this.isFail ? Pair.from(this) : this.value.map(Okay.of, Okay.of);
+    }
+    unzipFail() {
+        return this.isOkay ? Pair.from(this) : this.value.map(Fail.of, Fail.of);
+    }
+    collectMapFst(okayMorphism, failMorphism) {
+        return this.isOkay
+            ? okayMorphism(this.value).mapFst(Okay.of)
+            : failMorphism(this.value).mapFst(Fail.of);
+    }
+    collectFst() {
+        return this.isOkay
+            ? this.value.mapFst(Okay.of)
+            : this.value.mapFst(Fail.of);
+    }
+    collectMapSnd(okayMorphism, failMorphism) {
+        return this.isOkay
+            ? okayMorphism(this.value).mapSnd(Okay.of)
+            : failMorphism(this.value).mapSnd(Fail.of);
+    }
+    collectSnd() {
+        return this.isOkay
+            ? this.value.mapSnd(Okay.of)
+            : this.value.mapSnd(Fail.of);
+    }
+    collectMapOkay(okayMorphism, failMorphism) {
+        return this.isOkay
+            ? okayMorphism(this.value).mapOkay(Okay.of)
+            : failMorphism(this.value).mapOkay(Fail.of);
+    }
+    exchangeMapFail(exchange) {
+        return this.isFail ? new Okay(this) : exchange(this.value).mapOkay(Okay.of);
+    }
+    associateMapLeft(morphism) {
+        return this.isOkay ? new Okay(this) : morphism(this.value).mapOkay(Fail.of);
+    }
+    collectOkay() {
+        return this.isOkay
+            ? this.value.mapOkay(Okay.of)
+            : this.value.mapOkay(Fail.of);
+    }
+    exchangeFail() {
+        return this.isFail ? new Okay(this) : this.value.mapOkay(Okay.of);
+    }
+    associateLeft() {
+        return this.isOkay ? new Okay(this) : this.value.mapOkay(Fail.of);
+    }
+    collectMapFail(okayMorphism, failMorphism) {
+        return this.isOkay
+            ? okayMorphism(this.value).mapFail(Okay.of)
+            : failMorphism(this.value).mapFail(Fail.of);
+    }
+    exchangeMapOkay(exchange) {
+        return this.isOkay ? new Fail(this) : exchange(this.value).mapFail(Fail.of);
+    }
+    associateMapRight(morphism) {
+        return this.isFail ? new Fail(this) : morphism(this.value).mapFail(Okay.of);
+    }
+    collectFail() {
+        return this.isOkay
+            ? this.value.mapFail(Okay.of)
+            : this.value.mapFail(Fail.of);
+    }
+    exchangeOkay() {
+        return this.isOkay ? new Fail(this) : this.value.mapFail(Fail.of);
+    }
+    associateRight() {
+        return this.isFail ? new Fail(this) : this.value.mapFail(Okay.of);
+    }
+    distributeMap(okayMorphism, failMorphism) {
+        return this.isOkay
+            ? okayMorphism(this.value).map(Okay.of, Okay.of)
+            : failMorphism(this.value).map(Fail.of, Fail.of);
+    }
+    distribute() {
+        return this.isOkay
+            ? this.value.map(Okay.of, Okay.of)
+            : this.value.map(Fail.of, Fail.of);
+    }
+    gatherMapOkay(okayMorphism, failMorphism) {
+        return this.isOkay
+            ? okayMorphism(this.value).mapOkay(Okay.of)
+            : failMorphism(this.value).mapOkay(Fail.of);
+    }
+    swapMapFail(morphism) {
+        return this.isFail
+            ? Task.okay(this)
+            : morphism(this.value).mapOkay(Okay.of);
+    }
+    groupMapLeft(morphism) {
+        return this.isOkay
+            ? Task.okay(this)
+            : morphism(this.value).mapOkay(Fail.of);
+    }
+    gatherOkay() {
+        return this.isOkay
+            ? this.value.mapOkay(Okay.of)
+            : this.value.mapOkay(Fail.of);
+    }
+    swapFail() {
+        return this.isFail ? Task.okay(this) : this.value.mapOkay(Okay.of);
+    }
+    groupLeft() {
+        return this.isOkay ? Task.okay(this) : this.value.mapOkay(Fail.of);
+    }
+    gatherMapFail(okayMorphism, failMorphism) {
+        return this.isOkay
+            ? okayMorphism(this.value).mapFail(Okay.of)
+            : failMorphism(this.value).mapFail(Fail.of);
+    }
+    swapMapOkay(morphism) {
+        return this.isOkay
+            ? Task.fail(this)
+            : morphism(this.value).mapFail(Fail.of);
+    }
+    groupMapRight(morphism) {
+        return this.isFail
+            ? Task.fail(this)
+            : morphism(this.value).mapFail(Okay.of);
+    }
+    gatherFail() {
+        return this.isOkay
+            ? this.value.mapFail(Okay.of)
+            : this.value.mapFail(Fail.of);
+    }
+    swapOkay() {
+        return this.isOkay ? Task.fail(this) : this.value.mapFail(Fail.of);
+    }
+    groupRight() {
+        return this.isFail ? Task.fail(this) : this.value.mapFail(Okay.of);
+    }
+    interchangeMap(okayMorphism, failMorphism) {
+        return this.isOkay
+            ? okayMorphism(this.value).map(Okay.of, Okay.of)
+            : failMorphism(this.value).map(Fail.of, Fail.of);
+    }
+    interchange() {
+        return this.isOkay
+            ? this.value.map(Okay.of, Okay.of)
+            : this.value.map(Fail.of, Fail.of);
+    }
+    extractOkay(defaultValue) {
+        return this.isOkay ? this.value : defaultValue;
+    }
+    extractFail(defaultValue) {
+        return this.isFail ? this.value : defaultValue;
+    }
+    extractMapOkay(getOkayValue) {
+        return this.isOkay ? this.value : getOkayValue(this.value);
+    }
+    extractMapFail(getFailValue) {
+        return this.isFail ? this.value : getFailValue(this.value);
+    }
+    toOptionOkay() {
+        return this.isOkay ? new Some(this.value) : None.instance;
+    }
+    toOptionFail() {
+        return this.isFail ? new Some(this.value) : None.instance;
+    }
+    toTask() {
+        return new Task((signal, callback) => {
+            if (!signal.aborted)
+                callback(this);
+        });
+    }
+    isSame(that) {
+        return this.isOkay
+            ? that.isOkay && this.value.isSame(that.value)
+            : that.isFail && this.value.isSame(that.value);
+    }
+    isNotSame(that) {
+        return this.isOkay
+            ? that.isFail || this.value.isNotSame(that.value)
+            : that.isOkay || this.value.isNotSame(that.value);
+    }
+    isLess(that) {
+        return this.isOkay
+            ? that.isOkay && this.value.isLess(that.value)
+            : that.isOkay || this.value.isLess(that.value);
+    }
+    isNotLess(that) {
+        return this.isOkay
+            ? that.isFail || this.value.isNotLess(that.value)
+            : that.isFail && this.value.isNotLess(that.value);
+    }
+    isMore(that) {
+        return this.isOkay
+            ? that.isFail || this.value.isMore(that.value)
+            : that.isFail && this.value.isMore(that.value);
+    }
+    isNotMore(that) {
+        return this.isOkay
+            ? that.isOkay && this.value.isNotMore(that.value)
+            : that.isOkay || this.value.isNotMore(that.value);
+    }
+    compare(that) {
+        return this.isFail
+            ? that.isOkay
+                ? new Some("<")
+                : this.value.compare(that.value)
+            : that.isFail
+                ? new Some(">")
+                : this.value.compare(that.value);
+    }
+    max(that) {
+        return this.isOkay
+            ? that.isFail
+                ? this
+                : new Okay(this.value.max(that.value))
+            : that.isOkay
+                ? that
+                : new Fail(this.value.max(that.value));
+    }
+    min(that) {
+        return this.isOkay
+            ? that.isFail
+                ? that
+                : new Okay(this.value.min(that.value))
+            : that.isOkay
+                ? this
+                : new Fail(this.value.min(that.value));
+    }
+    clamp(lower, upper) {
+        return this.max(lower).min(upper);
+    }
+    *okayValues() {
+        if (this.isOkay)
+            yield this.value;
+    }
+    *failValues() {
+        if (this.isFail)
+            yield this.value;
+    }
+    *values() {
+        yield this.value;
+    }
+    *effectMap(morphism) {
+        const value = yield this;
+        return morphism(value);
+    }
+    *effect() {
+        const value = yield this;
+        return value;
+    }
+}
+export class Okay extends ResultTrait {
+    value;
+    isOkay = true;
+    isFail = false;
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    static of(value) {
+        return new Okay(value);
+    }
+    // TODO: <A, B>(getGenerator: () => Generator<Result<A, unknown>, B, A>) => Result<B, unknown>
+    static fromGenerator(getGenerator) {
+        const generator = getGenerator();
+        let iteratorResult;
+        try {
+            iteratorResult = generator.next();
+        }
+        catch (error) {
+            return new Fail(error);
+        }
+        while (!iteratorResult.done) {
+            const result = iteratorResult.value;
+            try {
+                iteratorResult = result.isOkay
+                    ? generator.next(result.value)
+                    : generator.throw(result.value);
+            }
+            catch (error) {
+                return new Fail(error);
+            }
+        }
+        return new Okay(iteratorResult.value);
+    }
+}
+export class Fail extends ResultTrait {
+    value;
+    isOkay = false;
+    isFail = true;
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    static of(value) {
+        return new Fail(value);
+    }
+}

package/lib/semigroup.d.ts

@@ -0,0 +1,3 @@
+export interface Semigroup<in out A> {
+    append: (this: A, that: A) => A;
+}

package/lib/semigroup.js

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

package/lib/task.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="node" resolution-mode="require"/>
+import { Pair } from "./pair.js";
+import type { Result } from "./result.js";
+export declare class Task<out A, out E> {
+    readonly execute: (signal: AbortSignal, callback: (result: Result<A, E>) => void) => void;
+    constructor(execute: (signal: AbortSignal, callback: (result: Result<A, E>) => void) => void);
+    static okay<A>(value: A): Task<A, never>;
+    static fail<E>(value: E): Task<never, E>;
+    static of<A, E>(task: (callback: (result: Result<A, E>) => void) => (reason: unknown) => void): Task<A, E>;
+    static fromGenerator<A>(getGenerator: () => Generator<Task<unknown, unknown>, A, unknown>): Task<A, unknown>;
+    run<A, E>(this: Task<A, E>, callback: (result: Result<A, E>) => void): AbortController;
+    map<A, B, E, F>(this: Task<A, E>, okayMorphism: (value: A) => B, failMorphism: (value: E) => F): Task<B, F>;
+    mapOkay<A, B, E>(this: Task<A, E>, morphism: (value: A) => B): Task<B, E>;
+    mapFail<A, E, F>(this: Task<A, E>, morphism: (value: E) => F): Task<A, F>;
+    replace<A, B, E, F>(this: Task<A, E>, okayValue: B, failValue: F): Task<B, F>;
+    replaceOkay<A, B, E>(this: Task<A, E>, value: B): Task<B, E>;
+    replaceFail<A, E, F>(this: Task<A, E>, value: F): Task<A, F>;
+    and<A, B, E>(this: Task<A, E>, that: Task<B, E>): Task<Pair<A, B>, E>;
+    andThen<A, B, E>(this: Task<A, E>, that: Task<B, E>): Task<B, E>;
+    andWhen<A, B, E>(this: Task<A, E>, that: Task<B, E>): Task<A, E>;
+    or<A, E, F>(this: Task<A, E>, that: Task<A, F>): Task<A, Pair<E, F>>;
+    orElse<A, E, F>(this: Task<A, E>, that: Task<A, F>): Task<A, F>;
+    orErst<A, E, F>(this: Task<A, E>, that: Task<A, F>): Task<A, E>;
+    flatMap<A, B, E, F>(this: Task<A, E>, okayArrow: (value: A) => Task<B, F>, failArrow: (value: E) => Task<B, F>): Task<B, F>;
+    flatMapOkay<A, B, E>(this: Task<A, E>, arrow: (value: A) => Task<B, E>): Task<B, E>;
+    flatMapFail<A, E, F>(this: Task<A, E>, arrow: (value: E) => Task<A, F>): Task<A, F>;
+    flatten<A, E>(this: Task<Task<A, E>, Task<A, E>>): Task<A, E>;
+    flattenOkay<A, E>(this: Task<Task<A, E>, E>): Task<A, E>;
+    flattenFail<A, E>(this: Task<A, Task<A, E>>): Task<A, E>;
+    flatMapUntil<A, B, E, F>(this: Task<A, E>, okayArrow: (value: A) => Task<Result<B, A>, Result<F, E>>, failArrow: (value: E) => Task<Result<B, A>, Result<F, E>>): Task<B, F>;
+    flatMapOkayUntil<A, B, E>(this: Task<A, E>, arrow: (value: A) => Task<Result<B, A>, E>): Task<B, E>;
+    flatMapFailUntil<A, E, F>(this: Task<A, E>, arrow: (value: E) => Task<A, Result<F, E>>): Task<A, F>;
+    commute<A, B>(this: Task<A, B>): Task<B, A>;
+    effectMap<A, B, E>(this: Task<A, E>, morphism: (value: A) => B): Generator<Task<A, E>, B, A>;
+    effect<A, E>(this: Task<A, E>): Generator<Task<A, E>, A, A>;
+}