From 09a2c76893eeefc605c58c4fbd82f265a28cc8b8 Mon Sep 17 00:00:00 2001 From: unknown Date: Mon, 4 Jan 2021 15:08:50 +0100 Subject: [PATCH 1/2] Powerful interpretNew --- polysemy.cabal | 3 +- src/Polysemy.hs | 6 + src/Polysemy/Error.hs | 17 +- src/Polysemy/Internal/Combinators.hs | 147 +-------------- src/Polysemy/Internal/InterpretNew.hs | 255 ++++++++++++++++++++++++++ src/Polysemy/Internal/Union.hs | 8 +- src/Polysemy/Internal/WeaveClass.hs | 56 ++++-- src/Polysemy/Internal/Writer.hs | 50 ++--- src/Polysemy/NonDet.hs | 8 +- src/Polysemy/Reader.hs | 8 +- src/Polysemy/Resource.hs | 46 +++-- src/Polysemy/Writer.hs | 24 +-- test/TacticsSpec.hs | 2 +- 13 files changed, 365 insertions(+), 265 deletions(-) create mode 100644 src/Polysemy/Internal/InterpretNew.hs diff --git a/polysemy.cabal b/polysemy.cabal index 19fd479c..60268f17 100644 --- a/polysemy.cabal +++ b/polysemy.cabal @@ -4,7 +4,7 @@ cabal-version: 2.0 -- -- see: https://github.com/sol/hpack -- --- hash: 754ab355722062c11ee014b832c3c95ddeea81fec4242a5938436c0ca64383c8 +-- hash: 53283f3e0706b3474ab26a2b75fc509c9ef2332c6580662107613bcf3dbecaf5 name: polysemy version: 1.4.0.0 @@ -64,6 +64,7 @@ library Polysemy.Internal.CustomErrors.Redefined Polysemy.Internal.Fixpoint Polysemy.Internal.Forklift + Polysemy.Internal.InterpretNew Polysemy.Internal.Kind Polysemy.Internal.NonDet Polysemy.Internal.Strategy diff --git a/src/Polysemy.hs b/src/Polysemy.hs index 57ea333f..dbaf4df4 100644 --- a/src/Polysemy.hs +++ b/src/Polysemy.hs @@ -107,6 +107,7 @@ module Polysemy , transform -- * Combinators for Interpreting Higher-Order Effects + , EffHandlerH , interpretNew , interceptNew , reinterpretNew @@ -138,6 +139,10 @@ module Polysemy -- using 'runH'. , RunH , runH + , runH' + , runExposeH + , runExposeH' + , restoreH -- * Tactics -- | Higher-order effects need to explicitly thread /other effects'/ state @@ -164,6 +169,7 @@ module Polysemy import Polysemy.Final import Polysemy.Internal import Polysemy.Internal.Combinators +import Polysemy.Internal.InterpretNew import Polysemy.Internal.Forklift import Polysemy.Internal.Kind import Polysemy.Internal.Tactics diff --git a/src/Polysemy/Error.hs b/src/Polysemy/Error.hs index 2cbc6ae1..d4ca40f3 100644 --- a/src/Polysemy/Error.hs +++ b/src/Polysemy/Error.hs @@ -217,21 +217,12 @@ mapError => (e1 -> e2) -> Sem (Error e1 ': r) a -> Sem r a -mapError f = interpretH $ \case +mapError f = interpretNew $ \case Throw e -> throw $ f e - Catch action handler -> do - a <- runT action - h <- bindT handler - - mx <- raise $ runError a - case mx of + Catch action handler -> + runError (runH' action) >>= \case Right x -> pure x - Left e -> do - istate <- getInitialStateT - mx' <- raise $ runError $ h $ e <$ istate - case mx' of - Right x -> pure x - Left e' -> throw $ f e' + Left e -> runH (handler e) {-# INLINE mapError #-} diff --git a/src/Polysemy/Internal/Combinators.hs b/src/Polysemy/Internal/Combinators.hs index 128aa0b5..a0b39c5e 100644 --- a/src/Polysemy/Internal/Combinators.hs +++ b/src/Polysemy/Internal/Combinators.hs @@ -47,6 +47,7 @@ import Polysemy.Internal import Polysemy.Internal.CustomErrors import Polysemy.Internal.Tactics import Polysemy.Internal.Union +import Polysemy.Internal.InterpretNew firstOrder :: ((forall rInitial x. e (Sem rInitial) x -> @@ -419,149 +420,3 @@ transform f (Sem m) = Sem $ \k -> m $ \u -> Left g -> g Right (Weaving e mkT lwr ex) -> injWeaving (Weaving (f e) mkT lwr ex) - - --- | An effect for running monadic actions within a higher-order effect --- currently being interpreted. -newtype RunH z (m :: * -> *) a where - RunH :: z a -> RunH z m a - --- | Run a monadic action given by a higher-order effect that is currently --- being interpreted. --- --- @since TODO -runH :: Member (RunH z) r => z a -> Sem r a -runH = send . RunH - ------------------------------------------------------------------------------- --- | Like 'interpret', but for higher-order effects (i.e. those which make use --- of the @m@ parameter.) --- --- This is significantly easier to use than 'interpretH' and its corresponding --- 'Tactical' environment. --- Because of this, 'interpretNew' and friends are /heavily recommended/ over --- 'interpretH' and friends /unless/ you need the extra power that the 'Tactical' --- environment provides -- the ability to inspect and manipulate the underlying --- effectful state. --- --- Higher-order thunks within the effect to be interpreted can be run using --- 'runH'. For example: --- --- @ --- data Bind m a where --- Bind :: m a -> (a -> m b) -> Bind m b --- --- runBind :: Sem (Bind ': r) a -> Sem r a --- runBind = 'interpretNew' \\case --- Bind ma f -> do --- a <- 'runH' ma --- b <- 'runH' (f a) --- return b --- @ --- --- @since TODO -interpretNew :: forall e r a - . (forall z x. e z x -> Sem (RunH z ': r) x) - -> Sem (e ': r) a - -> Sem r a -interpretNew h (Sem sem) = Sem $ \(k :: forall x. Union r (Sem r) x -> m x) -> - sem $ \u -> case decomp (hoist (interpretNew h) u) of - Left g -> k g - Right (Weaving e - (mkT :: forall n x - . Monad n - => (forall y. Sem r y -> n y) - -> z x -> t n x - ) - lwr - ex - ) -> - let - go1 :: forall x. Sem (RunH z ': r) x -> t m x - go1 = usingSem $ \u' -> case decomp u' of - Right (Weaving (RunH z) _ lwr' ex') -> - (ex' . (<$ mkInitState lwr')) <$> mkT (usingSem k) z - Left g -> liftHandlerWithNat go2 k g - - go2 :: forall x. Sem (RunH z ': r) x -> t (Sem r) x - go2 = usingSem $ \u' -> case decomp (hoist go2 u') of - Right (Weaving (RunH z) _ lwr' ex') -> - (ex' . (<$ mkInitState lwr')) <$> mkT id z - Left g -> liftHandler liftSem g - in - fmap ex $ lwr $ go1 (h e) - --- TODO (KingoftheHomeless): If it matters, optimize the definitions --- below - ------------------------------------------------------------------------------- --- | Like 'reinterpret', but for higher-order effects. --- --- This is /heavily recommended/ over 'reinterpretH' unless you need --- the extra power that the 'Tactical' environment provides. --- --- @since TODO -reinterpretNew :: forall e1 e2 r a - . (forall z x. e1 z x -> Sem (RunH z ': e2 ': r) x) - -> Sem (e1 ': r) a - -> Sem (e2 ': r) a -reinterpretNew h = interpretNew h . raiseUnder -{-# INLINE reinterpretNew #-} - ------------------------------------------------------------------------------- --- | Like 'reinterpret2', but for higher-order effects. --- --- This is /heavily recommended/ over 'reinterpret2H' unless you need --- the extra power that the 'Tactical' environment provides. --- --- @since TODO -reinterpret2New :: forall e1 e2 e3 r a - . (forall z x. e1 z x -> Sem (RunH z ': e2 ': e3 ': r) x) - -> Sem (e1 ': r) a - -> Sem (e2 ': e3 ': r) a -reinterpret2New h = interpretNew h . raiseUnder2 -{-# INLINE reinterpret2New #-} - ------------------------------------------------------------------------------- --- | Like 'reinterpret3', but for higher-order effects. --- --- This is /heavily recommended/ over 'reinterpret3H' unless you need --- the extra power that the 'Tactical' environment provides. --- --- @since TODO -reinterpret3New :: forall e1 e2 e3 e4 r a - . (forall z x. e1 z x -> Sem (RunH z ': e2 ': e3 ': e4 ': r) x) - -> Sem (e1 ': r) a - -> Sem (e2 ': e3 ': e4 ': r) a -reinterpret3New h = interpretNew h . raiseUnder3 -{-# INLINE reinterpret3New #-} - ------------------------------------------------------------------------------- --- | Like 'intercept', but for higher-order effects. --- --- This is /heavily recommended/ over 'interceptH' unless you need --- the extra power that the 'Tactical' environment provides. --- --- @since TODO -interceptNew :: forall e r a - . Member e r - => (forall z x. e z x -> Sem (RunH z ': r) x) - -> Sem r a - -> Sem r a -interceptNew h = interpretNew h . expose -{-# INLINE interceptNew #-} - ------------------------------------------------------------------------------- --- | Like 'interceptUsing', but for higher-order effects. --- --- This is /heavily recommended/ over 'interceptUsingH' unless you need --- the extra power that the 'Tactical' environment provides. --- --- @since TODO -interceptUsingNew :: forall e r a - . ElemOf e r - -> (forall z x. e z x -> Sem (RunH z ': r) x) - -> Sem r a - -> Sem r a -interceptUsingNew pr h = interpretNew h . exposeUsing pr -{-# INLINE interceptUsingNew #-} diff --git a/src/Polysemy/Internal/InterpretNew.hs b/src/Polysemy/Internal/InterpretNew.hs new file mode 100644 index 00000000..2552dffc --- /dev/null +++ b/src/Polysemy/Internal/InterpretNew.hs @@ -0,0 +1,255 @@ +module Polysemy.Internal.InterpretNew where + +import Polysemy.Internal +import Polysemy.Internal.WeaveClass +import Polysemy.Internal.Union +import Polysemy.Internal.Kind + + +-- | An effect for running monadic actions within a higher-order effect +-- currently being interpreted. +data RunH z t r :: Effect where + RunH :: forall z t r m a. z a -> RunH z t r m a + RunExposeH :: forall z t r m a. z a -> RunH z t r m (t a) + RunExposeH' :: forall z t r m a. z a -> RunH z t r m (Sem r (t a)) + RestoreH :: forall z t r m a. t a -> RunH z t r m a + +-- | Run a monadic action given by a higher-order effect that is currently +-- being interpreted, and recursively apply the current interpreter on it. +-- +-- This is the standard tool for interpreting higher-order effects. +-- +-- @since TODO +runH :: forall z t r r' a. z a -> Sem (RunH z t r ': r') a +runH = send . RunH @z @t @r +{-# INLINE runH #-} + +-- | Run a monadic action given by a higher-order effect that is currently +-- being interpreted. +-- +-- Unlike 'runH', this doesn't recursively apply the current interpreter +-- to the monadic action -- allowing you to run a different interpreter +-- on it instead. +-- +-- @since TODO +runH' :: forall z t e r a. z a -> Sem (e ': RunH z t (e ': r) ': r) a +runH' z = runExposeH' z >>= raise . restoreH +{-# INLINE runH' #-} + +-- | Run a monadic action given by a higher-order effect that is currently +-- being interpreted, recursively apply the current interpreter on it, +-- and reify the effectful state of all local effects +-- as part of the result. +-- +-- By reifying the effectful state, you may do one or more of the following: +-- +-- * Guarantee that the handler won't be interrupted by a local effect failing, +-- since that failure will instead be reified into the state. +-- * Check if the action run has failed because of a local effect by using 'Data.Foldable.null'. +-- * Discard any impact the monadic action has on local effects by never restoring the +-- efectful state. +-- +-- Once an effectful state has been reified, you may restore it using 'restoreH'. +-- +-- @since TODO +runExposeH :: forall z t r r' a. z a -> Sem (RunH z t r ': r') (t a) +runExposeH = send . RunExposeH @z @t @r +{-# INLINE runExposeH #-} + +-- | Run a monadic action given by a higher-order effect that is currently +-- being interpreted, and reify the effectful state of all local effects +-- as part of the result. +-- +-- See 'runExposeH' for more information. +-- +-- Unlike 'runH', this doesn't recursively apply the current interpreter +-- to the monadic action -- allowing you to run a different interpreter +-- on it instead. +-- +-- @since TODO +runExposeH' :: forall z t e r a. z a -> Sem (e ': RunH z t (e ': r) ': r) (t a) +runExposeH' z = raise (send (RunExposeH' @_ @t z)) >>= raiseUnder +{-# INLINE runExposeH' #-} + +-- Restore a reified effectful state, bringing its changes into scope, and returning +-- the result of the computation. +-- +-- /Note/: this overrides the local effectful state of any previously restored effectful state. +-- +-- For example, consider: +-- +-- @ +-- 'ta' <- runExposeH ma +-- 'tb' <- runExposeH mb +-- 'restoreH' ta +-- 'restoreH' tb +-- @ +-- Unless @'restoreH' ta@ causes the handler to fail (because @ma@ failed due to a local effect), +-- the changes it brings into scope will be overridden by @'restoreH' tb@. +-- +-- If you want to integrate the results of both actions, you need to restore the state +-- in between uses of 'runExposeH', so that @'runExposeH' mb@ works with the changes of @ta@ +-- in scope. +-- @ +-- 'ta' <- runExposeH ma +-- 'restoreH' ta +-- 'tb' <- runExposeH mb +-- 'restoreH' tb +-- @ +restoreH :: forall z t r r' a. t a -> Sem (RunH z t r ': r') a +restoreH = send . RestoreH @z @t @r +{-# INLINE restoreH #-} + +type EffHandlerH e r = + forall z t x + . Traversable t + => e z x -> Sem (RunH z t (e ': r) ': r) x + +------------------------------------------------------------------------------ +-- | Like 'interpret', but for higher-order effects (i.e. those which make use +-- of the @m@ parameter.) +-- +-- This is significantly easier to use than 'interpretH' and its corresponding +-- 'Tactical' environment. +-- Because of this, 'interpretNew' and friends are /heavily recommended/ over +-- 'interpretH' and friends /unless/ you need the extra power that the 'Tactical' +-- environment provides -- the ability to inspect and manipulate the underlying +-- effectful state. +-- +-- Higher-order thunks within the effect to be interpreted can be run using +-- 'runH'. For example: +-- +-- @ +-- data Bind m a where +-- Bind :: m a -> (a -> m b) -> Bind m b +-- +-- runBind :: Sem (Bind ': r) a -> Sem r a +-- runBind = 'interpretNew' \\case +-- Bind ma f -> do +-- a <- 'runH' ma +-- b <- 'runH' (f a) +-- return b +-- @ +-- +-- @since TODO +interpretNew :: forall e r a + . EffHandlerH e r + -> Sem (e ': r) a + -> Sem r a +interpretNew h (Sem sem) = Sem $ \(k :: forall x. Union r (Sem r) x -> m x) -> + sem $ \u -> case decomp u of + Left g -> k $ hoist (interpretNew h) g + Right (Weaving e + (mkT :: forall n x + . Monad n + => (forall y. Sem (e ': r) y -> n y) + -> z x -> t n x + ) + lwr + ex + ) -> + let + go1 :: forall x. Sem (RunH z (StT t) (e ': r) ': r) x -> t m x + go1 = usingSem $ \u' -> case decomp u' of + Left g -> liftHandlerWithNat go2 k g + Right (Weaving eff _ lwr' ex') -> do + (ex' . (<$ mkInitState lwr')) <$> case eff of + RunH z -> + mkT (usingSem k . interpretNew h) z + RunExposeH z -> + liftWith $ \lower -> lower (mkT (usingSem k . interpretNew h) z) + RunExposeH' z -> + liftWith $ \lower -> return (lower (mkT id z)) + RestoreH t -> + restoreT (return t) + + go2 :: forall x. Sem (RunH z (StT t) (e ': r) ': r) x -> t (Sem r) x + go2 = usingSem $ \u' -> case decomp u' of + Left g -> liftHandlerWithNat go2 liftSem g + Right (Weaving eff _ lwr' ex') -> do + (ex' . (<$ mkInitState lwr')) <$> case eff of + RunH z -> + mkT (interpretNew h) z + RunExposeH z -> + liftWith $ \lower -> lower (mkT (interpretNew h) z) + RunExposeH' z -> + liftWith $ \lower -> return (lower (mkT id z)) + RestoreH t -> + restoreT (return t) + in + fmap ex $ lwr $ go1 (h e) + +-- TODO (KingoftheHomeless): If it matters, optimize the definitions +-- below + +------------------------------------------------------------------------------ +-- | Like 'reinterpret', but for higher-order effects. +-- +-- This is /heavily recommended/ over 'reinterpretH' unless you need +-- the extra power that the 'Tactical' environment provides. +-- +-- @since TODO +reinterpretNew :: forall e1 e2 r a + . EffHandlerH e1 (e2 ': r) + -> Sem (e1 ': r) a + -> Sem (e2 ': r) a +reinterpretNew h = interpretNew h . raiseUnder +{-# INLINE reinterpretNew #-} + +------------------------------------------------------------------------------ +-- | Like 'reinterpret2', but for higher-order effects. +-- +-- This is /heavily recommended/ over 'reinterpret2H' unless you need +-- the extra power that the 'Tactical' environment provides. +-- +-- @since TODO +reinterpret2New :: forall e1 e2 e3 r a + . EffHandlerH e1 (e2 ': e3 ': r) + -> Sem (e1 ': r) a + -> Sem (e2 ': e3 ': r) a +reinterpret2New h = interpretNew h . raiseUnder2 +{-# INLINE reinterpret2New #-} + +------------------------------------------------------------------------------ +-- | Like 'reinterpret3', but for higher-order effects. +-- +-- This is /heavily recommended/ over 'reinterpret3H' unless you need +-- the extra power that the 'Tactical' environment provides. +-- +-- @since TODO +reinterpret3New :: forall e1 e2 e3 e4 r a + . EffHandlerH e1 (e2 ': e3 ': e4 ': r) + -> Sem (e1 ': r) a + -> Sem (e2 ': e3 ': e4 ': r) a +reinterpret3New h = interpretNew h . raiseUnder3 +{-# INLINE reinterpret3New #-} + +------------------------------------------------------------------------------ +-- | Like 'intercept', but for higher-order effects. +-- +-- This is /heavily recommended/ over 'interceptH' unless you need +-- the extra power that the 'Tactical' environment provides. +-- +-- @since TODO +interceptNew :: forall e r a + . Member e r + => EffHandlerH e r + -> Sem r a + -> Sem r a +interceptNew h = interpretNew h . expose +{-# INLINE interceptNew #-} + +------------------------------------------------------------------------------ +-- | Like 'interceptUsing', but for higher-order effects. +-- +-- This is /heavily recommended/ over 'interceptUsingH' unless you need +-- the extra power that the 'Tactical' environment provides. +-- +-- @since TODO +interceptUsingNew :: forall e r a + . ElemOf e r + -> EffHandlerH e r + -> Sem r a + -> Sem r a +interceptUsingNew pr h = interpretNew h . exposeUsing pr +{-# INLINE interceptUsingNew #-} diff --git a/src/Polysemy/Internal/Union.hs b/src/Polysemy/Internal/Union.hs index e72691b9..78c5906b 100644 --- a/src/Polysemy/Internal/Union.hs +++ b/src/Polysemy/Internal/Union.hs @@ -82,7 +82,7 @@ instance Functor (Union r mWoven) where data Weaving e mAfter resultType where Weaving - :: forall t e rInitial a resultType mAfter. (MonadTransControl t) + :: forall t e rInitial a resultType mAfter. (MonadTransWeave t) => { weaveEffect :: e (Sem rInitial) a -- ^ The original effect GADT originally lifted via @@ -100,7 +100,7 @@ instance Functor (Weaving e m) where -weave :: (MonadTransControl t, Monad n) +weave :: (MonadTransWeave t, Monad n) => (forall x. m x -> t n x) -> (forall z x. Monad z => t z x -> z (StT t x)) -> Union r m a @@ -112,13 +112,13 @@ weave mkT' lwr' (Union pr (Weaving e mkT lwr ex)) = (fmap ex . getCompose) {-# INLINE weave #-} -liftHandler :: (MonadTransControl t, Monad m, Monad n) +liftHandler :: (MonadTransWeave t, Monad m, Monad n) => (forall x. Union r m x -> n x) -> Union r (t m) a -> t n a liftHandler = liftHandlerWithNat id {-# INLINE liftHandler #-} -liftHandlerWithNat :: (MonadTransControl t, Monad m, Monad n) +liftHandlerWithNat :: (MonadTransWeave t, Monad m, Monad n) => (forall x. q x -> t m x) -> (forall x. Union r m x -> n x) -> Union r q a -> t n a diff --git a/src/Polysemy/Internal/WeaveClass.hs b/src/Polysemy/Internal/WeaveClass.hs index 5d500f89..e636540f 100644 --- a/src/Polysemy/Internal/WeaveClass.hs +++ b/src/Polysemy/Internal/WeaveClass.hs @@ -1,8 +1,7 @@ {-# LANGUAGE GeneralizedNewtypeDeriving, QuantifiedConstraints, TupleSections #-} {-# OPTIONS_HADDOCK not-home #-} module Polysemy.Internal.WeaveClass - ( MonadTransControl(..) - , controlT + ( MonadTransWeave(..) , mkInitState , mkDistrib @@ -26,14 +25,14 @@ import qualified Control.Monad.Trans.State.Lazy as LSt import qualified Control.Monad.Trans.State.Strict as SSt import qualified Control.Monad.Trans.Writer.Lazy as LWr --- | A variant of the classic @MonadTransControl@ class from @monad-control@, +-- | A variant of the classic @MonadTransWeave@ class from @monad-control@, -- but with a small number of changes to make it more suitable with Polysemy's -- internals. class ( MonadTrans t , forall z. Monad z => Monad (t z) , Traversable (StT t) ) - => MonadTransControl t where + => MonadTransWeave t where type StT t :: * -> * hoistT :: (Monad m, Monad n) @@ -42,18 +41,18 @@ class ( MonadTrans t hoistT n m = controlT $ \lower -> n (lower m) {-# INLINE hoistT #-} + controlT :: Monad m + => ((forall z x. Monad z => t z x -> z (StT t x)) -> m (StT t a)) + -> t m a + controlT main = liftWith main >>= restoreT . pure + {-# INLINE controlT #-} + liftWith :: Monad m => ((forall z x. Monad z => t z x -> z (StT t x)) -> m a) -> t m a restoreT :: Monad m => m (StT t a) -> t m a -controlT :: (MonadTransControl t, Monad m) - => ((forall z x. Monad z => t z x -> z (StT t x)) -> m (StT t a)) - -> t m a -controlT main = liftWith main >>= restoreT . pure -{-# INLINE controlT #-} - newtype ComposeT t (u :: (* -> *) -> * -> *) m a = ComposeT { getComposeT :: t (u m) a } @@ -66,14 +65,19 @@ instance ( MonadTrans t => MonadTrans (ComposeT t u) where lift m = ComposeT (lift (lift m)) -instance ( MonadTransControl t - , MonadTransControl u +instance ( MonadTransWeave t + , MonadTransWeave u ) - => MonadTransControl (ComposeT t u) where + => MonadTransWeave (ComposeT t u) where type StT (ComposeT t u) = Compose (StT u) (StT t) hoistT n (ComposeT m) = ComposeT (hoistT (hoistT n) m) + controlT main = ComposeT $ + controlT $ \lowerT -> + controlT $ \lowerU -> + getCompose <$> main (\(ComposeT m) -> Compose <$> lowerU (lowerT m)) + liftWith main = ComposeT $ liftWith $ \lowerT -> liftWith $ \lowerU -> @@ -89,7 +93,7 @@ mkInitState :: Monad (t Identity) mkInitState lwr = runIdentity $ lwr (pure ()) {-# INLINE mkInitState #-} -mkDistrib :: (MonadTransControl t, Monad m) +mkDistrib :: (MonadTransWeave t, Monad m) => (forall n x. Monad n => (forall y. m y -> n y) -> q x -> t n x) -> (forall z x. Monad z => t z x -> z (StT t x)) -> Distrib (StT t) q m @@ -100,7 +104,7 @@ mkInspector :: Foldable f => f a -> Maybe a mkInspector = foldr (const . Just) Nothing {-# INLINE mkInspector #-} -instance MonadTransControl IdentityT where +instance MonadTransWeave IdentityT where type StT IdentityT = Identity hoistT = (coerce :: (m x -> n x) -> IdentityT m x -> IdentityT n x) @@ -108,52 +112,64 @@ instance MonadTransControl IdentityT where restoreT = IdentityT . fmap runIdentity -instance MonadTransControl (LSt.StateT s) where +instance MonadTransWeave (LSt.StateT s) where type StT (LSt.StateT s) = (,) s hoistT = LSt.mapStateT + controlT main = LSt.StateT $ \s -> + swap <$> main (\m -> swap <$> LSt.runStateT m s) + liftWith main = LSt.StateT $ \s -> (, s) <$> main (\m -> swap <$> LSt.runStateT m s) restoreT m = LSt.StateT $ \_ -> swap <$> m -instance MonadTransControl (SSt.StateT s) where +instance MonadTransWeave (SSt.StateT s) where type StT (SSt.StateT s) = (,) s hoistT = SSt.mapStateT + controlT main = SSt.StateT $ \s -> + swap <$!> main (\m -> swap <$!> SSt.runStateT m s) + liftWith main = SSt.StateT $ \s -> (, s) <$> main (\m -> swap <$!> SSt.runStateT m s) restoreT m = SSt.StateT $ \_ -> swap <$!> m -instance MonadTransControl (E.ExceptT e) where +instance MonadTransWeave (E.ExceptT e) where type StT (E.ExceptT e) = Either e hoistT = E.mapExceptT + controlT main = E.ExceptT (main E.runExceptT) + liftWith main = lift $ main E.runExceptT restoreT = E.ExceptT -instance Monoid w => MonadTransControl (LWr.WriterT w) where +instance Monoid w => MonadTransWeave (LWr.WriterT w) where type StT (LWr.WriterT w) = (,) w hoistT = LWr.mapWriterT + controlT main = LWr.WriterT (swap <$> main (fmap swap . LWr.runWriterT)) + liftWith main = lift $ main (fmap swap . LWr.runWriterT) restoreT m = LWr.WriterT (swap <$> m) -instance MonadTransControl MaybeT where +instance MonadTransWeave MaybeT where type StT MaybeT = Maybe hoistT = mapMaybeT + controlT main = MaybeT (main runMaybeT) + liftWith main = lift $ main runMaybeT restoreT = MaybeT diff --git a/src/Polysemy/Internal/Writer.hs b/src/Polysemy/Internal/Writer.hs index 73482034..c80f6ea2 100644 --- a/src/Polysemy/Internal/Writer.hs +++ b/src/Polysemy/Internal/Writer.hs @@ -41,25 +41,15 @@ writerToEndoWriter :: (Monoid o, Member (Writer (Endo o)) r) => Sem (Writer o ': r) a -> Sem r a -writerToEndoWriter = interpretH $ \case - Tell o -> tell (Endo (o <>)) >>= pureT +writerToEndoWriter = interpretNew $ \case + Tell o -> tell (Endo (o <>)) Listen m -> do - m' <- writerToEndoWriter <$> runT m - raise $ do - (o, fa) <- listen m' - return $ (,) (appEndo o mempty) <$> fa - Pass m -> do - ins <- getInspectorT - m' <- writerToEndoWriter <$> runT m - raise $ pass $ do - t <- m' - let - f' = - maybe - id - (\(f, _) (Endo oo) -> let !o' = f (oo mempty) in Endo (o' <>)) - (inspect ins t) - return (f', snd <$> t) + (o, a) <- listen (runH m) + return (appEndo o mempty, a) + Pass m -> pass $ do + (f, a) <- runH m + let f' (Endo oo) = let !o' = f (oo mempty) in Endo (o' <>) + return (f', a) {-# INLINE writerToEndoWriter #-} @@ -76,37 +66,31 @@ runWriterSTMAction :: forall o r a => (o -> STM ()) -> Sem (Writer o ': r) a -> Sem r a -runWriterSTMAction write = interpretH $ \case - Tell o -> do - t <- embedFinal $ atomically (write o) - pureT t +runWriterSTMAction write = interpretNew $ \case + Tell o -> embedFinal $ atomically (write o) Listen m -> do - m' <- runT m -- Using 'withWeavingToFinal' instead of 'withStrategicToFinal' -- here allows us to avoid using two additional 'embedFinal's in -- order to create the TVars. - raise $ withWeavingToFinal $ \s wv _ -> mask $ \restore -> do + withWeavingToFinal $ \s wv _ -> mask $ \restore -> do -- See below to understand how this works tvar <- newTVarIO mempty switch <- newTVarIO False fa <- - restore (wv (runWriterSTMAction (writeListen tvar switch) m' <$ s)) + restore (wv (runWriterSTMAction (writeListen tvar switch) (runH' m) <$ s)) `onException` commitListen tvar switch o <- commitListen tvar switch - return $ (fmap . fmap) (o, ) fa + return $ fmap (o, ) fa Pass m -> do - m' <- runT m - ins <- getInspectorT - raise $ withWeavingToFinal $ \s wv ins' -> mask $ \restore -> do + withWeavingToFinal $ \s wv ins' -> mask $ \restore -> do -- See below to understand how this works tvar <- newTVarIO mempty switch <- newTVarIO False t <- - restore (wv (runWriterSTMAction (writePass tvar switch) m' <$ s)) + restore (wv (runWriterSTMAction (writePass tvar switch) (runH' m) <$ s)) `onException` commitPass tvar switch id - commitPass tvar switch - (maybe id fst $ ins' t >>= inspect ins) - return $ (fmap . fmap) snd t + commitPass tvar switch $ maybe id fst (ins' t) + return $ fmap snd t where {- KingoftheHomeless: diff --git a/src/Polysemy/NonDet.hs b/src/Polysemy/NonDet.hs index 564eb6ab..24cad6c9 100644 --- a/src/Polysemy/NonDet.hs +++ b/src/Polysemy/NonDet.hs @@ -59,12 +59,10 @@ nonDetToError :: Member (Error e) r => e -> Sem (NonDet ': r) a -> Sem r a -nonDetToError (e :: e) = interpretH $ \case +nonDetToError (e :: e) = interpretNew $ \case Empty -> throw e Choose left right -> do - left' <- nonDetToError e <$> runT left - right' <- nonDetToError e <$> runT right - raise (left' `catch` \(_ :: e) -> right') + runH left `catch` \(_ :: e) -> runH right {-# INLINE nonDetToError #-} @@ -106,7 +104,7 @@ instance Monad (NonDetC m) where instance MonadTrans NonDetC where lift m = NonDetC $ \c b -> m >>= (`c` b) -instance MonadTransControl NonDetC where +instance MonadTransWeave NonDetC where type StT NonDetC = [] hoistT n nd = NonDetC $ \c b -> diff --git a/src/Polysemy/Reader.hs b/src/Polysemy/Reader.hs index 615f4925..18829ac1 100644 --- a/src/Polysemy/Reader.hs +++ b/src/Polysemy/Reader.hs @@ -37,11 +37,9 @@ asks f = f <$> ask ------------------------------------------------------------------------------ -- | Run a 'Reader' effect with a constant value. runReader :: i -> Sem (Reader i ': r) a -> Sem r a -runReader i = interpretH $ \case - Ask -> pureT i - Local f m -> do - mm <- runT m - raise $ runReader (f i) mm +runReader i = interpretNew $ \case + Ask -> return i + Local f m -> runReader (f i) (runH' m) {-# INLINE runReader #-} diff --git a/src/Polysemy/Resource.hs b/src/Polysemy/Resource.hs index d613aac0..7567fd42 100644 --- a/src/Polysemy/Resource.hs +++ b/src/Polysemy/Resource.hs @@ -19,6 +19,7 @@ module Polysemy.Resource ) where import qualified Control.Exception as X +import Control.Monad import Polysemy import Polysemy.Final @@ -182,34 +183,29 @@ runResource :: ∀ r a . Sem (Resource ': r) a -> Sem r a -runResource = interpretH $ \case +runResource = interpretNew $ \case Bracket alloc dealloc use -> do - a <- runT alloc - d <- bindT dealloc - u <- bindT use - - let run_it = raise . runResource - resource <- run_it a - result <- run_it $ u resource - _ <- run_it $ d resource - pure result + r <- runH alloc + ta <- runExposeH (use r) + -- If "use" failed locally -- which we determine by inspecting + -- the effectful state -- then we run 'dealloc', discarding any + -- changes it does to the local state. + if null ta then do + _ <- runExposeH (dealloc r) + restoreH ta + else do + -- If "use" suceceeded, the we restore it and simply run dealloc as normal. + a <- restoreH ta + _ <- runH (dealloc r) + return a BracketOnError alloc dealloc use -> do - a <- runT alloc - d <- bindT dealloc - u <- bindT use - - let run_it = raise . runResource - - resource <- run_it a - result <- run_it $ u resource - - ins <- getInspectorT - case inspect ins result of - Just _ -> pure result - Nothing -> do - _ <- run_it $ d resource - pure result + r <- runH alloc + ta <- runExposeH (use r) + when (null ta) $ do + _ <- runExposeH (dealloc r) + return () + restoreH ta {-# INLINE runResource #-} diff --git a/src/Polysemy/Writer.hs b/src/Polysemy/Writer.hs index 885a2bab..da985b1a 100644 --- a/src/Polysemy/Writer.hs +++ b/src/Polysemy/Writer.hs @@ -66,23 +66,23 @@ runWriter :: Monoid o => Sem (Writer o ': r) a -> Sem r (o, a) -runWriter = runState mempty . reinterpretH +runWriter = runState mempty . reinterpretNew (\case - Tell o -> do - modify' (<> o) >>= pureT + Tell o -> modify' (<> o) Listen m -> do - mm <- runT m - -- TODO(sandy): this is stupid - (o, fa) <- raise $ runWriter mm + -- runExposeH' to prevent local failures from ruining our day + (o, ta) <- runWriter (runExposeH' m) modify' (<> o) - pure $ (o, ) <$> fa + a <- restoreH ta + return (o, a) Pass m -> do - mm <- runT m - (o, t) <- raise $ runWriter mm - ins <- getInspectorT - let f = maybe id fst (inspect ins t) + (o, t) <- runWriter (runExposeH' m) + -- Try to extract the modification function from the t. + -- If "m" failed, default to id. + let f = foldr (const . fst) id t modify' (<> f o) - pure $ snd <$> t + (_, a) <- restoreH t + return a ) {-# INLINE runWriter #-} diff --git a/test/TacticsSpec.hs b/test/TacticsSpec.hs index 91da8934..726be3cc 100644 --- a/test/TacticsSpec.hs +++ b/test/TacticsSpec.hs @@ -15,7 +15,7 @@ interpretTestE = bindTSimple f a spec :: Spec -spec = parallel $ describe "runTH and bindTH" $ do +spec = parallel $ describe "runTSimple and bindTSimple" $ do it "should act as expected" $ do r <- runM (interpretTestE (send (TestE (pure 5) (pure . (9 +))))) print r From 9fecb6e9ab7efe6af9eed7eb1ddf347d9b3f5984 Mon Sep 17 00:00:00 2001 From: unknown Date: Mon, 4 Jan 2021 17:54:25 +0100 Subject: [PATCH 2/2] exposeH, getProcessorH --- polysemy.cabal | 5 +- src/Polysemy.hs | 12 +- src/Polysemy/Async.hs | 37 ++--- src/Polysemy/Error.hs | 14 +- src/Polysemy/Internal/Combinators.hs | 12 -- .../{InterpretNew.hs => Interpretation.hs} | 128 +++++++++++++----- src/Polysemy/Interpretation.hs | 15 ++ src/Polysemy/Membership.hs | 1 + src/Polysemy/Resource.hs | 1 + src/Polysemy/Writer.hs | 1 + 10 files changed, 147 insertions(+), 79 deletions(-) rename src/Polysemy/Internal/{InterpretNew.hs => Interpretation.hs} (63%) create mode 100644 src/Polysemy/Interpretation.hs diff --git a/polysemy.cabal b/polysemy.cabal index 60268f17..9a0ed51b 100644 --- a/polysemy.cabal +++ b/polysemy.cabal @@ -4,7 +4,7 @@ cabal-version: 2.0 -- -- see: https://github.com/sol/hpack -- --- hash: 53283f3e0706b3474ab26a2b75fc509c9ef2332c6580662107613bcf3dbecaf5 +-- hash: d7bfeced9fb04f06fed1d7d70c5ba8bbb99be9e4bf37c0b6e514fca6891a1405 name: polysemy version: 1.4.0.0 @@ -64,7 +64,7 @@ library Polysemy.Internal.CustomErrors.Redefined Polysemy.Internal.Fixpoint Polysemy.Internal.Forklift - Polysemy.Internal.InterpretNew + Polysemy.Internal.Interpretation Polysemy.Internal.Kind Polysemy.Internal.NonDet Polysemy.Internal.Strategy @@ -74,6 +74,7 @@ library Polysemy.Internal.Union Polysemy.Internal.WeaveClass Polysemy.Internal.Writer + Polysemy.Interpretation Polysemy.IO Polysemy.Law Polysemy.Membership diff --git a/src/Polysemy.hs b/src/Polysemy.hs index dbaf4df4..462e9572 100644 --- a/src/Polysemy.hs +++ b/src/Polysemy.hs @@ -136,13 +136,15 @@ module Polysemy -- | When interpreting higher-order effects using 'interpretNew' -- and friends, you can't execute higher-order \"thunks\" given by -- the interpreted effect directly. Instead, these must be executed - -- using 'runH'. + -- using 'runH' or 'runH''. + -- + -- These functions are enough for most purposes when using + -- 'interpretNew'. However, "Polysemy.Interpretation" offers + -- additional, more complicated features which are occassionally + -- needed. , RunH , runH , runH' - , runExposeH - , runExposeH' - , restoreH -- * Tactics -- | Higher-order effects need to explicitly thread /other effects'/ state @@ -169,7 +171,7 @@ module Polysemy import Polysemy.Final import Polysemy.Internal import Polysemy.Internal.Combinators -import Polysemy.Internal.InterpretNew +import Polysemy.Internal.Interpretation import Polysemy.Internal.Forklift import Polysemy.Internal.Kind import Polysemy.Internal.Tactics diff --git a/src/Polysemy/Async.hs b/src/Polysemy/Async.hs index e1aa2b66..c5e40e7c 100644 --- a/src/Polysemy/Async.hs +++ b/src/Polysemy/Async.hs @@ -21,6 +21,7 @@ module Polysemy.Async import qualified Control.Concurrent.Async as A import Polysemy import Polysemy.Final +import Polysemy.Interpretation @@ -72,16 +73,16 @@ asyncToIO => Sem (Async ': r) a -> Sem r a asyncToIO m = withLowerToIO $ \lower _ -> lower $ - interpretH + interpretNew ( \case - Async a -> do - ma <- runT a - ins <- getInspectorT - fa <- embed $ A.async $ lower $ asyncToIO ma - pureT $ inspect ins <$> fa - - Await a -> pureT =<< embed (A.wait a) - Cancel a -> pureT =<< embed (A.cancel a) + Async ma -> do + Processor pr <- getProcessorH' + fa <- embed $ A.async $ lower $ asyncToIO (pr ma) + let ins = foldr (const . Just) Nothing + return (fmap ins fa) + + Await a -> embed (A.wait a) + Cancel a -> embed (A.cancel a) ) m {-# INLINE asyncToIO #-} @@ -126,16 +127,16 @@ lowerAsync -- some combination of 'runM' and other interpreters composed via '.@'. -> Sem (Async ': r) a -> Sem r a -lowerAsync lower m = interpretH +lowerAsync lower m = interpretNew ( \case - Async a -> do - ma <- runT a - ins <- getInspectorT - fa <- embed $ A.async $ lower $ lowerAsync lower ma - pureT $ inspect ins <$> fa - - Await a -> pureT =<< embed (A.wait a) - Cancel a -> pureT =<< embed (A.cancel a) + Async ma -> do + Processor pr <- getProcessorH + let ins = foldr (const . Just) Nothing + fa <- embed $ A.async $ lower $ pr ma + return $ ins <$> fa + + Await a -> embed (A.wait a) + Cancel a -> embed (A.cancel a) ) m {-# INLINE lowerAsync #-} {-# DEPRECATED lowerAsync "Use 'asyncToIOFinal' instead" #-} diff --git a/src/Polysemy/Error.hs b/src/Polysemy/Error.hs index d4ca40f3..eb742cfe 100644 --- a/src/Polysemy/Error.hs +++ b/src/Polysemy/Error.hs @@ -33,6 +33,7 @@ import Data.Bifunctor (first) import Data.Typeable import Polysemy import Polysemy.Final +import Polysemy.Interpretation import Polysemy.Internal import Polysemy.Internal.Union @@ -309,13 +310,12 @@ runErrorAsExc => (∀ x. Sem r x -> IO x) -> Sem (Error e ': r) a -> Sem r a -runErrorAsExc lower = interpretH $ \case +runErrorAsExc lower = interpretNew $ \case Throw e -> embed $ X.throwIO $ WrappedExc e Catch main handle -> do - is <- getInitialStateT - m <- runT main - h <- bindT handle - let runIt = lower . runErrorAsExc lower - embed $ X.catch (runIt m) $ \(se :: WrappedExc e) -> - runIt $ h $ unwrapExc se <$ is + Processor pr <- getProcessorH + let runIt = lower . pr + ta <- embed $ X.catch (runIt main) $ \(se :: WrappedExc e) -> + runIt $ handle $ unwrapExc se + restoreH ta {-# INLINE runErrorAsExc #-} diff --git a/src/Polysemy/Internal/Combinators.hs b/src/Polysemy/Internal/Combinators.hs index a0b39c5e..06fffce2 100644 --- a/src/Polysemy/Internal/Combinators.hs +++ b/src/Polysemy/Internal/Combinators.hs @@ -12,16 +12,6 @@ module Polysemy.Internal.Combinators , rewrite , transform - -- * Higher order - , RunH(..) - , runH - - , interpretNew - , interceptNew - , reinterpretNew - , reinterpret2New - , reinterpret3New - -- * Higher order with 'Tactical' , interpretH , interceptH @@ -32,7 +22,6 @@ module Polysemy.Internal.Combinators -- * Conditional , interceptUsing , interceptUsingH - , interceptUsingNew -- * Statefulness , stateful @@ -47,7 +36,6 @@ import Polysemy.Internal import Polysemy.Internal.CustomErrors import Polysemy.Internal.Tactics import Polysemy.Internal.Union -import Polysemy.Internal.InterpretNew firstOrder :: ((forall rInitial x. e (Sem rInitial) x -> diff --git a/src/Polysemy/Internal/InterpretNew.hs b/src/Polysemy/Internal/Interpretation.hs similarity index 63% rename from src/Polysemy/Internal/InterpretNew.hs rename to src/Polysemy/Internal/Interpretation.hs index 2552dffc..729aa096 100644 --- a/src/Polysemy/Internal/InterpretNew.hs +++ b/src/Polysemy/Internal/Interpretation.hs @@ -1,4 +1,6 @@ -module Polysemy.Internal.InterpretNew where +{-# LANGUAGE AllowAmbiguousTypes #-} +{-# OPTIONS_HADDOCK not-home #-} +module Polysemy.Internal.Interpretation where import Polysemy.Internal import Polysemy.Internal.WeaveClass @@ -6,13 +8,16 @@ import Polysemy.Internal.Union import Polysemy.Internal.Kind +newtype Processor z t r = Processor { getProcessor :: forall x. z x -> Sem r (t x) } + -- | An effect for running monadic actions within a higher-order effect -- currently being interpreted. -data RunH z t r :: Effect where - RunH :: forall z t r m a. z a -> RunH z t r m a - RunExposeH :: forall z t r m a. z a -> RunH z t r m (t a) - RunExposeH' :: forall z t r m a. z a -> RunH z t r m (Sem r (t a)) - RestoreH :: forall z t r m a. t a -> RunH z t r m a +data RunH z t e r :: Effect where + RunH :: forall z t e r m a. z a -> RunH z t e r m a + GetProcessorH :: forall z t e r m. RunH z t e r m (Processor z t r) + GetProcessorH' :: forall z t e r m. RunH z t e r m (Processor z t (e ': r)) + ExposeH :: forall z t e r m a. m a -> RunH z t e r m (t a) + RestoreH :: forall z t e r m a. t a -> RunH z t e r m a -- | Run a monadic action given by a higher-order effect that is currently -- being interpreted, and recursively apply the current interpreter on it. @@ -20,8 +25,8 @@ data RunH z t r :: Effect where -- This is the standard tool for interpreting higher-order effects. -- -- @since TODO -runH :: forall z t r r' a. z a -> Sem (RunH z t r ': r') a -runH = send . RunH @z @t @r +runH :: forall z t e r r' a. z a -> Sem (RunH z t e r ': r') a +runH = send . RunH @z @t @e @r {-# INLINE runH #-} -- | Run a monadic action given by a higher-order effect that is currently @@ -32,7 +37,7 @@ runH = send . RunH @z @t @r -- on it instead. -- -- @since TODO -runH' :: forall z t e r a. z a -> Sem (e ': RunH z t (e ': r) ': r) a +runH' :: forall z t e r a. z a -> Sem (e ': RunH z t e r ': r) a runH' z = runExposeH' z >>= raise . restoreH {-# INLINE runH' #-} @@ -52,8 +57,10 @@ runH' z = runExposeH' z >>= raise . restoreH -- Once an effectful state has been reified, you may restore it using 'restoreH'. -- -- @since TODO -runExposeH :: forall z t r r' a. z a -> Sem (RunH z t r ': r') (t a) -runExposeH = send . RunExposeH @z @t @r +runExposeH :: forall z t e r a. z a -> Sem (RunH z t e r ': r) (t a) +runExposeH z = do + Processor pr <- getProcessorH + raise (pr z) {-# INLINE runExposeH #-} -- | Run a monadic action given by a higher-order effect that is currently @@ -67,11 +74,15 @@ runExposeH = send . RunExposeH @z @t @r -- on it instead. -- -- @since TODO -runExposeH' :: forall z t e r a. z a -> Sem (e ': RunH z t (e ': r) ': r) (t a) -runExposeH' z = raise (send (RunExposeH' @_ @t z)) >>= raiseUnder +runExposeH' :: forall z t e r a. z a -> Sem (e ': RunH z t e r ': r) (t a) +runExposeH' z = do + Processor pr <- raise getProcessorH' + raiseUnder (pr z) {-# INLINE runExposeH' #-} --- Restore a reified effectful state, bringing its changes into scope, and returning + + +-- | Restore a reified effectful state, bringing its changes into scope, and returning -- the result of the computation. -- -- /Note/: this overrides the local effectful state of any previously restored effectful state. @@ -96,14 +107,49 @@ runExposeH' z = raise (send (RunExposeH' @_ @t z)) >>= raiseUnder -- 'tb' <- runExposeH mb -- 'restoreH' tb -- @ -restoreH :: forall z t r r' a. t a -> Sem (RunH z t r ': r') a -restoreH = send . RestoreH @z @t @r +-- +-- @since TODO +restoreH :: forall z t e r r' a. t a -> Sem (RunH z t e r ': r') a +restoreH = send . RestoreH @z @_ @e @r {-# INLINE restoreH #-} + +-- | Reify the effectful state of the local effects of the argument. +-- +-- @'runExposeH' m = 'exposeH' ('runH' m)@ +-- +-- /Note/: `polysemy-plugin` is heavily recommended when using this function +-- to avoid type ambiguous types. If `polysemy-plugin` isn't available, consider +-- using 'runExposeH' and `runExposeH'` instead. +-- +-- @since TODO +exposeH :: forall z t e r r' a. Member (RunH z t e r) r' => Sem r' a -> Sem r' (t a) +exposeH = send . ExposeH @z @_ @e @r +{-# INLINE exposeH #-} + +-- | Retrieve a 'Processor': a function which can be used +-- to process a monadic action given by a higher-order effect that is currently +-- being interpreted without immediately running it, turning it into a @'Sem' r@ action +-- that returns a reified effectful state. +-- +-- The processor automatically recursively applies the current interpreter on +-- monadic actions processed. +getProcessorH :: forall z t e r r'. Sem (RunH z t e r ': r') (Processor z t r) +getProcessorH = send (GetProcessorH @_ @_ @e) +{-# INLINE getProcessorH #-} + +-- | Retrieve a 'Processor': a function which can be used +-- to process a monadic action given by a higher-order effect that is currently +-- being interpreted without immediately running it, turning it into a @'Sem' (e ': r)@ action +-- that returns a reified effectful state. +getProcessorH' :: forall z t e r r'. Sem (RunH z t e r ': r') (Processor z t (e ': r)) +getProcessorH' = send GetProcessorH' +{-# INLINE getProcessorH' #-} + type EffHandlerH e r = forall z t x . Traversable t - => e z x -> Sem (RunH z t (e ': r) ': r) x + => e z x -> Sem (RunH z t e r ': r) x ------------------------------------------------------------------------------ -- | Like 'interpret', but for higher-order effects (i.e. those which make use @@ -149,33 +195,45 @@ interpretNew h (Sem sem) = Sem $ \(k :: forall x. Union r (Sem r) x -> m x) -> ex ) -> let - go1 :: forall x. Sem (RunH z (StT t) (e ': r) ': r) x -> t m x + go1 :: forall x. Sem (RunH z (StT t) e r ': r) x -> t m x go1 = usingSem $ \u' -> case decomp u' of Left g -> liftHandlerWithNat go2 k g - Right (Weaving eff _ lwr' ex') -> do - (ex' . (<$ mkInitState lwr')) <$> case eff of - RunH z -> + Right (Weaving eff mkT' lwr' ex') -> do + let run_it = fmap (ex' . (<$ mkInitState lwr')) + case eff of + RunH z -> run_it $ mkT (usingSem k . interpretNew h) z - RunExposeH z -> - liftWith $ \lower -> lower (mkT (usingSem k . interpretNew h) z) - RunExposeH' z -> - liftWith $ \lower -> return (lower (mkT id z)) - RestoreH t -> + GetProcessorH -> run_it $ + liftWith $ \lower -> return $ Processor (lower . mkT (interpretNew h)) + GetProcessorH' -> run_it $ + liftWith $ \lower -> return $ Processor (lower . mkT id) + RestoreH t -> run_it $ restoreT (return t) + ExposeH m -> fmap ex' $ lwr' $ controlT $ \lower' -> do + let m' = lower' (mkT' go1 m) + liftWith $ \lower -> do + t <- lower m' + lower' $ traverse (restoreT . return) t - go2 :: forall x. Sem (RunH z (StT t) (e ': r) ': r) x -> t (Sem r) x + go2 :: forall x. Sem (RunH z (StT t) e r ': r) x -> t (Sem r) x go2 = usingSem $ \u' -> case decomp u' of Left g -> liftHandlerWithNat go2 liftSem g - Right (Weaving eff _ lwr' ex') -> do - (ex' . (<$ mkInitState lwr')) <$> case eff of - RunH z -> + Right (Weaving eff mkT' lwr' ex') -> do + let run_it = fmap (ex' . (<$ mkInitState lwr')) + case eff of + RunH z -> run_it $ mkT (interpretNew h) z - RunExposeH z -> - liftWith $ \lower -> lower (mkT (interpretNew h) z) - RunExposeH' z -> - liftWith $ \lower -> return (lower (mkT id z)) - RestoreH t -> + GetProcessorH -> run_it $ + liftWith $ \lower -> return $ Processor (lower . mkT (interpretNew h)) + GetProcessorH' -> run_it $ + liftWith $ \lower -> return $ Processor (lower . mkT id) + RestoreH t -> run_it $ restoreT (return t) + ExposeH m -> fmap ex' $ lwr' $ controlT $ \lower' -> do + let m' = lower' (mkT' go2 m) + liftWith $ \lower -> do + t <- lower m' + lower' $ traverse (restoreT . return) t in fmap ex $ lwr $ go1 (h e) diff --git a/src/Polysemy/Interpretation.hs b/src/Polysemy/Interpretation.hs new file mode 100644 index 00000000..22437356 --- /dev/null +++ b/src/Polysemy/Interpretation.hs @@ -0,0 +1,15 @@ +-- | Tools for more advanced usages of 'Polysemy.interpretNew' +module Polysemy.Interpretation + ( -- * Manipuluating effectful state + runExposeH + , runExposeH' + , exposeH + , restoreH + + -- * Lowering Higher-Order thunks to actions of @'Sem' r@. + , Processor(..) + , getProcessorH + , getProcessorH' + ) where + +import Polysemy.Internal.Interpretation diff --git a/src/Polysemy/Membership.hs b/src/Polysemy/Membership.hs index fb6c4f49..c5472082 100644 --- a/src/Polysemy/Membership.hs +++ b/src/Polysemy/Membership.hs @@ -15,4 +15,5 @@ module Polysemy.Membership import Polysemy.Internal import Polysemy.Internal.Combinators +import Polysemy.Internal.Interpretation import Polysemy.Internal.Union diff --git a/src/Polysemy/Resource.hs b/src/Polysemy/Resource.hs index 7567fd42..ca5a731b 100644 --- a/src/Polysemy/Resource.hs +++ b/src/Polysemy/Resource.hs @@ -22,6 +22,7 @@ import qualified Control.Exception as X import Control.Monad import Polysemy import Polysemy.Final +import Polysemy.Interpretation ------------------------------------------------------------------------------ diff --git a/src/Polysemy/Writer.hs b/src/Polysemy/Writer.hs index da985b1a..ee5e3037 100644 --- a/src/Polysemy/Writer.hs +++ b/src/Polysemy/Writer.hs @@ -33,6 +33,7 @@ import Data.Semigroup import Polysemy import Polysemy.Output import Polysemy.State +import Polysemy.Interpretation import Polysemy.Internal.Union import Polysemy.Internal.Writer