More ergonomic match

.changeset/tall-berries-guess.md

@@ -0,0 +1,5 @@
+---
+"neverthrow": patch
+---
+
+enhance type inferrence of `match`

README.md

@@ -448,10 +448,10 @@ Match callbacks do not necessitate to return a `Result`, however you can return
 
 ```typescript
 class Result<T, E> {
-  match<A>(
+  match<A, B = A>(
     okCallback: (value: T) =>  A,
-    errorCallback: (error: E) =>  A
-  ): A => { ... }
+    errorCallback: (error: E) =>  B
+  ): A | B => { ... }
 }
 ```
 
@@ -1067,10 +1067,10 @@ The difference with `Result.match` is that it always returns a `Promise` because
 
 ```typescript
 class ResultAsync<T, E> {
-  match<A>(
+  match<A, B = A>(
     okCallback: (value: T) =>  A,
-    errorCallback: (error: E) =>  A
-  ): Promise<A> => { ... }
+    errorCallback: (error: E) =>  B
+  ): Promise<A | B> => { ... }
 }
 ```
 

src/result-async.ts

@@ -147,7 +147,7 @@ export class ResultAsync<T, E> implements PromiseLike<Result<T, E>> {
     )
   }
 
-  match<A>(ok: (t: T) => A, _err: (e: E) => A): Promise<A> {
+  match<A, B = A>(ok: (t: T) => A, _err: (e: E) => B): Promise<A | B> {
     return this._promise.then((res) => res.match(ok, _err))
   }
 

src/result.ts

@@ -232,7 +232,7 @@ interface IResult<T, E> {
    * @param ok
    * @param err
    */
-  match<A>(ok: (t: T) => A, err: (e: E) => A): A
+  match<A, B = A>(ok: (t: T) => A, err: (e: E) => B): A | B
 
   /**
    * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
@@ -309,7 +309,7 @@ export class Ok<T, E> implements IResult<T, E> {
   }
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  match<A>(ok: (t: T) => A, _err: (e: E) => A): A {
+  match<A, B = A>(ok: (t: T) => A, _err: (e: E) => B): A | B {
     return ok(this.value)
   }
 
@@ -380,7 +380,7 @@ export class Err<T, E> implements IResult<T, E> {
     return v
   }
 
-  match<A>(_ok: (t: T) => A, err: (e: E) => A): A {
+  match<A, B = A>(_ok: (t: T) => A, err: (e: E) => B): A | B {
     return err(this.error)
   }
 

tests/typecheck-tests.ts

@@ -229,6 +229,54 @@ type CreateTuple<L, V = string> =
     });
   });
 
+  (function describe(_ = 'match') {
+    (function it(_ = 'the type of the arguments match the types of the result') {
+      type OKExpectation = number
+      type ErrExpectation = string
+
+      ok<number, string>(123)
+        .match(
+          (val: OKExpectation): void => void val,
+          (val: ErrExpectation): void => void val,
+        );
+      err<number, string>("123")
+        .match(
+          (val: OKExpectation): void => void val,
+          (val: ErrExpectation): void => void val,
+        );
+    });
+
+    (function it(_ = 'infers the resulting value from match callbacks (same type)') {
+      type Expectation = boolean
+
+      const okResult: Expectation = ok<number, string>(123)
+        .match(
+          (val) => !!val,
+          (val) => !!val,
+        );
+      const errResult: Expectation = err<number, string>('123')
+        .match(
+          (val) => !!val,
+          (val) => !!val,
+        );
+    });
+
+    (function it(_ = 'infers the resulting value from match callbacks (different type)') {
+      type Expectation = boolean | bigint
+
+      const okResult: Expectation = ok<string, number>('123')
+        .match(
+          (val) => !!val,
+          (val) => BigInt(val),
+        );
+      const errResult: Expectation = err<string, number>(123)
+        .match(
+          (val) => !!val,
+          (val) => BigInt(val),
+        );
+    });
+  });
+
   (function describe(_ = 'asyncAndThen') {
     (function it(_ = 'Combines two equal error types (native scalar types)') {
       type Expectation = ResultAsync<unknown, string>