Question: How to recover from an error result to an ok result dynamically?

I see that I can map an ok value to any result I want by using .andThen. I can use unwrapOr to replace every error by given value.

But what about mapping an error value to an ok value dymically? It’s sound quite useful that we want to recover after error and e.g. provide a default value for one type of error and left error as is for other type.

e.g.

const occupationResult: Result<string, NotFoundError | ConnectionError> = await getUserOccupation();

const safeOccupationResult = occupationResult.someErrorMappingFunction(
  (error: NotFoundError | ConnectionError) => {
    if (err instanceof NotFoundError) {
      return ok("User not found");
    } else {
      return error;
    }
  }
);


// comparison to promises:
// a - rejected promise
const a = Promise.reject("an error");
// b - resolved promise
const b = a.catch(err => 33);
// c - rejected promise
const c = a.catch(err => Promise.reject("other error"));

how I could achieve currently the result that my imaginary function someErrorMappingFunction do?

[paduc]

I’m not sure I like the idea of having map and mapErr accept callbacks returning Results. The point of map and mapErr is that they do not change the nature of the Result (an Ok remains an Ok, an Err remains an Err), they should only transform the value itself.

Promises are a bit different in that they auto-unwrap (Promise<Promise<T>> becomes a Promise<T>) which is possible because they do not handle the error case.

That’s why I believe Result should have distinct map mapErr andThen and orElse as they all have a very specific transformation purpose. This is not specific to neverthrow, we find the same distinct methods in most (all?) monad libs that have an Either type.

[supermacro]

orElse is now implemented:

https://github.com/supermacro/neverthrow#resultorelse-method

Closing the issue to keep things a bit tidy, but feel free to chat here or in a new issue.