aang 2.0.0-alpha.2 → 2.0.0-alpha.20

package/lib/bool.d.ts

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

package/lib/bool.js

@@ -0,0 +1,44 @@
+import { Some } from "./option.js";
+export class Bool {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    static of(value) {
+        return new Bool(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/lib/datetime.d.ts

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

package/lib/datetime.js

@@ -0,0 +1,54 @@
+import { None, Some } from "./option.js";
+export class DateTime {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    static of(value) {
+        return new DateTime(value);
+    }
+    isSame(that) {
+        return Object.is(this.value.getTime(), that.value.getTime());
+    }
+    isNotSame(that) {
+        return !this.isSame(that);
+    }
+    isLess(that) {
+        return this.value < that.value;
+    }
+    isNotLess(that) {
+        return this.value > that.value || this.isSame(that);
+    }
+    isMore(that) {
+        return this.value > that.value;
+    }
+    isNotMore(that) {
+        return this.value < that.value || this.isSame(that);
+    }
+    compare(that) {
+        if (this.isSame(that))
+            return new Some("=");
+        if (this.value < that.value)
+            return new Some("<");
+        if (this.value > that.value)
+            return new Some(">");
+        return None.instance;
+    }
+    max(that) {
+        if (Number.isNaN(this.value.getTime()))
+            return this;
+        if (Number.isNaN(that.value.getTime()))
+            return that;
+        return this.value >= that.value ? this : that;
+    }
+    min(that) {
+        if (Number.isNaN(this.value.getTime()))
+            return this;
+        if (Number.isNaN(that.value.getTime()))
+            return that;
+        return this.value <= that.value ? this : that;
+    }
+    clamp(lower, upper) {
+        return this.max(lower).min(upper);
+    }
+}

package/lib/double.d.ts

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

package/lib/double.js

@@ -0,0 +1,46 @@
+import { None, Some } from "./option.js";
+export class Double {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    static of(value) {
+        return new Double(value);
+    }
+    isSame(that) {
+        return Object.is(this.value, that.value);
+    }
+    isNotSame(that) {
+        return !Object.is(this.value, that.value);
+    }
+    isLess(that) {
+        return this.value < that.value;
+    }
+    isNotLess(that) {
+        return this.value > that.value || Object.is(this.value, that.value);
+    }
+    isMore(that) {
+        return this.value > that.value;
+    }
+    isNotMore(that) {
+        return this.value < that.value || Object.is(this.value, that.value);
+    }
+    compare(that) {
+        if (Object.is(this.value, that.value))
+            return new Some("=");
+        if (this.value < that.value)
+            return new Some("<");
+        if (this.value > that.value)
+            return new Some(">");
+        return None.instance;
+    }
+    max(that) {
+        return new Double(Math.max(this.value, that.value));
+    }
+    min(that) {
+        return new Double(Math.min(this.value, that.value));
+    }
+    clamp(lower, upper) {
+        return this.max(lower).min(upper);
+    }
+}

package/lib/index.d.ts

@@ -1,2 +1,12 @@
+export * from "./bool.js";
+export * from "./datetime.js";
+export * from "./double.js";
 export * from "./exceptions.js";
+export * from "./integer.js";
+export * from "./miscellaneous.js";
 export * from "./option.js";
+export * from "./order.js";
+export * from "./ordering.js";
+export * from "./pair.js";
+export * from "./result.js";
+export * from "./text.js";

package/lib/index.js

@@ -1,2 +1,12 @@
+export * from "./bool.js";
+export * from "./datetime.js";
+export * from "./double.js";
 export * from "./exceptions.js";
+export * from "./integer.js";
+export * from "./miscellaneous.js";
 export * from "./option.js";
+export * from "./order.js";
+export * from "./ordering.js";
+export * from "./pair.js";
+export * from "./result.js";
+export * from "./text.js";

package/lib/integer.d.ts

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

package/lib/integer.js

@@ -0,0 +1,44 @@
+import { Some } from "./option.js";
+export class Integer {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    static of(value) {
+        return new Integer(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/lib/miscellaneous.d.ts

@@ -0,0 +1 @@
+export declare const id: <A>(value: A) => A;

package/lib/miscellaneous.js

@@ -0,0 +1 @@
+export const id = (value) => value;

package/lib/option.d.ts

@@ -1,21 +1,60 @@
 import { Exception } from "./exceptions.js";
+import type { PartialOrder, Setoid, TotalOrder } from "./order.js";
+import type { Ordering } from "./ordering.js";
+import { Pair } from "./pair.js";
+import type { Result } from "./result.js";
 export type Option<A> = Some<A> | None;
-declare abstract class OptionMethods {
+declare abstract class OptionTrait implements TotalOrder<Option<never>> {
     abstract readonly isSome: boolean;
     abstract readonly isNone: boolean;
+    toString<A>(this: Option<A>): string;
     map<A, B>(this: Option<A>, morphism: (value: A) => B): Option<B>;
+    replace<A, B>(this: Option<A>, value: B): Option<B>;
+    and<A, B>(this: Option<A>, that: Option<B>): Option<Pair<A, B>>;
+    andThen<A, B>(this: Option<A>, that: Option<B>): Option<B>;
+    andWith<A, B>(this: Option<A>, that: Option<B>): Option<A>;
+    or<A>(this: Option<A>, that: Option<A>): Option<A>;
+    flatMap<A, B>(this: Option<A>, arrow: (value: A) => Option<B>): Option<B>;
+    flatten<A>(this: Option<Option<A>>): Option<A>;
+    filter<A, B extends A>(this: Option<A>, predicate: (value: A) => value is B): Option<B>;
+    filter<A>(this: Option<A>, predicate: (value: A) => boolean): Option<A>;
+    isSomeAnd<A, B extends A>(this: Option<A>, predicate: (value: A) => value is B): this is Option<B>;
+    isSomeAnd<A>(this: Option<A>, predicate: (value: A) => boolean): boolean;
+    isNoneOr<A, B extends A>(this: Option<A>, predicate: (value: A) => value is B): this is Option<B>;
+    isNoneOr<A>(this: Option<A>, predicate: (value: A) => boolean): boolean;
+    unzipWith<A, B, C>(this: Option<A>, unzip: (value: A) => Pair<B, C>): Pair<Option<B>, Option<C>>;
+    unzip<A, B>(this: Option<Pair<A, B>>): Pair<Option<A>, Option<B>>;
+    transposeMap<A, E, B>(this: Option<A>, transpose: (value: A) => Result<E, B>): Result<E, Option<B>>;
+    transpose<E, A>(this: Option<Result<E, A>>): Result<E, Option<A>>;
+    safeExtract<A>(this: Option<A>, defaultValue: A): A;
     unsafeExtract<A>(this: Option<A>, error: Exception | string): A;
+    toResult<E, A>(this: Option<A>, defaultValue: E): Result<E, A>;
+    isSame<A extends Setoid<A>>(this: Option<A>, that: Option<A>): boolean;
+    isNotSame<A extends Setoid<A>>(this: Option<A>, that: Option<A>): boolean;
+    isLess<A extends PartialOrder<A>>(this: Option<A>, that: Option<A>): boolean;
+    isNotLess<A extends PartialOrder<A>>(this: Option<A>, that: Option<A>): boolean;
+    isMore<A extends PartialOrder<A>>(this: Option<A>, that: Option<A>): boolean;
+    isNotMore<A extends PartialOrder<A>>(this: Option<A>, that: Option<A>): boolean;
+    compare<A extends PartialOrder<A>>(this: Option<A>, that: Option<A>): Option<Ordering>;
+    max<A extends TotalOrder<A>>(this: Option<A>, that: Option<A>): Option<A>;
+    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>;
+    [Symbol.iterator]<A>(this: Option<A>): Generator<A, void, undefined>;
 }
-declare class Some<out A> extends OptionMethods {
+export declare class Some<out A> extends OptionTrait {
     readonly value: A;
     readonly isSome = true;
     readonly isNone = false;
     constructor(value: A);
+    static of<A>(value: A): Some<A>;
 }
-declare class None extends OptionMethods {
+export declare class None extends OptionTrait {
     readonly isSome = false;
     readonly isNone = true;
+    static readonly instance: None;
 }
-export declare const some: <A>(value: A) => Some<A>;
-export declare const none: None;
-export type { Some, None };
+export declare const fromNullable: <A>(value: A) => Option<NonNullable<A>>;
+export declare const fromFalsy: <A>(value: A) => Option<NonNullable<A>>;
+export declare function fromValue<A, B extends A>(value: A, predicate: (value: A) => value is B): Option<B>;
+export declare function fromValue<A>(value: A, predicate: (value: A) => boolean): Option<A>;
+export {};

package/lib/option.js

@@ -1,16 +1,125 @@
 import { UnsafeExtractError } from "./errors.js";
 import { Exception } from "./exceptions.js";
-class OptionMethods {
+import { Pair } from "./pair.js";
+import { Fail, Okay } from "./result.js";
+class OptionTrait {
+    toString() {
+        return this.isSome ? `Some(${String(this.value)})` : "None";
+    }
     map(morphism) {
-        return this.isSome ? new Some(morphism(this.value)) : none;
+        return this.isSome ? new Some(morphism(this.value)) : None.instance;
+    }
+    replace(value) {
+        return this.isSome ? new Some(value) : None.instance;
+    }
+    and(that) {
+        return this.isSome && that.isSome
+            ? new Some(new Pair(this.value, that.value))
+            : None.instance;
+    }
+    andThen(that) {
+        return this.isSome && that.isSome ? that : None.instance;
+    }
+    andWith(that) {
+        return this.isSome && that.isSome ? this : None.instance;
+    }
+    or(that) {
+        return this.isSome ? this : that;
+    }
+    flatMap(arrow) {
+        return this.isSome ? arrow(this.value) : None.instance;
+    }
+    flatten() {
+        return this.isSome ? this.value : None.instance;
+    }
+    filter(predicate) {
+        return this.isSome && predicate(this.value) ? this : None.instance;
+    }
+    isSomeAnd(predicate) {
+        return this.isSome && predicate(this.value);
+    }
+    isNoneOr(predicate) {
+        return this.isNone || predicate(this.value);
+    }
+    unzipWith(unzip) {
+        return this.isNone
+            ? Pair.of(None.instance)
+            : unzip(this.value).map(Some.of, Some.of);
+    }
+    unzip() {
+        return this.isNone
+            ? Pair.of(None.instance)
+            : this.value.map(Some.of, Some.of);
+    }
+    transposeMap(transpose) {
+        return this.isNone
+            ? new Okay(None.instance)
+            : transpose(this.value).mapOkay(Some.of);
+    }
+    transpose() {
+        return this.isNone ? new Okay(None.instance) : this.value.mapOkay(Some.of);
+    }
+    safeExtract(defaultValue) {
+        return this.isSome ? this.value : defaultValue;
     }
     unsafeExtract(error) {
         if (this.isSome)
             return this.value;
         throw error instanceof Exception ? error : new UnsafeExtractError(error);
     }
+    toResult(defaultValue) {
+        return this.isSome ? new Okay(this.value) : new Fail(defaultValue);
+    }
+    isSame(that) {
+        return this.isSome
+            ? that.isSome && this.value.isSame(that.value)
+            : that.isNone;
+    }
+    isNotSame(that) {
+        return this.isSome
+            ? that.isNone || this.value.isNotSame(that.value)
+            : that.isSome;
+    }
+    isLess(that) {
+        return that.isSome && (this.isNone || this.value.isLess(that.value));
+    }
+    isNotLess(that) {
+        return that.isNone || (this.isSome && this.value.isNotLess(that.value));
+    }
+    isMore(that) {
+        return this.isSome && (that.isNone || this.value.isMore(that.value));
+    }
+    isNotMore(that) {
+        return this.isNone || (that.isSome && this.value.isNotMore(that.value));
+    }
+    compare(that) {
+        if (this.isNone)
+            return new Some(that.isSome ? "<" : "=");
+        if (that.isNone)
+            return new Some(">");
+        return this.value.compare(that.value);
+    }
+    max(that) {
+        if (this.isNone)
+            return that;
+        if (that.isNone)
+            return this;
+        return new Some(this.value.max(that.value));
+    }
+    min(that) {
+        if (this.isNone || that.isNone)
+            return None.instance;
+        return new Some(this.value.min(that.value));
+    }
+    clamp(lower, upper) {
+        return this.max(lower).min(upper);
+    }
+    *[Symbol.iterator]() {
+        if (this.isSome)
+            yield this.value;
+    }
 }
-class Some extends OptionMethods {
+export class Some extends OptionTrait {
     value;
     isSome = true;
     isNone = false;
@@ -18,10 +127,17 @@ class Some extends OptionMethods {
         super();
         this.value = value;
     }
+    static of(value) {
+        return new Some(value);
+    }
 }
-class None extends OptionMethods {
+export class None extends OptionTrait {
     isSome = false;
     isNone = true;
+    static instance = new None();
+}
+export const fromNullable = (value) => value == null ? None.instance : new Some(value);
+export const fromFalsy = (value) => value ? new Some(value) : None.instance;
+export function fromValue(value, predicate) {
+    return predicate(value) ? new Some(value) : None.instance;
 }
-export const some = (value) => new Some(value);
-export const none = new None();

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,9 @@
+export declare class Pair<out A, out B> {
+    readonly fst: A;
+    readonly snd: B;
+    constructor(fst: A, snd: B);
+    static of<A>(value: A): Pair<A, A>;
+    map<A, B, C, D>(this: Pair<A, B>, fstMorphism: (fst: A) => C, sndMorphism: (snd: B) => D): Pair<C, D>;
+    associateLeft<A, B, C>(this: Pair<A, Pair<B, C>>): Pair<Pair<A, B>, C>;
+    associateRight<A, B, C>(this: Pair<Pair<A, B>, C>): Pair<A, Pair<B, C>>;
+}

package/lib/pair.js

@@ -0,0 +1,20 @@
+export class Pair {
+    fst;
+    snd;
+    constructor(fst, snd) {
+        this.fst = fst;
+        this.snd = snd;
+    }
+    static of(value) {
+        return new Pair(value, value);
+    }
+    map(fstMorphism, sndMorphism) {
+        return new Pair(fstMorphism(this.fst), sndMorphism(this.snd));
+    }
+    associateLeft() {
+        return new Pair(new Pair(this.fst, this.snd.fst), this.snd.snd);
+    }
+    associateRight() {
+        return new Pair(this.fst.fst, new Pair(this.fst.snd, this.snd));
+    }
+}

package/lib/result.d.ts

@@ -0,0 +1,22 @@
+export type Result<E, A> = Okay<A> | Fail<E>;
+declare abstract class ResultTrait {
+    abstract readonly isOkay: boolean;
+    abstract readonly isFail: boolean;
+    mapOkay<E, A, B>(this: Result<E, A>, morphism: (value: A) => B): Result<E, B>;
+    mapFail<E, F, A>(this: Result<E, A>, morphism: (value: E) => F): Result<F, 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>;
+}
+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 {};

package/lib/result.js

@@ -0,0 +1,32 @@
+class ResultTrait {
+    mapOkay(morphism) {
+        return this.isOkay ? new Okay(morphism(this.value)) : this;
+    }
+    mapFail(morphism) {
+        return this.isFail ? new Fail(morphism(this.value)) : this;
+    }
+}
+export class Okay extends ResultTrait {
+    value;
+    isOkay = true;
+    isFail = false;
+    constructor(value) {
+        super();
+        this.value = value;
+    }
+    static of(value) {
+        return new Okay(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/text.d.ts

@@ -0,0 +1,18 @@
+import type { Option } from "./option.js";
+import type { TotalOrder } from "./order.js";
+import type { Ordering } from "./ordering.js";
+export declare class Text implements TotalOrder<Text> {
+    readonly value: string;
+    constructor(value: string);
+    static of(value: string): 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,44 @@
+import { Some } from "./option.js";
+export class Text {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    static of(value) {
+        return new Text(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.2",
+  "version": "2.0.0-alpha.20",
   "description": "A powerful functional programming library for TypeScript.",
   "keywords": [
     "aang",