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

package/lib/bool.d.ts

@@ -0,0 +1,30 @@
+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 Bool implements TotalOrder<Bool> {
+    readonly value: boolean;
+    constructor(value: boolean);
+    static of(value: boolean): Bool;
+    toString(this: Bool): string;
+    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;
+}
+export declare class Any extends Bool implements Semigroup<Any> {
+    static of(value: boolean): Any;
+    toString(this: Any): string;
+    append(this: Any, that: Any): Any;
+}
+export declare class All extends Bool implements Semigroup<All> {
+    static of(value: boolean): All;
+    toString(this: All): string;
+    append(this: All, that: All): All;
+}

package/lib/bool.js

@@ -0,0 +1,69 @@
+import { Some } from "./option.js";
+export class Bool {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    static of(value) {
+        return new Bool(value);
+    }
+    toString() {
+        return `Bool(${this.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);
+    }
+}
+export class Any extends Bool {
+    static of(value) {
+        return new Any(value);
+    }
+    toString() {
+        return `Any(${this.value})`;
+    }
+    append(that) {
+        return new Any(this.value || that.value);
+    }
+}
+export class All extends Bool {
+    static of(value) {
+        return new All(value);
+    }
+    toString() {
+        return `All(${this.value})`;
+    }
+    append(that) {
+        return new All(this.value && that.value);
+    }
+}

package/lib/datetime.d.ts

@@ -0,0 +1,19 @@
+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;
+    toString(this: DateTime): string;
+    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,57 @@
+import { None, Some } from "./option.js";
+export class DateTime {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    static of(value) {
+        return new DateTime(value);
+    }
+    toString() {
+        return `DateTime(${this.value.getTime()})`;
+    }
+    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,19 @@
+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;
+    toString(this: Double): string;
+    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,49 @@
+import { None, Some } from "./option.js";
+export class Double {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    static of(value) {
+        return new Double(value);
+    }
+    toString() {
+        return `Double(${this.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,14 @@
+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 "./semigroup.js";
+export * from "./task.js";
+export * from "./text.js";

package/lib/index.js

@@ -1,2 +1,14 @@
+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 "./semigroup.js";
+export * from "./task.js";
+export * from "./text.js";

package/lib/integer.d.ts

@@ -0,0 +1,30 @@
+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 Integer implements TotalOrder<Integer> {
+    readonly value: bigint;
+    constructor(value: bigint);
+    static of(value: bigint): Integer;
+    toString(this: Integer): string;
+    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;
+}
+export declare class Sum extends Integer implements Semigroup<Sum> {
+    static of(value: bigint): Sum;
+    toString(this: Sum): string;
+    append(this: Sum, that: Sum): Sum;
+}
+export declare class Product extends Integer implements Semigroup<Product> {
+    static of(value: bigint): Product;
+    toString(this: Product): string;
+    append(this: Product, that: Product): Product;
+}

package/lib/integer.js

@@ -0,0 +1,69 @@
+import { Some } from "./option.js";
+export class Integer {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    static of(value) {
+        return new Integer(value);
+    }
+    toString() {
+        return `Integer(${this.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);
+    }
+}
+export class Sum extends Integer {
+    static of(value) {
+        return new Sum(value);
+    }
+    toString() {
+        return `Sum(${this.value})`;
+    }
+    append(that) {
+        return new Sum(this.value + that.value);
+    }
+}
+export class Product extends Integer {
+    static of(value) {
+        return new Product(value);
+    }
+    toString() {
+        return `Product(${this.value})`;
+    }
+    append(that) {
+        return new Product(this.value * that.value);
+    }
+}

package/lib/miscellaneous.d.ts

@@ -0,0 +1,5 @@
+import type { Pair } from "./pair.js";
+export declare const id: <A>(value: A) => A;
+export declare const uncurry2: <A, B, C>(morphism: (a: A, b: B) => C) => ({ fst: a, snd: b }: Pair<A, B>) => C;
+export declare const uncurry3: <A, B, C, D>(morphism: (a: A, b: B, c: C) => D) => ({ fst: { fst: a, snd: b }, snd: c }: Pair<Pair<A, B>, C>) => D;
+export declare const uncurry4: <A, B, C, D, E>(morphism: (a: A, b: B, c: C, d: D) => E) => ({ fst: { fst: { fst: a, snd: b }, snd: c }, snd: d }: Pair<Pair<Pair<A, B>, C>, D>) => E;

package/lib/miscellaneous.js

@@ -0,0 +1,6 @@
+export const id = (value) => value;
+export const uncurry2 = (morphism) => ({ fst: a, snd: b }) => morphism(a, b);
+export const uncurry3 = (morphism) => ({ fst: { fst: a, snd: b }, snd: c }) => morphism(a, b, c);
+export const uncurry4 = 
+// prettier-ignore
+(morphism) => ({ fst: { fst: { fst: a, snd: b }, snd: c }, snd: d }) => morphism(a, b, c, d);

package/lib/option.d.ts

@@ -1,23 +1,71 @@
-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";
+import type { Semigroup } from "./semigroup.js";
+import { Task } from "./task.js";
 export type Option<A> = Some<A> | None;
-declare abstract class OptionMethods {
+declare abstract class OptionTrait {
     abstract readonly isSome: boolean;
     abstract readonly isNone: boolean;
+    toString<A>(this: Option<A>): string;
+    fold<A, B>(this: Option<A>, morphism: (value: A) => B, defaultValue: B): B;
     map<A, B>(this: Option<A>, morphism: (value: A) => B): Option<B>;
-    safeExtract<A>(this: Option<A>, defaultValue: A): A;
-    safeExtractFrom<A>(this: Option<A>, getDefaultValue: () => A): A;
-    unsafeExtract<A>(this: Option<A>, error: Exception | string): A;
+    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>;
+    andWhen<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>;
+    flatMapUntil<A, B>(this: Option<A>, arrow: (value: A) => Option<Result<B, A>>): Option<B>;
+    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 Some<B>;
+    isSomeAnd<A>(this: Option<A>, predicate: (value: A) => boolean): this is Some<A>;
+    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>>;
+    transposeMapOkay<A, B, E>(this: Option<A>, transpose: (value: A) => Result<B, E>): Result<Option<B>, E>;
+    transposeMapFail<A, E, F>(this: Option<E>, transpose: (value: E) => Result<A, F>): Result<A, Option<F>>;
+    transposeOkay<A, E>(this: Option<Result<A, E>>): Result<Option<A>, E>;
+    transposeFail<A, E>(this: Option<Result<A, E>>): Result<A, Option<E>>;
+    exchangeMapOkay<A, B, E>(this: Option<A>, exchange: (value: A) => Task<B, E>): Task<Option<B>, E>;
+    exchangeMapFail<A, E, F>(this: Option<E>, exchange: (value: E) => Task<A, F>): Task<A, Option<F>>;
+    exchangeOkay<A, E>(this: Option<Task<A, E>>): Task<Option<A>, E>;
+    exchangeFail<A, E>(this: Option<Task<A, E>>): Task<A, Option<E>>;
+    extractSome<A>(this: Option<A>, defaultValue: A): A;
+    extractMapSome<A>(this: Option<A>, getDefaultValue: () => A): A;
+    toResultOkay<A, E>(this: Option<A>, defaultValue: E): Result<A, E>;
+    toResultFail<A, E>(this: Option<E>, defaultValue: A): Result<A, E>;
+    append<A extends Semigroup<A>>(this: Option<A>, that: Option<A>): Option<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>;
+    values<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>;
+    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>;
 }
-declare class None extends OptionMethods {
+export declare class None extends OptionTrait {
     readonly isSome = false;
     readonly isNone = true;
+    static readonly instance: None;
+    static fromNullish<A>(value: A): Option<NonNullable<A>>;
+    static fromFalsy<A>(value: A): Option<NonNullable<A>>;
 }
-export declare const some: <A>(value: A) => Some<A>;
-export declare const none: None;
-export type { Some, None };
+export {};

package/lib/option.js

@@ -1,22 +1,165 @@
-import { UnsafeExtractError } from "./errors.js";
-import { Exception } from "./exceptions.js";
-class OptionMethods {
+import { Pair } from "./pair.js";
+import { Fail, Okay } from "./result.js";
+import { Task } from "./task.js";
+class OptionTrait {
+    toString() {
+        return this.isSome ? `Some(${String(this.value)})` : "None";
+    }
+    fold(morphism, defaultValue) {
+        return this.isSome ? morphism(this.value) : defaultValue;
+    }
     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 : None.instance;
+    }
+    andWhen(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;
+    }
+    flatMapUntil(arrow) {
+        let result = this.flatMap(arrow).transposeOkay();
+        while (result.isFail)
+            result = arrow(result.value).transposeOkay();
+        return result.value;
+    }
+    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.from(None.instance)
+            : unzip(this.value).map(Some.of, Some.of);
+    }
+    unzip() {
+        return this.isNone
+            ? Pair.from(None.instance)
+            : this.value.map(Some.of, Some.of);
+    }
+    transposeMapOkay(transpose) {
+        return this.isNone
+            ? new Okay(None.instance)
+            : transpose(this.value).mapOkay(Some.of);
+    }
+    transposeMapFail(transpose) {
+        return this.isNone
+            ? new Fail(None.instance)
+            : transpose(this.value).mapFail(Some.of);
+    }
+    transposeOkay() {
+        return this.isNone ? new Okay(None.instance) : this.value.mapOkay(Some.of);
+    }
+    transposeFail() {
+        return this.isNone ? new Fail(None.instance) : this.value.mapFail(Some.of);
+    }
+    exchangeMapOkay(exchange) {
+        return this.isNone
+            ? Task.okay(None.instance)
+            : exchange(this.value).mapOkay(Some.of);
     }
-    safeExtract(defaultValue) {
+    exchangeMapFail(exchange) {
+        return this.isNone
+            ? Task.fail(None.instance)
+            : exchange(this.value).mapFail(Some.of);
+    }
+    exchangeOkay() {
+        return this.isNone ? Task.okay(None.instance) : this.value.mapOkay(Some.of);
+    }
+    exchangeFail() {
+        return this.isNone ? Task.fail(None.instance) : this.value.mapFail(Some.of);
+    }
+    extractSome(defaultValue) {
         return this.isSome ? this.value : defaultValue;
     }
-    safeExtractFrom(getDefaultValue) {
+    extractMapSome(getDefaultValue) {
         return this.isSome ? this.value : getDefaultValue();
     }
-    unsafeExtract(error) {
+    toResultOkay(defaultValue) {
+        return this.isSome ? new Okay(this.value) : new Fail(defaultValue);
+    }
+    toResultFail(defaultValue) {
+        return this.isSome ? new Fail(this.value) : new Okay(defaultValue);
+    }
+    append(that) {
+        if (this.isNone)
+            return that;
+        if (that.isNone)
+            return this;
+        return new Some(this.value.append(that.value));
+    }
+    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);
+    }
+    *values() {
         if (this.isSome)
-            return this.value;
-        throw error instanceof Exception ? error : new UnsafeExtractError(error);
+            yield this.value;
     }
 }
-class Some extends OptionMethods {
+export class Some extends OptionTrait {
     value;
     isSome = true;
     isNone = false;
@@ -24,10 +167,21 @@ class Some extends OptionMethods {
         super();
         this.value = value;
     }
+    static of(value) {
+        return new Some(value);
+    }
+    static fromValid(value, validate) {
+        return validate(value) ? new Some(value) : None.instance;
+    }
 }
-class None extends OptionMethods {
+export class None extends OptionTrait {
     isSome = false;
     isNone = true;
+    static instance = new None();
+    static fromNullish(value) {
+        return value == null ? None.instance : new Some(value);
+    }
+    static fromFalsy(value) {
+        return value ? new Some(value) : None.instance;
+    }
 }
-export const some = (value) => new Some(value);
-export const none = new None();