How to avoid "callback-hell" type of syntax?

I am looking into this library. However I can’t seem to understand how I would avoid nesting .maps inside each other.

For example, I would do something like:

asyncOperation1.map(success1 => {
  console.log("cool: ", success1);
  asyncOperation2.map(success2 => {
    console.log("cool: ", success2);
    asyncOperation3.map(success3 => {
      ...
    }).mapErr(err => {
      console.log("uh oh", err);
    });
  }).mapErr(err => {
    console.log("uh oh", err);
  });
.mapErr(err => {
  console.log("uh oh", err);
});

I feel like I must be missing something but I haven’t seen any examples addressing this case, of multiple async operations that depend on previous results. Any links to examples or suggestions for this?

[paduc]

@rhlsthrm I believe you tend to unwrap the result too early. A more idiomatic approach is to keep the result wrapped for as long as possible and use .andThen to chain each successive operation.

const res = doSomething(); // res is ResultAsync<T1,E1>
const res2 = res.andThen(doSomethingElse) // res2 is ResultAsync<T2, E1 | E2>
// ... later on, call match

// or more simply
const res = doSomething().andThen(doSomethingElse)

It really behaves like a Promise in that, you can chose to await right away or chain it with .then and keep it as a promise. The difference is that the error case is typed and it’s a lot harder to forget to handle it.

A good indicator that you are using neverthrow correctly is that you use andThen way more often than isOk/isError/match.

[paduc]

Hello @rhlsthrm !

When chaining multiple operations, you would do something similar to a chain of Promises.

const result = asyncOperation1.andThen(asyncOperation2).andThen(asyncOperation3)

The error case can be handled at the very end of the chain using .match or isErr() and .error.

const result = await asyncOperation1.andThen(asyncOperation2).andThen(asyncOperation3)
if(result.isErr()){
  console.error(result.error)
}
else{
  console.log('Success', result.value)
}

// or
await asyncOperation1.andThen(asyncOperation2).match((value) => console.log('success', value), (error) => console.error(error))

I personally make web apps, and use ResultAsync everywhere in my app but only use .match in my controllers, where I unwrap the final ResultAsync and decide what to do in the different error cases (because there are several error types) and the success case.

Here is a live production example of a controller unwrapping the value/error cases.