Merge pull request #562 from sharno/safeTry-to-ResultAsync

Return ResultAsync<T, E> from safeTry instead of Promise<Result<T, E>> for better composability

Author: supermacro

.changeset/safeTryAsyncResult.md

@@ -0,0 +1,5 @@
+---
+'neverthrow': minor
+---
+
+change the return type of `safeTry` to be `ResultAsync<T, E>` instead of `Promise<Result<T, E>>` for better composability

src/result.ts

@@ -104,31 +104,26 @@ export function safeTry<
  * `yield* resultAsync.safeUnwrap()` work as Rust's `result?` expression.
  * @returns The first occurence of either an yielded Err or a returned Result.
  */
-// NOTE:
-// Since body is potentially throwable because `await` can be used in it,
-// Promise<Result<T, E>>, not ResultAsync<T, E>, is used as the return type.
 export function safeTry<T, E>(
   body: () => AsyncGenerator<Err<never, E>, Result<T, E>>,
-): Promise<Result<T, E>>
+): ResultAsync<T, E>
 export function safeTry<
   YieldErr extends Err<never, unknown>,
   GeneratorReturnResult extends Result<unknown, unknown>
 >(
   body: () => AsyncGenerator<YieldErr, GeneratorReturnResult>,
-): Promise<
-  Result<
-    InferOkTypes<GeneratorReturnResult>,
-    InferErrTypes<YieldErr> | InferErrTypes<GeneratorReturnResult>
-  >
+): ResultAsync<
+  InferOkTypes<GeneratorReturnResult>,
+  InferErrTypes<YieldErr> | InferErrTypes<GeneratorReturnResult>
 >
 export function safeTry<T, E>(
   body:
     | (() => Generator<Err<never, E>, Result<T, E>>)
     | (() => AsyncGenerator<Err<never, E>, Result<T, E>>),
-): Result<T, E> | Promise<Result<T, E>> {
+): Result<T, E> | ResultAsync<T, E> {
   const n = body().next()
   if (n instanceof Promise) {
-    return n.then((r) => r.value)
+    return new ResultAsync(n.then((r) => r.value))
   }
   return n.value
 }

tests/safe-try.test.ts

@@ -177,7 +177,7 @@ describe("Tests if README's examples work", () => {
   })
 
   test("async mayFail1 error", async () => {
-    function myFunc(): Promise<Result<number, string>> {
+    function myFunc(): ResultAsync<number, string> {
       return safeTry<number, string>(async function*() {
         return ok(
           (yield* (await promiseBad())
@@ -197,7 +197,7 @@ describe("Tests if README's examples work", () => {
   })
 
   test("async mayFail2 error", async () => {
-    function myFunc(): Promise<Result<number, string>> {
+    function myFunc(): ResultAsync<number, string> {
       return safeTry<number, string>(async function*() {
         return ok(
           (yield* (await promiseGood())
@@ -217,7 +217,7 @@ describe("Tests if README's examples work", () => {
   })
 
   test("promise async all ok", async () => {
-    function myFunc(): Promise<Result<number, string>> {
+    function myFunc(): ResultAsync<number, string> {
       return safeTry<number, string>(async function*() {
         return ok(
           (yield* (await promiseGood())

tests/typecheck-tests.ts

@@ -2404,7 +2404,7 @@ type CreateTuple<L, V = string> =
           name: 'ReturnMyError'
         }
 
-        type Expectation = Promise<Result<string, ReturnMyError>>
+        type Expectation = ResultAsync<string, ReturnMyError>
 
         const result = safeTry(async function *() {
           return okAsync<string, ReturnMyError>('string');
@@ -2419,7 +2419,7 @@ type CreateTuple<L, V = string> =
           name: 'ReturnMyError';
         }
 
-        type Expectation = Promise<Result<string, ReturnMyError>>
+        type Expectation = ResultAsync<string, ReturnMyError>
 
         const result = safeTry(async function *() {
           return errAsync<string, ReturnMyError>({ name: 'ReturnMyError' });
@@ -2460,7 +2460,7 @@ type CreateTuple<L, V = string> =
           name: 'ReturnMyError';
         }
 
-        type Expectation = Promise<Result<string, FirstYieldMyError | SecondYieldMyError | ReturnMyError>>
+        type Expectation = ResultAsync<string, FirstYieldMyError | SecondYieldMyError | ReturnMyError>
 
         const result = safeTry(async function *() {
           yield* okAsync<number, FirstYieldMyError>(123).safeUnwrap();