Question

I’ve got a set of users, groups, and a mapping between users and groups. I have various functions that manipulate these sets, however one should not be able to add a user<->group mapping for a user that does not exist, nor remove a group which still has users as members, etc.

So basically I want these functions to throw “exceptions” that must be explicitly dealt with by the caller.

I first thought of returning something like this:

data Return r e = Success r | Exception e

And if the caller fails to pattern match against the Exception, they’ll hopefully get a compiler warning, or at the very least have an obvious runtime error when there is a problem.

Is this the best approach, and is there a pre-packaged solution that does this? Note I need to throw and catch “exceptions” in pure code, not the IO Monad.

Answer 1

Yes, this is a good approach, and it’s in the standard library: Return r e is the same as Either e r. You can even write code like you would using exceptions in IO, too (i.e. without having to explicitly handle the errors at each step with pattern matching): the Monad instance for Either propagates the errors, just like the Maybe monad does (but with the additional e value in the case of an error). For example:

data MyError
    = Oops String
    | VeryBadError Int Int

mightFail :: T -> Either MyError Int
mightFail a = ...

foo :: T -> T -> Int -> Either MyError Int
foo a b c = do
    x <- mightFail a
    y <- mightFail b
    if x == y
        then throwError (VeryBadError x y)
        else return (x + y + c)

If mightFail a or mightFail b returns Left someError, then foo a b c will, too; the errors are automatically propagated. (Here, throwError is just a nice way of writing Left, using the functions from Control.Monad.Error; there’s also catchError to catch these exceptions.)