feat: OrElse callback should be able to change Ok type

BUILD_SHA

@@ -1 +1 @@
-c2279236936f1c27556aa707d729f7cf991781b4
+3eebd1d3875783ff1f972f8bfac9d810a18d479e

jsr.json

@@ -1,5 +1,5 @@
 {
     "name": "@inaiat/resultar",
-    "version": "0.8.8",
+    "version": "0.9.0",
     "exports": "./src/index.ts"
 }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "resultar",
-  "version": "0.8.8",
+  "version": "0.9.0",
   "description": "Result pattern for typescript",
   "type": "module",
   "packageManager": "[email protected]",

src/index.ts

@@ -1,2 +1,6 @@
-export * from './result.js'
-export * from './result-async.js'
+export {
+  Result, ok, err, fromThrowable, safeTry,
+} from './result.js'
+export {
+  ResultAsync, okAsync, errAsync, fromPromise, fromSafePromise, safeTryAsync, fromThrowableAsync,
+} from './result-async.js'

src/result-async.ts

@@ -204,9 +204,13 @@ export class ResultAsync<T, E> implements PromiseLike<Result<T, E>> {
     )
   }
 
-  orElse<R extends Result<T, unknown>>(f: (e: E) => R): ResultAsync<T, InferErrTypes<R>>
-  orElse<R extends ResultAsync<T, unknown>>(f: (e: E) => R): ResultAsync<T, InferAsyncErrTypes<R>>
-  orElse<A>(f: (e: E) => Result<T, A> | ResultAsync<T, A>): ResultAsync<T, A>
+  orElse<R extends Result<unknown, unknown>>(
+    f: (e: E) => R,
+  ): ResultAsync<InferOkTypes<R> | T, InferErrTypes<R>>
+  orElse<R extends ResultAsync<unknown, unknown>>(
+    f: (e: E) => R,
+  ): ResultAsync<InferAsyncOkTypes<R> | T, InferAsyncErrTypes<R>>
+  orElse<U, A>(f: (e: E) => Result<U, A> | ResultAsync<U, A>): ResultAsync<U | T, A>
   orElse(f: any): any {
     return new ResultAsync(
       this.innerPromise.then(async (res: Result<T, E>) => { // eslint-disable-line @typescript-eslint/no-unsafe-argument

src/result.ts

@@ -1,5 +1,5 @@
 import {
-  CombineResults, CombineResultsWithAllErrorsArray, combineResultList, combineResultListWithAllErrors,
+  CombineResults, CombineResultsWithAllErrorsArray, InferErrTypes, InferOkTypes, combineResultList, combineResultListWithAllErrors,
 } from './utils.js'
 import { ErrorConfig, createResultarError } from './error.js'
 import { ResultAsync, errAsync } from './result-async.js'
@@ -225,8 +225,10 @@ export class Result<T, E> implements Resultable<T, E> {
    * @param f  A function to apply to an `Err` value, leaving `Ok` values
    * untouched.
    */
-  orElse<Y>(f: (t: E) => Result<T, Y>): Result<T, Y>
-  orElse<Y>(f: (t: E) => Result<T, Y>): Result<T, E | Y> {
+  orElse<R extends Result<unknown, unknown>>(
+    f: (e: E) => R,
+  ): Result<InferOkTypes<R> | T, InferErrTypes<R>>
+  orElse<U, A>(f: (e: E) => Result<U, A>): Result<U | T, A> {
     if (this.state.ok) {
       return ok(this.value as Exclude<T, Promise<any>>)
     }

tests/result-test.ts

@@ -1,4 +1,3 @@
-
 /* eslint-disable @typescript-eslint/prefer-promise-reject-errors */
 import { describe, it, mock } from 'node:test'
 import assert, {
@@ -973,6 +972,47 @@ await describe('ResultAsync', async () => {
   })
 })
 
+await describe('OrElse', async () => {
+  const foo = () => okAsync('foo')
+  const bar = () => errAsync(new Error('bar'))
+
+  class FooError extends Error {}
+  class BarError extends Error {}
+  class XooError extends Error {}
+
+  await it('Infer result', async () => {
+    type R = Result<string | number, never>
+    const result: R = await foo().orElse(() => okAsync(1))
+    equal(result._unsafeUnwrap(), 'foo')
+  })
+
+  await it('Set explicit type', async () => {
+    type R = Result<string | boolean, never>
+    const result: R = await foo().orElse<string | boolean, never>(() => okAsync(true))
+    equal(result._unsafeUnwrap(), 'foo')
+  })
+
+  await it('Infer multiples types', async () => {
+    type R = Result<string | undefined, string | Error>
+    const result: R = await bar().orElse(e => {
+      if (e instanceof BarError) {
+        return okAsync(undefined)
+      }
+
+      if (e instanceof FooError) {
+        return okAsync('foo')
+      }
+
+      if (e instanceof XooError) {
+        return errAsync('xoo')
+      }
+
+      return errAsync(e)
+    })
+    deepStrictEqual(result._unsafeUnwrapErr(), new Error('bar'))
+  })
+})
+
 await describe('Utils', async () => {
   await describe('`Result.combine`', async () => {
     await describe('Synchronous `combine`', async () => {