@@ -14,6 +14,7 @@ module Effectful.Interpreter
1414 ) where
1515
1616import Control.Monad.Catch
17+import GHC.Stack
1718
1819import Effectful.Internal.Effect
1920import Effectful.Internal.Env
@@ -24,8 +25,10 @@ import Effectful.Internal.Monad
2425
2526data Interpreter (e :: Effect) = forall localEs. Interpreter
2627 { _env :: Env localEs
27− , _interpret :: forall a es. (forall r. Eff es r -> IO r)
28− -> e (Eff es) a -> Eff localEs a
28+ , _interpret :: forall a es. HasCallStack
29+ => (forall r. Eff es r -> IO r)
30+ -> e (Eff es) a
31+ -> Eff localEs a
2932 }
3033
3134runInterpreter :: Env es -> Interpreter e -> Eff (e : es) a -> IO a
@@ -44,7 +47,7 @@ runInterpreter es0 e (Eff m) = do
4447-- Sending commands
4548
4649-- | Send an operation of a given effect to the interpreter.
47−send :: e :> es => e (Eff es) a -> Eff es a
50+send :: (HasCallStack, e :> es) => e (Eff es) a -> Eff es a
4851send op = readerEffectM $ \Interpreter{..} -> do
4952 unsafeUnliftEff $ \run -> unEff (_interpret run op) _env
5053
@@ -53,28 +56,32 @@ send op = readerEffectM $ \Interpreter{..} -> do
5356
5457-- | Interpret a first order effect.
5558interpret
56− :: (forall r es. e (Eff es) r -> Eff baseEs r)
59+ :: (forall r es. HasCallStack => e (Eff es) r -> Eff baseEs r)
5760 -> Eff (e : baseEs) a
5861 -> Eff baseEs a
59−interpret f = interpretIO $ \_ -> f
62+interpret interpreter m = unsafeEff $ \es -> do
63+ les <- forkEnv es
64+ runInterpreter es (Interpreter les $ \_ -> interpreter) m
6065
6166-- | Interpret a higher order effect with help of a natural transformation from
6267-- 'Eff' to 'Eff'.
6368interpretM
64− :: (forall r es. (forall t. Eff es t -> Eff baseEs t) -> e (Eff es) r -> Eff baseEs r)
69+ :: (forall r es. HasCallStack => (forall t. Eff es t -> Eff baseEs t) -> e (Eff es) r -> Eff baseEs r)
6570 -> Eff (e : baseEs) a
6671 -> Eff baseEs a
67−interpretM f = interpretIO $ \k -> f $ unsafeEff_ . k
72+interpretM interpreter m = unsafeEff $ \es -> do
73+ les <- forkEnv es
74+ runInterpreter es (Interpreter les $ \k -> interpreter $ unsafeEff_ . k) m
6875
6976-- | Interpret a higher order effect with help of a natural transformation from
7077-- 'Eff' to 'IO'.
7178interpretIO
72− :: (forall r es. (forall t. Eff es t -> IO t) -> e (Eff es) r -> Eff baseEs r)
79+ :: (forall r es. HasCallStack => (forall t. Eff es t -> IO t) -> e (Eff es) r -> Eff baseEs r)
7380 -> Eff (e : baseEs) a
7481 -> Eff baseEs a
75−interpretIO f m = unsafeEff $ \es -> do
82+interpretIO interpreter m = unsafeEff $ \es -> do
7683 les <- forkEnv es
77− runInterpreter es (Interpreter les f) m
84+ runInterpreter es (Interpreter les interpreter) m
7885
7986----------------------------------------
8087-- Reinterpretation
@@ -82,28 +89,34 @@ interpretIO f m = unsafeEff $ \es -> do
8289-- | Reinterpret local effects as a first order effect.
8390reinterpret
8491 :: (Eff localEs a -> Eff baseEs b)
85− -> (forall r es. e (Eff es) r -> Eff localEs r)
92+ -> (forall r es. HasCallStack => e (Eff es) r -> Eff localEs r)
8693 -> Eff (e : baseEs) a
8794 -> Eff baseEs b
88−reinterpret runLocal f = reinterpretIO runLocal $ \_ -> f
95+reinterpret runLocal interpreter m = unsafeEff $ \es -> do
96+ les0 <- forkEnv es
97+ (`unEff` les0) . runLocal . unsafeEff $ \les -> do
98+ runInterpreter es (Interpreter les $ \_ -> interpreter) m
8999
90100-- | Reinterpret local effects as a higher order effect with help of a natural
91101-- transformation from 'Eff' to 'Eff'.
92102reinterpretM
93103 :: (Eff localEs a -> Eff baseEs b)
94− -> (forall r es. (forall t. Eff es t -> Eff localEs t) -> e (Eff es) r -> Eff localEs r)
104+ -> (forall r es. HasCallStack => (forall t. Eff es t -> Eff localEs t) -> e (Eff es) r -> Eff localEs r)
95105 -> Eff (e : baseEs) a
96106 -> Eff baseEs b
97−reinterpretM runLocal f = reinterpretIO runLocal $ \k -> f $ unsafeEff_ . k
107+reinterpretM runLocal interpreter m = unsafeEff $ \es -> do
108+ les0 <- forkEnv es
109+ (`unEff` les0) . runLocal . unsafeEff $ \les -> do
110+ runInterpreter es (Interpreter les $ \k -> interpreter $ unsafeEff_ . k) m
98111
99112-- | Reinterpret local effects as a higher order effect with help of a natural
100113-- transformation from 'Eff' to 'IO'.
101114reinterpretIO
102115 :: (Eff localEs a -> Eff baseEs b)
103− -> (forall r es. (forall t. Eff es t -> IO t) -> e (Eff es) r -> Eff localEs r)
116+ -> (forall r es. HasCallStack => (forall t. Eff es t -> IO t) -> e (Eff es) r -> Eff localEs r)
104117 -> Eff (e : baseEs) a
105118 -> Eff baseEs b
106−reinterpretIO runLocal f m = unsafeEff $ \es -> do
119+reinterpretIO runLocal interpreter m = unsafeEff $ \es -> do
107120 les0 <- forkEnv es
108121 (`unEff` les0) . runLocal . unsafeEff $ \les -> do
109− runInterpreter es (Interpreter les f) m
122+ runInterpreter es (Interpreter les interpreter) m