Cleff.Internal.Monad

This module contains the definition of the Eff monad, which is basically an Env es -> IO a, as well as functions for manipulating the effect environment type Env. Most of the times, you won't need to use this module directly; user-facing functionalities are all exported via the Cleff module.

This is an internal module and its API may change even between minor versions. Therefore you should be extra careful if you're to depend on this module.

Core types

newtype InternalHandler e

The internal representation of effect handlers. This is just a natural transformation from the effect type e (Eff es) to the effect monad Eff es for any effect stack es.

In interpreting functions (see Cleff.Internal.Interpret), the user-facing Handler type is transformed into this type.

Constructors

InternalHandler

Fields

• runHandler :: forall es. e (Eff es) ~> Eff es

Instances

Typeable e => Show (InternalHandler e)

show (handler :: InternalHandler E) == "Handler E"

Defined in Cleff.Internal.Monad

Methods

showsPrec :: Int -> InternalHandler e -> ShowS

show :: InternalHandler e -> String

showList :: [InternalHandler e] -> ShowS

type Env = Mem InternalHandler

The effect memironment that stores handlers of any effect present in the stack es.

newtype Eff es a

The extensible effect monad. A monad Eff es is capable of performing any effect in the effect stack es, which is a type-level list that holds all effects available. However, most of the times, for flexibility, es should be a polymorphic type variable, and you should use the (:>) and (:>>) operators in constraints to indicate what effects are in the stack. For example,

Reader String :> es, State Bool :> es => Eff es Integer

allows you to perform operations of the Reader String effect and the State Bool effect in a computation returning an Integer.

Constructors

Eff

Fields

• unEff :: Env es -> IO a

Instances

IOE :> es => MonadBase IO (Eff es)

Compatibility instance; use MonadIO if possible.

Defined in Cleff.Internal.Base

Methods

liftBase :: IO α -> Eff es α

IOE :> es => MonadBaseControl IO (Eff es)

Compatibility instance; use MonadUnliftIO if possible.

Defined in Cleff.Internal.Base

Associated Types

type StM (Eff es) a

Methods

liftBaseWith :: (RunInBase (Eff es) IO -> IO a) -> Eff es a

restoreM :: StM (Eff es) a -> Eff es a

Monad (Eff es)

Defined in Cleff.Internal.Monad

Methods

(>>=) :: Eff es a -> (a -> Eff es b) -> Eff es b

(>>) :: Eff es a -> Eff es b -> Eff es b

return :: a -> Eff es a

Functor (Eff es)

Defined in Cleff.Internal.Monad

Methods

fmap :: (a -> b) -> Eff es a -> Eff es b

(<$) :: a -> Eff es b -> Eff es a

MonadFix (Eff es)

Defined in Cleff.Internal.Monad

Methods

mfix :: (a -> Eff es a) -> Eff es a

Fail :> es => MonadFail (Eff es)

Defined in Cleff.Fail

Methods

fail :: String -> Eff es a

Applicative (Eff es)

Defined in Cleff.Internal.Monad

Methods

pure :: a -> Eff es a

(<*>) :: Eff es (a -> b) -> Eff es a -> Eff es b

liftA2 :: (a -> b -> c) -> Eff es a -> Eff es b -> Eff es c

(*>) :: Eff es a -> Eff es b -> Eff es b

(<*) :: Eff es a -> Eff es b -> Eff es a

IOE :> es => MonadIO (Eff es)

Defined in Cleff.Internal.Base

Methods

liftIO :: IO a -> Eff es a

IOE :> es => MonadThrow (Eff es)

Defined in Cleff.Internal.Base

Methods

throwM :: Exception e => e -> Eff es a

IOE :> es => MonadCatch (Eff es)

Defined in Cleff.Internal.Base

Methods

catch :: Exception e => Eff es a -> (e -> Eff es a) -> Eff es a

IOE :> es => MonadMask (Eff es)

Defined in Cleff.Internal.Base

Methods

mask :: ((forall a. Eff es a -> Eff es a) -> Eff es b) -> Eff es b

uninterruptibleMask :: ((forall a. Eff es a -> Eff es a) -> Eff es b) -> Eff es b

generalBracket :: Eff es a -> (a -> ExitCase b -> Eff es c) -> (a -> Eff es b) -> Eff es (b, c)

IOE :> es => PrimMonad (Eff es)

Defined in Cleff.Internal.Base

Associated Types

type PrimState (Eff es)

Methods

primitive :: (State# (PrimState (Eff es)) -> (# State# (PrimState (Eff es)), a #)) -> Eff es a

IOE :> es => MonadUnliftIO (Eff es)

Defined in Cleff.Internal.Base

Methods

withRunInIO :: ((forall a. Eff es a -> IO a) -> IO b) -> Eff es b

Semigroup a => Semigroup (Eff es a)

Defined in Cleff.Internal.Monad

Methods

(<>) :: Eff es a -> Eff es a -> Eff es a

sconcat :: NonEmpty (Eff es a) -> Eff es a

stimes :: Integral b => b -> Eff es a -> Eff es a

Monoid a => Monoid (Eff es a)

Defined in Cleff.Internal.Monad

Methods

mempty :: Eff es a

mappend :: Eff es a -> Eff es a -> Eff es a

mconcat :: [Eff es a] -> Eff es a

type PrimState (Eff es)

Defined in Cleff.Internal.Base

type PrimState (Eff es) = RealWorld

type StM (Eff es) a

Defined in Cleff.Internal.Base

type StM (Eff es) a = a

Performing effect operations

class KnownList (es :: [k])

The list es list is concrete, i.e. is of the form '[a1, a2, ..., an], i.e. is not a type variable.

Instances

KnownList ('[] :: [k])

Defined in Data.Rec

Methods

reifyLen :: Int

KnownList es => KnownList (e ': es :: [k])

Defined in Data.Rec

Methods

reifyLen :: Int

class KnownList es => Subset (es :: [k]) (es' :: [k])

es is a subset of es'.

Instances

Subset ('[] :: [k]) (es :: [k])

Defined in Data.Rec

Methods

reifyIndices :: [Int]

(Subset es es', Elem e es') => Subset (e ': es :: [k]) (es' :: [k])

Defined in Data.Rec

Methods

reifyIndices :: [Int]

send :: e :> es => e (Eff es) ~> Eff es

Perform an effect operation, i.e. a value of an effect type e :: Effect. This requires e to be in the effect stack.