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

package/lib/task.js

@@ -0,0 +1,282 @@
+import { None, Some } from "./option.js";
+import { Pair } from "./pair.js";
+import { Fail, Okay } from "./result.js";
+export class Task {
+    execute;
+    constructor(execute) {
+        this.execute = execute;
+    }
+    static okay(value) {
+        return new Task((signal, callback) => {
+            if (!signal.aborted)
+                callback(new Okay(value));
+        });
+    }
+    static fail(value) {
+        return new Task((signal, callback) => {
+            if (!signal.aborted)
+                callback(new Fail(value));
+        });
+    }
+    static of(task) {
+        return new Task((signal, callback) => {
+            const abort = task((result) => {
+                if (!signal.aborted) {
+                    signal.removeEventListener("abort", onAbort);
+                    callback(result);
+                }
+            });
+            signal.addEventListener("abort", onAbort);
+            function onAbort() {
+                signal.removeEventListener("abort", onAbort);
+                abort(signal.reason);
+            }
+        });
+    }
+    // TODO: <A, B>(getGenerator: () => Generator<Task<A, unknown>, B, A>) => Task<B, unknown>
+    static fromGenerator(getGenerator) {
+        return new Task((signal, callback) => {
+            const generator = getGenerator();
+            const trampoline = (task) => {
+                let option = new Some(task);
+                while (option.isSome) {
+                    const task = option.value;
+                    option = None.instance;
+                    let isAsync = false;
+                    task.execute(signal, (result) => {
+                        let iteratorResult;
+                        try {
+                            iteratorResult = result.isOkay
+                                ? generator.next(result.value)
+                                : generator.throw(result.value);
+                        }
+                        catch (error) {
+                            return callback(new Fail(error));
+                        }
+                        if (iteratorResult.done)
+                            callback(new Okay(iteratorResult.value));
+                        else if (isAsync)
+                            trampoline(iteratorResult.value);
+                        else
+                            option = new Some(iteratorResult.value);
+                    });
+                    isAsync = true;
+                }
+            };
+            let iteratorResult;
+            try {
+                iteratorResult = generator.next();
+            }
+            catch (error) {
+                return callback(new Fail(error));
+            }
+            if (iteratorResult.done)
+                callback(new Okay(iteratorResult.value));
+            else
+                trampoline(iteratorResult.value);
+        });
+    }
+    run(callback) {
+        const controller = new AbortController();
+        this.execute(controller.signal, callback);
+        return controller;
+    }
+    map(okayMorphism, failMorphism) {
+        return new Task((signal, callback) => this.execute(signal, (result) => callback(result.map(okayMorphism, failMorphism))));
+    }
+    mapOkay(morphism) {
+        return new Task((signal, callback) => this.execute(signal, (result) => callback(result.mapOkay(morphism))));
+    }
+    mapFail(morphism) {
+        return new Task((signal, callback) => this.execute(signal, (result) => callback(result.mapFail(morphism))));
+    }
+    replace(okayValue, failValue) {
+        return new Task((signal, callback) => this.execute(signal, (result) => callback(result.replace(okayValue, failValue))));
+    }
+    replaceOkay(value) {
+        return new Task((signal, callback) => this.execute(signal, (result) => callback(result.replaceOkay(value))));
+    }
+    replaceFail(value) {
+        return new Task((signal, callback) => this.execute(signal, (result) => callback(result.replaceFail(value))));
+    }
+    and(that) {
+        return Task.of((callback) => {
+            const controller = new AbortController();
+            let fst = None.instance;
+            let snd = None.instance;
+            this.execute(controller.signal, (result) => {
+                if (result.isFail) {
+                    if (snd.isNone)
+                        controller.abort();
+                    callback(result);
+                }
+                else if (snd.isNone)
+                    fst = new Some(result.value);
+                else
+                    callback(new Okay(new Pair(result.value, snd.value)));
+            });
+            that.execute(controller.signal, (result) => {
+                if (result.isFail) {
+                    if (fst.isNone)
+                        controller.abort();
+                    callback(result);
+                }
+                else if (fst.isNone)
+                    snd = new Some(result.value);
+                else
+                    callback(new Okay(new Pair(fst.value, result.value)));
+            });
+            return (reason) => controller.abort(reason);
+        });
+    }
+    andThen(that) {
+        return this.and(that).mapOkay((pair) => pair.snd);
+    }
+    andWhen(that) {
+        return this.and(that).mapOkay((pair) => pair.fst);
+    }
+    or(that) {
+        return Task.of((callback) => {
+            const controller = new AbortController();
+            let fst = None.instance;
+            let snd = None.instance;
+            this.execute(controller.signal, (result) => {
+                if (result.isOkay) {
+                    if (snd.isNone)
+                        controller.abort();
+                    callback(result);
+                }
+                else if (snd.isNone)
+                    fst = new Some(result.value);
+                else
+                    callback(new Fail(new Pair(result.value, snd.value)));
+            });
+            that.execute(controller.signal, (result) => {
+                if (result.isOkay) {
+                    if (fst.isNone)
+                        controller.abort();
+                    callback(result);
+                }
+                else if (fst.isNone)
+                    snd = new Some(result.value);
+                else
+                    callback(new Fail(new Pair(fst.value, result.value)));
+            });
+            return (reason) => controller.abort(reason);
+        });
+    }
+    orElse(that) {
+        return this.or(that).mapFail((pair) => pair.snd);
+    }
+    orErst(that) {
+        return this.or(that).mapFail((pair) => pair.fst);
+    }
+    flatMap(okayArrow, failArrow) {
+        return new Task((signal, callback) => this.execute(signal, (result) => result.isOkay
+            ? okayArrow(result.value).execute(signal, callback)
+            : failArrow(result.value).execute(signal, callback)));
+    }
+    flatMapOkay(arrow) {
+        return new Task((signal, callback) => this.execute(signal, (result) => result.isOkay
+            ? arrow(result.value).execute(signal, callback)
+            : callback(result)));
+    }
+    flatMapFail(arrow) {
+        return new Task((signal, callback) => this.execute(signal, (result) => result.isFail
+            ? arrow(result.value).execute(signal, callback)
+            : callback(result)));
+    }
+    flatten() {
+        return new Task((signal, callback) => this.execute(signal, (result) => result.value.execute(signal, callback)));
+    }
+    flattenOkay() {
+        return new Task((signal, callback) => this.execute(signal, (result) => result.isOkay
+            ? result.value.execute(signal, callback)
+            : callback(result)));
+    }
+    flattenFail() {
+        return new Task((signal, callback) => this.execute(signal, (result) => result.isFail
+            ? result.value.execute(signal, callback)
+            : callback(result)));
+    }
+    flatMapUntil(okayArrow, failArrow) {
+        return new Task((signal, callback) => {
+            const trampoline = (task) => {
+                let option = new Some(task);
+                while (option.isSome) {
+                    const task = option.value;
+                    option = None.instance;
+                    let isAsync = false;
+                    task.flatMap(okayArrow, failArrow).execute(signal, (value) => {
+                        const result = value.distribute();
+                        if (result.isOkay)
+                            callback(result.value);
+                        else if (isAsync)
+                            trampoline(result.value.toTask());
+                        else
+                            option = new Some(result.value.toTask());
+                    });
+                    isAsync = true;
+                }
+            };
+            trampoline(this);
+        });
+    }
+    flatMapOkayUntil(arrow) {
+        return new Task((signal, callback) => {
+            const trampoline = (task) => {
+                let option = new Some(task);
+                while (option.isSome) {
+                    const task = option.value;
+                    option = None.instance;
+                    let isAsync = false;
+                    task.flatMapOkay(arrow).execute(signal, (value) => {
+                        const result = value.exchangeFail();
+                        if (result.isOkay)
+                            callback(result.value);
+                        else if (isAsync)
+                            trampoline(Task.okay(result.value));
+                        else
+                            option = new Some(Task.okay(result.value));
+                    });
+                    isAsync = true;
+                }
+            };
+            trampoline(this);
+        });
+    }
+    flatMapFailUntil(arrow) {
+        return new Task((signal, callback) => {
+            const trampoline = (task) => {
+                let option = new Some(task);
+                while (option.isSome) {
+                    const task = option.value;
+                    option = None.instance;
+                    let isAsync = false;
+                    task.flatMapFail(arrow).execute(signal, (value) => {
+                        const result = value.associateLeft();
+                        if (result.isOkay)
+                            callback(result.value);
+                        else if (isAsync)
+                            trampoline(Task.fail(result.value));
+                        else
+                            option = new Some(Task.fail(result.value));
+                    });
+                    isAsync = true;
+                }
+            };
+            trampoline(this);
+        });
+    }
+    commute() {
+        return new Task((signal, callback) => this.execute(signal, (result) => callback(result.commute())));
+    }
+    *effectMap(morphism) {
+        const value = yield this;
+        return morphism(value);
+    }
+    *effect() {
+        const value = yield this;
+        return value;
+    }
+}

package/lib/text.d.ts

@@ -0,0 +1,21 @@
+import type { Option } from "./option.js";
+import type { TotalOrder } from "./order.js";
+import type { Ordering } from "./ordering.js";
+import type { Semigroup } from "./semigroup.js";
+export declare class Text implements Semigroup<Text>, TotalOrder<Text> {
+    readonly value: string;
+    constructor(value: string);
+    static of(value: string): Text;
+    toString(this: Text): string;
+    append(this: Text, that: Text): Text;
+    isSame(this: Text, that: Text): boolean;
+    isNotSame(this: Text, that: Text): boolean;
+    isLess(this: Text, that: Text): boolean;
+    isNotLess(this: Text, that: Text): boolean;
+    isMore(this: Text, that: Text): boolean;
+    isNotMore(this: Text, that: Text): boolean;
+    compare(this: Text, that: Text): Option<Ordering>;
+    max(this: Text, that: Text): Text;
+    min(this: Text, that: Text): Text;
+    clamp(this: Text, lower: Text, upper: Text): Text;
+}

package/lib/text.js

@@ -0,0 +1,50 @@
+import { Some } from "./option.js";
+export class Text {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    static of(value) {
+        return new Text(value);
+    }
+    toString() {
+        return `Text(${JSON.stringify(this.value)})`;
+    }
+    append(that) {
+        return new Text(`${this.value}${that.value}`);
+    }
+    isSame(that) {
+        return this.value === that.value;
+    }
+    isNotSame(that) {
+        return this.value !== that.value;
+    }
+    isLess(that) {
+        return this.value < that.value;
+    }
+    isNotLess(that) {
+        return this.value >= that.value;
+    }
+    isMore(that) {
+        return this.value > that.value;
+    }
+    isNotMore(that) {
+        return this.value <= that.value;
+    }
+    compare(that) {
+        if (this.value < that.value)
+            return new Some("<");
+        if (this.value > that.value)
+            return new Some(">");
+        return new Some("=");
+    }
+    max(that) {
+        return this.value >= that.value ? this : that;
+    }
+    min(that) {
+        return this.value <= that.value ? this : that;
+    }
+    clamp(lower, upper) {
+        return this.max(lower).min(upper);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aang",
-  "version": "2.0.0-alpha.3",
+  "version": "2.0.0-alpha.30",
   "description": "A powerful functional programming library for TypeScript.",
   "keywords": [
     "aang",

package/lib/errors.d.ts

@@ -1,4 +0,0 @@
-import { Exception } from "./exceptions.js";
-export declare class UnsafeExtractError extends Exception {
-    constructor(message: string);
-}

package/lib/errors.js

@@ -1,7 +0,0 @@
-import { Exception } from "./exceptions.js";
-export class UnsafeExtractError extends Exception {
-    constructor(message) {
-        super(message);
-        this.setName("UnsafeExtractError");
-    }
-}