@@ -6,7 +6,7 @@
6-- This module is intended for internal use only, and may change without warning
6-- This module is intended for internal use only, and may change without warning
7-- in subsequent releases.
7-- in subsequent releases.
8module Effectful.Internal.Monad
8module Effectful.Internal.Monad
9− ( -- * Monad
9+ ( -- * The 'Eff' monad
11 , runPureEff
11 , runPureEff
@@ -22,48 +22,41 @@ module Effectful.Internal.Monad
25− -- * Primitive
25+ -- * Prim
29− -- ** Unlift strategies
29+ -- * Unlift strategies
30 , UnliftStrategy(..)
30 , UnliftStrategy(..)
31 , Persistence(..)
31 , Persistence(..)
32 , Limit(..)
32 , Limit(..)
33 , unliftStrategy
33 , unliftStrategy
34 , withUnliftStrategy
34 , withUnliftStrategy
35 , withEffToIO
35 , withEffToIO
38− --- *** Low-level helpers
37+ -- ** Low-level unlifts
39− , unsafeLiftMapIO
38+ , seqUnliftIO
40− , seqUnliftEff
39+ , concUnliftIO
43 -- * Effects
41 -- * Effects
45− -- ** Handler
43+ -- ** Dynamic dispatch
46 , EffectHandler
44 , EffectHandler
47 , LocalEnv(..)
45 , LocalEnv(..)
48− , Handler(..)
46+ , HandlerA(..)
49 , runHandler
47 , runHandler
51− -- *** Sending operations
54− -- ** Primitive
50+ -- ** Static dispatch
56− -- *** Running
52+ , runData
57− , runEffect
53+ , evalData
58− , evalEffect
54+ , execData
59− , execEffect
55+ , getData
61− -- *** Modification
57+ , stateData
62− , getEffect
58+ , stateDataM
63− , putEffect
59+ , localData
69import Control.Applicative (liftA2)
62import Control.Applicative (liftA2)
@@ -86,44 +79,43 @@ import Effectful.Internal.Unlift
87type role Eff nominal representational
80type role Eff nominal representational
89−-- | The 'Eff' monad provides the implementation of an operation that performs
82+-- | The 'Eff' monad provides the implementation of a computation that performs
90-- an arbitrary set of effects. In @'Eff' es a@, @es@ is a type-level list that
83-- an arbitrary set of effects. In @'Eff' es a@, @es@ is a type-level list that
91−-- contains all the effects that the operation may perform. For example, an
84+-- contains all the effects that the computation may perform. For example, a
92−-- operation that produces an 'Integer' by consuming a 'String' from the global
85+-- computation that produces an 'Integer' by consuming a 'String' from the
93−-- environment and acting upon a single mutable cell containing a 'Bool' would
86+-- global environment and acting upon a single mutable value of type 'Bool'
94−-- have the following type:
87+-- would have the following type:
97−-- 'Eff' '['Effectful.Reader.Reader' 'String', 'Effectful.State.State' 'Bool'] 'Integer'
90+-- 'Eff' '['Effectful.Reader.Reader' 'String', 'Effectful.State.Local.State' 'Bool'] 'Integer'
100-- Normally, a concrete list of effects is not used to parameterize 'Eff'.
93-- Normally, a concrete list of effects is not used to parameterize 'Eff'.
101-- Instead, the '(:>)' type class is used to express constraints on the list of
94-- Instead, the '(:>)' type class is used to express constraints on the list of
102−-- effects without coupling an operation to a concrete list of effects. For
95+-- effects without coupling a computation to a concrete list of effects. For
103−-- example, the above example would more commonly be expressed with the
96+-- example, the above example would be expressed with the following type:
107−-- ('Effectful.Reader.Reader' 'String' ':>' es, 'Effectful.State.State' 'Bool' ':>' es) => 'Eff' es 'Integer'
99+-- ('Effectful.Reader.Reader' 'String' ':>' es, 'Effectful.State.Local.State' 'Bool' ':>' es) => 'Eff' es 'Integer'
110−-- This abstraction allows the operation to be used in functions that may
102+-- This abstraction allows the computation to be used in functions that may
111-- perform other effects, and it also allows the effects to be handled in any
103-- perform other effects, and it also allows the effects to be handled in any
113newtype Eff (es :: [Effect]) a = Eff (Env es -> IO a)
105newtype Eff (es :: [Effect]) a = Eff (Env es -> IO a)
114 deriving (Monoid, Semigroup)
106 deriving (Monoid, Semigroup)
116−-- | Run a pure 'Eff' operation.
108+-- | Run a pure 'Eff' computation.
118−-- For running operations with side effects see 'runEff'.
110+-- For running computations with side effects see 'runEff'.
119runPureEff :: Eff '[] a -> a
111runPureEff :: Eff '[] a -> a
120runPureEff (Eff m) =
112runPureEff (Eff m) =
121− -- unsafePerformIO is safe here since IOE was not on the stack, so no IO with
113+ -- unsafeDupablePerformIO is safe here since IOE was not on the stack, so no
122− -- side effects was performed (unless someone sneakily introduced side effects
114+ -- IO with side effects was performed (unless someone sneakily introduced side
123− -- with unsafeEff, but then all bets are off).
115+ -- effects with unsafeEff, but then all bets are off).
125 -- Moreover, internals don't allocate any resources that require explicit
117 -- Moreover, internals don't allocate any resources that require explicit
126− -- cleanup actions to run, so the "Dupable" part should also be just fine.
118+ -- cleanup actions to run.
127 unsafeDupablePerformIO $ m =<< emptyEnv
119 unsafeDupablePerformIO $ m =<< emptyEnv
129----------------------------------------
121----------------------------------------
@@ -136,69 +128,29 @@ unEff (Eff m) = m
136-- | Access the underlying 'IO' monad along with the environment.
128-- | Access the underlying 'IO' monad along with the environment.
138-- This function is __unsafe__ because it can be used to introduce arbitrary
130-- This function is __unsafe__ because it can be used to introduce arbitrary
139−-- 'IO' actions into pure 'Eff' operations.
131+-- 'IO' actions into pure 'Eff' computations.
140unsafeEff :: (Env es -> IO a) -> Eff es a
132unsafeEff :: (Env es -> IO a) -> Eff es a
141unsafeEff m = Eff (oneShot m)
133unsafeEff m = Eff (oneShot m)
143-- | Access the underlying 'IO' monad.
135-- | Access the underlying 'IO' monad.
145-- This function is __unsafe__ because it can be used to introduce arbitrary
137-- This function is __unsafe__ because it can be used to introduce arbitrary
146−-- 'IO' actions into pure 'Eff' operations.
138+-- 'IO' actions into pure 'Eff' computations.
147unsafeEff_ :: IO a -> Eff es a
139unsafeEff_ :: IO a -> Eff es a
148unsafeEff_ m = unsafeEff $ \_ -> m
140unsafeEff_ m = unsafeEff $ \_ -> m
150−-- | Utility for lifting 'IO' operations of type
152−-- @'IO' a -> 'IO' b@
156−-- @'Eff' es a -> 'Eff' es b@
158−-- This function is __unsafe__ because:
160−-- - It can be used to introduce arbitrary 'IO' actions into pure 'Eff'
163−-- - The 'IO' operation must not run its argument in a separate thread, but it's
164−-- not checked anywhere.
165−unsafeLiftMapIO :: (IO a -> IO b) -> Eff es a -> Eff es b
166−unsafeLiftMapIO f m = unsafeEff $ \es -> f (unEff m es)
168----------------------------------------
142----------------------------------------
169−-- Unlifting Eff
143+-- Unlifting IO
171-- | Get the current 'UnliftStrategy'.
145-- | Get the current 'UnliftStrategy'.
172unliftStrategy :: IOE :> es => Eff es UnliftStrategy
146unliftStrategy :: IOE :> es => Eff es UnliftStrategy
173unliftStrategy = do
147unliftStrategy = do
174− IdE (IOE unlift) <- getEffect
148+ DataA (IOE unlift) <- getData
175 pure unlift
149 pure unlift
177-- | Locally override the 'UnliftStrategy' with the given value.
151-- | Locally override the 'UnliftStrategy' with the given value.
178withUnliftStrategy :: IOE :> es => UnliftStrategy -> Eff es a -> Eff es a
152withUnliftStrategy :: IOE :> es => UnliftStrategy -> Eff es a -> Eff es a
179−withUnliftStrategy unlift = localEffect $ \_ -> IdE (IOE unlift)
153+withUnliftStrategy unlift = localData $ \_ -> DataA (IOE unlift)
181−-- | Lower 'Eff' operations into 'IO' ('SeqUnlift').
183−-- Exceptions thrown by this function:
185−-- - 'InvalidUseOfSeqUnlift' if the unlift function is used in another thread.
189− -> ((forall r. Eff es r -> IO r) -> IO a)
191−seqUnliftEff es k = seqUnliftIO k es unEff
193−-- | Lower 'Eff' operations into 'IO' ('ConcUnlift').
199− -> ((forall r. Eff es r -> IO r) -> IO a)
201−concUnliftEff es persistence limit k = concUnliftIO persistence limit k es unEff
203-- | Create an unlifting function with the current 'UnliftStrategy'.
155-- | Create an unlifting function with the current 'UnliftStrategy'.
@@ -206,16 +158,38 @@ concUnliftEff es persistence limit k = concUnliftIO persistence limit k es unEff
206-- constraint for accurate stack traces in case an insufficiently powerful
158-- constraint for accurate stack traces in case an insufficiently powerful
207-- 'UnliftStrategy' is used and the unlifting function fails.
159-- 'UnliftStrategy' is used and the unlifting function fails.
209−-- /Note:/ the strategy is reset to 'SeqUnlift' for new threads.
161+-- /Note:/ the strategy is reset to 'SeqUnlift' inside the continuation.
210withEffToIO
162withEffToIO
211 :: (HasCallStack, IOE :> es)
163 :: (HasCallStack, IOE :> es)
212 => ((forall r. Eff es r -> IO r) -> IO a)
164 => ((forall r. Eff es r -> IO r) -> IO a)
213 -- ^ Continuation with the unlifting function in scope.
165 -- ^ Continuation with the unlifting function in scope.
214 -> Eff es a
166 -> Eff es a
215withEffToIO f = unliftStrategy >>= \case
167withEffToIO f = unliftStrategy >>= \case
216− SeqUnlift -> unsafeEff $ \es -> seqUnliftEff es f
168+ SeqUnlift -> unsafeEff $ \es -> seqUnliftIO es f
217 ConcUnlift p b -> withUnliftStrategy SeqUnlift $ do
169 ConcUnlift p b -> withUnliftStrategy SeqUnlift $ do
218− unsafeEff $ \es -> concUnliftEff es p b f
170+ unsafeEff $ \es -> concUnliftIO es p b f
172+-- | Create an unlifting function with the 'SeqUnlift' strategy.
176+ -- ^ The environment.
177+ -> ((forall r. Eff es r -> IO r) -> IO a)
178+ -- ^ Continuation with the unlifting function in scope.
180+seqUnliftIO es k = seqUnlift k es unEff
182+-- | Create an unlifting function with the 'ConcUnlift' strategy.
186+ -- ^ The environment.
189+ -> ((forall r. Eff es r -> IO r) -> IO a)
190+ -- ^ Continuation with the unlifting function in scope.
192+concUnliftIO es persistence limit k = concUnlift persistence limit k es unEff
220----------------------------------------
194----------------------------------------
@@ -284,15 +258,15 @@ instance Fail :> es => MonadFail (Eff es) where
284----------------------------------------
258----------------------------------------
287−-- | Run arbitrary 'IO' operations via 'MonadIO' or 'MonadUnliftIO'.
261+-- | Run arbitrary 'IO' computations via 'MonadIO' or 'MonadUnliftIO'.
288newtype IOE :: Effect where
262newtype IOE :: Effect where
289 IOE :: UnliftStrategy -> IOE m r
263 IOE :: UnliftStrategy -> IOE m r
291−-- | Run an 'Eff' operation with side effects.
265+-- | Run an 'Eff' computation with side effects.
293−-- For running pure operations see 'runPureEff'.
267+-- For running pure computations see 'runPureEff'.
294runEff :: Eff '[IOE] a -> IO a
268runEff :: Eff '[IOE] a -> IO a
295−runEff m = unEff (evalEffect (IdE (IOE SeqUnlift)) m) =<< emptyEnv
269+runEff m = unEff (evalData (DataA (IOE SeqUnlift)) m) =<< emptyEnv
297instance IOE :> es => MonadIO (Eff es) where
271instance IOE :> es => MonadIO (Eff es) where
298 liftIO = unsafeEff_
272 liftIO = unsafeEff_
@@ -316,20 +290,20 @@ instance IOE :> es => MonadBaseControl IO (Eff es) where
316----------------------------------------
290----------------------------------------
317-- Primitive
291-- Primitive
319−-- | An effect to perform primitive state-transformer actions.
293+-- | Provide the ability to perform primitive state-transformer actions.
320data Prim :: Effect where
294data Prim :: Effect where
321 Prim :: Prim m r
295 Prim :: Prim m r
323−-- | Run an 'Eff' operation with primitive state-transformer actions.
297+-- | Run an 'Eff' computation with primitive state-transformer actions.
324runPrim :: IOE :> es => Eff (Prim : es) a -> Eff es a
298runPrim :: IOE :> es => Eff (Prim : es) a -> Eff es a
325−runPrim = evalEffect (IdE Prim)
299+runPrim = evalData (DataA Prim)
327instance Prim :> es => PrimMonad (Eff es) where
301instance Prim :> es => PrimMonad (Eff es) where
328 type PrimState (Eff es) = RealWorld
302 type PrimState (Eff es) = RealWorld
329 primitive = unsafeEff_ . IO
303 primitive = unsafeEff_ . IO
331----------------------------------------
305----------------------------------------
332−-- Handler
306+-- Dynamic dispatch
334type role LocalEnv nominal nominal
308type role LocalEnv nominal nominal
@@ -345,76 +319,97 @@ newtype LocalEnv (localEs :: [Effect]) (handlerEs :: [Effect]) = LocalEnv (Env l
345type EffectHandler e es
319type EffectHandler e es
346 = forall a localEs. HasCallStack
320 = forall a localEs. HasCallStack
347 => LocalEnv localEs es
321 => LocalEnv localEs es
348− -- ^ Capture of the local environment for handling local 'Eff' operations when
322+ -- ^ Capture of the local environment for handling local 'Eff' computations
349− -- @e@ is a higher order effect.
323+ -- when @e@ is a higher order effect.
350 -> e (Eff localEs) a
324 -> e (Eff localEs) a
351 -- ^ The effect performed in the local environment.
325 -- ^ The effect performed in the local environment.
352 -> Eff es a
326 -> Eff es a
328+-- | An adapter for dynamically dispatched effects.
354−-- | An effect handler bundled along with its environment.
330+-- Represents the effect handler bundled with its environment.
355−data Handler :: Effect -> Type where
331+data HandlerA :: Effect -> Type where
356− Handler :: !(Env es) -> !(EffectHandler e es) -> Handler e
332+ HandlerA :: !(Env es) -> !(EffectHandler e es) -> HandlerA e
358−-- | Run the effect with the given handler.
334+-- | Run a dynamically dispatched effect with the given handler.
359−runHandler :: Handler e -> Eff (e : es) a -> Eff es a
335+runHandler :: HandlerA e -> Eff (e : es) a -> Eff es a
360runHandler e m = unsafeEff $ \es0 -> do
336runHandler e m = unsafeEff $ \es0 -> do
361 size0 <- sizeEnv es0
337 size0 <- sizeEnv es0
362 E.bracket (unsafeConsEnv e relinker es0)
338 E.bracket (unsafeConsEnv e relinker es0)
363 (unsafeTailEnv size0)
339 (unsafeTailEnv size0)
364 (\es -> unEff m es)
340 (\es -> unEff m es)
366− relinker :: Relinker Handler e
342+ relinker :: Relinker HandlerA e
367− relinker = Relinker $ \relink (Handler env handle) -> do
343+ relinker = Relinker $ \relink (HandlerA handlerEs handle) -> do
368− newEnv <- relink env
344+ newHandlerEs <- relink handlerEs
369− pure $ Handler newEnv handle
345+ pure $ HandlerA newHandlerEs handle
371-- | Send an operation of the given effect to its handler for execution.
347-- | Send an operation of the given effect to its handler for execution.
372send :: (HasCallStack, e :> es) => e (Eff es) a -> Eff es a
348send :: (HasCallStack, e :> es) => e (Eff es) a -> Eff es a
373send op = unsafeEff $ \es -> do
349send op = unsafeEff $ \es -> do
374− Handler env handle <- getEnv es
350+ HandlerA handlerEs handle <- getEnv es
375− unEff (handle (LocalEnv es) op) env
351+ unEff (handle (LocalEnv es) op) handlerEs
377----------------------------------------
353----------------------------------------
378−-- Helpers
354+-- Static dispatch
356+-- | An adapter for statically dispatched effects.
358+-- Represents an arbitrary data type with the appropriate number of phantom type
360+newtype DataA :: Effect -> Type where
361+ DataA :: (forall m r. e m r) -> DataA e
363+-- | Run a statically dispatched effect with the given initial state and return
364+-- the final value along with the final state.
380−runEffect :: handler e -> Eff (e : es) a -> Eff es (a, handler e)
365+runData :: DataA e -> Eff (e : es) a -> Eff es (a, DataA e)
381−runEffect e0 m = unsafeEff $ \es0 -> do
366+runData e0 m = unsafeEff $ \es0 -> do
382 size0 <- sizeEnv es0
367 size0 <- sizeEnv es0
383 E.bracket (unsafeConsEnv e0 noRelinker es0)
368 E.bracket (unsafeConsEnv e0 noRelinker es0)
384 (unsafeTailEnv size0)
369 (unsafeTailEnv size0)
385 (\es -> (,) <$> unEff m es <*> getEnv es)
370 (\es -> (,) <$> unEff m es <*> getEnv es)
372+-- | Run a statically dispatched effect with the given initial state and return
373+-- the final value, discarding the final state.
387−evalEffect :: handler e -> Eff (e : es) a -> Eff es a
374+evalData :: DataA e -> Eff (e : es) a -> Eff es a
388−evalEffect e m = unsafeEff $ \es0 -> do
375+evalData e m = unsafeEff $ \es0 -> do
389 size0 <- sizeEnv es0
376 size0 <- sizeEnv es0
390 E.bracket (unsafeConsEnv e noRelinker es0)
377 E.bracket (unsafeConsEnv e noRelinker es0)
391 (unsafeTailEnv size0)
378 (unsafeTailEnv size0)
392 (\es -> unEff m es)
379 (\es -> unEff m es)
381+-- | Run a statically dispatched effect with the given initial state and return
382+-- the final state, discarding the final value.
394−execEffect :: handler e -> Eff (e : es) a -> Eff es (handler e)
383+execData :: DataA e -> Eff (e : es) a -> Eff es (DataA e)
395−execEffect e0 m = unsafeEff $ \es0 -> do
384+execData e0 m = unsafeEff $ \es0 -> do
396 size0 <- sizeEnv es0
385 size0 <- sizeEnv es0
397 E.bracket (unsafeConsEnv e0 noRelinker es0)
386 E.bracket (unsafeConsEnv e0 noRelinker es0)
398 (unsafeTailEnv size0)
387 (unsafeTailEnv size0)
399 (\es -> unEff m es *> getEnv es)
388 (\es -> unEff m es *> getEnv es)
401−getEffect :: e :> es => Eff es (handler e)
390+-- | Fetch the current state of the effect.
391+getData :: e :> es => Eff es (DataA e)
402−getEffect = unsafeEff $ \es -> getEnv es
392+getData = unsafeEff $ \es -> getEnv es
404−putEffect :: e :> es => handler e -> Eff es ()
394+-- | Set the current state of the effect to the given value.
395+putData :: e :> es => DataA e -> Eff es ()
405−putEffect e = unsafeEff $ \es -> putEnv es e
396+putData e = unsafeEff $ \es -> putEnv es e
407−stateEffect :: e :> es => (handler e -> (a, handler e)) -> Eff es a
398+-- | Apply the function to the current state of the effect and return a value.
399+stateData :: e :> es => (DataA e -> (a, DataA e)) -> Eff es a
408−stateEffect f = unsafeEff $ \es -> stateEnv es f
400+stateData f = unsafeEff $ \es -> stateEnv es f
402+-- | Apply the monadic function to the current state of the effect and return a
410−stateEffectM :: e :> es => (handler e -> Eff es (a, handler e)) -> Eff es a
404+stateDataM :: e :> es => (DataA e -> Eff es (a, DataA e)) -> Eff es a
411−stateEffectM f = unsafeEff $ \es -> E.mask $ \release -> do
405+stateDataM f = unsafeEff $ \es -> E.mask $ \release -> do
412 (a, e) <- (\e -> release $ unEff (f e) es) =<< getEnv es
406 (a, e) <- (\e -> release $ unEff (f e) es) =<< getEnv es
413 putEnv es e
407 putEnv es e
410+-- | Execute a computation with a temporarily modified state of the effect.
416−localEffect :: e :> es => (handler e -> handler e) -> Eff es a -> Eff es a
411+localData :: e :> es => (DataA e -> DataA e) -> Eff es a -> Eff es a
417−localEffect f m = unsafeEff $ \es -> do
412+localData f m = unsafeEff $ \es -> do
418 E.bracket (stateEnv es $ \e -> (e, f e))
413 E.bracket (stateEnv es $ \e -> (e, f e))
419 (\e -> putEnv es e)
414 (\e -> putEnv es e)
420 (\_ -> unEff m es)
415 (\_ -> unEff m es)