rsult 1.2.0 → 1.4.0

package/dist/lib.d.ts

@@ -0,0 +1,2 @@
+export * from './result';
+export * from './option';

package/dist/lib.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./result"), exports);
+__exportStar(require("./option"), exports);
+//# sourceMappingURL=lib.js.map

package/dist/lib.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lib.js","sourceRoot":"","sources":["../src/lib.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,2CAAyB;AACzB,2CAAyB"}

package/dist/option.d.ts

@@ -0,0 +1,307 @@
+export type Option<T> = OptionSome<T> | OptionNone<T>;
+export interface IOptionCheck<T> {
+    /**
+     * Determines if the Option is Some.
+     * @returns true if the Option is Some, otherwise false.
+     *
+     * Usage Example:
+     * const myOption = Some(5);
+     * if (myOption.is_some()) {
+     *   console.log("It's Some!");
+     * }
+     */
+    is_some(): this is OptionSome<T>;
+    /**
+     * Determines if the Option is Some and the contained value meets a condition.
+     * @param f The condition to apply to the contained value if it's Some.
+     * @returns true if the Option is Some and the condition returns true, otherwise false.
+     *
+     * Usage Example:
+     * const myOption = Some(5);
+     * const isGreaterThanThree = myOption.is_some_and(x => x > 3); // true
+     */
+    is_some_and(f: (arg: T) => boolean): boolean;
+    /**
+     * Determines if the Option is None.
+     * @returns true if the Option is None, otherwise false.
+     *
+     * Usage Example:
+     * const myOption = None();
+     * if (myOption.is_none()) {
+     *  console.log("It's None!");
+     * }
+     */
+    is_none(): boolean;
+}
+export interface IOptionExpect<T> {
+    /**
+     * Extracts the value from a Some, throwing an error if it is None.
+     * @param msg The error message to throw if the Option is None.
+     * @returns The contained value if the Option is Some.
+     * @throws Error with provided message if the Option is None.
+     *
+     * Usage Example:
+     * const myOption = Some(5);
+     * const value = myOption.expect("Expected a value!"); // 5
+     */
+    expect(msg: string): T | never;
+}
+export interface IOptionTransform<T> {
+    /**
+     * Transforms the contained value of a Some with a provided function. Returns None if this Option is None.
+     * @param fn The mapping function to apply to the contained value.
+     * @returns An Option containing the result of applying fn to the original value if it was Some, else None.
+     *
+     * Usage Example:
+     * const myOption = Some(5);
+     * const newOption = myOption.map(x => x * 2); // Some(10)
+     */
+    map<U>(fn: (arg: T) => U): Option<U>;
+    /**
+     * Applies a function to the contained value if Some, otherwise returns a provided default.
+     * @param defaultVal The default value to return if the Option is None.
+     * @param fn The function to apply to the contained value if Some.
+     * @returns The result of applying fn to the contained value if this Option is Some, else defaultVal.
+     *
+     * Usage Example:
+     * const myOption = None();
+     * const value = myOption.map_or(0, x => x * 2); // 0
+     */
+    map_or<U>(defaultVal: U, fn: (arg: T) => U): U;
+}
+export interface IOptionCombine<T> {
+    /**
+     * Returns the passed Option if this Option is Some, else returns None.
+     * @param opt The Option to return if this Option is Some.
+     * @returns The passed Option if this Option is Some, else None.
+     *
+     * Usage Example:
+     * const opt1 = Some(5);
+     * const opt2 = Some(10);
+     * const result = opt1.and(opt2); // Some(10)
+     */
+    and<U>(opt: Option<U>): Option<U>;
+    /**
+     * Returns the result of applying a function to the contained value if Some, otherwise returns None.
+     * @param fn The function to apply to the contained value.
+     * @returns An Option containing the result of applying fn to the original value if it was Some, else None.
+     *
+     * Usage Example:
+     * const myOption = Some(5);
+     * const newOption = myOption.and_then(x => Some(x * 2)); // Some(10)
+     */
+    and_then<U>(fn: (arg: T) => Option<U>): Option<U>;
+    /**
+     * Returns the passed Option if this Option is None, else returns this Option.
+     * @param opt The alternative Option to return if this Option is None.
+     * @returns This Option if it is Some, otherwise the passed Option.
+     *
+     * Usage Example:
+     * const opt1 = None();
+     * const opt2 = Some(10);
+     * const result = opt1.or(opt2); // Some(10)
+     */
+    or<U>(opt: Option<U>): Option<T> | Option<U>;
+    /**
+     * Returns the result of applying a function if this Option is None, else returns this Option.
+     * @param fn The function that produces an Option to return if this Option is None.
+     * @returns This Option if it is Some, otherwise the Option produced by fn.
+     *
+     * Usage Example:
+     * const opt1 = None();
+     * const result = opt1.or_else(() => Some(10)); // Some(10)
+     */
+    or_else<U>(fn: () => Option<U>): Option<T> | Option<U>;
+    /**
+     * Returns None if both this and the passed Option are Some. Otherwise returns the Option that is Some.
+     * @param optb The other Option to compare with.
+     * @returns None if both Options are Some, otherwise the Option that is Some.
+     *
+     * Usage Example:
+     * const opt1 = Some(5);
+     * const opt2 = None();
+     * const result = opt1.xor(opt2); // Some(5)
+     */
+    xor(optb: Option<T>): Option<T>;
+}
+export interface IOptionUtility<T> {
+    /**
+     * Unwraps the Option, returning the contained value, or throws an error if the Option is None.
+     * @returns The contained value if this Option is Some.
+     * @throws Error if this Option is None.
+     *
+     * Usage Example:
+     * const myOption = Some(5);
+     * const value = myOption.unwrap(); // 5
+     */
+    unwrap(): T | never;
+    /**
+     * Returns the contained value if Some, else returns a provided alternative.
+     * @param optb The alternative value to return if this Option is None.
+     * @returns The contained value if this Option is Some, else optb.
+     *
+     * Usage Example:
+     * const myOption = None();
+     * const value = myOption.unwrap_or(10); // 10
+     */
+    unwrap_or(optb: T): T;
+    /**
+     * Returns the contained value if Some, else computes a value from a provided function.
+     * @param fn The function to compute the alternative value from if this Option is None.
+     * @returns The contained value if this Option is Some, else the result of fn.
+     *
+     * Usage Example:
+     * const myOption = None();
+     * const value = myOption.unwrap_or_else(() => 10); // 10
+     */
+    unwrap_or_else(fn: () => T): T;
+    /**
+     * Returns the contained value if Some, otherwise the default value for the type.
+     * @returns The contained value if Some, else the type’s default value.
+     *
+     * Usage Example:
+     * const myOption is None<number>();
+     * const value = myOption.unwrap_or_default(); // 0
+     */
+    unwrap_or_default(): T | null;
+}
+export interface IOptionMutate<T> {
+    /**
+     * Takes the contained value out of the Option, leaving a None in its place.
+     * @returns The Option containing the original value before it was taken.
+     *
+     * Usage Example:
+     * const myOption = Some(5);
+     * const takenValue = myOption.take(); // Some(5), myOption is now None
+     */
+    take(): Option<T>;
+    /**
+     * Takes the contained value out of the Option if it satisfies a predicate, leaving a None in its place.
+     * @param predicate The predicate to apply to the contained value.
+     * @returns The Option containing the original value if the predicate returns true, otherwise None.
+     *
+     * Usage Example:
+     * const myOption = Some(5);
+     * const takenValue = myOption.take_if(x => x > 3); // Some(5), myOption is now None
+     */
+    take_if(predicate: (arg: T) => boolean): Option<T>;
+    /**
+     * Replaces the contained value with another, returning the old value wrapped in an Option.
+     * @param value The new value to put in the Option.
+     * @returns An Option containing the old value.
+     *
+     * Usage Example:
+     * const myOption = Some(5);
+     * const oldValue = myOption.replace(10); // Some(5), myOption now contains 10
+     *
+    */
+    replace(value: T): Option<T>;
+}
+export interface IOptionZip<T> {
+    /**
+     * Combines two Option values into a single Option containing a tuple of their values if both are Some, otherwise returns None.
+     * @param other The other Option to zip with.
+     * @returns An Option containing a tuple of the two Option values if both are Some, otherwise None.
+     *
+     * Usage Example:
+     * const opt1 = Some(5);
+     * const opt2 = Some("hello");
+     * const zipped = opt1.zip(opt2); // Some([5, "hello"])
+     */
+    zip<U>(other: Option<U>): Option<[T, U]>;
+    /**
+     * Combines two Option values by applying a function if both are Some, otherwise returns None.
+     * @param other The other Option to zip with.
+     * @param f The function to apply to the values if both Options are Some.
+     * @returns An Option containing the result of the function if both Options are Some, otherwise None.
+     *
+     * Usage Example:
+     * const opt1 = Some(5);
+     * const opt2 = Some(10);
+     * const added = opt1.zip_with(opt2, (a, b) => a + b); // Some(15)
+     */
+    zip_with<U, R>(other: Option<U>, f: (val: T, other: U) => R): Option<R>;
+}
+export interface IOptionFilter<T> {
+    /**
+     * Applies a predicate to the contained value if Some, returns None if the predicate does not hold or if this Option is None.
+     * @param predicate The predicate function to apply.
+     * @returns The original Option if it is Some and the predicate holds, else None.
+     *
+     * Usage Example:
+     * const myOption = Some(5);
+     * const filteredOption = myOption.filter(x => x > 3); // Some(5)
+     */
+    filter(predicate: (arg: T) => boolean): Option<T>;
+}
+export interface IOptionFlatten<T> {
+    /**
+     * Flattens a nested Option, if the Option contains another Option, returning the inner Option if it's Some.
+     * @returns The contained Option if this is an Option of an Option and the inner Option is Some, otherwise None.
+     *
+     * Usage Example:
+     * const opt = Some(Some(5));
+     * const flattened = opt.flatten(); // Some(5)
+     */
+    flatten<T extends Option<T>>(): Option<T>;
+}
+export interface IOption<T> extends IOptionCheck<T>, IOptionExpect<T>, IOptionTransform<T>, IOptionCombine<T>, IOptionUtility<T>, IOptionMutate<T>, IOptionZip<T>, IOptionFilter<T>, IOptionFlatten<T> {
+}
+export declare class OptionSome<T> implements IOption<T> {
+    readonly value: T;
+    readonly _tag: "Some";
+    readonly _T: T;
+    constructor(value: T);
+    is_some(): this is OptionSome<T>;
+    is_some_and(f: (arg: T) => boolean): boolean;
+    is_none(): this is never;
+    expect(_msg: string): T;
+    map<U>(fn: (arg: T) => U): Option<U>;
+    map_or<U>(_defaultVal: U, fn: (arg: T) => U): U;
+    and<U>(opt: Option<U>): Option<U>;
+    and_then<U>(fn: (arg: T) => Option<U>): Option<U>;
+    filter(predicate: (arg: T) => boolean): Option<T>;
+    or<U>(_opt: Option<U>): Option<T>;
+    or_else<U>(_fn: () => Option<U>): Option<T>;
+    xor(optb: Option<T>): Option<T>;
+    unwrap(): T;
+    unwrap_or(optb: T): T;
+    unwrap_or_else(_fn: () => T): T;
+    unwrap_or_default(): T | null;
+    take(): Option<T>;
+    take_if(predicate: (arg: T) => boolean): Option<T>;
+    replace(value: T): Option<T>;
+    zip<U>(other: Option<U>): Option<[T, U]>;
+    zip_with<U, R>(other: Option<U>, f: (val: T, other: U) => R): Option<R>;
+    flatten<T extends Option<T>>(): Option<T>;
+}
+export declare class OptionNone<T> implements IOption<T> {
+    private readonly _tag;
+    private readonly _T;
+    is_some(): this is never;
+    is_some_and(_f: (arg: T) => boolean): boolean;
+    is_none(): this is OptionNone<T>;
+    expect(msg: string): never;
+    map<U>(_fn: (arg: T) => U): Option<U>;
+    map_or<U>(defaultVal: U, _fn: (arg: T) => U): U;
+    and<U>(_opt: Option<U>): Option<U>;
+    and_then<U>(_fn: (arg: T) => Option<U>): Option<U>;
+    filter(_predicate: (arg: T) => boolean): Option<T>;
+    or<U>(opt: Option<U>): Option<U>;
+    or_else<U>(fn: () => Option<U>): Option<U>;
+    xor(optb: Option<T>): Option<T>;
+    unwrap(): never;
+    unwrap_or(optb: T): T;
+    unwrap_or_else(fn: () => T): T;
+    unwrap_or_default(): T | null;
+    take(): Option<T>;
+    take_if(_predicate: (arg: T) => boolean): Option<T>;
+    replace(value: T): Option<T>;
+    zip<U>(other: Option<U>): Option<[T, U]>;
+    zip_with<U, R>(_other: Option<U>, _f: (val: T, other: U) => R): Option<R>;
+    flatten<T extends Option<T>>(): Option<T>;
+}
+export declare const Some: <T>(val: T) => Option<T>;
+export declare const None: <T>() => Option<T>;
+export declare const option_from_nullable: <T>(val: T | null | undefined) => Option<T>;
+export declare const option_from_promise: <T>(promise: Promise<T>) => Promise<Option<T>>;

package/dist/option.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.option_from_promise = exports.option_from_nullable = exports.None = exports.Some = exports.OptionNone = exports.OptionSome = void 0;
+class OptionSome {
+    constructor(value) {
+        this.value = value;
+        this._tag = 'Some';
+    }
+    is_some() {
+        return true;
+    }
+    is_some_and(f) {
+        return f(this.value);
+    }
+    is_none() {
+        return false;
+    }
+    expect(_msg) {
+        return this.value;
+    }
+    map(fn) {
+        return new OptionSome(fn(this.value));
+    }
+    map_or(_defaultVal, fn) {
+        return fn(this.value);
+    }
+    and(opt) {
+        return opt;
+    }
+    and_then(fn) {
+        return fn(this.value);
+    }
+    filter(predicate) {
+        if (predicate(this.value)) {
+            return this;
+        }
+        return (0, exports.None)();
+    }
+    or(_opt) {
+        return this;
+    }
+    or_else(_fn) {
+        return this;
+    }
+    xor(optb) {
+        if (optb.is_some()) {
+            return (0, exports.None)();
+        }
+        return this;
+    }
+    unwrap() {
+        return this.value;
+    }
+    unwrap_or(optb) {
+        return this.value;
+    }
+    unwrap_or_else(_fn) {
+        return this.value;
+    }
+    unwrap_or_default() {
+        return this.value;
+    }
+    take() {
+        const value = this.value;
+        // @ts-ignore "administrative override" :-)
+        this.value = undefined;
+        return new OptionSome(value);
+    }
+    take_if(predicate) {
+        if (predicate(this.value)) {
+            return this.take();
+        }
+        return (0, exports.None)();
+    }
+    replace(value) {
+        const oldValue = this.value;
+        // @ts-ignore "administrative override" :-)
+        this.value = value;
+        return new OptionSome(oldValue);
+    }
+    zip(other) {
+        if (other.is_some()) {
+            return new OptionSome([this.value, other.unwrap()]);
+        }
+        return new OptionNone();
+    }
+    zip_with(other, f) {
+        if (other.is_some()) {
+            return new OptionSome(f(this.value, other.unwrap()));
+        }
+        return new OptionNone();
+    }
+    flatten() {
+        if (this.value instanceof OptionSome) {
+            // If the value is an OptionSome, we return it directly.
+            return this.value;
+        }
+        else {
+            // If the value is not an OptionSome (meaning it's an OptionNone or another type),
+            // we return None<T>(). This assumes that None<T>() creates an OptionNone<T> instance.
+            return (0, exports.None)();
+        }
+    }
+}
+exports.OptionSome = OptionSome;
+class OptionNone {
+    constructor() {
+        this._tag = 'None';
+    }
+    is_some() {
+        return false;
+    }
+    is_some_and(_f) {
+        return false;
+    }
+    is_none() {
+        return true;
+    }
+    expect(msg) {
+        throw new Error(msg);
+    }
+    map(_fn) {
+        return this;
+    }
+    map_or(defaultVal, _fn) {
+        return defaultVal;
+    }
+    and(_opt) {
+        return this;
+    }
+    and_then(_fn) {
+        return this;
+    }
+    filter(_predicate) {
+        return this;
+    }
+    or(opt) {
+        return opt;
+    }
+    or_else(fn) {
+        return fn();
+    }
+    xor(optb) {
+        return optb;
+    }
+    unwrap() {
+        throw new Error('Called Option.unwrap() on a None value');
+    }
+    unwrap_or(optb) {
+        return optb;
+    }
+    unwrap_or_else(fn) {
+        return fn();
+    }
+    unwrap_or_default() {
+        return null;
+    }
+    take() {
+        return this;
+    }
+    take_if(_predicate) {
+        return this;
+    }
+    replace(value) {
+        return new OptionSome(value);
+    }
+    zip(other) {
+        return (0, exports.None)();
+    }
+    zip_with(_other, _f) {
+        return (0, exports.None)();
+    }
+    flatten() {
+        return this;
+    }
+}
+exports.OptionNone = OptionNone;
+const Some = (val) => {
+    return new OptionSome(val);
+};
+exports.Some = Some;
+const None = () => {
+    return new OptionNone();
+};
+exports.None = None;
+const option_from_nullable = (val) => {
+    if (val === null || val === undefined) {
+        return (0, exports.None)();
+    }
+    return (0, exports.Some)(val);
+};
+exports.option_from_nullable = option_from_nullable;
+const option_from_promise = (promise) => promise.then(exports.Some).catch(() => (0, exports.None)());
+exports.option_from_promise = option_from_promise;
+//# sourceMappingURL=option.js.map

package/dist/option.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"option.js","sourceRoot":"","sources":["../src/option.ts"],"names":[],"mappings":"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"}

package/dist/result.d.ts

@@ -0,0 +1,410 @@
+import { Option } from './option';
+export type Result<T, E> = ResultOk<T, E> | ResultErr<T, E>;
+export interface IResultCore<T, E> {
+    /**
+     * Checks if the result is an instance of `ResultOk`.
+     * @returns true if the result is `ResultOk`, otherwise false.
+     *
+     * Usage Example:
+     * const result = Ok(5);
+     * if (result.is_ok()) {
+     *   console.log("Result is Ok");
+     * }
+     */
+    is_ok(): this is ResultOk<T, E>;
+    /**
+     * Checks if the result is an instance of `ResultErr`.
+     * @returns true if the result is `ResultErr`, otherwise false.
+     *
+     * Usage Example:
+     * const result = Err(new Error("Error"));
+     * if (result.is_err()) {
+     *   console.log("Result is Err");
+     * }
+     */
+    is_err(): this is ResultErr<T, E>;
+    /**
+     * Retrieves the value from `ResultOk`, wrapped in an `Option`.
+     * @returns `Some` containing the value if the result is `ResultOk`, otherwise `None`.
+     *
+     * Usage Example:
+     * const result = Ok(5);
+     * const value = result.ok();
+     * if (value.is_some()) {
+     *   console.log("Value:", value.unwrap());
+     * }
+     */
+    ok(): Option<T>;
+    /**
+     * Retrieves the error from `ResultErr`, wrapped in an `Option`.
+     * @returns `Some` containing the error if the result is `ResultErr`, otherwise `None`.
+     *
+     * Usage Example:
+     * const result = Err(new Error("Error"));
+     * const error = result.err();
+     * if (error.is_some()) {
+     *   console.log("Error:", error.unwrap());
+     * }
+     */
+    err(): Option<E>;
+    /**
+     * Returns the contained `ResultOk` value, but throws an error with a provided message if
+     * the result is a `ResultErr`.
+     * @param msg The message to throw with if the result is an error.
+     * @returns The contained `ResultOk` value.
+     *
+     * Usage Example:
+     * const result = Ok(5);
+     * console.log(result.expect("This should not fail"));
+     */
+    expect(msg: string): T;
+    /**
+     * Unwraps a `ResultOk`, yielding the contained value.
+     * @returns The `ResultOk` value.
+     * @throws Throws if the result is `ResultErr`.
+     *
+     * Usage Example:
+     * const result = Ok(5);
+     * console.log(result.unwrap());
+     */
+    unwrap(): T;
+    /**
+     * Returns the contained `ResultErr` error, but throws an error with a provided message if
+     * the result is a `ResultOk`.
+     * @param msg The message to throw with if the result is Ok.
+     * @returns The contained `ResultErr` error.
+     *
+     * Usage Example:
+     * const result = Err(new Error("Failure"));
+     * console.log(result.expect_err("Expected an error"));
+     */
+    expect_err(msg: string): E;
+    /**
+     * Unwraps a `ResultErr`, yielding the contained error.
+     * @returns The `ResultErr` error.
+     * @throws Throws if the result is `ResultOk`.
+     *
+     * Usage Example:
+     * const result = Err(new Error("Failure"));
+     * console.log(result.unwrap_err());
+     */
+    unwrap_err(): E;
+    /**
+     * Converts from `IResultCore<T, E>` to `T`.
+     * @returns The contained `ResultOk` value.
+     * @throws Throws if the result is `ResultErr`.
+     *
+     * Usage Example:
+     * const result = Ok(5);
+     * console.log(result.into_ok());
+     */
+    into_ok(): T;
+    /**
+     * Converts from `IResultCore<T, E>` to `E`.
+     * @returns The contained `ResultErr` error.
+     * @throws Throws if the result is `ResultOk`.
+     *
+     * Usage Example:
+     * const result = Err(new Error("Failure"));
+     * console.log(result.into_err());
+     */
+    into_err(): E;
+    /**
+     * Converts between different forms of `Result`, allowing the error type to be widened.
+     *
+     * If called on a `ResultOk<T, E>`, it will return a `Result<T, never>`, effectively discarding
+     * the error type. This is useful when you want to use the `Result` in a context that expects
+     * a `Result` with a specific error type, but you know that the `Result` is an `Ok` variant.
+     *
+     * If called on a `ResultErr<T, E>`, it will return a `Result<never, E>`, effectively discarding
+     * the value type. This is useful when you want to use the `Result` in a context that expects
+     * a `Result` with a specific value type, but you know that the `Result` is an `Err` variant.
+     *
+     * This is particularly useful when trying to forward a ResultErr returned by a function whose
+     * error type overlaps with the returned error type of the current function, but whose value type
+     * does not.
+     *
+     * Usage Example:
+     * const result: Result<number, Error> = Ok<number, Error>(5);
+     * const transmuted: Result<number, never> = result.transmute();
+     *
+     * const result: Result<number, Error> = Err<number, Error>(new Error("Failure"));
+     * const transmuted: Result<never, Error> = result.transmute();
+     */
+    transmute(): Result<T, never> | Result<never, E>;
+}
+export interface IResultExt<T, E> extends IResultCore<T, E> {
+    /**
+     * Checks if the result is Ok and the contained value passes a specified condition.
+     * @param f A predicate to apply to the contained value if the result is Ok.
+     * @returns true if the result is Ok and the predicate returns true, otherwise false.
+     *
+     * Usage Examples:
+     * const result = Ok(5);
+     * if (result.is_ok_and(x => x > 3)) {
+     *   console.log("Result is Ok and greater than 3");
+     * }
+     *
+     * const result = Ok(2);
+     * if (!result.is_ok_and(x => x > 3)) {
+     *   console.log("Result is not Ok or not greater than 3");
+     * }
+     */
+    is_ok_and(f: (value: T) => boolean): boolean;
+    /**
+     * Checks if the result is Err and the contained error passes a specified condition.
+     * @param f A predicate to apply to the contained error if the result is Err.
+     * @returns true if the result is Err and the predicate returns true, otherwise false.
+     *
+     * Usage Examples:
+     * const result = Err(new Error("Network failure"));
+     * if (result.is_err_and(e => e.message.includes("Network"))) {
+     *   console.log("Network error occurred");
+     * }
+     */
+    is_err_and(f: (value: E) => boolean): boolean;
+    /**
+     * Transforms the result via a mapping function if it is Ok.
+     * @param fn A function to transform the Ok value.
+     * @returns A new Result where the Ok value has been transformed.
+     *
+     * Usage Example:
+     * const result = Ok(5);
+     * const mapped = result.map(x => x * 2);
+     *
+     * const result = Err("Error");
+     * const mapped = result.map(x => x * 2); // remains Err
+     */
+    map<U>(fn: (arg: T) => U): Result<U, E>;
+    /**
+     * Transforms the result via a mapping function if it is Ok, otherwise returns a default value.
+     * @param defaultVal A default value to return if the result is Err.
+     * @param f A function to transform the Ok value.
+     * @returns The transformed Ok value or the default value.
+     *
+     * Usage Example:
+     * const result = Ok(5);
+     * const value = result.map_or(0, x => x * 2);
+     *
+     * const result = Err("Error");
+     * const value = result.map_or(0, x => x * 2); // 0
+     */
+    map_or<U>(defaultVal: U, f: (arg: T) => U): U;
+    /**
+     * Transforms the result via a mapping function if it is Ok, otherwise computes a default value using a function.
+     * @param defaultFunc A function to compute a default value if the result is Err.
+     * @param f A function to transform the Ok value.
+     * @returns The transformed Ok value or the computed default value.
+     *
+     * Usage Example:
+     * const result = Ok(5);
+     * const value = result.map_or_else(() => 0, x => x * 2);
+     *
+     * const result = Err("Error");
+     * const value = result.map_or_else(() => 0, x => x * 2); // 0
+     */
+    map_or_else<U>(defaultFunc: (err: E) => U, f: (arg: T) => U): U;
+    /**
+     * Maps a `Result<T, E>` to `Result<T, U>` by applying a function to a contained `Err` value, leaving an `Ok` value untouched.
+     * @param fn A function to transform the Err value.
+     * @returns A new Result where the Err has been transformed.
+     *
+     * Usage Example:
+     * const result = Err("Error");
+     * const mappedErr = result.map_err(e => new Error(e));
+     */
+    map_err<U>(fn: (arg: E) => U): Result<T, U>;
+    /**
+     * Applies a function to the contained value (if Ok), then returns the unmodified Result.
+     * @param f A function to apply to the Ok value.
+     * @returns The original Result.
+     *
+     * Usage Example:
+     * const result = Ok(5);
+     * result.inspect(x => console.log(`Value: ${x}`));
+     */
+    inspect(f: (val: T) => void): Result<T, E>;
+    /**
+     * Applies a function to the contained error (if Err), then returns the unmodified Result.
+     * @param f A function to apply to the Err value.
+     * @returns The original Result.
+     *
+     * Usage Example:
+     * const result = Err("Error");
+     * result.inspect_err(e => console.log(`Error: ${e}`));
+     */
+    inspect_err(f: (val: E) => void): Result<T, E>;
+    /**
+     * Returns `res` if the result is Ok, otherwise returns the Err value of `self`.
+     * @param res The result to return if `self` is Ok.
+     * @returns Either `res` or the original Err.
+     *
+     * Usage Example:
+     * const result = Ok(5);
+     * const other = Ok("Hello");
+     * const finalResult = result.and(other); // Ok("Hello")
+     */
+    and<U>(res: Result<U, E>): Result<U, E>;
+    /**
+     * Calls `fn` if the result is Ok, otherwise returns the Err value of `self`.
+     * @param fn A function to apply to the Ok value.
+     * @returns The result of `fn` if the original result is Ok, otherwise the Err.
+     *
+     * Usage Example:
+     * const result = Ok(5);
+     * const finalResult = result.and_then(x => Ok(x * 2)); // Ok(10)
+     */
+    and_then<U>(fn: (arg: T) => Result<U, E>): Result<U, E>;
+    /**
+     * Returns `res` if the result is Err, otherwise returns the Ok value of `self`.
+     * @param res The result to return if `self` is Err.
+     * @returns Either `res` or the original Ok.
+     *
+     * Usage Example:
+     * const result = Err("Error");
+     * const other = Ok(5);
+     * const finalResult = result.or(other); // Ok(5)
+     */
+    or<U>(res: Result<U, E>): Result<U, E>;
+    /**
+     * Calls `fn` if the result is Err, otherwise returns the Ok value of `self`.
+     * @param fn A function to apply to the Err value.
+     * @returns The result of `fn` if the original result is Err, otherwise the Ok.
+     *
+     * Usage Example:
+     * const result = Err("Error");
+     * const finalResult = result.or_else(e => Ok(`Handled ${e}`)); // Ok("Handled Error")
+     */
+    or_else<U>(fn: (arg: E) => Result<T, U>): Result<T, U>;
+    /**
+     * Returns the contained Ok value or a provided default.
+     * @param defaultVal The default value to return if the result is Err.
+     * @returns The Ok value or the default.
+     *
+     * Usage Example:
+     * const result = Ok(5);
+     * console.log(result.unwrap_or(0)); // 5
+     *
+     * const result = Err("Error");
+     * console.log(result.unwrap_or(0)); // 0
+     */
+    unwrap_or(defaultVal: T): T;
+    /**
+     * Returns the contained Ok value or computes it from a function.
+     * @param fn A function to compute the default value if the result is Err.
+     * @returns The Ok value or the computed one.
+     *
+     * Usage Example:
+     * const result = Err("Error");
+     * console.log(result.unwrap_or_else(() => 5)); // 5
+     */
+    unwrap_or_else(fn: (arg: E) => T): T;
+}
+type UnwrapResult<T> = T extends Result<infer U, any> ? U : T;
+export interface IResultIteration<T, E> extends IResultCore<T, E> {
+    /**
+     * Returns an iterator over the potentially contained value.
+     * @returns An iterator which yields the contained value if it is `ResultOk<T, E>`.
+     *
+     * Usage Example:
+     * const okResult = Ok(5);
+     * for (const value of okResult.iter()) {
+     *   console.log(value); // prints 5
+     * }
+     *
+     * const errResult = Err(new Error("error"));
+     * for (const value of errResult.iter()) {
+     *   // This block will not be executed.
+     * }
+     */
+    iter(): IterableIterator<T>;
+    /**
+     * Flattens a nested `Result` if the contained value is itself a `Result`.
+     * @returns A single-layer `Result`, by stripping one layer of `Result` container.
+     *
+     * Usage Example:
+     * const nestedOk = Ok(Ok(5));
+     * const flattened = nestedOk.flatten(); // Results in Ok(5)
+     *
+     * const nestedErr = Ok(Err(new Error("error")));
+     * const flattenedError = nestedErr.flatten(); // Results in Err(new Error("error"))
+     */
+    flatten(): Result<UnwrapResult<T>, E>;
+}
+export interface IResult<T, E> extends IResultCore<T, E>, IResultExt<T, E>, IResultIteration<T, E> {
+}
+export declare const isResultOk: <T, E>(val: any) => val is ResultOk<T, E>;
+export declare const isResultErr: <T, E>(val: any) => val is ResultErr<T, E>;
+export declare class ResultOk<T, E> implements IResult<T, E> {
+    readonly value: T;
+    private readonly _tag;
+    private readonly _T;
+    private readonly _E;
+    constructor(value: T);
+    is_ok(): this is ResultOk<T, E>;
+    is_err(): this is never;
+    is_ok_and(f: (value: T) => boolean): boolean;
+    is_err_and(_f: (value: E) => boolean): boolean;
+    ok(): Option<T>;
+    err(): Option<E>;
+    map<U>(fn: (arg: T) => U): Result<U, E>;
+    map_or<U>(_d: U, f: (arg: T) => U): U;
+    map_or_else<U>(_d: (e: E) => U, f: (arg: T) => U): U;
+    map_err<U>(_fn: (arg: E) => U): Result<T, U>;
+    inspect(f: (val: T) => void): Result<T, E>;
+    inspect_err(_f: (val: E) => void): Result<T, E>;
+    iter(): IterableIterator<T>;
+    expect(_msg: string): T;
+    unwrap(): T;
+    expect_err(msg: string): E;
+    unwrap_err(): never;
+    and<U>(res: Result<U, E>): Result<U, E>;
+    and_then<U>(fn: (arg: T) => Result<U, E>): Result<U, E>;
+    or<U>(_res: Result<U, E>): Result<U, E>;
+    or_else<U>(fn: (arg: E) => Result<T, U>): Result<T, U>;
+    unwrap_or(_optb: T): T;
+    unwrap_or_else(_fn: (arg: E) => T): T;
+    flatten(): Result<UnwrapResult<T>, E>;
+    into_ok(): T;
+    into_err(): never;
+    transmute(): Result<T, never>;
+}
+export declare class ResultErr<T, E> implements IResult<T, E> {
+    readonly value: E;
+    private readonly _tag;
+    private readonly _T;
+    private readonly _E;
+    constructor(value: E);
+    is_ok(): this is never;
+    is_err(): this is ResultErr<T, E>;
+    is_ok_and(_f: (value: T) => boolean): boolean;
+    is_err_and(f: (value: E) => boolean): boolean;
+    ok(): Option<T>;
+    err(): Option<E>;
+    map<U>(_fn: (arg: T) => U): Result<U, E>;
+    map_or<U>(d: U, _f: (arg: T) => U): U;
+    map_or_else<U>(d: (e: E) => U, _f: (arg: T) => U): U;
+    map_err<U>(fn: (arg: E) => U): Result<T, U>;
+    inspect(_f: (val: T) => void): Result<T, E>;
+    inspect_err(f: (val: E) => void): Result<T, E>;
+    iter(): IterableIterator<T>;
+    expect(msg: string): never;
+    unwrap(): never;
+    expect_err(_msg: string): E;
+    unwrap_err(): E;
+    and<U>(_res: Result<U, E>): Result<U, E>;
+    and_then<U>(_fn: (arg: T) => Result<U, E>): Result<U, E>;
+    or<U>(res: Result<U, E>): Result<U, E>;
+    or_else<U>(fn: (arg: E) => Result<T, U>): Result<T, U>;
+    unwrap_or(optb: T): T;
+    unwrap_or_else(fn: (arg: E) => T): T;
+    flatten(): Result<UnwrapResult<T>, E>;
+    into_ok(): T;
+    into_err(): E;
+    transmute(): Result<never, E>;
+}
+export declare const Ok: <T, E>(val: T) => Result<T, never>;
+export declare const Err: <T, E>(val: E) => Result<never, E>;
+export declare const try_catch: <T, E = Error>(fn: () => T) => Result<T, E>;
+export declare const result_from_promise: <T, E = Error>(val: Promise<T>) => Promise<Result<T, E>>;
+export {};

package/dist/result.js

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.result_from_promise = exports.try_catch = exports.Err = exports.Ok = exports.ResultErr = exports.ResultOk = exports.isResultErr = exports.isResultOk = void 0;
+const option_1 = require("./option");
+const isResultOk = (val) => {
+    return val instanceof ResultOk;
+};
+exports.isResultOk = isResultOk;
+const isResultErr = (val) => {
+    return val instanceof ResultErr;
+};
+exports.isResultErr = isResultErr;
+class ResultOk {
+    constructor(value) {
+        this.value = value;
+        this._tag = 'Ok';
+    }
+    is_ok() {
+        return true;
+    }
+    is_err() {
+        return false;
+    }
+    is_ok_and(f) {
+        return f(this.value);
+    }
+    is_err_and(_f) {
+        return false;
+    }
+    ok() {
+        return (0, option_1.Some)(this.value);
+    }
+    err() {
+        return (0, option_1.None)();
+    }
+    map(fn) {
+        return new ResultOk(fn(this.value));
+    }
+    map_or(_d, f) {
+        return f(this.value);
+    }
+    map_or_else(_d, f) {
+        return f(this.value);
+    }
+    map_err(_fn) {
+        return this;
+    }
+    inspect(f) {
+        f(this.value);
+        return this;
+    }
+    inspect_err(_f) {
+        return this;
+    }
+    iter() {
+        return [this.value][Symbol.iterator]();
+    }
+    expect(_msg) {
+        return this.value;
+    }
+    unwrap() {
+        return this.value;
+    }
+    //unwrap_or_default(): T {
+    //    ! not implemented
+    //}
+    expect_err(msg) {
+        throw new Error(msg);
+    }
+    unwrap_err() {
+        throw new Error('Called Result.unwrap_err() on an Ok value: ' + this.value);
+    }
+    and(res) {
+        return res;
+    }
+    and_then(fn) {
+        return fn(this.value);
+    }
+    or(_res) {
+        return this;
+    }
+    or_else(fn) {
+        return this;
+    }
+    unwrap_or(_optb) {
+        return this.value;
+    }
+    unwrap_or_else(_fn) {
+        return this.value;
+    }
+    flatten() {
+        if (this.value instanceof ResultOk || this.value instanceof ResultErr) {
+            return this.value;
+        }
+        else {
+            // This case should not happen if T is always a Result,
+            // but it's here to satisfy TypeScript's type checker.
+            return new ResultOk(this.value);
+        }
+    }
+    into_ok() {
+        return this.value;
+    }
+    into_err() {
+        throw new Error('Called Result.into_err() on an Ok value: ' + this.value);
+    }
+    transmute() {
+        return this;
+    }
+}
+exports.ResultOk = ResultOk;
+class ResultErr {
+    constructor(value) {
+        this.value = value;
+        this._tag = 'Err';
+    }
+    is_ok() {
+        return false;
+    }
+    is_err() {
+        return true;
+    }
+    is_ok_and(_f) {
+        return false;
+    }
+    is_err_and(f) {
+        return f(this.value);
+    }
+    ok() {
+        return (0, option_1.None)();
+    }
+    err() {
+        return (0, option_1.Some)(this.value);
+    }
+    map(_fn) {
+        return this;
+    }
+    map_or(d, _f) {
+        return d;
+    }
+    map_or_else(d, _f) {
+        return d(this.value);
+    }
+    map_err(fn) {
+        return new ResultErr(fn(this.value));
+    }
+    inspect(_f) {
+        return this;
+    }
+    inspect_err(f) {
+        f(this.value);
+        return this;
+    }
+    iter() {
+        return [][Symbol.iterator]();
+    }
+    expect(msg) {
+        throw new Error(msg);
+    }
+    unwrap() {
+        throw new Error('Called Result.unwrap() on an Err value: ' + this.value);
+    }
+    //unwrap_or_default(): never {
+    //    // ! not implemented
+    //}
+    expect_err(_msg) {
+        return this.value;
+    }
+    unwrap_err() {
+        return this.value;
+    }
+    and(_res) {
+        return this;
+    }
+    and_then(_fn) {
+        return this;
+    }
+    or(res) {
+        return res;
+    }
+    or_else(fn) {
+        return fn(this.value);
+    }
+    unwrap_or(optb) {
+        return optb;
+    }
+    unwrap_or_else(fn) {
+        return fn(this.value);
+    }
+    flatten() {
+        return new ResultErr(this.value);
+    }
+    into_ok() {
+        throw new Error('Called Result.into_ok() on an Err value: ' + this.value);
+    }
+    into_err() {
+        return this.value;
+    }
+    transmute() {
+        return this;
+    }
+}
+exports.ResultErr = ResultErr;
+const Ok = (val) => {
+    return new ResultOk(val);
+};
+exports.Ok = Ok;
+const Err = (val) => {
+    return new ResultErr(val);
+};
+exports.Err = Err;
+const try_catch = (fn) => {
+    try {
+        return (0, exports.Ok)(fn());
+        // @ts-ignore (error is nominally of type any / unknown, not Error)
+    }
+    catch (error) {
+        return (0, exports.Err)(error);
+    }
+};
+exports.try_catch = try_catch;
+const result_from_promise = async (val) => {
+    try {
+        return new ResultOk(await val);
+    }
+    catch (error) {
+        return new ResultErr(error);
+    }
+};
+exports.result_from_promise = result_from_promise;
+//# sourceMappingURL=result.js.map

package/dist/result.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"result.js","sourceRoot":"","sources":["../src/result.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,19 +1,20 @@
 {
-    "name": "rsult",
-    "version": "1.2.0",
-    "description": "",
-    "main": "src/lib.ts",
-    "repository": "https://github.com/indicium-ag/rsult",
-    "scripts": {
-        "test": "echo \"Error: no test specified\" && exit 1"
-    },
-    "keywords": [],
-    "author": "Kenan Sulayman <kenan@sly.mn>",
-    "license": "MIT",
-    "devDependencies": {
-        "@swc/core": "^1.4.12",
-        "@swc/jest": "^0.2.36",
-        "@types/jest": "^29.5.12",
-        "jest": "^29.7.0"
-    }
+  "name": "rsult",
+  "version": "1.4.0",
+  "description": "",
+  "main": "dist/lib.js",
+  "types": "dist/lib.d.ts",
+  "repository": "https://github.com/indicium-ag/rsult",
+  "keywords": [],
+  "author": "Kenan Sulayman <kenan@sly.mn>",
+  "license": "MIT",
+  "devDependencies": {
+    "@swc/core": "^1.4.12",
+    "@swc/jest": "^0.2.36",
+    "@types/jest": "^29.5.12",
+    "jest": "^29.7.0"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  }
 }

package/src/option.ts

@@ -429,7 +429,7 @@ export class OptionNone<T> implements IOption<T> {
         throw new Error(msg);
     }
 
-    map<U>(_fn: (arg: any) => U): Option<U> {
+    map<U>(_fn: (arg: T) => U): Option<U> {
         return this as any;
     }
 
@@ -441,7 +441,7 @@ export class OptionNone<T> implements IOption<T> {
         return this as any;
     }
 
-    and_then<U>(_fn: (arg: any) => Option<U>): Option<U> {
+    and_then<U>(_fn: (arg: T) => Option<U>): Option<U> {
         return this as any;
     }
 
@@ -465,11 +465,11 @@ export class OptionNone<T> implements IOption<T> {
         throw new Error('Called Option.unwrap() on a None value');
     }
 
-    unwrap_or(optb: any): any {
+    unwrap_or(optb: T): T {
         return optb;
     }
 
-    unwrap_or_else(fn: () => any): any {
+    unwrap_or_else(fn: () => T): T {
         return fn();
     }
 

package/tsconfig.json

@@ -11,7 +11,6 @@
         "allowJs": false,
         "moduleResolution": "node",
         "forceConsistentCasingInFileNames": true,
-        "emitDeclarationOnly": true,
         "noImplicitReturns": true,
         "noImplicitThis": true,
         "noImplicitAny": true,