aang 2.0.0-alpha.26 → 2.0.0-alpha.28

package/lib/exceptions.d.ts

@@ -5,6 +5,3 @@ export declare abstract class Exception extends Error {
     constructor(message?: string, options?: ErrorOptions);
     protected setName(name: string): void;
 }
-export declare class NoneException extends Exception {
-    constructor();
-}

package/lib/exceptions.js

@@ -15,9 +15,3 @@ export class Exception extends Error {
         });
     }
 }
-export class NoneException extends Exception {
-    constructor() {
-        super();
-        this.setName("NoneException");
-    }
-}

package/lib/option.d.ts

@@ -4,7 +4,7 @@ import { Pair } from "./pair.js";
 import type { Result } from "./result.js";
 import type { Semigroup } from "./semigroup.js";
 export type Option<A> = Some<A> | None;
-declare abstract class OptionTrait implements Semigroup<Option<never>>, TotalOrder<Option<never>> {
+declare abstract class OptionTrait {
     abstract readonly isSome: boolean;
     abstract readonly isNone: boolean;
     toString<A>(this: Option<A>): string;
@@ -46,8 +46,6 @@ declare abstract class OptionTrait implements Semigroup<Option<never>>, TotalOrd
     min<A extends TotalOrder<A>>(this: Option<A>, that: Option<A>): Option<A>;
     clamp<A extends TotalOrder<A>>(this: Option<A>, lower: Option<A>, upper: Option<A>): Option<A>;
     values<A>(this: Option<A>): Generator<A, void, undefined>;
-    effectMap<A, B>(this: Option<A>, morphism: (value: A) => B): Generator<Option<A>, B, A>;
-    effect<A>(this: Option<A>): Generator<Option<A>, A, A>;
 }
 export declare class Some<out A> extends OptionTrait {
     readonly value: A;
@@ -57,7 +55,6 @@ export declare class Some<out A> extends OptionTrait {
     static of<A>(value: A): Some<A>;
     static fromValid<A, B extends A>(value: A, validate: (value: A) => value is B): Option<B>;
     static fromValid<A>(value: A, validate: (value: A) => boolean): Option<A>;
-    static fromGenerator<A>(getGenerator: () => Generator<Option<unknown>, A, unknown>): Option<A>;
 }
 export declare class None extends OptionTrait {
     readonly isSome = false;

package/lib/option.js

@@ -1,4 +1,3 @@
-import { NoneException } from "./exceptions.js";
 import { Pair } from "./pair.js";
 import { Fail, Okay } from "./result.js";
 class OptionTrait {
@@ -142,14 +141,6 @@ class OptionTrait {
         if (this.isSome)
             yield this.value;
     }
-    *effectMap(morphism) {
-        const value = yield this;
-        return morphism(value);
-    }
-    *effect() {
-        const value = yield this;
-        return value;
-    }
 }
 export class Some extends OptionTrait {
     value;
@@ -165,33 +156,6 @@ export class Some extends OptionTrait {
     static fromValid(value, validate) {
         return validate(value) ? new Some(value) : None.instance;
     }
-    // TODO: <A, B>(getGenerator: () => Generator<Option<A>, B, A>) => Option<B>
-    static fromGenerator(getGenerator) {
-        const generator = getGenerator();
-        let result;
-        try {
-            result = generator.next();
-        }
-        catch (error) {
-            if (error instanceof NoneException)
-                return None.instance;
-            throw error;
-        }
-        while (!result.done) {
-            const option = result.value;
-            try {
-                result = option.isSome
-                    ? generator.next(option.value)
-                    : generator.throw(new NoneException());
-            }
-            catch (error) {
-                if (error instanceof NoneException)
-                    return None.instance;
-                throw error;
-            }
-        }
-        return new Some(result.value);
-    }
 }
 export class None extends OptionTrait {
     isSome = false;

package/lib/pair.d.ts

@@ -19,8 +19,12 @@ export declare class Pair<out A, out B> {
     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>(this: Pair<A, C>, snd: B): Pair<Pair<A, B>, C>;
-    andSnd<A, B, C>(this: Pair<A, B>, snd: C): Pair<A, Pair<B, C>>;
+    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>;

package/lib/pair.js

@@ -44,11 +44,23 @@ export class Pair {
     and(that) {
         return new Pair(new Pair(this.fst, that.fst), new Pair(this.snd, that.snd));
     }
-    andFst(snd) {
-        return new Pair(new Pair(this.fst, snd), this.snd);
+    andFst(that) {
+        return new Pair(new Pair(this.fst, that.fst), this.snd.append(that.snd));
     }
-    andSnd(snd) {
-        return new Pair(this.fst, new Pair(this.snd, 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));

package/lib/result.d.ts

@@ -3,7 +3,7 @@ import type { PartialOrder, Setoid, TotalOrder } from "./order.js";
 import type { Ordering } from "./ordering.js";
 import { Pair } from "./pair.js";
 export type Result<A, E> = Okay<A> | Fail<E>;
-declare abstract class ResultTrait implements TotalOrder<Result<never, never>> {
+declare abstract class ResultTrait {
     abstract readonly isOkay: boolean;
     abstract readonly isFail: boolean;
     toString<A, E>(this: Result<A, E>): string;

package/package.json

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