lens-3.8.7.3: Lenses, Folds and Traversals

Portability | non-portable
Stability | experimental
Maintainer | Edward Kmett <ekmett@gmail.com>
Safe Haskell | Trustworthy

Control.Lens.Internal.Exception

Description

This module uses dirty tricks to generate a `Handler` from an arbitrary `Fold`.

Synopsis

- class Handleable e m h | h -> e m where
  - handler :: Getting (First a) e t a b -> (a -> m r) -> h r
  - handler_ :: Getting (First a) e t a b -> m r -> h r
- data HandlingException = HandlingException

# Documentation

class Handleable e m h | h -> e m where

Both `MonadCatchIO-transformers` and Control.Exception provide a `Handler` type.

This lets us write combinators to build handlers that are agnostic about the choice of which of these they use.

Methods

handler :: Getting (First a) e t a b -> (a -> m r) -> h r

This builds a `Handler` for just the targets of a given `Prism` (or any `Getter`, really).

     catches ... [ handler _AssertionFailed (s -> print $ "Assertion Failed\n" ++ s)
                 , handler _ErrorCall (s -> print $ "Error\n" ++ s)
                 ]

This works ith both the `Handler` type provided by `Control.Exception`:

     handler :: Getter     SomeException a -> (a -> IO r) -> Handler r
     handler :: Fold       SomeException a -> (a -> IO r) -> Handler r
     handler :: Prism'     SomeException a -> (a -> IO r) -> Handler r
     handler :: Lens'      SomeException a -> (a -> IO r) -> Handler r
     handler :: Traversal' SomeException a -> (a -> IO r) -> Handler r

and with the `Handler` type provided by `Control.Monad.CatchIO`:

     handler :: Getter     SomeException a -> (a -> m r) -> Handler m r
     handler :: Fold       SomeException a -> (a -> m r) -> Handler m r
     handler :: Prism'     SomeException a -> (a -> m r) -> Handler m r
     handler :: Lens'      SomeException a -> (a -> m r) -> Handler m r
     handler :: Traversal' SomeException a -> (a -> m r) -> Handler m r

and with the `Handler` type provided by `Control.Monad.Error.Lens`:

     handler :: Getter     e a -> (a -> m r) -> Handler e m r
     handler :: Fold       e a -> (a -> m r) -> Handler e m r
     handler :: Prism'     e a -> (a -> m r) -> Handler e m r
     handler :: Lens'      e a -> (a -> m r) -> Handler e m r
     handler :: Traversal' e a -> (a -> m r) -> Handler e m r

handler_ :: Getting (First a) e t a b -> m r -> h r

This builds a `Handler` for just the targets of a given `Prism` (or any `Getter`, really). that ignores its input and just recovers with the stated monadic action.

     catches ... [ handler_ _NonTermination (return "looped")
                 , handler_ _StackOverflow (return "overflow")
                 ]

This works with the `Handler` type provided by `Control.Exception`:

     handler_ :: Getter     SomeException a -> IO r -> Handler r
     handler_ :: Fold       SomeException a -> IO r -> Handler r
     handler_ :: Prism'     SomeException a -> IO r -> Handler r
     handler_ :: Lens'      SomeException a -> IO r -> Handler r
     handler_ :: Traversal' SomeException a -> IO r -> Handler r

and with the `Handler` type provided by `Control.Monad.CatchIO`:

     handler_ :: Getter     SomeException a -> m r -> Handler m r
     handler_ :: Fold       SomeException a -> m r -> Handler m r
     handler_ :: Prism'     SomeException a -> m r -> Handler m r
     handler_ :: Lens'      SomeException a -> m r -> Handler m r
     handler_ :: Traversal' SomeException a -> m r -> Handler m r

and with the `Handler` type provided by `Control.Monad.Error.Lens`:

     handler_ :: Getter     e a -> m r -> Handler e m r
     handler_ :: Fold       e a -> m r -> Handler e m r
     handler_ :: Prism'     e a -> m r -> Handler e m r
     handler_ :: Lens'      e a -> m r -> Handler e m r
     handler_ :: Traversal' e a -> m r -> Handler e m r

Instances

Handleable SomeException IO Handler |
Handleable SomeException m (Handler m) |
Handleable e m (Handler e m) |

data HandlingException

There was an `Exception` caused by abusing the internals of a `Handler`.

Constructors

HandlingException |

Instances

Show HandlingException |
Typeable HandlingException |
Exception HandlingException |
(Profunctor p, Functor f) => AsHandlingException p f HandlingException |