neverthrow VS rustic_result

Very timely, was just trying to understand how to improve error handling with typescript recently and came across neverthrow (https://github.com/supermacro/neverthrow) which looks promising…

On my team we use Rust-style Result/Option types for any unrecoverable exceptions.

https://github.com/supermacro/neverthrow

I was happy when Promise became available, but in retrospect I'd wish we would have skipped ahead and gotten Observable (e.g: https://rxjs.dev/) instead to enable more powerful functionality and composition etc.

In Typescript dealing with rejection is also painful since rejection reasons can't be guaranteed to be Error even when you always take care of that. And it can't help you guarantee that you're handling all types of errors thrown. For that purpose I'm thinking of using https://github.com/supermacro/neverthrow#readme or https://swan-io.github.io/boxed.

I highly recommend the neverthrow library for bringing Result to Typescript.

I like the Result monad from here: https://github.com/supermacro/neverthrow

What do you think of neverthrow?

I use https://github.com/supermacro/neverthrow for this

See neverthrow as an example of correctly encoding the failure into the return type of the function.

I use Neverthrow. Same idea, concurrent projects...

Self promotion moment:

If you enjoy the Result/Either type and API in Rust, I made this project just for this: https://github.com/linkdd/rustic_result

I also made https://github.com/linkdd/rustic_maybe/tree/main for an Option/Maybe type.

NB: Those are not types, but I'm waiting for set theoretic types to update those libs :)

It's missing the Erlang/Elixir pattern of returning a tuple `{:ok, T}` or `{:error, E}`, where we can then use pattern matching, or `with` expressions, etc...

To be fair, it is very similar to a `Result` type, which is why I made this library a while ago: https://github.com/linkdd/rustic_result

I intend to add a pipeline operator similar to Elixir, to be used with an std::result module which will provide functions to ease writing such complex code. I may take inspiration on an Elixir library I wrote a while ago: https://github.com/linkdd/rustic_result

A while ago, I made this library https://github.com/linkdd/rustic_result

I also made a library for working with `{:ok, value}` and `{:error, reason}` in Elixir: https://github.com/linkdd/rustic_result

Thanks to the pipeline operator and pattern matching, it makes pretty easy to read pipelines. It does not completely replace the with statement (that was not the point) but it simplified a lot of code.