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


-- | Heterogenous memoisation monad
--   
--   See README.md for details
@package tangle
@version 0.1

module Control.Monad.Tangle

-- | <a>TangleFT</a> is a higher-kinded heterogeneous memoisation monad
--   transformer. <tt>t</tt> represents the shape of the underlying data
--   structure, and <tt>f</tt> is the wrapper type of each field. This
--   monad represents computations that depend on the contents of <tt>t
--   f</tt>.
newtype TangleFT t f m a
TangleFT :: (t (Compose (TangleFT t f m) f) -> t (Compose Maybe f) -> m (t (Compose Maybe f), a)) -> TangleFT t f m a
[runTangleFT] :: TangleFT t f m a -> t (Compose (TangleFT t f m) f) -> t (Compose Maybe f) -> m (t (Compose Maybe f), a)

-- | Obtain a value from the tangle. The result gets memoised.
hitchF :: Monad m => (forall h g. Functor g => (h a -> g (h a)) -> t h -> g (t h)) -> TangleFT t f m (f a)
evalTangleFT :: (ApplicativeB t, Functor m) => TangleFT t f m a -> t (Compose (TangleFT t f m) f) -> m a

-- | Lift a collection of <a>TangleT</a>s so that it fits the argument of
--   <a>runTangleFT</a>.
liftTangles :: (FunctorB b, Functor m) => b (TangleT b m) -> b (Compose (TangleT b m) Identity)

-- | A product where all the elements are <a>Compose</a> <a>Nothing</a>
blank :: ApplicativeB b => b (Compose Maybe f)

-- | Bare variant of <a>hitchF</a>
hitch :: Monad m => (forall h g. Functor g => (h a -> g (h a)) -> t h -> g (t h)) -> TangleT t m a

-- | Collect all results in the tangle.
gather :: (TraversableB t, Monad m) => TangleFT t f m (t f)

-- | Non-transformer version of <a>TangleFT</a>
type TangleF t f = TangleFT t f Identity
evalTangleF :: ApplicativeB t => TangleF t f a -> t (Compose (TangleF t f) f) -> a

-- | Bare version of <a>TangleFT</a>
type TangleT t = TangleFT t Identity
evalTangleT :: (Functor m, ApplicativeB t) => TangleT t m a -> t (TangleT t m) -> m a

-- | Bare non-transformer tangle
type Tangle t = TangleFT t Identity Identity
evalTangle :: ApplicativeB t => Tangle t a -> t (Tangle t) -> a
instance GHC.Base.Functor m => GHC.Base.Functor (Control.Monad.Tangle.TangleFT t f m)
instance GHC.Base.Monad m => GHC.Base.Applicative (Control.Monad.Tangle.TangleFT t f m)
instance GHC.Base.Monad m => GHC.Base.Monad (Control.Monad.Tangle.TangleFT t f m)
instance (GHC.Base.Monad m, GHC.Base.Semigroup a) => GHC.Base.Semigroup (Control.Monad.Tangle.TangleFT t f m a)
instance (GHC.Base.Monad m, GHC.Base.Monoid a) => GHC.Base.Monoid (Control.Monad.Tangle.TangleFT t f m a)
instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Tangle.TangleFT t f)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Tangle.TangleFT t f m)