Merge branch 'master' into schniz/remove-maintainer-callout

CHANGELOG.md

@@ -1,5 +1,13 @@
 # neverthrow
 
+## 7.0.1
+
+### Patch Changes
+
+- [#527](https://github.com/supermacro/neverthrow/pull/527) [`2e1f198`](https://github.com/supermacro/neverthrow/commit/2e1f19899800ce5e1164412c6a693cf2f1c40b20) Thanks [@3846masa](https://github.com/3846masa)! - fix: change type definitions to make inferring types of safeTry more strict
+
+- [#497](https://github.com/supermacro/neverthrow/pull/497) [`e06203e`](https://github.com/supermacro/neverthrow/commit/e06203e90b2b64edaa42707cbca8383c9f4765e8) Thanks [@braxtonhall](https://github.com/braxtonhall)! - enhance type inferrence of `match`
+
 ## 7.0.0
 
 ### Major Changes

README.md

@@ -445,10 +445,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 => { ... }
 }
 ```
 
@@ -1064,10 +1064,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> => { ... }
 }
 ```
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "neverthrow",
-  "version": "7.0.0",
+  "version": "7.0.1",
   "description": "Stop throwing errors, and instead return Results!",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",

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>