Polysemy.Internal

Documentation

newtype Sem r a

The Sem monad handles computations of arbitrary extensible effects. A value of type Sem r describes a program with the capabilities of r. For best results, r should always be kept polymorphic, but you can add capabilities via the Member constraint.

The value of the Sem monad is that it allows you to write programs against a set of effects without a predefined meaning, and provide that meaning later. For example, unlike with mtl, you can decide to interpret an Error effect traditionally as an Either, or instead as (a significantly faster) IO Exception. These interpretations (and others that you might add) may be used interchangeably without needing to write any newtypes or Monad instances. The only change needed to swap interpretations is to change a call from runError to errorToIOFinal.

The effect stack r can contain arbitrary other monads inside of it. These monads are lifted into effects via the Embed effect. Monadic values can be lifted into a Sem via embed.

Higher-order actions of another monad can be lifted into higher-order actions of Sem via the Final effect, which is more powerful than Embed, but also less flexible to interpret.

A Sem can be interpreted as a pure value (via run) or as any traditional Monad (via runM or runFinal). Each effect E comes equipped with some interpreters of the form:

runE :: Sem (E ': r) a -> Sem r a

which is responsible for removing the effect E from the effect stack. It is the order in which you call the interpreters that determines the monomorphic representation of the r parameter.

Order of interpreters can be important - it determines behaviour of effects that manipulate state or change control flow. For example, when interpreting this action:

>>> :{
  example :: Members '[State String, Error String] r => Sem r String
  example = do
    put "start"
    let throwing, catching :: Members '[State String, Error String] r => Sem r String
        throwing = do
          modify (++"-throw")
          throw "error"
          get
        catching = do
          modify (++"-catch")
          get
    catch @String throwing (\ _ -> catching)
:}

when handling Error first, state is preserved after error occurs:

>>> :{
  example
    & runError
    & fmap (either id id)
    & evalState ""
    & runM
    & (print =<<)
:}
"start-throw-catch"

while handling State first discards state in such cases:

>>> :{
  example
    & evalState ""
    & runError
    & fmap (either id id)
    & runM
    & (print =<<)
:}
"start-catch"

A good rule of thumb is to handle effects which should have "global" behaviour over other effects later in the chain.

After all of your effects are handled, you'll be left with either a Sem '[] a, a Sem '[ Embed m ] a, or a Sem '[ Final m ] a value, which can be consumed respectively by run, runM, and runFinal.

Examples

As an example of keeping r polymorphic, we can consider the type

Member (State String) r => Sem r ()

to be a program with access to

get :: Sem r String
put :: String -> Sem r ()

methods.

By also adding a

Member (Error Bool) r

constraint on r, we gain access to the

throw :: Bool -> Sem r a
catch :: Sem r a -> (Bool -> Sem r a) -> Sem r a

functions as well.

In this sense, a Member (State s) r constraint is analogous to mtl's MonadState s m and should be thought of as such. However, unlike mtl, a Sem monad may have an arbitrary number of the same effect.

For example, we can write a Sem program which can output either Ints or Bools:

foo :: ( Member (Output Int) r
       , Member (Output Bool) r
       )
    => Sem r ()
foo = do
  output @Int  5
  output True

Notice that we must use -XTypeApplications to specify that we'd like to use the (Output Int) effect.

Since: 0.1.2.0

Constructors

Sem

Fields

• runSem :: forall m. Monad m => (forall x. Union r (Sem r) x -> m x) -> m a

Instances

Monad (Sem f)

Defined in Polysemy.Internal

Methods

(>>=) :: Sem f a -> (a -> Sem f b) -> Sem f b

(>>) :: Sem f a -> Sem f b -> Sem f b

return :: a -> Sem f a

Functor (Sem f)

Defined in Polysemy.Internal

Methods

fmap :: (a -> b) -> Sem f a -> Sem f b

(<$) :: a -> Sem f b -> Sem f a

Member Fixpoint r => MonadFix (Sem r)

Defined in Polysemy.Internal

Methods

mfix :: (a -> Sem r a) -> Sem r a

Member (Fail :: (Type -> Type) -> Type -> Type) r => MonadFail (Sem r)

Since: 1.1.0.0

Defined in Polysemy.Internal

Methods

fail :: String -> Sem r a

Applicative (Sem f)

Defined in Polysemy.Internal

Methods

pure :: a -> Sem f a

(<*>) :: Sem f (a -> b) -> Sem f a -> Sem f b

liftA2 :: (a -> b -> c) -> Sem f a -> Sem f b -> Sem f c

(*>) :: Sem f a -> Sem f b -> Sem f b

(<*) :: Sem f a -> Sem f b -> Sem f a

Member (Embed IO) r => MonadIO (Sem r)

This instance will only lift IO actions. If you want to lift into some other MonadIO type, use this instance, and handle it via the embedToMonadIO interpretation.

Defined in Polysemy.Internal

Methods

liftIO :: IO a -> Sem r a

Member NonDet r => Alternative (Sem r)

Defined in Polysemy.Internal

Methods

empty :: Sem r a

(<|>) :: Sem r a -> Sem r a -> Sem r a

some :: Sem r a -> Sem r [a]

many :: Sem r a -> Sem r [a]

Member NonDet r => MonadPlus (Sem r)

Since: 0.2.1.0

Defined in Polysemy.Internal

Methods

mzero :: Sem r a

mplus :: Sem r a -> Sem r a -> Sem r a

Citizen (Sem r a -> b) (Sem r a -> b)

Defined in Polysemy.Law

Methods

getCitizen :: (Sem r a -> b) -> (Sem r a -> b) -> Gen ([String], (Sem r a -> b, Sem r a -> b))

Citizen (Sem r a) (Sem r a)

Defined in Polysemy.Law

Methods

getCitizen :: Sem r a -> Sem r a -> Gen ([String], (Sem r a, Sem r a))

type Member e r = MemberNoError e r

A proof that the effect e is available somewhere inside of the effect stack r.

type MemberWithError e r = (MemberNoError e r, WhenStuck (LocateEffect e r) (AmbiguousSend e r))

Like Member, but will produce an error message if the types are ambiguous. This is the constraint used for actions generated by makeSem.

Be careful with this. Due to quirks of TypeError, the custom error messages emitted by this can potentially override other, more helpful error messages. See the discussion in Issue #227.

Since: 1.2.3.0

type family Members es r :: Constraint where ...

Makes constraints of functions that use multiple effects shorter by translating single list of effects into multiple Member constraints:

foo :: Members '[ Output Int
                , Output Bool
                , State String
                ] r
    => Sem r ()

translates into:

foo :: ( Member (Output Int) r
       , Member (Output Bool) r
       , Member (State String) r
       )
    => Sem r ()

Since: 0.1.2.0

Equations

Members '[] r = ()

Members (e ': es) r = (Member e r, Members es r)

send :: Member e r => e (Sem r) a -> Sem r a

Embed an effect into a Sem. This is used primarily via makeSem to implement smart constructors.

sendUsing :: ElemOf e r -> e (Sem r) a -> Sem r a

Embed an effect into a Sem, given an explicit proof that the effect exists in r.

This is useful in conjunction with tryMembership, in order to conditionally make use of effects.

embed :: Member (Embed m) r => m a -> Sem r a

Embed a monadic action m in Sem.

Since: 1.0.0.0

run :: Sem '[] a -> a

Run a Sem containing no effects as a pure value.

runM :: Monad m => Sem '[Embed m] a -> m a

Lower a Sem containing only a single lifted Monad into that monad.

raise_ :: forall r r' a. Raise r r' => Sem r a -> Sem r' a

Introduce an arbitrary number of effects on top of the effect stack. This function is highly polymorphic, so it may be good idea to use its more concrete versions (like raise) or type annotations to avoid vague errors in ambiguous contexts.

Since: 1.4.0.0

class Raise (r :: EffectRow) (r' :: EffectRow) where

See raise'.

Since: 1.4.0.0

Methods

raiseUnion :: Union r m a -> Union r' m a

Instances

(r' ~ (_0 ': r''), Raise r r'') => Raise r r'

Defined in Polysemy.Internal

Methods

raiseUnion :: forall (m :: Type -> Type) a. Union r m a -> Union r' m a

Raise r r

Defined in Polysemy.Internal

Methods

raiseUnion :: forall (m :: Type -> Type) a. Union r m a -> Union r m a

raise :: forall e r a. Sem r a -> Sem (e ': r) a

Introduce an effect into Sem. Analogous to lift in the mtl ecosystem. For a variant that can introduce an arbitrary number of effects, see raise_.

raiseUnder :: forall e2 e1 r a. Sem (e1 ': r) a -> Sem (e1 ': (e2 ': r)) a

Like raise, but introduces a new effect underneath the head of the list. See raiseUnder2 or raiseUnder3 for introducing more effects. If you need to introduce even more of them, check out subsume_.

raiseUnder can be used in order to turn transformative interpreters into reinterpreters. This is especially useful if you're writing an interpreter which introduces an intermediary effect, and then want to use an existing interpreter on that effect.

For example, given:

fooToBar :: Member Bar r => Sem (Foo ': r) a -> Sem r a
runBar   :: Sem (Bar ': r) a -> Sem r a

You can write:

runFoo :: Sem (Foo ': r) a -> Sem r a
runFoo =
    runBar     -- Consume Bar
  . fooToBar   -- Interpret Foo in terms of the new Bar
  . raiseUnder -- Introduces Bar under Foo

Since: 1.2.0.0

raiseUnder2 :: forall e2 e3 e1 r a. Sem (e1 ': r) a -> Sem (e1 ': (e2 ': (e3 ': r))) a

Like raise, but introduces two new effects underneath the head of the list.

Since: 1.2.0.0

raiseUnder3 :: forall e2 e3 e4 e1 r a. Sem (e1 ': r) a -> Sem (e1 ': (e2 ': (e3 ': (e4 ': r)))) a

Like raise, but introduces three new effects underneath the head of the list.

Since: 1.2.0.0

raise2Under :: forall e3 e1 e2 r a. Sem (e1 ': (e2 ': r)) a -> Sem (e1 ': (e2 ': (e3 ': r))) a

Like raise, but introduces an effect two levels underneath the head of the list.

Since: 1.4.0.0

raise3Under :: forall e4 e1 e2 e3 r a. Sem (e1 ': (e2 ': (e3 ': r))) a -> Sem (e1 ': (e2 ': (e3 ': (e4 ': r)))) a

Like raise, but introduces an effect three levels underneath the head of the list.

Since: 1.4.0.0

subsume_ :: forall r r' a. Subsume r r' => Sem r a -> Sem r' a

Allows reordering and adding known effects on top of the effect stack, as long as the polymorphic "tail" of new stack is a raise-d version of the original one. This function is highly polymorphic, so it may be a good idea to use its more concrete version (subsume), fitting functions from the raise family or type annotations to avoid vague errors in ambiguous contexts.

Since: 1.4.0.0

class Subsume (r :: EffectRow) (r' :: EffectRow) where

See subsume_.

Since: 1.4.0.0

Methods

subsumeUnion :: Union r m a -> Union r' m a

Instances

Raise r r' => Subsume r r'

Defined in Polysemy.Internal

Methods

subsumeUnion :: forall (m :: Type -> Type) a. Union r m a -> Union r' m a

Subsume ('[] :: [Effect]) r

Defined in Polysemy.Internal

Methods

subsumeUnion :: forall (m :: Type -> Type) a. Union '[] m a -> Union r m a

(Member e r', Subsume r r') => Subsume (e ': r) r'

Defined in Polysemy.Internal

Methods

subsumeUnion :: forall (m :: Type -> Type) a. Union (e ': r) m a -> Union r' m a

subsume :: forall e r a. Member e r => Sem (e ': r) a -> Sem r a

Interprets an effect in terms of another identical effect.

This is useful for defining interpreters that use reinterpretH without immediately consuming the newly introduced effect. Using such an interpreter recursively may result in duplicate effects, which may then be eliminated using subsume.

For a version that can introduce an arbitrary number of new effects and reorder existing ones, see subsume_.

Since: 1.2.0.0

subsumeUsing :: forall e r a. ElemOf e r -> Sem (e ': r) a -> Sem r a

Interprets an effect in terms of another identical effect, given an explicit proof that the effect exists in r.

This is useful in conjunction with tryMembership in order to conditionally make use of effects. For example:

tryListen :: KnownRow r => Sem r a -> Maybe (Sem r ([Int], a))
tryListen m = case tryMembership @(Writer [Int]) of
  Just pr -> Just $ subsumeUsing pr (listen (raise m))
  _       -> Nothing

Since: 1.3.0.0

newtype Embed m (z :: Type -> Type) a where

An effect which allows a regular Monad m into the Sem ecosystem. Monadic actions in m can be lifted into Sem via embed.

For example, you can use this effect to lift IO actions directly into Sem:

embed (putStrLn "hello") :: Member (Embed IO) r => Sem r ()

That being said, you lose out on a significant amount of the benefits of Sem by using embed directly in application code; doing so will tie your application code directly to the underlying monad, and prevent you from interpreting it differently. For best results, only use Embed in your effect interpreters.

Consider using trace and traceToIO as a substitute for using putStrLn directly.

Since: 1.0.0.0

Constructors

Embed

Fields

• :: { unEmbed :: m a
•    } -> Embed m z a

Instances

MakeLaw e '[Embed IO]

Defined in Polysemy.Law

Methods

mkLaw :: (Eq a, Show a, Citizen res (Sem (e ': '[Embed IO]) a)) => String -> res -> String -> res -> Law e '[Embed IO]

usingSem :: Monad m => (forall x. Union r (Sem r) x -> m x) -> Sem r a -> m a

Like runSem but flipped for better ergonomics sometimes.

liftSem :: Union r (Sem r) a -> Sem r a

hoistSem :: (forall x. Union r (Sem r) x -> Union r' (Sem r') x) -> Sem r a -> Sem r' a

type family Append l r where ...

Equations

Append (a ': l) r = a ': Append l r

Append '[] r = r

type InterpreterFor e r = forall a. Sem (e ': r) a -> Sem r a

Type synonym for interpreters that consume an effect without changing the return value. Offered for user convenience.

r Is kept polymorphic so it's possible to place constraints upon it:

teletypeToIO :: Member (Embed IO) r
             => InterpreterFor Teletype r

type InterpretersFor es r = forall a. Sem (Append es r) a -> Sem r a

Variant of InterpreterFor that takes a list of effects. @since 1.5.0.0

(.@) infixl 8

Arguments

:: Monad m

=> (forall x. Sem r x -> m x)

The lowering function, likely runM.

-> (forall y. (forall x. Sem r x -> m x) -> Sem (e ': r) y -> Sem r y)

-> Sem (e ': r) z

-> m z

Some interpreters need to be able to lower down to the base monad (often IO) in order to function properly --- some good examples of this are lowerError and lowerResource.

However, these interpreters don't compose particularly nicely; for example, to run lowerResource, you must write:

runM . lowerError runM

Notice that runM is duplicated in two places here. The situation gets exponentially worse the more intepreters you have that need to run in this pattern.

Instead, .@ performs the composition we'd like. The above can be written as

(runM .@ lowerError)

The parentheses here are important; without them you'll run into operator precedence errors.

Warning: This combinator will duplicate work that is intended to be just for initialization. This can result in rather surprising behavior. For a version of .@ that won't duplicate work, see the .@! operator in polysemy-zoo.

Interpreters using Final may be composed normally, and avoid the work duplication issue. For that reason, you're encouraged to use -Final interpreters instead of lower- interpreters whenever possible.

(.@@) infixl 8

Arguments

:: Monad m

=> (forall x. Sem r x -> m x)

The lowering function, likely runM.

-> (forall y. (forall x. Sem r x -> m x) -> Sem (e ': r) y -> Sem r (f y))

-> Sem (e ': r) z

-> m (f z)

Like .@, but for interpreters which change the resulting type --- eg. lowerError.