git.iko.soy/effectful
on master help sign in
Don't export the constructor of Eff
commit4f7723293841dc00ea21ca2bfd6552f6e792fba1 authorAndrzej Rybczak <andrzej@rybczak.net> dateMon 28 Jun 2021, 19:43 (5 years ago) parente519afb
6 files changed+39−29
compare with master
unifiedsplit
src/Effectful/Error.hs+4−4 src/Effectful/Internal/Monad.hs+27−17 src/Effectful/Interpreter.hs+2−2 src/Effectful/Resource.hs+2−2 src/Effectful/Writer.hs+2−2 src/Effectful/Writer/MVar.hs+2−2
src/Effectful/Error.hs+4−4
@@ -50,13 +50,13 @@ runError
5050 :: forall e es a. Typeable e
5151 => Eff (Error e : es) a
5252 -> Eff es (Either (CallStack, e) a)
53−runError (Eff m) = unsafeEff $ \es0 -> mask $ \release -> do
53+runError m = unsafeEff $ \es0 -> mask $ \release -> do
5454 -- A unique tag is picked so that different runError handlers for the same
5555 -- type don't catch each other's exceptions.
5656 tag <- newUnique
5757 size0 <- sizeEnv es0
5858 es <- unsafeConsEnv (IdE (Error @e tag)) noRelinker es0
59− r <- tryErrorIO tag (release $ m es) `onException` unsafeTailEnv size0 es
59+ r <- tryErrorIO tag (release $ unEff m es) `onException` unsafeTailEnv size0 es
6060 _ <- unsafeTailEnv size0 es
6161 pure r
6262
@@ -72,10 +72,10 @@ catchError
7272 => Eff es a
7373 -> (CallStack -> e -> Eff es a)
7474 -> Eff es a
75−catchError (Eff m) handler = do
75+catchError m handler = do
7676 readerEffectM @(Error e) $ \(IdE (Error tag)) -> unsafeEff $ \es -> do
7777 size <- sizeEnv es
78− catchErrorIO tag (m es) $ \cs e -> do
78+ catchErrorIO tag (unEff m es) $ \cs e -> do
7979 checkSizeEnv size es
8080 unEff (handler cs e) es
8181
src/Effectful/Internal/Monad.hs+27−17
@@ -7,11 +7,12 @@
77-- in subsequent releases.
88module Effectful.Internal.Monad
99 ( -- * Monad
10− Eff(..)
10+ Eff
1111 , runEff
1212
1313 -- ** Access to the internal representation
1414 , RunIn
15+ , unEff
1516 , unsafeEff
1617 , unsafeEff_
1718 , unsafeUnliftEff
@@ -20,10 +21,14 @@ module Effectful.Internal.Monad
2021 , IOE
2122 , runIOE
2223
23− -- * Helpers
24+ -- * Low-level helpers
25+
26+ -- ** Running
2427 , runEffect
2528 , evalEffect
2629 , execEffect
30+
31+ -- ** Modification
2732 , getEffect
2833 , putEffect
2934 , stateEffect
@@ -47,7 +52,7 @@ import Effectful.Internal.Env
4752
4853type role Eff nominal representational
4954
50−newtype Eff (es :: [Effect]) a = Eff { unEff :: Env es -> IO a }
55+newtype Eff (es :: [Effect]) a = Eff (Env es -> IO a)
5156
5257-- | Run a pure 'Eff' computation.
5358--
@@ -63,6 +68,11 @@ runEff (Eff m) =
6368 unsafeDupablePerformIO $ m =<< emptyEnv
6469
6570----------------------------------------
71+-- Access to the internal representation
72+
73+-- | Peel off the constructor of 'Eff'.
74+unEff :: Eff es a -> Env es -> IO a
75+unEff (Eff m) = m
6676
6777-- | Access underlying 'IO' monad along with the environment.
6878unsafeEff :: (Env es -> IO a) -> Eff es a
@@ -100,10 +110,10 @@ type RunIn es m = forall r. Eff es r -> m r
100110unsafeUnliftEff :: (RunIn es IO -> IO a) -> Eff es a
101111unsafeUnliftEff f = unsafeEff $ \es -> do
102112 tid0 <- myThreadId
103− f $ \(Eff m) -> do
113+ f $ \m -> do
104114 tid <- myThreadId
105115 if tid == tid0
106− then m es
116+ then unEff m es
107117 else error $ "Running Eff computations in a different thread is "
108118 ++ "currently only possible via the AsyncE effect"
109119
@@ -134,18 +144,18 @@ instance MonadThrow (Eff es) where
134144 throwM = unsafeEff_ . throwM
135145
136146instance MonadCatch (Eff es) where
137− catch (Eff m) handler = unsafeEff $ \es -> do
147+ catch m handler = unsafeEff $ \es -> do
138148 size <- sizeEnv es
139− m es `catch` \e -> do
149+ unEff m es `catch` \e -> do
140150 checkSizeEnv size es
141151 unEff (handler e) es
142152
143153instance MonadMask (Eff es) where
144154 mask k = unsafeEff $ \es -> mask $ \restore ->
145− unEff (k $ \(Eff m) -> unsafeEff $ restore . m) es
155+ unEff (k $ \m -> unsafeEff $ restore . unEff m) es
146156
147157 uninterruptibleMask k = unsafeEff $ \es -> uninterruptibleMask $ \restore ->
148− unEff (k $ \(Eff m) -> unsafeEff $ restore . m) es
158+ unEff (k $ \m -> unsafeEff $ restore . unEff m) es
149159
150160 generalBracket acquire release use = unsafeEff $ \es -> mask $ \restore -> do
151161 size <- sizeEnv es
@@ -188,25 +198,25 @@ instance IOE :> es => MonadUnliftIO (Eff es) where
188198-- Helpers
189199
190200runEffect :: i e -> Eff (e : es) a -> Eff es (a, i e)
191−runEffect e0 (Eff m) = unsafeEff $ \es0 -> do
201+runEffect e0 m = unsafeEff $ \es0 -> do
192202 size0 <- sizeEnv es0
193203 bracket (unsafeConsEnv e0 noRelinker es0)
194204 (unsafeTailEnv size0)
195− (\es -> (,) <$> m es <*> getEnv es)
205+ (\es -> (,) <$> unEff m es <*> getEnv es)
196206
197207evalEffect :: i e -> Eff (e : es) a -> Eff es a
198−evalEffect e (Eff m) = unsafeEff $ \es0 -> do
208+evalEffect e m = unsafeEff $ \es0 -> do
199209 size0 <- sizeEnv es0
200210 bracket (unsafeConsEnv e noRelinker es0)
201211 (unsafeTailEnv size0)
202− (\es -> m es)
212+ (\es -> unEff m es)
203213
204214execEffect :: i e -> Eff (e : es) a -> Eff es (i e)
205−execEffect e0 (Eff m) = unsafeEff $ \es0 -> do
215+execEffect e0 m = unsafeEff $ \es0 -> do
206216 size0 <- sizeEnv es0
207217 bracket (unsafeConsEnv e0 noRelinker es0)
208218 (unsafeTailEnv size0)
209− (\es -> m es *> getEnv es)
219+ (\es -> unEff m es *> getEnv es)
210220
211221getEffect :: e :> es => Eff es (i e)
212222getEffect = unsafeEff $ \es -> getEnv es
@@ -221,10 +231,10 @@ stateEffect f = unsafeEff $ \es -> unsafeStateEnv f es
221231{-# INLINE stateEffect #-}
222232
223233localEffect :: e :> es => (i e -> i e) -> Eff es a -> Eff es a
224−localEffect f (Eff m) = unsafeEff $ \es -> do
234+localEffect f m = unsafeEff $ \es -> do
225235 bracket (unsafeStateEnv (\e -> (e, f e)) es)
226236 (\e -> unsafePutEnv e es)
227− (\_ -> m es)
237+ (\_ -> unEff m es)
228238{-# INLINE localEffect #-}
229239
230240readerEffectM :: e :> es => (i e -> Eff es a) -> Eff es a
src/Effectful/Interpreter.hs+2−2
@@ -35,11 +35,11 @@ data Interpreter (e :: Effect) = forall localEs. Interpreter
3535 }
3636
3737runInterpreter :: Env es -> Interpreter e -> Eff (e : es) a -> IO a
38−runInterpreter es0 e (Eff m) = do
38+runInterpreter es0 e m = do
3939 size0 <- sizeEnv es0
4040 bracket (unsafeConsEnv e relinker es0)
4141 (unsafeTailEnv size0)
42− (\es -> m es)
42+ (\es -> unEff m es)
4343 where
4444 relinker :: Relinker Interpreter e
4545 relinker = Relinker $ \relink Interpreter{..} -> do
src/Effectful/Resource.hs+2−2
@@ -27,12 +27,12 @@ newtype Resource :: Effect where
2727
2828-- | Run the resource effect.
2929runResource :: IOE :> es => Eff (Resource : es) a -> Eff es a
30−runResource (Eff m) = unsafeEff $ \es0 -> do
30+runResource m = unsafeEff $ \es0 -> do
3131 size0 <- sizeEnv es0
3232 istate <- R.createInternalState
3333 mask $ \restore -> do
3434 es <- unsafeConsEnv (IdE (Resource istate)) noRelinker es0
35− a <- restore (m es) `catch` \e -> do
35+ a <- restore (unEff m es) `catch` \e -> do
3636 _ <- unsafeTailEnv size0 es
3737 RI.stateCleanupChecked (Just e) istate
3838 throwIO e
src/Effectful/Writer.hs+2−2
@@ -39,10 +39,10 @@ listen
3939 :: forall w es a. (Writer w :> es, Monoid w)
4040 => Eff es a
4141 -> Eff es (a, w)
42−listen (Eff m) = unsafeEff $ \es -> mask $ \restore -> do
42+listen m = unsafeEff $ \es -> mask $ \restore -> do
4343 w0 <- unsafeStateEnv (\(IdE (Writer w)) -> (w, IdE (Writer mempty))) es
4444 -- If an exception is thrown, restore e0 and keep parts of e1.
45− a <- restore (m es) `onException`
45+ a <- restore (unEff m es) `onException`
4646 unsafeModifyEnv (\(IdE (Writer w)) -> IdE (Writer (w0 <> w))) es
4747 w1 <- unsafeStateEnv (\(IdE (Writer w)) -> (w, IdE (Writer (w0 <> w)))) es
4848 pure (a, w1)
src/Effectful/Writer/MVar.hs+2−2
@@ -44,11 +44,11 @@ listen
4444 :: forall w es a. (Writer w :> es, Monoid w)
4545 => Eff es a
4646 -> Eff es (a, w)
47−listen (Eff m) = unsafeEff $ \es -> uninterruptibleMask $ \restore -> do
47+listen m = unsafeEff $ \es -> uninterruptibleMask $ \restore -> do
4848 v1 <- newMVar mempty
4949 -- Replace thread local MVar with a fresh one for isolated listening.
5050 v0 <- unsafeStateEnv (\(IdE (Writer v)) -> (v, IdE (Writer v1))) es
51− a <- restore (m es) `onException` merge es v0 v1
51+ a <- restore (unEff m es) `onException` merge es v0 v1
5252 (a, ) <$> merge es v0 v1
5353 where
5454 -- Merge results accumulated in the local MVar with the mainline. If an