Control.Monad.Dep.Advice.Basic

This module contains examples of simple advices.

BEWARE! These are provided for illustrative purposes only, they strive for simplicity and not robustness or efficiency.

Basic advices

returnMempty :: forall ca e_ m r. (Monad m, Monoid r) => Advice ca e_ m r

Makes functions discard their result and always return mempty.

printArgs :: forall e_ m r. MonadIO m => Handle -> String -> Advice Show e_ m r

Given a Handle and a prefix string, makes functions print their arguments to the Handle.

doLocally :: forall ca e_ m r. Monad m => (forall n. e_ n -> e_ n) -> Advice ca e_ m r

Use local on the final DepT action of a function.

Allows tweaking the environment that will be seen by the function and all of its sub-calls into dependencies.

Perhaps this is not what you want; often, it's better to tweak the environment for the current function only. For those cases, deceive might be a better fit.

>>> :{
 type HasLogger :: Type -> (Type -> Type) -> Constraint
 class HasLogger em m | em -> m where
   logger :: em -> String -> m ()
 type Env :: (Type -> Type) -> Type
 data Env m = Env
   { _logger1 :: String -> m (),
     _logger2 :: String -> m (),
     _controllerA :: Int -> m (),
     _controllerB :: Int -> m ()
   }
 instance HasLogger (Env m) m where
   logger = _logger1
 envIO :: Env (DepT Env IO)
 envIO = Env 
   {
     _logger1 = 
         \_ -> liftIO $ putStrLn "logger1 ran",
     _logger2 = 
         \_ -> liftIO $ putStrLn "logger2 ran",
     _controllerA = 
         \_ -> do e <- ask; logger e "foo",
     _controllerB = 
         advise @Top 
         (doLocally \e@Env{_logger2} -> e {_logger1 = _logger2}) 
         \_ -> do e <- ask; logger e "foo" 
   }
:}

>>> runFromEnv (pure envIO) _controllerA 0
logger1 ran

>>> runFromEnv (pure envIO) _controllerB 0
logger2 ran

data AnyEq where

A helper datatype for universal equality comparisons of existentialized values, used by doCachingBadly.

For a more complete elaboration of this idea, see the the "exinst" package.

Constructors

AnyEq :: forall a. (Typeable a, Eq a) => a -> AnyEq

Instances

Eq AnyEq

Defined in Control.Monad.Dep.Advice.Basic

Methods

(==) :: AnyEq -> AnyEq -> Bool

(/=) :: AnyEq -> AnyEq -> Bool

doCachingBadly :: forall e_ m r. Monad m => (AnyEq -> m (Maybe r)) -> (AnyEq -> r -> m ()) -> Advice (Eq `And` Typeable) e_ m r

Given the means for looking up and storing r values in the underlying monad m, makes functions (inefficiently) cache their results.

The monad m and the result type r must be known before building the advice. So, once built, this Advice won't be polymorphic over them.

The implementation of this function makes use of the existential type parameter u of makeAdvice, because the phase that processes the function arguments needs to communicate the calculated AnyEq cache key to the phase that processes the function result.

A better implementation of this advice would likely use an AnyHashable helper datatype for the keys.

doAsyncBadly :: forall ca e_. Advice ca e_ IO ()

Makes functions that return () launch asynchronously.

A better implementation of this advice would likely use the "async" package instead of bare forkIO.

The IO monad could be generalized to MonadUnliftIO.