lisa.monad.MonadTrans

class lisa.monad.MonadTrans

Bases: Monad, ABC

Base class for monad transformers.

Heavily inspired by transformers as defined by: https://hackage.haskell.org/package/transformers

And stack manipulation inspired by: https://hackage.haskell.org/package/mmorph

Methods

bind()	Takes a monadic value Monad[A], a function that takes an A and returns Monad[B], and returns a Monad[B].
do()	Decorate a coroutine function so that awaits gains the powers of the monad.
hoist()	Lift a monadic value m by one level in the stack, i.e.: Given a stack for 3 transformers T1(T2(T3(Identity))), a value m = T2(Identity).pure(42). we have T2.hoist(m, T3.pure) == T2(T3(Identity)).pure(42).
lift()	Lift a monadic value m by one level in the stack, i.e.: Given a stack for 3 transformers T1(T2(T3(Identity))), a value m = T3(Identity).pure(42). we have T2.lift(m) == T2(T3(Identity)).pure(42).
pure()	Turn a regular value of type A into a monadic value of type Monad[A].
__await__() inherited
join() inherited	Takes a monadic value Monad[Monad[A]], and returns a Monad[A].
map() inherited	Takes a monadic value Monad[A], a function that takes an A and returns B, and returns a Monad[B].

Methods

abstract MonadTrans.bind(continuation)

Takes a monadic value Monad[A], a function that takes an A and returns Monad[B], and returns a Monad[B].

Note

It is allowed to return a _TailCall instance.

classmethod MonadTrans.do(f)

Decorate a coroutine function so that awaits gains the powers of the monad.

See also

This decorator is very similar to the do-notation in Haskell.

abstract classmethod MonadTrans.hoist(self, nat)

Lift a monadic value m by one level in the stack, i.e.: Given a stack for 3 transformers T1(T2(T3(Identity))), a value m = T2(Identity).pure(42). we have T2.hoist(m, T3.pure) == T2(T3(Identity)).pure(42).

In other words, it allows adding a level “from below”, whereas lift adds a level “from above”. It’s similar to map, except that instead of traversing all the nested functor layers, it stops at the first one.

Parameters:

• self (lisa.monad.Monad) – Monadic value to hoist.

• nat (collections.abc.Callable) – Natural transform. i.e. a morphism from Monad1[A] to Monad2[A] that obeys certain laws.

See also

hoist as defined in https://hackage.haskell.org/package/mmorph

Note

Note for implementers: A monad transformers t m a (t is the transformer HKT, m is the base monad and a is the “contained type) usually ends up containing an “m (f a)” (f being some kind of functor). For example, MaybeT in Haskell (Option here) is more or less defined as data MaybeT m a = MaybeT (m (Maybe a)). What the hoist implementation must do is to “rebuild” a value with a call to nat() around the m (...) part. For MaybeT, this gives hoist nat (MaybeT (m (Maybe a))) = MaybeT(nat(m (Maybe a))).

abstract classmethod MonadTrans.lift(m)

Lift a monadic value m by one level in the stack, i.e.: Given a stack for 3 transformers T1(T2(T3(Identity))), a value m = T3(Identity).pure(42). we have T2.lift(m) == T2(T3(Identity)).pure(42).

See also

lift as defined in https://hackage.haskell.org/package/transformers

classmethod MonadTrans.pure(x)

Turn a regular value of type A into a monadic value of type Monad[A].

MonadTrans.__await__()

Inherited method, see lisa.monad.Monad.__await__()

classmethod MonadTrans.join(self)

Inherited method, see lisa.monad.Monad.join()

Takes a monadic value Monad[Monad[A]], and returns a Monad[A].

classmethod MonadTrans.map(self, f)

Inherited method, see lisa.monad.Monad.map()

Takes a monadic value Monad[A], a function that takes an A and returns B, and returns a Monad[B].