Effect systems are being actively explored as ways to structure Haskell programs. This package provides experimental support for the effectful effect system.

This module introcuces a new effect, ProgramE, which plumbs the current program context into the effect system. By calling runProgramE to add the ProgramE effect to the current list of in-scope effects you can then use withProgram' to run a Program action. The more general withProgram gives you an unlifting function to return back to the effect system so you can continue processing within your effects stack.

Usage

As an example, here's an effect which lifts to Program τ, does some log output, then unlifts back to Eff es to then query something from the Environment effect (which requires the IOE effect to run):

retrieveProgramName
    :: forall τ es
     . (IOE :> es, ProgramE τ :> es)
    => Eff es ()
retrieveProgramName = do
    -- we're in (IOE :> es, ProgramE :> es) => Eff es, right?

    withProgram @τ $ \runEffect -> do
        -- now we're in Program τ

        info "Running in Program"

        path <- runEffect $ do
            -- now back in (IOE :> es, ProgramE τ :> es) => Eff es, and can call
            -- something that requires the IOE effect be present.

            runEnvironment $ do
                -- now in (Environment :> es) => Eff es
                getExecutablePath

        info "Done running effects"
        debugS "path" path

The @τ type application shown here is vital; without it the compiler will not be able to resolve all the ambiguous types when attempting to determine which effect to run. It doesn't have to be polymorphic; if you know the actual top-level application state type you can do @Settings or whatever.

This all assumes you are running with the ProgramE τ effect in-scope. You can achieve that as follows:

main :: IO ()
main = execute program

program :: Program None ()
program = do
    -- in Program τ, where τ is None here
    context <- getContext
    liftIO $ do
        -- in IO
        runEff $ do
            -- in (IOE :> es) => Eff es
            runProgramE context $ do
                -- in (IOE :> es, ProgramE τ :> es) => Eff es
                ...