feat: add unwrapOrElse

Author: deebloo

src/lib/result.test.ts

@@ -25,6 +25,16 @@ describe("Result", () => {
       assert.strictEqual(result.unwrapOr("default"), "original");
     });
 
+    it("should not call unwrapOrElse when Ok", () => {
+      const result = new Ok("value");
+
+      const output = result.unwrapOrElse(() => {
+        return "fallback";
+      });
+
+      assert.strictEqual(output, "value");
+    });
+
     it("should return value from expect when Ok", () => {
       const result = new Ok("test");
 
@@ -39,6 +49,15 @@ describe("Result", () => {
       });
     });
 
+    it("should include custom message in expectErr error", () => {
+      const result = new Ok("ok");
+
+      assert.throws(
+        () => result.expectErr("expected error"),
+        (err) => err instanceof Error && err.message.includes("expected error"),
+      );
+    });
+
     it("should map Ok value correctly", () => {
       const result = new Ok(5);
       const mapped = result.map((x) => x * 2);
@@ -116,6 +135,16 @@ describe("Result", () => {
       assert.strictEqual(result.unwrapOr("default"), "default");
     });
 
+    it("should call unwrapOrElse with error when Err", () => {
+      const result = new Err("missing");
+
+      const output = result.unwrapOrElse((err) => {
+        return "fallback";
+      });
+
+      assert.strictEqual(output, "fallback");
+    });
+
     it("should throw when expect is called on Err", () => {
       const result = new Err("test error");
 
@@ -138,6 +167,12 @@ describe("Result", () => {
       assert.strictEqual(result.expectErr("should not throw"), "test error");
     });
 
+    it("should ignore message when expectErr is called on Err", () => {
+      const result = new Err("original");
+
+      assert.strictEqual(result.expectErr("ignored"), "original");
+    });
+
     it("should return Err when map is called on Err", () => {
       const result = new Err("error") as Result<number, string>;
       const mapped = result.map((x) => x * 2);

src/lib/result.ts

@@ -1,8 +1,9 @@
 // BASELINE CODE FORKED FROM https://github.com/deebloo/ts-results
 import { toString, wait } from "./util.js";
 
-interface BaseResult<T, E>
-  extends Iterable<T extends Iterable<infer U> ? U : never> {
+interface BaseResult<T, E> extends Iterable<
+  T extends Iterable<infer U> ? U : never
+> {
   /** `true` when the result is Ok */ readonly ok: boolean;
   /** `true` when the result is Err */ readonly err: boolean;
 
@@ -34,6 +35,13 @@ interface BaseResult<T, E>
    */
   unwrapOr<T2 extends T>(val: T2): T | T2;
 
+  /**
+   * Returns the contained `Ok` value or computes a default from the `Err` value.
+   *
+   * (This is the `unwrap_or_else` in rust)
+   */
+  unwrapOrElse<T2 extends T>(op: (err: E) => T2): T | T2;
+
   /**
    * Calls `mapper` if the result is `Ok`, otherwise returns the `Err` value of self.
    * This function can be used for control flow based on `Result` values.
@@ -103,6 +111,10 @@ export class Err<E> implements BaseResult<never, E> {
     return val;
   }
 
+  unwrapOrElse<T2>(op: (err: E) => T2): T2 {
+    return op(this.val);
+  }
+
   expect(msg: string): never {
     throw new Error(`${msg} - Error: ${toString(this.val)}\n${this.#stack}`);
   }
@@ -113,7 +125,7 @@ export class Err<E> implements BaseResult<never, E> {
 
   unwrap(): never {
     throw new Error(
-      `Tried to unwrap Error: ${toString(this.val)}\n${this.#stack}`
+      `Tried to unwrap Error: ${toString(this.val)}\n${this.#stack}`,
     );
   }
 
@@ -165,6 +177,10 @@ export class Ok<T> implements BaseResult<T, never> {
     return this.val;
   }
 
+  unwrapOrElse(_op: (err: never) => unknown): T {
+    return this.val;
+  }
+
   expect(_msg: string): T {
     return this.val;
   }
@@ -225,7 +241,7 @@ export namespace Result {
    * @param op The operation function
    */
   export async function wrapAsync<T, E = unknown>(
-    op: () => Promise<T>
+    op: () => Promise<T>,
   ): Promise<Result<T, E>> {
     try {
       return op()
@@ -244,7 +260,7 @@ export namespace Result {
    */
   export async function attempt<T, E>(
     cb: () => Promise<Result<T, E>>,
-    { attempts = 3, timeout = 1000, backoff = 0.5 } = {}
+    { attempts = 3, timeout = 1000, backoff = 0.5 } = {},
   ) {
     let count = 1;
     let waitTime = timeout;
@@ -272,7 +288,7 @@ export namespace Result {
   }
 
   export function isResult<T = any, E = any>(
-    val: unknown
+    val: unknown,
   ): val is Result<T, E> {
     return val instanceof Err || val instanceof Ok;
   }