-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | A monad transformer for tracing provenience of errors
--   
@package trace
@version 0.1.0.1

module Control.Monad.Trace.ErrorTrace

-- | A datatype containing an error and its provenience.
data ErrorTrace t e
ErrorTrace :: !e -> !(Seq t) -> ErrorTrace t e
_etError :: ErrorTrace t e -> !e
_etTrace :: ErrorTrace t e -> !(Seq t)

-- | An isomorphism <tt><a>ErrorTrace</a> t e ≅ (e, <a>Seq</a> t)</tt>.
_ErrorTrace :: (Choice p, Functor f) => p (ErrorTrace t e) (f (ErrorTrace t' e')) -> p (e, Seq t) (f (e', Seq t'))

-- | A lens <tt><a>ErrorTrace</a> t e → e</tt>.
etError :: Functor f => (e -> f e') -> ErrorTrace t e -> f (ErrorTrace t e')

-- | A lens <tt><a>ErrorTrace</a> t e → Seq t</tt>.
etTrace :: Functor f => (Seq t -> f (Seq t')) -> ErrorTrace t e -> f (ErrorTrace t' e)
instance (Show t, Show e) => Show (ErrorTrace t e)

module Control.Monad.Trace.Class

-- | A class for monads that have a scoped tracing effect
class MonadTrace t m | m -> t
traceScope :: MonadTrace t m => t -> m α -> m α
readTrace :: MonadTrace t m => m (Seq t)

module Control.Monad.Trans.Trace

-- | A concrete monad transformer <tt><a>TraceT</a> t e m</tt> where
--   <tt>t</tt> is the type of tags/breadcrumbs, <tt>e</tt> is the type of
--   errors, and <tt>m</tt> is the underlying monad.
data TraceT t e m α

-- | Run a traced traced computation to get either its result, or an error
--   and its provenience (<a>ErrorTrace</a>).
runTraceT :: (Functor m, Monad m) => TraceT t e m α -> EitherT (ErrorTrace t e) m α

-- | Realize your own trace
readTrace :: MonadTrace t m => m (Seq t)
instance Monad m => Functor (TraceT t e m)
instance Monad m => Monad (TraceT t e m)
instance Monad m => Applicative (TraceT t e m)
instance (Monad m, Monoid e) => Alternative (TraceT t e m)
instance MonadIO m => MonadIO (TraceT t e m)
instance MonadBase b m => MonadBase b (TraceT t e m)
instance Monad m => MonadError e (TraceT t e m)
instance MonadBaseControl b m => MonadBaseControl b (TraceT t e m)
instance MonadTransControl (TraceT t e)
instance Monad m => MonadTrace t (TraceT t e m)
instance MonadTrans (TraceT t e)

module Control.Monad.Trace.Codensity

-- | Add a trace in synchronous style
putTrace :: (Monad m, MonadTrace t m) => t -> Codensity m ()

module Control.Monad.Trace