Ndtyjky

I'm currently reading the paper Monad Transformers Step by Step
by Martin Grabmüller.

Theres a part in the paper where he lists off the following instance declaration:

instance (MonadError e m) => MonadError e (ReaderT r m) where...

I've looked all over but I can't really find any info on what exactly a multi-parameter constraint like (Foo a b) means. I don't totally understand how e and m work together within the instance head => MonadError e (ReaderT r m).

How do these multi-parameter constraints work? Thanks!

Essentially, a constraint like Show a constrains the type variable a to represent a showable type. You seem to understand this.

A constraint of the form C a b constrains the pair of type variables a and b. Intuitively, this constrains means that there is a relation between such types.

Consider this fictional class

class C a b where

   sum :: a -> b -> (Int, b)

Intuitively, the constraint C a b means that a and b can be summed together (in that order!), and the result of that sum will be a pair (Int, b).

In your case you are dealing with

class Monad m => MonadError e m | m -> e where

   throwError :: e -> m a

Here, MonadError e m expresses the following relation between e and m.

1. 
   m is a monad


2. 
   e is a type for which we can convert any value x :: e into throwError x :: m a, for any a. Intuitively, this is an "error" type, representing the nature of some error, and throwError simply includes such value inside the monad


3. given m, there is only one error type e. In other words, the relation is actually a function. This is expressed through a functional dependency ... | m -> e in the class above.

The simple version is: MonadError m a means that m is a monad which can express some "error values", of type e.

For example, if we have MonadError M String available, we can write

foo :: Int -> M Int

foo n | n == 0    = throwError "can't handle zero!"

      | otherwise = return (100 `div` n)