Turn an effect handler into an effectful operation.

Since: 2.3.0.0

>>> import Control.Monad.IO.Class
>>> import Data.Map.Strict qualified as M
>>> import Effectful.Dispatch.Dynamic
>>> import Effectful.State.Static.Local

Given an effect:

>>> :{
  data Write :: Effect where
    Write :: String -> Write m ()
  type instance DispatchOf Write = Dynamic
:}

>>> :{
  write :: Write :> es => String -> Eff es ()
  write = send . Write
:}

its handler can be turned into an effectful operation with the Provider effect:

>>> :{
  action :: Provider_ Write FilePath :> es => Eff es ()
  action = do
    provideWith_ @Write "in.txt" $ do
      write "hi"
      write "there"
    provideWith_ @Write "out.txt" $ do
      write "good"
      write "bye"
:}

Then, given multiple interpreters:

>>> :{
  runWriteIO
    :: IOE :> es
    => FilePath
    -> Eff (Write : es) a
    -> Eff es a
  runWriteIO fp = interpret_ $ \case
    Write msg -> liftIO . putStrLn $ fp ++ ": " ++ msg
:}

>>> :{
  runWritePure
    :: State (M.Map FilePath [String]) :> es
    => FilePath
    -> Eff (Write : es) a
    -> Eff es a
  runWritePure fp = interpret_ $ \case
    Write msg -> modify $ M.insertWith (++) fp [msg]
:}

action can be supplied with either of them for the appropriate behavior:

>>> :{
  runEff
    . runProvider_ runWriteIO
    $ action
:}
in.txt: hi
in.txt: there
out.txt: good
out.txt: bye

>>> :{
  runPureEff
    . fmap (fmap reverse)
    . execState @(M.Map FilePath [String]) M.empty
    . runProvider_ runWritePure
    $ action
:}
fromList [("in.txt",["hi","there"]),("out.txt",["good","bye"])]