Merge pull request #2 from Noctua-Technology/feature/all

feat: Result.all

Author: deebloo

README.md

@@ -145,6 +145,23 @@ Notes:
 - `backoff` increases wait time after each retry
 - final failed result is marked with `attempted = true`
 
+## Collecting multiple results
+
+Use `Result.all` to combine an array (or tuple) of Results into a single Result. It returns `Ok` with all values if every result succeeded, or the first `Err` it encounters.
+
+```ts
+const results = Result.all([
+  Result.wrap(() => JSON.parse('{"port":3000}')),
+  Result.wrap(() => JSON.parse('{"host":"localhost"}')),
+]);
+
+if (results.ok) {
+  const [portConfig, hostConfig] = results.val;
+}
+```
+
+Tuple types are fully preserved, so each element's type is inferred independently.
+
 ## Runtime checks
 
 ```ts
@@ -163,6 +180,7 @@ if (Result.isResult(maybe)) {
 - Read values: `unwrap`, `unwrapOr` (value or function), `expect`, `expectErr`
 - Wrappers: `Result.wrap`, `Result.wrapAsync`
 - Retry: `Result.attempt`
+- Collect: `Result.all`
 - Type guard: `Result.isResult`
 
 ## Development

package-lock.json

@@ -25,15 +25,15 @@
       ]
     },
     "test": {
-      "command": "node --test \"./target/**/*.test.js\"",
+      "command": "node --enable-source-maps --test \"./target/**/*.test.js\"",
       "dependencies": [
         "build"
       ]
     }
   },
   "devDependencies": {
     "@types/node": "^24.0.4",
-    "typescript": "^5.9.3",
+    "typescript": "^6.0.0",
     "wireit": "^0.14.12"
   }
 }

package.json

@@ -385,6 +385,45 @@ describe("Result", () => {
     });
   });
 
+  describe("Result.all", () => {
+    it("should return Ok with all values when all results are Ok", () => {
+      const result = Result.all([new Ok(1), new Ok(2), new Ok(3)]);
+
+      assert.ok(result instanceof Ok);
+      assert.deepStrictEqual(result.val, [1, 2, 3]);
+    });
+
+    it("should return the first Err when any result is Err", () => {
+      const result = Result.all([new Ok(1), new Err("boom"), new Ok(3)]);
+
+      assert.ok(result instanceof Err);
+      assert.strictEqual(result.val, "boom");
+    });
+
+    it("should return the first Err and not continue evaluating", () => {
+      const result = Result.all([new Err("first"), new Err("second")]);
+
+      assert.ok(result instanceof Err);
+      assert.strictEqual(result.val, "first");
+    });
+
+    it("should return Ok with an empty array for an empty input", () => {
+      const result = Result.all([]);
+
+      assert.ok(result instanceof Ok);
+      assert.deepStrictEqual(result.val, []);
+    });
+
+    it("should preserve tuple types", () => {
+      const a = new Ok(42) as Result<number, string>;
+      const b = new Ok("hello") as Result<string, string>;
+      const result = Result.all([a, b]);
+
+      assert.ok(result instanceof Ok);
+      assert.deepStrictEqual(result.val, [42, "hello"]);
+    });
+  });
+
   describe("Complex scenarios", () => {
     it("should handle chaining multiple operations", () => {
       const result = new Ok(5)

src/lib/result.test.ts

@@ -89,11 +89,7 @@ export class Err<E> implements BaseResult<never, E> {
     this.val = val;
 
     const stackLines = new Error().stack!.split("\n").slice(2);
-    if (
-      stackLines &&
-      stackLines.length > 0 &&
-      stackLines[0].includes("ErrImpl")
-    ) {
+    if (stackLines.length > 0 && stackLines[0]?.includes("ErrImpl")) {
       stackLines.shift();
     }
 
@@ -281,4 +277,28 @@ export namespace Result {
   ): val is Result<T, E> {
     return val instanceof Err || val instanceof Ok;
   }
+
+  /**
+   * Takes an array (or tuple) of Results and returns an `Ok` containing all
+   * success values in the same shape, or the first `Err` encountered.
+   */
+  export function all<T extends readonly Result<unknown, unknown>[]>(
+    results: [...T],
+  ): Result<
+    { [K in keyof T]: T[K] extends Result<infer U, any> ? U : never },
+    { [K in keyof T]: T[K] extends Result<any, infer F> ? F : never }[number]
+  >;
+  export function all<T, E>(results: Result<T, E>[]): Result<T[], E>;
+  export function all(
+    results: Result<unknown, unknown>[],
+  ): Result<unknown[], unknown> {
+    const values: unknown[] = [];
+    for (const result of results) {
+      if (result.err) {
+        return result;
+      }
+      values.push(result.val);
+    }
+    return new Ok(values);
+  }
 }