Incorrect type inference when crossing async boundary

[jaydenfyi]

Hi there,

I had a quick play around with the library and noticed the return types aren't reflecting the runtime values when switching from sync to async code.

import { Result } from '@praha/byethrow';

const doublePlusFive = Result.pipe(
  //    ^?
  // (sync) initial value
  Result.succeed(5),
  // (sync -> async) return a promise to cross into async code
  Result.map((x) => {
    return Promise.resolve(x * 2);
  }),
  // (async) map the value from the previous step
  Result.map((x) => {
    //        ^?
    return x + 5; // x is actually 10 here at runtime, but types suggest it's a promise
  })
);
// test is actually a promise returning a Result at runtime, but types suggest it's a sync Result

Playground link

To be honest I'm not confident it's possible to get the types for this to work properly without having separate sync and async implementations of every function. But hopefully it's an easy fix or I'm just doing something incorrectly.

[Karibash]

@jaydenfyi
Hi, thank you for trying out the library and for the detailed report!

You're absolutely right in observing the mismatch between types and runtime behavior when using map with an async function. This is actually by design — the map function is intended strictly for synchronous, side-effect-free transformations. This design helps ensure that mapping operations remain predictable and free of unexpected runtime errors.

Because asynchronous operations can fail and introduce side effects, we intentionally don't support async functions in map. Instead, for chaining async operations, please use andThen, which is designed to handle functions that return ResultAsync.

For example, your use case could be rewritten like this:

import { Result } from '@praha/byethrow';

const test = Result.pipe(
  Result.succeed(5),
  Result.andThen((x) => {
    return Result.try({
      immediate: true,
      try: () => Promise.resolve(x * 2),
      catch: (error) => new Error('Unexpected error', { cause: error }),
    });
  }),
  Result.map((x) => {
    return x + 5;
  }),
);

We also recommend combining andThen with try when performing operations that may throw or reject, in order to properly capture and propagate errors.

Thanks again for the thoughtful feedback! Let us know if you have any other questions or ideas.