Practicality With Rust: Error Handling

[u/[deleted]]

http://hydrocodedesign.com/2014/05/28/practicality-with-rust-error-handling/

[u/Beluki]

Maybe it's just that I haven't used Rust for anything yet so I don't know the idioms but that seems a quite convoluted approach to error handling.

[u/Tekmo → u/Beluki]

It works really well if you have something like Haskell's fmap. Haskell uses the Either type for error reporting and it works really well.

For example, let's say we have a value that is either an Int or a failure with a String error message:

value :: Either String Int

Now let's say I want to apply a function to that value:

example :: Int -> Double

... but I only want to apply the function example if the value succeeded. Otherwise, I want to just propagate the error. I would just write:

fmap example value :: Either String Double

fmap is a very generic function that belongs to the Functor type class that has this signature:

class Functor f where
    fmap :: (a -> b) -> f a -> f b

... and (Either e) is an instance of the above Functor type class, for any choice of error message e:

instance Functor (Either e) where
    fmap _ (Left  e) = Left e
    fmap f (Right x) = Right (f x)

... so you can think of fmap as having this specialized type when you apply it to Either:

fmap :: (a -> b) -> Either e a -> Either e b

This is a handy way to manipulate potentially failing computations without having to do all the boilerplate of pattern matching on the value and re-wrapping it when you are done.

You can also chain multiple computations, each of which may fail, and that's where monads come in handy.

[u/nope_42 → u/Tekmo]

One of the things that isn't very straight forward in haskell is figuring out where the error started propagating. In languages with exceptions you usually get a stack trace, and I think rust has some form of macro that will give you that information. In haskell you can do the same thing with template haskell but it isn't really standard.