Safe Haskell | None |
---|---|
Language | Haskell2010 |
This module contains basic examples advices.
BEWARE! These are provided for illustrative purposes only, they strive for simplicity and not robustness or efficiency.
They can be converted to DepT
-based Advice
s using fromSimple
.
Synopsis
- returnMempty :: forall ca m r. (Monad m, Monoid r) => Advice ca m r
- printArgs :: forall m r. MonadIO m => Handle -> String -> Advice Show m r
- data AnyEq where
- doCachingBadly :: forall m r. Monad m => (AnyEq -> m (Maybe r)) -> (AnyEq -> r -> m ()) -> Advice (Eq `And` Typeable) m r
- doAsyncBadly :: forall ca m. MonadUnliftIO m => Advice ca m ()
- injectFailures :: forall ca m r. (MonadIO m, MonadFail m) => IORef ([IO ()], [IO ()]) -> Advice ca m r
- type MethodName = String
- type StackFrame = NonEmpty (TypeRep, MethodName)
- type SyntheticCallStack = [StackFrame]
- class HasSyntheticCallStack e where
- callStack :: forall f. Functor f => (SyntheticCallStack -> f SyntheticCallStack) -> e -> f e
- type SyntheticStackTrace = NonEmpty StackFrame
- data SyntheticStackTraceException = SyntheticStackTraceException SomeException SyntheticStackTrace
- keepCallStack :: (MonadUnliftIO m, MonadCallStack m, Exception e) => (SomeException -> Maybe e) -> NonEmpty (TypeRep, MethodName) -> Advice ca m r
Basic advices
returnMempty :: forall ca m r. (Monad m, Monoid r) => Advice ca m r Source #
Makes functions discard their result and always return mempty
.
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.
doCachingBadly :: forall m r. Monad m => (AnyEq -> m (Maybe r)) -> (AnyEq -> r -> m ()) -> Advice (Eq `And` Typeable) m r Source #
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 m. MonadUnliftIO m => Advice ca m () Source #
Makes functions that return ()
launch asynchronously.
A better implementation of this advice would likely use the "async"
package instead of bare forkIO
.
injectFailures :: forall ca m r. (MonadIO m, MonadFail m) => IORef ([IO ()], [IO ()]) -> Advice ca m r Source #
Given a reference with two infinite lists of IO
actions, on each
invocation of the advised function, take an action from the first list and
execute it before, and take one action from the second list and execute it
after.
A common use for this would be to pass exception-throwing actions.
Synthetic call stacks
type MethodName = String Source #
type StackFrame = NonEmpty (TypeRep, MethodName) Source #
The typeable representation of the record which contains the invoked function, along with the field name of the invoked function.
type SyntheticCallStack = [StackFrame] Source #
class HasSyntheticCallStack e where Source #
Class of environments that carry a SyntheticCallStack
value that can be
modified.
callStack :: forall f. Functor f => (SyntheticCallStack -> f SyntheticCallStack) -> e -> f e Source #
A lens from the environment to the call stack.
Instances
HasSyntheticCallStack SyntheticCallStack Source # | The trivial case, useful when |
Defined in Dep.SimpleAdvice.Basic callStack :: Functor f => (SyntheticCallStack -> f SyntheticCallStack) -> SyntheticCallStack -> f SyntheticCallStack Source # | |
HasSyntheticCallStack s => HasSyntheticCallStack (Const s x) Source # | |
Defined in Dep.SimpleAdvice.Basic callStack :: Functor f => (SyntheticCallStack -> f SyntheticCallStack) -> Const s x -> f (Const s x) Source # |
type SyntheticStackTrace = NonEmpty StackFrame Source #
data SyntheticStackTraceException Source #
Wraps an exception along with a SyntheticCallStack
.
Instances
:: (MonadUnliftIO m, MonadCallStack m, Exception e) | |
=> (SomeException -> Maybe e) | A selector for the kinds of exceptions we want to catch.
For example |
-> NonEmpty (TypeRep, MethodName) | The path to the current component/method in the environment.
It will be usually obtained through
|
-> Advice ca m r |
If the environment carries a SyntheticCallStack
, make advised functions add
themselves to the SyntheticCallStack
before they start executing.
This Advice
requires a reader-like base monad to work. It
doesn't need to be DepT
, it can be regular a
ReaderT
.
Caught exceptions are rethrown wrapped in SyntheticStackTraceException
s,
with the current SyntheticCallStack
added.