HoistFail

[lrworth]

Adds a new typeclass HoistFail analogous to HoistError but for hoisting into MonadFail. This is concretely useful for writing aeson and cassava parsers; both of these libraries use MonadFail to support parse errors, and our parsers tend to be littered with variations of either fail pure.

To support common use cases I've added some functions with mnemonic suffixes:

• a family of functions ending with ', which simplify hoisting from different monads with the same error type
• a family of functions with E in the suffix, which set the input monad to Either to support hoisting from types where the monad is polymorphic.

[endgame]

I would be OK with dropping support for ancient GHC.

[lrworth]

This has been a long time coming.

[endgame]

I keep wondering, "what if the new typeclasses aren't necessary?" From there, I wonder if the basic design of this library could be better?

The core class of hoist-error is:

class Monad m => HoistError m t e e' | t -> e where
  hoistError :: (e -> e') -> t a -> m a

It tells us which error/partiality functor t is in play (e.g., Maybe, Either e, ExceptT e m), what the error type e is for t (Maybe -> (); Either e -> e) and which error type is used by the monad m. If we separate the ideas of "identifying the error" and "hoisting the error into some other monad", then maybe we can avoid rewriting all machinery for MonadError and MonadFail. Perhaps something like this?

class InspectError e t m | t -> e where
  inspectError :: t a -> m (Either e a)

instance Applicative m => InspectError () Maybe m where
  inspectError = pure . \case
    Nothing -> Left ()
    Just a -> Right a

instance Applicative m => InspectError e (Either e) m where
  inspectError = pure

instance InspectError e (ExceptT e m) m where
  inspectError = runExceptT

hoistError :: (MonadError e' m, InspectError e t m) => (e -> e') -> t a -> m a
hoistError f = either (throwError . f) pure <=< inspectError

hoistFail :: (MonadFail m, InspectError e t m) => (e -> String) -> t a -> m a
hoistFail f = either (fail . f) pure <=< inspectError

I'd probably put the InspectError class in Control.Monad.Error.Hoist, put all the fail-based machinery in Control.Monad.Fail.Hoist, and then everything should "just work".

[lrworth]

I wonder if the basic design of this library could be better?

Sounds great, but it'll be a breaking change so should happen in a different PR.

[JackKelly-Bellroy]

In the spirit of "make the hard change easy, then make the easy change", I think we should look at the InspectError refactor first.