git.iko.soy/effectful
on master help sign in
swap
0d028399 ahead, 0 behind
24 files changed+281−189
since splitsnapshots
unifiedsplit
.github/workflows/haskell-ci.yml−5 README.md+2−2 effectful-core/effectful-core.cabal+1−1 effectful-core/src/Effectful/Dispatch/Dynamic.hs+15−3 effectful-core/src/Effectful/Dispatch/Static.hs+18−21 effectful-core/src/Effectful/Error.hs+36−6 effectful-core/src/Effectful/Internal/Effect.hs+1−17 effectful-core/src/Effectful/Internal/Env.hs+25−20 effectful-core/src/Effectful/Internal/Monad.hs+69−56 effectful-core/src/Effectful/Reader.hs+3−3 effectful-core/src/Effectful/State/Local.hs+16−13 effectful-core/src/Effectful/State/Shared.hs+31−8 effectful-core/src/Effectful/Writer/Local.hs+24−9 effectful-core/src/Effectful/Writer/Shared.hs+25−10 effectful/bench/Main.hs+3−3 effectful/effectful.cabal+1−1 effectful/src/Effectful/Concurrent/Effect.hs+1−1 effectful/src/Effectful/Environment.hs+1−1 effectful/src/Effectful/FileSystem.hs+1−1 effectful/src/Effectful/FileSystem/Effect.hs+1−1 effectful/src/Effectful/Process.hs+1−1 effectful/src/Effectful/Resource.hs+4−4 effectful/src/Effectful/Temporary.hs+1−1 effectful/src/Effectful/Timeout.hs+1−1
.github/workflows/haskell-ci.yml−5
@@ -37,11 +37,6 @@ jobs:
3737 compilerVersion: 9.2.1
3838 setup-method: ghcup
3939 allow-failure: false
40− - compiler: ghc-9.0.1
41− compilerKind: ghc
42− compilerVersion: 9.0.1
43− setup-method: hvr-ppa
44− allow-failure: false
4540 - compiler: ghc-8.10.7
4641 compilerKind: ghc
4742 compilerVersion: 8.10.7
README.md+2−2
@@ -20,8 +20,8 @@ Main features:
2020
21212. Easy to use API (no boilerplate code and dealing with arcane types).
2222
23−3. Correct semantics in presence of runtime exceptions (no more lost or
24− discarded state).
23+3. Correct semantics in presence of runtime exceptions (no more lost state
24+ modifications).
2525
26264. Seamless integration with the existing ecosystem (`exceptions`,
2727 `monad-control`, `unliftio-core`, `resourcet` etc.).
effectful-core/effectful-core.cabal+1−1
@@ -18,7 +18,7 @@ description: An easy to use, performant extensible effects library with seamless
1818
1919extra-source-files: CHANGELOG.md
2020
21−tested-with: GHC ==8.8.4 || ==8.10.7 || ==9.0.1 || ==9.2.1
21+tested-with: GHC ==8.8.4 || ==8.10.7 || ==9.2.1
2222
2323bug-reports: https://github.com/arybczak/effectful/issues
2424source-repository head
effectful-core/src/Effectful/Dispatch/Dynamic.hs+15−3
@@ -32,7 +32,8 @@ module Effectful.Dispatch.Dynamic
3232 ) where
3333
3434import Control.Monad.IO.Unlift
35−import GHC.Stack
35+import Data.Kind
36+import GHC.Stack (HasCallStack)
3637
3738import Effectful.Internal.Effect
3839import Effectful.Internal.Env
@@ -49,7 +50,7 @@ interpret
4950 -> Eff es a
5051interpret handler m = unsafeEff $ \es -> do
5152 les <- forkEnv es
52− (`unEff` es) $ runHandlerA (HandlerA les handler) m
53+ (`unEff` es) $ runHandler (HandlerA les handler) m
5354
5455-- | Interpret an effect using other effects.
5556reinterpret
@@ -62,7 +63,7 @@ reinterpret
6263reinterpret runHandlerEs handler m = unsafeEff $ \es -> do
6364 les0 <- forkEnv es
6465 (`unEff` les0) . runHandlerEs . unsafeEff $ \les -> do
65− (`unEff` es) $ runHandlerA (HandlerA les handler) m
66+ (`unEff` es) $ runHandler (HandlerA les handler) m
6667
6768----------------------------------------
6869-- Unlifts
@@ -230,5 +231,16 @@ localLiftUnliftIO (LocalEnv les) strategy k = case strategy of
230231 SeqUnlift -> liftIO $ seqUnliftIO les $ k unsafeEff_
231232 ConcUnlift p l -> liftIO $ concUnliftIO les p l $ k unsafeEff_
232233
234+----------------------------------------
235+-- Utils
236+
237+-- | Require that the second list of effects is a suffix of the first one.
238+--
239+-- In other words, 'SuffixOf' @es@ @baseEs@ means "a suffix of @es@ is
240+-- @baseEs@".
241+type family SuffixOf (es :: [Effect]) (baseEs :: [Effect]) :: Constraint where
242+ SuffixOf baseEs baseEs = ()
243+ SuffixOf (e : es) baseEs = SuffixOf es baseEs
244+
233245-- $setup
234246-- >>> import Control.Concurrent
effectful-core/src/Effectful/Dispatch/Static.hs+18−21
@@ -1,23 +1,30 @@
11module Effectful.Dispatch.Static
22 ( -- * Low level API
3− IdA(..)
3+ DataA(..)
44
5− -- ** Running
6− , runEffect
7− , evalEffect
8− , execEffect
5+ -- ** Extending the environment
6+ , runData
7+ , evalData
8+ , execData
99
10− -- ** Modification
11− , getEffect
12− , putEffect
13− , stateEffect
14− , stateEffectM
15− , localEffect
10+ -- ** Data retrieval and update
11+ , getData
12+ , putData
13+ , stateData
14+ , stateDataM
15+ , localData
1616
1717 -- ** Unlifts
1818 , seqUnliftIO
1919 , concUnliftIO
2020
21+ -- ** Utils
22+ , unEff
23+ , unsafeEff
24+ , unsafeEff_
25+ , unsafeLiftMapIO
26+ , unsafeUnliftIO
27+
2128 -- * Primitive API
2229 , Env
2330 , Relinker(..)
@@ -39,18 +46,8 @@ module Effectful.Dispatch.Static
3946 , putEnv
4047 , stateEnv
4148 , modifyEnv
42−
43− -- * Unsafe 'Eff' operations
44− , unsafeEff
45− , unsafeEff_
46− , unsafeLiftMapIO
47− , unsafeUnliftIO
48−
49− -- * Utils
50− , unEff
5149 ) where
5250
53−import Effectful.Internal.Effect
5451import Effectful.Internal.Env
5552import Effectful.Internal.Monad
5653
effectful-core/src/Effectful/Error.hs+36−6
@@ -1,8 +1,6 @@
11-- | Support for handling errors of a particular type, i.e. checked exceptions.
22--
3−-- /Note:/ the 'Error' effect is a suitable replacement for the
4−-- 'Control.Monad.Trans.Except.ExceptT' monad transformer from the
5−-- @transformers@ library. It is __not__ a general mechanism for handling
3+-- The 'Error' effect is __not__ a general mechanism for handling regular
64-- exceptions, that's what functions from the @exceptions@ library are for (see
75-- "Control.Monad.Catch" for more information).
86--
@@ -37,6 +35,38 @@
3735-- Cleaning up.
3836-- Left "oops"
3937--
38+-- /Note:/ unlike the 'Control.Monad.Trans.Except.ExceptT' monad transformer
39+-- from the @transformers@ library, the order in which you handle the 'Error'
40+-- effect with regard to other stateful effects does not matter. Consider the
41+-- following:
42+--
43+-- >>> import qualified Control.Monad.State.Strict as T
44+-- >>> import qualified Control.Monad.Except as T
45+--
46+-- >>> let m1 = (T.modify (++ " there!") >> T.throwError "oops") `T.catchError` \_ -> pure ()
47+--
48+-- >>> (`T.runStateT` "Hi") . T.runExceptT $ m1
49+-- (Right (),"Hi there!")
50+--
51+-- >>> T.runExceptT . (`T.runStateT` "Hi") $ m1
52+-- Right ((),"Hi")
53+--
54+-- Here, whether state modifications within the @catchError@ block are lost or
55+-- not depends on the shape of the monad transformer stack, which is surprising
56+-- and can be a source of subtle bugs. On the other hand:
57+--
58+-- >>> import Effectful.State.Local
59+--
60+-- >>> let m2 = (modify (++ " there!") >> throwError "oops") `catchError` \_ (_::String) -> pure ()
61+--
62+-- >>> runEff . runState "Hi" . runError @String $ m2
63+-- (Right (),"Hi there!")
64+--
65+-- >>> runEff . runError @String . runState "Hi" $ m2
66+-- Right ((),"Hi there!")
67+--
68+-- Here, no matter the order of effects, state modifications within the
69+-- @catchError@ block always persist, giving predictable behavior.
4070module Effectful.Error
4171 ( Error
4272 , runError
@@ -72,7 +102,7 @@ runError
72102runError m = unsafeEff $ \es0 -> mask $ \release -> do
73103 eid <- newErrorId
74104 size0 <- sizeEnv es0
75− es <- unsafeConsEnv (IdA (Error @e eid)) noRelinker es0
105+ es <- unsafeConsEnv (DataA (Error @e eid)) noRelinker es0
76106 r <- tryErrorIO release eid es `onException` unsafeTailEnv size0 es
77107 unsafeTailEnv size0 es
78108 pure r
@@ -89,7 +119,7 @@ throwError
89119 -- ^ The error.
90120 -> Eff es a
91121throwError e = unsafeEff $ \es -> do
92− IdA (Error eid) <- getEnv @(Error e) es
122+ DataA (Error eid) <- getEnv @(Error e) es
93123 throwIO $ ErrorEx eid callStack e
94124
95125-- | Handle an error of type @e@.
@@ -101,7 +131,7 @@ catchError
101131 -- ^ A handler for errors in the inner computation.
102132 -> Eff es a
103133catchError m handler = unsafeEff $ \es -> do
104− IdA (Error eid) <- getEnv @(Error e) es
134+ DataA (Error eid) <- getEnv @(Error e) es
105135 size <- sizeEnv es
106136 catchErrorIO eid (unEff m es) $ \cs e -> do
107137 checkSizeEnv size es
effectful-core/src/Effectful/Internal/Effect.hs+1−17
@@ -8,10 +8,6 @@
88module Effectful.Internal.Effect
99 ( Effect
1010 , (:>)(..)
11− , IdA(..)
12−
13− -- * Utils
14− , SuffixOf
1511
1612 -- * Re-exports
1713 , Type
@@ -23,10 +19,6 @@ import GHC.TypeLits
2319-- | The kind of effects.
2420type Effect = (Type -> Type) -> Type -> Type
2521
26−-- | An adapter for statically dispatched effects.
27−newtype IdA :: Effect -> Type where
28− IdA :: (forall m r. e m r) -> IdA e
29−
3022-- | A constraint that requires that a particular effect @e@ is a member of the
3123-- type-level list @es@. This is used to parameterize an 'Effectful.Monad.Eff'
3224-- computation over an arbitrary list of effects, so long as @e@ is /somewhere/
@@ -36,7 +28,7 @@ newtype IdA :: Effect -> Type where
3628-- 'Integer' would likely use the following type:
3729--
3830-- @
39−-- 'Effectful.State.State' 'Integer' ':>' es => 'Effectful.Monad.Eff' es ()
31+-- 'Effectful.State.Local.State' 'Integer' ':>' es => 'Effectful.Monad.Eff' es ()
4032-- @
4133class (e :: Effect) :> (es :: [Effect]) where
4234 -- | Get the position of @e@ in @es@.
@@ -59,11 +51,3 @@ instance {-# OVERLAPPING #-} e :> (e : es) where
5951
6052instance e :> es => e :> (x : es) where
6153 reifyIndex = 1 + reifyIndex @e @es
62−
63−-- | Require that the second list of effects is a suffix of the first one.
64−--
65−-- In other words, 'SuffixOf' @es@ @baseEs@ means "a suffix of @es@ is
66−-- @baseEs@".
67−type family SuffixOf (es :: [Effect]) (baseEs :: [Effect]) :: Constraint where
68− SuffixOf baseEs baseEs = ()
69− SuffixOf (e : es) baseEs = SuffixOf es baseEs
effectful-core/src/Effectful/Internal/Env.hs+25−20
@@ -1,3 +1,4 @@
1+{-# LANGUAGE MagicHash #-}
12{-# OPTIONS_HADDOCK not-home #-}
23-- | The environment for the 'Effectful.Internal.Monad.Eff' monad.
34--
@@ -42,7 +43,7 @@ import Control.Monad
4243import Control.Monad.Primitive
4344import Data.IORef
4445import Data.Primitive.SmallArray
45−import GHC.Exts (Any)
46+import GHC.Exts (Any, SmallMutableArray#)
4647import GHC.Stack (HasCallStack)
4748import Unsafe.Coerce
4849import qualified Data.IntMap.Strict as IM
@@ -417,43 +418,43 @@ unsafeTailEnv len (Env fork gref _) = case fork of
417418
418419-- | Extract a specific data type from the environment.
419420getEnv
420− :: forall e es adapter. e :> es
421+ :: forall e adapter es. e :> es
421422 => Env es
422423 -> IO (adapter e)
423424getEnv env = do
424− (i, es) <- getLocation (reifyIndex @e @es) env
425+ Location i es <- getLocation (reifyIndex @e @es) env
425426 fromAny <$> readSmallArray es i
426427
427428-- | Replace the data type in the environment with a new value (in place).
428429putEnv
429− :: forall e es adapter. e :> es
430+ :: forall e adapter es. e :> es
430431 => Env es
431432 -> adapter e
432433 -> IO ()
433434putEnv env e = do
434− (i, es) <- getLocation (reifyIndex @e @es) env
435+ Location i es <- getLocation (reifyIndex @e @es) env
435436 e `seq` writeSmallArray es i (toAny e)
436437
437438-- | Modify the data type in the environment (in place) and return a value.
438439stateEnv
439− :: forall e es adapter a. e :> es
440+ :: forall e adapter es a. e :> es
440441 => Env es
441442 -> (adapter e -> (a, adapter e))
442443 -> IO a
443444stateEnv env f = do
444− (i, es) <- getLocation (reifyIndex @e @es) env
445+ Location i es <- getLocation (reifyIndex @e @es) env
445446 (a, e) <- f . fromAny <$> readSmallArray es i
446447 e `seq` writeSmallArray es i (toAny e)
447448 pure a
448449
449450-- | Modify the data type in the environment (in place).
450451modifyEnv
451− :: forall e es adapter. e :> es
452+ :: forall e adapter es. e :> es
452453 => Env es
453454 -> (adapter e -> adapter e)
454455 -> IO ()
455456modifyEnv env f = do
456− (i, es) <- getLocation (reifyIndex @e @es) env
457+ Location i es <- getLocation (reifyIndex @e @es) env
457458 e <- f . fromAny <$> readSmallArray es i
458459 e `seq` writeSmallArray es i (toAny e)
459460
@@ -469,13 +470,17 @@ emptyEnvRef = do
469470 fs <- newSmallArray 0 undefinedData
470471 newIORef $ EnvRef 0 es fs
471472
473+-- | Location with unboxed fields to make GHC generate Core without unnecessary
474+-- reboxing around the local 'go' function from 'getLocation'.
475+data Location = Location !Int !(SmallMutableArray RealWorld Any)
476+
472477-- | Determine location of the data type in the environment.
473478getLocation
474479 :: Int
475480 -> Env es
476− -> IO (Int, SmallMutableArray RealWorld Any)
481+ -> IO Location
477482getLocation ixE (Env fork ref _) = do
478− EnvRef n es _ <- readIORef ref
483+ EnvRef n es@(SmallMutableArray es#) _ <- readIORef ref
479484 -- Optimized for the common access pattern:
480485 --
481486 -- - Most application code has no access to forks, in which case we look at
@@ -484,25 +489,25 @@ getLocation ixE (Env fork ref _) = do
484489 -- - Effect handlers will most likely access the newest fork with handler
485490 -- specific effects for reinterpretation.
486491 case fork of
487− NoFork -> pure (ix n, es)
492+ NoFork -> pure $ Location (ix n) es
488493 Forks _ baseIx lref forks -> do
489494 EnvRef ln les _ <- readIORef lref
490495 let i = ix (baseIx + ln)
491496 if i >= baseIx
492− then pure (i - baseIx, les)
493− else go es i forks
497+ then pure $ Location (i - baseIx) les
498+ else go es# i forks
494499 where
495− go :: SmallMutableArray RealWorld Any
500+ go :: SmallMutableArray# RealWorld Any
496501 -> Int
497502 -> Forks
498− -> IO (Int, SmallMutableArray RealWorld Any)
499− go es i = \case
500− NoFork -> pure (i, es)
503+ -> IO Location
504+ go es# i = \case
505+ NoFork -> pure $ Location i (SmallMutableArray es#)
501506 Forks _ baseIx lref forks -> do
502507 EnvRef _ les _ <- readIORef lref
503508 if i >= baseIx
504− then pure (i - baseIx, les)
505− else go es i forks
509+ then pure $ Location (i - baseIx) les
510+ else go es# i forks
506511
507512 ix :: Int -> Int
508513 ix n = n - ixE - 1
effectful-core/src/Effectful/Internal/Monad.hs+69−56
@@ -6,7 +6,7 @@
66-- This module is intended for internal use only, and may change without warning
77-- in subsequent releases.
88module Effectful.Internal.Monad
9− ( -- * Monad
9+ ( -- * The 'Eff' monad
1010 Eff
1111 , runPureEff
1212
@@ -22,11 +22,11 @@ module Effectful.Internal.Monad
2222 , IOE
2323 , runEff
2424
25− -- * Primitive
25+ -- * Prim
2626 , Prim
2727 , runPrim
2828
29− -- ** Unlift strategies
29+ -- * Unlift strategies
3030 , UnliftStrategy(..)
3131 , Persistence(..)
3232 , Limit(..)
@@ -34,34 +34,29 @@ module Effectful.Internal.Monad
3434 , withUnliftStrategy
3535 , withEffToIO
3636
37− --- *** Low-level helpers
37+ -- ** Low-level unlifts
3838 , seqUnliftIO
3939 , concUnliftIO
4040
4141 -- * Effects
4242
43− -- ** Handler
43+ -- ** Dynamic dispatch
4444 , EffectHandler
4545 , LocalEnv(..)
4646 , HandlerA(..)
47− , runHandlerA
48−
49− -- *** Sending operations
47+ , runHandler
5048 , send
5149
52− -- ** Primitive
53−
54− -- *** Running
55− , runEffect
56− , evalEffect
57− , execEffect
58−
59− -- *** Modification
60− , getEffect
61− , putEffect
62− , stateEffect
63− , stateEffectM
64− , localEffect
50+ -- ** Static dispatch
51+ , DataA(..)
52+ , runData
53+ , evalData
54+ , execData
55+ , getData
56+ , putData
57+ , stateData
58+ , stateDataM
59+ , localData
6560 ) where
6661
6762import Control.Applicative (liftA2)
@@ -92,17 +87,16 @@ type role Eff nominal representational
9287-- would have the following type:
9388--
9489-- @
95−-- 'Eff' '['Effectful.Reader.Reader' 'String', 'Effectful.State.State' 'Bool'] 'Integer'
90+-- 'Eff' '['Effectful.Reader.Reader' 'String', 'Effectful.State.Local.State' 'Bool'] 'Integer'
9691-- @
9792--
9893-- Normally, a concrete list of effects is not used to parameterize 'Eff'.
9994-- Instead, the '(:>)' type class is used to express constraints on the list of
10095-- effects without coupling a computation to a concrete list of effects. For
101−-- example, the above example would more commonly be expressed with the
102−-- following type:
96+-- example, the above example would be expressed with the following type:
10397--
10498-- @
105−-- ('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'
106100-- @
107101--
108102-- This abstraction allows the computation to be used in functions that may
@@ -116,12 +110,12 @@ newtype Eff (es :: [Effect]) a = Eff (Env es -> IO a)
116110-- For running computations with side effects see 'runEff'.
117111runPureEff :: Eff '[] a -> a
118112runPureEff (Eff m) =
119− -- unsafePerformIO is safe here since IOE was not on the stack, so no IO with
120− -- side effects was performed (unless someone sneakily introduced side effects
121− -- with unsafeEff, but then all bets are off).
113+ -- unsafeDupablePerformIO is safe here since IOE was not on the stack, so no
114+ -- IO with side effects was performed (unless someone sneakily introduced side
115+ -- effects with unsafeEff, but then all bets are off).
122116 --
123117 -- Moreover, internals don't allocate any resources that require explicit
124− -- cleanup actions to run, so the "Dupable" part should also be just fine.
118+ -- cleanup actions to run.
125119 unsafeDupablePerformIO $ m =<< emptyEnv
126120
127121----------------------------------------
@@ -151,12 +145,12 @@ unsafeEff_ m = unsafeEff $ \_ -> m
151145-- | Get the current 'UnliftStrategy'.
152146unliftStrategy :: IOE :> es => Eff es UnliftStrategy
153147unliftStrategy = do
154− IdA (IOE unlift) <- getEffect
148+ DataA (IOE unlift) <- getData
155149 pure unlift
156150
157151-- | Locally override the 'UnliftStrategy' with the given value.
158152withUnliftStrategy :: IOE :> es => UnliftStrategy -> Eff es a -> Eff es a
159−withUnliftStrategy unlift = localEffect $ \_ -> IdA (IOE unlift)
153+withUnliftStrategy unlift = localData $ \_ -> DataA (IOE unlift)
160154
161155-- | Create an unlifting function with the current 'UnliftStrategy'.
162156--
@@ -164,7 +158,7 @@ withUnliftStrategy unlift = localEffect $ \_ -> IdA (IOE unlift)
164158-- constraint for accurate stack traces in case an insufficiently powerful
165159-- 'UnliftStrategy' is used and the unlifting function fails.
166160--
167−-- /Note:/ the strategy is reset to 'SeqUnlift' for new threads.
161+-- /Note:/ the strategy is reset to 'SeqUnlift' inside the continuation.
168162withEffToIO
169163 :: (HasCallStack, IOE :> es)
170164 => ((forall r. Eff es r -> IO r) -> IO a)
@@ -272,7 +266,7 @@ newtype IOE :: Effect where
272266--
273267-- For running pure computations see 'runPureEff'.
274268runEff :: Eff '[IOE] a -> IO a
275−runEff m = unEff (evalEffect (IdA (IOE SeqUnlift)) m) =<< emptyEnv
269+runEff m = unEff (evalData (DataA (IOE SeqUnlift)) m) =<< emptyEnv
276270
277271instance IOE :> es => MonadIO (Eff es) where
278272 liftIO = unsafeEff_
@@ -302,14 +296,14 @@ data Prim :: Effect where
302296
303297-- | Run an 'Eff' computation with primitive state-transformer actions.
304298runPrim :: IOE :> es => Eff (Prim : es) a -> Eff es a
305−runPrim = evalEffect (IdA Prim)
299+runPrim = evalData (DataA Prim)
306300
307301instance Prim :> es => PrimMonad (Eff es) where
308302 type PrimState (Eff es) = RealWorld
309303 primitive = unsafeEff_ . IO
310304
311305----------------------------------------
312−-- Handler
306+-- Dynamic dispatch
313307
314308type role LocalEnv nominal nominal
315309
@@ -333,13 +327,13 @@ type EffectHandler e es
333327
334328-- | An adapter for dynamically dispatched effects.
335329--
336−-- Represents the effect handler bundled along with its environment.
330+-- Represents the effect handler bundled with its environment.
337331data HandlerA :: Effect -> Type where
338332 HandlerA :: !(Env es) -> !(EffectHandler e es) -> HandlerA e
339333
340−-- | Run the effect with the given handler.
341−runHandlerA :: HandlerA e -> Eff (e : es) a -> Eff es a
342−runHandlerA e m = unsafeEff $ \es0 -> do
334+-- | Run a dynamically dispatched effect with the given handler.
335+runHandler :: HandlerA e -> Eff (e : es) a -> Eff es a
336+runHandler e m = unsafeEff $ \es0 -> do
343337 size0 <- sizeEnv es0
344338 E.bracket (unsafeConsEnv e relinker es0)
345339 (unsafeTailEnv size0)
@@ -357,46 +351,65 @@ send op = unsafeEff $ \es -> do
357351 unEff (handle (LocalEnv es) op) handlerEs
358352
359353----------------------------------------
360−-- Helpers
354+-- Static dispatch
361355
362−runEffect :: adapter e -> Eff (e : es) a -> Eff es (a, adapter e)
363−runEffect e0 m = unsafeEff $ \es0 -> do
356+-- | An adapter for statically dispatched effects.
357+--
358+-- Represents an arbitrary data type with the appropriate number of phantom type
359+-- parameters.
360+newtype DataA :: Effect -> Type where
361+ DataA :: (forall m r. e m r) -> DataA e
362+
363+-- | Run a statically dispatched effect with the given initial state and return
364+-- the final value along with the final state.
365+runData :: DataA e -> Eff (e : es) a -> Eff es (a, DataA e)
366+runData e0 m = unsafeEff $ \es0 -> do
364367 size0 <- sizeEnv es0
365368 E.bracket (unsafeConsEnv e0 noRelinker es0)
366369 (unsafeTailEnv size0)
367370 (\es -> (,) <$> unEff m es <*> getEnv es)
368371
369−evalEffect :: adapter e -> Eff (e : es) a -> Eff es a
370−evalEffect e m = unsafeEff $ \es0 -> do
372+-- | Run a statically dispatched effect with the given initial state and return
373+-- the final value, discarding the final state.
374+evalData :: DataA e -> Eff (e : es) a -> Eff es a
375+evalData e m = unsafeEff $ \es0 -> do
371376 size0 <- sizeEnv es0
372377 E.bracket (unsafeConsEnv e noRelinker es0)
373378 (unsafeTailEnv size0)
374379 (\es -> unEff m es)
375380
376−execEffect :: adapter e -> Eff (e : es) a -> Eff es (adapter e)
377−execEffect e0 m = unsafeEff $ \es0 -> do
381+-- | Run a statically dispatched effect with the given initial state and return
382+-- the final state, discarding the final value.
383+execData :: DataA e -> Eff (e : es) a -> Eff es (DataA e)
384+execData e0 m = unsafeEff $ \es0 -> do
378385 size0 <- sizeEnv es0
379386 E.bracket (unsafeConsEnv e0 noRelinker es0)
380387 (unsafeTailEnv size0)
381388 (\es -> unEff m es *> getEnv es)
382389
383−getEffect :: e :> es => Eff es (adapter e)
384−getEffect = unsafeEff $ \es -> getEnv es
390+-- | Fetch the current state of the effect.
391+getData :: e :> es => Eff es (DataA e)
392+getData = unsafeEff $ \es -> getEnv es
385393
386−putEffect :: e :> es => adapter e -> Eff es ()
387−putEffect e = unsafeEff $ \es -> putEnv es e
394+-- | Set the current state of the effect to the given value.
395+putData :: e :> es => DataA e -> Eff es ()
396+putData e = unsafeEff $ \es -> putEnv es e
388397
389−stateEffect :: e :> es => (adapter e -> (a, adapter e)) -> Eff es a
390−stateEffect f = unsafeEff $ \es -> stateEnv es f
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
400+stateData f = unsafeEff $ \es -> stateEnv es f
391401
392−stateEffectM :: e :> es => (adapter e -> Eff es (a, adapter e)) -> Eff es a
393−stateEffectM f = unsafeEff $ \es -> E.mask $ \release -> do
402+-- | Apply the monadic function to the current state of the effect and return a
403+-- value.
404+stateDataM :: e :> es => (DataA e -> Eff es (a, DataA e)) -> Eff es a
405+stateDataM f = unsafeEff $ \es -> E.mask $ \release -> do
394406 (a, e) <- (\e -> release $ unEff (f e) es) =<< getEnv es
395407 putEnv es e
396408 pure a
397409
398−localEffect :: e :> es => (adapter e -> adapter e) -> Eff es a -> Eff es a
399−localEffect f m = unsafeEff $ \es -> do
410+-- | Execute a computation with a temporarily modified state of the effect.
411+localData :: e :> es => (DataA e -> DataA e) -> Eff es a -> Eff es a
412+localData f m = unsafeEff $ \es -> do
400413 E.bracket (stateEnv es $ \e -> (e, f e))
401414 (\e -> putEnv es e)
402415 (\_ -> unEff m es)
effectful-core/src/Effectful/Reader.hs+3−3
@@ -20,12 +20,12 @@ runReader
2020 :: r -- ^ An initial environment.
2121 -> Eff (Reader r : es) a
2222 -> Eff es a
23−runReader r = evalEffect (IdA (Reader r))
23+runReader r = evalData (DataA (Reader r))
2424
2525-- | Fetch the value of the environment.
2626ask :: Reader r :> es => Eff es r
2727ask = do
28− IdA (Reader r) <- getEffect
28+ DataA (Reader r) <- getData
2929 pure r
3030
3131-- | Retrieve a function of the current environment.
@@ -46,4 +46,4 @@ local
4646 => (r -> r) -- ^ The function to modify the environment.
4747 -> Eff es a
4848 -> Eff es a
49−local f = localEffect $ \(IdA (Reader r)) -> IdA (Reader (f r))
49+local f = localData $ \(DataA (Reader r)) -> DataA (Reader (f r))
effectful-core/src/Effectful/State/Local.hs+16−13
@@ -5,13 +5,12 @@
55--
66-- - very fast.
77--
8−-- /Note:/ unlike 'Control.Monad.Trans.State.StateT', the 'State' effect doesn't
9−-- lose state modifications in presence of runtime exceptions:
10−--
11−-- >>> import Control.Exception (ErrorCall)
12−-- >>> import Control.Monad.Catch
8+-- /Note:/ unlike the 'Control.Monad.Trans.State.StateT' monad transformer from
9+-- the @transformers@ library, the 'State' effect doesn't lose state
10+-- modifications when an exception is received:
1311--
1412-- >>> import qualified Control.Monad.Trans.State.Strict as S
13+--
1514-- >>> :{
1615-- (`S.execStateT` "Hi") . handle (\(_::ErrorCall) -> pure ()) $ do
1716-- S.modify (++ " there!")
@@ -53,7 +52,7 @@ runState
5352 -> Eff (State s : es) a
5453 -> Eff es (a, s)
5554runState s0 m = do
56− (a, IdA (State s)) <- runEffect (IdA (State s0)) m
55+ (a, DataA (State s)) <- runData (DataA (State s0)) m
5756 pure (a, s)
5857
5958-- | Run a 'State' effect with the given initial state and return the final
@@ -62,7 +61,7 @@ evalState
6261 :: s -- ^ An initial state.
6362 -> Eff (State s : es) a
6463 -> Eff es a -- ^ A return value.
65−evalState s = evalEffect (IdA (State s))
64+evalState s = evalData (DataA (State s))
6665
6766-- | Run a 'State' effect with the given initial state and return the final
6867-- state, discarding the final value.
@@ -71,13 +70,13 @@ execState
7170 -> Eff (State s : es) a
7271 -> Eff es s
7372execState s0 m = do
74− IdA (State s) <- execEffect (IdA (State s0)) m
73+ DataA (State s) <- execData (DataA (State s0)) m
7574 pure s
7675
7776-- | Fetch the current value of the state.
7877get :: State s :> es => Eff es s
7978get = do
80− IdA (State s) <- getEffect
79+ DataA (State s) <- getData
8180 pure s
8281
8382-- | Get a function of the current state.
@@ -91,14 +90,14 @@ gets f = f <$> get
9190
9291-- | Set the current state to the given value.
9392put :: State s :> es => s -> Eff es ()
94−put s = putEffect (IdA (State s))
93+put s = putData (DataA (State s))
9594
9695-- | Apply the function to the current state and return a value.
9796state
9897 :: State s :> es
9998 => (s -> (a, s)) -- ^ The function to modify the state.
10099 -> Eff es a
101−state f = stateEffect $ \(IdA (State s0)) -> let (a, s) = f s0 in (a, IdA (State s))
100+state f = stateData $ \(DataA (State s0)) -> let (a, s) = f s0 in (a, DataA (State s))
102101
103102-- | Apply the function to the current state.
104103--
@@ -114,9 +113,9 @@ stateM
114113 :: State s :> es
115114 => (s -> Eff es (a, s)) -- ^ The function to modify the state.
116115 -> Eff es a
117−stateM f = stateEffectM $ \(IdA (State s0)) -> do
116+stateM f = stateDataM $ \(DataA (State s0)) -> do
118117 (a, s) <- f s0
119− pure (a, IdA (State s))
118+ pure (a, DataA (State s))
120119
121120-- | Apply the monadic function to the current state.
122121--
@@ -126,3 +125,7 @@ modifyM
126125 => (s -> Eff es s) -- ^ The monadic function to modify the state.
127126 -> Eff es ()
128127modifyM f = stateM (\s -> ((), ) <$> f s)
128+
129+-- $setup
130+-- >>> import Control.Exception (ErrorCall)
131+-- >>> import Control.Monad.Catch
effectful-core/src/Effectful/State/Shared.hs+31−8
@@ -3,8 +3,27 @@
33-- - shared between multiple threads (if you want each thead to manage its own
44-- version of the value, see "Effectful.State.Local").
55--
6−-- - slower than "Effectful.State.Local".
6+-- - slightly slower than "Effectful.State.Local".
77--
8+-- /Note:/ unlike the 'Control.Monad.Trans.State.StateT' monad transformer from
9+-- the @transformers@ library, the 'State' effect doesn't lose state
10+-- modifications when an exception is received:
11+--
12+-- >>> import qualified Control.Monad.Trans.State.Strict as S
13+--
14+-- >>> :{
15+-- (`S.execStateT` "Hi") . handle (\(_::ErrorCall) -> pure ()) $ do
16+-- S.modify (++ " there!")
17+-- error "oops"
18+-- :}
19+-- "Hi"
20+--
21+-- >>> :{
22+-- runEff . execState "Hi" . handle (\(_::ErrorCall) -> pure ()) $ do
23+-- modify (++ " there!")
24+-- error "oops"
25+-- :}
26+-- "Hi there!"
827module Effectful.State.Shared
928 ( State
1029 , runState
@@ -33,7 +52,7 @@ newtype State s :: Effect where
3352runState :: s -> Eff (State s : es) a -> Eff es (a, s)
3453runState s m = do
3554 v <- unsafeEff_ $ newMVar s
36− a <- evalEffect (IdA (State v)) m
55+ a <- evalData (DataA (State v)) m
3756 (a, ) <$> unsafeEff_ (readMVar v)
3857
3958-- | Run a 'State' effect with the given initial state and return the final
@@ -41,20 +60,20 @@ runState s m = do
4160evalState :: s -> Eff (State s : es) a -> Eff es a
4261evalState s m = do
4362 v <- unsafeEff_ $ newMVar s
44− evalEffect (IdA (State v)) m
63+ evalData (DataA (State v)) m
4564
4665-- | Run a 'State' effect with the given initial state and return the final
4766-- state, discarding the final value.
4867execState :: s -> Eff (State s : es) a -> Eff es s
4968execState s m = do
5069 v <- unsafeEff_ $ newMVar s
51− _ <- evalEffect (IdA (State v)) m
70+ _ <- evalData (DataA (State v)) m
5271 unsafeEff_ $ readMVar v
5372
5473-- | Fetch the current value of the state.
5574get :: State s :> es => Eff es s
5675get = unsafeEff $ \es -> do
57− IdA (State v) <- getEnv es
76+ DataA (State v) <- getEnv es
5877 readMVar v
5978
6079-- | Get a function of the current state.
@@ -66,7 +85,7 @@ gets f = f <$> get
6685-- | Set the current state to the given value.
6786put :: State s :> es => s -> Eff es ()
6887put s = unsafeEff $ \es -> do
69− IdA (State v) <- getEnv es
88+ DataA (State v) <- getEnv es
7089 modifyMVar_ v $ \_ -> s `seq` pure s
7190
7291-- | Apply the function to the current state and return a value.
@@ -74,7 +93,7 @@ put s = unsafeEff $ \es -> do
7493-- /Note:/ this function gets an exclusive access to the state for its duration.
7594state :: State s :> es => (s -> (a, s)) -> Eff es a
7695state f = unsafeEff $ \es -> do
77− IdA (State v) <- getEnv es
96+ DataA (State v) <- getEnv es
7897 modifyMVar v $ \s0 -> let (a, s) = f s0 in s `seq` pure (s, a)
7998
8099-- | Apply the function to the current state.
@@ -90,7 +109,7 @@ modify f = state (\s -> ((), f s))
90109-- /Note:/ this function gets an exclusive access to the state for its duration.
91110stateM :: State s :> es => (s -> Eff es (a, s)) -> Eff es a
92111stateM f = unsafeEff $ \es -> do
93− IdA (State v) <- getEnv es
112+ DataA (State v) <- getEnv es
94113 modifyMVar v $ \s0 -> do
95114 (a, s) <- unEff (f s0) es
96115 s `seq` pure (s, a)
@@ -102,3 +121,7 @@ stateM f = unsafeEff $ \es -> do
102121-- /Note:/ this function gets an exclusive access to the state for its duration.
103122modifyM :: State s :> es => (s -> Eff es s) -> Eff es ()
104123modifyM f = stateM (\s -> ((), ) <$> f s)
124+
125+-- $setup
126+-- >>> import Control.Exception (ErrorCall)
127+-- >>> import Control.Monad.Catch
effectful-core/src/Effectful/Writer/Local.hs+24−9
@@ -24,7 +24,7 @@ module Effectful.Writer.Local
2424 , listens
2525 ) where
2626
27−import Control.Exception
27+import Control.Exception (onException, mask)
2828
2929import Effectful.Dispatch.Static
3030import Effectful.Monad
@@ -38,35 +38,46 @@ newtype Writer w :: Effect where
3838-- output.
3939runWriter :: Monoid w => Eff (Writer w : es) a -> Eff es (a, w)
4040runWriter m = do
41− (a, IdA (Writer w)) <- runEffect (IdA (Writer mempty)) m
41+ (a, DataA (Writer w)) <- runData (DataA (Writer mempty)) m
4242 pure (a, w)
4343
4444-- | Run a 'Writer' effect and return the final output, discarding the final
4545-- value.
4646execWriter :: Monoid w => Eff (Writer w : es) a -> Eff es w
4747execWriter m = do
48− IdA (Writer w) <- execEffect (IdA (Writer mempty)) m
48+ DataA (Writer w) <- execData (DataA (Writer mempty)) m
4949 pure w
5050
5151-- | Append the given output to the overall output of the 'Writer'.
5252tell :: (Writer w :> es, Monoid w) => w -> Eff es ()
53−tell w = stateEffect $ \(IdA (Writer w0)) -> ((), IdA (Writer (w0 <> w)))
53+tell w = stateData $ \(DataA (Writer w0)) -> ((), DataA (Writer (w0 <> w)))
5454
5555-- | Execute an action and append its output to the overall output of the
5656-- 'Writer'.
5757--
58−-- /Note:/ if a runtime exception is received while the action is executed, the
59−-- partial output of the action will still be appended to the overall output of
60−-- the 'Writer'.
58+-- /Note:/ if an exception is received while the action is executed, the partial
59+-- output of the action will still be appended to the overall output of the
60+-- 'Writer':
61+--
62+-- >>> :{
63+-- runEff . execWriter @String $ do
64+-- tell "Hi"
65+-- handle (\(_::ErrorCall) -> pure ((), "")) $ do
66+-- tell " there"
67+-- listen $ do
68+-- tell "!"
69+-- error "oops"
70+-- :}
71+-- "Hi there!"
6172listen :: (Writer w :> es, Monoid w) => Eff es a -> Eff es (a, w)
6273listen m = unsafeEff $ \es -> mask $ \restore -> do
63− w0 <- stateEnv es $ \(IdA (Writer w)) -> (w, IdA (Writer mempty))
74+ w0 <- stateEnv es $ \(DataA (Writer w)) -> (w, DataA (Writer mempty))
6475 a <- restore (unEff m es) `onException` merge es w0
6576 (a, ) <$> merge es w0
6677 where
6778 merge es w0 =
6879 -- If an exception is thrown, restore w0 and keep parts of w1.
69− stateEnv es $ \(IdA (Writer w1)) -> (w1, IdA (Writer (w0 <> w1)))
80+ stateEnv es $ \(DataA (Writer w1)) -> (w1, DataA (Writer (w0 <> w1)))
7081
7182-- | Execute an action and append its output to the overall output of the
7283-- 'Writer', then return the final value along with a function of the recorded
@@ -77,3 +88,7 @@ listens :: (Writer w :> es, Monoid w) => (w -> b) -> Eff es a -> Eff es (a, b)
7788listens f m = do
7889 (a, w) <- listen m
7990 pure (a, f w)
91+
92+-- $setup
93+-- >>> import Control.Exception (ErrorCall)
94+-- >>> import Control.Monad.Catch
effectful-core/src/Effectful/Writer/Shared.hs+25−10
@@ -3,7 +3,7 @@
33-- - shared between multiple threads (if you want each thead to manage its own
44-- version of the value, see "Effectful.Writer.Local").
55--
6−-- - slower than "Effectful.Writer.Local".
6+-- - slightly slower than "Effectful.Writer.Local".
77--
88-- /Warning:/ 'Writer'\'s state will be accumulated via __left-associated__ uses
99-- of '<>', which makes it unsuitable for use with types for which such pattern
@@ -25,7 +25,7 @@ module Effectful.Writer.Shared
2525 ) where
2626
2727import Control.Concurrent.MVar
28−import Control.Exception
28+import Control.Exception (onException, uninterruptibleMask)
2929
3030import Effectful.Dispatch.Static
3131import Effectful.Monad
@@ -39,7 +39,7 @@ newtype Writer w :: Effect where
3939runWriter :: Monoid w => Eff (Writer w : es) a -> Eff es (a, w)
4040runWriter m = do
4141 v <- unsafeEff_ $ newMVar mempty
42− a <- evalEffect (IdA (Writer v)) m
42+ a <- evalData (DataA (Writer v)) m
4343 (a, ) <$> unsafeEff_ (readMVar v)
4444
4545-- | Run a 'Writer' effect and return the final output, discarding the final
@@ -47,21 +47,32 @@ runWriter m = do
4747execWriter :: Monoid w => Eff (Writer w : es) a -> Eff es w
4848execWriter m = do
4949 v <- unsafeEff_ $ newMVar mempty
50− _ <- evalEffect (IdA (Writer v)) m
50+ _ <- evalData (DataA (Writer v)) m
5151 unsafeEff_ $ readMVar v
5252
5353-- | Append the given output to the overall output of the 'Writer'.
5454tell :: (Writer w :> es, Monoid w) => w -> Eff es ()
5555tell w1 = unsafeEff $ \es -> do
56− IdA (Writer v) <- getEnv es
56+ DataA (Writer v) <- getEnv es
5757 modifyMVar_ v $ \w0 -> let w = w0 <> w1 in w `seq` pure w
5858
5959-- | Execute an action and append its output to the overall output of the
6060-- 'Writer'.
6161--
62−-- /Note:/ if a runtime exception is received while the action is executed, the
63−-- partial output of the action will still be appended to the overall output of
64−-- the 'Writer'.
62+-- /Note:/ if an exception is received while the action is executed, the partial
63+-- output of the action will still be appended to the overall output of the
64+-- 'Writer':
65+--
66+-- >>> :{
67+-- runEff . execWriter @String $ do
68+-- tell "Hi"
69+-- handle (\(_::ErrorCall) -> pure ((), "")) $ do
70+-- tell " there"
71+-- listen $ do
72+-- tell "!"
73+-- error "oops"
74+-- :}
75+-- "Hi there!"
6576listen :: (Writer w :> es, Monoid w) => Eff es a -> Eff es (a, w)
6677listen m = unsafeEff $ \es -> do
6778 -- The mask is uninterruptible because modifyMVar_ v0 in the merge function
@@ -70,14 +81,14 @@ listen m = unsafeEff $ \es -> do
7081 uninterruptibleMask $ \restore -> do
7182 v1 <- newMVar mempty
7283 -- Replace thread local MVar with a fresh one for isolated listening.
73− v0 <- stateEnv es $ \(IdA (Writer v)) -> (v, IdA (Writer v1))
84+ v0 <- stateEnv es $ \(DataA (Writer v)) -> (v, DataA (Writer v1))
7485 a <- restore (unEff m es) `onException` merge es v0 v1
7586 (a, ) <$> merge es v0 v1
7687 where
7788 -- Merge results accumulated in the local MVar with the mainline. If an
7889 -- exception was received while listening, merge results recorded so far.
7990 merge es v0 v1 = do
80− putEnv es $ IdA (Writer v0)
91+ putEnv es $ DataA (Writer v0)
8192 w1 <- readMVar v1
8293 modifyMVar_ v0 $ \w0 -> let w = w0 <> w1 in w `seq` pure w
8394 pure w1
@@ -91,3 +102,7 @@ listens :: (Writer w :> es, Monoid w) => (w -> b) -> Eff es a -> Eff es (a, b)
91102listens f m = do
92103 (a, w) <- listen m
93104 pure (a, f w)
105+
106+-- $setup
107+-- >>> import Control.Exception (ErrorCall)
108+-- >>> import Control.Monad.Catch
effectful/bench/Main.hs+3−3
@@ -97,11 +97,11 @@ filesize n = bgroup (show n)
9797#ifdef VERSION_eff
9898 , bench "eff" $ nfAppIO eff_calculateFileSizesDeep (take n files)
9999#endif
100−#ifdef VERSION_polysemy
101− , bench "polysemy" $ nfAppIO poly_calculateFileSizesDeep (take n files)
102−#endif
103100#ifdef VERSION_mtl
104101 , bench "mtl" $ nfAppIO mtl_calculateFileSizesDeep (take n files)
102+#endif
103+#ifdef VERSION_polysemy
104+ , bench "polysemy" $ nfAppIO poly_calculateFileSizesDeep (take n files)
105105#endif
106106 ]
107107 ]
effectful/effectful.cabal+1−1
@@ -20,7 +20,7 @@ description: An easy to use, performant extensible effects library with seamless
2020
2121extra-source-files: CHANGELOG.md
2222
23−tested-with: GHC ==8.8.4 || ==8.10.7 || ==9.0.1 || ==9.2.1
23+tested-with: GHC ==8.8.4 || ==8.10.7 || ==9.2.1
2424
2525bug-reports: https://github.com/arybczak/effectful/issues
2626source-repository head
effectful/src/Effectful/Concurrent/Effect.hs+1−1
@@ -72,7 +72,7 @@ data Concurrent :: Effect where
7272
7373-- | Run the 'Concurrent' effect.
7474runConcurrent :: IOE :> es => Eff (Concurrent : es) a -> Eff es a
75−runConcurrent = evalEffect (IdA Concurrent)
75+runConcurrent = evalData (DataA Concurrent)
7676
7777-- $setup
7878-- >>> import Effectful.Concurrent
effectful/src/Effectful/Environment.hs+1−1
@@ -28,7 +28,7 @@ data Environment :: Effect where
2828
2929-- | Run the 'Environment' effect.
3030runEnvironment :: IOE :> es => Eff (Environment : es) a -> Eff es a
31−runEnvironment = evalEffect (IdA Environment)
31+runEnvironment = evalData (DataA Environment)
3232
3333-- | Lifted 'E.getArgs'.
3434getArgs :: Environment :> es => Eff es [String]
effectful/src/Effectful/FileSystem.hs+1−1
@@ -100,7 +100,7 @@ data FileSystem :: Effect where
100100
101101-- | Run the 'FileSystem' effect.
102102runFileSystem :: IOE :> es => Eff (FileSystem : es) a -> Eff es a
103−runFileSystem = evalEffect (IdA FileSystem)
103+runFileSystem = evalData (DataA FileSystem)
104104
105105----------------------------------------
106106-- Actions on directories
effectful/src/Effectful/FileSystem/Effect.hs+1−1
@@ -12,4 +12,4 @@ data FileSystem :: Effect where
1212
1313-- | Run the 'FileSystem' effect.
1414runFileSystem :: IOE :> es => Eff (FileSystem : es) a -> Eff es a
15−runFileSystem = evalEffect (IdA FileSystem)
15+runFileSystem = evalData (DataA FileSystem)
effectful/src/Effectful/Process.hs+1−1
@@ -58,7 +58,7 @@ data Process :: Effect where
5858 Process :: Process m r
5959
6060runProcess :: IOE :> es => Eff (Process : es) a -> Eff es a
61−runProcess = evalEffect (IdA Process)
61+runProcess = evalData (DataA Process)
6262
6363----------------------------------------
6464-- Running sub-processes
effectful/src/Effectful/Resource.hs+4−4
@@ -37,7 +37,7 @@ runResource m = unsafeEff $ \es0 -> do
3737 size0 <- sizeEnv es0
3838 istate <- R.createInternalState
3939 mask $ \restore -> do
40− es <- unsafeConsEnv (IdA (Resource istate)) noRelinker es0
40+ es <- unsafeConsEnv (DataA (Resource istate)) noRelinker es0
4141 a <- restore (unEff m es) `catch` \e -> do
4242 unsafeTailEnv size0 es
4343 RI.stateCleanupChecked (Just e) istate
@@ -52,18 +52,18 @@ runResource m = unsafeEff $ \es0 -> do
5252-- | Get the 'R.InternalState' of the current 'Resource' effect.
5353getInternalState :: Resource :> es => Eff es R.InternalState
5454getInternalState = do
55− IdA (Resource istate) <- getEffect
55+ DataA (Resource istate) <- getData
5656 pure istate
5757
5858-- | Run the 'Resource' effect with existing 'R.InternalState'.
5959--
6060-- /Note:/ the 'R.InternalState' will not be closed at the end.
6161runInternalState :: R.InternalState -> Eff (Resource : es) a -> Eff es a
62−runInternalState istate = evalEffect $ IdA (Resource istate)
62+runInternalState istate = evalData (DataA (Resource istate))
6363
6464----------------------------------------
6565-- Orphan instance
6666
6767instance (IOE :> es, Resource :> es) => R.MonadResource (Eff es) where
6868 liftResourceT (RI.ResourceT m) = unsafeEff $ \es -> do
69− getEnv es >>= \(IdA (Resource istate)) -> m istate
69+ getEnv es >>= \(DataA (Resource istate)) -> m istate
effectful/src/Effectful/Temporary.hs+1−1
@@ -19,7 +19,7 @@ data Temporary :: Effect where
1919
2020-- | Run the 'Temporary' effect.
2121runTemporary :: IOE :> es => Eff (Temporary : es) a -> Eff es a
22−runTemporary = evalEffect (IdA Temporary)
22+runTemporary = evalData (DataA Temporary)
2323
2424-- | Lifted 'T.withSystemTempFile'.
2525withSystemTempFile
effectful/src/Effectful/Timeout.hs+1−1
@@ -15,7 +15,7 @@ data Timeout :: Effect where
1515
1616-- | Run the 'Timeout' effect.
1717runTimeout :: IOE :> es => Eff (Timeout : es) a -> Eff es a
18−runTimeout = evalEffect (IdA Timeout)
18+runTimeout = evalData (DataA Timeout)
1919
2020-- | Lifted 'T.timeout'.
2121timeout