polysemy- Higher-order, low-boilerplate, zero-cost free monads.

Safe HaskellNone




data Strategy m f n z a where Source #


GetInitialState :: Strategy m f n z (f ()) 
HoistInterpretation :: (a -> n b) -> Strategy m f n z (f a -> m (f b)) 
GetInspector :: Strategy m f n z (Inspector f) 

type Strategic m n a = forall f. Functor f => Sem (WithStrategy m f n) (m (f a)) Source #

Strategic is an environment in which you're capable of explicitly threading higher-order effect states to the final monad. This is a variant of Tactics (see Tactical), and usage is extremely similar.


type WithStrategy m f n = '[Strategy m f n] Source #


runStrategy :: Functor f => Sem '[Strategy m f n] a -> f () -> (forall x. f (n x) -> m (f x)) -> (forall x. f x -> Maybe x) -> a Source #

Internal function to process Strategies in terms of withWeavingToFinal.


getInspectorS :: forall m f n. Sem (WithStrategy m f n) (Inspector f) Source #

Get a natural transformation capable of potentially inspecting values inside of f. Binding the result of getInspectorS produces a function that can sometimes peek inside values returned by bindS.

This is often useful for running callback functions that are not managed by polysemy code.

See also getInspectorT


getInitialStateS :: forall m f n. Sem (WithStrategy m f n) (f ()) Source #

Get the stateful environment of the world at the moment the Strategy is to be run.

Prefer pureS, liftS, runS, or bindS instead of using this function directly.


pureS :: Applicative m => a -> Strategic m n a Source #

Embed a value into Strategic.


liftS :: Functor m => m a -> Strategic m n a Source #

Lifts an action of the final monad into Strategic.

Note: you don't need to use this function if you already have a monadic action with the functorial state threaded into it, by the use of runS or bindS. In these cases, you need only use pure to embed the action into the Strategic environment.


runS :: n a -> Sem (WithStrategy m f n) (m (f a)) Source #

Lifts a monadic action into the stateful environment, in terms of the final monad. The stateful environment will be the same as the one that the Strategy is initially run in.

Use bindS if you'd prefer to explicitly manage your stateful environment.


bindS :: (a -> n b) -> Sem (WithStrategy m f n) (f a -> m (f b)) Source #

Embed a kleisli action into the stateful environment, in terms of the final monad. You can use bindS to get an effect parameter of the form a -> n b into something that can be used after calling runS on an effect parameter n a.