@madkarma/result 1.0.2 → 2.0.0

package/README.md

@@ -2,6 +2,10 @@
 
 Rust's Result type, for TypeScript.
 
+Inspired by [this video](https://www.youtube.com/watch?v=ovnyeq-Xxrc) by Web Dev Simplified and [vultix/ts-results](https://github.com/vultix/ts-results).
+
+This library mimics the Rust `Result` enum and includes its chainable methods adapted for TypeScript. For full documentation on the available methods, please refer to the [official Rust Result documentation](https://doc.rust-lang.org/std/result/enum.Result.html) (or read the JSDocs directly in your editor).
+
 ## Installation
 
 ```bash
@@ -19,40 +23,49 @@ yarn add @madkarma/result
 ```typescript
 import { Ok, Err } from '@madkarma/result';
 
-const getUser = (id: number) => {
-    if (typeof id !== 'number')
-        return Err({ code: 'NOT_A_NUMBER', message: 'ID must be a number' });
+const parseUserId = (id: string) => {
+    const parsed = parseInt(id, 10);
+    if (isNaN(parsed))
+        return Err({
+            code: 'INVALID_INPUT',
+            message: 'ID must be a valid number'
+        });
 
-    if (id < 0)
+    if (parsed <= 0)
         return Err({ code: 'INVALID_ID', message: 'ID must be positive' });
 
-    if (id === 0) return Err({ code: 'NOT_FOUND', message: 'User not found' });
+    return Ok(parsed);
+};
+
+const fetchUser = (id: number) => {
+    if (id === 13) return Err({ code: 'NOT_FOUND', message: 'User not found' });
 
-    return Ok({ id, name: 'Alice' });
+    return Ok({ id, name: 'Alice', role: 'admin' });
 };
 
-const [user, error] = getUser(10);
+// Processing an input by chaining methods
+const { value: user, error } = parseUserId('10')
+    .map((id) => id + 3) // Transform the Ok value (10 -> 13)
+    .andThen(fetchUser); // Chain operations that return another Result
 
-if (error)
+if (error) {
     switch (error.code) {
-        case 'NOT_A_NUMBER':
-            console.error(error.message);
-            break;
+        case 'INVALID_INPUT':
         case 'INVALID_ID':
-            console.error(error.message);
+            console.error(`Validation Error: ${error.message}`);
             break;
         case 'NOT_FOUND':
-            console.error(error.message);
+            console.error(`Database Error: ${error.message}`);
             break;
     }
-else console.log(`Hello, ${user.name}!`);
+} else {
+    console.log(`Welcome, ${user.role} ${user.name}!`);
+}
 ```
 
-### How this differs from Rust
-
-Instead of Rust's `match` expressions, check `[value, error]` directly and use a JavaScript `switch` on `error.code` to emulate pattern matching.
+## How this differs from Rust
 
-This library is essentially a type-safe helper for TypeScript developers. It does **not** include any of the chainable methods found in the actual Rust `Result` type. Its sole purpose is to enforce explicit error handling through control flow.
+Instead of Rust's `match` expressions, check `{ value, error }` directly and use a `switch` on `error.code` to emulate pattern matching.
 
 ## Contributing
 

package/dist/index.d.ts

@@ -1,58 +1,2 @@
-/**
- * `Result<T, E>` is the type used for returning and propagating errors.
- *
- * It is a type with the parameters, `Ok(T)`, representing success and containing a value,
- * and `Err(E)`, representing error and containing an error value.
- *
- * Functions return `Result` whenever errors are expected and recoverable.
- *
- * The error type `E` must be an object that contains a `code` property of type `string`.
- *
- * @example
- * ```typescript
- * const divide = (a: number, b: number) => {
- *   if (b === 0) return Err({ code: 'DIVIDE_BY_ZERO' });
- *   return Ok(a / b);
- * }
- *
- * const [value, error] = divide(10, 2);
- * if (error) console.error(error.code);
- * else console.log(value);
- * ```
- *
- * @see https://www.youtube.com/watch?v=ovnyeq-Xxrc
- * @template T - Contains the success value.
- * @template E - Contains the error value. Must have a `code` property of type `string`.
- */
-export type Result<T, E extends {
-    code: string;
-}> = [T, null] | [null, E];
-/**
- * Contains the success value.
- *
- * @example
- * ```typescript
- * const result = Ok(42);
- * ```
- *
- * @see https://www.youtube.com/watch?v=ovnyeq-Xxrc
- * @param value - The value to wrap in a successful result.
- * @returns A `Result` representing a successful outcome.
- */
-export declare const Ok: <T>(value: T) => Result<T, never>;
-/**
- * Contains the error value.
- *
- * @example
- * ```typescript
- * const result = Err({ code: 'NOT_FOUND' });
- * ```
- *
- * @see https://www.youtube.com/watch?v=ovnyeq-Xxrc
- * @param error - The error to wrap in a failed result. Must have a `code` property of type `string`.
- * @returns A `Result` representing a failed outcome.
- */
-export declare const Err: <const C extends string, E extends {
-    code: C;
-}>(error: E) => Result<never, E>;
+export * from './result';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,SAAS;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;AAE1E;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,EAAE,GAAI,CAAC,EAAE,OAAO,CAAC,KAAG,MAAM,CAAC,CAAC,EAAE,KAAK,CAAkB,CAAC;AAEnE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,GAAG,GAAI,KAAK,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS;IAAE,IAAI,EAAE,CAAC,CAAA;CAAE,EAC7D,OAAO,CAAC,KACT,MAAM,CAAC,KAAK,EAAE,CAAC,CAOjB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC"}

package/dist/index.js

@@ -1,31 +1,2 @@
-/**
- * Contains the success value.
- *
- * @example
- * ```typescript
- * const result = Ok(42);
- * ```
- *
- * @see https://www.youtube.com/watch?v=ovnyeq-Xxrc
- * @param value - The value to wrap in a successful result.
- * @returns A `Result` representing a successful outcome.
- */
-export const Ok = (value) => [value, null];
-/**
- * Contains the error value.
- *
- * @example
- * ```typescript
- * const result = Err({ code: 'NOT_FOUND' });
- * ```
- *
- * @see https://www.youtube.com/watch?v=ovnyeq-Xxrc
- * @param error - The error to wrap in a failed result. Must have a `code` property of type `string`.
- * @returns A `Result` representing a failed outcome.
- */
-export const Err = (error) => {
-    if (typeof error.code !== 'string')
-        throw new TypeError('Error object must have a code property of type string');
-    return [null, error];
-};
+export * from './result';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AA4BA;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,EAAE,GAAG,CAAI,KAAQ,EAAoB,EAAE,CAAC,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;AAEnE;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,GAAG,GAAG,CACf,KAAQ,EACQ,EAAE;IAClB,IAAI,OAAO,KAAK,CAAC,IAAI,KAAK,QAAQ;QAC9B,MAAM,IAAI,SAAS,CACf,uDAAuD,CAC1D,CAAC;IAEN,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;AACzB,CAAC,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC"}

package/dist/result.d.ts

@@ -0,0 +1,196 @@
+/**
+ * The base interface for all errors returned by a `Result`.
+ * It requires a `code` property which can be used to identify the error type.
+ */
+export interface ResultError {
+    code: string;
+}
+/**
+ * Represents a successful `Result` containing a value of type `T`.
+ */
+export type OkResult<T, E extends ResultError> = {
+    readonly value: T;
+    readonly error: null;
+} & ResultMethods<T, E>;
+/**
+ * Represents a failed `Result` containing an error of type `E`.
+ */
+export type ErrResult<T, E extends ResultError> = {
+    readonly value: null;
+    readonly error: E;
+} & ResultMethods<T, E>;
+/**
+ * `Result<T, E>` is the type used for returning and propagating errors.
+ *
+ * It is a type with the parameters, `Ok(T)`, representing success and containing a value,
+ * and `Err(E)`, representing error and containing an error value.
+ *
+ * Functions return `Result` whenever errors are expected and recoverable.
+ *
+ * The error type `E` must extend `ResultError` which contains a `code` property of type `string`.
+ *
+ * @example
+ * ```typescript
+ * const divide = (a: number, b: number) => {
+ *   if (b === 0) return Err({ code: 'DIVIDE_BY_ZERO' });
+ *   return Ok(a / b);
+ * }
+ *
+ * const { value, error } = divide(10, 2);
+ * if (error) console.error(error.code);
+ * else console.log(value);
+ * ```
+ *
+ * @see https://www.youtube.com/watch?v=ovnyeq-Xxrc
+ * @template T - Contains the success value.
+ * @template E - Contains the error value. Must have a `code` property of type `string`.
+ */
+export type Result<T, E extends ResultError> = OkResult<T, E> | ErrResult<T, E>;
+interface ResultMethods<T, E extends ResultError> {
+    /**
+     * Returns `true` if the result is `Ok`.
+     */
+    isOk(): this is OkResult<T, E>;
+    /**
+     * Returns `true` if the result is `Ok` and the value inside of it matches a predicate.
+     */
+    isOkAnd(fn: (val: T) => boolean): this is OkResult<T, E>;
+    /**
+     * Returns `true` if the result is `Err`.
+     */
+    isErr(): this is ErrResult<T, E>;
+    /**
+     * Returns `true` if the result is `Err` and the value inside of it matches a predicate.
+     */
+    isErrAnd(fn: (err: E) => boolean): this is ErrResult<T, E>;
+    /**
+     * Maps a `Result<T, E>` to `Result<U, E>` by applying a function to a contained `Ok` value, leaving an `Err` value untouched.
+     *
+     * This function can be used to compose the results of two functions.
+     */
+    map<U>(fn: (val: T) => U): Result<U, E>;
+    /**
+     * Returns the provided default (if `Err`), or applies a function to the contained value (if `Ok`).
+     *
+     * Arguments passed to `mapOr` are eagerly evaluated; if you are passing the result of a function call, it is recommended to use `mapOrElse`, which is lazily evaluated.
+     */
+    mapOr<U>(fallback: U, fn: (val: T) => U): U;
+    /**
+     * Maps a `Result<T, E>` to `U` by applying fallback function `fallbackFn` to a contained `Err` value, or function `fn` to a contained `Ok` value.
+     *
+     * This function can be used to unpack a successful result while handling an error.
+     */
+    mapOrElse<U>(fallbackFn: (err: E) => U, fn: (val: T) => U): U;
+    /**
+     * Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a contained `Err` value, leaving an `Ok` value untouched.
+     *
+     * This function can be used to pass through a successful result while handling an error.
+     */
+    mapErr<F extends ResultError>(fn: (err: E) => F): Result<T, F>;
+    /**
+     * Calls a function with a reference to the contained value if `Ok`.
+     *
+     * Returns the original result.
+     */
+    inspect(fn: (val: T) => void): Result<T, E>;
+    /**
+     * Calls a function with a reference to the contained value if `Err`.
+     *
+     * Returns the original result.
+     */
+    inspectErr(fn: (err: E) => void): Result<T, E>;
+    /**
+     * Returns an iterator over the possibly contained value.
+     *
+     * The iterator yields one value if the result is `Result::Ok`, otherwise none.
+     */
+    iter(): Iterable<T>;
+    /**
+     * Returns the contained `Ok` value, consuming the `self` value.
+     *
+     * @throws Throws if the value is an `Err`, with an error message including the passed message, and the content of the `Err`.
+     */
+    expect(msg: string): T;
+    /**
+     * Returns the contained `Ok` value, consuming the `self` value.
+     *
+     * @throws Throws if the value is an `Err`, with an error message provided by the `Err`'s value.
+     */
+    unwrap(): T;
+    /**
+     * Returns the contained `Err` value, consuming the `self` value.
+     *
+     * @throws Throws if the value is an `Ok`, with an error message including the passed message, and the content of the `Ok`.
+     */
+    expectErr(msg: string): E;
+    /**
+     * Returns the contained `Err` value, consuming the `self` value.
+     *
+     * @throws Throws if the value is an `Ok`, with a custom error message provided by the `Ok`'s value.
+     */
+    unwrapErr(): E;
+    /**
+     * Returns `res` if the result is `Ok`, otherwise returns the `Err` value of `self`.
+     *
+     * Arguments passed to `and` are eagerly evaluated; if you are passing the result of a function call, it is recommended to use `andThen`, which is lazily evaluated.
+     */
+    and<U, E2 extends ResultError>(res: Result<U, E2>): Result<U, E | E2>;
+    /**
+     * Calls `fn` if the result is `Ok`, otherwise returns the `Err` value of `self`.
+     *
+     * This function can be used for control flow based on `Result` values.
+     */
+    andThen<U, F extends ResultError>(fn: (val: T) => Result<U, F>): Result<U, E | F>;
+    /**
+     * Returns `res` if the result is `Err`, otherwise returns the `Ok` value of `self`.
+     *
+     * Arguments passed to `or` are eagerly evaluated; if you are passing the result of a function call, it is recommended to use `orElse`, which is lazily evaluated.
+     */
+    or<T2, F extends ResultError>(res: Result<T2, F>): Result<T | T2, F>;
+    /**
+     * Calls `fn` if the result is `Err`, otherwise returns the `Ok` value of `self`.
+     *
+     * This function can be used for control flow based on result values.
+     */
+    orElse<T2, F extends ResultError>(fn: (err: E) => Result<T2, F>): Result<T | T2, F>;
+    /**
+     * Returns the contained `Ok` value or a provided default.
+     *
+     * Arguments passed to `unwrapOr` are eagerly evaluated; if you are passing the result of a function call, it is recommended to use `unwrapOrElse`, which is lazily evaluated.
+     */
+    unwrapOr<T2>(fallback: T2): T | T2;
+    /**
+     * Returns the contained `Ok` value or computes it from a closure.
+     */
+    unwrapOrElse<T2>(fn: (err: E) => T2): T | T2;
+}
+/**
+ * Contains the success value.
+ *
+ * @example
+ * ```typescript
+ * const { value } = Ok(42);
+ * ```
+ *
+ * @see https://www.youtube.com/watch?v=ovnyeq-Xxrc
+ * @param value - The value to wrap in a successful result.
+ * @returns A `Result` representing a successful outcome.
+ */
+export declare const Ok: <T, E extends ResultError = never>(value: T) => Result<T, E>;
+/**
+ * Contains the error value.
+ *
+ * @example
+ * ```typescript
+ * const { error } = Err({ code: 'NOT_FOUND' });
+ * ```
+ *
+ * @see https://www.youtube.com/watch?v=ovnyeq-Xxrc
+ * @param error - The error to wrap in a failed result. Must have a `code` property of type `string`.
+ * @returns A `Result` representing a failed outcome.
+ */
+export declare const Err: <const C extends string, E extends ResultError & {
+    code: C;
+}>(error: E) => Result<never, E>;
+export {};
+//# sourceMappingURL=result.d.ts.map

package/dist/result.d.ts.map

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

package/dist/result.js

@@ -0,0 +1,145 @@
+class ResultImpl {
+    // will error at runtime if trying to access # fields
+    #value;
+    #error;
+    constructor(value, error) {
+        this.#value = value;
+        this.#error = error;
+    }
+    // will prevent mutation at runtime
+    get value() {
+        return this.#value;
+    }
+    // will prevent mutation at runtime
+    get error() {
+        return this.#error;
+    }
+    isOk() {
+        return this.error === null;
+    }
+    isOkAnd(fn) {
+        return this.isOk() && fn(this.value);
+    }
+    isErr() {
+        return this.error !== null;
+    }
+    isErrAnd(fn) {
+        return this.isErr() && fn(this.error);
+    }
+    map(fn) {
+        if (this.isErr()) {
+            return new ResultImpl(null, this.error);
+        }
+        return new ResultImpl(fn(this.value), null);
+    }
+    mapOr(fallback, fn) {
+        if (this.isErr())
+            return fallback;
+        return fn(this.value);
+    }
+    mapOrElse(fallbackFn, fn) {
+        if (this.isErr())
+            return fallbackFn(this.error);
+        return fn(this.value);
+    }
+    mapErr(fn) {
+        if (this.isErr())
+            return new ResultImpl(null, fn(this.error));
+        return new ResultImpl(this.value, null);
+    }
+    inspect(fn) {
+        if (this.isOk())
+            fn(this.value);
+        return this;
+    }
+    inspectErr(fn) {
+        if (this.isErr())
+            fn(this.error);
+        return this;
+    }
+    *iter() {
+        if (this.isOk())
+            yield this.value;
+    }
+    expect(msg) {
+        if (this.isErr())
+            throw new Error(msg);
+        return this.value;
+    }
+    unwrap() {
+        if (this.error !== null)
+            throw this.error;
+        return this.value;
+    }
+    expectErr(msg) {
+        if (this.isOk())
+            throw new Error(msg);
+        return this.error;
+    }
+    unwrapErr() {
+        if (this.isOk())
+            throw new Error(String(this.value));
+        return this.error;
+    }
+    and(res) {
+        if (this.isOk())
+            return res;
+        return new ResultImpl(null, this.error);
+    }
+    andThen(fn) {
+        if (this.isOk())
+            return fn(this.value);
+        return new ResultImpl(null, this.error);
+    }
+    or(res) {
+        if (this.isErr())
+            return res;
+        return new ResultImpl(this.value, null);
+    }
+    orElse(fn) {
+        if (this.isErr())
+            return fn(this.error);
+        return new ResultImpl(this.value, null);
+    }
+    unwrapOr(fallback) {
+        if (this.isErr())
+            return fallback;
+        return this.value;
+    }
+    unwrapOrElse(fn) {
+        if (this.isErr())
+            return fn(this.error);
+        return this.value;
+    }
+}
+/**
+ * Contains the success value.
+ *
+ * @example
+ * ```typescript
+ * const { value } = Ok(42);
+ * ```
+ *
+ * @see https://www.youtube.com/watch?v=ovnyeq-Xxrc
+ * @param value - The value to wrap in a successful result.
+ * @returns A `Result` representing a successful outcome.
+ */
+export const Ok = (value) => {
+    return new ResultImpl(value, null);
+};
+/**
+ * Contains the error value.
+ *
+ * @example
+ * ```typescript
+ * const { error } = Err({ code: 'NOT_FOUND' });
+ * ```
+ *
+ * @see https://www.youtube.com/watch?v=ovnyeq-Xxrc
+ * @param error - The error to wrap in a failed result. Must have a `code` property of type `string`.
+ * @returns A `Result` representing a failed outcome.
+ */
+export const Err = (error) => {
+    return new ResultImpl(null, error);
+};
+//# 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,10 +1,11 @@
 {
     "name": "@madkarma/result",
-    "version": "1.0.2",
+    "version": "2.0.0",
     "description": "Rust's Result type, for TypeScript",
     "devDependencies": {
         "prettier": "3.8.3",
-        "typescript": "^6.0.3"
+        "typescript": "^6.0.3",
+        "vitest": "^4.1.6"
     },
     "type": "module",
     "exports": {
@@ -18,6 +19,8 @@
         "dist"
     ],
     "scripts": {
+        "test:dev": "vitest watch",
+        "test": "vitest run",
         "build": "tsc",
         "dev": "tsc --watch",
         "format": "prettier --write --ignore-unknown .",