Control.FX

Effect Classes

class (Monad m, forall x. Eq x => Eq (m x), forall x. Semigroup x => Semigroup (m x), forall x. Monoid x => Monoid (m x)) => MonadIdentity m where

Class representing monads from which we can extract a pure value. Instances should satisfy the following laws:

(1) unwrap . return === id

(2) return . unwrap === id

(3) x >>= f === f (unwrap x)

Methods

unwrap :: m a -> a

Extract a pure value

Instances

MonadIdentity Identity

Defined in Control.FX.Monad.Identity

Methods

unwrap :: Identity a -> a

Renaming f => MonadIdentity (Wrap f)

Defined in Control.FX.Monad.Class

Methods

unwrap :: Wrap f a -> a

MonadIdentity mark => MonadIdentity (OutputT (ReadOnlyT mark r))

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

unwrap :: OutputT (ReadOnlyT mark r) a -> a

(MonadIdentity m, Central m) => MonadIdentity (IdentityT m)

Defined in Control.FX.Monad.Trans.IdentityT

Methods

unwrap :: IdentityT m a -> a

MonadIdentity mark => MonadIdentity (OutputTT (PromptTT mark p))

Defined in Control.FX.Monad.Trans.Trans.PromptTT

Methods

unwrap :: OutputTT (PromptTT mark p) a -> a

(Monad m, MonadTrans t, MonadIdentity (t m)) => MonadIdentity (IdentityTT t m)

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

unwrap :: IdentityTT t m a -> a

(MonadIdentity m, MonadTrans t1, MonadTrans t2, ComposableT t1, forall (x :: Type -> Type). MonadIdentity x => MonadIdentity (t1 x), forall (x :: Type -> Type). MonadIdentity x => MonadIdentity (t2 x)) => MonadIdentity (ComposeT t1 t2 m)

Defined in Control.FX.Monad.Trans.ComposeT

Methods

unwrap :: ComposeT t1 t2 m a -> a

(Monad m, MonadTrans t, MonadTrans v, OverableT v, MonadTransTrans u, MonadIdentity (v (u t m))) => MonadIdentity (OverTT v u t m)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Methods

unwrap :: OverTT v u t m a -> a

class (Monad m, MonadIdentity mark) => MonadHalt mark m where

Class representing monads which can fail catastrophically, returning nothing. Instances should satisfy the following laws:

(1) halt a >> x === halt a

Minimal complete definition

Nothing

Methods

halt :: mark () -> m a

Fail catastrophically, returning nothing.

halt :: (Monad m1, MonadTrans t1, m ~ t1 m1, MonadHalt mark m1) => mark () -> m a

Fail catastrophically, returning nothing.

Instances

MonadIdentity mark => MonadHalt mark (Halt mark)

Defined in Control.FX.Monad.Halt

Methods

halt :: mark () -> Halt mark a

MonadHalt mark m => MonadHalt mark (IdentityT m)

Defined in Control.FX.Monad.Trans.IdentityT

Methods

halt :: mark () -> IdentityT m a

(MonadHalt mark m, MonadIdentity mark, MonadIdentity mark1) => MonadHalt mark (HaltT mark1 m)

Defined in Control.FX.Monad.Trans.HaltT

Methods

halt :: mark () -> HaltT mark1 m a

(Monad m, MonadIdentity mark) => MonadHalt mark (HaltT mark m)

Defined in Control.FX.Monad.Trans.HaltT

Methods

halt :: mark () -> HaltT mark m a

(Monad m, MonadTrans t, MonadIdentity mark, MonadHalt mark (t m)) => MonadHalt mark (IdentityTT t m)

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

halt :: mark () -> IdentityTT t m a

(Monad m, MonadIdentity mark1, Monoid w, MonadIdentity mark, MonadHalt mark m) => MonadHalt mark (WriteOnlyT mark1 w m)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

halt :: mark () -> WriteOnlyT mark1 w m a

(Monad m, MonadIdentity mark1, MonadIdentity mark, MonadHalt mark m) => MonadHalt mark (WriteOnceT mark1 w m)

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

halt :: mark () -> WriteOnceT mark1 w m a

(Monad m, MonadIdentity mark1, MonadIdentity mark, MonadHalt mark m) => MonadHalt mark (StateT mark1 s m)

Defined in Control.FX.Monad.Trans.StateT

Methods

halt :: mark () -> StateT mark1 s m a

(Monad m, MonadIdentity mark1, Commutant mark1, MonadIdentity mark, MonadHalt mark m) => MonadHalt mark (ReadOnlyT mark1 r m)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

halt :: mark () -> ReadOnlyT mark1 r m a

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadHalt mark m) => MonadHalt mark (ExceptT mark1 e m)

Defined in Control.FX.Monad.Trans.ExceptT

Methods

halt :: mark () -> ExceptT mark1 e m a

(Monad m, MonadIdentity mark1, MonadIdentity mark, Monoid w, MonadHalt mark m) => MonadHalt mark (AppendOnlyT mark1 w m)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

halt :: mark () -> AppendOnlyT mark1 w m a

(Monad m, MonadTrans t1, MonadTrans t2, ComposableT t1, LiftLocal t1, MonadIdentity mark, forall (x :: Type -> Type). Monad x => MonadHalt mark (t2 x)) => MonadHalt mark (ComposeT t1 t2 m)

Defined in Control.FX.Monad.Trans.ComposeT

Methods

halt :: mark () -> ComposeT t1 t2 m a

(Monad m, MonadTrans t2, MonadIdentity mark) => MonadHalt mark (ComposeT (HaltT mark) t2 m)

Defined in Control.FX.Monad.Trans.ComposeT

Methods

halt :: mark () -> ComposeT (HaltT mark) t2 m a

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadHalt mark (t x)) => MonadHalt mark (HaltTT mark1 t m)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

halt :: mark () -> HaltTT mark1 t m a

(Monad m, MonadTrans t, MonadIdentity mark) => MonadHalt mark (HaltTT mark t m)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

halt :: mark () -> HaltTT mark t m a

(Monad m, MonadTrans t, MonadIdentity mark1, Monoid w, MonadIdentity mark, forall (x :: Type -> Type). Monad x => MonadHalt mark (t x)) => MonadHalt mark (WriteOnlyTT mark1 w t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

halt :: mark () -> WriteOnlyTT mark1 w t m a

(Monad m, MonadTrans t, MonadIdentity mark1, MonadIdentity mark, forall (x :: Type -> Type). Monad x => MonadHalt mark (t x)) => MonadHalt mark (WriteOnceTT mark1 w t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

halt :: mark () -> WriteOnceTT mark1 w t m a

(Monad m, MonadTrans t, MonadIdentity mark1, MonadIdentity mark, forall (x :: Type -> Type). Monad x => MonadHalt mark (t x)) => MonadHalt mark (StateTT mark1 s t m)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

halt :: mark () -> StateTT mark1 s t m a

(Monad m, MonadTrans t, MonadIdentity mark1, MonadIdentity mark, forall (x :: Type -> Type). Monad x => MonadHalt mark (t x)) => MonadHalt mark (ReadOnlyTT mark1 r t m)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

halt :: mark () -> ReadOnlyTT mark1 r t m a

(Monad m, MonadTrans t, MonadTrans v, MonadTransTrans u, MonadIdentity mark, OverableT v, forall (x :: Type -> Type). Monad x => MonadHalt mark (u t x)) => MonadHalt mark (OverTT v u t m)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Methods

halt :: mark () -> OverTT v u t m a

(Monad m, MonadTrans t, MonadTransTrans u, MonadIdentity mark) => MonadHalt mark (OverTT (HaltT mark) u t m)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Methods

halt :: mark () -> OverTT (HaltT mark) u t m a

(Monad m, MonadTrans t, MonadIdentity mark1, MonadIdentity mark, forall (x :: Type -> Type). Monad x => MonadHalt mark (t x)) => MonadHalt mark (ExceptTT mark1 e t m)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

halt :: mark () -> ExceptTT mark1 e t m a

(Monad m, MonadTrans t, MonadIdentity mark1, MonadIdentity mark, Monoid w, forall (x :: Type -> Type). Monad x => MonadHalt mark (t x)) => MonadHalt mark (AppendOnlyTT mark1 w t m)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

halt :: mark () -> AppendOnlyTT mark1 w t m a

class (Monad m, MonadIdentity mark) => MonadExcept mark e m where

Class representing monads which can raise and handle marked exceptions of type mark e. Instances should satisfy the following laws:

(1) catch (return a) h === return a

(2) catch (throw e) h === h e

(3) throw e >>= f === throw e

Minimal complete definition

Nothing

Methods

throw :: mark e -> m a

Raise an exception

throw :: (Monad m1, MonadTrans t1, m ~ t1 m1, MonadExcept mark e m1) => mark e -> m a

Raise an exception

catch :: m a -> (mark e -> m a) -> m a

Run a computation, applying a handler to any raised exceptions

catch :: (Monad m1, MonadTrans t1, m ~ t1 m1, LiftCatch t1, MonadExcept mark e m1) => m a -> (mark e -> m a) -> m a

Run a computation, applying a handler to any raised exceptions

Instances

MonadExcept mark e m => MonadExcept mark e (IdentityT m)

Defined in Control.FX.Monad.Trans.IdentityT

Methods

throw :: mark e -> IdentityT m a

catch :: IdentityT m a -> (mark e -> IdentityT m a) -> IdentityT m a

MonadIdentity mark => MonadExcept mark e (Except mark e)

Defined in Control.FX.Monad.Except

Methods

throw :: mark e -> Except mark e a

catch :: Except mark e a -> (mark e -> Except mark e a) -> Except mark e a

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadExcept mark e m) => MonadExcept mark e (HaltT mark1 m)

Defined in Control.FX.Monad.Trans.HaltT

Methods

throw :: mark e -> HaltT mark1 m a

catch :: HaltT mark1 m a -> (mark e -> HaltT mark1 m a) -> HaltT mark1 m a

(Monad m, MonadTrans t, MonadIdentity mark, MonadExcept mark e (t m)) => MonadExcept mark e (IdentityTT t m)

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

throw :: mark e -> IdentityTT t m a

catch :: IdentityTT t m a -> (mark e -> IdentityTT t m a) -> IdentityTT t m a

(Monad m, MonadIdentity mark, MonadIdentity mark1, Monoid w, MonadExcept mark e m) => MonadExcept mark e (WriteOnlyT mark1 w m)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

throw :: mark e -> WriteOnlyT mark1 w m a

catch :: WriteOnlyT mark1 w m a -> (mark e -> WriteOnlyT mark1 w m a) -> WriteOnlyT mark1 w m a

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadExcept mark e m) => MonadExcept mark e (WriteOnceT mark1 w m)

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

throw :: mark e -> WriteOnceT mark1 w m a

catch :: WriteOnceT mark1 w m a -> (mark e -> WriteOnceT mark1 w m a) -> WriteOnceT mark1 w m a

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadExcept mark e m) => MonadExcept mark e (StateT mark1 s m)

Defined in Control.FX.Monad.Trans.StateT

Methods

throw :: mark e -> StateT mark1 s m a

catch :: StateT mark1 s m a -> (mark e -> StateT mark1 s m a) -> StateT mark1 s m a

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadExcept mark e m, Commutant mark1) => MonadExcept mark e (ReadOnlyT mark1 r m)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

throw :: mark e -> ReadOnlyT mark1 r m a

catch :: ReadOnlyT mark1 r m a -> (mark e -> ReadOnlyT mark1 r m a) -> ReadOnlyT mark1 r m a

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadExcept mark e m) => MonadExcept mark e (ExceptT mark1 e1 m)

Defined in Control.FX.Monad.Trans.ExceptT

Methods

throw :: mark e -> ExceptT mark1 e1 m a

catch :: ExceptT mark1 e1 m a -> (mark e -> ExceptT mark1 e1 m a) -> ExceptT mark1 e1 m a

(Monad m, MonadIdentity mark) => MonadExcept mark e (ExceptT mark e m)

Defined in Control.FX.Monad.Trans.ExceptT

Methods

throw :: mark e -> ExceptT mark e m a

catch :: ExceptT mark e m a -> (mark e -> ExceptT mark e m a) -> ExceptT mark e m a

(Monad m, MonadIdentity mark, MonadIdentity mark1, Monoid w, MonadExcept mark e m) => MonadExcept mark e (AppendOnlyT mark1 w m)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

throw :: mark e -> AppendOnlyT mark1 w m a

catch :: AppendOnlyT mark1 w m a -> (mark e -> AppendOnlyT mark1 w m a) -> AppendOnlyT mark1 w m a

(Monad m, MonadTrans t1, MonadTrans t2, ComposableT t1, MonadIdentity mark, LiftCatch t1, forall (x :: Type -> Type). Monad x => MonadExcept mark e (t2 x)) => MonadExcept mark e (ComposeT t1 t2 m)

Defined in Control.FX.Monad.Trans.ComposeT

Methods

throw :: mark e -> ComposeT t1 t2 m a

catch :: ComposeT t1 t2 m a -> (mark e -> ComposeT t1 t2 m a) -> ComposeT t1 t2 m a

(Monad m, MonadTrans t2, MonadIdentity mark) => MonadExcept mark e (ComposeT (ExceptT mark e) t2 m)

Defined in Control.FX.Monad.Trans.ComposeT

Methods

throw :: mark e -> ComposeT (ExceptT mark e) t2 m a

catch :: ComposeT (ExceptT mark e) t2 m a -> (mark e -> ComposeT (ExceptT mark e) t2 m a) -> ComposeT (ExceptT mark e) t2 m a

(Monad m, MonadTrans t, MonadIdentity mark1, MonadExcept mark e (t m)) => MonadExcept mark e (HaltTT mark1 t m)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

throw :: mark e -> HaltTT mark1 t m a

catch :: HaltTT mark1 t m a -> (mark e -> HaltTT mark1 t m a) -> HaltTT mark1 t m a

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Monoid w, forall (x :: Type -> Type). Monad x => MonadExcept mark e (t x)) => MonadExcept mark e (WriteOnlyTT mark1 w t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

throw :: mark e -> WriteOnlyTT mark1 w t m a

catch :: WriteOnlyTT mark1 w t m a -> (mark e -> WriteOnlyTT mark1 w t m a) -> WriteOnlyTT mark1 w t m a

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadExcept mark e (t x)) => MonadExcept mark e (WriteOnceTT mark1 w t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

throw :: mark e -> WriteOnceTT mark1 w t m a

catch :: WriteOnceTT mark1 w t m a -> (mark e -> WriteOnceTT mark1 w t m a) -> WriteOnceTT mark1 w t m a

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadExcept mark e (t x)) => MonadExcept mark e (StateTT mark1 s t m)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

throw :: mark e -> StateTT mark1 s t m a

catch :: StateTT mark1 s t m a -> (mark e -> StateTT mark1 s t m a) -> StateTT mark1 s t m a

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Commutant mark1, forall (x :: Type -> Type). Monad x => MonadExcept mark e (t x)) => MonadExcept mark e (ReadOnlyTT mark1 r t m)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

throw :: mark e -> ReadOnlyTT mark1 r t m a

catch :: ReadOnlyTT mark1 r t m a -> (mark e -> ReadOnlyTT mark1 r t m a) -> ReadOnlyTT mark1 r t m a

(Monad m, MonadTrans t, MonadTrans v, OverableT v, MonadTransTrans u, MonadIdentity mark, LiftCatch v, forall (x :: Type -> Type). Monad x => MonadExcept mark e (u t x)) => MonadExcept mark e (OverTT v u t m)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Methods

throw :: mark e -> OverTT v u t m a

catch :: OverTT v u t m a -> (mark e -> OverTT v u t m a) -> OverTT v u t m a

(Monad m, MonadTrans t, MonadTransTrans u, MonadIdentity mark) => MonadExcept mark e (OverTT (ExceptT mark e) u t m)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Methods

throw :: mark e -> OverTT (ExceptT mark e) u t m a

catch :: OverTT (ExceptT mark e) u t m a -> (mark e -> OverTT (ExceptT mark e) u t m a) -> OverTT (ExceptT mark e) u t m a

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadExcept mark e (t x)) => MonadExcept mark e (ExceptTT mark1 e1 t m)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

throw :: mark e -> ExceptTT mark1 e1 t m a

catch :: ExceptTT mark1 e1 t m a -> (mark e -> ExceptTT mark1 e1 t m a) -> ExceptTT mark1 e1 t m a

(Monad m, MonadTrans t, MonadIdentity mark) => MonadExcept mark e (ExceptTT mark e t m)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

throw :: mark e -> ExceptTT mark e t m a

catch :: ExceptTT mark e t m a -> (mark e -> ExceptTT mark e t m a) -> ExceptTT mark e t m a

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadExcept mark e (t x), Monoid w) => MonadExcept mark e (AppendOnlyTT mark1 w t m)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

throw :: mark e -> AppendOnlyTT mark1 w t m a

catch :: AppendOnlyTT mark1 w t m a -> (mark e -> AppendOnlyTT mark1 w t m a) -> AppendOnlyTT mark1 w t m a

class (Monad m, MonadIdentity mark) => MonadState mark s m where

Class representing monads with access to a marked mutable state mark s. Instances should satisfy the following laws:

(1) put s1 >> put s2 === put s2

(2) put s >> get === put s >> return s

(3) get >>= put === return ()

(4) get >>= \\s -> get >>= k s === get >>= \\s -> k s s

Minimal complete definition

Nothing

Methods

get :: m (mark s)

Retrieve the current state

get :: (Monad m1, MonadTrans t1, m ~ t1 m1, MonadState mark s m1) => m (mark s)

Retrieve the current state

put :: mark s -> m ()

Replace the current state

put :: (Monad m1, MonadTrans t1, m ~ t1 m1, MonadState mark s m1) => mark s -> m ()

Replace the current state

Instances

MonadState mark s m => MonadState mark s (IdentityT m)

Defined in Control.FX.Monad.Trans.IdentityT

Methods

get :: IdentityT m (mark s)

put :: mark s -> IdentityT m ()

MonadIdentity mark => MonadState mark s (State mark s)

Defined in Control.FX.Monad.State

Methods

get :: State mark s (mark s)

put :: mark s -> State mark s ()

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadState mark s m) => MonadState mark s (HaltT mark1 m)

Defined in Control.FX.Monad.Trans.HaltT

Methods

get :: HaltT mark1 m (mark s)

put :: mark s -> HaltT mark1 m ()

(Monad m, MonadTrans t, MonadIdentity mark, MonadState mark s (t m)) => MonadState mark s (IdentityTT t m)

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

get :: IdentityTT t m (mark s)

put :: mark s -> IdentityTT t m ()

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadState mark s m, Monoid w) => MonadState mark s (WriteOnlyT mark1 w m)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

get :: WriteOnlyT mark1 w m (mark s)

put :: mark s -> WriteOnlyT mark1 w m ()

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadState mark s m) => MonadState mark s (WriteOnceT mark1 w m)

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

get :: WriteOnceT mark1 w m (mark s)

put :: mark s -> WriteOnceT mark1 w m ()

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadState mark s m) => MonadState mark s (StateT mark1 s1 m)

Defined in Control.FX.Monad.Trans.StateT

Methods

get :: StateT mark1 s1 m (mark s)

put :: mark s -> StateT mark1 s1 m ()

(Monad m, MonadIdentity mark) => MonadState mark s (StateT mark s m)

Defined in Control.FX.Monad.Trans.StateT

Methods

get :: StateT mark s m (mark s)

put :: mark s -> StateT mark s m ()

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadState mark s m, Commutant mark1) => MonadState mark s (ReadOnlyT mark1 r m)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

get :: ReadOnlyT mark1 r m (mark s)

put :: mark s -> ReadOnlyT mark1 r m ()

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadState mark s m) => MonadState mark s (ExceptT mark1 e m)

Defined in Control.FX.Monad.Trans.ExceptT

Methods

get :: ExceptT mark1 e m (mark s)

put :: mark s -> ExceptT mark1 e m ()

(Monad m, MonadIdentity mark, MonadIdentity mark1, Monoid w, MonadState mark s m) => MonadState mark s (AppendOnlyT mark1 w m)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

get :: AppendOnlyT mark1 w m (mark s)

put :: mark s -> AppendOnlyT mark1 w m ()

(Monad m, MonadTrans t1, MonadTrans t2, MonadIdentity mark, ComposableT t1, forall (x :: Type -> Type). Monad x => MonadState mark s (t2 x)) => MonadState mark s (ComposeT t1 t2 m)

Defined in Control.FX.Monad.Trans.ComposeT

Methods

get :: ComposeT t1 t2 m (mark s)

put :: mark s -> ComposeT t1 t2 m ()

(Monad m, MonadTrans t2, MonadIdentity mark) => MonadState mark s (ComposeT (StateT mark s) t2 m)

Defined in Control.FX.Monad.Trans.ComposeT

Methods

get :: ComposeT (StateT mark s) t2 m (mark s)

put :: mark s -> ComposeT (StateT mark s) t2 m ()

(Monad m, MonadTrans t, MonadIdentity mark1, MonadState mark s (t m)) => MonadState mark s (HaltTT mark1 t m)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

get :: HaltTT mark1 t m (mark s)

put :: mark s -> HaltTT mark1 t m ()

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Monoid w, forall (x :: Type -> Type). Monad x => MonadState mark s (t x)) => MonadState mark s (WriteOnlyTT mark1 w t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

get :: WriteOnlyTT mark1 w t m (mark s)

put :: mark s -> WriteOnlyTT mark1 w t m ()

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadState mark s (t x)) => MonadState mark s (WriteOnceTT mark1 w t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

get :: WriteOnceTT mark1 w t m (mark s)

put :: mark s -> WriteOnceTT mark1 w t m ()

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadState mark s (t x)) => MonadState mark s (StateTT mark1 s1 t m)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

get :: StateTT mark1 s1 t m (mark s)

put :: mark s -> StateTT mark1 s1 t m ()

(Monad m, MonadTrans t, MonadIdentity mark) => MonadState mark s (StateTT mark s t m)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

get :: StateTT mark s t m (mark s)

put :: mark s -> StateTT mark s t m ()

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadState mark s (t x)) => MonadState mark s (ReadOnlyTT mark1 r t m)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

get :: ReadOnlyTT mark1 r t m (mark s)

put :: mark s -> ReadOnlyTT mark1 r t m ()

(Monad m, MonadTrans t, MonadTrans v, OverableT v, MonadTransTrans u, MonadIdentity mark, forall (x :: Type -> Type). Monad x => MonadState mark s (u t x)) => MonadState mark s (OverTT v u t m)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Methods

get :: OverTT v u t m (mark s)

put :: mark s -> OverTT v u t m ()

(Monad m, MonadTrans t, MonadTransTrans u, MonadIdentity mark) => MonadState mark s (OverTT (StateT mark s) u t m)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Methods

get :: OverTT (StateT mark s) u t m (mark s)

put :: mark s -> OverTT (StateT mark s) u t m ()

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadState mark s (t x)) => MonadState mark s (PromptTT mark1 p t m)

Defined in Control.FX.Monad.Trans.Trans.PromptTT

Methods

get :: PromptTT mark1 p t m (mark s)

put :: mark s -> PromptTT mark1 p t m ()

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadState mark s (t x)) => MonadState mark s (ExceptTT mark1 e1 t m)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

get :: ExceptTT mark1 e1 t m (mark s)

put :: mark s -> ExceptTT mark1 e1 t m ()

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadState mark s (t x), Monoid w) => MonadState mark s (AppendOnlyTT mark1 w t m)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

get :: AppendOnlyTT mark1 w t m (mark s)

put :: mark s -> AppendOnlyTT mark1 w t m ()

class (Monad m, Monoid w, MonadIdentity mark) => MonadWriteOnly mark w m where

Class representing monads with access to a marked write-only state mark w. Note that w must be an instance of Monoid. Instances should satisfy the following laws:

(1) draft (tell w) === return ((),w)

(2) tell mempty === return ()

(3) tell w1 >> tell w2 === tell (mappend w1 w2)

(4) draft (return a) === return (a, mempty)

(5) draft (x >>= f) === draft x >>= (draft' f)
      where draft' f (a,w) = mapsnd (mappend w) <$> draft (f a)

Minimal complete definition

Nothing

Methods

tell :: mark w -> m ()

Combine a value with the current write-only state

tell :: (Monad m1, MonadTrans t1, m ~ t1 m1, MonadWriteOnly mark w m1) => mark w -> m ()

Combine a value with the current write-only state

draft :: m a -> m (Pair (mark w) a)

Run a computation, returning the write-only state with the result rather than writing it

draft :: (Monad m1, MonadTrans t1, m ~ t1 m1, LiftDraft t1, MonadWriteOnly mark w m1) => m a -> m (Pair (mark w) a)

Run a computation, returning the write-only state with the result rather than writing it

Instances

(MonadWriteOnly mark w m, Monoid w) => MonadWriteOnly mark w (IdentityT m)

Defined in Control.FX.Monad.Trans.IdentityT

Methods

tell :: mark w -> IdentityT m ()

draft :: IdentityT m a -> IdentityT m (Pair (mark w) a)

(Monoid w, MonadIdentity mark) => MonadWriteOnly mark w (WriteOnly mark w)

Defined in Control.FX.Monad.WriteOnly

Methods

tell :: mark w -> WriteOnly mark w ()

draft :: WriteOnly mark w a -> WriteOnly mark w (Pair (mark w) a)

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnly mark w m, Monoid w) => MonadWriteOnly mark w (HaltT mark1 m)

Defined in Control.FX.Monad.Trans.HaltT

Methods

tell :: mark w -> HaltT mark1 m ()

draft :: HaltT mark1 m a -> HaltT mark1 m (Pair (mark w) a)

(Monad m, MonadTrans t, MonadIdentity mark, MonadWriteOnly mark w (t m), Monoid w) => MonadWriteOnly mark w (IdentityTT t m)

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

tell :: mark w -> IdentityTT t m ()

draft :: IdentityTT t m a -> IdentityTT t m (Pair (mark w) a)

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnly mark w m, Monoid w, Monoid w1) => MonadWriteOnly mark w (WriteOnlyT mark1 w1 m)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

tell :: mark w -> WriteOnlyT mark1 w1 m ()

draft :: WriteOnlyT mark1 w1 m a -> WriteOnlyT mark1 w1 m (Pair (mark w) a)

(Monoid w, Monad m, MonadIdentity mark) => MonadWriteOnly mark w (WriteOnlyT mark w m)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

tell :: mark w -> WriteOnlyT mark w m ()

draft :: WriteOnlyT mark w m a -> WriteOnlyT mark w m (Pair (mark w) a)

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnly mark w m) => MonadWriteOnly mark w (WriteOnceT mark1 w1 m)

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

tell :: mark w -> WriteOnceT mark1 w1 m ()

draft :: WriteOnceT mark1 w1 m a -> WriteOnceT mark1 w1 m (Pair (mark w) a)

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnly mark w m, Monoid w) => MonadWriteOnly mark w (StateT mark1 s m)

Defined in Control.FX.Monad.Trans.StateT

Methods

tell :: mark w -> StateT mark1 s m ()

draft :: StateT mark1 s m a -> StateT mark1 s m (Pair (mark w) a)

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnly mark w m, Commutant mark1, Monoid w) => MonadWriteOnly mark w (ReadOnlyT mark1 r m)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

tell :: mark w -> ReadOnlyT mark1 r m ()

draft :: ReadOnlyT mark1 r m a -> ReadOnlyT mark1 r m (Pair (mark w) a)

(Monad m, MonadIdentity mark, MonadIdentity mark1, Monoid w, MonadWriteOnly mark w m) => MonadWriteOnly mark w (ExceptT mark1 e m)

Defined in Control.FX.Monad.Trans.ExceptT

Methods

tell :: mark w -> ExceptT mark1 e m ()

draft :: ExceptT mark1 e m a -> ExceptT mark1 e m (Pair (mark w) a)

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnly mark w m, Monoid w, Monoid w1) => MonadWriteOnly mark w (AppendOnlyT mark1 w1 m)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

tell :: mark w -> AppendOnlyT mark1 w1 m ()

draft :: AppendOnlyT mark1 w1 m a -> AppendOnlyT mark1 w1 m (Pair (mark w) a)

(Monad m, MonadTrans t1, MonadTrans t2, Monoid w, ComposableT t1, LiftDraft t1, MonadIdentity mark, forall (x :: Type -> Type). Monad x => MonadWriteOnly mark w (t2 x)) => MonadWriteOnly mark w (ComposeT t1 t2 m)

Defined in Control.FX.Monad.Trans.ComposeT

Methods

tell :: mark w -> ComposeT t1 t2 m ()

draft :: ComposeT t1 t2 m a -> ComposeT t1 t2 m (Pair (mark w) a)

(Monad m, MonadTrans t2, Monoid w, MonadIdentity mark) => MonadWriteOnly mark w (ComposeT (WriteOnlyT mark w) t2 m)

Defined in Control.FX.Monad.Trans.ComposeT

Methods

tell :: mark w -> ComposeT (WriteOnlyT mark w) t2 m ()

draft :: ComposeT (WriteOnlyT mark w) t2 m a -> ComposeT (WriteOnlyT mark w) t2 m (Pair (mark w) a)

(Monad m, MonadTrans t, Monoid w, MonadIdentity mark1, MonadWriteOnly mark w (t m)) => MonadWriteOnly mark w (HaltTT mark1 t m)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

tell :: mark w -> HaltTT mark1 t m ()

draft :: HaltTT mark1 t m a -> HaltTT mark1 t m (Pair (mark w) a)

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Monoid w, Monoid w1, forall (x :: Type -> Type). Monad x => MonadWriteOnly mark w (t x)) => MonadWriteOnly mark w (WriteOnlyTT mark1 w1 t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

tell :: mark w -> WriteOnlyTT mark1 w1 t m ()

draft :: WriteOnlyTT mark1 w1 t m a -> WriteOnlyTT mark1 w1 t m (Pair (mark w) a)

(Monad m, MonadTrans t, MonadIdentity mark, Monoid w) => MonadWriteOnly mark w (WriteOnlyTT mark w t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

tell :: mark w -> WriteOnlyTT mark w t m ()

draft :: WriteOnlyTT mark w t m a -> WriteOnlyTT mark w t m (Pair (mark w) a)

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadWriteOnly mark w (t x), Monoid w) => MonadWriteOnly mark w (WriteOnceTT mark1 w1 t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

tell :: mark w -> WriteOnceTT mark1 w1 t m ()

draft :: WriteOnceTT mark1 w1 t m a -> WriteOnceTT mark1 w1 t m (Pair (mark w) a)

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Monoid w, forall (x :: Type -> Type). Monad x => MonadWriteOnly mark w (t x)) => MonadWriteOnly mark w (StateTT mark1 s t m)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

tell :: mark w -> StateTT mark1 s t m ()

draft :: StateTT mark1 s t m a -> StateTT mark1 s t m (Pair (mark w) a)

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Monoid w, Commutant mark1, forall (x :: Type -> Type). Monad x => MonadWriteOnly mark w (t x)) => MonadWriteOnly mark w (ReadOnlyTT mark1 r t m)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

tell :: mark w -> ReadOnlyTT mark1 r t m ()

draft :: ReadOnlyTT mark1 r t m a -> ReadOnlyTT mark1 r t m (Pair (mark w) a)

(Monad m, MonadTrans t, MonadTrans v, Monoid w, LiftDraft v, MonadTransTrans u, MonadIdentity mark, OverableT v, forall (x :: Type -> Type). Monad x => MonadWriteOnly mark w (u t x)) => MonadWriteOnly mark w (OverTT v u t m)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Methods

tell :: mark w -> OverTT v u t m ()

draft :: OverTT v u t m a -> OverTT v u t m (Pair (mark w) a)

(Monad m, MonadTrans t, Monoid w, MonadTransTrans u, MonadIdentity mark) => MonadWriteOnly mark w (OverTT (WriteOnlyT mark w) u t m)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Methods

tell :: mark w -> OverTT (WriteOnlyT mark w) u t m ()

draft :: OverTT (WriteOnlyT mark w) u t m a -> OverTT (WriteOnlyT mark w) u t m (Pair (mark w) a)

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Monoid w, forall (x :: Type -> Type). Monad x => MonadWriteOnly mark w (t x)) => MonadWriteOnly mark w (ExceptTT mark1 e t m)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

tell :: mark w -> ExceptTT mark1 e t m ()

draft :: ExceptTT mark1 e t m a -> ExceptTT mark1 e t m (Pair (mark w) a)

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Monoid w, forall (x :: Type -> Type). Monad x => MonadWriteOnly mark w (t x), Monoid w1) => MonadWriteOnly mark w (AppendOnlyTT mark1 w1 t m)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

tell :: mark w -> AppendOnlyTT mark1 w1 t m ()

draft :: AppendOnlyTT mark1 w1 t m a -> AppendOnlyTT mark1 w1 t m (Pair (mark w) a)

class (Monad m, MonadIdentity mark) => MonadReadOnly mark r m where

Class representing monads with access to a marked read-only state mark r. Instances should satisfy the following laws:

(1) local u ask === fmap u ask

(2) local u (local v x) === local (v . u) x

(3) local u x >> ask === ask >>= \r -> local u x >> return r

(4) local u (return a) === return a

(5) local u (x >>= f) === local u x >>= (local u . f)

Minimal complete definition

Nothing

Methods

ask :: m (mark r)

Retrieve the read-only state

ask :: (Monad m1, MonadTrans t1, m ~ t1 m1, MonadReadOnly mark r m1) => m (mark r)

Retrieve the read-only state

local :: (mark r -> mark r) -> m a -> m a

Run a computation with a locally modified read-only state

local :: (Monad m1, MonadTrans t1, m ~ t1 m1, LiftLocal t1, MonadReadOnly mark r m1) => (mark r -> mark r) -> m a -> m a

Run a computation with a locally modified read-only state

Instances

MonadReadOnly mark r m => MonadReadOnly mark r (IdentityT m)

Defined in Control.FX.Monad.Trans.IdentityT

Methods

ask :: IdentityT m (mark r)

local :: (mark r -> mark r) -> IdentityT m a -> IdentityT m a

MonadIdentity mark => MonadReadOnly mark r (ReadOnly mark r)

Defined in Control.FX.Monad.ReadOnly

Methods

ask :: ReadOnly mark r (mark r)

local :: (mark r -> mark r) -> ReadOnly mark r a -> ReadOnly mark r a

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadReadOnly mark r m) => MonadReadOnly mark r (HaltT mark1 m)

Defined in Control.FX.Monad.Trans.HaltT

Methods

ask :: HaltT mark1 m (mark r)

local :: (mark r -> mark r) -> HaltT mark1 m a -> HaltT mark1 m a

(Monad m, MonadTrans t, MonadIdentity mark, MonadReadOnly mark r (t m)) => MonadReadOnly mark r (IdentityTT t m)

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

ask :: IdentityTT t m (mark r)

local :: (mark r -> mark r) -> IdentityTT t m a -> IdentityTT t m a

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadReadOnly mark r m, Monoid w) => MonadReadOnly mark r (WriteOnlyT mark1 w m)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

ask :: WriteOnlyT mark1 w m (mark r)

local :: (mark r -> mark r) -> WriteOnlyT mark1 w m a -> WriteOnlyT mark1 w m a

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadReadOnly mark r m) => MonadReadOnly mark r (WriteOnceT mark1 w m)

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

ask :: WriteOnceT mark1 w m (mark r)

local :: (mark r -> mark r) -> WriteOnceT mark1 w m a -> WriteOnceT mark1 w m a

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadReadOnly mark r m) => MonadReadOnly mark r (StateT mark1 s m)

Defined in Control.FX.Monad.Trans.StateT

Methods

ask :: StateT mark1 s m (mark r)

local :: (mark r -> mark r) -> StateT mark1 s m a -> StateT mark1 s m a

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadReadOnly mark r m, Commutant mark1) => MonadReadOnly mark r (ReadOnlyT mark1 r1 m)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

ask :: ReadOnlyT mark1 r1 m (mark r)

local :: (mark r -> mark r) -> ReadOnlyT mark1 r1 m a -> ReadOnlyT mark1 r1 m a

(Monad m, MonadIdentity mark) => MonadReadOnly mark r (ReadOnlyT mark r m)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

ask :: ReadOnlyT mark r m (mark r)

local :: (mark r -> mark r) -> ReadOnlyT mark r m a -> ReadOnlyT mark r m a

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadReadOnly mark r m) => MonadReadOnly mark r (ExceptT mark1 e m)

Defined in Control.FX.Monad.Trans.ExceptT

Methods

ask :: ExceptT mark1 e m (mark r)

local :: (mark r -> mark r) -> ExceptT mark1 e m a -> ExceptT mark1 e m a

(Monad m, MonadIdentity mark, MonadIdentity mark1, Monoid w, MonadReadOnly mark r m) => MonadReadOnly mark r (AppendOnlyT mark1 w m)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

ask :: AppendOnlyT mark1 w m (mark r)

local :: (mark r -> mark r) -> AppendOnlyT mark1 w m a -> AppendOnlyT mark1 w m a

(Monad m, MonadTrans t1, MonadTrans t2, ComposableT t1, LiftLocal t1, MonadIdentity mark, forall (x :: Type -> Type). Monad x => MonadReadOnly mark r (t2 x)) => MonadReadOnly mark r (ComposeT t1 t2 m)

Defined in Control.FX.Monad.Trans.ComposeT

Methods

ask :: ComposeT t1 t2 m (mark r)

local :: (mark r -> mark r) -> ComposeT t1 t2 m a -> ComposeT t1 t2 m a

(Monad m, MonadTrans t2, MonadIdentity mark) => MonadReadOnly mark r (ComposeT (ReadOnlyT mark r) t2 m)

Defined in Control.FX.Monad.Trans.ComposeT

Methods

ask :: ComposeT (ReadOnlyT mark r) t2 m (mark r)

local :: (mark r -> mark r) -> ComposeT (ReadOnlyT mark r) t2 m a -> ComposeT (ReadOnlyT mark r) t2 m a

(Monad m, MonadTrans t, MonadIdentity mark1, MonadReadOnly mark r (t m)) => MonadReadOnly mark r (HaltTT mark1 t m)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

ask :: HaltTT mark1 t m (mark r)

local :: (mark r -> mark r) -> HaltTT mark1 t m a -> HaltTT mark1 t m a

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Monoid w, forall (x :: Type -> Type). Monad x => MonadReadOnly mark r (t x)) => MonadReadOnly mark r (WriteOnlyTT mark1 w t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

ask :: WriteOnlyTT mark1 w t m (mark r)

local :: (mark r -> mark r) -> WriteOnlyTT mark1 w t m a -> WriteOnlyTT mark1 w t m a

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadReadOnly mark r (t x)) => MonadReadOnly mark r (WriteOnceTT mark1 w t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

ask :: WriteOnceTT mark1 w t m (mark r)

local :: (mark r -> mark r) -> WriteOnceTT mark1 w t m a -> WriteOnceTT mark1 w t m a

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadReadOnly mark r (t x)) => MonadReadOnly mark r (StateTT mark1 s t m)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

ask :: StateTT mark1 s t m (mark r)

local :: (mark r -> mark r) -> StateTT mark1 s t m a -> StateTT mark1 s t m a

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Commutant mark1, forall (x :: Type -> Type). Monad x => MonadReadOnly mark r (t x)) => MonadReadOnly mark r (ReadOnlyTT mark1 r1 t m)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

ask :: ReadOnlyTT mark1 r1 t m (mark r)

local :: (mark r -> mark r) -> ReadOnlyTT mark1 r1 t m a -> ReadOnlyTT mark1 r1 t m a

(Monad m, MonadTrans t, MonadIdentity mark) => MonadReadOnly mark r (ReadOnlyTT mark r t m)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

ask :: ReadOnlyTT mark r t m (mark r)

local :: (mark r -> mark r) -> ReadOnlyTT mark r t m a -> ReadOnlyTT mark r t m a

(Monad m, MonadTrans t, MonadTrans v, OverableT v, MonadTransTrans u, MonadIdentity mark, LiftLocal v, forall (x :: Type -> Type). Monad x => MonadReadOnly mark r (u t x)) => MonadReadOnly mark r (OverTT v u t m)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Methods

ask :: OverTT v u t m (mark r)

local :: (mark r -> mark r) -> OverTT v u t m a -> OverTT v u t m a

(Monad m, MonadTrans t, MonadTransTrans u, MonadIdentity mark) => MonadReadOnly mark r (OverTT (ReadOnlyT mark r) u t m)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Methods

ask :: OverTT (ReadOnlyT mark r) u t m (mark r)

local :: (mark r -> mark r) -> OverTT (ReadOnlyT mark r) u t m a -> OverTT (ReadOnlyT mark r) u t m a

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Commutant mark1, forall (x :: Type -> Type). Monad x => MonadReadOnly mark r (t x)) => MonadReadOnly mark r (PromptTT mark1 p t m)

Defined in Control.FX.Monad.Trans.Trans.PromptTT

Methods

ask :: PromptTT mark1 p t m (mark r)

local :: (mark r -> mark r) -> PromptTT mark1 p t m a -> PromptTT mark1 p t m a

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadReadOnly mark r (t x)) => MonadReadOnly mark r (ExceptTT mark1 e t m)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

ask :: ExceptTT mark1 e t m (mark r)

local :: (mark r -> mark r) -> ExceptTT mark1 e t m a -> ExceptTT mark1 e t m a

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadReadOnly mark r (t x), Monoid w) => MonadReadOnly mark r (AppendOnlyTT mark1 w t m)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

ask :: AppendOnlyTT mark1 w t m (mark r)

local :: (mark r -> mark r) -> AppendOnlyTT mark1 w t m a -> AppendOnlyTT mark1 w t m a

class (Monad m, MonadIdentity mark) => MonadAppendOnly mark w m where

Class representing monads with access to a marked append-only state mark w. Instances should satisfy the following laws:

(1) jot mempty  ===  return ()

(2) jot (a <> b)  ===  jot a >> jot b

(3) look  ===  return mempty

(4) x >> look >> y  ===  x >> y

(5) jot w >> look  ===  jot w >> return w

Minimal complete definition

Nothing

Methods

look :: m (mark w)

Retrieve the append-only state

look :: (Monad m1, MonadTrans t1, m ~ t1 m1, MonadAppendOnly mark w m1) => m (mark w)

Retrieve the append-only state

jot :: mark w -> m ()

Append a value to the state

jot :: (Monad m1, MonadTrans t1, m ~ t1 m1, MonadAppendOnly mark w m1) => mark w -> m ()

Append a value to the state

Instances

MonadAppendOnly mark w m => MonadAppendOnly mark w (IdentityT m)

Defined in Control.FX.Monad.Trans.IdentityT

Methods

look :: IdentityT m (mark w)

jot :: mark w -> IdentityT m ()

(Monoid w, MonadIdentity mark) => MonadAppendOnly mark w (AppendOnly mark w)

Defined in Control.FX.Monad.AppendOnly

Methods

look :: AppendOnly mark w (mark w)

jot :: mark w -> AppendOnly mark w ()

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadAppendOnly mark w m, Monoid w) => MonadAppendOnly mark w (HaltT mark1 m)

Defined in Control.FX.Monad.Trans.HaltT

Methods

look :: HaltT mark1 m (mark w)

jot :: mark w -> HaltT mark1 m ()

(Monad m, MonadTrans t, MonadIdentity mark, MonadAppendOnly mark w (t m), Monoid w) => MonadAppendOnly mark w (IdentityTT t m)

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

look :: IdentityTT t m (mark w)

jot :: mark w -> IdentityTT t m ()

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadAppendOnly mark w m, Monoid w, Monoid w1) => MonadAppendOnly mark w (WriteOnlyT mark1 w1 m)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

look :: WriteOnlyT mark1 w1 m (mark w)

jot :: mark w -> WriteOnlyT mark1 w1 m ()

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadAppendOnly mark w m) => MonadAppendOnly mark w (WriteOnceT mark1 w1 m)

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

look :: WriteOnceT mark1 w1 m (mark w)

jot :: mark w -> WriteOnceT mark1 w1 m ()

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadAppendOnly mark w m, Monoid w) => MonadAppendOnly mark w (StateT mark1 s m)

Defined in Control.FX.Monad.Trans.StateT

Methods

look :: StateT mark1 s m (mark w)

jot :: mark w -> StateT mark1 s m ()

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadAppendOnly mark w m, Commutant mark1, Monoid w) => MonadAppendOnly mark w (ReadOnlyT mark1 r m)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

look :: ReadOnlyT mark1 r m (mark w)

jot :: mark w -> ReadOnlyT mark1 r m ()

(Monad m, MonadIdentity mark, MonadIdentity mark1, Monoid w, MonadAppendOnly mark w m) => MonadAppendOnly mark w (ExceptT mark1 e m)

Defined in Control.FX.Monad.Trans.ExceptT

Methods

look :: ExceptT mark1 e m (mark w)

jot :: mark w -> ExceptT mark1 e m ()

(Monad m, MonadIdentity mark, MonadIdentity mark1, Monoid w, Monoid w1, MonadAppendOnly mark w m) => MonadAppendOnly mark w (AppendOnlyT mark1 w1 m)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

look :: AppendOnlyT mark1 w1 m (mark w)

jot :: mark w -> AppendOnlyT mark1 w1 m ()

(Monad m, MonadIdentity mark, Monoid w) => MonadAppendOnly mark w (AppendOnlyT mark w m)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

look :: AppendOnlyT mark w m (mark w)

jot :: mark w -> AppendOnlyT mark w m ()

(Monad m, MonadTrans t1, MonadTrans t2, Monoid w, ComposableT t1, LiftDraft t1, MonadIdentity mark, forall (x :: Type -> Type). Monad x => MonadAppendOnly mark w (t2 x)) => MonadAppendOnly mark w (ComposeT t1 t2 m)

Defined in Control.FX.Monad.Trans.ComposeT

Methods

look :: ComposeT t1 t2 m (mark w)

jot :: mark w -> ComposeT t1 t2 m ()

(Monad m, MonadTrans t2, Monoid w, MonadIdentity mark) => MonadAppendOnly mark w (ComposeT (AppendOnlyT mark w) t2 m)

Defined in Control.FX.Monad.Trans.ComposeT

Methods

look :: ComposeT (AppendOnlyT mark w) t2 m (mark w)

jot :: mark w -> ComposeT (AppendOnlyT mark w) t2 m ()

(Monad m, MonadTrans t, Monoid w, MonadIdentity mark1, MonadAppendOnly mark w (t m)) => MonadAppendOnly mark w (HaltTT mark1 t m)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

look :: HaltTT mark1 t m (mark w)

jot :: mark w -> HaltTT mark1 t m ()

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Monoid w, Monoid w1, forall (x :: Type -> Type). Monad x => MonadAppendOnly mark w (t x)) => MonadAppendOnly mark w (WriteOnlyTT mark1 w1 t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

look :: WriteOnlyTT mark1 w1 t m (mark w)

jot :: mark w -> WriteOnlyTT mark1 w1 t m ()

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadAppendOnly mark w (t x), Monoid w) => MonadAppendOnly mark w (WriteOnceTT mark1 w1 t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

look :: WriteOnceTT mark1 w1 t m (mark w)

jot :: mark w -> WriteOnceTT mark1 w1 t m ()

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Monoid w, forall (x :: Type -> Type). Monad x => MonadAppendOnly mark w (t x)) => MonadAppendOnly mark w (StateTT mark1 s t m)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

look :: StateTT mark1 s t m (mark w)

jot :: mark w -> StateTT mark1 s t m ()

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Monoid w, Commutant mark1, forall (x :: Type -> Type). Monad x => MonadAppendOnly mark w (t x)) => MonadAppendOnly mark w (ReadOnlyTT mark1 r t m)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

look :: ReadOnlyTT mark1 r t m (mark w)

jot :: mark w -> ReadOnlyTT mark1 r t m ()

(Monad m, MonadTrans t, MonadTrans v, Monoid w, MonadTransTrans u, MonadIdentity mark, OverableT v, forall (x :: Type -> Type). Monad x => MonadAppendOnly mark w (u t x)) => MonadAppendOnly mark w (OverTT v u t m)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Methods

look :: OverTT v u t m (mark w)

jot :: mark w -> OverTT v u t m ()

(Monad m, MonadTrans t, Monoid w, MonadTransTrans u, MonadIdentity mark) => MonadAppendOnly mark w (OverTT (AppendOnlyT mark w) u t m)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Methods

look :: OverTT (AppendOnlyT mark w) u t m (mark w)

jot :: mark w -> OverTT (AppendOnlyT mark w) u t m ()

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Commutant mark1, Monoid w, forall (x :: Type -> Type). Monad x => MonadAppendOnly mark w (t x)) => MonadAppendOnly mark w (PromptTT mark1 p t m)

Defined in Control.FX.Monad.Trans.Trans.PromptTT

Methods

look :: PromptTT mark1 p t m (mark w)

jot :: mark w -> PromptTT mark1 p t m ()

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Monoid w, forall (x :: Type -> Type). Monad x => MonadAppendOnly mark w (t x)) => MonadAppendOnly mark w (ExceptTT mark1 e t m)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

look :: ExceptTT mark1 e t m (mark w)

jot :: mark w -> ExceptTT mark1 e t m ()

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadAppendOnly mark w (t x), Monoid w1, Monoid w) => MonadAppendOnly mark w (AppendOnlyTT mark1 w1 t m)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

look :: AppendOnlyTT mark1 w1 t m (mark w)

jot :: mark w -> AppendOnlyTT mark1 w1 t m ()

(Monad m, MonadTrans t, MonadIdentity mark, Monoid w) => MonadAppendOnly mark w (AppendOnlyTT mark w t m)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

look :: AppendOnlyTT mark w t m (mark w)

jot :: mark w -> AppendOnlyTT mark w t m ()

class (Monad m, MonadIdentity mark) => MonadWriteOnce mark w m where

Class representing monads with access to a write-once, read-many state mark w. Instances should satisfy the following laws.

(1) etch a >> etch b  ===  etch a >> return False

(2) etch a >> press  ===  return (Just $ pure a)

Minimal complete definition

Nothing

Methods

etch :: mark w -> m Bool

Attempt to record the write-once state, returning True if and only if the write succeeds.

etch :: (Monad m1, MonadTrans t1, m ~ t1 m1, MonadWriteOnce mark w m1) => mark w -> m Bool

Attempt to record the write-once state, returning True if and only if the write succeeds.

press :: m (Maybe (mark w))

Attempt to read a copy of the write-once state.

press :: (Monad m1, MonadTrans t1, m ~ t1 m1, MonadWriteOnce mark w m1) => m (Maybe (mark w))

Attempt to read a copy of the write-once state.

Instances

MonadWriteOnce mark w m => MonadWriteOnce mark w (IdentityT m)

Defined in Control.FX.Monad.Trans.IdentityT

Methods

etch :: mark w -> IdentityT m Bool

press :: IdentityT m (Maybe (mark w))

MonadIdentity mark => MonadWriteOnce mark w (WriteOnce mark w)

Defined in Control.FX.Monad.WriteOnce

Methods

etch :: mark w -> WriteOnce mark w Bool

press :: WriteOnce mark w (Maybe (mark w))

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnce mark w m) => MonadWriteOnce mark w (HaltT mark1 m)

Defined in Control.FX.Monad.Trans.HaltT

Methods

etch :: mark w -> HaltT mark1 m Bool

press :: HaltT mark1 m (Maybe (mark w))

(Monad m, MonadTrans t, MonadIdentity mark, MonadWriteOnce mark w (t m)) => MonadWriteOnce mark w (IdentityTT t m)

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

etch :: mark w -> IdentityTT t m Bool

press :: IdentityTT t m (Maybe (mark w))

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnce mark w m, Monoid w1) => MonadWriteOnce mark w (WriteOnlyT mark1 w1 m)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

etch :: mark w -> WriteOnlyT mark1 w1 m Bool

press :: WriteOnlyT mark1 w1 m (Maybe (mark w))

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnce mark w m) => MonadWriteOnce mark w (WriteOnceT mark1 w1 m)

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

etch :: mark w -> WriteOnceT mark1 w1 m Bool

press :: WriteOnceT mark1 w1 m (Maybe (mark w))

(Monad m, MonadIdentity mark) => MonadWriteOnce mark w (WriteOnceT mark w m)

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

etch :: mark w -> WriteOnceT mark w m Bool

press :: WriteOnceT mark w m (Maybe (mark w))

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnce mark w m) => MonadWriteOnce mark w (StateT mark1 s m)

Defined in Control.FX.Monad.Trans.StateT

Methods

etch :: mark w -> StateT mark1 s m Bool

press :: StateT mark1 s m (Maybe (mark w))

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnce mark w m, Commutant mark1) => MonadWriteOnce mark w (ReadOnlyT mark1 r m)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

etch :: mark w -> ReadOnlyT mark1 r m Bool

press :: ReadOnlyT mark1 r m (Maybe (mark w))

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnce mark w m) => MonadWriteOnce mark w (ExceptT mark1 e m)

Defined in Control.FX.Monad.Trans.ExceptT

Methods

etch :: mark w -> ExceptT mark1 e m Bool

press :: ExceptT mark1 e m (Maybe (mark w))

(Monad m, MonadIdentity mark, MonadIdentity mark1, Monoid w, Monoid w1, MonadWriteOnce mark w m) => MonadWriteOnce mark w (AppendOnlyT mark1 w1 m)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

etch :: mark w -> AppendOnlyT mark1 w1 m Bool

press :: AppendOnlyT mark1 w1 m (Maybe (mark w))

(Monad m, MonadTrans t1, MonadTrans t2, ComposableT t1, LiftDraft t1, MonadIdentity mark, forall (x :: Type -> Type). Monad x => MonadWriteOnce mark w (t2 x)) => MonadWriteOnce mark w (ComposeT t1 t2 m)

Defined in Control.FX.Monad.Trans.ComposeT

Methods

etch :: mark w -> ComposeT t1 t2 m Bool

press :: ComposeT t1 t2 m (Maybe (mark w))

(Monad m, MonadTrans t2, MonadIdentity mark) => MonadWriteOnce mark w (ComposeT (WriteOnceT mark w) t2 m)

Defined in Control.FX.Monad.Trans.ComposeT

Methods

etch :: mark w -> ComposeT (WriteOnceT mark w) t2 m Bool

press :: ComposeT (WriteOnceT mark w) t2 m (Maybe (mark w))

(Monad m, MonadTrans t, MonadIdentity mark1, MonadWriteOnce mark w (t m)) => MonadWriteOnce mark w (HaltTT mark1 t m)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

etch :: mark w -> HaltTT mark1 t m Bool

press :: HaltTT mark1 t m (Maybe (mark w))

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Monoid w1, forall (x :: Type -> Type). Monad x => MonadWriteOnce mark w (t x)) => MonadWriteOnce mark w (WriteOnlyTT mark1 w1 t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

etch :: mark w -> WriteOnlyTT mark1 w1 t m Bool

press :: WriteOnlyTT mark1 w1 t m (Maybe (mark w))

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadWriteOnce mark w (t x)) => MonadWriteOnce mark w (WriteOnceTT mark1 w1 t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

etch :: mark w -> WriteOnceTT mark1 w1 t m Bool

press :: WriteOnceTT mark1 w1 t m (Maybe (mark w))

(Monad m, MonadTrans t, MonadIdentity mark) => MonadWriteOnce mark w (WriteOnceTT mark w t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

etch :: mark w -> WriteOnceTT mark w t m Bool

press :: WriteOnceTT mark w t m (Maybe (mark w))

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadWriteOnce mark w (t x)) => MonadWriteOnce mark w (StateTT mark1 s t m)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

etch :: mark w -> StateTT mark1 s t m Bool

press :: StateTT mark1 s t m (Maybe (mark w))

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Commutant mark1, forall (x :: Type -> Type). Monad x => MonadWriteOnce mark w (t x)) => MonadWriteOnce mark w (ReadOnlyTT mark1 r t m)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

etch :: mark w -> ReadOnlyTT mark1 r t m Bool

press :: ReadOnlyTT mark1 r t m (Maybe (mark w))

(Monad m, MonadTrans t, MonadTrans v, OverableT v, MonadTransTrans u, MonadIdentity mark, forall (x :: Type -> Type). Monad x => MonadWriteOnce mark w (u t x)) => MonadWriteOnce mark w (OverTT v u t m)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Methods

etch :: mark w -> OverTT v u t m Bool

press :: OverTT v u t m (Maybe (mark w))

(Monad m, MonadTrans t, MonadTransTrans u, MonadIdentity mark) => MonadWriteOnce mark w (OverTT (WriteOnceT mark w) u t m)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Methods

etch :: mark w -> OverTT (WriteOnceT mark w) u t m Bool

press :: OverTT (WriteOnceT mark w) u t m (Maybe (mark w))

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Commutant mark1, forall (x :: Type -> Type). Monad x => MonadWriteOnce mark w (t x)) => MonadWriteOnce mark w (PromptTT mark1 p t m)

Defined in Control.FX.Monad.Trans.Trans.PromptTT

Methods

etch :: mark w -> PromptTT mark1 p t m Bool

press :: PromptTT mark1 p t m (Maybe (mark w))

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadWriteOnce mark w (t x)) => MonadWriteOnce mark w (ExceptTT mark1 e t m)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

etch :: mark w -> ExceptTT mark1 e t m Bool

press :: ExceptTT mark1 e t m (Maybe (mark w))

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadWriteOnce mark w (t x), Monoid w1) => MonadWriteOnce mark w (AppendOnlyTT mark1 w1 t m)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

etch :: mark w -> AppendOnlyTT mark1 w1 t m Bool

press :: AppendOnlyTT mark1 w1 t m (Maybe (mark w))

class (Monad m, MonadIdentity mark) => MonadPrompt mark (p :: * -> *) m where

Class representing monads which can prompt an oracle for a monadic result.

Minimal complete definition

Nothing

Methods

prompt :: mark (p a) -> m (mark a)

Prompt an oracle of type mark (p a), receiving a monadic result

prompt :: (Monad m1, MonadTrans t1, m ~ t1 m1, MonadPrompt mark p m1) => mark (p a) -> m (mark a)

Prompt an oracle of type mark (p a), receiving a monadic result

Instances

MonadPrompt mark p m => MonadPrompt mark p (IdentityT m)

Defined in Control.FX.Monad.Trans.IdentityT

Methods

prompt :: mark (p a) -> IdentityT m (mark a)

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadPrompt mark p m) => MonadPrompt mark p (HaltT mark1 m)

Defined in Control.FX.Monad.Trans.HaltT

Methods

prompt :: mark (p a) -> HaltT mark1 m (mark a)

(Monad m, MonadTrans t, MonadIdentity mark, MonadPrompt mark p (t m)) => MonadPrompt mark p (IdentityTT t m)

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

prompt :: mark (p a) -> IdentityTT t m (mark a)

(Monad m, MonadIdentity mark, MonadIdentity mark1, Monoid w, MonadPrompt mark p m) => MonadPrompt mark p (WriteOnlyT mark1 w m)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

prompt :: mark (p a) -> WriteOnlyT mark1 w m (mark a)

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadPrompt mark p m) => MonadPrompt mark p (WriteOnceT mark1 w m)

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

prompt :: mark (p a) -> WriteOnceT mark1 w m (mark a)

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadPrompt mark p m) => MonadPrompt mark p (StateT mark1 s m)

Defined in Control.FX.Monad.Trans.StateT

Methods

prompt :: mark (p a) -> StateT mark1 s m (mark a)

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadPrompt mark p m, Commutant mark1) => MonadPrompt mark p (ReadOnlyT mark1 r m)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

prompt :: mark (p a) -> ReadOnlyT mark1 r m (mark a)

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadPrompt mark p m) => MonadPrompt mark p (ExceptT mark1 e m)

Defined in Control.FX.Monad.Trans.ExceptT

Methods

prompt :: mark (p a) -> ExceptT mark1 e m (mark a)

(Monad m, MonadIdentity mark, MonadIdentity mark1, Monoid w, MonadPrompt mark p m) => MonadPrompt mark p (AppendOnlyT mark1 w m)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

prompt :: mark (p a) -> AppendOnlyT mark1 w m (mark a)

(Monad m, MonadTrans t, MonadIdentity mark1, MonadPrompt mark p (t m)) => MonadPrompt mark p (HaltTT mark1 t m)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

prompt :: mark (p a) -> HaltTT mark1 t m (mark a)

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Monoid w, forall (x :: Type -> Type). Monad x => MonadPrompt mark p (t x)) => MonadPrompt mark p (WriteOnlyTT mark1 w t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

prompt :: mark (p a) -> WriteOnlyTT mark1 w t m (mark a)

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadPrompt mark p (t x)) => MonadPrompt mark p (WriteOnceTT mark1 w t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

prompt :: mark (p a) -> WriteOnceTT mark1 w t m (mark a)

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadPrompt mark p (t x)) => MonadPrompt mark p (StateTT mark1 s t m)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

prompt :: mark (p a) -> StateTT mark1 s t m (mark a)

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadPrompt mark p (t x)) => MonadPrompt mark p (ReadOnlyTT mark1 r t m)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

prompt :: mark (p a) -> ReadOnlyTT mark1 r t m (mark a)

(Monad m, MonadTrans t, MonadTrans v, OverableT v, MonadTransTrans u, MonadPrompt mark p (u t m)) => MonadPrompt mark p (OverTT v u t m)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Methods

prompt :: mark (p a) -> OverTT v u t m (mark a)

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Commutant mark1, forall (x :: Type -> Type). Monad x => MonadPrompt mark p (t x)) => MonadPrompt mark p (PromptTT mark1 p1 t m)

Defined in Control.FX.Monad.Trans.Trans.PromptTT

Methods

prompt :: mark (p a) -> PromptTT mark1 p1 t m (mark a)

(Monad m, MonadTrans t, MonadIdentity mark) => MonadPrompt mark p (PromptTT mark p t m)

Defined in Control.FX.Monad.Trans.Trans.PromptTT

Methods

prompt :: mark (p a) -> PromptTT mark p t m (mark a)

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadPrompt mark p (t x)) => MonadPrompt mark p (ExceptTT mark1 e t m)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

prompt :: mark (p a) -> ExceptTT mark1 e t m (mark a)

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadPrompt mark p (t x), Monoid w) => MonadPrompt mark p (AppendOnlyTT mark1 w t m)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

prompt :: mark (p a) -> AppendOnlyTT mark1 w t m (mark a)

Concrete Types

Monads

data Identity (a :: *)

Concrete identity monad

Constructors

Identity

Fields

• unIdentity :: a

  Extract a pure value

Instances

Monad Identity

Defined in Control.FX.Monad.Identity

Methods

(>>=) :: Identity a -> (a -> Identity b) -> Identity b

(>>) :: Identity a -> Identity b -> Identity b

return :: a -> Identity a

fail :: String -> Identity a

Functor Identity

Defined in Control.FX.Monad.Identity

Methods

fmap :: (a -> b) -> Identity a -> Identity b

(<$) :: a -> Identity b -> Identity a

Applicative Identity

Defined in Control.FX.Monad.Identity

Methods

pure :: a -> Identity a

(<*>) :: Identity (a -> b) -> Identity a -> Identity b

liftA2 :: (a -> b -> c) -> Identity a -> Identity b -> Identity c

(*>) :: Identity a -> Identity b -> Identity b

(<*) :: Identity a -> Identity b -> Identity a

EqIn Identity

Defined in Control.FX.Monad.Identity

Associated Types

data Context Identity :: Type

Methods

eqIn :: Eq a => Context Identity -> Identity a -> Identity a -> Bool

Commutant Identity

Defined in Control.FX.Monad.Identity

Methods

commute :: Applicative f => Identity (f a) -> f (Identity a)

MonadIdentity Identity

Defined in Control.FX.Monad.Identity

Methods

unwrap :: Identity a -> a

RunMonad Identity

Defined in Control.FX.Monad.Identity

Associated Types

data Input Identity :: Type

data Output Identity a :: Type

Methods

run :: Input Identity -> Identity a -> Output Identity a

Central Identity

Defined in Control.FX.Monad.Identity

Eq (Context Identity)

Defined in Control.FX.Monad.Identity

Methods

(==) :: Context Identity -> Context Identity -> Bool

(/=) :: Context Identity -> Context Identity -> Bool

Eq (Input Identity)

Defined in Control.FX.Monad.Identity

Methods

(==) :: Input Identity -> Input Identity -> Bool

(/=) :: Input Identity -> Input Identity -> Bool

Eq a => Eq (Identity a)

Defined in Control.FX.Monad.Identity

Methods

(==) :: Identity a -> Identity a -> Bool

(/=) :: Identity a -> Identity a -> Bool

Show (Context Identity)

Defined in Control.FX.Monad.Identity

Methods

showsPrec :: Int -> Context Identity -> ShowS

show :: Context Identity -> String

showList :: [Context Identity] -> ShowS

Show (Input Identity)

Defined in Control.FX.Monad.Identity

Methods

showsPrec :: Int -> Input Identity -> ShowS

show :: Input Identity -> String

showList :: [Input Identity] -> ShowS

Show a => Show (Identity a)

Defined in Control.FX.Monad.Identity

Methods

showsPrec :: Int -> Identity a -> ShowS

show :: Identity a -> String

showList :: [Identity a] -> ShowS

Semigroup a => Semigroup (Identity a)

Defined in Control.FX.Monad.Identity

Methods

(<>) :: Identity a -> Identity a -> Identity a

sconcat :: NonEmpty (Identity a) -> Identity a

stimes :: Integral b => b -> Identity a -> Identity a

Monoid a => Monoid (Identity a)

Defined in Control.FX.Monad.Identity

Methods

mempty :: Identity a

mappend :: Identity a -> Identity a -> Identity a

mconcat :: [Identity a] -> Identity a

Eq a => Eq (Output Identity a)

Defined in Control.FX.Monad.Identity

Methods

(==) :: Output Identity a -> Output Identity a -> Bool

(/=) :: Output Identity a -> Output Identity a -> Bool

Show a => Show (Output Identity a)

Defined in Control.FX.Monad.Identity

Methods

showsPrec :: Int -> Output Identity a -> ShowS

show :: Output Identity a -> String

showList :: [Output Identity a] -> ShowS

data Context Identity

Defined in Control.FX.Monad.Identity

data Context Identity = IdentityCtx {

• unIdentityCtx :: ()

}

data Input Identity

Defined in Control.FX.Monad.Identity

data Input Identity = IdentityIn {

• unIdentityIn :: ()

}

data Output Identity a

Defined in Control.FX.Monad.Identity

data Output Identity a = IdentityOut {

• unIdentityOut :: Identity a

}

newtype Compose (m1 :: * -> *) (m2 :: * -> *) (a :: *)

Concrete composite monad

Constructors

Compose

Fields

• unCompose :: m1 (m2 a)

Instances

(Eq (Input m1), Eq (Input m2)) => Eq (Input (Compose m1 m2))

Defined in Control.FX.Monad.Compose

Methods

(==) :: Input (Compose m1 m2) -> Input (Compose m1 m2) -> Bool

(/=) :: Input (Compose m1 m2) -> Input (Compose m1 m2) -> Bool

(Show (Input m1), Show (Input m2)) => Show (Input (Compose m1 m2))

Defined in Control.FX.Monad.Compose

Methods

showsPrec :: Int -> Input (Compose m1 m2) -> ShowS

show :: Input (Compose m1 m2) -> String

showList :: [Input (Compose m1 m2)] -> ShowS

(Eq (Output m1 (Output m2 a)), Eq (Output m2 a)) => Eq (Output (Compose m1 m2) a)

Defined in Control.FX.Monad.Compose

Methods

(==) :: Output (Compose m1 m2) a -> Output (Compose m1 m2) a -> Bool

(/=) :: Output (Compose m1 m2) a -> Output (Compose m1 m2) a -> Bool

(Monad m1, Monad m2, Central m2) => Monad (Compose m1 m2)

Defined in Control.FX.Monad.Compose

Methods

(>>=) :: Compose m1 m2 a -> (a -> Compose m1 m2 b) -> Compose m1 m2 b

(>>) :: Compose m1 m2 a -> Compose m1 m2 b -> Compose m1 m2 b

return :: a -> Compose m1 m2 a

fail :: String -> Compose m1 m2 a

(Functor m1, Functor m2) => Functor (Compose m1 m2)

Defined in Control.FX.Monad.Compose

Methods

fmap :: (a -> b) -> Compose m1 m2 a -> Compose m1 m2 b

(<$) :: a -> Compose m1 m2 b -> Compose m1 m2 a

(Show (Output m1 (Output m2 a)), Show (Output m2 a)) => Show (Output (Compose m1 m2) a)

Defined in Control.FX.Monad.Compose

Methods

showsPrec :: Int -> Output (Compose m1 m2) a -> ShowS

show :: Output (Compose m1 m2) a -> String

showList :: [Output (Compose m1 m2) a] -> ShowS

(Applicative m1, Applicative m2) => Applicative (Compose m1 m2)

Defined in Control.FX.Monad.Compose

Methods

pure :: a -> Compose m1 m2 a

(<*>) :: Compose m1 m2 (a -> b) -> Compose m1 m2 a -> Compose m1 m2 b

liftA2 :: (a -> b -> c) -> Compose m1 m2 a -> Compose m1 m2 b -> Compose m1 m2 c

(*>) :: Compose m1 m2 a -> Compose m1 m2 b -> Compose m1 m2 b

(<*) :: Compose m1 m2 a -> Compose m1 m2 b -> Compose m1 m2 a

(Commutant c1, Commutant c2) => Commutant (Compose c1 c2)

Defined in Control.FX.Monad.Compose

Methods

commute :: Applicative f => Compose c1 c2 (f a) -> f (Compose c1 c2 a)

(RunMonad m1, RunMonad m2, Central m2, Functor (Output m1)) => RunMonad (Compose m1 m2)

Defined in Control.FX.Monad.Compose

Associated Types

data Input (Compose m1 m2) :: Type

data Output (Compose m1 m2) a :: Type

Methods

run :: Input (Compose m1 m2) -> Compose m1 m2 a -> Output (Compose m1 m2) a

(Central c1, Central c2) => Central (Compose c1 c2)

Defined in Control.FX.Monad.Compose

Eq (m1 (m2 a)) => Eq (Compose m1 m2 a)

Defined in Control.FX.Monad.Compose

Methods

(==) :: Compose m1 m2 a -> Compose m1 m2 a -> Bool

(/=) :: Compose m1 m2 a -> Compose m1 m2 a -> Bool

Show (m1 (m2 a)) => Show (Compose m1 m2 a)

Defined in Control.FX.Monad.Compose

Methods

showsPrec :: Int -> Compose m1 m2 a -> ShowS

show :: Compose m1 m2 a -> String

showList :: [Compose m1 m2 a] -> ShowS

newtype Input (Compose m1 m2)

Defined in Control.FX.Monad.Compose

newtype Input (Compose m1 m2) = ComposeIn {

• unComposeIn :: (Input m1, Input m2)

}

newtype Output (Compose m1 m2) a

Defined in Control.FX.Monad.Compose

newtype Output (Compose m1 m2) a = ComposeOut {

• unComposeOut :: Compose (Output m1) (Output m2) a

}

newtype ReadOnly (mark :: * -> *) (r :: *) (a :: *)

Concrete read-only state monad with state type r

Constructors

ReadOnly

Fields

• unReadOnly :: r -> a

Instances

MonadIdentity mark => MonadReadOnly mark r (ReadOnly mark r)

Defined in Control.FX.Monad.ReadOnly

Methods

ask :: ReadOnly mark r (mark r)

local :: (mark r -> mark r) -> ReadOnly mark r a -> ReadOnly mark r a

Eq (mark r) => Eq (Context (ReadOnly mark r))

Defined in Control.FX.Monad.ReadOnly

Methods

(==) :: Context (ReadOnly mark r) -> Context (ReadOnly mark r) -> Bool

(/=) :: Context (ReadOnly mark r) -> Context (ReadOnly mark r) -> Bool

Eq (mark r) => Eq (Input (ReadOnly mark r))

Defined in Control.FX.Monad.ReadOnly

Methods

(==) :: Input (ReadOnly mark r) -> Input (ReadOnly mark r) -> Bool

(/=) :: Input (ReadOnly mark r) -> Input (ReadOnly mark r) -> Bool

Show (mark r) => Show (Context (ReadOnly mark r))

Defined in Control.FX.Monad.ReadOnly

Methods

showsPrec :: Int -> Context (ReadOnly mark r) -> ShowS

show :: Context (ReadOnly mark r) -> String

showList :: [Context (ReadOnly mark r)] -> ShowS

Show (mark r) => Show (Input (ReadOnly mark r))

Defined in Control.FX.Monad.ReadOnly

Methods

showsPrec :: Int -> Input (ReadOnly mark r) -> ShowS

show :: Input (ReadOnly mark r) -> String

showList :: [Input (ReadOnly mark r)] -> ShowS

Eq (mark a) => Eq (Output (ReadOnly mark r) a)

Defined in Control.FX.Monad.ReadOnly

Methods

(==) :: Output (ReadOnly mark r) a -> Output (ReadOnly mark r) a -> Bool

(/=) :: Output (ReadOnly mark r) a -> Output (ReadOnly mark r) a -> Bool

MonadIdentity mark => Monad (ReadOnly mark r)

Defined in Control.FX.Monad.ReadOnly

Methods

(>>=) :: ReadOnly mark r a -> (a -> ReadOnly mark r b) -> ReadOnly mark r b

(>>) :: ReadOnly mark r a -> ReadOnly mark r b -> ReadOnly mark r b

return :: a -> ReadOnly mark r a

fail :: String -> ReadOnly mark r a

MonadIdentity mark => Functor (ReadOnly mark r)

Defined in Control.FX.Monad.ReadOnly

Methods

fmap :: (a -> b) -> ReadOnly mark r a -> ReadOnly mark r b

(<$) :: a -> ReadOnly mark r b -> ReadOnly mark r a

Show (mark a) => Show (Output (ReadOnly mark r) a)

Defined in Control.FX.Monad.ReadOnly

Methods

showsPrec :: Int -> Output (ReadOnly mark r) a -> ShowS

show :: Output (ReadOnly mark r) a -> String

showList :: [Output (ReadOnly mark r) a] -> ShowS

MonadIdentity mark => Applicative (ReadOnly mark r)

Defined in Control.FX.Monad.ReadOnly

Methods

pure :: a -> ReadOnly mark r a

(<*>) :: ReadOnly mark r (a -> b) -> ReadOnly mark r a -> ReadOnly mark r b

liftA2 :: (a -> b -> c) -> ReadOnly mark r a -> ReadOnly mark r b -> ReadOnly mark r c

(*>) :: ReadOnly mark r a -> ReadOnly mark r b -> ReadOnly mark r b

(<*) :: ReadOnly mark r a -> ReadOnly mark r b -> ReadOnly mark r a

MonadIdentity mark => EqIn (ReadOnly mark r)

Defined in Control.FX.Monad.ReadOnly

Associated Types

data Context (ReadOnly mark r) :: Type

Methods

eqIn :: Eq a => Context (ReadOnly mark r) -> ReadOnly mark r a -> ReadOnly mark r a -> Bool

(MonadIdentity mark, Commutant mark) => RunMonad (ReadOnly mark r)

Defined in Control.FX.Monad.ReadOnly

Associated Types

data Input (ReadOnly mark r) :: Type

data Output (ReadOnly mark r) a :: Type

Methods

run :: Input (ReadOnly mark r) -> ReadOnly mark r a -> Output (ReadOnly mark r) a

(Typeable r, Typeable a, Typeable mark) => Show (ReadOnly mark r a)

Defined in Control.FX.Monad.ReadOnly

Methods

showsPrec :: Int -> ReadOnly mark r a -> ShowS

show :: ReadOnly mark r a -> String

showList :: [ReadOnly mark r a] -> ShowS

newtype Context (ReadOnly mark r)

Defined in Control.FX.Monad.ReadOnly

newtype Context (ReadOnly mark r) = ReadOnlyCtx {

• unReadOnlyCtx :: mark r

}

newtype Input (ReadOnly mark r)

Defined in Control.FX.Monad.ReadOnly

newtype Input (ReadOnly mark r) = ReadOnlyIn {

• unReadOnlyIn :: mark r

}

newtype Output (ReadOnly mark r) a

Defined in Control.FX.Monad.ReadOnly

newtype Output (ReadOnly mark r) a = ReadOnlyOut {

• unReadOnlyOut :: mark a

}

newtype State (mark :: * -> *) (s :: *) (a :: *)

Concrete state monad

Constructors

State

Fields

• unState :: s -> Pair s a

Instances

MonadIdentity mark => MonadState mark s (State mark s)

Defined in Control.FX.Monad.State

Methods

get :: State mark s (mark s)

put :: mark s -> State mark s ()

Eq (mark s) => Eq (Context (State mark s))

Defined in Control.FX.Monad.State

Methods

(==) :: Context (State mark s) -> Context (State mark s) -> Bool

(/=) :: Context (State mark s) -> Context (State mark s) -> Bool

Eq (mark s) => Eq (Input (State mark s))

Defined in Control.FX.Monad.State

Methods

(==) :: Input (State mark s) -> Input (State mark s) -> Bool

(/=) :: Input (State mark s) -> Input (State mark s) -> Bool

Show (mark s) => Show (Context (State mark s))

Defined in Control.FX.Monad.State

Methods

showsPrec :: Int -> Context (State mark s) -> ShowS

show :: Context (State mark s) -> String

showList :: [Context (State mark s)] -> ShowS

Show (mark s) => Show (Input (State mark s))

Defined in Control.FX.Monad.State

Methods

showsPrec :: Int -> Input (State mark s) -> ShowS

show :: Input (State mark s) -> String

showList :: [Input (State mark s)] -> ShowS

(Eq (mark s), Eq a) => Eq (Output (State mark s) a)

Defined in Control.FX.Monad.State

Methods

(==) :: Output (State mark s) a -> Output (State mark s) a -> Bool

(/=) :: Output (State mark s) a -> Output (State mark s) a -> Bool

MonadIdentity mark => Monad (State mark s)

Defined in Control.FX.Monad.State

Methods

(>>=) :: State mark s a -> (a -> State mark s b) -> State mark s b

(>>) :: State mark s a -> State mark s b -> State mark s b

return :: a -> State mark s a

fail :: String -> State mark s a

MonadIdentity mark => Functor (State mark s)

Defined in Control.FX.Monad.State

Methods

fmap :: (a -> b) -> State mark s a -> State mark s b

(<$) :: a -> State mark s b -> State mark s a

(Show (mark s), Show a) => Show (Output (State mark s) a)

Defined in Control.FX.Monad.State

Methods

showsPrec :: Int -> Output (State mark s) a -> ShowS

show :: Output (State mark s) a -> String

showList :: [Output (State mark s) a] -> ShowS

MonadIdentity mark => Applicative (State mark s)

Defined in Control.FX.Monad.State

Methods

pure :: a -> State mark s a

(<*>) :: State mark s (a -> b) -> State mark s a -> State mark s b

liftA2 :: (a -> b -> c) -> State mark s a -> State mark s b -> State mark s c

(*>) :: State mark s a -> State mark s b -> State mark s b

(<*) :: State mark s a -> State mark s b -> State mark s a

(Eq s, MonadIdentity mark) => EqIn (State mark s)

Defined in Control.FX.Monad.State

Associated Types

data Context (State mark s) :: Type

Methods

eqIn :: Eq a => Context (State mark s) -> State mark s a -> State mark s a -> Bool

MonadIdentity mark => RunMonad (State mark s)

Defined in Control.FX.Monad.State

Associated Types

data Input (State mark s) :: Type

data Output (State mark s) a :: Type

Methods

run :: Input (State mark s) -> State mark s a -> Output (State mark s) a

(Typeable s, Typeable a, Typeable mark) => Show (State mark s a)

Defined in Control.FX.Monad.State

Methods

showsPrec :: Int -> State mark s a -> ShowS

show :: State mark s a -> String

showList :: [State mark s a] -> ShowS

data Context (State mark s)

Defined in Control.FX.Monad.State

data Context (State mark s) = StateCtx {

• unStateCtx :: mark s

}

data Input (State mark s)

Defined in Control.FX.Monad.State

data Input (State mark s) = StateIn {

• unStateIn :: mark s

}

data Output (State mark s) a

Defined in Control.FX.Monad.State

data Output (State mark s) a = StateOut {

• unStateOut :: Pair (mark s) a

}

data Except (mark :: * -> *) (e :: *) (a :: *)

Concrete exception monad, throwing marked exceptions of type mark e and producing values of type a

Constructors

Except e

Exceptional result

Accept a

Normal result

Instances

MonadIdentity mark => MonadExcept mark e (Except mark e)

Defined in Control.FX.Monad.Except

Methods

throw :: mark e -> Except mark e a

catch :: Except mark e a -> (mark e -> Except mark e a) -> Except mark e a

Eq (mark ()) => Eq (Context (Except mark e))

Defined in Control.FX.Monad.Except

Methods

(==) :: Context (Except mark e) -> Context (Except mark e) -> Bool

(/=) :: Context (Except mark e) -> Context (Except mark e) -> Bool

Eq (mark ()) => Eq (Input (Except mark e))

Defined in Control.FX.Monad.Except

Methods

(==) :: Input (Except mark e) -> Input (Except mark e) -> Bool

(/=) :: Input (Except mark e) -> Input (Except mark e) -> Bool

Show (mark ()) => Show (Context (Except mark e))

Defined in Control.FX.Monad.Except

Methods

showsPrec :: Int -> Context (Except mark e) -> ShowS

show :: Context (Except mark e) -> String

showList :: [Context (Except mark e)] -> ShowS

Show (mark ()) => Show (Input (Except mark e))

Defined in Control.FX.Monad.Except

Methods

showsPrec :: Int -> Input (Except mark e) -> ShowS

show :: Input (Except mark e) -> String

showList :: [Input (Except mark e)] -> ShowS

MonadIdentity mark => Bifunctor (Except mark)

Defined in Control.FX.Monad.Except

Methods

bimap1 :: (a -> c) -> Except mark a b -> Except mark c b

bimap2 :: (b -> c) -> Except mark a b -> Except mark a c

(Eq e, Eq a) => Eq (Output (Except mark e) a)

Defined in Control.FX.Monad.Except

Methods

(==) :: Output (Except mark e) a -> Output (Except mark e) a -> Bool

(/=) :: Output (Except mark e) a -> Output (Except mark e) a -> Bool

MonadIdentity mark => Monad (Except mark e)

Defined in Control.FX.Monad.Except

Methods

(>>=) :: Except mark e a -> (a -> Except mark e b) -> Except mark e b

(>>) :: Except mark e a -> Except mark e b -> Except mark e b

return :: a -> Except mark e a

fail :: String -> Except mark e a

MonadIdentity mark => Functor (Except mark e)

Defined in Control.FX.Monad.Except

Methods

fmap :: (a -> b) -> Except mark e a -> Except mark e b

(<$) :: a -> Except mark e b -> Except mark e a

(Show e, Show a) => Show (Output (Except mark e) a)

Defined in Control.FX.Monad.Except

Methods

showsPrec :: Int -> Output (Except mark e) a -> ShowS

show :: Output (Except mark e) a -> String

showList :: [Output (Except mark e) a] -> ShowS

MonadIdentity mark => Applicative (Except mark e)

Defined in Control.FX.Monad.Except

Methods

pure :: a -> Except mark e a

(<*>) :: Except mark e (a -> b) -> Except mark e a -> Except mark e b

liftA2 :: (a -> b -> c) -> Except mark e a -> Except mark e b -> Except mark e c

(*>) :: Except mark e a -> Except mark e b -> Except mark e b

(<*) :: Except mark e a -> Except mark e b -> Except mark e a

Eq e => EqIn (Except mark e)

Defined in Control.FX.Monad.Except

Associated Types

data Context (Except mark e) :: Type

Methods

eqIn :: Eq a => Context (Except mark e) -> Except mark e a -> Except mark e a -> Bool

MonadIdentity mark => Commutant (Except mark e)

Defined in Control.FX.Monad.Except

Methods

commute :: Applicative f => Except mark e (f a) -> f (Except mark e a)

MonadIdentity mark => RunMonad (Except mark e)

Defined in Control.FX.Monad.Except

Associated Types

data Input (Except mark e) :: Type

data Output (Except mark e) a :: Type

Methods

run :: Input (Except mark e) -> Except mark e a -> Output (Except mark e) a

MonadIdentity mark => Central (Except mark e)

Defined in Control.FX.Monad.Except

(Eq e, Eq a) => Eq (Except mark e a)

Defined in Control.FX.Monad.Except

Methods

(==) :: Except mark e a -> Except mark e a -> Bool

(/=) :: Except mark e a -> Except mark e a -> Bool

(Show e, Show a) => Show (Except mark e a)

Defined in Control.FX.Monad.Except

Methods

showsPrec :: Int -> Except mark e a -> ShowS

show :: Except mark e a -> String

showList :: [Except mark e a] -> ShowS

newtype Context (Except mark e)

Defined in Control.FX.Monad.Except

newtype Context (Except mark e) = ExceptCtx {

• unExceptCtx :: mark ()

}

newtype Input (Except mark e)

Defined in Control.FX.Monad.Except

newtype Input (Except mark e) = ExceptIn {

• unExceptIn :: mark ()

}

newtype Output (Except mark e) a

Defined in Control.FX.Monad.Except

newtype Output (Except mark e) a = ExceptOut {

• unExceptOut :: Except mark e a

}

newtype WriteOnly (mark :: * -> *) (w :: *) (a :: *)

Concrete write-only state monad with state type w

Constructors

WriteOnly

Fields

• unWriteOnly :: Pair w a

Instances

(Monoid w, MonadIdentity mark) => MonadWriteOnly mark w (WriteOnly mark w)

Defined in Control.FX.Monad.WriteOnly

Methods

tell :: mark w -> WriteOnly mark w ()

draft :: WriteOnly mark w a -> WriteOnly mark w (Pair (mark w) a)

Eq (mark ()) => Eq (Context (WriteOnly mark w))

Defined in Control.FX.Monad.WriteOnly

Methods

(==) :: Context (WriteOnly mark w) -> Context (WriteOnly mark w) -> Bool

(/=) :: Context (WriteOnly mark w) -> Context (WriteOnly mark w) -> Bool

Eq (mark ()) => Eq (Input (WriteOnly mark w))

Defined in Control.FX.Monad.WriteOnly

Methods

(==) :: Input (WriteOnly mark w) -> Input (WriteOnly mark w) -> Bool

(/=) :: Input (WriteOnly mark w) -> Input (WriteOnly mark w) -> Bool

Show (mark ()) => Show (Context (WriteOnly mark w))

Defined in Control.FX.Monad.WriteOnly

Methods

showsPrec :: Int -> Context (WriteOnly mark w) -> ShowS

show :: Context (WriteOnly mark w) -> String

showList :: [Context (WriteOnly mark w)] -> ShowS

Show (mark ()) => Show (Input (WriteOnly mark w))

Defined in Control.FX.Monad.WriteOnly

Methods

showsPrec :: Int -> Input (WriteOnly mark w) -> ShowS

show :: Input (WriteOnly mark w) -> String

showList :: [Input (WriteOnly mark w)] -> ShowS

MonadIdentity mark => Bifunctor (WriteOnly mark)

Defined in Control.FX.Monad.WriteOnly

Methods

bimap1 :: (a -> c) -> WriteOnly mark a b -> WriteOnly mark c b

bimap2 :: (b -> c) -> WriteOnly mark a b -> WriteOnly mark a c

(Eq (mark w), Eq a) => Eq (Output (WriteOnly mark w) a)

Defined in Control.FX.Monad.WriteOnly

Methods

(==) :: Output (WriteOnly mark w) a -> Output (WriteOnly mark w) a -> Bool

(/=) :: Output (WriteOnly mark w) a -> Output (WriteOnly mark w) a -> Bool

(Monoid w, MonadIdentity mark) => Monad (WriteOnly mark w)

Defined in Control.FX.Monad.WriteOnly

Methods

(>>=) :: WriteOnly mark w a -> (a -> WriteOnly mark w b) -> WriteOnly mark w b

(>>) :: WriteOnly mark w a -> WriteOnly mark w b -> WriteOnly mark w b

return :: a -> WriteOnly mark w a

fail :: String -> WriteOnly mark w a

(Monoid w, MonadIdentity mark) => Functor (WriteOnly mark w)

Defined in Control.FX.Monad.WriteOnly

Methods

fmap :: (a -> b) -> WriteOnly mark w a -> WriteOnly mark w b

(<$) :: a -> WriteOnly mark w b -> WriteOnly mark w a

(Show (mark w), Show a) => Show (Output (WriteOnly mark w) a)

Defined in Control.FX.Monad.WriteOnly

Methods

showsPrec :: Int -> Output (WriteOnly mark w) a -> ShowS

show :: Output (WriteOnly mark w) a -> String

showList :: [Output (WriteOnly mark w) a] -> ShowS

(Monoid w, MonadIdentity mark) => Applicative (WriteOnly mark w)

Defined in Control.FX.Monad.WriteOnly

Methods

pure :: a -> WriteOnly mark w a

(<*>) :: WriteOnly mark w (a -> b) -> WriteOnly mark w a -> WriteOnly mark w b

liftA2 :: (a -> b -> c) -> WriteOnly mark w a -> WriteOnly mark w b -> WriteOnly mark w c

(*>) :: WriteOnly mark w a -> WriteOnly mark w b -> WriteOnly mark w b

(<*) :: WriteOnly mark w a -> WriteOnly mark w b -> WriteOnly mark w a

Eq w => EqIn (WriteOnly mark w)

Defined in Control.FX.Monad.WriteOnly

Associated Types

data Context (WriteOnly mark w) :: Type

Methods

eqIn :: Eq a => Context (WriteOnly mark w) -> WriteOnly mark w a -> WriteOnly mark w a -> Bool

(Monoid w, MonadIdentity mark) => Commutant (WriteOnly mark w)

Defined in Control.FX.Monad.WriteOnly

Methods

commute :: Applicative f => WriteOnly mark w (f a) -> f (WriteOnly mark w a)

(Monoid w, MonadIdentity mark) => RunMonad (WriteOnly mark w)

Defined in Control.FX.Monad.WriteOnly

Associated Types

data Input (WriteOnly mark w) :: Type

data Output (WriteOnly mark w) a :: Type

Methods

run :: Input (WriteOnly mark w) -> WriteOnly mark w a -> Output (WriteOnly mark w) a

(Monoid w, MonadIdentity mark) => Central (WriteOnly mark w)

Defined in Control.FX.Monad.WriteOnly

(Eq w, Eq a) => Eq (WriteOnly mark w a)

Defined in Control.FX.Monad.WriteOnly

Methods

(==) :: WriteOnly mark w a -> WriteOnly mark w a -> Bool

(/=) :: WriteOnly mark w a -> WriteOnly mark w a -> Bool

(Show w, Show a) => Show (WriteOnly mark w a)

Defined in Control.FX.Monad.WriteOnly

Methods

showsPrec :: Int -> WriteOnly mark w a -> ShowS

show :: WriteOnly mark w a -> String

showList :: [WriteOnly mark w a] -> ShowS

newtype Context (WriteOnly mark w)

Defined in Control.FX.Monad.WriteOnly

newtype Context (WriteOnly mark w) = WriteOnlyCtx {

• unWriteOnlyCtx :: mark ()

}

newtype Input (WriteOnly mark w)

Defined in Control.FX.Monad.WriteOnly

newtype Input (WriteOnly mark w) = WriteOnlyIn {

• unWriteOnlyIn :: mark ()

}

newtype Output (WriteOnly mark w) a

Defined in Control.FX.Monad.WriteOnly

newtype Output (WriteOnly mark w) a = WriteOnlyOut {

• unWriteOnlyOut :: Pair (mark w) a

}

data Halt (mark :: * -> *) (a :: *)

Concrete monad representing catastrophic failure mark e and producing values of type a

Constructors

Step a

Proceed

Halt

Bail out

Instances

MonadIdentity mark => MonadHalt mark (Halt mark)

Defined in Control.FX.Monad.Halt

Methods

halt :: mark () -> Halt mark a

Eq (mark ()) => Eq (Context (Halt mark))

Defined in Control.FX.Monad.Halt

Methods

(==) :: Context (Halt mark) -> Context (Halt mark) -> Bool

(/=) :: Context (Halt mark) -> Context (Halt mark) -> Bool

Eq (mark ()) => Eq (Input (Halt mark))

Defined in Control.FX.Monad.Halt

Methods

(==) :: Input (Halt mark) -> Input (Halt mark) -> Bool

(/=) :: Input (Halt mark) -> Input (Halt mark) -> Bool

MonadIdentity mark => Monad (Halt mark)

Defined in Control.FX.Monad.Halt

Methods

(>>=) :: Halt mark a -> (a -> Halt mark b) -> Halt mark b

(>>) :: Halt mark a -> Halt mark b -> Halt mark b

return :: a -> Halt mark a

fail :: String -> Halt mark a

MonadIdentity mark => Functor (Halt mark)

Defined in Control.FX.Monad.Halt

Methods

fmap :: (a -> b) -> Halt mark a -> Halt mark b

(<$) :: a -> Halt mark b -> Halt mark a

Show (mark ()) => Show (Context (Halt mark))

Defined in Control.FX.Monad.Halt

Methods

showsPrec :: Int -> Context (Halt mark) -> ShowS

show :: Context (Halt mark) -> String

showList :: [Context (Halt mark)] -> ShowS

Show (mark ()) => Show (Input (Halt mark))

Defined in Control.FX.Monad.Halt

Methods

showsPrec :: Int -> Input (Halt mark) -> ShowS

show :: Input (Halt mark) -> String

showList :: [Input (Halt mark)] -> ShowS

MonadIdentity mark => Applicative (Halt mark)

Defined in Control.FX.Monad.Halt

Methods

pure :: a -> Halt mark a

(<*>) :: Halt mark (a -> b) -> Halt mark a -> Halt mark b

liftA2 :: (a -> b -> c) -> Halt mark a -> Halt mark b -> Halt mark c

(*>) :: Halt mark a -> Halt mark b -> Halt mark b

(<*) :: Halt mark a -> Halt mark b -> Halt mark a

EqIn (Halt mark)

Defined in Control.FX.Monad.Halt

Associated Types

data Context (Halt mark) :: Type

Methods

eqIn :: Eq a => Context (Halt mark) -> Halt mark a -> Halt mark a -> Bool

MonadIdentity mark => Commutant (Halt mark)

Defined in Control.FX.Monad.Halt

Methods

commute :: Applicative f => Halt mark (f a) -> f (Halt mark a)

MonadIdentity mark => RunMonad (Halt mark)

Defined in Control.FX.Monad.Halt

Associated Types

data Input (Halt mark) :: Type

data Output (Halt mark) a :: Type

Methods

run :: Input (Halt mark) -> Halt mark a -> Output (Halt mark) a

MonadIdentity mark => Central (Halt mark)

Defined in Control.FX.Monad.Halt

Eq a => Eq (Output (Halt mark) a)

Defined in Control.FX.Monad.Halt

Methods

(==) :: Output (Halt mark) a -> Output (Halt mark) a -> Bool

(/=) :: Output (Halt mark) a -> Output (Halt mark) a -> Bool

Eq a => Eq (Halt mark a)

Defined in Control.FX.Monad.Halt

Methods

(==) :: Halt mark a -> Halt mark a -> Bool

(/=) :: Halt mark a -> Halt mark a -> Bool

Show a => Show (Output (Halt mark) a)

Defined in Control.FX.Monad.Halt

Methods

showsPrec :: Int -> Output (Halt mark) a -> ShowS

show :: Output (Halt mark) a -> String

showList :: [Output (Halt mark) a] -> ShowS

Show a => Show (Halt mark a)

Defined in Control.FX.Monad.Halt

Methods

showsPrec :: Int -> Halt mark a -> ShowS

show :: Halt mark a -> String

showList :: [Halt mark a] -> ShowS

data Context (Halt mark)

Defined in Control.FX.Monad.Halt

data Context (Halt mark) = HaltCtx {

• unHaltCtx :: mark ()

}

data Input (Halt mark)

Defined in Control.FX.Monad.Halt

data Input (Halt mark) = HaltIn {

• unHaltIn :: mark ()

}

data Output (Halt mark) a

Defined in Control.FX.Monad.Halt

data Output (Halt mark) a = HaltOut {

• unHaltOut :: Halt mark a

}

newtype AppendOnly (mark :: * -> *) (w :: *) (a :: *)

Concrete append-only state monad with state type w

Constructors

AppendOnly

Fields

• unAppendOnly :: w -> Pair w a

  f = unAppendOnly x must have the property that if f w1 = Pair w2 a, then there exists w such that w2 == w1 <> w. This cannot be enforced by the type, but the class instance methods for AppendOnly all preserve it.

Instances

(Monoid w, MonadIdentity mark) => MonadAppendOnly mark w (AppendOnly mark w)

Defined in Control.FX.Monad.AppendOnly

Methods

look :: AppendOnly mark w (mark w)

jot :: mark w -> AppendOnly mark w ()

Eq (mark ()) => Eq (Context (AppendOnly mark w))

Defined in Control.FX.Monad.AppendOnly

Methods

(==) :: Context (AppendOnly mark w) -> Context (AppendOnly mark w) -> Bool

(/=) :: Context (AppendOnly mark w) -> Context (AppendOnly mark w) -> Bool

Eq (mark ()) => Eq (Input (AppendOnly mark w))

Defined in Control.FX.Monad.AppendOnly

Methods

(==) :: Input (AppendOnly mark w) -> Input (AppendOnly mark w) -> Bool

(/=) :: Input (AppendOnly mark w) -> Input (AppendOnly mark w) -> Bool

Show (mark ()) => Show (Context (AppendOnly mark w))

Defined in Control.FX.Monad.AppendOnly

Methods

showsPrec :: Int -> Context (AppendOnly mark w) -> ShowS

show :: Context (AppendOnly mark w) -> String

showList :: [Context (AppendOnly mark w)] -> ShowS

Show (mark ()) => Show (Input (AppendOnly mark w))

Defined in Control.FX.Monad.AppendOnly

Methods

showsPrec :: Int -> Input (AppendOnly mark w) -> ShowS

show :: Input (AppendOnly mark w) -> String

showList :: [Input (AppendOnly mark w)] -> ShowS

(Eq (mark w), Eq a) => Eq (Output (AppendOnly mark w) a)

Defined in Control.FX.Monad.AppendOnly

Methods

(==) :: Output (AppendOnly mark w) a -> Output (AppendOnly mark w) a -> Bool

(/=) :: Output (AppendOnly mark w) a -> Output (AppendOnly mark w) a -> Bool

(Monoid w, MonadIdentity mark) => Monad (AppendOnly mark w)

Defined in Control.FX.Monad.AppendOnly

Methods

(>>=) :: AppendOnly mark w a -> (a -> AppendOnly mark w b) -> AppendOnly mark w b

(>>) :: AppendOnly mark w a -> AppendOnly mark w b -> AppendOnly mark w b

return :: a -> AppendOnly mark w a

fail :: String -> AppendOnly mark w a

(Monoid w, MonadIdentity mark) => Functor (AppendOnly mark w)

Defined in Control.FX.Monad.AppendOnly

Methods

fmap :: (a -> b) -> AppendOnly mark w a -> AppendOnly mark w b

(<$) :: a -> AppendOnly mark w b -> AppendOnly mark w a

(Show (mark w), Show a) => Show (Output (AppendOnly mark w) a)

Defined in Control.FX.Monad.AppendOnly

Methods

showsPrec :: Int -> Output (AppendOnly mark w) a -> ShowS

show :: Output (AppendOnly mark w) a -> String

showList :: [Output (AppendOnly mark w) a] -> ShowS

(Monoid w, MonadIdentity mark) => Applicative (AppendOnly mark w)

Defined in Control.FX.Monad.AppendOnly

Methods

pure :: a -> AppendOnly mark w a

(<*>) :: AppendOnly mark w (a -> b) -> AppendOnly mark w a -> AppendOnly mark w b

liftA2 :: (a -> b -> c) -> AppendOnly mark w a -> AppendOnly mark w b -> AppendOnly mark w c

(*>) :: AppendOnly mark w a -> AppendOnly mark w b -> AppendOnly mark w b

(<*) :: AppendOnly mark w a -> AppendOnly mark w b -> AppendOnly mark w a

(Eq w, Monoid w) => EqIn (AppendOnly mark w)

Defined in Control.FX.Monad.AppendOnly

Associated Types

data Context (AppendOnly mark w) :: Type

Methods

eqIn :: Eq a => Context (AppendOnly mark w) -> AppendOnly mark w a -> AppendOnly mark w a -> Bool

(Monoid w, MonadIdentity mark) => RunMonad (AppendOnly mark w)

Defined in Control.FX.Monad.AppendOnly

Associated Types

data Input (AppendOnly mark w) :: Type

data Output (AppendOnly mark w) a :: Type

Methods

run :: Input (AppendOnly mark w) -> AppendOnly mark w a -> Output (AppendOnly mark w) a

(Typeable w, Typeable a, Typeable mark) => Show (AppendOnly mark w a)

Defined in Control.FX.Monad.AppendOnly

Methods

showsPrec :: Int -> AppendOnly mark w a -> ShowS

show :: AppendOnly mark w a -> String

showList :: [AppendOnly mark w a] -> ShowS

newtype Context (AppendOnly mark w)

Defined in Control.FX.Monad.AppendOnly

newtype Context (AppendOnly mark w) = AppendOnlyCtx {

• unAppendOnlyCtx :: mark ()

}

newtype Input (AppendOnly mark w)

Defined in Control.FX.Monad.AppendOnly

newtype Input (AppendOnly mark w) = AppendOnlyIn {

• unAppendOnlyIn :: mark ()

}

newtype Output (AppendOnly mark w) a

Defined in Control.FX.Monad.AppendOnly

newtype Output (AppendOnly mark w) a = AppendOnlyOut {

• unAppendOnlyOut :: Pair (mark w) a

}

newtype WriteOnce (mark :: * -> *) (w :: *) (a :: *)

Concrete write-once state monad

Constructors

WriteOnce

Fields

• unWriteOnce :: LeftZero w -> Pair (LeftZero w) a

Instances

MonadIdentity mark => MonadWriteOnce mark w (WriteOnce mark w)

Defined in Control.FX.Monad.WriteOnce

Methods

etch :: mark w -> WriteOnce mark w Bool

press :: WriteOnce mark w (Maybe (mark w))

Eq (mark ()) => Eq (Context (WriteOnce mark w))

Defined in Control.FX.Monad.WriteOnce

Methods

(==) :: Context (WriteOnce mark w) -> Context (WriteOnce mark w) -> Bool

(/=) :: Context (WriteOnce mark w) -> Context (WriteOnce mark w) -> Bool

Eq (mark ()) => Eq (Input (WriteOnce mark w))

Defined in Control.FX.Monad.WriteOnce

Methods

(==) :: Input (WriteOnce mark w) -> Input (WriteOnce mark w) -> Bool

(/=) :: Input (WriteOnce mark w) -> Input (WriteOnce mark w) -> Bool

Show (mark ()) => Show (Context (WriteOnce mark w))

Defined in Control.FX.Monad.WriteOnce

Methods

showsPrec :: Int -> Context (WriteOnce mark w) -> ShowS

show :: Context (WriteOnce mark w) -> String

showList :: [Context (WriteOnce mark w)] -> ShowS

Show (mark ()) => Show (Input (WriteOnce mark w))

Defined in Control.FX.Monad.WriteOnce

Methods

showsPrec :: Int -> Input (WriteOnce mark w) -> ShowS

show :: Input (WriteOnce mark w) -> String

showList :: [Input (WriteOnce mark w)] -> ShowS

(Eq (mark (Maybe w)), Eq a) => Eq (Output (WriteOnce mark w) a)

Defined in Control.FX.Monad.WriteOnce

Methods

(==) :: Output (WriteOnce mark w) a -> Output (WriteOnce mark w) a -> Bool

(/=) :: Output (WriteOnce mark w) a -> Output (WriteOnce mark w) a -> Bool

MonadIdentity mark => Monad (WriteOnce mark w)

Defined in Control.FX.Monad.WriteOnce

Methods

(>>=) :: WriteOnce mark w a -> (a -> WriteOnce mark w b) -> WriteOnce mark w b

(>>) :: WriteOnce mark w a -> WriteOnce mark w b -> WriteOnce mark w b

return :: a -> WriteOnce mark w a

fail :: String -> WriteOnce mark w a

MonadIdentity mark => Functor (WriteOnce mark w)

Defined in Control.FX.Monad.WriteOnce

Methods

fmap :: (a -> b) -> WriteOnce mark w a -> WriteOnce mark w b

(<$) :: a -> WriteOnce mark w b -> WriteOnce mark w a

(Show (mark (Maybe w)), Show a) => Show (Output (WriteOnce mark w) a)

Defined in Control.FX.Monad.WriteOnce

Methods

showsPrec :: Int -> Output (WriteOnce mark w) a -> ShowS

show :: Output (WriteOnce mark w) a -> String

showList :: [Output (WriteOnce mark w) a] -> ShowS

MonadIdentity mark => Applicative (WriteOnce mark w)

Defined in Control.FX.Monad.WriteOnce

Methods

pure :: a -> WriteOnce mark w a

(<*>) :: WriteOnce mark w (a -> b) -> WriteOnce mark w a -> WriteOnce mark w b

liftA2 :: (a -> b -> c) -> WriteOnce mark w a -> WriteOnce mark w b -> WriteOnce mark w c

(*>) :: WriteOnce mark w a -> WriteOnce mark w b -> WriteOnce mark w b

(<*) :: WriteOnce mark w a -> WriteOnce mark w b -> WriteOnce mark w a

(Eq w, Monoid w) => EqIn (WriteOnce mark w)

Defined in Control.FX.Monad.WriteOnce

Associated Types

data Context (WriteOnce mark w) :: Type

Methods

eqIn :: Eq a => Context (WriteOnce mark w) -> WriteOnce mark w a -> WriteOnce mark w a -> Bool

MonadIdentity mark => RunMonad (WriteOnce mark w)

Defined in Control.FX.Monad.WriteOnce

Associated Types

data Input (WriteOnce mark w) :: Type

data Output (WriteOnce mark w) a :: Type

Methods

run :: Input (WriteOnce mark w) -> WriteOnce mark w a -> Output (WriteOnce mark w) a

(Typeable w, Typeable a, Typeable mark) => Show (WriteOnce mark w a)

Defined in Control.FX.Monad.WriteOnce

Methods

showsPrec :: Int -> WriteOnce mark w a -> ShowS

show :: WriteOnce mark w a -> String

showList :: [WriteOnce mark w a] -> ShowS

newtype Context (WriteOnce mark w)

Defined in Control.FX.Monad.WriteOnce

newtype Context (WriteOnce mark w) = WriteOnceCtx {

• unWriteOnceCtx :: mark ()

}

newtype Input (WriteOnce mark w)

Defined in Control.FX.Monad.WriteOnce

newtype Input (WriteOnce mark w) = WriteOnceIn {

• unWriteOnceIn :: mark ()

}

newtype Output (WriteOnce mark w) a

Defined in Control.FX.Monad.WriteOnce

newtype Output (WriteOnce mark w) a = WriteOnceOut {

• unWriteOnceOut :: Pair (mark (Maybe w)) a

}

Transformers

newtype IdentityT (m :: * -> *) (a :: *)

Concrete identity monad transformer

Constructors

IdentityT

Fields

• unIdentityT :: m a

Instances

LiftLocal IdentityT

Defined in Control.FX.Monad.Trans.IdentityT

Methods

liftLocal :: Monad m => Local r m (OutputT IdentityT a) -> Local r (IdentityT m) a

LiftDraft IdentityT

Defined in Control.FX.Monad.Trans.IdentityT

Methods

liftDraft :: (Monad m, Monoid w) => Draft w m (OutputT IdentityT a) -> Draft w (IdentityT m) a

LiftCatch IdentityT

Defined in Control.FX.Monad.Trans.IdentityT

Methods

liftCatch :: Monad m => Catch e m (OutputT IdentityT a) -> Catch e (IdentityT m) a

RunMonadTrans IdentityT

Defined in Control.FX.Monad.Trans.IdentityT

Associated Types

data InputT IdentityT :: Type

data OutputT IdentityT a :: Type

Methods

runT :: Monad m => InputT IdentityT -> IdentityT m a -> m (OutputT IdentityT a)

MonadTrans IdentityT

Defined in Control.FX.Monad.Trans.IdentityT

Methods

lift :: Monad m => m a -> IdentityT m a

MonadFunctor IdentityT

Defined in Control.FX.Monad.Trans.IdentityT

Methods

hoist :: (Monad m, Monad n) => (forall u. m u -> n u) -> IdentityT m a -> IdentityT n a

ComposableT IdentityT

Defined in Control.FX.Monad.Trans.ComposeT

Associated Types

data ComposeT IdentityT t2 m a :: Type

Methods

toComposeT :: IdentityT (t2 m) a -> ComposeT IdentityT t2 m a

unComposeT :: ComposeT IdentityT t2 m a -> IdentityT (t2 m) a

OverableT IdentityT

Defined in Control.FX.Monad.Trans.Trans.OverTT

Associated Types

data OverTT IdentityT u t m a :: Type

Methods

toOverTT :: IdentityT (u t m) a -> OverTT IdentityT u t m a

unOverTT :: OverTT IdentityT u t m a -> IdentityT (u t m) a

MonadPrompt mark p m => MonadPrompt mark p (IdentityT m)

Defined in Control.FX.Monad.Trans.IdentityT

Methods

prompt :: mark (p a) -> IdentityT m (mark a)

MonadWriteOnce mark w m => MonadWriteOnce mark w (IdentityT m)

Defined in Control.FX.Monad.Trans.IdentityT

Methods

etch :: mark w -> IdentityT m Bool

press :: IdentityT m (Maybe (mark w))

MonadAppendOnly mark w m => MonadAppendOnly mark w (IdentityT m)

Defined in Control.FX.Monad.Trans.IdentityT

Methods

look :: IdentityT m (mark w)

jot :: mark w -> IdentityT m ()

MonadReadOnly mark r m => MonadReadOnly mark r (IdentityT m)

Defined in Control.FX.Monad.Trans.IdentityT

Methods

ask :: IdentityT m (mark r)

local :: (mark r -> mark r) -> IdentityT m a -> IdentityT m a

(MonadWriteOnly mark w m, Monoid w) => MonadWriteOnly mark w (IdentityT m)

Defined in Control.FX.Monad.Trans.IdentityT

Methods

tell :: mark w -> IdentityT m ()

draft :: IdentityT m a -> IdentityT m (Pair (mark w) a)

MonadState mark s m => MonadState mark s (IdentityT m)

Defined in Control.FX.Monad.Trans.IdentityT

Methods

get :: IdentityT m (mark s)

put :: mark s -> IdentityT m ()

MonadExcept mark e m => MonadExcept mark e (IdentityT m)

Defined in Control.FX.Monad.Trans.IdentityT

Methods

throw :: mark e -> IdentityT m a

catch :: IdentityT m a -> (mark e -> IdentityT m a) -> IdentityT m a

MonadHalt mark m => MonadHalt mark (IdentityT m)

Defined in Control.FX.Monad.Trans.IdentityT

Methods

halt :: mark () -> IdentityT m a

Eq (Context m) => Eq (Context (IdentityT m))

Defined in Control.FX.Monad.Trans.IdentityT

Methods

(==) :: Context (IdentityT m) -> Context (IdentityT m) -> Bool

(/=) :: Context (IdentityT m) -> Context (IdentityT m) -> Bool

Eq (InputT IdentityT)

Defined in Control.FX.Monad.Trans.IdentityT

Methods

(==) :: InputT IdentityT -> InputT IdentityT -> Bool

(/=) :: InputT IdentityT -> InputT IdentityT -> Bool

Monad m => Monad (IdentityT m)

Defined in Control.FX.Monad.Trans.IdentityT

Methods

(>>=) :: IdentityT m a -> (a -> IdentityT m b) -> IdentityT m b

(>>) :: IdentityT m a -> IdentityT m b -> IdentityT m b

return :: a -> IdentityT m a

fail :: String -> IdentityT m a

Functor m => Functor (IdentityT m)

Defined in Control.FX.Monad.Trans.IdentityT

Methods

fmap :: (a -> b) -> IdentityT m a -> IdentityT m b

(<$) :: a -> IdentityT m b -> IdentityT m a

Show (Context m) => Show (Context (IdentityT m))

Defined in Control.FX.Monad.Trans.IdentityT

Methods

showsPrec :: Int -> Context (IdentityT m) -> ShowS

show :: Context (IdentityT m) -> String

showList :: [Context (IdentityT m)] -> ShowS

Show (InputT IdentityT)

Defined in Control.FX.Monad.Trans.IdentityT

Methods

showsPrec :: Int -> InputT IdentityT -> ShowS

show :: InputT IdentityT -> String

showList :: [InputT IdentityT] -> ShowS

Applicative m => Applicative (IdentityT m)

Defined in Control.FX.Monad.Trans.IdentityT

Methods

pure :: a -> IdentityT m a

(<*>) :: IdentityT m (a -> b) -> IdentityT m a -> IdentityT m b

liftA2 :: (a -> b -> c) -> IdentityT m a -> IdentityT m b -> IdentityT m c

(*>) :: IdentityT m a -> IdentityT m b -> IdentityT m b

(<*) :: IdentityT m a -> IdentityT m b -> IdentityT m a

(EqIn m, Functor m) => EqIn (IdentityT m)

Defined in Control.FX.Monad.Trans.IdentityT

Associated Types

data Context (IdentityT m) :: Type

Methods

eqIn :: Eq a => Context (IdentityT m) -> IdentityT m a -> IdentityT m a -> Bool

Central c => Commutant (IdentityT c)

Defined in Control.FX.Monad.Trans.IdentityT

Methods

commute :: Applicative f => IdentityT c (f a) -> f (IdentityT c a)

(MonadIdentity m, Central m) => MonadIdentity (IdentityT m)

Defined in Control.FX.Monad.Trans.IdentityT

Methods

unwrap :: IdentityT m a -> a

Central c => Central (IdentityT c)

Defined in Control.FX.Monad.Trans.IdentityT

Eq a => Eq (OutputT IdentityT a)

Defined in Control.FX.Monad.Trans.IdentityT

Methods

(==) :: OutputT IdentityT a -> OutputT IdentityT a -> Bool

(/=) :: OutputT IdentityT a -> OutputT IdentityT a -> Bool

(MonadIdentity m, Eq a) => Eq (IdentityT m a)

Defined in Control.FX.Monad.Trans.IdentityT

Methods

(==) :: IdentityT m a -> IdentityT m a -> Bool

(/=) :: IdentityT m a -> IdentityT m a -> Bool

Show a => Show (OutputT IdentityT a)

Defined in Control.FX.Monad.Trans.IdentityT

Methods

showsPrec :: Int -> OutputT IdentityT a -> ShowS

show :: OutputT IdentityT a -> String

showList :: [OutputT IdentityT a] -> ShowS

Show (m a) => Show (IdentityT m a)

Defined in Control.FX.Monad.Trans.IdentityT

Methods

showsPrec :: Int -> IdentityT m a -> ShowS

show :: IdentityT m a -> String

showList :: [IdentityT m a] -> ShowS

(MonadIdentity m, Semigroup a) => Semigroup (IdentityT m a)

Defined in Control.FX.Monad.Trans.IdentityT

Methods

(<>) :: IdentityT m a -> IdentityT m a -> IdentityT m a

sconcat :: NonEmpty (IdentityT m a) -> IdentityT m a

stimes :: Integral b => b -> IdentityT m a -> IdentityT m a

(MonadIdentity m, Monoid a) => Monoid (IdentityT m a)

Defined in Control.FX.Monad.Trans.IdentityT

Methods

mempty :: IdentityT m a

mappend :: IdentityT m a -> IdentityT m a -> IdentityT m a

mconcat :: [IdentityT m a] -> IdentityT m a

data InputT IdentityT

Defined in Control.FX.Monad.Trans.IdentityT

data InputT IdentityT = IdentityTIn {

• unIdentityTIn :: ()

}

data OutputT IdentityT a

Defined in Control.FX.Monad.Trans.IdentityT

data OutputT IdentityT a = IdentityTOut {

• unIdentityTOut :: Identity a

}

newtype ComposeT IdentityT t2 m a

Defined in Control.FX.Monad.Trans.ComposeT

newtype ComposeT IdentityT t2 m a = ComposeT_IdentityT {

• unComposeT_IdentityT :: IdentityT (t2 m) a

}

newtype OverTT IdentityT u t m a

Defined in Control.FX.Monad.Trans.Trans.OverTT

newtype OverTT IdentityT u t m a = OverTT_IdentityT {

• unOverTT_IdentityT :: IdentityT (u t m) a

}

data Context (IdentityT m)

Defined in Control.FX.Monad.Trans.IdentityT

data Context (IdentityT m) = IdentityTCtx {

• unIdentityTCtx :: Context m

}

runIdentityT :: Monad m => IdentityT m a -> m (Identity a)

class MonadTrans t1 => ComposableT t1 where

Class representing monad transformers which can be composed on top of an arbitrary monad transformer.

Associated Types

data ComposeT (t1 :: (* -> *) -> * -> *) (t2 :: (* -> *) -> * -> *) (m :: * -> *) (a :: *)

Concrete composite monad transformer

Methods

toComposeT :: t1 (t2 m) a -> ComposeT t1 t2 m a

unComposeT :: ComposeT t1 t2 m a -> t1 (t2 m) a

Instances

ComposableT IdentityT

Defined in Control.FX.Monad.Trans.ComposeT

Associated Types

data ComposeT IdentityT t2 m a :: Type

Methods

toComposeT :: IdentityT (t2 m) a -> ComposeT IdentityT t2 m a

unComposeT :: ComposeT IdentityT t2 m a -> IdentityT (t2 m) a

MonadIdentity mark => ComposableT (HaltT mark)

Defined in Control.FX.Monad.Trans.ComposeT

Associated Types

data ComposeT (HaltT mark) t2 m a :: Type

Methods

toComposeT :: HaltT mark (t2 m) a -> ComposeT (HaltT mark) t2 m a

unComposeT :: ComposeT (HaltT mark) t2 m a -> HaltT mark (t2 m) a

(MonadIdentity mark, Monoid w) => ComposableT (WriteOnlyT mark w)

Defined in Control.FX.Monad.Trans.ComposeT

Associated Types

data ComposeT (WriteOnlyT mark w) t2 m a :: Type

Methods

toComposeT :: WriteOnlyT mark w (t2 m) a -> ComposeT (WriteOnlyT mark w) t2 m a

unComposeT :: ComposeT (WriteOnlyT mark w) t2 m a -> WriteOnlyT mark w (t2 m) a

MonadIdentity mark => ComposableT (WriteOnceT mark w)

Defined in Control.FX.Monad.Trans.ComposeT

Associated Types

data ComposeT (WriteOnceT mark w) t2 m a :: Type

Methods

toComposeT :: WriteOnceT mark w (t2 m) a -> ComposeT (WriteOnceT mark w) t2 m a

unComposeT :: ComposeT (WriteOnceT mark w) t2 m a -> WriteOnceT mark w (t2 m) a

MonadIdentity mark => ComposableT (StateT mark s)

Defined in Control.FX.Monad.Trans.ComposeT

Associated Types

data ComposeT (StateT mark s) t2 m a :: Type

Methods

toComposeT :: StateT mark s (t2 m) a -> ComposeT (StateT mark s) t2 m a

unComposeT :: ComposeT (StateT mark s) t2 m a -> StateT mark s (t2 m) a

MonadIdentity mark => ComposableT (ReadOnlyT mark r)

Defined in Control.FX.Monad.Trans.ComposeT

Associated Types

data ComposeT (ReadOnlyT mark r) t2 m a :: Type

Methods

toComposeT :: ReadOnlyT mark r (t2 m) a -> ComposeT (ReadOnlyT mark r) t2 m a

unComposeT :: ComposeT (ReadOnlyT mark r) t2 m a -> ReadOnlyT mark r (t2 m) a

MonadIdentity mark => ComposableT (ExceptT mark e)

Defined in Control.FX.Monad.Trans.ComposeT

Associated Types

data ComposeT (ExceptT mark e) t2 m a :: Type

Methods

toComposeT :: ExceptT mark e (t2 m) a -> ComposeT (ExceptT mark e) t2 m a

unComposeT :: ComposeT (ExceptT mark e) t2 m a -> ExceptT mark e (t2 m) a

(MonadIdentity mark, Monoid w) => ComposableT (AppendOnlyT mark w)

Defined in Control.FX.Monad.Trans.ComposeT

Associated Types

data ComposeT (AppendOnlyT mark w) t2 m a :: Type

Methods

toComposeT :: AppendOnlyT mark w (t2 m) a -> ComposeT (AppendOnlyT mark w) t2 m a

unComposeT :: ComposeT (AppendOnlyT mark w) t2 m a -> AppendOnlyT mark w (t2 m) a

newtype ReadOnlyT (mark :: * -> *) (r :: *) (m :: * -> *) (a :: *)

Concrete ReadOnly monad transformer

Constructors

ReadOnlyT

Fields

• unReadOnlyT :: ReadOnly mark r (m a)

Instances

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadPrompt mark p m, Commutant mark1) => MonadPrompt mark p (ReadOnlyT mark1 r m)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

prompt :: mark (p a) -> ReadOnlyT mark1 r m (mark a)

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnce mark w m, Commutant mark1) => MonadWriteOnce mark w (ReadOnlyT mark1 r m)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

etch :: mark w -> ReadOnlyT mark1 r m Bool

press :: ReadOnlyT mark1 r m (Maybe (mark w))

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadAppendOnly mark w m, Commutant mark1, Monoid w) => MonadAppendOnly mark w (ReadOnlyT mark1 r m)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

look :: ReadOnlyT mark1 r m (mark w)

jot :: mark w -> ReadOnlyT mark1 r m ()

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadReadOnly mark r m, Commutant mark1) => MonadReadOnly mark r (ReadOnlyT mark1 r1 m)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

ask :: ReadOnlyT mark1 r1 m (mark r)

local :: (mark r -> mark r) -> ReadOnlyT mark1 r1 m a -> ReadOnlyT mark1 r1 m a

(Monad m, MonadIdentity mark) => MonadReadOnly mark r (ReadOnlyT mark r m)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

ask :: ReadOnlyT mark r m (mark r)

local :: (mark r -> mark r) -> ReadOnlyT mark r m a -> ReadOnlyT mark r m a

(Monad m, MonadTrans t2, MonadIdentity mark) => MonadReadOnly mark r (ComposeT (ReadOnlyT mark r) t2 m)

Defined in Control.FX.Monad.Trans.ComposeT

Methods

ask :: ComposeT (ReadOnlyT mark r) t2 m (mark r)

local :: (mark r -> mark r) -> ComposeT (ReadOnlyT mark r) t2 m a -> ComposeT (ReadOnlyT mark r) t2 m a

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnly mark w m, Commutant mark1, Monoid w) => MonadWriteOnly mark w (ReadOnlyT mark1 r m)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

tell :: mark w -> ReadOnlyT mark1 r m ()

draft :: ReadOnlyT mark1 r m a -> ReadOnlyT mark1 r m (Pair (mark w) a)

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadState mark s m, Commutant mark1) => MonadState mark s (ReadOnlyT mark1 r m)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

get :: ReadOnlyT mark1 r m (mark s)

put :: mark s -> ReadOnlyT mark1 r m ()

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadExcept mark e m, Commutant mark1) => MonadExcept mark e (ReadOnlyT mark1 r m)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

throw :: mark e -> ReadOnlyT mark1 r m a

catch :: ReadOnlyT mark1 r m a -> (mark e -> ReadOnlyT mark1 r m a) -> ReadOnlyT mark1 r m a

(Monad m, MonadTrans t, MonadTransTrans u, MonadIdentity mark) => MonadReadOnly mark r (OverTT (ReadOnlyT mark r) u t m)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Methods

ask :: OverTT (ReadOnlyT mark r) u t m (mark r)

local :: (mark r -> mark r) -> OverTT (ReadOnlyT mark r) u t m a -> OverTT (ReadOnlyT mark r) u t m a

(Monad m, MonadIdentity mark1, Commutant mark1, MonadIdentity mark, MonadHalt mark m) => MonadHalt mark (ReadOnlyT mark1 r m)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

halt :: mark () -> ReadOnlyT mark1 r m a

(Eq (mark r), Eq (Context m)) => Eq (Context (ReadOnlyT mark r m))

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

(==) :: Context (ReadOnlyT mark r m) -> Context (ReadOnlyT mark r m) -> Bool

(/=) :: Context (ReadOnlyT mark r m) -> Context (ReadOnlyT mark r m) -> Bool

Eq (mark r) => Eq (InputT (ReadOnlyT mark r))

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

(==) :: InputT (ReadOnlyT mark r) -> InputT (ReadOnlyT mark r) -> Bool

(/=) :: InputT (ReadOnlyT mark r) -> InputT (ReadOnlyT mark r) -> Bool

MonadIdentity mark => Monad (OutputT (ReadOnlyT mark r))

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

(>>=) :: OutputT (ReadOnlyT mark r) a -> (a -> OutputT (ReadOnlyT mark r) b) -> OutputT (ReadOnlyT mark r) b

(>>) :: OutputT (ReadOnlyT mark r) a -> OutputT (ReadOnlyT mark r) b -> OutputT (ReadOnlyT mark r) b

return :: a -> OutputT (ReadOnlyT mark r) a

fail :: String -> OutputT (ReadOnlyT mark r) a

MonadIdentity mark => Functor (OutputT (ReadOnlyT mark r))

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

fmap :: (a -> b) -> OutputT (ReadOnlyT mark r) a -> OutputT (ReadOnlyT mark r) b

(<$) :: a -> OutputT (ReadOnlyT mark r) b -> OutputT (ReadOnlyT mark r) a

(Show (mark r), Show (Context m)) => Show (Context (ReadOnlyT mark r m))

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

showsPrec :: Int -> Context (ReadOnlyT mark r m) -> ShowS

show :: Context (ReadOnlyT mark r m) -> String

showList :: [Context (ReadOnlyT mark r m)] -> ShowS

Show (mark r) => Show (InputT (ReadOnlyT mark r))

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

showsPrec :: Int -> InputT (ReadOnlyT mark r) -> ShowS

show :: InputT (ReadOnlyT mark r) -> String

showList :: [InputT (ReadOnlyT mark r)] -> ShowS

MonadIdentity mark => Applicative (OutputT (ReadOnlyT mark r))

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

pure :: a -> OutputT (ReadOnlyT mark r) a

(<*>) :: OutputT (ReadOnlyT mark r) (a -> b) -> OutputT (ReadOnlyT mark r) a -> OutputT (ReadOnlyT mark r) b

liftA2 :: (a -> b -> c) -> OutputT (ReadOnlyT mark r) a -> OutputT (ReadOnlyT mark r) b -> OutputT (ReadOnlyT mark r) c

(*>) :: OutputT (ReadOnlyT mark r) a -> OutputT (ReadOnlyT mark r) b -> OutputT (ReadOnlyT mark r) b

(<*) :: OutputT (ReadOnlyT mark r) a -> OutputT (ReadOnlyT mark r) b -> OutputT (ReadOnlyT mark r) a

MonadIdentity mark => MonadIdentity (OutputT (ReadOnlyT mark r))

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

unwrap :: OutputT (ReadOnlyT mark r) a -> a

Eq (mark a) => Eq (OutputT (ReadOnlyT mark r) a)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

(==) :: OutputT (ReadOnlyT mark r) a -> OutputT (ReadOnlyT mark r) a -> Bool

(/=) :: OutputT (ReadOnlyT mark r) a -> OutputT (ReadOnlyT mark r) a -> Bool

Show (mark a) => Show (OutputT (ReadOnlyT mark r) a)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

showsPrec :: Int -> OutputT (ReadOnlyT mark r) a -> ShowS

show :: OutputT (ReadOnlyT mark r) a -> String

showList :: [OutputT (ReadOnlyT mark r) a] -> ShowS

(Semigroup a, MonadIdentity mark) => Semigroup (OutputT (ReadOnlyT mark r) a)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

(<>) :: OutputT (ReadOnlyT mark r) a -> OutputT (ReadOnlyT mark r) a -> OutputT (ReadOnlyT mark r) a

sconcat :: NonEmpty (OutputT (ReadOnlyT mark r) a) -> OutputT (ReadOnlyT mark r) a

stimes :: Integral b => b -> OutputT (ReadOnlyT mark r) a -> OutputT (ReadOnlyT mark r) a

(Monoid a, MonadIdentity mark) => Monoid (OutputT (ReadOnlyT mark r) a)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

mempty :: OutputT (ReadOnlyT mark r) a

mappend :: OutputT (ReadOnlyT mark r) a -> OutputT (ReadOnlyT mark r) a -> OutputT (ReadOnlyT mark r) a

mconcat :: [OutputT (ReadOnlyT mark r) a] -> OutputT (ReadOnlyT mark r) a

(MonadIdentity mark, Commutant mark) => LiftLocal (ReadOnlyT mark r)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

liftLocal :: Monad m => Local r0 m (OutputT (ReadOnlyT mark r) a) -> Local r0 (ReadOnlyT mark r m) a

(MonadIdentity mark, Commutant mark) => LiftDraft (ReadOnlyT mark r)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

liftDraft :: (Monad m, Monoid w) => Draft w m (OutputT (ReadOnlyT mark r) a) -> Draft w (ReadOnlyT mark r m) a

(MonadIdentity mark, Commutant mark) => LiftCatch (ReadOnlyT mark r)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

liftCatch :: Monad m => Catch e m (OutputT (ReadOnlyT mark r) a) -> Catch e (ReadOnlyT mark r m) a

(MonadIdentity mark, Commutant mark) => RunMonadTrans (ReadOnlyT mark r)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Associated Types

data InputT (ReadOnlyT mark r) :: Type

data OutputT (ReadOnlyT mark r) a :: Type

Methods

runT :: Monad m => InputT (ReadOnlyT mark r) -> ReadOnlyT mark r m a -> m (OutputT (ReadOnlyT mark r) a)

MonadIdentity mark => MonadTrans (ReadOnlyT mark r)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

lift :: Monad m => m a -> ReadOnlyT mark r m a

MonadIdentity mark => MonadFunctor (ReadOnlyT mark r)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

hoist :: (Monad m, Monad n) => (forall u. m u -> n u) -> ReadOnlyT mark r m a -> ReadOnlyT mark r n a

MonadIdentity mark => ComposableT (ReadOnlyT mark r)

Defined in Control.FX.Monad.Trans.ComposeT

Associated Types

data ComposeT (ReadOnlyT mark r) t2 m a :: Type

Methods

toComposeT :: ReadOnlyT mark r (t2 m) a -> ComposeT (ReadOnlyT mark r) t2 m a

unComposeT :: ComposeT (ReadOnlyT mark r) t2 m a -> ReadOnlyT mark r (t2 m) a

MonadIdentity mark => OverableT (ReadOnlyT mark r)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Associated Types

data OverTT (ReadOnlyT mark r) u t m a :: Type

Methods

toOverTT :: ReadOnlyT mark r (u t m) a -> OverTT (ReadOnlyT mark r) u t m a

unOverTT :: OverTT (ReadOnlyT mark r) u t m a -> ReadOnlyT mark r (u t m) a

(Monad m, MonadIdentity mark) => Monad (ReadOnlyT mark r m)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

(>>=) :: ReadOnlyT mark r m a -> (a -> ReadOnlyT mark r m b) -> ReadOnlyT mark r m b

(>>) :: ReadOnlyT mark r m a -> ReadOnlyT mark r m b -> ReadOnlyT mark r m b

return :: a -> ReadOnlyT mark r m a

fail :: String -> ReadOnlyT mark r m a

(Functor m, MonadIdentity mark) => Functor (ReadOnlyT mark r m)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

fmap :: (a -> b) -> ReadOnlyT mark r m a -> ReadOnlyT mark r m b

(<$) :: a -> ReadOnlyT mark r m b -> ReadOnlyT mark r m a

(Applicative m, MonadIdentity mark) => Applicative (ReadOnlyT mark r m)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

pure :: a -> ReadOnlyT mark r m a

(<*>) :: ReadOnlyT mark r m (a -> b) -> ReadOnlyT mark r m a -> ReadOnlyT mark r m b

liftA2 :: (a -> b -> c) -> ReadOnlyT mark r m a -> ReadOnlyT mark r m b -> ReadOnlyT mark r m c

(*>) :: ReadOnlyT mark r m a -> ReadOnlyT mark r m b -> ReadOnlyT mark r m b

(<*) :: ReadOnlyT mark r m a -> ReadOnlyT mark r m b -> ReadOnlyT mark r m a

(EqIn m, Functor m, MonadIdentity mark) => EqIn (ReadOnlyT mark r m)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Associated Types

data Context (ReadOnlyT mark r m) :: Type

Methods

eqIn :: Eq a => Context (ReadOnlyT mark r m) -> ReadOnlyT mark r m a -> ReadOnlyT mark r m a -> Bool

(Typeable r, Typeable m, Typeable a, Typeable mark) => Show (ReadOnlyT mark r m a)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

showsPrec :: Int -> ReadOnlyT mark r m a -> ShowS

show :: ReadOnlyT mark r m a -> String

showList :: [ReadOnlyT mark r m a] -> ShowS

newtype InputT (ReadOnlyT mark r)

Defined in Control.FX.Monad.Trans.ReadOnlyT

newtype InputT (ReadOnlyT mark r) = ReadOnlyTIn {

• unReadOnlyTIn :: mark r

}

newtype OutputT (ReadOnlyT mark r) a

Defined in Control.FX.Monad.Trans.ReadOnlyT

newtype OutputT (ReadOnlyT mark r) a = ReadOnlyTOut {

• unReadOnlyTOut :: mark a

}

newtype ComposeT (ReadOnlyT mark r) t2 m a

Defined in Control.FX.Monad.Trans.ComposeT

newtype ComposeT (ReadOnlyT mark r) t2 m a = ComposeT_ReadOnlyT {

• unComposeT_ReadOnlyT :: ReadOnlyT mark r (t2 m) a

}

newtype OverTT (ReadOnlyT mark r) u t m a

Defined in Control.FX.Monad.Trans.Trans.OverTT

newtype OverTT (ReadOnlyT mark r) u t m a = OverTT_ReadOnlyT {

• unOverTT_ReadOnlyT :: ReadOnlyT mark r (u t m) a

}

newtype Context (ReadOnlyT mark r m)

Defined in Control.FX.Monad.Trans.ReadOnlyT

newtype Context (ReadOnlyT mark r m) = ReadOnlyTCtx {

• unReadOnlyTCtx :: (mark r, Context m)

}

runReadOnlyT :: (Monad m, MonadIdentity mark, Commutant mark) => mark r -> ReadOnlyT mark r m a -> m (mark a)

newtype StateT (mark :: * -> *) (s :: *) (m :: * -> *) (a :: *)

Concrete State monad transformer

Constructors

StateT

Fields

• unStateT :: s -> m (Pair s a)

Instances

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadPrompt mark p m) => MonadPrompt mark p (StateT mark1 s m)

Defined in Control.FX.Monad.Trans.StateT

Methods

prompt :: mark (p a) -> StateT mark1 s m (mark a)

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnce mark w m) => MonadWriteOnce mark w (StateT mark1 s m)

Defined in Control.FX.Monad.Trans.StateT

Methods

etch :: mark w -> StateT mark1 s m Bool

press :: StateT mark1 s m (Maybe (mark w))

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadAppendOnly mark w m, Monoid w) => MonadAppendOnly mark w (StateT mark1 s m)

Defined in Control.FX.Monad.Trans.StateT

Methods

look :: StateT mark1 s m (mark w)

jot :: mark w -> StateT mark1 s m ()

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadReadOnly mark r m) => MonadReadOnly mark r (StateT mark1 s m)

Defined in Control.FX.Monad.Trans.StateT

Methods

ask :: StateT mark1 s m (mark r)

local :: (mark r -> mark r) -> StateT mark1 s m a -> StateT mark1 s m a

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnly mark w m, Monoid w) => MonadWriteOnly mark w (StateT mark1 s m)

Defined in Control.FX.Monad.Trans.StateT

Methods

tell :: mark w -> StateT mark1 s m ()

draft :: StateT mark1 s m a -> StateT mark1 s m (Pair (mark w) a)

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadState mark s m) => MonadState mark s (StateT mark1 s1 m)

Defined in Control.FX.Monad.Trans.StateT

Methods

get :: StateT mark1 s1 m (mark s)

put :: mark s -> StateT mark1 s1 m ()

(Monad m, MonadIdentity mark) => MonadState mark s (StateT mark s m)

Defined in Control.FX.Monad.Trans.StateT

Methods

get :: StateT mark s m (mark s)

put :: mark s -> StateT mark s m ()

(Monad m, MonadTrans t2, MonadIdentity mark) => MonadState mark s (ComposeT (StateT mark s) t2 m)

Defined in Control.FX.Monad.Trans.ComposeT

Methods

get :: ComposeT (StateT mark s) t2 m (mark s)

put :: mark s -> ComposeT (StateT mark s) t2 m ()

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadExcept mark e m) => MonadExcept mark e (StateT mark1 s m)

Defined in Control.FX.Monad.Trans.StateT

Methods

throw :: mark e -> StateT mark1 s m a

catch :: StateT mark1 s m a -> (mark e -> StateT mark1 s m a) -> StateT mark1 s m a

(Monad m, MonadTrans t, MonadTransTrans u, MonadIdentity mark) => MonadState mark s (OverTT (StateT mark s) u t m)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Methods

get :: OverTT (StateT mark s) u t m (mark s)

put :: mark s -> OverTT (StateT mark s) u t m ()

(Monad m, MonadIdentity mark1, MonadIdentity mark, MonadHalt mark m) => MonadHalt mark (StateT mark1 s m)

Defined in Control.FX.Monad.Trans.StateT

Methods

halt :: mark () -> StateT mark1 s m a

(Eq (mark s), Eq (Context m)) => Eq (Context (StateT mark s m))

Defined in Control.FX.Monad.Trans.StateT

Methods

(==) :: Context (StateT mark s m) -> Context (StateT mark s m) -> Bool

(/=) :: Context (StateT mark s m) -> Context (StateT mark s m) -> Bool

Eq (mark s) => Eq (InputT (StateT mark s))

Defined in Control.FX.Monad.Trans.StateT

Methods

(==) :: InputT (StateT mark s) -> InputT (StateT mark s) -> Bool

(/=) :: InputT (StateT mark s) -> InputT (StateT mark s) -> Bool

(Show (mark s), Show (Context m)) => Show (Context (StateT mark s m))

Defined in Control.FX.Monad.Trans.StateT

Methods

showsPrec :: Int -> Context (StateT mark s m) -> ShowS

show :: Context (StateT mark s m) -> String

showList :: [Context (StateT mark s m)] -> ShowS

Show (mark s) => Show (InputT (StateT mark s))

Defined in Control.FX.Monad.Trans.StateT

Methods

showsPrec :: Int -> InputT (StateT mark s) -> ShowS

show :: InputT (StateT mark s) -> String

showList :: [InputT (StateT mark s)] -> ShowS

(Eq (mark s), Eq a) => Eq (OutputT (StateT mark s) a)

Defined in Control.FX.Monad.Trans.StateT

Methods

(==) :: OutputT (StateT mark s) a -> OutputT (StateT mark s) a -> Bool

(/=) :: OutputT (StateT mark s) a -> OutputT (StateT mark s) a -> Bool

(Show (mark s), Show a) => Show (OutputT (StateT mark s) a)

Defined in Control.FX.Monad.Trans.StateT

Methods

showsPrec :: Int -> OutputT (StateT mark s) a -> ShowS

show :: OutputT (StateT mark s) a -> String

showList :: [OutputT (StateT mark s) a] -> ShowS

MonadIdentity mark => LiftLocal (StateT mark s)

Defined in Control.FX.Monad.Trans.StateT

Methods

liftLocal :: Monad m => Local r m (OutputT (StateT mark s) a) -> Local r (StateT mark s m) a

MonadIdentity mark => LiftDraft (StateT mark s)

Defined in Control.FX.Monad.Trans.StateT

Methods

liftDraft :: (Monad m, Monoid w) => Draft w m (OutputT (StateT mark s) a) -> Draft w (StateT mark s m) a

MonadIdentity mark => LiftCatch (StateT mark s)

Defined in Control.FX.Monad.Trans.StateT

Methods

liftCatch :: Monad m => Catch e m (OutputT (StateT mark s) a) -> Catch e (StateT mark s m) a

MonadIdentity mark => RunMonadTrans (StateT mark s)

Defined in Control.FX.Monad.Trans.StateT

Associated Types

data InputT (StateT mark s) :: Type

data OutputT (StateT mark s) a :: Type

Methods

runT :: Monad m => InputT (StateT mark s) -> StateT mark s m a -> m (OutputT (StateT mark s) a)

MonadIdentity mark => MonadTrans (StateT mark s)

Defined in Control.FX.Monad.Trans.StateT

Methods

lift :: Monad m => m a -> StateT mark s m a

MonadIdentity mark => MonadFunctor (StateT mark s)

Defined in Control.FX.Monad.Trans.StateT

Methods

hoist :: (Monad m, Monad n) => (forall u. m u -> n u) -> StateT mark s m a -> StateT mark s n a

MonadIdentity mark => ComposableT (StateT mark s)

Defined in Control.FX.Monad.Trans.ComposeT

Associated Types

data ComposeT (StateT mark s) t2 m a :: Type

Methods

toComposeT :: StateT mark s (t2 m) a -> ComposeT (StateT mark s) t2 m a

unComposeT :: ComposeT (StateT mark s) t2 m a -> StateT mark s (t2 m) a

MonadIdentity mark => OverableT (StateT mark s)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Associated Types

data OverTT (StateT mark s) u t m a :: Type

Methods

toOverTT :: StateT mark s (u t m) a -> OverTT (StateT mark s) u t m a

unOverTT :: OverTT (StateT mark s) u t m a -> StateT mark s (u t m) a

(Monad m, MonadIdentity mark) => Monad (StateT mark s m)

Defined in Control.FX.Monad.Trans.StateT

Methods

(>>=) :: StateT mark s m a -> (a -> StateT mark s m b) -> StateT mark s m b

(>>) :: StateT mark s m a -> StateT mark s m b -> StateT mark s m b

return :: a -> StateT mark s m a

fail :: String -> StateT mark s m a

(Monad m, MonadIdentity mark) => Functor (StateT mark s m)

Defined in Control.FX.Monad.Trans.StateT

Methods

fmap :: (a -> b) -> StateT mark s m a -> StateT mark s m b

(<$) :: a -> StateT mark s m b -> StateT mark s m a

(Monad m, MonadIdentity mark) => Applicative (StateT mark s m)

Defined in Control.FX.Monad.Trans.StateT

Methods

pure :: a -> StateT mark s m a

(<*>) :: StateT mark s m (a -> b) -> StateT mark s m a -> StateT mark s m b

liftA2 :: (a -> b -> c) -> StateT mark s m a -> StateT mark s m b -> StateT mark s m c

(*>) :: StateT mark s m a -> StateT mark s m b -> StateT mark s m b

(<*) :: StateT mark s m a -> StateT mark s m b -> StateT mark s m a

(EqIn m, MonadIdentity mark, Eq s) => EqIn (StateT mark s m)

Defined in Control.FX.Monad.Trans.StateT

Associated Types

data Context (StateT mark s m) :: Type

Methods

eqIn :: Eq a => Context (StateT mark s m) -> StateT mark s m a -> StateT mark s m a -> Bool

(Typeable s, Typeable m, Typeable a, Typeable mark) => Show (StateT mark s m a)

Defined in Control.FX.Monad.Trans.StateT

Methods

showsPrec :: Int -> StateT mark s m a -> ShowS

show :: StateT mark s m a -> String

showList :: [StateT mark s m a] -> ShowS

newtype InputT (StateT mark s)

Defined in Control.FX.Monad.Trans.StateT

newtype InputT (StateT mark s) = StateTIn {

• unStateTIn :: mark s

}

newtype OutputT (StateT mark s) a

Defined in Control.FX.Monad.Trans.StateT

newtype OutputT (StateT mark s) a = StateTOut {

• unStateTOut :: Pair (mark s) a

}

newtype ComposeT (StateT mark s) t2 m a

Defined in Control.FX.Monad.Trans.ComposeT

newtype ComposeT (StateT mark s) t2 m a = ComposeT_StateT {

• unComposeT_StateT :: StateT mark s (t2 m) a

}

newtype OverTT (StateT mark s) u t m a

Defined in Control.FX.Monad.Trans.Trans.OverTT

newtype OverTT (StateT mark s) u t m a = OverTT_StateT {

• unOverTT_StateT :: StateT mark s (u t m) a

}

newtype Context (StateT mark s m)

Defined in Control.FX.Monad.Trans.StateT

newtype Context (StateT mark s m) = StateTCtx {

• unStateTCtx :: (mark s, Context m)

}

runStateT :: (Monad m, MonadIdentity mark) => mark s -> StateT mark s m a -> m (Pair (mark s) a)

newtype HaltT (mark :: * -> *) (m :: * -> *) (a :: *)

Concrete Maybe monad transformer

Constructors

HaltT

Fields

• unHaltT :: m (Halt mark a)

Instances

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadPrompt mark p m) => MonadPrompt mark p (HaltT mark1 m)

Defined in Control.FX.Monad.Trans.HaltT

Methods

prompt :: mark (p a) -> HaltT mark1 m (mark a)

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnce mark w m) => MonadWriteOnce mark w (HaltT mark1 m)

Defined in Control.FX.Monad.Trans.HaltT

Methods

etch :: mark w -> HaltT mark1 m Bool

press :: HaltT mark1 m (Maybe (mark w))

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadAppendOnly mark w m, Monoid w) => MonadAppendOnly mark w (HaltT mark1 m)

Defined in Control.FX.Monad.Trans.HaltT

Methods

look :: HaltT mark1 m (mark w)

jot :: mark w -> HaltT mark1 m ()

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadReadOnly mark r m) => MonadReadOnly mark r (HaltT mark1 m)

Defined in Control.FX.Monad.Trans.HaltT

Methods

ask :: HaltT mark1 m (mark r)

local :: (mark r -> mark r) -> HaltT mark1 m a -> HaltT mark1 m a

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnly mark w m, Monoid w) => MonadWriteOnly mark w (HaltT mark1 m)

Defined in Control.FX.Monad.Trans.HaltT

Methods

tell :: mark w -> HaltT mark1 m ()

draft :: HaltT mark1 m a -> HaltT mark1 m (Pair (mark w) a)

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadState mark s m) => MonadState mark s (HaltT mark1 m)

Defined in Control.FX.Monad.Trans.HaltT

Methods

get :: HaltT mark1 m (mark s)

put :: mark s -> HaltT mark1 m ()

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadExcept mark e m) => MonadExcept mark e (HaltT mark1 m)

Defined in Control.FX.Monad.Trans.HaltT

Methods

throw :: mark e -> HaltT mark1 m a

catch :: HaltT mark1 m a -> (mark e -> HaltT mark1 m a) -> HaltT mark1 m a

(MonadHalt mark m, MonadIdentity mark, MonadIdentity mark1) => MonadHalt mark (HaltT mark1 m)

Defined in Control.FX.Monad.Trans.HaltT

Methods

halt :: mark () -> HaltT mark1 m a

(Monad m, MonadIdentity mark) => MonadHalt mark (HaltT mark m)

Defined in Control.FX.Monad.Trans.HaltT

Methods

halt :: mark () -> HaltT mark m a

(Monad m, MonadTrans t2, MonadIdentity mark) => MonadHalt mark (ComposeT (HaltT mark) t2 m)

Defined in Control.FX.Monad.Trans.ComposeT

Methods

halt :: mark () -> ComposeT (HaltT mark) t2 m a

(Monad m, MonadTrans t, MonadTransTrans u, MonadIdentity mark) => MonadHalt mark (OverTT (HaltT mark) u t m)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Methods

halt :: mark () -> OverTT (HaltT mark) u t m a

(Eq (mark ()), Eq (Context m)) => Eq (Context (HaltT mark m))

Defined in Control.FX.Monad.Trans.HaltT

Methods

(==) :: Context (HaltT mark m) -> Context (HaltT mark m) -> Bool

(/=) :: Context (HaltT mark m) -> Context (HaltT mark m) -> Bool

Eq (mark ()) => Eq (InputT (HaltT mark))

Defined in Control.FX.Monad.Trans.HaltT

Methods

(==) :: InputT (HaltT mark) -> InputT (HaltT mark) -> Bool

(/=) :: InputT (HaltT mark) -> InputT (HaltT mark) -> Bool

MonadIdentity mark => Functor (OutputT (HaltT mark))

Defined in Control.FX.Monad.Trans.HaltT

Methods

fmap :: (a -> b) -> OutputT (HaltT mark) a -> OutputT (HaltT mark) b

(<$) :: a -> OutputT (HaltT mark) b -> OutputT (HaltT mark) a

(Show (mark ()), Show (Context m)) => Show (Context (HaltT mark m))

Defined in Control.FX.Monad.Trans.HaltT

Methods

showsPrec :: Int -> Context (HaltT mark m) -> ShowS

show :: Context (HaltT mark m) -> String

showList :: [Context (HaltT mark m)] -> ShowS

Show (mark ()) => Show (InputT (HaltT mark))

Defined in Control.FX.Monad.Trans.HaltT

Methods

showsPrec :: Int -> InputT (HaltT mark) -> ShowS

show :: InputT (HaltT mark) -> String

showList :: [InputT (HaltT mark)] -> ShowS

MonadIdentity mark => Applicative (OutputT (HaltT mark))

Defined in Control.FX.Monad.Trans.HaltT

Methods

pure :: a -> OutputT (HaltT mark) a

(<*>) :: OutputT (HaltT mark) (a -> b) -> OutputT (HaltT mark) a -> OutputT (HaltT mark) b

liftA2 :: (a -> b -> c) -> OutputT (HaltT mark) a -> OutputT (HaltT mark) b -> OutputT (HaltT mark) c

(*>) :: OutputT (HaltT mark) a -> OutputT (HaltT mark) b -> OutputT (HaltT mark) b

(<*) :: OutputT (HaltT mark) a -> OutputT (HaltT mark) b -> OutputT (HaltT mark) a

MonadIdentity mark => LiftLocal (HaltT mark)

Defined in Control.FX.Monad.Trans.HaltT

Methods

liftLocal :: Monad m => Local r m (OutputT (HaltT mark) a) -> Local r (HaltT mark m) a

MonadIdentity mark => LiftDraft (HaltT mark)

Defined in Control.FX.Monad.Trans.HaltT

Methods

liftDraft :: (Monad m, Monoid w) => Draft w m (OutputT (HaltT mark) a) -> Draft w (HaltT mark m) a

MonadIdentity mark => LiftCatch (HaltT mark)

Defined in Control.FX.Monad.Trans.HaltT

Methods

liftCatch :: Monad m => Catch e m (OutputT (HaltT mark) a) -> Catch e (HaltT mark m) a

MonadIdentity mark => RunMonadTrans (HaltT mark)

Defined in Control.FX.Monad.Trans.HaltT

Associated Types

data InputT (HaltT mark) :: Type

data OutputT (HaltT mark) a :: Type

Methods

runT :: Monad m => InputT (HaltT mark) -> HaltT mark m a -> m (OutputT (HaltT mark) a)

MonadIdentity mark => MonadTrans (HaltT mark)

Defined in Control.FX.Monad.Trans.HaltT

Methods

lift :: Monad m => m a -> HaltT mark m a

MonadIdentity mark => MonadFunctor (HaltT mark)

Defined in Control.FX.Monad.Trans.HaltT

Methods

hoist :: (Monad m, Monad n) => (forall u. m u -> n u) -> HaltT mark m a -> HaltT mark n a

MonadIdentity mark => ComposableT (HaltT mark)

Defined in Control.FX.Monad.Trans.ComposeT

Associated Types

data ComposeT (HaltT mark) t2 m a :: Type

Methods

toComposeT :: HaltT mark (t2 m) a -> ComposeT (HaltT mark) t2 m a

unComposeT :: ComposeT (HaltT mark) t2 m a -> HaltT mark (t2 m) a

MonadIdentity mark => OverableT (HaltT mark)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Associated Types

data OverTT (HaltT mark) u t m a :: Type

Methods

toOverTT :: HaltT mark (u t m) a -> OverTT (HaltT mark) u t m a

unOverTT :: OverTT (HaltT mark) u t m a -> HaltT mark (u t m) a

Eq a => Eq (OutputT (HaltT mark) a)

Defined in Control.FX.Monad.Trans.HaltT

Methods

(==) :: OutputT (HaltT mark) a -> OutputT (HaltT mark) a -> Bool

(/=) :: OutputT (HaltT mark) a -> OutputT (HaltT mark) a -> Bool

(Monad m, MonadIdentity mark) => Monad (HaltT mark m)

Defined in Control.FX.Monad.Trans.HaltT

Methods

(>>=) :: HaltT mark m a -> (a -> HaltT mark m b) -> HaltT mark m b

(>>) :: HaltT mark m a -> HaltT mark m b -> HaltT mark m b

return :: a -> HaltT mark m a

fail :: String -> HaltT mark m a

(Monad m, MonadIdentity mark) => Functor (HaltT mark m)

Defined in Control.FX.Monad.Trans.HaltT

Methods

fmap :: (a -> b) -> HaltT mark m a -> HaltT mark m b

(<$) :: a -> HaltT mark m b -> HaltT mark m a

Show a => Show (OutputT (HaltT mark) a)

Defined in Control.FX.Monad.Trans.HaltT

Methods

showsPrec :: Int -> OutputT (HaltT mark) a -> ShowS

show :: OutputT (HaltT mark) a -> String

showList :: [OutputT (HaltT mark) a] -> ShowS

(Monad m, MonadIdentity mark) => Applicative (HaltT mark m)

Defined in Control.FX.Monad.Trans.HaltT

Methods

pure :: a -> HaltT mark m a

(<*>) :: HaltT mark m (a -> b) -> HaltT mark m a -> HaltT mark m b

liftA2 :: (a -> b -> c) -> HaltT mark m a -> HaltT mark m b -> HaltT mark m c

(*>) :: HaltT mark m a -> HaltT mark m b -> HaltT mark m b

(<*) :: HaltT mark m a -> HaltT mark m b -> HaltT mark m a

EqIn m => EqIn (HaltT mark m)

Defined in Control.FX.Monad.Trans.HaltT

Associated Types

data Context (HaltT mark m) :: Type

Methods

eqIn :: Eq a => Context (HaltT mark m) -> HaltT mark m a -> HaltT mark m a -> Bool

(Central c, MonadIdentity mark) => Commutant (HaltT mark c)

Defined in Control.FX.Monad.Trans.HaltT

Methods

commute :: Applicative f => HaltT mark c (f a) -> f (HaltT mark c a)

(Central c, MonadIdentity mark) => Central (HaltT mark c)

Defined in Control.FX.Monad.Trans.HaltT

Show (m (Halt mark a)) => Show (HaltT mark m a)

Defined in Control.FX.Monad.Trans.HaltT

Methods

showsPrec :: Int -> HaltT mark m a -> ShowS

show :: HaltT mark m a -> String

showList :: [HaltT mark m a] -> ShowS

newtype InputT (HaltT mark)

Defined in Control.FX.Monad.Trans.HaltT

newtype InputT (HaltT mark) = HaltTIn {

• unHaltTIn :: mark ()

}

newtype OutputT (HaltT mark) a

Defined in Control.FX.Monad.Trans.HaltT

newtype OutputT (HaltT mark) a = HaltTOut {

• unHaltTOut :: Halt mark a

}

newtype ComposeT (HaltT mark) t2 m a

Defined in Control.FX.Monad.Trans.ComposeT

newtype ComposeT (HaltT mark) t2 m a = ComposeT_HaltT {

• unComposeT_HaltT :: HaltT mark (t2 m) a

}

newtype OverTT (HaltT mark) u t m a

Defined in Control.FX.Monad.Trans.Trans.OverTT

newtype OverTT (HaltT mark) u t m a = OverTT_HaltT {

• unOverTT_HaltT :: HaltT mark (u t m) a

}

newtype Context (HaltT mark m)

Defined in Control.FX.Monad.Trans.HaltT

newtype Context (HaltT mark m) = HaltTCtx {

• unHaltTCtx :: (mark (), Context m)

}

runHaltT :: (Monad m, MonadIdentity mark) => HaltT mark m a -> m (Halt mark a)

newtype ExceptT (mark :: * -> *) (e :: *) (m :: * -> *) (a :: *)

Concrete exception monad transformer

Constructors

ExceptT

Fields

• unExceptT :: m (Except mark e a)

Instances

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadPrompt mark p m) => MonadPrompt mark p (ExceptT mark1 e m)

Defined in Control.FX.Monad.Trans.ExceptT

Methods

prompt :: mark (p a) -> ExceptT mark1 e m (mark a)

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnce mark w m) => MonadWriteOnce mark w (ExceptT mark1 e m)

Defined in Control.FX.Monad.Trans.ExceptT

Methods

etch :: mark w -> ExceptT mark1 e m Bool

press :: ExceptT mark1 e m (Maybe (mark w))

(Monad m, MonadIdentity mark, MonadIdentity mark1, Monoid w, MonadAppendOnly mark w m) => MonadAppendOnly mark w (ExceptT mark1 e m)

Defined in Control.FX.Monad.Trans.ExceptT

Methods

look :: ExceptT mark1 e m (mark w)

jot :: mark w -> ExceptT mark1 e m ()

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadReadOnly mark r m) => MonadReadOnly mark r (ExceptT mark1 e m)

Defined in Control.FX.Monad.Trans.ExceptT

Methods

ask :: ExceptT mark1 e m (mark r)

local :: (mark r -> mark r) -> ExceptT mark1 e m a -> ExceptT mark1 e m a

(Monad m, MonadIdentity mark, MonadIdentity mark1, Monoid w, MonadWriteOnly mark w m) => MonadWriteOnly mark w (ExceptT mark1 e m)

Defined in Control.FX.Monad.Trans.ExceptT

Methods

tell :: mark w -> ExceptT mark1 e m ()

draft :: ExceptT mark1 e m a -> ExceptT mark1 e m (Pair (mark w) a)

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadState mark s m) => MonadState mark s (ExceptT mark1 e m)

Defined in Control.FX.Monad.Trans.ExceptT

Methods

get :: ExceptT mark1 e m (mark s)

put :: mark s -> ExceptT mark1 e m ()

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadExcept mark e m) => MonadExcept mark e (ExceptT mark1 e1 m)

Defined in Control.FX.Monad.Trans.ExceptT

Methods

throw :: mark e -> ExceptT mark1 e1 m a

catch :: ExceptT mark1 e1 m a -> (mark e -> ExceptT mark1 e1 m a) -> ExceptT mark1 e1 m a

(Monad m, MonadIdentity mark) => MonadExcept mark e (ExceptT mark e m)

Defined in Control.FX.Monad.Trans.ExceptT

Methods

throw :: mark e -> ExceptT mark e m a

catch :: ExceptT mark e m a -> (mark e -> ExceptT mark e m a) -> ExceptT mark e m a

(Monad m, MonadTrans t2, MonadIdentity mark) => MonadExcept mark e (ComposeT (ExceptT mark e) t2 m)

Defined in Control.FX.Monad.Trans.ComposeT

Methods

throw :: mark e -> ComposeT (ExceptT mark e) t2 m a

catch :: ComposeT (ExceptT mark e) t2 m a -> (mark e -> ComposeT (ExceptT mark e) t2 m a) -> ComposeT (ExceptT mark e) t2 m a

(Monad m, MonadTrans t, MonadTransTrans u, MonadIdentity mark) => MonadExcept mark e (OverTT (ExceptT mark e) u t m)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Methods

throw :: mark e -> OverTT (ExceptT mark e) u t m a

catch :: OverTT (ExceptT mark e) u t m a -> (mark e -> OverTT (ExceptT mark e) u t m a) -> OverTT (ExceptT mark e) u t m a

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadHalt mark m) => MonadHalt mark (ExceptT mark1 e m)

Defined in Control.FX.Monad.Trans.ExceptT

Methods

halt :: mark () -> ExceptT mark1 e m a

(Eq (mark ()), Eq (Context m)) => Eq (Context (ExceptT mark e m))

Defined in Control.FX.Monad.Trans.ExceptT

Methods

(==) :: Context (ExceptT mark e m) -> Context (ExceptT mark e m) -> Bool

(/=) :: Context (ExceptT mark e m) -> Context (ExceptT mark e m) -> Bool

Eq (mark ()) => Eq (InputT (ExceptT mark e))

Defined in Control.FX.Monad.Trans.ExceptT

Methods

(==) :: InputT (ExceptT mark e) -> InputT (ExceptT mark e) -> Bool

(/=) :: InputT (ExceptT mark e) -> InputT (ExceptT mark e) -> Bool

MonadIdentity mark => Functor (OutputT (ExceptT mark e))

Defined in Control.FX.Monad.Trans.ExceptT

Methods

fmap :: (a -> b) -> OutputT (ExceptT mark e) a -> OutputT (ExceptT mark e) b

(<$) :: a -> OutputT (ExceptT mark e) b -> OutputT (ExceptT mark e) a

(Show (mark ()), Show (Context m)) => Show (Context (ExceptT mark e m))

Defined in Control.FX.Monad.Trans.ExceptT

Methods

showsPrec :: Int -> Context (ExceptT mark e m) -> ShowS

show :: Context (ExceptT mark e m) -> String

showList :: [Context (ExceptT mark e m)] -> ShowS

Show (mark ()) => Show (InputT (ExceptT mark e))

Defined in Control.FX.Monad.Trans.ExceptT

Methods

showsPrec :: Int -> InputT (ExceptT mark e) -> ShowS

show :: InputT (ExceptT mark e) -> String

showList :: [InputT (ExceptT mark e)] -> ShowS

MonadIdentity mark => Applicative (OutputT (ExceptT mark e))

Defined in Control.FX.Monad.Trans.ExceptT

Methods

pure :: a -> OutputT (ExceptT mark e) a

(<*>) :: OutputT (ExceptT mark e) (a -> b) -> OutputT (ExceptT mark e) a -> OutputT (ExceptT mark e) b

liftA2 :: (a -> b -> c) -> OutputT (ExceptT mark e) a -> OutputT (ExceptT mark e) b -> OutputT (ExceptT mark e) c

(*>) :: OutputT (ExceptT mark e) a -> OutputT (ExceptT mark e) b -> OutputT (ExceptT mark e) b

(<*) :: OutputT (ExceptT mark e) a -> OutputT (ExceptT mark e) b -> OutputT (ExceptT mark e) a

(Eq e, Eq a) => Eq (OutputT (ExceptT mark e) a)

Defined in Control.FX.Monad.Trans.ExceptT

Methods

(==) :: OutputT (ExceptT mark e) a -> OutputT (ExceptT mark e) a -> Bool

(/=) :: OutputT (ExceptT mark e) a -> OutputT (ExceptT mark e) a -> Bool

(Show e, Show a) => Show (OutputT (ExceptT mark e) a)

Defined in Control.FX.Monad.Trans.ExceptT

Methods

showsPrec :: Int -> OutputT (ExceptT mark e) a -> ShowS

show :: OutputT (ExceptT mark e) a -> String

showList :: [OutputT (ExceptT mark e) a] -> ShowS

MonadIdentity mark => LiftLocal (ExceptT mark e)

Defined in Control.FX.Monad.Trans.ExceptT

Methods

liftLocal :: Monad m => Local r m (OutputT (ExceptT mark e) a) -> Local r (ExceptT mark e m) a

MonadIdentity mark => LiftDraft (ExceptT mark e)

Defined in Control.FX.Monad.Trans.ExceptT

Methods

liftDraft :: (Monad m, Monoid w) => Draft w m (OutputT (ExceptT mark e) a) -> Draft w (ExceptT mark e m) a

MonadIdentity mark => LiftCatch (ExceptT mark e)

Defined in Control.FX.Monad.Trans.ExceptT

Methods

liftCatch :: Monad m => Catch e0 m (OutputT (ExceptT mark e) a) -> Catch e0 (ExceptT mark e m) a

MonadIdentity mark => RunMonadTrans (ExceptT mark e)

Defined in Control.FX.Monad.Trans.ExceptT

Associated Types

data InputT (ExceptT mark e) :: Type

data OutputT (ExceptT mark e) a :: Type

Methods

runT :: Monad m => InputT (ExceptT mark e) -> ExceptT mark e m a -> m (OutputT (ExceptT mark e) a)

MonadIdentity mark => MonadTrans (ExceptT mark e)

Defined in Control.FX.Monad.Trans.ExceptT

Methods

lift :: Monad m => m a -> ExceptT mark e m a

MonadIdentity mark => MonadFunctor (ExceptT mark e)

Defined in Control.FX.Monad.Trans.ExceptT

Methods

hoist :: (Monad m, Monad n) => (forall u. m u -> n u) -> ExceptT mark e m a -> ExceptT mark e n a

MonadIdentity mark => ComposableT (ExceptT mark e)

Defined in Control.FX.Monad.Trans.ComposeT

Associated Types

data ComposeT (ExceptT mark e) t2 m a :: Type

Methods

toComposeT :: ExceptT mark e (t2 m) a -> ComposeT (ExceptT mark e) t2 m a

unComposeT :: ComposeT (ExceptT mark e) t2 m a -> ExceptT mark e (t2 m) a

MonadIdentity mark => OverableT (ExceptT mark e)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Associated Types

data OverTT (ExceptT mark e) u t m a :: Type

Methods

toOverTT :: ExceptT mark e (u t m) a -> OverTT (ExceptT mark e) u t m a

unOverTT :: OverTT (ExceptT mark e) u t m a -> ExceptT mark e (u t m) a

(Monad m, MonadIdentity mark) => Monad (ExceptT mark e m)

Defined in Control.FX.Monad.Trans.ExceptT

Methods

(>>=) :: ExceptT mark e m a -> (a -> ExceptT mark e m b) -> ExceptT mark e m b

(>>) :: ExceptT mark e m a -> ExceptT mark e m b -> ExceptT mark e m b

return :: a -> ExceptT mark e m a

fail :: String -> ExceptT mark e m a

(Monad m, MonadIdentity mark) => Functor (ExceptT mark e m)

Defined in Control.FX.Monad.Trans.ExceptT

Methods

fmap :: (a -> b) -> ExceptT mark e m a -> ExceptT mark e m b

(<$) :: a -> ExceptT mark e m b -> ExceptT mark e m a

(Monad m, MonadIdentity mark) => Applicative (ExceptT mark e m)

Defined in Control.FX.Monad.Trans.ExceptT

Methods

pure :: a -> ExceptT mark e m a

(<*>) :: ExceptT mark e m (a -> b) -> ExceptT mark e m a -> ExceptT mark e m b

liftA2 :: (a -> b -> c) -> ExceptT mark e m a -> ExceptT mark e m b -> ExceptT mark e m c

(*>) :: ExceptT mark e m a -> ExceptT mark e m b -> ExceptT mark e m b

(<*) :: ExceptT mark e m a -> ExceptT mark e m b -> ExceptT mark e m a

(EqIn m, MonadIdentity mark, Eq e) => EqIn (ExceptT mark e m)

Defined in Control.FX.Monad.Trans.ExceptT

Associated Types

data Context (ExceptT mark e m) :: Type

Methods

eqIn :: Eq a => Context (ExceptT mark e m) -> ExceptT mark e m a -> ExceptT mark e m a -> Bool

(Central c, MonadIdentity mark) => Commutant (ExceptT mark e c)

Defined in Control.FX.Monad.Trans.ExceptT

Methods

commute :: Applicative f => ExceptT mark e c (f a) -> f (ExceptT mark e c a)

(Central c, MonadIdentity mark) => Central (ExceptT mark e c)

Defined in Control.FX.Monad.Trans.ExceptT

Show (m (Except mark e a)) => Show (ExceptT mark e m a)

Defined in Control.FX.Monad.Trans.ExceptT

Methods

showsPrec :: Int -> ExceptT mark e m a -> ShowS

show :: ExceptT mark e m a -> String

showList :: [ExceptT mark e m a] -> ShowS

newtype InputT (ExceptT mark e)

Defined in Control.FX.Monad.Trans.ExceptT

newtype InputT (ExceptT mark e) = ExceptTIn {

• unExceptTIn :: mark ()

}

newtype OutputT (ExceptT mark e) a

Defined in Control.FX.Monad.Trans.ExceptT

newtype OutputT (ExceptT mark e) a = ExceptTOut {

• unExceptTOut :: Except mark e a

}

newtype ComposeT (ExceptT mark e) t2 m a

Defined in Control.FX.Monad.Trans.ComposeT

newtype ComposeT (ExceptT mark e) t2 m a = ComposeT_ExceptT {

• unComposeT_ExceptT :: ExceptT mark e (t2 m) a

}

newtype OverTT (ExceptT mark e) u t m a

Defined in Control.FX.Monad.Trans.Trans.OverTT

newtype OverTT (ExceptT mark e) u t m a = OverTT_ExceptT {

• unOverTT_ExceptT :: ExceptT mark e (u t m) a

}

newtype Context (ExceptT mark e m)

Defined in Control.FX.Monad.Trans.ExceptT

newtype Context (ExceptT mark e m) = ExceptTCtx {

• unExceptTCtx :: (mark (), Context m)

}

runExceptT :: (Monad m, MonadIdentity mark) => ExceptT mark e m a -> m (Except mark e a)

newtype WriteOnlyT (mark :: * -> *) (w :: *) (m :: * -> *) (a :: *)

Concrete write-only state monad transformer

Constructors

WriteOnlyT

Fields

• unWriteOnlyT :: m (WriteOnly mark w a)

Instances

(Monad m, MonadIdentity mark, MonadIdentity mark1, Monoid w, MonadPrompt mark p m) => MonadPrompt mark p (WriteOnlyT mark1 w m)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

prompt :: mark (p a) -> WriteOnlyT mark1 w m (mark a)

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnce mark w m, Monoid w1) => MonadWriteOnce mark w (WriteOnlyT mark1 w1 m)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

etch :: mark w -> WriteOnlyT mark1 w1 m Bool

press :: WriteOnlyT mark1 w1 m (Maybe (mark w))

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadAppendOnly mark w m, Monoid w, Monoid w1) => MonadAppendOnly mark w (WriteOnlyT mark1 w1 m)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

look :: WriteOnlyT mark1 w1 m (mark w)

jot :: mark w -> WriteOnlyT mark1 w1 m ()

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadReadOnly mark r m, Monoid w) => MonadReadOnly mark r (WriteOnlyT mark1 w m)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

ask :: WriteOnlyT mark1 w m (mark r)

local :: (mark r -> mark r) -> WriteOnlyT mark1 w m a -> WriteOnlyT mark1 w m a

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnly mark w m, Monoid w, Monoid w1) => MonadWriteOnly mark w (WriteOnlyT mark1 w1 m)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

tell :: mark w -> WriteOnlyT mark1 w1 m ()

draft :: WriteOnlyT mark1 w1 m a -> WriteOnlyT mark1 w1 m (Pair (mark w) a)

(Monoid w, Monad m, MonadIdentity mark) => MonadWriteOnly mark w (WriteOnlyT mark w m)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

tell :: mark w -> WriteOnlyT mark w m ()

draft :: WriteOnlyT mark w m a -> WriteOnlyT mark w m (Pair (mark w) a)

(Monad m, MonadTrans t2, Monoid w, MonadIdentity mark) => MonadWriteOnly mark w (ComposeT (WriteOnlyT mark w) t2 m)

Defined in Control.FX.Monad.Trans.ComposeT

Methods

tell :: mark w -> ComposeT (WriteOnlyT mark w) t2 m ()

draft :: ComposeT (WriteOnlyT mark w) t2 m a -> ComposeT (WriteOnlyT mark w) t2 m (Pair (mark w) a)

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadState mark s m, Monoid w) => MonadState mark s (WriteOnlyT mark1 w m)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

get :: WriteOnlyT mark1 w m (mark s)

put :: mark s -> WriteOnlyT mark1 w m ()

(Monad m, MonadIdentity mark, MonadIdentity mark1, Monoid w, MonadExcept mark e m) => MonadExcept mark e (WriteOnlyT mark1 w m)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

throw :: mark e -> WriteOnlyT mark1 w m a

catch :: WriteOnlyT mark1 w m a -> (mark e -> WriteOnlyT mark1 w m a) -> WriteOnlyT mark1 w m a

(Monad m, MonadTrans t, Monoid w, MonadTransTrans u, MonadIdentity mark) => MonadWriteOnly mark w (OverTT (WriteOnlyT mark w) u t m)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Methods

tell :: mark w -> OverTT (WriteOnlyT mark w) u t m ()

draft :: OverTT (WriteOnlyT mark w) u t m a -> OverTT (WriteOnlyT mark w) u t m (Pair (mark w) a)

(Monad m, MonadIdentity mark1, Monoid w, MonadIdentity mark, MonadHalt mark m) => MonadHalt mark (WriteOnlyT mark1 w m)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

halt :: mark () -> WriteOnlyT mark1 w m a

(Eq (mark ()), Eq (Context m)) => Eq (Context (WriteOnlyT mark w m))

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

(==) :: Context (WriteOnlyT mark w m) -> Context (WriteOnlyT mark w m) -> Bool

(/=) :: Context (WriteOnlyT mark w m) -> Context (WriteOnlyT mark w m) -> Bool

Eq (mark ()) => Eq (InputT (WriteOnlyT mark w))

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

(==) :: InputT (WriteOnlyT mark w) -> InputT (WriteOnlyT mark w) -> Bool

(/=) :: InputT (WriteOnlyT mark w) -> InputT (WriteOnlyT mark w) -> Bool

(Monoid w, MonadIdentity mark) => Functor (OutputT (WriteOnlyT mark w))

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

fmap :: (a -> b) -> OutputT (WriteOnlyT mark w) a -> OutputT (WriteOnlyT mark w) b

(<$) :: a -> OutputT (WriteOnlyT mark w) b -> OutputT (WriteOnlyT mark w) a

(Show (mark ()), Show (Context m)) => Show (Context (WriteOnlyT mark w m))

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

showsPrec :: Int -> Context (WriteOnlyT mark w m) -> ShowS

show :: Context (WriteOnlyT mark w m) -> String

showList :: [Context (WriteOnlyT mark w m)] -> ShowS

Show (mark ()) => Show (InputT (WriteOnlyT mark w))

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

showsPrec :: Int -> InputT (WriteOnlyT mark w) -> ShowS

show :: InputT (WriteOnlyT mark w) -> String

showList :: [InputT (WriteOnlyT mark w)] -> ShowS

(Monoid w, MonadIdentity mark) => Applicative (OutputT (WriteOnlyT mark w))

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

pure :: a -> OutputT (WriteOnlyT mark w) a

(<*>) :: OutputT (WriteOnlyT mark w) (a -> b) -> OutputT (WriteOnlyT mark w) a -> OutputT (WriteOnlyT mark w) b

liftA2 :: (a -> b -> c) -> OutputT (WriteOnlyT mark w) a -> OutputT (WriteOnlyT mark w) b -> OutputT (WriteOnlyT mark w) c

(*>) :: OutputT (WriteOnlyT mark w) a -> OutputT (WriteOnlyT mark w) b -> OutputT (WriteOnlyT mark w) b

(<*) :: OutputT (WriteOnlyT mark w) a -> OutputT (WriteOnlyT mark w) b -> OutputT (WriteOnlyT mark w) a

(Eq a, Eq (mark w)) => Eq (OutputT (WriteOnlyT mark w) a)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

(==) :: OutputT (WriteOnlyT mark w) a -> OutputT (WriteOnlyT mark w) a -> Bool

(/=) :: OutputT (WriteOnlyT mark w) a -> OutputT (WriteOnlyT mark w) a -> Bool

(Show a, Show (mark w)) => Show (OutputT (WriteOnlyT mark w) a)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

showsPrec :: Int -> OutputT (WriteOnlyT mark w) a -> ShowS

show :: OutputT (WriteOnlyT mark w) a -> String

showList :: [OutputT (WriteOnlyT mark w) a] -> ShowS

(Monoid w, MonadIdentity mark) => LiftLocal (WriteOnlyT mark w)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

liftLocal :: Monad m => Local r m (OutputT (WriteOnlyT mark w) a) -> Local r (WriteOnlyT mark w m) a

(Monoid w, MonadIdentity mark, forall x. Monoid x => Monoid (mark x)) => LiftDraft (WriteOnlyT mark w)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

liftDraft :: (Monad m, Monoid w0) => Draft w0 m (OutputT (WriteOnlyT mark w) a) -> Draft w0 (WriteOnlyT mark w m) a

(Monoid w, MonadIdentity mark) => LiftCatch (WriteOnlyT mark w)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

liftCatch :: Monad m => Catch e m (OutputT (WriteOnlyT mark w) a) -> Catch e (WriteOnlyT mark w m) a

(Monoid w, MonadIdentity mark) => RunMonadTrans (WriteOnlyT mark w)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Associated Types

data InputT (WriteOnlyT mark w) :: Type

data OutputT (WriteOnlyT mark w) a :: Type

Methods

runT :: Monad m => InputT (WriteOnlyT mark w) -> WriteOnlyT mark w m a -> m (OutputT (WriteOnlyT mark w) a)

(Monoid w, MonadIdentity mark) => MonadTrans (WriteOnlyT mark w)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

lift :: Monad m => m a -> WriteOnlyT mark w m a

(Monoid w, MonadIdentity mark) => MonadFunctor (WriteOnlyT mark w)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

hoist :: (Monad m, Monad n) => (forall u. m u -> n u) -> WriteOnlyT mark w m a -> WriteOnlyT mark w n a

(MonadIdentity mark, Monoid w) => ComposableT (WriteOnlyT mark w)

Defined in Control.FX.Monad.Trans.ComposeT

Associated Types

data ComposeT (WriteOnlyT mark w) t2 m a :: Type

Methods

toComposeT :: WriteOnlyT mark w (t2 m) a -> ComposeT (WriteOnlyT mark w) t2 m a

unComposeT :: ComposeT (WriteOnlyT mark w) t2 m a -> WriteOnlyT mark w (t2 m) a

(MonadIdentity mark, Monoid w) => OverableT (WriteOnlyT mark w)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Associated Types

data OverTT (WriteOnlyT mark w) u t m a :: Type

Methods

toOverTT :: WriteOnlyT mark w (u t m) a -> OverTT (WriteOnlyT mark w) u t m a

unOverTT :: OverTT (WriteOnlyT mark w) u t m a -> WriteOnlyT mark w (u t m) a

(Monoid w, Monad m, MonadIdentity mark) => Monad (WriteOnlyT mark w m)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

(>>=) :: WriteOnlyT mark w m a -> (a -> WriteOnlyT mark w m b) -> WriteOnlyT mark w m b

(>>) :: WriteOnlyT mark w m a -> WriteOnlyT mark w m b -> WriteOnlyT mark w m b

return :: a -> WriteOnlyT mark w m a

fail :: String -> WriteOnlyT mark w m a

(Monoid w, Monad m, MonadIdentity mark) => Functor (WriteOnlyT mark w m)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

fmap :: (a -> b) -> WriteOnlyT mark w m a -> WriteOnlyT mark w m b

(<$) :: a -> WriteOnlyT mark w m b -> WriteOnlyT mark w m a

(Monoid w, Monad m, MonadIdentity mark) => Applicative (WriteOnlyT mark w m)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

pure :: a -> WriteOnlyT mark w m a

(<*>) :: WriteOnlyT mark w m (a -> b) -> WriteOnlyT mark w m a -> WriteOnlyT mark w m b

liftA2 :: (a -> b -> c) -> WriteOnlyT mark w m a -> WriteOnlyT mark w m b -> WriteOnlyT mark w m c

(*>) :: WriteOnlyT mark w m a -> WriteOnlyT mark w m b -> WriteOnlyT mark w m b

(<*) :: WriteOnlyT mark w m a -> WriteOnlyT mark w m b -> WriteOnlyT mark w m a

(EqIn m, MonadIdentity mark, Eq w) => EqIn (WriteOnlyT mark w m)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Associated Types

data Context (WriteOnlyT mark w m) :: Type

Methods

eqIn :: Eq a => Context (WriteOnlyT mark w m) -> WriteOnlyT mark w m a -> WriteOnlyT mark w m a -> Bool

(Monoid w, Central c, MonadIdentity mark) => Commutant (WriteOnlyT mark w c)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

commute :: Applicative f => WriteOnlyT mark w c (f a) -> f (WriteOnlyT mark w c a)

(Monoid w, Central c, MonadIdentity mark) => Central (WriteOnlyT mark w c)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Show (m (WriteOnly mark w a)) => Show (WriteOnlyT mark w m a)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

showsPrec :: Int -> WriteOnlyT mark w m a -> ShowS

show :: WriteOnlyT mark w m a -> String

showList :: [WriteOnlyT mark w m a] -> ShowS

data InputT (WriteOnlyT mark w)

Defined in Control.FX.Monad.Trans.WriteOnlyT

data InputT (WriteOnlyT mark w) = WriteOnlyTIn {

• unWriteOnlyTIn :: mark ()

}

data OutputT (WriteOnlyT mark w) a

Defined in Control.FX.Monad.Trans.WriteOnlyT

data OutputT (WriteOnlyT mark w) a = WriteOnlyTOut {

• unWriteOnlyTOut :: Pair (mark w) a

}

newtype ComposeT (WriteOnlyT mark w) t2 m a

Defined in Control.FX.Monad.Trans.ComposeT

newtype ComposeT (WriteOnlyT mark w) t2 m a = ComposeT_WriteOnlyT {

• unComposeT_WriteOnlyT :: WriteOnlyT mark w (t2 m) a

}

newtype OverTT (WriteOnlyT mark w) u t m a

Defined in Control.FX.Monad.Trans.Trans.OverTT

newtype OverTT (WriteOnlyT mark w) u t m a = OverTT_WriteOnlyT {

• unOverTT_WriteOnlyT :: WriteOnlyT mark w (u t m) a

}

data Context (WriteOnlyT mark w m)

Defined in Control.FX.Monad.Trans.WriteOnlyT

data Context (WriteOnlyT mark w m) = WriteOnlyTCtx {

• unWriteOnlyTCtx :: (mark (), Context m)

}

runWriteOnlyT :: (Monad m, MonadIdentity mark, Monoid w) => WriteOnlyT mark w m a -> m (Pair (mark w) a)

newtype WriteOnceT (mark :: * -> *) (w :: *) (m :: * -> *) (a :: *)

Concrete State monad transformer

Constructors

WriteOnceT

Fields

• unWriteOnceT :: LeftZero w -> m (Pair (LeftZero w) a)

Instances

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadPrompt mark p m) => MonadPrompt mark p (WriteOnceT mark1 w m)

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

prompt :: mark (p a) -> WriteOnceT mark1 w m (mark a)

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnce mark w m) => MonadWriteOnce mark w (WriteOnceT mark1 w1 m)

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

etch :: mark w -> WriteOnceT mark1 w1 m Bool

press :: WriteOnceT mark1 w1 m (Maybe (mark w))

(Monad m, MonadIdentity mark) => MonadWriteOnce mark w (WriteOnceT mark w m)

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

etch :: mark w -> WriteOnceT mark w m Bool

press :: WriteOnceT mark w m (Maybe (mark w))

(Monad m, MonadTrans t2, MonadIdentity mark) => MonadWriteOnce mark w (ComposeT (WriteOnceT mark w) t2 m)

Defined in Control.FX.Monad.Trans.ComposeT

Methods

etch :: mark w -> ComposeT (WriteOnceT mark w) t2 m Bool

press :: ComposeT (WriteOnceT mark w) t2 m (Maybe (mark w))

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadAppendOnly mark w m) => MonadAppendOnly mark w (WriteOnceT mark1 w1 m)

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

look :: WriteOnceT mark1 w1 m (mark w)

jot :: mark w -> WriteOnceT mark1 w1 m ()

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadReadOnly mark r m) => MonadReadOnly mark r (WriteOnceT mark1 w m)

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

ask :: WriteOnceT mark1 w m (mark r)

local :: (mark r -> mark r) -> WriteOnceT mark1 w m a -> WriteOnceT mark1 w m a

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnly mark w m) => MonadWriteOnly mark w (WriteOnceT mark1 w1 m)

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

tell :: mark w -> WriteOnceT mark1 w1 m ()

draft :: WriteOnceT mark1 w1 m a -> WriteOnceT mark1 w1 m (Pair (mark w) a)

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadState mark s m) => MonadState mark s (WriteOnceT mark1 w m)

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

get :: WriteOnceT mark1 w m (mark s)

put :: mark s -> WriteOnceT mark1 w m ()

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadExcept mark e m) => MonadExcept mark e (WriteOnceT mark1 w m)

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

throw :: mark e -> WriteOnceT mark1 w m a

catch :: WriteOnceT mark1 w m a -> (mark e -> WriteOnceT mark1 w m a) -> WriteOnceT mark1 w m a

(Monad m, MonadTrans t, MonadTransTrans u, MonadIdentity mark) => MonadWriteOnce mark w (OverTT (WriteOnceT mark w) u t m)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Methods

etch :: mark w -> OverTT (WriteOnceT mark w) u t m Bool

press :: OverTT (WriteOnceT mark w) u t m (Maybe (mark w))

(Monad m, MonadIdentity mark1, MonadIdentity mark, MonadHalt mark m) => MonadHalt mark (WriteOnceT mark1 w m)

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

halt :: mark () -> WriteOnceT mark1 w m a

(Eq (mark ()), Eq (Context m)) => Eq (Context (WriteOnceT mark w m))

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

(==) :: Context (WriteOnceT mark w m) -> Context (WriteOnceT mark w m) -> Bool

(/=) :: Context (WriteOnceT mark w m) -> Context (WriteOnceT mark w m) -> Bool

Eq (mark ()) => Eq (InputT (WriteOnceT mark w))

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

(==) :: InputT (WriteOnceT mark w) -> InputT (WriteOnceT mark w) -> Bool

(/=) :: InputT (WriteOnceT mark w) -> InputT (WriteOnceT mark w) -> Bool

(Show (mark ()), Show (Context m)) => Show (Context (WriteOnceT mark w m))

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

showsPrec :: Int -> Context (WriteOnceT mark w m) -> ShowS

show :: Context (WriteOnceT mark w m) -> String

showList :: [Context (WriteOnceT mark w m)] -> ShowS

Show (mark ()) => Show (InputT (WriteOnceT mark w))

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

showsPrec :: Int -> InputT (WriteOnceT mark w) -> ShowS

show :: InputT (WriteOnceT mark w) -> String

showList :: [InputT (WriteOnceT mark w)] -> ShowS

(Eq (mark (Maybe w)), Eq a) => Eq (OutputT (WriteOnceT mark w) a)

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

(==) :: OutputT (WriteOnceT mark w) a -> OutputT (WriteOnceT mark w) a -> Bool

(/=) :: OutputT (WriteOnceT mark w) a -> OutputT (WriteOnceT mark w) a -> Bool

(Show (mark (Maybe w)), Show a) => Show (OutputT (WriteOnceT mark w) a)

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

showsPrec :: Int -> OutputT (WriteOnceT mark w) a -> ShowS

show :: OutputT (WriteOnceT mark w) a -> String

showList :: [OutputT (WriteOnceT mark w) a] -> ShowS

MonadIdentity mark => LiftLocal (WriteOnceT mark w)

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

liftLocal :: Monad m => Local r m (OutputT (WriteOnceT mark w) a) -> Local r (WriteOnceT mark w m) a

MonadIdentity mark => LiftDraft (WriteOnceT mark w)

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

liftDraft :: (Monad m, Monoid w0) => Draft w0 m (OutputT (WriteOnceT mark w) a) -> Draft w0 (WriteOnceT mark w m) a

MonadIdentity mark => LiftCatch (WriteOnceT mark w)

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

liftCatch :: Monad m => Catch e m (OutputT (WriteOnceT mark w) a) -> Catch e (WriteOnceT mark w m) a

MonadIdentity mark => RunMonadTrans (WriteOnceT mark w)

Defined in Control.FX.Monad.Trans.WriteOnceT

Associated Types

data InputT (WriteOnceT mark w) :: Type

data OutputT (WriteOnceT mark w) a :: Type

Methods

runT :: Monad m => InputT (WriteOnceT mark w) -> WriteOnceT mark w m a -> m (OutputT (WriteOnceT mark w) a)

MonadIdentity mark => MonadTrans (WriteOnceT mark w)

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

lift :: Monad m => m a -> WriteOnceT mark w m a

MonadIdentity mark => MonadFunctor (WriteOnceT mark w)

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

hoist :: (Monad m, Monad n) => (forall u. m u -> n u) -> WriteOnceT mark w m a -> WriteOnceT mark w n a

MonadIdentity mark => ComposableT (WriteOnceT mark w)

Defined in Control.FX.Monad.Trans.ComposeT

Associated Types

data ComposeT (WriteOnceT mark w) t2 m a :: Type

Methods

toComposeT :: WriteOnceT mark w (t2 m) a -> ComposeT (WriteOnceT mark w) t2 m a

unComposeT :: ComposeT (WriteOnceT mark w) t2 m a -> WriteOnceT mark w (t2 m) a

MonadIdentity mark => OverableT (WriteOnceT mark w)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Associated Types

data OverTT (WriteOnceT mark w) u t m a :: Type

Methods

toOverTT :: WriteOnceT mark w (u t m) a -> OverTT (WriteOnceT mark w) u t m a

unOverTT :: OverTT (WriteOnceT mark w) u t m a -> WriteOnceT mark w (u t m) a

(Monad m, MonadIdentity mark) => Monad (WriteOnceT mark w m)

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

(>>=) :: WriteOnceT mark w m a -> (a -> WriteOnceT mark w m b) -> WriteOnceT mark w m b

(>>) :: WriteOnceT mark w m a -> WriteOnceT mark w m b -> WriteOnceT mark w m b

return :: a -> WriteOnceT mark w m a

fail :: String -> WriteOnceT mark w m a

(Monad m, MonadIdentity mark) => Functor (WriteOnceT mark w m)

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

fmap :: (a -> b) -> WriteOnceT mark w m a -> WriteOnceT mark w m b

(<$) :: a -> WriteOnceT mark w m b -> WriteOnceT mark w m a

(Monad m, MonadIdentity mark) => Applicative (WriteOnceT mark w m)

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

pure :: a -> WriteOnceT mark w m a

(<*>) :: WriteOnceT mark w m (a -> b) -> WriteOnceT mark w m a -> WriteOnceT mark w m b

liftA2 :: (a -> b -> c) -> WriteOnceT mark w m a -> WriteOnceT mark w m b -> WriteOnceT mark w m c

(*>) :: WriteOnceT mark w m a -> WriteOnceT mark w m b -> WriteOnceT mark w m b

(<*) :: WriteOnceT mark w m a -> WriteOnceT mark w m b -> WriteOnceT mark w m a

(EqIn m, MonadIdentity mark, Eq w) => EqIn (WriteOnceT mark w m)

Defined in Control.FX.Monad.Trans.WriteOnceT

Associated Types

data Context (WriteOnceT mark w m) :: Type

Methods

eqIn :: Eq a => Context (WriteOnceT mark w m) -> WriteOnceT mark w m a -> WriteOnceT mark w m a -> Bool

(Typeable w, Typeable m, Typeable a, Typeable mark) => Show (WriteOnceT mark w m a)

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

showsPrec :: Int -> WriteOnceT mark w m a -> ShowS

show :: WriteOnceT mark w m a -> String

showList :: [WriteOnceT mark w m a] -> ShowS

newtype InputT (WriteOnceT mark w)

Defined in Control.FX.Monad.Trans.WriteOnceT

newtype InputT (WriteOnceT mark w) = WriteOnceTIn {

• unWriteOnceTIn :: mark ()

}

newtype OutputT (WriteOnceT mark w) a

Defined in Control.FX.Monad.Trans.WriteOnceT

newtype OutputT (WriteOnceT mark w) a = WriteOnceTOut {

• unWriteOnceTOut :: Pair (mark (Maybe w)) a

}

newtype ComposeT (WriteOnceT mark w) t2 m a

Defined in Control.FX.Monad.Trans.ComposeT

newtype ComposeT (WriteOnceT mark w) t2 m a = ComposeT_WriteOnceT {

• unComposeT_WriteOnceT :: WriteOnceT mark w (t2 m) a

}

newtype OverTT (WriteOnceT mark w) u t m a

Defined in Control.FX.Monad.Trans.Trans.OverTT

newtype OverTT (WriteOnceT mark w) u t m a = OverTT_WriteOnceT {

• unOverTT_WriteOnceT :: WriteOnceT mark w (u t m) a

}

newtype Context (WriteOnceT mark w m)

Defined in Control.FX.Monad.Trans.WriteOnceT

newtype Context (WriteOnceT mark w m) = WriteOnceTCtx {

• unWriteOnceTCtx :: (mark (), Context m)

}

runWriteOnceT :: (Monad m, MonadIdentity mark) => WriteOnceT mark w m a -> m (Pair (mark (Maybe w)) a)

newtype AppendOnlyT (mark :: * -> *) (w :: *) (m :: * -> *) (a :: *)

Concrete State monad transformer

Constructors

AppendOnlyT

Fields

• unAppendOnlyT :: w -> m (Pair w a)

Instances

(Monad m, MonadIdentity mark, MonadIdentity mark1, Monoid w, MonadPrompt mark p m) => MonadPrompt mark p (AppendOnlyT mark1 w m)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

prompt :: mark (p a) -> AppendOnlyT mark1 w m (mark a)

(Monad m, MonadIdentity mark, MonadIdentity mark1, Monoid w, Monoid w1, MonadWriteOnce mark w m) => MonadWriteOnce mark w (AppendOnlyT mark1 w1 m)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

etch :: mark w -> AppendOnlyT mark1 w1 m Bool

press :: AppendOnlyT mark1 w1 m (Maybe (mark w))

(Monad m, MonadIdentity mark, MonadIdentity mark1, Monoid w, Monoid w1, MonadAppendOnly mark w m) => MonadAppendOnly mark w (AppendOnlyT mark1 w1 m)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

look :: AppendOnlyT mark1 w1 m (mark w)

jot :: mark w -> AppendOnlyT mark1 w1 m ()

(Monad m, MonadIdentity mark, Monoid w) => MonadAppendOnly mark w (AppendOnlyT mark w m)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

look :: AppendOnlyT mark w m (mark w)

jot :: mark w -> AppendOnlyT mark w m ()

(Monad m, MonadTrans t2, Monoid w, MonadIdentity mark) => MonadAppendOnly mark w (ComposeT (AppendOnlyT mark w) t2 m)

Defined in Control.FX.Monad.Trans.ComposeT

Methods

look :: ComposeT (AppendOnlyT mark w) t2 m (mark w)

jot :: mark w -> ComposeT (AppendOnlyT mark w) t2 m ()

(Monad m, MonadIdentity mark, MonadIdentity mark1, Monoid w, MonadReadOnly mark r m) => MonadReadOnly mark r (AppendOnlyT mark1 w m)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

ask :: AppendOnlyT mark1 w m (mark r)

local :: (mark r -> mark r) -> AppendOnlyT mark1 w m a -> AppendOnlyT mark1 w m a

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnly mark w m, Monoid w, Monoid w1) => MonadWriteOnly mark w (AppendOnlyT mark1 w1 m)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

tell :: mark w -> AppendOnlyT mark1 w1 m ()

draft :: AppendOnlyT mark1 w1 m a -> AppendOnlyT mark1 w1 m (Pair (mark w) a)

(Monad m, MonadIdentity mark, MonadIdentity mark1, Monoid w, MonadState mark s m) => MonadState mark s (AppendOnlyT mark1 w m)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

get :: AppendOnlyT mark1 w m (mark s)

put :: mark s -> AppendOnlyT mark1 w m ()

(Monad m, MonadIdentity mark, MonadIdentity mark1, Monoid w, MonadExcept mark e m) => MonadExcept mark e (AppendOnlyT mark1 w m)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

throw :: mark e -> AppendOnlyT mark1 w m a

catch :: AppendOnlyT mark1 w m a -> (mark e -> AppendOnlyT mark1 w m a) -> AppendOnlyT mark1 w m a

(Monad m, MonadTrans t, Monoid w, MonadTransTrans u, MonadIdentity mark) => MonadAppendOnly mark w (OverTT (AppendOnlyT mark w) u t m)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Methods

look :: OverTT (AppendOnlyT mark w) u t m (mark w)

jot :: mark w -> OverTT (AppendOnlyT mark w) u t m ()

(Monad m, MonadIdentity mark1, MonadIdentity mark, Monoid w, MonadHalt mark m) => MonadHalt mark (AppendOnlyT mark1 w m)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

halt :: mark () -> AppendOnlyT mark1 w m a

(Eq (mark w), Eq (Context m)) => Eq (Context (AppendOnlyT mark w m))

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

(==) :: Context (AppendOnlyT mark w m) -> Context (AppendOnlyT mark w m) -> Bool

(/=) :: Context (AppendOnlyT mark w m) -> Context (AppendOnlyT mark w m) -> Bool

Eq (mark ()) => Eq (InputT (AppendOnlyT mark w))

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

(==) :: InputT (AppendOnlyT mark w) -> InputT (AppendOnlyT mark w) -> Bool

(/=) :: InputT (AppendOnlyT mark w) -> InputT (AppendOnlyT mark w) -> Bool

(Show (mark w), Show (Context m)) => Show (Context (AppendOnlyT mark w m))

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

showsPrec :: Int -> Context (AppendOnlyT mark w m) -> ShowS

show :: Context (AppendOnlyT mark w m) -> String

showList :: [Context (AppendOnlyT mark w m)] -> ShowS

Show (mark ()) => Show (InputT (AppendOnlyT mark w))

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

showsPrec :: Int -> InputT (AppendOnlyT mark w) -> ShowS

show :: InputT (AppendOnlyT mark w) -> String

showList :: [InputT (AppendOnlyT mark w)] -> ShowS

(Eq (mark w), Eq a) => Eq (OutputT (AppendOnlyT mark w) a)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

(==) :: OutputT (AppendOnlyT mark w) a -> OutputT (AppendOnlyT mark w) a -> Bool

(/=) :: OutputT (AppendOnlyT mark w) a -> OutputT (AppendOnlyT mark w) a -> Bool

(Show (mark w), Show a) => Show (OutputT (AppendOnlyT mark w) a)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

showsPrec :: Int -> OutputT (AppendOnlyT mark w) a -> ShowS

show :: OutputT (AppendOnlyT mark w) a -> String

showList :: [OutputT (AppendOnlyT mark w) a] -> ShowS

(MonadIdentity mark, Monoid w) => LiftLocal (AppendOnlyT mark w)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

liftLocal :: Monad m => Local r m (OutputT (AppendOnlyT mark w) a) -> Local r (AppendOnlyT mark w m) a

(MonadIdentity mark, Monoid w) => LiftDraft (AppendOnlyT mark w)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

liftDraft :: (Monad m, Monoid w0) => Draft w0 m (OutputT (AppendOnlyT mark w) a) -> Draft w0 (AppendOnlyT mark w m) a

(MonadIdentity mark, Monoid w) => LiftCatch (AppendOnlyT mark w)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

liftCatch :: Monad m => Catch e m (OutputT (AppendOnlyT mark w) a) -> Catch e (AppendOnlyT mark w m) a

(MonadIdentity mark, Monoid w) => RunMonadTrans (AppendOnlyT mark w)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Associated Types

data InputT (AppendOnlyT mark w) :: Type

data OutputT (AppendOnlyT mark w) a :: Type

Methods

runT :: Monad m => InputT (AppendOnlyT mark w) -> AppendOnlyT mark w m a -> m (OutputT (AppendOnlyT mark w) a)

(MonadIdentity mark, Monoid w) => MonadTrans (AppendOnlyT mark w)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

lift :: Monad m => m a -> AppendOnlyT mark w m a

(MonadIdentity mark, Monoid w) => MonadFunctor (AppendOnlyT mark w)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

hoist :: (Monad m, Monad n) => (forall u. m u -> n u) -> AppendOnlyT mark w m a -> AppendOnlyT mark w n a

(MonadIdentity mark, Monoid w) => ComposableT (AppendOnlyT mark w)

Defined in Control.FX.Monad.Trans.ComposeT

Associated Types

data ComposeT (AppendOnlyT mark w) t2 m a :: Type

Methods

toComposeT :: AppendOnlyT mark w (t2 m) a -> ComposeT (AppendOnlyT mark w) t2 m a

unComposeT :: ComposeT (AppendOnlyT mark w) t2 m a -> AppendOnlyT mark w (t2 m) a

(MonadIdentity mark, Monoid w) => OverableT (AppendOnlyT mark w)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Associated Types

data OverTT (AppendOnlyT mark w) u t m a :: Type

Methods

toOverTT :: AppendOnlyT mark w (u t m) a -> OverTT (AppendOnlyT mark w) u t m a

unOverTT :: OverTT (AppendOnlyT mark w) u t m a -> AppendOnlyT mark w (u t m) a

(Monad m, MonadIdentity mark, Monoid w) => Monad (AppendOnlyT mark w m)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

(>>=) :: AppendOnlyT mark w m a -> (a -> AppendOnlyT mark w m b) -> AppendOnlyT mark w m b

(>>) :: AppendOnlyT mark w m a -> AppendOnlyT mark w m b -> AppendOnlyT mark w m b

return :: a -> AppendOnlyT mark w m a

fail :: String -> AppendOnlyT mark w m a

(Monad m, MonadIdentity mark, Monoid w) => Functor (AppendOnlyT mark w m)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

fmap :: (a -> b) -> AppendOnlyT mark w m a -> AppendOnlyT mark w m b

(<$) :: a -> AppendOnlyT mark w m b -> AppendOnlyT mark w m a

(Monad m, MonadIdentity mark, Monoid w) => Applicative (AppendOnlyT mark w m)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

pure :: a -> AppendOnlyT mark w m a

(<*>) :: AppendOnlyT mark w m (a -> b) -> AppendOnlyT mark w m a -> AppendOnlyT mark w m b

liftA2 :: (a -> b -> c) -> AppendOnlyT mark w m a -> AppendOnlyT mark w m b -> AppendOnlyT mark w m c

(*>) :: AppendOnlyT mark w m a -> AppendOnlyT mark w m b -> AppendOnlyT mark w m b

(<*) :: AppendOnlyT mark w m a -> AppendOnlyT mark w m b -> AppendOnlyT mark w m a

(EqIn m, MonadIdentity mark, Eq w) => EqIn (AppendOnlyT mark w m)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Associated Types

data Context (AppendOnlyT mark w m) :: Type

Methods

eqIn :: Eq a => Context (AppendOnlyT mark w m) -> AppendOnlyT mark w m a -> AppendOnlyT mark w m a -> Bool

(Typeable w, Typeable m, Typeable a, Typeable mark) => Show (AppendOnlyT mark w m a)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

showsPrec :: Int -> AppendOnlyT mark w m a -> ShowS

show :: AppendOnlyT mark w m a -> String

showList :: [AppendOnlyT mark w m a] -> ShowS

newtype InputT (AppendOnlyT mark w)

Defined in Control.FX.Monad.Trans.AppendOnlyT

newtype InputT (AppendOnlyT mark w) = AppendOnlyTIn {

• unAppendOnlyTIn :: mark ()

}

newtype OutputT (AppendOnlyT mark w) a

Defined in Control.FX.Monad.Trans.AppendOnlyT

newtype OutputT (AppendOnlyT mark w) a = AppendOnlyTOut {

• unAppendOnlyTOut :: Pair (mark w) a

}

newtype ComposeT (AppendOnlyT mark w) t2 m a

Defined in Control.FX.Monad.Trans.ComposeT

newtype ComposeT (AppendOnlyT mark w) t2 m a = ComposeT_AppendOnlyT {

• unComposeT_AppendOnlyT :: AppendOnlyT mark w (t2 m) a

}

newtype OverTT (AppendOnlyT mark w) u t m a

Defined in Control.FX.Monad.Trans.Trans.OverTT

newtype OverTT (AppendOnlyT mark w) u t m a = OverTT_AppendOnlyT {

• unOverTT_AppendOnlyT :: AppendOnlyT mark w (u t m) a

}

newtype Context (AppendOnlyT mark w m)

Defined in Control.FX.Monad.Trans.AppendOnlyT

newtype Context (AppendOnlyT mark w m) = AppendOnlyTCtx {

• unAppendOnlyTCtx :: (mark w, Context m)

}

runAppendOnlyT :: (Monad m, MonadIdentity mark, Monoid w) => AppendOnlyT mark w m a -> m (Pair (mark w) a)

Transformer Transformers

data IdentityTT (t :: (* -> *) -> * -> *) (m :: * -> *) (a :: *)

Concrete identity monad transformer transformer

Constructors

IdentityTT

Fields

• unIdentityTT :: t m a

Instances

LiftLocalT IdentityTT

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

liftLocalT :: (Monad m, MonadTrans t) => (forall x. Local r (t m) (OutputTT IdentityTT x)) -> forall x. Local r (IdentityTT t m) x

LiftDraftT IdentityTT

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

liftDraftT :: (Monad m, MonadTrans t, Monoid w) => (forall x. Draft w (t m) (OutputTT IdentityTT x)) -> forall x. Draft w (IdentityTT t m) x

LiftCatchT IdentityTT

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

liftCatchT :: (Monad m, MonadTrans t) => (forall x. Catch e (t m) (OutputTT IdentityTT x)) -> forall x. Catch e (IdentityTT t m) x

RunMonadTransTrans IdentityTT

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Associated Types

data InputTT IdentityTT m :: Type

data OutputTT IdentityTT a :: Type

Methods

runTT :: (Monad m, MonadTrans t) => InputTT IdentityTT m -> IdentityTT t m a -> t m (OutputTT IdentityTT a)

MonadTransTrans IdentityTT

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

liftT :: (Monad m, MonadTrans t) => t m a -> IdentityTT t m a

(Monad m, MonadTrans t, MonadIdentity mark, MonadPrompt mark p (t m)) => MonadPrompt mark p (IdentityTT t m)

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

prompt :: mark (p a) -> IdentityTT t m (mark a)

(Monad m, MonadTrans t, MonadIdentity mark, MonadWriteOnce mark w (t m)) => MonadWriteOnce mark w (IdentityTT t m)

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

etch :: mark w -> IdentityTT t m Bool

press :: IdentityTT t m (Maybe (mark w))

(Monad m, MonadTrans t, MonadIdentity mark, MonadAppendOnly mark w (t m), Monoid w) => MonadAppendOnly mark w (IdentityTT t m)

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

look :: IdentityTT t m (mark w)

jot :: mark w -> IdentityTT t m ()

(Monad m, MonadTrans t, MonadIdentity mark, MonadReadOnly mark r (t m)) => MonadReadOnly mark r (IdentityTT t m)

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

ask :: IdentityTT t m (mark r)

local :: (mark r -> mark r) -> IdentityTT t m a -> IdentityTT t m a

(Monad m, MonadTrans t, MonadIdentity mark, MonadWriteOnly mark w (t m), Monoid w) => MonadWriteOnly mark w (IdentityTT t m)

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

tell :: mark w -> IdentityTT t m ()

draft :: IdentityTT t m a -> IdentityTT t m (Pair (mark w) a)

(Monad m, MonadTrans t, MonadIdentity mark, MonadState mark s (t m)) => MonadState mark s (IdentityTT t m)

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

get :: IdentityTT t m (mark s)

put :: mark s -> IdentityTT t m ()

(Monad m, MonadTrans t, MonadIdentity mark, MonadExcept mark e (t m)) => MonadExcept mark e (IdentityTT t m)

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

throw :: mark e -> IdentityTT t m a

catch :: IdentityTT t m a -> (mark e -> IdentityTT t m a) -> IdentityTT t m a

(Monad m, MonadTrans t, MonadIdentity mark, MonadHalt mark (t m)) => MonadHalt mark (IdentityTT t m)

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

halt :: mark () -> IdentityTT t m a

Eq (Context (t m)) => Eq (Context (IdentityTT t m))

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

(==) :: Context (IdentityTT t m) -> Context (IdentityTT t m) -> Bool

(/=) :: Context (IdentityTT t m) -> Context (IdentityTT t m) -> Bool

Show (Context (t m)) => Show (Context (IdentityTT t m))

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

showsPrec :: Int -> Context (IdentityTT t m) -> ShowS

show :: Context (IdentityTT t m) -> String

showList :: [Context (IdentityTT t m)] -> ShowS

MonadTrans t => MonadTrans (IdentityTT t)

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

lift :: Monad m => m a -> IdentityTT t m a

MonadFunctor t => MonadFunctor (IdentityTT t)

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

hoist :: (Monad m, Monad n) => (forall u. m u -> n u) -> IdentityTT t m a -> IdentityTT t n a

Eq (InputTT IdentityTT m)

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

(==) :: InputTT IdentityTT m -> InputTT IdentityTT m -> Bool

(/=) :: InputTT IdentityTT m -> InputTT IdentityTT m -> Bool

Eq a => Eq (OutputTT IdentityTT a)

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

(==) :: OutputTT IdentityTT a -> OutputTT IdentityTT a -> Bool

(/=) :: OutputTT IdentityTT a -> OutputTT IdentityTT a -> Bool

(Monad m, MonadTrans t) => Monad (IdentityTT t m)

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

(>>=) :: IdentityTT t m a -> (a -> IdentityTT t m b) -> IdentityTT t m b

(>>) :: IdentityTT t m a -> IdentityTT t m b -> IdentityTT t m b

return :: a -> IdentityTT t m a

fail :: String -> IdentityTT t m a

(Monad m, MonadTrans t) => Functor (IdentityTT t m)

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

fmap :: (a -> b) -> IdentityTT t m a -> IdentityTT t m b

(<$) :: a -> IdentityTT t m b -> IdentityTT t m a

Show (InputTT IdentityTT m)

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

showsPrec :: Int -> InputTT IdentityTT m -> ShowS

show :: InputTT IdentityTT m -> String

showList :: [InputTT IdentityTT m] -> ShowS

Show a => Show (OutputTT IdentityTT a)

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

showsPrec :: Int -> OutputTT IdentityTT a -> ShowS

show :: OutputTT IdentityTT a -> String

showList :: [OutputTT IdentityTT a] -> ShowS

(Monad m, MonadTrans t) => Applicative (IdentityTT t m)

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

pure :: a -> IdentityTT t m a

(<*>) :: IdentityTT t m (a -> b) -> IdentityTT t m a -> IdentityTT t m b

liftA2 :: (a -> b -> c) -> IdentityTT t m a -> IdentityTT t m b -> IdentityTT t m c

(*>) :: IdentityTT t m a -> IdentityTT t m b -> IdentityTT t m b

(<*) :: IdentityTT t m a -> IdentityTT t m b -> IdentityTT t m a

EqIn (t m) => EqIn (IdentityTT t m)

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Associated Types

data Context (IdentityTT t m) :: Type

Methods

eqIn :: Eq a => Context (IdentityTT t m) -> IdentityTT t m a -> IdentityTT t m a -> Bool

(Monad m, MonadTrans t, MonadIdentity (t m)) => MonadIdentity (IdentityTT t m)

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

unwrap :: IdentityTT t m a -> a

Eq (t m a) => Eq (IdentityTT t m a)

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

(==) :: IdentityTT t m a -> IdentityTT t m a -> Bool

(/=) :: IdentityTT t m a -> IdentityTT t m a -> Bool

Show (t m a) => Show (IdentityTT t m a)

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

showsPrec :: Int -> IdentityTT t m a -> ShowS

show :: IdentityTT t m a -> String

showList :: [IdentityTT t m a] -> ShowS

(Monad m, Semigroup a, MonadIdentity (t m)) => Semigroup (IdentityTT t m a)

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

(<>) :: IdentityTT t m a -> IdentityTT t m a -> IdentityTT t m a

sconcat :: NonEmpty (IdentityTT t m a) -> IdentityTT t m a

stimes :: Integral b => b -> IdentityTT t m a -> IdentityTT t m a

(Monad m, Monoid a, MonadIdentity (t m)) => Monoid (IdentityTT t m a)

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

mempty :: IdentityTT t m a

mappend :: IdentityTT t m a -> IdentityTT t m a -> IdentityTT t m a

mconcat :: [IdentityTT t m a] -> IdentityTT t m a

newtype InputTT IdentityTT m

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

newtype InputTT IdentityTT m = IdentityTTIn {

• unIdentityTTIn :: ()

}

newtype OutputTT IdentityTT a

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

newtype OutputTT IdentityTT a = IdentityTTOut {

• unIdentityTTOut :: Identity a

}

newtype Context (IdentityTT t m)

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

newtype Context (IdentityTT t m) = IdentityTTCtx {

• unIdentityTTCtx :: Context (t m)

}

runIdentityTT :: (Monad m, MonadTrans t) => IdentityTT t m a -> t m (Identity a)

data PromptTT (mark :: * -> *) (p :: * -> *) (t :: (* -> *) -> * -> *) (m :: * -> *) (a :: *)

Concrete prompt monad transformer transformer

Constructors

PromptTT

Fields

• unPromptTT :: forall v. (a -> t m v) -> (forall u. p u -> (u -> t m v) -> t m v) -> t m v

Instances

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Commutant mark1, forall (x :: Type -> Type). Monad x => MonadPrompt mark p (t x)) => MonadPrompt mark p (PromptTT mark1 p1 t m)

Defined in Control.FX.Monad.Trans.Trans.PromptTT

Methods

prompt :: mark (p a) -> PromptTT mark1 p1 t m (mark a)

(Monad m, MonadTrans t, MonadIdentity mark) => MonadPrompt mark p (PromptTT mark p t m)

Defined in Control.FX.Monad.Trans.Trans.PromptTT

Methods

prompt :: mark (p a) -> PromptTT mark p t m (mark a)

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Commutant mark1, forall (x :: Type -> Type). Monad x => MonadWriteOnce mark w (t x)) => MonadWriteOnce mark w (PromptTT mark1 p t m)

Defined in Control.FX.Monad.Trans.Trans.PromptTT

Methods

etch :: mark w -> PromptTT mark1 p t m Bool

press :: PromptTT mark1 p t m (Maybe (mark w))

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Commutant mark1, Monoid w, forall (x :: Type -> Type). Monad x => MonadAppendOnly mark w (t x)) => MonadAppendOnly mark w (PromptTT mark1 p t m)

Defined in Control.FX.Monad.Trans.Trans.PromptTT

Methods

look :: PromptTT mark1 p t m (mark w)

jot :: mark w -> PromptTT mark1 p t m ()

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Commutant mark1, forall (x :: Type -> Type). Monad x => MonadReadOnly mark r (t x)) => MonadReadOnly mark r (PromptTT mark1 p t m)

Defined in Control.FX.Monad.Trans.Trans.PromptTT

Methods

ask :: PromptTT mark1 p t m (mark r)

local :: (mark r -> mark r) -> PromptTT mark1 p t m a -> PromptTT mark1 p t m a

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadState mark s (t x)) => MonadState mark s (PromptTT mark1 p t m)

Defined in Control.FX.Monad.Trans.Trans.PromptTT

Methods

get :: PromptTT mark1 p t m (mark s)

put :: mark s -> PromptTT mark1 p t m ()

MonadIdentity mark => Monad (OutputTT (PromptTT mark p))

Defined in Control.FX.Monad.Trans.Trans.PromptTT

Methods

(>>=) :: OutputTT (PromptTT mark p) a -> (a -> OutputTT (PromptTT mark p) b) -> OutputTT (PromptTT mark p) b

(>>) :: OutputTT (PromptTT mark p) a -> OutputTT (PromptTT mark p) b -> OutputTT (PromptTT mark p) b

return :: a -> OutputTT (PromptTT mark p) a

fail :: String -> OutputTT (PromptTT mark p) a

MonadIdentity mark => Functor (OutputTT (PromptTT mark p))

Defined in Control.FX.Monad.Trans.Trans.PromptTT

Methods

fmap :: (a -> b) -> OutputTT (PromptTT mark p) a -> OutputTT (PromptTT mark p) b

(<$) :: a -> OutputTT (PromptTT mark p) b -> OutputTT (PromptTT mark p) a

(Typeable mark, Typeable p, Typeable t, Typeable m) => Show (Context (PromptTT mark p t m))

Defined in Control.FX.Monad.Trans.Trans.PromptTT

Methods

showsPrec :: Int -> Context (PromptTT mark p t m) -> ShowS

show :: Context (PromptTT mark p t m) -> String

showList :: [Context (PromptTT mark p t m)] -> ShowS

MonadIdentity mark => Applicative (OutputTT (PromptTT mark p))

Defined in Control.FX.Monad.Trans.Trans.PromptTT

Methods

pure :: a -> OutputTT (PromptTT mark p) a

(<*>) :: OutputTT (PromptTT mark p) (a -> b) -> OutputTT (PromptTT mark p) a -> OutputTT (PromptTT mark p) b

liftA2 :: (a -> b -> c) -> OutputTT (PromptTT mark p) a -> OutputTT (PromptTT mark p) b -> OutputTT (PromptTT mark p) c

(*>) :: OutputTT (PromptTT mark p) a -> OutputTT (PromptTT mark p) b -> OutputTT (PromptTT mark p) b

(<*) :: OutputTT (PromptTT mark p) a -> OutputTT (PromptTT mark p) b -> OutputTT (PromptTT mark p) a

MonadIdentity mark => MonadIdentity (OutputTT (PromptTT mark p))

Defined in Control.FX.Monad.Trans.Trans.PromptTT

Methods

unwrap :: OutputTT (PromptTT mark p) a -> a

Eq (mark a) => Eq (OutputTT (PromptTT mark p) a)

Defined in Control.FX.Monad.Trans.Trans.PromptTT

Methods

(==) :: OutputTT (PromptTT mark p) a -> OutputTT (PromptTT mark p) a -> Bool

(/=) :: OutputTT (PromptTT mark p) a -> OutputTT (PromptTT mark p) a -> Bool

(Typeable mark, Typeable p, Typeable m) => Show (InputTT (PromptTT mark p) m)

Defined in Control.FX.Monad.Trans.Trans.PromptTT

Methods

showsPrec :: Int -> InputTT (PromptTT mark p) m -> ShowS

show :: InputTT (PromptTT mark p) m -> String

showList :: [InputTT (PromptTT mark p) m] -> ShowS

Show (mark a) => Show (OutputTT (PromptTT mark p) a)

Defined in Control.FX.Monad.Trans.Trans.PromptTT

Methods

showsPrec :: Int -> OutputTT (PromptTT mark p) a -> ShowS

show :: OutputTT (PromptTT mark p) a -> String

showList :: [OutputTT (PromptTT mark p) a] -> ShowS

(MonadIdentity mark, Semigroup a) => Semigroup (OutputTT (PromptTT mark p) a)

Defined in Control.FX.Monad.Trans.Trans.PromptTT

Methods

(<>) :: OutputTT (PromptTT mark p) a -> OutputTT (PromptTT mark p) a -> OutputTT (PromptTT mark p) a

sconcat :: NonEmpty (OutputTT (PromptTT mark p) a) -> OutputTT (PromptTT mark p) a

stimes :: Integral b => b -> OutputTT (PromptTT mark p) a -> OutputTT (PromptTT mark p) a

(MonadIdentity mark, Monoid a) => Monoid (OutputTT (PromptTT mark p) a)

Defined in Control.FX.Monad.Trans.Trans.PromptTT

Methods

mempty :: OutputTT (PromptTT mark p) a

mappend :: OutputTT (PromptTT mark p) a -> OutputTT (PromptTT mark p) a -> OutputTT (PromptTT mark p) a

mconcat :: [OutputTT (PromptTT mark p) a] -> OutputTT (PromptTT mark p) a

(MonadIdentity mark, Commutant mark) => RunMonadTransTrans (PromptTT mark p)

Defined in Control.FX.Monad.Trans.Trans.PromptTT

Associated Types

data InputTT (PromptTT mark p) m :: Type

data OutputTT (PromptTT mark p) a :: Type

Methods

runTT :: (Monad m, MonadTrans t) => InputTT (PromptTT mark p) m -> PromptTT mark p t m a -> t m (OutputTT (PromptTT mark p) a)

MonadIdentity mark => MonadTransTrans (PromptTT mark p)

Defined in Control.FX.Monad.Trans.Trans.PromptTT

Methods

liftT :: (Monad m, MonadTrans t) => t m a -> PromptTT mark p t m a

(MonadTrans t, MonadIdentity mark) => MonadTrans (PromptTT mark p t)

Defined in Control.FX.Monad.Trans.Trans.PromptTT

Methods

lift :: Monad m => m a -> PromptTT mark p t m a

(Monad m, MonadTrans t, MonadIdentity mark) => Monad (PromptTT mark p t m)

Defined in Control.FX.Monad.Trans.Trans.PromptTT

Methods

(>>=) :: PromptTT mark p t m a -> (a -> PromptTT mark p t m b) -> PromptTT mark p t m b

(>>) :: PromptTT mark p t m a -> PromptTT mark p t m b -> PromptTT mark p t m b

return :: a -> PromptTT mark p t m a

fail :: String -> PromptTT mark p t m a

(Monad m, MonadTrans t, MonadIdentity mark) => Functor (PromptTT mark p t m)

Defined in Control.FX.Monad.Trans.Trans.PromptTT

Methods

fmap :: (a -> b) -> PromptTT mark p t m a -> PromptTT mark p t m b

(<$) :: a -> PromptTT mark p t m b -> PromptTT mark p t m a

(Monad m, MonadTrans t, MonadIdentity mark) => Applicative (PromptTT mark p t m)

Defined in Control.FX.Monad.Trans.Trans.PromptTT

Methods

pure :: a -> PromptTT mark p t m a

(<*>) :: PromptTT mark p t m (a -> b) -> PromptTT mark p t m a -> PromptTT mark p t m b

liftA2 :: (a -> b -> c) -> PromptTT mark p t m a -> PromptTT mark p t m b -> PromptTT mark p t m c

(*>) :: PromptTT mark p t m a -> PromptTT mark p t m b -> PromptTT mark p t m b

(<*) :: PromptTT mark p t m a -> PromptTT mark p t m b -> PromptTT mark p t m a

(Monad m, MonadTrans t, MonadIdentity mark, Commutant mark, EqIn (t m)) => EqIn (PromptTT mark p t m)

Defined in Control.FX.Monad.Trans.Trans.PromptTT

Associated Types

data Context (PromptTT mark p t m) :: Type

Methods

eqIn :: Eq a => Context (PromptTT mark p t m) -> PromptTT mark p t m a -> PromptTT mark p t m a -> Bool

(Typeable p, Typeable t, Typeable m, Typeable a, Typeable mark) => Show (PromptTT mark p t m a)

Defined in Control.FX.Monad.Trans.Trans.PromptTT

Methods

showsPrec :: Int -> PromptTT mark p t m a -> ShowS

show :: PromptTT mark p t m a -> String

showList :: [PromptTT mark p t m a] -> ShowS

newtype InputTT (PromptTT mark p) m

Defined in Control.FX.Monad.Trans.Trans.PromptTT

newtype InputTT (PromptTT mark p) m = PromptTTIn {

• unPromptTTIn :: Eval p m

}

newtype OutputTT (PromptTT mark p) a

Defined in Control.FX.Monad.Trans.Trans.PromptTT

newtype OutputTT (PromptTT mark p) a = PromptTTOut {

• unPromptTTOut :: mark a

}

newtype Context (PromptTT mark p t m)

Defined in Control.FX.Monad.Trans.Trans.PromptTT

newtype Context (PromptTT mark p t m) = PromptTTCtx {

• unPromptTTCtx :: (Eval p m, Context (t m))

}

runPromptTT :: (Monad m, MonadTrans t, MonadIdentity mark, Commutant mark) => Eval p m -> PromptTT mark p t m a -> t m (mark a)

data Eval (p :: * -> *) (m :: * -> *)

Helper type for running prompt computations

Constructors

Eval

Fields

• unEval :: forall u. p u -> m u

Instances

(Typeable p, Typeable m) => Show (Eval p m)

Defined in Control.FX.Monad.Trans.Trans.PromptTT

Methods

showsPrec :: Int -> Eval p m -> ShowS

show :: Eval p m -> String

showList :: [Eval p m] -> ShowS

runOverTT :: (RunMonadTransTrans u, RunMonadTrans v, OverableT v, Monad m, MonadTrans t, MonadTrans v) => InputTT u m -> InputT v -> OverTT v u t m a -> t m (OutputTT u (OutputT v a))

class MonadTrans v => OverableT v where

Associated Types

data OverTT (v :: (* -> *) -> * -> *) (u :: ((* -> *) -> * -> *) -> (* -> *) -> * -> *) (t :: (* -> *) -> * -> *) (m :: * -> *) (a :: *)

Concrete monad transformer transformer which applies a monad functor

Methods

toOverTT :: v (u t m) a -> OverTT v u t m a

unOverTT :: OverTT v u t m a -> v (u t m) a

Instances

OverableT IdentityT

Defined in Control.FX.Monad.Trans.Trans.OverTT

Associated Types

data OverTT IdentityT u t m a :: Type

Methods

toOverTT :: IdentityT (u t m) a -> OverTT IdentityT u t m a

unOverTT :: OverTT IdentityT u t m a -> IdentityT (u t m) a

MonadIdentity mark => OverableT (HaltT mark)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Associated Types

data OverTT (HaltT mark) u t m a :: Type

Methods

toOverTT :: HaltT mark (u t m) a -> OverTT (HaltT mark) u t m a

unOverTT :: OverTT (HaltT mark) u t m a -> HaltT mark (u t m) a

(MonadIdentity mark, Monoid w) => OverableT (WriteOnlyT mark w)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Associated Types

data OverTT (WriteOnlyT mark w) u t m a :: Type

Methods

toOverTT :: WriteOnlyT mark w (u t m) a -> OverTT (WriteOnlyT mark w) u t m a

unOverTT :: OverTT (WriteOnlyT mark w) u t m a -> WriteOnlyT mark w (u t m) a

MonadIdentity mark => OverableT (WriteOnceT mark w)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Associated Types

data OverTT (WriteOnceT mark w) u t m a :: Type

Methods

toOverTT :: WriteOnceT mark w (u t m) a -> OverTT (WriteOnceT mark w) u t m a

unOverTT :: OverTT (WriteOnceT mark w) u t m a -> WriteOnceT mark w (u t m) a

MonadIdentity mark => OverableT (StateT mark s)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Associated Types

data OverTT (StateT mark s) u t m a :: Type

Methods

toOverTT :: StateT mark s (u t m) a -> OverTT (StateT mark s) u t m a

unOverTT :: OverTT (StateT mark s) u t m a -> StateT mark s (u t m) a

MonadIdentity mark => OverableT (ReadOnlyT mark r)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Associated Types

data OverTT (ReadOnlyT mark r) u t m a :: Type

Methods

toOverTT :: ReadOnlyT mark r (u t m) a -> OverTT (ReadOnlyT mark r) u t m a

unOverTT :: OverTT (ReadOnlyT mark r) u t m a -> ReadOnlyT mark r (u t m) a

MonadIdentity mark => OverableT (ExceptT mark e)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Associated Types

data OverTT (ExceptT mark e) u t m a :: Type

Methods

toOverTT :: ExceptT mark e (u t m) a -> OverTT (ExceptT mark e) u t m a

unOverTT :: OverTT (ExceptT mark e) u t m a -> ExceptT mark e (u t m) a

(MonadIdentity mark, Monoid w) => OverableT (AppendOnlyT mark w)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Associated Types

data OverTT (AppendOnlyT mark w) u t m a :: Type

Methods

toOverTT :: AppendOnlyT mark w (u t m) a -> OverTT (AppendOnlyT mark w) u t m a

unOverTT :: OverTT (AppendOnlyT mark w) u t m a -> AppendOnlyT mark w (u t m) a

newtype StateTT (mark :: * -> *) (s :: *) (t :: (* -> *) -> * -> *) (m :: * -> *) (a :: *)

Constructors

StateTT

Fields

• unStateTT :: StateT mark s (t m) a

Instances

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadPrompt mark p (t x)) => MonadPrompt mark p (StateTT mark1 s t m)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

prompt :: mark (p a) -> StateTT mark1 s t m (mark a)

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadWriteOnce mark w (t x)) => MonadWriteOnce mark w (StateTT mark1 s t m)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

etch :: mark w -> StateTT mark1 s t m Bool

press :: StateTT mark1 s t m (Maybe (mark w))

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Monoid w, forall (x :: Type -> Type). Monad x => MonadAppendOnly mark w (t x)) => MonadAppendOnly mark w (StateTT mark1 s t m)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

look :: StateTT mark1 s t m (mark w)

jot :: mark w -> StateTT mark1 s t m ()

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadReadOnly mark r (t x)) => MonadReadOnly mark r (StateTT mark1 s t m)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

ask :: StateTT mark1 s t m (mark r)

local :: (mark r -> mark r) -> StateTT mark1 s t m a -> StateTT mark1 s t m a

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Monoid w, forall (x :: Type -> Type). Monad x => MonadWriteOnly mark w (t x)) => MonadWriteOnly mark w (StateTT mark1 s t m)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

tell :: mark w -> StateTT mark1 s t m ()

draft :: StateTT mark1 s t m a -> StateTT mark1 s t m (Pair (mark w) a)

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadState mark s (t x)) => MonadState mark s (StateTT mark1 s1 t m)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

get :: StateTT mark1 s1 t m (mark s)

put :: mark s -> StateTT mark1 s1 t m ()

(Monad m, MonadTrans t, MonadIdentity mark) => MonadState mark s (StateTT mark s t m)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

get :: StateTT mark s t m (mark s)

put :: mark s -> StateTT mark s t m ()

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadExcept mark e (t x)) => MonadExcept mark e (StateTT mark1 s t m)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

throw :: mark e -> StateTT mark1 s t m a

catch :: StateTT mark1 s t m a -> (mark e -> StateTT mark1 s t m a) -> StateTT mark1 s t m a

(Monad m, MonadTrans t, MonadIdentity mark1, MonadIdentity mark, forall (x :: Type -> Type). Monad x => MonadHalt mark (t x)) => MonadHalt mark (StateTT mark1 s t m)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

halt :: mark () -> StateTT mark1 s t m a

(Eq (mark s), Eq (Context (t m))) => Eq (Context (StateTT mark s t m))

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

(==) :: Context (StateTT mark s t m) -> Context (StateTT mark s t m) -> Bool

(/=) :: Context (StateTT mark s t m) -> Context (StateTT mark s t m) -> Bool

(Show (mark s), Show (Context (t m))) => Show (Context (StateTT mark s t m))

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

showsPrec :: Int -> Context (StateTT mark s t m) -> ShowS

show :: Context (StateTT mark s t m) -> String

showList :: [Context (StateTT mark s t m)] -> ShowS

Eq (mark s) => Eq (InputTT (StateTT mark s) m)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

(==) :: InputTT (StateTT mark s) m -> InputTT (StateTT mark s) m -> Bool

(/=) :: InputTT (StateTT mark s) m -> InputTT (StateTT mark s) m -> Bool

(Eq (mark s), Eq a) => Eq (OutputTT (StateTT mark s) a)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

(==) :: OutputTT (StateTT mark s) a -> OutputTT (StateTT mark s) a -> Bool

(/=) :: OutputTT (StateTT mark s) a -> OutputTT (StateTT mark s) a -> Bool

Show (mark s) => Show (InputTT (StateTT mark s) m)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

showsPrec :: Int -> InputTT (StateTT mark s) m -> ShowS

show :: InputTT (StateTT mark s) m -> String

showList :: [InputTT (StateTT mark s) m] -> ShowS

(Show (mark s), Show a) => Show (OutputTT (StateTT mark s) a)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

showsPrec :: Int -> OutputTT (StateTT mark s) a -> ShowS

show :: OutputTT (StateTT mark s) a -> String

showList :: [OutputTT (StateTT mark s) a] -> ShowS

MonadIdentity mark => LiftLocalT (StateTT mark s)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

liftLocalT :: (Monad m, MonadTrans t) => (forall x. Local r (t m) (OutputTT (StateTT mark s) x)) -> forall x. Local r (StateTT mark s t m) x

MonadIdentity mark => LiftDraftT (StateTT mark s)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

liftDraftT :: (Monad m, MonadTrans t, Monoid w) => (forall x. Draft w (t m) (OutputTT (StateTT mark s) x)) -> forall x. Draft w (StateTT mark s t m) x

MonadIdentity mark => LiftCatchT (StateTT mark s)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

liftCatchT :: (Monad m, MonadTrans t) => (forall x. Catch e (t m) (OutputTT (StateTT mark s) x)) -> forall x. Catch e (StateTT mark s t m) x

MonadIdentity mark => RunMonadTransTrans (StateTT mark s)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Associated Types

data InputTT (StateTT mark s) m :: Type

data OutputTT (StateTT mark s) a :: Type

Methods

runTT :: (Monad m, MonadTrans t) => InputTT (StateTT mark s) m -> StateTT mark s t m a -> t m (OutputTT (StateTT mark s) a)

MonadIdentity mark => MonadTransTrans (StateTT mark s)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

liftT :: (Monad m, MonadTrans t) => t m a -> StateTT mark s t m a

(MonadTrans t, MonadIdentity mark) => MonadTrans (StateTT mark s t)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

lift :: Monad m => m a -> StateTT mark s t m a

(MonadFunctor t, MonadIdentity mark) => MonadFunctor (StateTT mark s t)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

hoist :: (Monad m, Monad n) => (forall u. m u -> n u) -> StateTT mark s t m a -> StateTT mark s t n a

(MonadIdentity mark, Monad (t m)) => Monad (StateTT mark s t m)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

(>>=) :: StateTT mark s t m a -> (a -> StateTT mark s t m b) -> StateTT mark s t m b

(>>) :: StateTT mark s t m a -> StateTT mark s t m b -> StateTT mark s t m b

return :: a -> StateTT mark s t m a

fail :: String -> StateTT mark s t m a

(MonadIdentity mark, Monad (t m)) => Functor (StateTT mark s t m)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

fmap :: (a -> b) -> StateTT mark s t m a -> StateTT mark s t m b

(<$) :: a -> StateTT mark s t m b -> StateTT mark s t m a

(MonadIdentity mark, Monad (t m)) => Applicative (StateTT mark s t m)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

pure :: a -> StateTT mark s t m a

(<*>) :: StateTT mark s t m (a -> b) -> StateTT mark s t m a -> StateTT mark s t m b

liftA2 :: (a -> b -> c) -> StateTT mark s t m a -> StateTT mark s t m b -> StateTT mark s t m c

(*>) :: StateTT mark s t m a -> StateTT mark s t m b -> StateTT mark s t m b

(<*) :: StateTT mark s t m a -> StateTT mark s t m b -> StateTT mark s t m a

(Monad m, MonadTrans t, MonadIdentity mark, Eq s, EqIn (t m)) => EqIn (StateTT mark s t m)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Associated Types

data Context (StateTT mark s t m) :: Type

Methods

eqIn :: Eq a => Context (StateTT mark s t m) -> StateTT mark s t m a -> StateTT mark s t m a -> Bool

(Typeable t, Typeable m, Typeable mark, Typeable s, Typeable a) => Show (StateTT mark s t m a)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

showsPrec :: Int -> StateTT mark s t m a -> ShowS

show :: StateTT mark s t m a -> String

showList :: [StateTT mark s t m a] -> ShowS

newtype InputTT (StateTT mark s) m

Defined in Control.FX.Monad.Trans.Trans.StateTT

newtype InputTT (StateTT mark s) m = StateTTIn {

• unStateTTIn :: mark s

}

newtype OutputTT (StateTT mark s) a

Defined in Control.FX.Monad.Trans.Trans.StateTT

newtype OutputTT (StateTT mark s) a = StateTTOut {

• unStateTTOut :: Pair (mark s) a

}

newtype Context (StateTT mark s t m)

Defined in Control.FX.Monad.Trans.Trans.StateTT

newtype Context (StateTT mark s t m) = StateTTCtx {

• unStateTTCtx :: (mark s, Context (t m))

}

runStateTT :: (MonadIdentity mark, Monad m, MonadTrans t) => mark s -> StateTT mark s t m a -> t m (Pair (mark s) a)

newtype ReadOnlyTT (mark :: * -> *) (r :: *) (t :: (* -> *) -> * -> *) (m :: * -> *) (a :: *)

Constructors

ReadOnlyTT

Fields

• unReadOnlyTT :: ReadOnlyT mark r (t m) a

Instances

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadPrompt mark p (t x)) => MonadPrompt mark p (ReadOnlyTT mark1 r t m)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

prompt :: mark (p a) -> ReadOnlyTT mark1 r t m (mark a)

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Commutant mark1, forall (x :: Type -> Type). Monad x => MonadWriteOnce mark w (t x)) => MonadWriteOnce mark w (ReadOnlyTT mark1 r t m)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

etch :: mark w -> ReadOnlyTT mark1 r t m Bool

press :: ReadOnlyTT mark1 r t m (Maybe (mark w))

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Monoid w, Commutant mark1, forall (x :: Type -> Type). Monad x => MonadAppendOnly mark w (t x)) => MonadAppendOnly mark w (ReadOnlyTT mark1 r t m)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

look :: ReadOnlyTT mark1 r t m (mark w)

jot :: mark w -> ReadOnlyTT mark1 r t m ()

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Commutant mark1, forall (x :: Type -> Type). Monad x => MonadReadOnly mark r (t x)) => MonadReadOnly mark r (ReadOnlyTT mark1 r1 t m)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

ask :: ReadOnlyTT mark1 r1 t m (mark r)

local :: (mark r -> mark r) -> ReadOnlyTT mark1 r1 t m a -> ReadOnlyTT mark1 r1 t m a

(Monad m, MonadTrans t, MonadIdentity mark) => MonadReadOnly mark r (ReadOnlyTT mark r t m)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

ask :: ReadOnlyTT mark r t m (mark r)

local :: (mark r -> mark r) -> ReadOnlyTT mark r t m a -> ReadOnlyTT mark r t m a

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Monoid w, Commutant mark1, forall (x :: Type -> Type). Monad x => MonadWriteOnly mark w (t x)) => MonadWriteOnly mark w (ReadOnlyTT mark1 r t m)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

tell :: mark w -> ReadOnlyTT mark1 r t m ()

draft :: ReadOnlyTT mark1 r t m a -> ReadOnlyTT mark1 r t m (Pair (mark w) a)

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadState mark s (t x)) => MonadState mark s (ReadOnlyTT mark1 r t m)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

get :: ReadOnlyTT mark1 r t m (mark s)

put :: mark s -> ReadOnlyTT mark1 r t m ()

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Commutant mark1, forall (x :: Type -> Type). Monad x => MonadExcept mark e (t x)) => MonadExcept mark e (ReadOnlyTT mark1 r t m)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

throw :: mark e -> ReadOnlyTT mark1 r t m a

catch :: ReadOnlyTT mark1 r t m a -> (mark e -> ReadOnlyTT mark1 r t m a) -> ReadOnlyTT mark1 r t m a

(Monad m, MonadTrans t, MonadIdentity mark1, MonadIdentity mark, forall (x :: Type -> Type). Monad x => MonadHalt mark (t x)) => MonadHalt mark (ReadOnlyTT mark1 r t m)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

halt :: mark () -> ReadOnlyTT mark1 r t m a

(Eq (mark r), Eq (Context (t m))) => Eq (Context (ReadOnlyTT mark r t m))

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

(==) :: Context (ReadOnlyTT mark r t m) -> Context (ReadOnlyTT mark r t m) -> Bool

(/=) :: Context (ReadOnlyTT mark r t m) -> Context (ReadOnlyTT mark r t m) -> Bool

(Show (mark r), Show (Context (t m))) => Show (Context (ReadOnlyTT mark r t m))

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

showsPrec :: Int -> Context (ReadOnlyTT mark r t m) -> ShowS

show :: Context (ReadOnlyTT mark r t m) -> String

showList :: [Context (ReadOnlyTT mark r t m)] -> ShowS

Eq (mark r) => Eq (InputTT (ReadOnlyTT mark r) m)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

(==) :: InputTT (ReadOnlyTT mark r) m -> InputTT (ReadOnlyTT mark r) m -> Bool

(/=) :: InputTT (ReadOnlyTT mark r) m -> InputTT (ReadOnlyTT mark r) m -> Bool

Eq (mark a) => Eq (OutputTT (ReadOnlyTT mark r) a)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

(==) :: OutputTT (ReadOnlyTT mark r) a -> OutputTT (ReadOnlyTT mark r) a -> Bool

(/=) :: OutputTT (ReadOnlyTT mark r) a -> OutputTT (ReadOnlyTT mark r) a -> Bool

Show (mark r) => Show (InputTT (ReadOnlyTT mark r) m)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

showsPrec :: Int -> InputTT (ReadOnlyTT mark r) m -> ShowS

show :: InputTT (ReadOnlyTT mark r) m -> String

showList :: [InputTT (ReadOnlyTT mark r) m] -> ShowS

Show (mark a) => Show (OutputTT (ReadOnlyTT mark r) a)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

showsPrec :: Int -> OutputTT (ReadOnlyTT mark r) a -> ShowS

show :: OutputTT (ReadOnlyTT mark r) a -> String

showList :: [OutputTT (ReadOnlyTT mark r) a] -> ShowS

(MonadIdentity mark, Commutant mark) => LiftLocalT (ReadOnlyTT mark r)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

liftLocalT :: (Monad m, MonadTrans t) => (forall x. Local r0 (t m) (OutputTT (ReadOnlyTT mark r) x)) -> forall x. Local r0 (ReadOnlyTT mark r t m) x

(MonadIdentity mark, Commutant mark) => LiftDraftT (ReadOnlyTT mark r)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

liftDraftT :: (Monad m, MonadTrans t, Monoid w) => (forall x. Draft w (t m) (OutputTT (ReadOnlyTT mark r) x)) -> forall x. Draft w (ReadOnlyTT mark r t m) x

(MonadIdentity mark, Commutant mark) => LiftCatchT (ReadOnlyTT mark r)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

liftCatchT :: (Monad m, MonadTrans t) => (forall x. Catch e (t m) (OutputTT (ReadOnlyTT mark r) x)) -> forall x. Catch e (ReadOnlyTT mark r t m) x

(MonadIdentity mark, Commutant mark) => RunMonadTransTrans (ReadOnlyTT mark r)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Associated Types

data InputTT (ReadOnlyTT mark r) m :: Type

data OutputTT (ReadOnlyTT mark r) a :: Type

Methods

runTT :: (Monad m, MonadTrans t) => InputTT (ReadOnlyTT mark r) m -> ReadOnlyTT mark r t m a -> t m (OutputTT (ReadOnlyTT mark r) a)

MonadIdentity mark => MonadTransTrans (ReadOnlyTT mark r)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

liftT :: (Monad m, MonadTrans t) => t m a -> ReadOnlyTT mark r t m a

(MonadTrans t, MonadIdentity mark) => MonadTrans (ReadOnlyTT mark r t)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

lift :: Monad m => m a -> ReadOnlyTT mark r t m a

(MonadFunctor t, MonadIdentity mark) => MonadFunctor (ReadOnlyTT mark r t)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

hoist :: (Monad m, Monad n) => (forall u. m u -> n u) -> ReadOnlyTT mark r t m a -> ReadOnlyTT mark r t n a

(MonadIdentity mark, Monad (t m)) => Monad (ReadOnlyTT mark r t m)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

(>>=) :: ReadOnlyTT mark r t m a -> (a -> ReadOnlyTT mark r t m b) -> ReadOnlyTT mark r t m b

(>>) :: ReadOnlyTT mark r t m a -> ReadOnlyTT mark r t m b -> ReadOnlyTT mark r t m b

return :: a -> ReadOnlyTT mark r t m a

fail :: String -> ReadOnlyTT mark r t m a

(MonadIdentity mark, Functor (t m)) => Functor (ReadOnlyTT mark r t m)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

fmap :: (a -> b) -> ReadOnlyTT mark r t m a -> ReadOnlyTT mark r t m b

(<$) :: a -> ReadOnlyTT mark r t m b -> ReadOnlyTT mark r t m a

(MonadIdentity mark, Applicative (t m)) => Applicative (ReadOnlyTT mark r t m)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

pure :: a -> ReadOnlyTT mark r t m a

(<*>) :: ReadOnlyTT mark r t m (a -> b) -> ReadOnlyTT mark r t m a -> ReadOnlyTT mark r t m b

liftA2 :: (a -> b -> c) -> ReadOnlyTT mark r t m a -> ReadOnlyTT mark r t m b -> ReadOnlyTT mark r t m c

(*>) :: ReadOnlyTT mark r t m a -> ReadOnlyTT mark r t m b -> ReadOnlyTT mark r t m b

(<*) :: ReadOnlyTT mark r t m a -> ReadOnlyTT mark r t m b -> ReadOnlyTT mark r t m a

(Monad m, MonadTrans t, MonadIdentity mark, Commutant mark, EqIn (t m)) => EqIn (ReadOnlyTT mark r t m)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Associated Types

data Context (ReadOnlyTT mark r t m) :: Type

Methods

eqIn :: Eq a => Context (ReadOnlyTT mark r t m) -> ReadOnlyTT mark r t m a -> ReadOnlyTT mark r t m a -> Bool

(Typeable t, Typeable m, Typeable mark, Typeable r, Typeable a) => Show (ReadOnlyTT mark r t m a)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

showsPrec :: Int -> ReadOnlyTT mark r t m a -> ShowS

show :: ReadOnlyTT mark r t m a -> String

showList :: [ReadOnlyTT mark r t m a] -> ShowS

newtype InputTT (ReadOnlyTT mark r) m

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

newtype InputTT (ReadOnlyTT mark r) m = ReadOnlyTTIn {

• unReadOnlyTTIn :: mark r

}

newtype OutputTT (ReadOnlyTT mark r) a

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

newtype OutputTT (ReadOnlyTT mark r) a = ReadOnlyTTOut {

• unReadOnlyTTOut :: mark a

}

newtype Context (ReadOnlyTT mark r t m)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

newtype Context (ReadOnlyTT mark r t m) = ReadOnlyTTCtx {

• unReadOnlyTTCtx :: (mark r, Context (t m))

}

runReadOnlyTT :: (MonadIdentity mark, Commutant mark, Monad m, MonadTrans t) => mark r -> ReadOnlyTT mark r t m a -> t m (mark a)

newtype WriteOnlyTT (mark :: * -> *) (w :: *) (t :: (* -> *) -> * -> *) (m :: * -> *) (a :: *)

Constructors

WriteOnlyTT

Fields

• unWriteOnlyTT :: WriteOnlyT mark w (t m) a

Instances

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Monoid w, forall (x :: Type -> Type). Monad x => MonadPrompt mark p (t x)) => MonadPrompt mark p (WriteOnlyTT mark1 w t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

prompt :: mark (p a) -> WriteOnlyTT mark1 w t m (mark a)

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Monoid w1, forall (x :: Type -> Type). Monad x => MonadWriteOnce mark w (t x)) => MonadWriteOnce mark w (WriteOnlyTT mark1 w1 t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

etch :: mark w -> WriteOnlyTT mark1 w1 t m Bool

press :: WriteOnlyTT mark1 w1 t m (Maybe (mark w))

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Monoid w, Monoid w1, forall (x :: Type -> Type). Monad x => MonadAppendOnly mark w (t x)) => MonadAppendOnly mark w (WriteOnlyTT mark1 w1 t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

look :: WriteOnlyTT mark1 w1 t m (mark w)

jot :: mark w -> WriteOnlyTT mark1 w1 t m ()

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Monoid w, forall (x :: Type -> Type). Monad x => MonadReadOnly mark r (t x)) => MonadReadOnly mark r (WriteOnlyTT mark1 w t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

ask :: WriteOnlyTT mark1 w t m (mark r)

local :: (mark r -> mark r) -> WriteOnlyTT mark1 w t m a -> WriteOnlyTT mark1 w t m a

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Monoid w, Monoid w1, forall (x :: Type -> Type). Monad x => MonadWriteOnly mark w (t x)) => MonadWriteOnly mark w (WriteOnlyTT mark1 w1 t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

tell :: mark w -> WriteOnlyTT mark1 w1 t m ()

draft :: WriteOnlyTT mark1 w1 t m a -> WriteOnlyTT mark1 w1 t m (Pair (mark w) a)

(Monad m, MonadTrans t, MonadIdentity mark, Monoid w) => MonadWriteOnly mark w (WriteOnlyTT mark w t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

tell :: mark w -> WriteOnlyTT mark w t m ()

draft :: WriteOnlyTT mark w t m a -> WriteOnlyTT mark w t m (Pair (mark w) a)

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Monoid w, forall (x :: Type -> Type). Monad x => MonadState mark s (t x)) => MonadState mark s (WriteOnlyTT mark1 w t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

get :: WriteOnlyTT mark1 w t m (mark s)

put :: mark s -> WriteOnlyTT mark1 w t m ()

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Monoid w, forall (x :: Type -> Type). Monad x => MonadExcept mark e (t x)) => MonadExcept mark e (WriteOnlyTT mark1 w t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

throw :: mark e -> WriteOnlyTT mark1 w t m a

catch :: WriteOnlyTT mark1 w t m a -> (mark e -> WriteOnlyTT mark1 w t m a) -> WriteOnlyTT mark1 w t m a

(Monad m, MonadTrans t, MonadIdentity mark1, Monoid w, MonadIdentity mark, forall (x :: Type -> Type). Monad x => MonadHalt mark (t x)) => MonadHalt mark (WriteOnlyTT mark1 w t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

halt :: mark () -> WriteOnlyTT mark1 w t m a

(Eq (mark ()), Eq (Context (t m))) => Eq (Context (WriteOnlyTT mark w t m))

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

(==) :: Context (WriteOnlyTT mark w t m) -> Context (WriteOnlyTT mark w t m) -> Bool

(/=) :: Context (WriteOnlyTT mark w t m) -> Context (WriteOnlyTT mark w t m) -> Bool

(Show (mark ()), Show (Context (t m))) => Show (Context (WriteOnlyTT mark w t m))

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

showsPrec :: Int -> Context (WriteOnlyTT mark w t m) -> ShowS

show :: Context (WriteOnlyTT mark w t m) -> String

showList :: [Context (WriteOnlyTT mark w t m)] -> ShowS

Eq (mark ()) => Eq (InputTT (WriteOnlyTT mark w) m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

(==) :: InputTT (WriteOnlyTT mark w) m -> InputTT (WriteOnlyTT mark w) m -> Bool

(/=) :: InputTT (WriteOnlyTT mark w) m -> InputTT (WriteOnlyTT mark w) m -> Bool

(Eq (mark w), Eq a) => Eq (OutputTT (WriteOnlyTT mark w) a)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

(==) :: OutputTT (WriteOnlyTT mark w) a -> OutputTT (WriteOnlyTT mark w) a -> Bool

(/=) :: OutputTT (WriteOnlyTT mark w) a -> OutputTT (WriteOnlyTT mark w) a -> Bool

Show (mark ()) => Show (InputTT (WriteOnlyTT mark w) m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

showsPrec :: Int -> InputTT (WriteOnlyTT mark w) m -> ShowS

show :: InputTT (WriteOnlyTT mark w) m -> String

showList :: [InputTT (WriteOnlyTT mark w) m] -> ShowS

(Show (mark w), Show a) => Show (OutputTT (WriteOnlyTT mark w) a)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

showsPrec :: Int -> OutputTT (WriteOnlyTT mark w) a -> ShowS

show :: OutputTT (WriteOnlyTT mark w) a -> String

showList :: [OutputTT (WriteOnlyTT mark w) a] -> ShowS

(MonadIdentity mark, Monoid w) => LiftLocalT (WriteOnlyTT mark w)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

liftLocalT :: (Monad m, MonadTrans t) => (forall x. Local r (t m) (OutputTT (WriteOnlyTT mark w) x)) -> forall x. Local r (WriteOnlyTT mark w t m) x

(MonadIdentity mark, Monoid w) => LiftDraftT (WriteOnlyTT mark w)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

liftDraftT :: (Monad m, MonadTrans t, Monoid w0) => (forall x. Draft w0 (t m) (OutputTT (WriteOnlyTT mark w) x)) -> forall x. Draft w0 (WriteOnlyTT mark w t m) x

(MonadIdentity mark, Monoid w) => LiftCatchT (WriteOnlyTT mark w)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

liftCatchT :: (Monad m, MonadTrans t) => (forall x. Catch e (t m) (OutputTT (WriteOnlyTT mark w) x)) -> forall x. Catch e (WriteOnlyTT mark w t m) x

(MonadIdentity mark, Monoid w) => RunMonadTransTrans (WriteOnlyTT mark w)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Associated Types

data InputTT (WriteOnlyTT mark w) m :: Type

data OutputTT (WriteOnlyTT mark w) a :: Type

Methods

runTT :: (Monad m, MonadTrans t) => InputTT (WriteOnlyTT mark w) m -> WriteOnlyTT mark w t m a -> t m (OutputTT (WriteOnlyTT mark w) a)

(MonadIdentity mark, Monoid w) => MonadTransTrans (WriteOnlyTT mark w)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

liftT :: (Monad m, MonadTrans t) => t m a -> WriteOnlyTT mark w t m a

(MonadTrans t, MonadIdentity mark, Monoid w) => MonadTrans (WriteOnlyTT mark w t)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

lift :: Monad m => m a -> WriteOnlyTT mark w t m a

(MonadFunctor t, MonadIdentity mark, Monoid w) => MonadFunctor (WriteOnlyTT mark w t)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

hoist :: (Monad m, Monad n) => (forall u. m u -> n u) -> WriteOnlyTT mark w t m a -> WriteOnlyTT mark w t n a

(Monoid w, MonadIdentity mark, Monad (t m)) => Monad (WriteOnlyTT mark w t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

(>>=) :: WriteOnlyTT mark w t m a -> (a -> WriteOnlyTT mark w t m b) -> WriteOnlyTT mark w t m b

(>>) :: WriteOnlyTT mark w t m a -> WriteOnlyTT mark w t m b -> WriteOnlyTT mark w t m b

return :: a -> WriteOnlyTT mark w t m a

fail :: String -> WriteOnlyTT mark w t m a

(Monoid w, MonadIdentity mark, Monad (t m)) => Functor (WriteOnlyTT mark w t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

fmap :: (a -> b) -> WriteOnlyTT mark w t m a -> WriteOnlyTT mark w t m b

(<$) :: a -> WriteOnlyTT mark w t m b -> WriteOnlyTT mark w t m a

(Monoid w, MonadIdentity mark, Monad (t m)) => Applicative (WriteOnlyTT mark w t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

pure :: a -> WriteOnlyTT mark w t m a

(<*>) :: WriteOnlyTT mark w t m (a -> b) -> WriteOnlyTT mark w t m a -> WriteOnlyTT mark w t m b

liftA2 :: (a -> b -> c) -> WriteOnlyTT mark w t m a -> WriteOnlyTT mark w t m b -> WriteOnlyTT mark w t m c

(*>) :: WriteOnlyTT mark w t m a -> WriteOnlyTT mark w t m b -> WriteOnlyTT mark w t m b

(<*) :: WriteOnlyTT mark w t m a -> WriteOnlyTT mark w t m b -> WriteOnlyTT mark w t m a

(Monad m, MonadTrans t, MonadIdentity mark, Eq w, EqIn (t m), Monoid w) => EqIn (WriteOnlyTT mark w t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Associated Types

data Context (WriteOnlyTT mark w t m) :: Type

Methods

eqIn :: Eq a => Context (WriteOnlyTT mark w t m) -> WriteOnlyTT mark w t m a -> WriteOnlyTT mark w t m a -> Bool

Show (t m (WriteOnly mark w a)) => Show (WriteOnlyTT mark w t m a)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

showsPrec :: Int -> WriteOnlyTT mark w t m a -> ShowS

show :: WriteOnlyTT mark w t m a -> String

showList :: [WriteOnlyTT mark w t m a] -> ShowS

newtype InputTT (WriteOnlyTT mark w) m

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

newtype InputTT (WriteOnlyTT mark w) m = WriteOnlyTTIn {

• unWriteOnlyTTIn :: mark ()

}

newtype OutputTT (WriteOnlyTT mark w) a

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

newtype OutputTT (WriteOnlyTT mark w) a = WriteOnlyTTOut {

• unWriteOnlyTTOut :: Pair (mark w) a

}

newtype Context (WriteOnlyTT mark w t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

newtype Context (WriteOnlyTT mark w t m) = WriteOnlyTTCtx {

• unWriteOnlyTTCtx :: (mark (), Context (t m))

}

runWriteOnlyTT :: (MonadIdentity mark, Monad m, MonadTrans t, Monoid w) => mark () -> WriteOnlyTT mark w t m a -> t m (Pair (mark w) a)

newtype ExceptTT (mark :: * -> *) (e :: *) (t :: (* -> *) -> * -> *) (m :: * -> *) (a :: *)

Constructors

ExceptTT

Fields

• unExceptTT :: ExceptT mark e (t m) a

Instances

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadPrompt mark p (t x)) => MonadPrompt mark p (ExceptTT mark1 e t m)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

prompt :: mark (p a) -> ExceptTT mark1 e t m (mark a)

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadWriteOnce mark w (t x)) => MonadWriteOnce mark w (ExceptTT mark1 e t m)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

etch :: mark w -> ExceptTT mark1 e t m Bool

press :: ExceptTT mark1 e t m (Maybe (mark w))

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Monoid w, forall (x :: Type -> Type). Monad x => MonadAppendOnly mark w (t x)) => MonadAppendOnly mark w (ExceptTT mark1 e t m)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

look :: ExceptTT mark1 e t m (mark w)

jot :: mark w -> ExceptTT mark1 e t m ()

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadReadOnly mark r (t x)) => MonadReadOnly mark r (ExceptTT mark1 e t m)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

ask :: ExceptTT mark1 e t m (mark r)

local :: (mark r -> mark r) -> ExceptTT mark1 e t m a -> ExceptTT mark1 e t m a

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Monoid w, forall (x :: Type -> Type). Monad x => MonadWriteOnly mark w (t x)) => MonadWriteOnly mark w (ExceptTT mark1 e t m)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

tell :: mark w -> ExceptTT mark1 e t m ()

draft :: ExceptTT mark1 e t m a -> ExceptTT mark1 e t m (Pair (mark w) a)

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadState mark s (t x)) => MonadState mark s (ExceptTT mark1 e1 t m)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

get :: ExceptTT mark1 e1 t m (mark s)

put :: mark s -> ExceptTT mark1 e1 t m ()

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadExcept mark e (t x)) => MonadExcept mark e (ExceptTT mark1 e1 t m)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

throw :: mark e -> ExceptTT mark1 e1 t m a

catch :: ExceptTT mark1 e1 t m a -> (mark e -> ExceptTT mark1 e1 t m a) -> ExceptTT mark1 e1 t m a

(Monad m, MonadTrans t, MonadIdentity mark) => MonadExcept mark e (ExceptTT mark e t m)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

throw :: mark e -> ExceptTT mark e t m a

catch :: ExceptTT mark e t m a -> (mark e -> ExceptTT mark e t m a) -> ExceptTT mark e t m a

(Monad m, MonadTrans t, MonadIdentity mark1, MonadIdentity mark, forall (x :: Type -> Type). Monad x => MonadHalt mark (t x)) => MonadHalt mark (ExceptTT mark1 e t m)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

halt :: mark () -> ExceptTT mark1 e t m a

(Eq (mark ()), Eq (Context (t m))) => Eq (Context (ExceptTT mark e t m))

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

(==) :: Context (ExceptTT mark e t m) -> Context (ExceptTT mark e t m) -> Bool

(/=) :: Context (ExceptTT mark e t m) -> Context (ExceptTT mark e t m) -> Bool

(Show (mark ()), Show (Context (t m))) => Show (Context (ExceptTT mark e t m))

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

showsPrec :: Int -> Context (ExceptTT mark e t m) -> ShowS

show :: Context (ExceptTT mark e t m) -> String

showList :: [Context (ExceptTT mark e t m)] -> ShowS

Eq (mark ()) => Eq (InputTT (ExceptTT mark e) m)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

(==) :: InputTT (ExceptTT mark e) m -> InputTT (ExceptTT mark e) m -> Bool

(/=) :: InputTT (ExceptTT mark e) m -> InputTT (ExceptTT mark e) m -> Bool

(Eq e, Eq a) => Eq (OutputTT (ExceptTT mark e) a)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

(==) :: OutputTT (ExceptTT mark e) a -> OutputTT (ExceptTT mark e) a -> Bool

(/=) :: OutputTT (ExceptTT mark e) a -> OutputTT (ExceptTT mark e) a -> Bool

Show (mark ()) => Show (InputTT (ExceptTT mark e) m)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

showsPrec :: Int -> InputTT (ExceptTT mark e) m -> ShowS

show :: InputTT (ExceptTT mark e) m -> String

showList :: [InputTT (ExceptTT mark e) m] -> ShowS

(Show e, Show a) => Show (OutputTT (ExceptTT mark e) a)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

showsPrec :: Int -> OutputTT (ExceptTT mark e) a -> ShowS

show :: OutputTT (ExceptTT mark e) a -> String

showList :: [OutputTT (ExceptTT mark e) a] -> ShowS

MonadIdentity mark => LiftLocalT (ExceptTT mark e)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

liftLocalT :: (Monad m, MonadTrans t) => (forall x. Local r (t m) (OutputTT (ExceptTT mark e) x)) -> forall x. Local r (ExceptTT mark e t m) x

MonadIdentity mark => LiftDraftT (ExceptTT mark e)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

liftDraftT :: (Monad m, MonadTrans t, Monoid w) => (forall x. Draft w (t m) (OutputTT (ExceptTT mark e) x)) -> forall x. Draft w (ExceptTT mark e t m) x

MonadIdentity mark => LiftCatchT (ExceptTT mark e)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

liftCatchT :: (Monad m, MonadTrans t) => (forall x. Catch e0 (t m) (OutputTT (ExceptTT mark e) x)) -> forall x. Catch e0 (ExceptTT mark e t m) x

MonadIdentity mark => RunMonadTransTrans (ExceptTT mark e)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Associated Types

data InputTT (ExceptTT mark e) m :: Type

data OutputTT (ExceptTT mark e) a :: Type

Methods

runTT :: (Monad m, MonadTrans t) => InputTT (ExceptTT mark e) m -> ExceptTT mark e t m a -> t m (OutputTT (ExceptTT mark e) a)

MonadIdentity mark => MonadTransTrans (ExceptTT mark e)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

liftT :: (Monad m, MonadTrans t) => t m a -> ExceptTT mark e t m a

(MonadTrans t, MonadIdentity mark) => MonadTrans (ExceptTT mark e t)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

lift :: Monad m => m a -> ExceptTT mark e t m a

(MonadFunctor t, MonadIdentity mark) => MonadFunctor (ExceptTT mark e t)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

hoist :: (Monad m, Monad n) => (forall u. m u -> n u) -> ExceptTT mark e t m a -> ExceptTT mark e t n a

(MonadIdentity mark, Monad (t m)) => Monad (ExceptTT mark e t m)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

(>>=) :: ExceptTT mark e t m a -> (a -> ExceptTT mark e t m b) -> ExceptTT mark e t m b

(>>) :: ExceptTT mark e t m a -> ExceptTT mark e t m b -> ExceptTT mark e t m b

return :: a -> ExceptTT mark e t m a

fail :: String -> ExceptTT mark e t m a

(MonadIdentity mark, Monad (t m)) => Functor (ExceptTT mark e t m)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

fmap :: (a -> b) -> ExceptTT mark e t m a -> ExceptTT mark e t m b

(<$) :: a -> ExceptTT mark e t m b -> ExceptTT mark e t m a

(MonadIdentity mark, Monad (t m)) => Applicative (ExceptTT mark e t m)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

pure :: a -> ExceptTT mark e t m a

(<*>) :: ExceptTT mark e t m (a -> b) -> ExceptTT mark e t m a -> ExceptTT mark e t m b

liftA2 :: (a -> b -> c) -> ExceptTT mark e t m a -> ExceptTT mark e t m b -> ExceptTT mark e t m c

(*>) :: ExceptTT mark e t m a -> ExceptTT mark e t m b -> ExceptTT mark e t m b

(<*) :: ExceptTT mark e t m a -> ExceptTT mark e t m b -> ExceptTT mark e t m a

(Monad m, MonadTrans t, MonadIdentity mark, Eq e, EqIn (t m)) => EqIn (ExceptTT mark e t m)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Associated Types

data Context (ExceptTT mark e t m) :: Type

Methods

eqIn :: Eq a => Context (ExceptTT mark e t m) -> ExceptTT mark e t m a -> ExceptTT mark e t m a -> Bool

Show (t m (Except mark e a)) => Show (ExceptTT mark e t m a)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

showsPrec :: Int -> ExceptTT mark e t m a -> ShowS

show :: ExceptTT mark e t m a -> String

showList :: [ExceptTT mark e t m a] -> ShowS

newtype InputTT (ExceptTT mark e) m

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

newtype InputTT (ExceptTT mark e) m = ExceptTTIn {

• unExceptTTIn :: mark ()

}

newtype OutputTT (ExceptTT mark e) a

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

newtype OutputTT (ExceptTT mark e) a = ExceptTTOut {

• unExceptTTOut :: Except mark e a

}

newtype Context (ExceptTT mark e t m)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

newtype Context (ExceptTT mark e t m) = ExceptTTCtx {

• unExceptTTCtx :: (mark (), Context (t m))

}

runExceptTT :: (MonadIdentity mark, Monad m, MonadTrans t) => mark () -> ExceptTT mark e t m a -> t m (Except mark e a)

newtype HaltTT (mark :: * -> *) (t :: (* -> *) -> * -> *) (m :: * -> *) (a :: *)

Constructors

HaltTT

Fields

• unHaltTT :: HaltT mark (t m) a

Instances

(Monad m, MonadTrans t, MonadIdentity mark1, MonadPrompt mark p (t m)) => MonadPrompt mark p (HaltTT mark1 t m)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

prompt :: mark (p a) -> HaltTT mark1 t m (mark a)

(Monad m, MonadTrans t, MonadIdentity mark1, MonadWriteOnce mark w (t m)) => MonadWriteOnce mark w (HaltTT mark1 t m)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

etch :: mark w -> HaltTT mark1 t m Bool

press :: HaltTT mark1 t m (Maybe (mark w))

(Monad m, MonadTrans t, Monoid w, MonadIdentity mark1, MonadAppendOnly mark w (t m)) => MonadAppendOnly mark w (HaltTT mark1 t m)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

look :: HaltTT mark1 t m (mark w)

jot :: mark w -> HaltTT mark1 t m ()

(Monad m, MonadTrans t, MonadIdentity mark1, MonadReadOnly mark r (t m)) => MonadReadOnly mark r (HaltTT mark1 t m)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

ask :: HaltTT mark1 t m (mark r)

local :: (mark r -> mark r) -> HaltTT mark1 t m a -> HaltTT mark1 t m a

(Monad m, MonadTrans t, Monoid w, MonadIdentity mark1, MonadWriteOnly mark w (t m)) => MonadWriteOnly mark w (HaltTT mark1 t m)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

tell :: mark w -> HaltTT mark1 t m ()

draft :: HaltTT mark1 t m a -> HaltTT mark1 t m (Pair (mark w) a)

(Monad m, MonadTrans t, MonadIdentity mark1, MonadState mark s (t m)) => MonadState mark s (HaltTT mark1 t m)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

get :: HaltTT mark1 t m (mark s)

put :: mark s -> HaltTT mark1 t m ()

(Monad m, MonadTrans t, MonadIdentity mark1, MonadExcept mark e (t m)) => MonadExcept mark e (HaltTT mark1 t m)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

throw :: mark e -> HaltTT mark1 t m a

catch :: HaltTT mark1 t m a -> (mark e -> HaltTT mark1 t m a) -> HaltTT mark1 t m a

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadHalt mark (t x)) => MonadHalt mark (HaltTT mark1 t m)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

halt :: mark () -> HaltTT mark1 t m a

(Monad m, MonadTrans t, MonadIdentity mark) => MonadHalt mark (HaltTT mark t m)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

halt :: mark () -> HaltTT mark t m a

(Eq (mark ()), Eq (Context (t m))) => Eq (Context (HaltTT mark t m))

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

(==) :: Context (HaltTT mark t m) -> Context (HaltTT mark t m) -> Bool

(/=) :: Context (HaltTT mark t m) -> Context (HaltTT mark t m) -> Bool

(Show (mark ()), Show (Context (t m))) => Show (Context (HaltTT mark t m))

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

showsPrec :: Int -> Context (HaltTT mark t m) -> ShowS

show :: Context (HaltTT mark t m) -> String

showList :: [Context (HaltTT mark t m)] -> ShowS

MonadIdentity mark => LiftLocalT (HaltTT mark)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

liftLocalT :: (Monad m, MonadTrans t) => (forall x. Local r (t m) (OutputTT (HaltTT mark) x)) -> forall x. Local r (HaltTT mark t m) x

MonadIdentity mark => LiftDraftT (HaltTT mark)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

liftDraftT :: (Monad m, MonadTrans t, Monoid w) => (forall x. Draft w (t m) (OutputTT (HaltTT mark) x)) -> forall x. Draft w (HaltTT mark t m) x

MonadIdentity mark => LiftCatchT (HaltTT mark)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

liftCatchT :: (Monad m, MonadTrans t) => (forall x. Catch e (t m) (OutputTT (HaltTT mark) x)) -> forall x. Catch e (HaltTT mark t m) x

MonadIdentity mark => RunMonadTransTrans (HaltTT mark)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Associated Types

data InputTT (HaltTT mark) m :: Type

data OutputTT (HaltTT mark) a :: Type

Methods

runTT :: (Monad m, MonadTrans t) => InputTT (HaltTT mark) m -> HaltTT mark t m a -> t m (OutputTT (HaltTT mark) a)

MonadIdentity mark => MonadTransTrans (HaltTT mark)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

liftT :: (Monad m, MonadTrans t) => t m a -> HaltTT mark t m a

Eq (mark ()) => Eq (InputTT (HaltTT mark) m)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

(==) :: InputTT (HaltTT mark) m -> InputTT (HaltTT mark) m -> Bool

(/=) :: InputTT (HaltTT mark) m -> InputTT (HaltTT mark) m -> Bool

(Eq (mark ()), Eq a) => Eq (OutputTT (HaltTT mark) a)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

(==) :: OutputTT (HaltTT mark) a -> OutputTT (HaltTT mark) a -> Bool

(/=) :: OutputTT (HaltTT mark) a -> OutputTT (HaltTT mark) a -> Bool

Show (mark ()) => Show (InputTT (HaltTT mark) m)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

showsPrec :: Int -> InputTT (HaltTT mark) m -> ShowS

show :: InputTT (HaltTT mark) m -> String

showList :: [InputTT (HaltTT mark) m] -> ShowS

(Show (mark ()), Show a) => Show (OutputTT (HaltTT mark) a)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

showsPrec :: Int -> OutputTT (HaltTT mark) a -> ShowS

show :: OutputTT (HaltTT mark) a -> String

showList :: [OutputTT (HaltTT mark) a] -> ShowS

(MonadTrans t, MonadIdentity mark) => MonadTrans (HaltTT mark t)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

lift :: Monad m => m a -> HaltTT mark t m a

(MonadFunctor t, MonadIdentity mark) => MonadFunctor (HaltTT mark t)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

hoist :: (Monad m, Monad n) => (forall u. m u -> n u) -> HaltTT mark t m a -> HaltTT mark t n a

(MonadIdentity mark, Monad (t m)) => Monad (HaltTT mark t m)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

(>>=) :: HaltTT mark t m a -> (a -> HaltTT mark t m b) -> HaltTT mark t m b

(>>) :: HaltTT mark t m a -> HaltTT mark t m b -> HaltTT mark t m b

return :: a -> HaltTT mark t m a

fail :: String -> HaltTT mark t m a

(MonadIdentity mark, Monad (t m)) => Functor (HaltTT mark t m)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

fmap :: (a -> b) -> HaltTT mark t m a -> HaltTT mark t m b

(<$) :: a -> HaltTT mark t m b -> HaltTT mark t m a

(MonadIdentity mark, Monad (t m)) => Applicative (HaltTT mark t m)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

pure :: a -> HaltTT mark t m a

(<*>) :: HaltTT mark t m (a -> b) -> HaltTT mark t m a -> HaltTT mark t m b

liftA2 :: (a -> b -> c) -> HaltTT mark t m a -> HaltTT mark t m b -> HaltTT mark t m c

(*>) :: HaltTT mark t m a -> HaltTT mark t m b -> HaltTT mark t m b

(<*) :: HaltTT mark t m a -> HaltTT mark t m b -> HaltTT mark t m a

(Monad m, MonadTrans t, MonadIdentity mark, EqIn (t m)) => EqIn (HaltTT mark t m)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Associated Types

data Context (HaltTT mark t m) :: Type

Methods

eqIn :: Eq a => Context (HaltTT mark t m) -> HaltTT mark t m a -> HaltTT mark t m a -> Bool

Show (t m (Halt mark a)) => Show (HaltTT mark t m a)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

showsPrec :: Int -> HaltTT mark t m a -> ShowS

show :: HaltTT mark t m a -> String

showList :: [HaltTT mark t m a] -> ShowS

newtype InputTT (HaltTT mark) m

Defined in Control.FX.Monad.Trans.Trans.HaltTT

newtype InputTT (HaltTT mark) m = HaltTTIn {

• unHaltTTIn :: mark ()

}

newtype OutputTT (HaltTT mark) a

Defined in Control.FX.Monad.Trans.Trans.HaltTT

newtype OutputTT (HaltTT mark) a = HaltTTOut {

• unHaltTTOut :: Halt mark a

}

newtype Context (HaltTT mark t m)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

newtype Context (HaltTT mark t m) = HaltTTCtx {

• unHaltTTCtx :: (mark (), Context (t m))

}

runHaltTT :: (Monad m, MonadTrans t, MonadIdentity mark) => HaltTT mark t m a -> t m (Halt mark a)

newtype AppendOnlyTT (mark :: * -> *) (w :: *) (t :: (* -> *) -> * -> *) (m :: * -> *) (a :: *)

Constructors

AppendOnlyTT

Fields

• unAppendOnlyTT :: AppendOnlyT mark w (t m) a

Instances

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadPrompt mark p (t x), Monoid w) => MonadPrompt mark p (AppendOnlyTT mark1 w t m)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

prompt :: mark (p a) -> AppendOnlyTT mark1 w t m (mark a)

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadWriteOnce mark w (t x), Monoid w1) => MonadWriteOnce mark w (AppendOnlyTT mark1 w1 t m)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

etch :: mark w -> AppendOnlyTT mark1 w1 t m Bool

press :: AppendOnlyTT mark1 w1 t m (Maybe (mark w))

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadAppendOnly mark w (t x), Monoid w1, Monoid w) => MonadAppendOnly mark w (AppendOnlyTT mark1 w1 t m)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

look :: AppendOnlyTT mark1 w1 t m (mark w)

jot :: mark w -> AppendOnlyTT mark1 w1 t m ()

(Monad m, MonadTrans t, MonadIdentity mark, Monoid w) => MonadAppendOnly mark w (AppendOnlyTT mark w t m)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

look :: AppendOnlyTT mark w t m (mark w)

jot :: mark w -> AppendOnlyTT mark w t m ()

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadReadOnly mark r (t x), Monoid w) => MonadReadOnly mark r (AppendOnlyTT mark1 w t m)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

ask :: AppendOnlyTT mark1 w t m (mark r)

local :: (mark r -> mark r) -> AppendOnlyTT mark1 w t m a -> AppendOnlyTT mark1 w t m a

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Monoid w, forall (x :: Type -> Type). Monad x => MonadWriteOnly mark w (t x), Monoid w1) => MonadWriteOnly mark w (AppendOnlyTT mark1 w1 t m)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

tell :: mark w -> AppendOnlyTT mark1 w1 t m ()

draft :: AppendOnlyTT mark1 w1 t m a -> AppendOnlyTT mark1 w1 t m (Pair (mark w) a)

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadState mark s (t x), Monoid w) => MonadState mark s (AppendOnlyTT mark1 w t m)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

get :: AppendOnlyTT mark1 w t m (mark s)

put :: mark s -> AppendOnlyTT mark1 w t m ()

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadExcept mark e (t x), Monoid w) => MonadExcept mark e (AppendOnlyTT mark1 w t m)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

throw :: mark e -> AppendOnlyTT mark1 w t m a

catch :: AppendOnlyTT mark1 w t m a -> (mark e -> AppendOnlyTT mark1 w t m a) -> AppendOnlyTT mark1 w t m a

(Monad m, MonadTrans t, MonadIdentity mark1, MonadIdentity mark, Monoid w, forall (x :: Type -> Type). Monad x => MonadHalt mark (t x)) => MonadHalt mark (AppendOnlyTT mark1 w t m)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

halt :: mark () -> AppendOnlyTT mark1 w t m a

(Eq (mark ()), Eq (Context (t m))) => Eq (Context (AppendOnlyTT mark w t m))

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

(==) :: Context (AppendOnlyTT mark w t m) -> Context (AppendOnlyTT mark w t m) -> Bool

(/=) :: Context (AppendOnlyTT mark w t m) -> Context (AppendOnlyTT mark w t m) -> Bool

(Show (mark ()), Show (Context (t m))) => Show (Context (AppendOnlyTT mark w t m))

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

showsPrec :: Int -> Context (AppendOnlyTT mark w t m) -> ShowS

show :: Context (AppendOnlyTT mark w t m) -> String

showList :: [Context (AppendOnlyTT mark w t m)] -> ShowS

Eq (mark ()) => Eq (InputTT (AppendOnlyTT mark w) m)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

(==) :: InputTT (AppendOnlyTT mark w) m -> InputTT (AppendOnlyTT mark w) m -> Bool

(/=) :: InputTT (AppendOnlyTT mark w) m -> InputTT (AppendOnlyTT mark w) m -> Bool

(Eq (mark w), Eq a) => Eq (OutputTT (AppendOnlyTT mark w) a)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

(==) :: OutputTT (AppendOnlyTT mark w) a -> OutputTT (AppendOnlyTT mark w) a -> Bool

(/=) :: OutputTT (AppendOnlyTT mark w) a -> OutputTT (AppendOnlyTT mark w) a -> Bool

Show (mark ()) => Show (InputTT (AppendOnlyTT mark w) m)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

showsPrec :: Int -> InputTT (AppendOnlyTT mark w) m -> ShowS

show :: InputTT (AppendOnlyTT mark w) m -> String

showList :: [InputTT (AppendOnlyTT mark w) m] -> ShowS

(Show (mark w), Show a) => Show (OutputTT (AppendOnlyTT mark w) a)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

showsPrec :: Int -> OutputTT (AppendOnlyTT mark w) a -> ShowS

show :: OutputTT (AppendOnlyTT mark w) a -> String

showList :: [OutputTT (AppendOnlyTT mark w) a] -> ShowS

(MonadIdentity mark, Monoid w) => LiftLocalT (AppendOnlyTT mark w)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

liftLocalT :: (Monad m, MonadTrans t) => (forall x. Local r (t m) (OutputTT (AppendOnlyTT mark w) x)) -> forall x. Local r (AppendOnlyTT mark w t m) x

(MonadIdentity mark, Monoid w) => LiftDraftT (AppendOnlyTT mark w)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

liftDraftT :: (Monad m, MonadTrans t, Monoid w0) => (forall x. Draft w0 (t m) (OutputTT (AppendOnlyTT mark w) x)) -> forall x. Draft w0 (AppendOnlyTT mark w t m) x

(MonadIdentity mark, Monoid w) => LiftCatchT (AppendOnlyTT mark w)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

liftCatchT :: (Monad m, MonadTrans t) => (forall x. Catch e (t m) (OutputTT (AppendOnlyTT mark w) x)) -> forall x. Catch e (AppendOnlyTT mark w t m) x

(MonadIdentity mark, Monoid w) => RunMonadTransTrans (AppendOnlyTT mark w)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Associated Types

data InputTT (AppendOnlyTT mark w) m :: Type

data OutputTT (AppendOnlyTT mark w) a :: Type

Methods

runTT :: (Monad m, MonadTrans t) => InputTT (AppendOnlyTT mark w) m -> AppendOnlyTT mark w t m a -> t m (OutputTT (AppendOnlyTT mark w) a)

(MonadIdentity mark, Monoid w) => MonadTransTrans (AppendOnlyTT mark w)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

liftT :: (Monad m, MonadTrans t) => t m a -> AppendOnlyTT mark w t m a

(MonadTrans t, MonadIdentity mark, Monoid w) => MonadTrans (AppendOnlyTT mark w t)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

lift :: Monad m => m a -> AppendOnlyTT mark w t m a

(MonadFunctor t, MonadIdentity mark, Monoid w) => MonadFunctor (AppendOnlyTT mark w t)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

hoist :: (Monad m, Monad n) => (forall u. m u -> n u) -> AppendOnlyTT mark w t m a -> AppendOnlyTT mark w t n a

(MonadIdentity mark, Monoid w, Monad (t m)) => Monad (AppendOnlyTT mark w t m)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

(>>=) :: AppendOnlyTT mark w t m a -> (a -> AppendOnlyTT mark w t m b) -> AppendOnlyTT mark w t m b

(>>) :: AppendOnlyTT mark w t m a -> AppendOnlyTT mark w t m b -> AppendOnlyTT mark w t m b

return :: a -> AppendOnlyTT mark w t m a

fail :: String -> AppendOnlyTT mark w t m a

(MonadIdentity mark, Monoid w, Monad (t m)) => Functor (AppendOnlyTT mark w t m)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

fmap :: (a -> b) -> AppendOnlyTT mark w t m a -> AppendOnlyTT mark w t m b

(<$) :: a -> AppendOnlyTT mark w t m b -> AppendOnlyTT mark w t m a

(MonadIdentity mark, Monoid w, Monad (t m)) => Applicative (AppendOnlyTT mark w t m)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

pure :: a -> AppendOnlyTT mark w t m a

(<*>) :: AppendOnlyTT mark w t m (a -> b) -> AppendOnlyTT mark w t m a -> AppendOnlyTT mark w t m b

liftA2 :: (a -> b -> c) -> AppendOnlyTT mark w t m a -> AppendOnlyTT mark w t m b -> AppendOnlyTT mark w t m c

(*>) :: AppendOnlyTT mark w t m a -> AppendOnlyTT mark w t m b -> AppendOnlyTT mark w t m b

(<*) :: AppendOnlyTT mark w t m a -> AppendOnlyTT mark w t m b -> AppendOnlyTT mark w t m a

(Monad m, MonadTrans t, MonadIdentity mark, Eq w, EqIn (t m), Monoid w) => EqIn (AppendOnlyTT mark w t m)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Associated Types

data Context (AppendOnlyTT mark w t m) :: Type

Methods

eqIn :: Eq a => Context (AppendOnlyTT mark w t m) -> AppendOnlyTT mark w t m a -> AppendOnlyTT mark w t m a -> Bool

(Typeable t, Typeable m, Typeable mark, Typeable w, Typeable a) => Show (AppendOnlyTT mark w t m a)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

showsPrec :: Int -> AppendOnlyTT mark w t m a -> ShowS

show :: AppendOnlyTT mark w t m a -> String

showList :: [AppendOnlyTT mark w t m a] -> ShowS

newtype InputTT (AppendOnlyTT mark w) m

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

newtype InputTT (AppendOnlyTT mark w) m = AppendOnlyTTIn {

• unAppendOnlyTTIn :: mark ()

}

newtype OutputTT (AppendOnlyTT mark w) a

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

newtype OutputTT (AppendOnlyTT mark w) a = AppendOnlyTTOut {

• unAppendOnlyTTOut :: Pair (mark w) a

}

newtype Context (AppendOnlyTT mark w t m)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

newtype Context (AppendOnlyTT mark w t m) = AppendOnlyTTCtx {

• unAppendOnlyTTCtx :: (mark (), Context (t m))

}

runAppendOnlyTT :: (MonadIdentity mark, Monad m, MonadTrans t, Monoid w) => mark () -> AppendOnlyTT mark w t m a -> t m (Pair (mark w) a)

newtype WriteOnceTT (mark :: * -> *) (w :: *) (t :: (* -> *) -> * -> *) (m :: * -> *) (a :: *)

Constructors

WriteOnceTT

Fields

• unWriteOnceTT :: WriteOnceT mark w (t m) a

Instances

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadPrompt mark p (t x)) => MonadPrompt mark p (WriteOnceTT mark1 w t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

prompt :: mark (p a) -> WriteOnceTT mark1 w t m (mark a)

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadWriteOnce mark w (t x)) => MonadWriteOnce mark w (WriteOnceTT mark1 w1 t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

etch :: mark w -> WriteOnceTT mark1 w1 t m Bool

press :: WriteOnceTT mark1 w1 t m (Maybe (mark w))

(Monad m, MonadTrans t, MonadIdentity mark) => MonadWriteOnce mark w (WriteOnceTT mark w t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

etch :: mark w -> WriteOnceTT mark w t m Bool

press :: WriteOnceTT mark w t m (Maybe (mark w))

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadAppendOnly mark w (t x), Monoid w) => MonadAppendOnly mark w (WriteOnceTT mark1 w1 t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

look :: WriteOnceTT mark1 w1 t m (mark w)

jot :: mark w -> WriteOnceTT mark1 w1 t m ()

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadReadOnly mark r (t x)) => MonadReadOnly mark r (WriteOnceTT mark1 w t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

ask :: WriteOnceTT mark1 w t m (mark r)

local :: (mark r -> mark r) -> WriteOnceTT mark1 w t m a -> WriteOnceTT mark1 w t m a

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadWriteOnly mark w (t x), Monoid w) => MonadWriteOnly mark w (WriteOnceTT mark1 w1 t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

tell :: mark w -> WriteOnceTT mark1 w1 t m ()

draft :: WriteOnceTT mark1 w1 t m a -> WriteOnceTT mark1 w1 t m (Pair (mark w) a)

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadState mark s (t x)) => MonadState mark s (WriteOnceTT mark1 w t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

get :: WriteOnceTT mark1 w t m (mark s)

put :: mark s -> WriteOnceTT mark1 w t m ()

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadExcept mark e (t x)) => MonadExcept mark e (WriteOnceTT mark1 w t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

throw :: mark e -> WriteOnceTT mark1 w t m a

catch :: WriteOnceTT mark1 w t m a -> (mark e -> WriteOnceTT mark1 w t m a) -> WriteOnceTT mark1 w t m a

(Monad m, MonadTrans t, MonadIdentity mark1, MonadIdentity mark, forall (x :: Type -> Type). Monad x => MonadHalt mark (t x)) => MonadHalt mark (WriteOnceTT mark1 w t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

halt :: mark () -> WriteOnceTT mark1 w t m a

(Eq (mark ()), Eq (Context (t m))) => Eq (Context (WriteOnceTT mark w t m))

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

(==) :: Context (WriteOnceTT mark w t m) -> Context (WriteOnceTT mark w t m) -> Bool

(/=) :: Context (WriteOnceTT mark w t m) -> Context (WriteOnceTT mark w t m) -> Bool

(Show (mark ()), Show (Context (t m))) => Show (Context (WriteOnceTT mark w t m))

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

showsPrec :: Int -> Context (WriteOnceTT mark w t m) -> ShowS

show :: Context (WriteOnceTT mark w t m) -> String

showList :: [Context (WriteOnceTT mark w t m)] -> ShowS

Eq (mark ()) => Eq (InputTT (WriteOnceTT mark w) m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

(==) :: InputTT (WriteOnceTT mark w) m -> InputTT (WriteOnceTT mark w) m -> Bool

(/=) :: InputTT (WriteOnceTT mark w) m -> InputTT (WriteOnceTT mark w) m -> Bool

(Eq (mark (Maybe w)), Eq a) => Eq (OutputTT (WriteOnceTT mark w) a)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

(==) :: OutputTT (WriteOnceTT mark w) a -> OutputTT (WriteOnceTT mark w) a -> Bool

(/=) :: OutputTT (WriteOnceTT mark w) a -> OutputTT (WriteOnceTT mark w) a -> Bool

Show (mark ()) => Show (InputTT (WriteOnceTT mark w) m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

showsPrec :: Int -> InputTT (WriteOnceTT mark w) m -> ShowS

show :: InputTT (WriteOnceTT mark w) m -> String

showList :: [InputTT (WriteOnceTT mark w) m] -> ShowS

(Show (mark (Maybe w)), Show a) => Show (OutputTT (WriteOnceTT mark w) a)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

showsPrec :: Int -> OutputTT (WriteOnceTT mark w) a -> ShowS

show :: OutputTT (WriteOnceTT mark w) a -> String

showList :: [OutputTT (WriteOnceTT mark w) a] -> ShowS

MonadIdentity mark => LiftLocalT (WriteOnceTT mark w)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

liftLocalT :: (Monad m, MonadTrans t) => (forall x. Local r (t m) (OutputTT (WriteOnceTT mark w) x)) -> forall x. Local r (WriteOnceTT mark w t m) x

MonadIdentity mark => LiftDraftT (WriteOnceTT mark w)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

liftDraftT :: (Monad m, MonadTrans t, Monoid w0) => (forall x. Draft w0 (t m) (OutputTT (WriteOnceTT mark w) x)) -> forall x. Draft w0 (WriteOnceTT mark w t m) x

MonadIdentity mark => LiftCatchT (WriteOnceTT mark w)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

liftCatchT :: (Monad m, MonadTrans t) => (forall x. Catch e (t m) (OutputTT (WriteOnceTT mark w) x)) -> forall x. Catch e (WriteOnceTT mark w t m) x

MonadIdentity mark => RunMonadTransTrans (WriteOnceTT mark w)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Associated Types

data InputTT (WriteOnceTT mark w) m :: Type

data OutputTT (WriteOnceTT mark w) a :: Type

Methods

runTT :: (Monad m, MonadTrans t) => InputTT (WriteOnceTT mark w) m -> WriteOnceTT mark w t m a -> t m (OutputTT (WriteOnceTT mark w) a)

MonadIdentity mark => MonadTransTrans (WriteOnceTT mark w)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

liftT :: (Monad m, MonadTrans t) => t m a -> WriteOnceTT mark w t m a

(MonadTrans t, MonadIdentity mark) => MonadTrans (WriteOnceTT mark w t)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

lift :: Monad m => m a -> WriteOnceTT mark w t m a

(MonadFunctor t, MonadIdentity mark) => MonadFunctor (WriteOnceTT mark w t)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

hoist :: (Monad m, Monad n) => (forall u. m u -> n u) -> WriteOnceTT mark w t m a -> WriteOnceTT mark w t n a

(MonadIdentity mark, Monad (t m)) => Monad (WriteOnceTT mark w t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

(>>=) :: WriteOnceTT mark w t m a -> (a -> WriteOnceTT mark w t m b) -> WriteOnceTT mark w t m b

(>>) :: WriteOnceTT mark w t m a -> WriteOnceTT mark w t m b -> WriteOnceTT mark w t m b

return :: a -> WriteOnceTT mark w t m a

fail :: String -> WriteOnceTT mark w t m a

(MonadIdentity mark, Monad (t m)) => Functor (WriteOnceTT mark w t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

fmap :: (a -> b) -> WriteOnceTT mark w t m a -> WriteOnceTT mark w t m b

(<$) :: a -> WriteOnceTT mark w t m b -> WriteOnceTT mark w t m a

(MonadIdentity mark, Monad (t m)) => Applicative (WriteOnceTT mark w t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

pure :: a -> WriteOnceTT mark w t m a

(<*>) :: WriteOnceTT mark w t m (a -> b) -> WriteOnceTT mark w t m a -> WriteOnceTT mark w t m b

liftA2 :: (a -> b -> c) -> WriteOnceTT mark w t m a -> WriteOnceTT mark w t m b -> WriteOnceTT mark w t m c

(*>) :: WriteOnceTT mark w t m a -> WriteOnceTT mark w t m b -> WriteOnceTT mark w t m b

(<*) :: WriteOnceTT mark w t m a -> WriteOnceTT mark w t m b -> WriteOnceTT mark w t m a

(Monad m, MonadTrans t, MonadIdentity mark, Eq w, EqIn (t m)) => EqIn (WriteOnceTT mark w t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Associated Types

data Context (WriteOnceTT mark w t m) :: Type

Methods

eqIn :: Eq a => Context (WriteOnceTT mark w t m) -> WriteOnceTT mark w t m a -> WriteOnceTT mark w t m a -> Bool

(Typeable t, Typeable m, Typeable mark, Typeable w, Typeable a) => Show (WriteOnceTT mark w t m a)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

showsPrec :: Int -> WriteOnceTT mark w t m a -> ShowS

show :: WriteOnceTT mark w t m a -> String

showList :: [WriteOnceTT mark w t m a] -> ShowS

newtype InputTT (WriteOnceTT mark w) m

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

newtype InputTT (WriteOnceTT mark w) m = WriteOnceTTIn {

• unWriteOnceTTIn :: mark ()

}

newtype OutputTT (WriteOnceTT mark w) a

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

newtype OutputTT (WriteOnceTT mark w) a = WriteOnceTTOut {

• unWriteOnceTTOut :: Pair (mark (Maybe w)) a

}

newtype Context (WriteOnceTT mark w t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

newtype Context (WriteOnceTT mark w t m) = WriteOnceTTCtx {

• unWriteOnceTTCtx :: (mark (), Context (t m))

}

runWriteOnceTT :: (MonadIdentity mark, Monad m, MonadTrans t) => mark () -> WriteOnceTT mark w t m a -> t m (Pair (mark (Maybe w)) a)

Values In Context

Monads

class Monad m => RunMonad m where

Class representing monads that can be "run" inside some context z, producing a value in some result context f.

Associated Types

data Input m :: *

data Output m :: * -> *

Methods

run :: Input m -> m a -> Output m a

Run a monadic computation in context

Instances

RunMonad Maybe

Defined in Control.FX.Monad.Class

Associated Types

data Input Maybe :: Type

data Output Maybe a :: Type

Methods

run :: Input Maybe -> Maybe a -> Output Maybe a

RunMonad Identity

Defined in Control.FX.Monad.Identity

Associated Types

data Input Identity :: Type

data Output Identity a :: Type

Methods

run :: Input Identity -> Identity a -> Output Identity a

MonadIdentity mark => RunMonad (Halt mark)

Defined in Control.FX.Monad.Halt

Associated Types

data Input (Halt mark) :: Type

data Output (Halt mark) a :: Type

Methods

run :: Input (Halt mark) -> Halt mark a -> Output (Halt mark) a

(Monoid w, MonadIdentity mark) => RunMonad (AppendOnly mark w)

Defined in Control.FX.Monad.AppendOnly

Associated Types

data Input (AppendOnly mark w) :: Type

data Output (AppendOnly mark w) a :: Type

Methods

run :: Input (AppendOnly mark w) -> AppendOnly mark w a -> Output (AppendOnly mark w) a

(RunMonad m1, RunMonad m2, Central m2, Functor (Output m1)) => RunMonad (Compose m1 m2)

Defined in Control.FX.Monad.Compose

Associated Types

data Input (Compose m1 m2) :: Type

data Output (Compose m1 m2) a :: Type

Methods

run :: Input (Compose m1 m2) -> Compose m1 m2 a -> Output (Compose m1 m2) a

MonadIdentity mark => RunMonad (Except mark e)

Defined in Control.FX.Monad.Except

Associated Types

data Input (Except mark e) :: Type

data Output (Except mark e) a :: Type

Methods

run :: Input (Except mark e) -> Except mark e a -> Output (Except mark e) a

(MonadIdentity mark, Commutant mark) => RunMonad (ReadOnly mark r)

Defined in Control.FX.Monad.ReadOnly

Associated Types

data Input (ReadOnly mark r) :: Type

data Output (ReadOnly mark r) a :: Type

Methods

run :: Input (ReadOnly mark r) -> ReadOnly mark r a -> Output (ReadOnly mark r) a

MonadIdentity mark => RunMonad (State mark s)

Defined in Control.FX.Monad.State

Associated Types

data Input (State mark s) :: Type

data Output (State mark s) a :: Type

Methods

run :: Input (State mark s) -> State mark s a -> Output (State mark s) a

MonadIdentity mark => RunMonad (WriteOnce mark w)

Defined in Control.FX.Monad.WriteOnce

Associated Types

data Input (WriteOnce mark w) :: Type

data Output (WriteOnce mark w) a :: Type

Methods

run :: Input (WriteOnce mark w) -> WriteOnce mark w a -> Output (WriteOnce mark w) a

(Monoid w, MonadIdentity mark) => RunMonad (WriteOnly mark w)

Defined in Control.FX.Monad.WriteOnly

Associated Types

data Input (WriteOnly mark w) :: Type

data Output (WriteOnly mark w) a :: Type

Methods

run :: Input (WriteOnly mark w) -> WriteOnly mark w a -> Output (WriteOnly mark w) a

Transformers

class MonadTrans t => RunMonadTrans t where

Class representing monad transformers which can be run in an input context, producting a monadic value in an output context.

Associated Types

data InputT t :: *

data OutputT t :: * -> *

Methods

runT :: Monad m => InputT t -> t m a -> m (OutputT t a)

Instances

RunMonadTrans IdentityT

Defined in Control.FX.Monad.Trans.IdentityT

Associated Types

data InputT IdentityT :: Type

data OutputT IdentityT a :: Type

Methods

runT :: Monad m => InputT IdentityT -> IdentityT m a -> m (OutputT IdentityT a)

MonadIdentity mark => RunMonadTrans (HaltT mark)

Defined in Control.FX.Monad.Trans.HaltT

Associated Types

data InputT (HaltT mark) :: Type

data OutputT (HaltT mark) a :: Type

Methods

runT :: Monad m => InputT (HaltT mark) -> HaltT mark m a -> m (OutputT (HaltT mark) a)

(Monoid w, MonadIdentity mark) => RunMonadTrans (WriteOnlyT mark w)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Associated Types

data InputT (WriteOnlyT mark w) :: Type

data OutputT (WriteOnlyT mark w) a :: Type

Methods

runT :: Monad m => InputT (WriteOnlyT mark w) -> WriteOnlyT mark w m a -> m (OutputT (WriteOnlyT mark w) a)

MonadIdentity mark => RunMonadTrans (WriteOnceT mark w)

Defined in Control.FX.Monad.Trans.WriteOnceT

Associated Types

data InputT (WriteOnceT mark w) :: Type

data OutputT (WriteOnceT mark w) a :: Type

Methods

runT :: Monad m => InputT (WriteOnceT mark w) -> WriteOnceT mark w m a -> m (OutputT (WriteOnceT mark w) a)

MonadIdentity mark => RunMonadTrans (StateT mark s)

Defined in Control.FX.Monad.Trans.StateT

Associated Types

data InputT (StateT mark s) :: Type

data OutputT (StateT mark s) a :: Type

Methods

runT :: Monad m => InputT (StateT mark s) -> StateT mark s m a -> m (OutputT (StateT mark s) a)

(MonadIdentity mark, Commutant mark) => RunMonadTrans (ReadOnlyT mark r)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Associated Types

data InputT (ReadOnlyT mark r) :: Type

data OutputT (ReadOnlyT mark r) a :: Type

Methods

runT :: Monad m => InputT (ReadOnlyT mark r) -> ReadOnlyT mark r m a -> m (OutputT (ReadOnlyT mark r) a)

MonadIdentity mark => RunMonadTrans (ExceptT mark e)

Defined in Control.FX.Monad.Trans.ExceptT

Associated Types

data InputT (ExceptT mark e) :: Type

data OutputT (ExceptT mark e) a :: Type

Methods

runT :: Monad m => InputT (ExceptT mark e) -> ExceptT mark e m a -> m (OutputT (ExceptT mark e) a)

(MonadIdentity mark, Monoid w) => RunMonadTrans (AppendOnlyT mark w)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Associated Types

data InputT (AppendOnlyT mark w) :: Type

data OutputT (AppendOnlyT mark w) a :: Type

Methods

runT :: Monad m => InputT (AppendOnlyT mark w) -> AppendOnlyT mark w m a -> m (OutputT (AppendOnlyT mark w) a)

(RunMonadTrans t1, RunMonadTrans t2, ComposableT t1) => RunMonadTrans (ComposeT t1 t2)

Defined in Control.FX.Monad.Trans.ComposeT

Associated Types

data InputT (ComposeT t1 t2) :: Type

data OutputT (ComposeT t1 t2) a :: Type

Methods

runT :: Monad m => InputT (ComposeT t1 t2) -> ComposeT t1 t2 m a -> m (OutputT (ComposeT t1 t2) a)

Transformer Transformers

class MonadTransTrans u => RunMonadTransTrans u where

Class representing monad transformer transformers which can be "run" in a context z m, producing a value in context t m (f a).

Associated Types

data InputTT u (m :: * -> *) :: *

data OutputTT u :: * -> *

Methods

runTT :: (Monad m, MonadTrans t) => InputTT u m -> u t m a -> t m (OutputTT u a)

Instances

RunMonadTransTrans IdentityTT

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Associated Types

data InputTT IdentityTT m :: Type

data OutputTT IdentityTT a :: Type

Methods

runTT :: (Monad m, MonadTrans t) => InputTT IdentityTT m -> IdentityTT t m a -> t m (OutputTT IdentityTT a)

MonadIdentity mark => RunMonadTransTrans (HaltTT mark)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Associated Types

data InputTT (HaltTT mark) m :: Type

data OutputTT (HaltTT mark) a :: Type

Methods

runTT :: (Monad m, MonadTrans t) => InputTT (HaltTT mark) m -> HaltTT mark t m a -> t m (OutputTT (HaltTT mark) a)

(MonadIdentity mark, Monoid w) => RunMonadTransTrans (WriteOnlyTT mark w)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Associated Types

data InputTT (WriteOnlyTT mark w) m :: Type

data OutputTT (WriteOnlyTT mark w) a :: Type

Methods

runTT :: (Monad m, MonadTrans t) => InputTT (WriteOnlyTT mark w) m -> WriteOnlyTT mark w t m a -> t m (OutputTT (WriteOnlyTT mark w) a)

MonadIdentity mark => RunMonadTransTrans (WriteOnceTT mark w)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Associated Types

data InputTT (WriteOnceTT mark w) m :: Type

data OutputTT (WriteOnceTT mark w) a :: Type

Methods

runTT :: (Monad m, MonadTrans t) => InputTT (WriteOnceTT mark w) m -> WriteOnceTT mark w t m a -> t m (OutputTT (WriteOnceTT mark w) a)

MonadIdentity mark => RunMonadTransTrans (StateTT mark s)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Associated Types

data InputTT (StateTT mark s) m :: Type

data OutputTT (StateTT mark s) a :: Type

Methods

runTT :: (Monad m, MonadTrans t) => InputTT (StateTT mark s) m -> StateTT mark s t m a -> t m (OutputTT (StateTT mark s) a)

(MonadIdentity mark, Commutant mark) => RunMonadTransTrans (ReadOnlyTT mark r)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Associated Types

data InputTT (ReadOnlyTT mark r) m :: Type

data OutputTT (ReadOnlyTT mark r) a :: Type

Methods

runTT :: (Monad m, MonadTrans t) => InputTT (ReadOnlyTT mark r) m -> ReadOnlyTT mark r t m a -> t m (OutputTT (ReadOnlyTT mark r) a)

(RunMonadTransTrans u, RunMonadTrans v, MonadTrans v, OverableT v) => RunMonadTransTrans (OverTT v u)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Associated Types

data InputTT (OverTT v u) m :: Type

data OutputTT (OverTT v u) a :: Type

Methods

runTT :: (Monad m, MonadTrans t) => InputTT (OverTT v u) m -> OverTT v u t m a -> t m (OutputTT (OverTT v u) a)

(MonadIdentity mark, Commutant mark) => RunMonadTransTrans (PromptTT mark p)

Defined in Control.FX.Monad.Trans.Trans.PromptTT

Associated Types

data InputTT (PromptTT mark p) m :: Type

data OutputTT (PromptTT mark p) a :: Type

Methods

runTT :: (Monad m, MonadTrans t) => InputTT (PromptTT mark p) m -> PromptTT mark p t m a -> t m (OutputTT (PromptTT mark p) a)

MonadIdentity mark => RunMonadTransTrans (ExceptTT mark e)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Associated Types

data InputTT (ExceptTT mark e) m :: Type

data OutputTT (ExceptTT mark e) a :: Type

Methods

runTT :: (Monad m, MonadTrans t) => InputTT (ExceptTT mark e) m -> ExceptTT mark e t m a -> t m (OutputTT (ExceptTT mark e) a)

(MonadIdentity mark, Monoid w) => RunMonadTransTrans (AppendOnlyTT mark w)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Associated Types

data InputTT (AppendOnlyTT mark w) m :: Type

data OutputTT (AppendOnlyTT mark w) a :: Type

Methods

runTT :: (Monad m, MonadTrans t) => InputTT (AppendOnlyTT mark w) m -> AppendOnlyTT mark w t m a -> t m (OutputTT (AppendOnlyTT mark w) a)

Equality

class EqIn (t :: * -> *) where

Class representing types which can be compared for equality within an environment. Instances should satisfy the following laws:

(1) eqIn env x x  ===  True

(2) eqIn env x y  ===  eqIn env y x

(3) if (eqIn env x y) && (eqIn env y z) then eqIn env x z else True

Associated Types

data Context t

Methods

eqIn :: Eq a => Context t -> t a -> t a -> Bool

Instances

EqIn Maybe

Defined in Control.FX.EqIn

Associated Types

data Context Maybe :: Type

Methods

eqIn :: Eq a => Context Maybe -> Maybe a -> Maybe a -> Bool

EqIn LeftZero

Defined in Control.FX.Functor.LeftZero

Associated Types

data Context LeftZero :: Type

Methods

eqIn :: Eq a => Context LeftZero -> LeftZero a -> LeftZero a -> Bool

EqIn RightZero

Defined in Control.FX.Functor.RightZero

Associated Types

data Context RightZero :: Type

Methods

eqIn :: Eq a => Context RightZero -> RightZero a -> RightZero a -> Bool

EqIn Identity

Defined in Control.FX.Monad.Identity

Associated Types

data Context Identity :: Type

Methods

eqIn :: Eq a => Context Identity -> Identity a -> Identity a -> Bool

Eq a => EqIn (Either a)

Defined in Control.FX.EqIn

Associated Types

data Context (Either a) :: Type

Methods

eqIn :: Eq a0 => Context (Either a) -> Either a a0 -> Either a a0 -> Bool

Eq a => EqIn (Pair a)

Defined in Control.FX.Functor.Pair

Associated Types

data Context (Pair a) :: Type

Methods

eqIn :: Eq a0 => Context (Pair a) -> Pair a a0 -> Pair a a0 -> Bool

EqIn (Halt mark)

Defined in Control.FX.Monad.Halt

Associated Types

data Context (Halt mark) :: Type

Methods

eqIn :: Eq a => Context (Halt mark) -> Halt mark a -> Halt mark a -> Bool

(EqIn m, Functor m) => EqIn (IdentityT m)

Defined in Control.FX.Monad.Trans.IdentityT

Associated Types

data Context (IdentityT m) :: Type

Methods

eqIn :: Eq a => Context (IdentityT m) -> IdentityT m a -> IdentityT m a -> Bool

(Eq w, Monoid w) => EqIn (AppendOnly mark w)

Defined in Control.FX.Monad.AppendOnly

Associated Types

data Context (AppendOnly mark w) :: Type

Methods

eqIn :: Eq a => Context (AppendOnly mark w) -> AppendOnly mark w a -> AppendOnly mark w a -> Bool

Eq e => EqIn (Except mark e)

Defined in Control.FX.Monad.Except

Associated Types

data Context (Except mark e) :: Type

Methods

eqIn :: Eq a => Context (Except mark e) -> Except mark e a -> Except mark e a -> Bool

MonadIdentity mark => EqIn (ReadOnly mark r)

Defined in Control.FX.Monad.ReadOnly

Associated Types

data Context (ReadOnly mark r) :: Type

Methods

eqIn :: Eq a => Context (ReadOnly mark r) -> ReadOnly mark r a -> ReadOnly mark r a -> Bool

(Eq s, MonadIdentity mark) => EqIn (State mark s)

Defined in Control.FX.Monad.State

Associated Types

data Context (State mark s) :: Type

Methods

eqIn :: Eq a => Context (State mark s) -> State mark s a -> State mark s a -> Bool

(Eq w, Monoid w) => EqIn (WriteOnce mark w)

Defined in Control.FX.Monad.WriteOnce

Associated Types

data Context (WriteOnce mark w) :: Type

Methods

eqIn :: Eq a => Context (WriteOnce mark w) -> WriteOnce mark w a -> WriteOnce mark w a -> Bool

Eq w => EqIn (WriteOnly mark w)

Defined in Control.FX.Monad.WriteOnly

Associated Types

data Context (WriteOnly mark w) :: Type

Methods

eqIn :: Eq a => Context (WriteOnly mark w) -> WriteOnly mark w a -> WriteOnly mark w a -> Bool

EqIn m => EqIn (HaltT mark m)

Defined in Control.FX.Monad.Trans.HaltT

Associated Types

data Context (HaltT mark m) :: Type

Methods

eqIn :: Eq a => Context (HaltT mark m) -> HaltT mark m a -> HaltT mark m a -> Bool

EqIn (t m) => EqIn (IdentityTT t m)

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Associated Types

data Context (IdentityTT t m) :: Type

Methods

eqIn :: Eq a => Context (IdentityTT t m) -> IdentityTT t m a -> IdentityTT t m a -> Bool

(EqIn m, MonadIdentity mark, Eq w) => EqIn (WriteOnlyT mark w m)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Associated Types

data Context (WriteOnlyT mark w m) :: Type

Methods

eqIn :: Eq a => Context (WriteOnlyT mark w m) -> WriteOnlyT mark w m a -> WriteOnlyT mark w m a -> Bool

(EqIn m, MonadIdentity mark, Eq w) => EqIn (WriteOnceT mark w m)

Defined in Control.FX.Monad.Trans.WriteOnceT

Associated Types

data Context (WriteOnceT mark w m) :: Type

Methods

eqIn :: Eq a => Context (WriteOnceT mark w m) -> WriteOnceT mark w m a -> WriteOnceT mark w m a -> Bool

(EqIn m, MonadIdentity mark, Eq s) => EqIn (StateT mark s m)

Defined in Control.FX.Monad.Trans.StateT

Associated Types

data Context (StateT mark s m) :: Type

Methods

eqIn :: Eq a => Context (StateT mark s m) -> StateT mark s m a -> StateT mark s m a -> Bool

(EqIn m, Functor m, MonadIdentity mark) => EqIn (ReadOnlyT mark r m)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Associated Types

data Context (ReadOnlyT mark r m) :: Type

Methods

eqIn :: Eq a => Context (ReadOnlyT mark r m) -> ReadOnlyT mark r m a -> ReadOnlyT mark r m a -> Bool

(EqIn m, MonadIdentity mark, Eq e) => EqIn (ExceptT mark e m)

Defined in Control.FX.Monad.Trans.ExceptT

Associated Types

data Context (ExceptT mark e m) :: Type

Methods

eqIn :: Eq a => Context (ExceptT mark e m) -> ExceptT mark e m a -> ExceptT mark e m a -> Bool

(EqIn m, MonadIdentity mark, Eq w) => EqIn (AppendOnlyT mark w m)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Associated Types

data Context (AppendOnlyT mark w m) :: Type

Methods

eqIn :: Eq a => Context (AppendOnlyT mark w m) -> AppendOnlyT mark w m a -> AppendOnlyT mark w m a -> Bool

(EqIn (t1 (t2 m)), ComposableT t1) => EqIn (ComposeT t1 t2 m)

Defined in Control.FX.Monad.Trans.ComposeT

Associated Types

data Context (ComposeT t1 t2 m) :: Type

Methods

eqIn :: Eq a => Context (ComposeT t1 t2 m) -> ComposeT t1 t2 m a -> ComposeT t1 t2 m a -> Bool

(Monad m, MonadTrans t, MonadIdentity mark, EqIn (t m)) => EqIn (HaltTT mark t m)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Associated Types

data Context (HaltTT mark t m) :: Type

Methods

eqIn :: Eq a => Context (HaltTT mark t m) -> HaltTT mark t m a -> HaltTT mark t m a -> Bool

(Monad m, MonadTrans t, MonadIdentity mark, Eq w, EqIn (t m), Monoid w) => EqIn (WriteOnlyTT mark w t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Associated Types

data Context (WriteOnlyTT mark w t m) :: Type

Methods

eqIn :: Eq a => Context (WriteOnlyTT mark w t m) -> WriteOnlyTT mark w t m a -> WriteOnlyTT mark w t m a -> Bool

(Monad m, MonadTrans t, MonadIdentity mark, Eq w, EqIn (t m)) => EqIn (WriteOnceTT mark w t m)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Associated Types

data Context (WriteOnceTT mark w t m) :: Type

Methods

eqIn :: Eq a => Context (WriteOnceTT mark w t m) -> WriteOnceTT mark w t m a -> WriteOnceTT mark w t m a -> Bool

(Monad m, MonadTrans t, MonadIdentity mark, Eq s, EqIn (t m)) => EqIn (StateTT mark s t m)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Associated Types

data Context (StateTT mark s t m) :: Type

Methods

eqIn :: Eq a => Context (StateTT mark s t m) -> StateTT mark s t m a -> StateTT mark s t m a -> Bool

(Monad m, MonadTrans t, MonadIdentity mark, Commutant mark, EqIn (t m)) => EqIn (ReadOnlyTT mark r t m)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Associated Types

data Context (ReadOnlyTT mark r t m) :: Type

Methods

eqIn :: Eq a => Context (ReadOnlyTT mark r t m) -> ReadOnlyTT mark r t m a -> ReadOnlyTT mark r t m a -> Bool

(Monad m, MonadTrans t, MonadTrans v, MonadTransTrans u, RunMonadTransTrans u, RunMonadTrans v, OverableT v, forall x. Eq x => Eq (OutputTT u (OutputT v x)), EqIn (t m)) => EqIn (OverTT v u t m)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Associated Types

data Context (OverTT v u t m) :: Type

Methods

eqIn :: Eq a => Context (OverTT v u t m) -> OverTT v u t m a -> OverTT v u t m a -> Bool

(Monad m, MonadTrans t, MonadIdentity mark, Commutant mark, EqIn (t m)) => EqIn (PromptTT mark p t m)

Defined in Control.FX.Monad.Trans.Trans.PromptTT

Associated Types

data Context (PromptTT mark p t m) :: Type

Methods

eqIn :: Eq a => Context (PromptTT mark p t m) -> PromptTT mark p t m a -> PromptTT mark p t m a -> Bool

(Monad m, MonadTrans t, MonadIdentity mark, Eq e, EqIn (t m)) => EqIn (ExceptTT mark e t m)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Associated Types

data Context (ExceptTT mark e t m) :: Type

Methods

eqIn :: Eq a => Context (ExceptTT mark e t m) -> ExceptTT mark e t m a -> ExceptTT mark e t m a -> Bool

(Monad m, MonadTrans t, MonadIdentity mark, Eq w, EqIn (t m), Monoid w) => EqIn (AppendOnlyTT mark w t m)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Associated Types

data Context (AppendOnlyTT mark w t m) :: Type

Methods

eqIn :: Eq a => Context (AppendOnlyTT mark w t m) -> AppendOnlyTT mark w t m a -> AppendOnlyTT mark w t m a -> Bool

Specialized Lifts

type Catch e m a = m a -> (e -> m a) -> m a

The signature of catch from MonadExcept

class (MonadTrans t, RunMonadTrans t) => LiftCatch t where

Class representing monad transformers through which catch from MonadExcept can be lifted. Instances should satisfy the following law:

(1) lift (catch x h) === liftCatch catch (lift x) (lift . h)

Methods

liftCatch :: Monad m => Catch e m (OutputT t a) -> Catch e (t m) a

Instances

LiftCatch IdentityT

Defined in Control.FX.Monad.Trans.IdentityT

Methods

liftCatch :: Monad m => Catch e m (OutputT IdentityT a) -> Catch e (IdentityT m) a

MonadIdentity mark => LiftCatch (HaltT mark)

Defined in Control.FX.Monad.Trans.HaltT

Methods

liftCatch :: Monad m => Catch e m (OutputT (HaltT mark) a) -> Catch e (HaltT mark m) a

(Monoid w, MonadIdentity mark) => LiftCatch (WriteOnlyT mark w)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

liftCatch :: Monad m => Catch e m (OutputT (WriteOnlyT mark w) a) -> Catch e (WriteOnlyT mark w m) a

MonadIdentity mark => LiftCatch (WriteOnceT mark w)

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

liftCatch :: Monad m => Catch e m (OutputT (WriteOnceT mark w) a) -> Catch e (WriteOnceT mark w m) a

MonadIdentity mark => LiftCatch (StateT mark s)

Defined in Control.FX.Monad.Trans.StateT

Methods

liftCatch :: Monad m => Catch e m (OutputT (StateT mark s) a) -> Catch e (StateT mark s m) a

(MonadIdentity mark, Commutant mark) => LiftCatch (ReadOnlyT mark r)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

liftCatch :: Monad m => Catch e m (OutputT (ReadOnlyT mark r) a) -> Catch e (ReadOnlyT mark r m) a

MonadIdentity mark => LiftCatch (ExceptT mark e)

Defined in Control.FX.Monad.Trans.ExceptT

Methods

liftCatch :: Monad m => Catch e0 m (OutputT (ExceptT mark e) a) -> Catch e0 (ExceptT mark e m) a

(MonadIdentity mark, Monoid w) => LiftCatch (AppendOnlyT mark w)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

liftCatch :: Monad m => Catch e m (OutputT (AppendOnlyT mark w) a) -> Catch e (AppendOnlyT mark w m) a

(LiftCatch t1, LiftCatch t2, ComposableT t1) => LiftCatch (ComposeT t1 t2)

Defined in Control.FX.Monad.Trans.ComposeT

Methods

liftCatch :: Monad m => Catch e m (OutputT (ComposeT t1 t2) a) -> Catch e (ComposeT t1 t2 m) a

class (MonadTransTrans u, RunMonadTransTrans u) => LiftCatchT u where

Class representing monad transformer transformers through which catch from MonadExcept can be lifted.

Methods

liftCatchT :: (Monad m, MonadTrans t) => (forall x. Catch e (t m) (OutputTT u x)) -> forall x. Catch e (u t m) x

Instances

LiftCatchT IdentityTT

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

liftCatchT :: (Monad m, MonadTrans t) => (forall x. Catch e (t m) (OutputTT IdentityTT x)) -> forall x. Catch e (IdentityTT t m) x

MonadIdentity mark => LiftCatchT (HaltTT mark)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

liftCatchT :: (Monad m, MonadTrans t) => (forall x. Catch e (t m) (OutputTT (HaltTT mark) x)) -> forall x. Catch e (HaltTT mark t m) x

(MonadIdentity mark, Monoid w) => LiftCatchT (WriteOnlyTT mark w)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

liftCatchT :: (Monad m, MonadTrans t) => (forall x. Catch e (t m) (OutputTT (WriteOnlyTT mark w) x)) -> forall x. Catch e (WriteOnlyTT mark w t m) x

MonadIdentity mark => LiftCatchT (WriteOnceTT mark w)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

liftCatchT :: (Monad m, MonadTrans t) => (forall x. Catch e (t m) (OutputTT (WriteOnceTT mark w) x)) -> forall x. Catch e (WriteOnceTT mark w t m) x

MonadIdentity mark => LiftCatchT (StateTT mark s)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

liftCatchT :: (Monad m, MonadTrans t) => (forall x. Catch e (t m) (OutputTT (StateTT mark s) x)) -> forall x. Catch e (StateTT mark s t m) x

(MonadIdentity mark, Commutant mark) => LiftCatchT (ReadOnlyTT mark r)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

liftCatchT :: (Monad m, MonadTrans t) => (forall x. Catch e (t m) (OutputTT (ReadOnlyTT mark r) x)) -> forall x. Catch e (ReadOnlyTT mark r t m) x

MonadIdentity mark => LiftCatchT (ExceptTT mark e)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

liftCatchT :: (Monad m, MonadTrans t) => (forall x. Catch e0 (t m) (OutputTT (ExceptTT mark e) x)) -> forall x. Catch e0 (ExceptTT mark e t m) x

(MonadIdentity mark, Monoid w) => LiftCatchT (AppendOnlyTT mark w)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

liftCatchT :: (Monad m, MonadTrans t) => (forall x. Catch e (t m) (OutputTT (AppendOnlyTT mark w) x)) -> forall x. Catch e (AppendOnlyTT mark w t m) x

type Draft w m a = m a -> m (Pair w a)

The signature of draft from MonadWriteOnly

class (MonadTrans t, RunMonadTrans t) => LiftDraft t where

Class representing monad transformers through which draft from MonadWriteOnly can be lifted. Instances should satisfy the following law:

(1) liftDraft draft (lift x) === lift (draft x)

Methods

liftDraft :: (Monad m, Monoid w) => Draft w m (OutputT t a) -> Draft w (t m) a

Instances

LiftDraft IdentityT

Defined in Control.FX.Monad.Trans.IdentityT

Methods

liftDraft :: (Monad m, Monoid w) => Draft w m (OutputT IdentityT a) -> Draft w (IdentityT m) a

MonadIdentity mark => LiftDraft (HaltT mark)

Defined in Control.FX.Monad.Trans.HaltT

Methods

liftDraft :: (Monad m, Monoid w) => Draft w m (OutputT (HaltT mark) a) -> Draft w (HaltT mark m) a

(Monoid w, MonadIdentity mark, forall x. Monoid x => Monoid (mark x)) => LiftDraft (WriteOnlyT mark w)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

liftDraft :: (Monad m, Monoid w0) => Draft w0 m (OutputT (WriteOnlyT mark w) a) -> Draft w0 (WriteOnlyT mark w m) a

MonadIdentity mark => LiftDraft (WriteOnceT mark w)

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

liftDraft :: (Monad m, Monoid w0) => Draft w0 m (OutputT (WriteOnceT mark w) a) -> Draft w0 (WriteOnceT mark w m) a

MonadIdentity mark => LiftDraft (StateT mark s)

Defined in Control.FX.Monad.Trans.StateT

Methods

liftDraft :: (Monad m, Monoid w) => Draft w m (OutputT (StateT mark s) a) -> Draft w (StateT mark s m) a

(MonadIdentity mark, Commutant mark) => LiftDraft (ReadOnlyT mark r)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

liftDraft :: (Monad m, Monoid w) => Draft w m (OutputT (ReadOnlyT mark r) a) -> Draft w (ReadOnlyT mark r m) a

MonadIdentity mark => LiftDraft (ExceptT mark e)

Defined in Control.FX.Monad.Trans.ExceptT

Methods

liftDraft :: (Monad m, Monoid w) => Draft w m (OutputT (ExceptT mark e) a) -> Draft w (ExceptT mark e m) a

(MonadIdentity mark, Monoid w) => LiftDraft (AppendOnlyT mark w)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

liftDraft :: (Monad m, Monoid w0) => Draft w0 m (OutputT (AppendOnlyT mark w) a) -> Draft w0 (AppendOnlyT mark w m) a

(LiftDraft t1, LiftDraft t2, ComposableT t1) => LiftDraft (ComposeT t1 t2)

Defined in Control.FX.Monad.Trans.ComposeT

Methods

liftDraft :: (Monad m, Monoid w) => Draft w m (OutputT (ComposeT t1 t2) a) -> Draft w (ComposeT t1 t2 m) a

class (MonadTransTrans u, RunMonadTransTrans u) => LiftDraftT u where

Class representing monad transformer transformers through which draft from MonadWriteOnly can be lifted.

Methods

liftDraftT :: (Monad m, MonadTrans t, Monoid w) => (forall x. Draft w (t m) (OutputTT u x)) -> forall x. Draft w (u t m) x

Instances

LiftDraftT IdentityTT

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

liftDraftT :: (Monad m, MonadTrans t, Monoid w) => (forall x. Draft w (t m) (OutputTT IdentityTT x)) -> forall x. Draft w (IdentityTT t m) x

MonadIdentity mark => LiftDraftT (HaltTT mark)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

liftDraftT :: (Monad m, MonadTrans t, Monoid w) => (forall x. Draft w (t m) (OutputTT (HaltTT mark) x)) -> forall x. Draft w (HaltTT mark t m) x

(MonadIdentity mark, Monoid w) => LiftDraftT (WriteOnlyTT mark w)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

liftDraftT :: (Monad m, MonadTrans t, Monoid w0) => (forall x. Draft w0 (t m) (OutputTT (WriteOnlyTT mark w) x)) -> forall x. Draft w0 (WriteOnlyTT mark w t m) x

MonadIdentity mark => LiftDraftT (WriteOnceTT mark w)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

liftDraftT :: (Monad m, MonadTrans t, Monoid w0) => (forall x. Draft w0 (t m) (OutputTT (WriteOnceTT mark w) x)) -> forall x. Draft w0 (WriteOnceTT mark w t m) x

MonadIdentity mark => LiftDraftT (StateTT mark s)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

liftDraftT :: (Monad m, MonadTrans t, Monoid w) => (forall x. Draft w (t m) (OutputTT (StateTT mark s) x)) -> forall x. Draft w (StateTT mark s t m) x

(MonadIdentity mark, Commutant mark) => LiftDraftT (ReadOnlyTT mark r)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

liftDraftT :: (Monad m, MonadTrans t, Monoid w) => (forall x. Draft w (t m) (OutputTT (ReadOnlyTT mark r) x)) -> forall x. Draft w (ReadOnlyTT mark r t m) x

MonadIdentity mark => LiftDraftT (ExceptTT mark e)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

liftDraftT :: (Monad m, MonadTrans t, Monoid w) => (forall x. Draft w (t m) (OutputTT (ExceptTT mark e) x)) -> forall x. Draft w (ExceptTT mark e t m) x

(MonadIdentity mark, Monoid w) => LiftDraftT (AppendOnlyTT mark w)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

liftDraftT :: (Monad m, MonadTrans t, Monoid w0) => (forall x. Draft w0 (t m) (OutputTT (AppendOnlyTT mark w) x)) -> forall x. Draft w0 (AppendOnlyTT mark w t m) x

type Local r m a = (r -> r) -> m a -> m a

The signature of local from MonadReadOnly

class (MonadTrans t, RunMonadTrans t) => LiftLocal t where

Class representing monad transformers through which local from MonadReadOnly can be lifted

Methods

liftLocal :: Monad m => Local r m (OutputT t a) -> Local r (t m) a

Instances

LiftLocal IdentityT

Defined in Control.FX.Monad.Trans.IdentityT

Methods

liftLocal :: Monad m => Local r m (OutputT IdentityT a) -> Local r (IdentityT m) a

MonadIdentity mark => LiftLocal (HaltT mark)

Defined in Control.FX.Monad.Trans.HaltT

Methods

liftLocal :: Monad m => Local r m (OutputT (HaltT mark) a) -> Local r (HaltT mark m) a

(Monoid w, MonadIdentity mark) => LiftLocal (WriteOnlyT mark w)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

liftLocal :: Monad m => Local r m (OutputT (WriteOnlyT mark w) a) -> Local r (WriteOnlyT mark w m) a

MonadIdentity mark => LiftLocal (WriteOnceT mark w)

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

liftLocal :: Monad m => Local r m (OutputT (WriteOnceT mark w) a) -> Local r (WriteOnceT mark w m) a

MonadIdentity mark => LiftLocal (StateT mark s)

Defined in Control.FX.Monad.Trans.StateT

Methods

liftLocal :: Monad m => Local r m (OutputT (StateT mark s) a) -> Local r (StateT mark s m) a

(MonadIdentity mark, Commutant mark) => LiftLocal (ReadOnlyT mark r)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

liftLocal :: Monad m => Local r0 m (OutputT (ReadOnlyT mark r) a) -> Local r0 (ReadOnlyT mark r m) a

MonadIdentity mark => LiftLocal (ExceptT mark e)

Defined in Control.FX.Monad.Trans.ExceptT

Methods

liftLocal :: Monad m => Local r m (OutputT (ExceptT mark e) a) -> Local r (ExceptT mark e m) a

(MonadIdentity mark, Monoid w) => LiftLocal (AppendOnlyT mark w)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

liftLocal :: Monad m => Local r m (OutputT (AppendOnlyT mark w) a) -> Local r (AppendOnlyT mark w m) a

(LiftLocal t1, LiftLocal t2, ComposableT t1) => LiftLocal (ComposeT t1 t2)

Defined in Control.FX.Monad.Trans.ComposeT

Methods

liftLocal :: Monad m => Local r m (OutputT (ComposeT t1 t2) a) -> Local r (ComposeT t1 t2 m) a

class (MonadTransTrans u, RunMonadTransTrans u) => LiftLocalT u where

Class representing monad transformer transformers through which local from MonadReadOnly can be lifted.

Methods

liftLocalT :: (Monad m, MonadTrans t) => (forall x. Local r (t m) (OutputTT u x)) -> forall x. Local r (u t m) x

Instances

LiftLocalT IdentityTT

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

liftLocalT :: (Monad m, MonadTrans t) => (forall x. Local r (t m) (OutputTT IdentityTT x)) -> forall x. Local r (IdentityTT t m) x

MonadIdentity mark => LiftLocalT (HaltTT mark)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

liftLocalT :: (Monad m, MonadTrans t) => (forall x. Local r (t m) (OutputTT (HaltTT mark) x)) -> forall x. Local r (HaltTT mark t m) x

(MonadIdentity mark, Monoid w) => LiftLocalT (WriteOnlyTT mark w)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

liftLocalT :: (Monad m, MonadTrans t) => (forall x. Local r (t m) (OutputTT (WriteOnlyTT mark w) x)) -> forall x. Local r (WriteOnlyTT mark w t m) x

MonadIdentity mark => LiftLocalT (WriteOnceTT mark w)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

liftLocalT :: (Monad m, MonadTrans t) => (forall x. Local r (t m) (OutputTT (WriteOnceTT mark w) x)) -> forall x. Local r (WriteOnceTT mark w t m) x

MonadIdentity mark => LiftLocalT (StateTT mark s)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

liftLocalT :: (Monad m, MonadTrans t) => (forall x. Local r (t m) (OutputTT (StateTT mark s) x)) -> forall x. Local r (StateTT mark s t m) x

(MonadIdentity mark, Commutant mark) => LiftLocalT (ReadOnlyTT mark r)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

liftLocalT :: (Monad m, MonadTrans t) => (forall x. Local r0 (t m) (OutputTT (ReadOnlyTT mark r) x)) -> forall x. Local r0 (ReadOnlyTT mark r t m) x

MonadIdentity mark => LiftLocalT (ExceptTT mark e)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

liftLocalT :: (Monad m, MonadTrans t) => (forall x. Local r (t m) (OutputTT (ExceptTT mark e) x)) -> forall x. Local r (ExceptTT mark e t m) x

(MonadIdentity mark, Monoid w) => LiftLocalT (AppendOnlyTT mark w)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

liftLocalT :: (Monad m, MonadTrans t) => (forall x. Local r (t m) (OutputTT (AppendOnlyTT mark w) x)) -> forall x. Local r (AppendOnlyTT mark w t m) x

Misc

class Functor d => Commutant d where

Class representing Functors which "commute" with every Applicative in a precise sense. Instances should satisfy the following law:

(1) commute . fmap pure  ===  pure

This looks a lot like the sequenceA function from Traversable, but that class entails a bunch of extra technology that we don't really need.

The motivation for Commutant comes from the observation that most useful monads can be run to produce a "value", though in general that value will depend on some other context. In every case I've tried so far that context is a Commutant functor, which is enough to make a generic RunMonad instance for Compose.

Methods

commute :: Applicative f => d (f a) -> f (d a)

Instances

Commutant Maybe

Defined in Control.FX.Functor.Class

Methods

commute :: Applicative f => Maybe (f a) -> f (Maybe a)

Commutant LeftZero

Defined in Control.FX.Functor.LeftZero

Methods

commute :: Applicative f => LeftZero (f a) -> f (LeftZero a)

Commutant RightZero

Defined in Control.FX.Functor.RightZero

Methods

commute :: Applicative f => RightZero (f a) -> f (RightZero a)

Commutant Identity

Defined in Control.FX.Monad.Identity

Methods

commute :: Applicative f => Identity (f a) -> f (Identity a)

Commutant (Either e)

Defined in Control.FX.Functor.Class

Methods

commute :: Applicative f => Either e (f a) -> f (Either e a)

Commutant (Pair c)

Defined in Control.FX.Functor.Pair

Methods

commute :: Applicative f => Pair c (f a) -> f (Pair c a)

MonadIdentity mark => Commutant (Halt mark)

Defined in Control.FX.Monad.Halt

Methods

commute :: Applicative f => Halt mark (f a) -> f (Halt mark a)

Central c => Commutant (IdentityT c)

Defined in Control.FX.Monad.Trans.IdentityT

Methods

commute :: Applicative f => IdentityT c (f a) -> f (IdentityT c a)

(Commutant c1, Commutant c2) => Commutant (Compose c1 c2)

Defined in Control.FX.Monad.Compose

Methods

commute :: Applicative f => Compose c1 c2 (f a) -> f (Compose c1 c2 a)

MonadIdentity mark => Commutant (Except mark e)

Defined in Control.FX.Monad.Except

Methods

commute :: Applicative f => Except mark e (f a) -> f (Except mark e a)

(Monoid w, MonadIdentity mark) => Commutant (WriteOnly mark w)

Defined in Control.FX.Monad.WriteOnly

Methods

commute :: Applicative f => WriteOnly mark w (f a) -> f (WriteOnly mark w a)

(Central c, MonadIdentity mark) => Commutant (HaltT mark c)

Defined in Control.FX.Monad.Trans.HaltT

Methods

commute :: Applicative f => HaltT mark c (f a) -> f (HaltT mark c a)

(Monoid w, Central c, MonadIdentity mark) => Commutant (WriteOnlyT mark w c)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

commute :: Applicative f => WriteOnlyT mark w c (f a) -> f (WriteOnlyT mark w c a)

(Central c, MonadIdentity mark) => Commutant (ExceptT mark e c)

Defined in Control.FX.Monad.Trans.ExceptT

Methods

commute :: Applicative f => ExceptT mark e c (f a) -> f (ExceptT mark e c a)

class (Commutant c, Monad c) => Central c

Class representing monads that commute with every other monad. Instances should satisfy the following laws:

(1) commute . return === fmap return

(2) commute . join === fmap join . commute . fmap commute

(3) commute . fmap join === join . fmap commute . commute

Instances

Central Maybe

Defined in Control.FX.Monad.Class

Central Identity

Defined in Control.FX.Monad.Identity

Central (Either e)

Defined in Control.FX.Monad.Class

Monoid a => Central (Pair a)

Defined in Control.FX.Monad.Class

MonadIdentity mark => Central (Halt mark)

Defined in Control.FX.Monad.Halt

Central c => Central (IdentityT c)

Defined in Control.FX.Monad.Trans.IdentityT

(Central c1, Central c2) => Central (Compose c1 c2)

Defined in Control.FX.Monad.Compose

MonadIdentity mark => Central (Except mark e)

Defined in Control.FX.Monad.Except

(Monoid w, MonadIdentity mark) => Central (WriteOnly mark w)

Defined in Control.FX.Monad.WriteOnly

(Central c, MonadIdentity mark) => Central (HaltT mark c)

Defined in Control.FX.Monad.Trans.HaltT

(Monoid w, Central c, MonadIdentity mark) => Central (WriteOnlyT mark w c)

Defined in Control.FX.Monad.Trans.WriteOnlyT

(Central c, MonadIdentity mark) => Central (ExceptT mark e c)

Defined in Control.FX.Monad.Trans.ExceptT

class Bifunctor (f :: * -> * -> *) where

Class representing bifunctors on the category of types. Instances should satisfy the following laws:

(1) bimap1 id  ===  id

(2) bimap1 (f . g)  ===  bimap1 f . bimap1 g

(3) bimap2 id  ===  id

(4) bimap2 (f . g)  ===  bimap2 f . bimap2 g

(5) bimap1 f . bimap2 g  ===  bimap2 g . bimap1 f

Methods

bimap1 :: (a -> c) -> f a b -> f c b

fmap in the "first" component

bimap2 :: (b -> c) -> f a b -> f a c

fmap in the "second" component

Instances

Bifunctor Either

Defined in Control.FX.Functor.Class

Methods

bimap1 :: (a -> c) -> Either a b -> Either c b

bimap2 :: (b -> c) -> Either a b -> Either a c

Bifunctor (,)

Defined in Control.FX.Functor.Class

Methods

bimap1 :: (a -> c) -> (a, b) -> (c, b)

bimap2 :: (b -> c) -> (a, b) -> (a, c)

Bifunctor Pair

Defined in Control.FX.Functor.Pair

Methods

bimap1 :: (a -> c) -> Pair a b -> Pair c b

bimap2 :: (b -> c) -> Pair a b -> Pair a c

MonadIdentity mark => Bifunctor (Except mark)

Defined in Control.FX.Monad.Except

Methods

bimap1 :: (a -> c) -> Except mark a b -> Except mark c b

bimap2 :: (b -> c) -> Except mark a b -> Except mark a c

MonadIdentity mark => Bifunctor (WriteOnly mark)

Defined in Control.FX.Monad.WriteOnly

Methods

bimap1 :: (a -> c) -> WriteOnly mark a b -> WriteOnly mark c b

bimap2 :: (b -> c) -> WriteOnly mark a b -> WriteOnly mark a c

newtype Wrap f a

Constructors

Wrap

Fields

• unWrap :: f a

Instances

Renaming f => Monad (Wrap f)

Defined in Control.FX.Functor.Class

Methods

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

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

return :: a -> Wrap f a

fail :: String -> Wrap f a

Renaming f => Functor (Wrap f)

Defined in Control.FX.Functor.Class

Methods

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

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

Renaming f => Applicative (Wrap f)

Defined in Control.FX.Functor.Class

Methods

pure :: a -> Wrap f a

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

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

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

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

Renaming f => MonadIdentity (Wrap f)

Defined in Control.FX.Monad.Class

Methods

unwrap :: Wrap f a -> a

(Renaming f, Eq a) => Eq (Wrap f a)

Defined in Control.FX.Functor.Class

Methods

(==) :: Wrap f a -> Wrap f a -> Bool

(/=) :: Wrap f a -> Wrap f a -> Bool

(Renaming f, Semigroup a) => Semigroup (Wrap f a)

Defined in Control.FX.Functor.Class

Methods

(<>) :: Wrap f a -> Wrap f a -> Wrap f a

sconcat :: NonEmpty (Wrap f a) -> Wrap f a

stimes :: Integral b => b -> Wrap f a -> Wrap f a

(Renaming f, Monoid a) => Monoid (Wrap f a)

Defined in Control.FX.Functor.Class

Methods

mempty :: Wrap f a

mappend :: Wrap f a -> Wrap f a -> Wrap f a

mconcat :: [Wrap f a] -> Wrap f a

class Renaming f where

Methods

namingMap :: a -> f a

namingInv :: f a -> a

data Pair (a :: *) (b :: *)

Tuple type, isomorphic to (a,b). This is here so we can have a partially applied tuple type Pair a without syntax hacks.

Constructors

Pair

Fields

• slot1 :: a
• slot2 :: b

Instances

Bifunctor Pair

Defined in Control.FX.Functor.Pair

Methods

bimap1 :: (a -> c) -> Pair a b -> Pair c b

bimap2 :: (b -> c) -> Pair a b -> Pair a c

Eq (Context (Pair a))

Defined in Control.FX.Functor.Pair

Methods

(==) :: Context (Pair a) -> Context (Pair a) -> Bool

(/=) :: Context (Pair a) -> Context (Pair a) -> Bool

Monoid a => Monad (Pair a)

Defined in Control.FX.Functor.Pair

Methods

(>>=) :: Pair a a0 -> (a0 -> Pair a b) -> Pair a b

(>>) :: Pair a a0 -> Pair a b -> Pair a b

return :: a0 -> Pair a a0

fail :: String -> Pair a a0

Functor (Pair c)

Defined in Control.FX.Functor.Pair

Methods

fmap :: (a -> b) -> Pair c a -> Pair c b

(<$) :: a -> Pair c b -> Pair c a

Show (Context (Pair a))

Defined in Control.FX.Functor.Pair

Methods

showsPrec :: Int -> Context (Pair a) -> ShowS

show :: Context (Pair a) -> String

showList :: [Context (Pair a)] -> ShowS

Monoid a => Applicative (Pair a)

Defined in Control.FX.Functor.Pair

Methods

pure :: a0 -> Pair a a0

(<*>) :: Pair a (a0 -> b) -> Pair a a0 -> Pair a b

liftA2 :: (a0 -> b -> c) -> Pair a a0 -> Pair a b -> Pair a c

(*>) :: Pair a a0 -> Pair a b -> Pair a b

(<*) :: Pair a a0 -> Pair a b -> Pair a a0

Eq a => EqIn (Pair a)

Defined in Control.FX.Functor.Pair

Associated Types

data Context (Pair a) :: Type

Methods

eqIn :: Eq a0 => Context (Pair a) -> Pair a a0 -> Pair a a0 -> Bool

Commutant (Pair c)

Defined in Control.FX.Functor.Pair

Methods

commute :: Applicative f => Pair c (f a) -> f (Pair c a)

Monoid a => Central (Pair a)

Defined in Control.FX.Monad.Class

(Eq a, Eq b) => Eq (Pair a b)

Defined in Control.FX.Functor.Pair

Methods

(==) :: Pair a b -> Pair a b -> Bool

(/=) :: Pair a b -> Pair a b -> Bool

(Show a, Show b) => Show (Pair a b)

Defined in Control.FX.Functor.Pair

Methods

showsPrec :: Int -> Pair a b -> ShowS

show :: Pair a b -> String

showList :: [Pair a b] -> ShowS

newtype Context (Pair a)

Defined in Control.FX.Functor.Pair

newtype Context (Pair a) = PairCtx {

• unPairCtx :: ()

}

data LeftZero (a :: *)

Type representing the left zero semigroup on a with an identity attached. As a functor LeftZero is isomorphic to Maybe.

Constructors

LeftZero a

LeftUnit

Instances

Functor LeftZero

Defined in Control.FX.Functor.LeftZero

Methods

fmap :: (a -> b) -> LeftZero a -> LeftZero b

(<$) :: a -> LeftZero b -> LeftZero a

Applicative LeftZero

Defined in Control.FX.Functor.LeftZero

Methods

pure :: a -> LeftZero a

(<*>) :: LeftZero (a -> b) -> LeftZero a -> LeftZero b

liftA2 :: (a -> b -> c) -> LeftZero a -> LeftZero b -> LeftZero c

(*>) :: LeftZero a -> LeftZero b -> LeftZero b

(<*) :: LeftZero a -> LeftZero b -> LeftZero a

EqIn LeftZero

Defined in Control.FX.Functor.LeftZero

Associated Types

data Context LeftZero :: Type

Methods

eqIn :: Eq a => Context LeftZero -> LeftZero a -> LeftZero a -> Bool

IsMaybe LeftZero

Defined in Control.FX.Functor.LeftZero

Methods

fromMaybe :: Maybe a -> LeftZero a

toMaybe :: LeftZero a -> Maybe a

Commutant LeftZero

Defined in Control.FX.Functor.LeftZero

Methods

commute :: Applicative f => LeftZero (f a) -> f (LeftZero a)

Eq (Context LeftZero)

Defined in Control.FX.Functor.LeftZero

Methods

(==) :: Context LeftZero -> Context LeftZero -> Bool

(/=) :: Context LeftZero -> Context LeftZero -> Bool

Eq a => Eq (LeftZero a)

Defined in Control.FX.Functor.LeftZero

Methods

(==) :: LeftZero a -> LeftZero a -> Bool

(/=) :: LeftZero a -> LeftZero a -> Bool

Show (Context LeftZero)

Defined in Control.FX.Functor.LeftZero

Methods

showsPrec :: Int -> Context LeftZero -> ShowS

show :: Context LeftZero -> String

showList :: [Context LeftZero] -> ShowS

Show a => Show (LeftZero a)

Defined in Control.FX.Functor.LeftZero

Methods

showsPrec :: Int -> LeftZero a -> ShowS

show :: LeftZero a -> String

showList :: [LeftZero a] -> ShowS

Semigroup (LeftZero a)

Defined in Control.FX.Functor.LeftZero

Methods

(<>) :: LeftZero a -> LeftZero a -> LeftZero a

sconcat :: NonEmpty (LeftZero a) -> LeftZero a

stimes :: Integral b => b -> LeftZero a -> LeftZero a

Monoid (LeftZero a)

Defined in Control.FX.Functor.LeftZero

Methods

mempty :: LeftZero a

mappend :: LeftZero a -> LeftZero a -> LeftZero a

mconcat :: [LeftZero a] -> LeftZero a

newtype Context LeftZero

Defined in Control.FX.Functor.LeftZero

newtype Context LeftZero = LeftZeroCtx {

• unLeftZeroCtx :: ()

}

data RightZero (a :: *)

Type representing the right zero semigroup on a with an identity attached. As a functor RightZero is isomorphic to Maybe.

Constructors

RightZero a

RightUnit

Instances

Functor RightZero

Defined in Control.FX.Functor.RightZero

Methods

fmap :: (a -> b) -> RightZero a -> RightZero b

(<$) :: a -> RightZero b -> RightZero a

Applicative RightZero

Defined in Control.FX.Functor.RightZero

Methods

pure :: a -> RightZero a

(<*>) :: RightZero (a -> b) -> RightZero a -> RightZero b

liftA2 :: (a -> b -> c) -> RightZero a -> RightZero b -> RightZero c

(*>) :: RightZero a -> RightZero b -> RightZero b

(<*) :: RightZero a -> RightZero b -> RightZero a

EqIn RightZero

Defined in Control.FX.Functor.RightZero

Associated Types

data Context RightZero :: Type

Methods

eqIn :: Eq a => Context RightZero -> RightZero a -> RightZero a -> Bool

IsMaybe RightZero

Defined in Control.FX.Functor.RightZero

Methods

fromMaybe :: Maybe a -> RightZero a

toMaybe :: RightZero a -> Maybe a

Commutant RightZero

Defined in Control.FX.Functor.RightZero

Methods

commute :: Applicative f => RightZero (f a) -> f (RightZero a)

Eq (Context RightZero)

Defined in Control.FX.Functor.RightZero

Methods

(==) :: Context RightZero -> Context RightZero -> Bool

(/=) :: Context RightZero -> Context RightZero -> Bool

Eq a => Eq (RightZero a)

Defined in Control.FX.Functor.RightZero

Methods

(==) :: RightZero a -> RightZero a -> Bool

(/=) :: RightZero a -> RightZero a -> Bool

Show (Context RightZero)

Defined in Control.FX.Functor.RightZero

Methods

showsPrec :: Int -> Context RightZero -> ShowS

show :: Context RightZero -> String

showList :: [Context RightZero] -> ShowS

Show a => Show (RightZero a)

Defined in Control.FX.Functor.RightZero

Methods

showsPrec :: Int -> RightZero a -> ShowS

show :: RightZero a -> String

showList :: [RightZero a] -> ShowS

Semigroup (RightZero a)

Defined in Control.FX.Functor.RightZero

Methods

(<>) :: RightZero a -> RightZero a -> RightZero a

sconcat :: NonEmpty (RightZero a) -> RightZero a

stimes :: Integral b => b -> RightZero a -> RightZero a

Monoid (RightZero a)

Defined in Control.FX.Functor.RightZero

Methods

mempty :: RightZero a

mappend :: RightZero a -> RightZero a -> RightZero a

mconcat :: [RightZero a] -> RightZero a

newtype Context RightZero

Defined in Control.FX.Functor.RightZero

newtype Context RightZero = RightZeroCtx {

• unRightZeroCtx :: ()

}

class IsMaybe (f :: * -> *) where

Class representing type constructors which are isomorphic to Maybe. Instances should satisfy the following laws:

(1) toMaybe . fromMaybe  ==  id

(2) fromMaybe . toMaybe  ==  id

Methods

fromMaybe :: Maybe a -> f a

Convert from Maybe a

toMaybe :: f a -> Maybe a

Convert to Maybe a

Instances

IsMaybe Maybe

Defined in Control.FX.Functor.Class

Methods

fromMaybe :: Maybe a -> Maybe a

toMaybe :: Maybe a -> Maybe a

IsMaybe LeftZero

Defined in Control.FX.Functor.LeftZero

Methods

fromMaybe :: Maybe a -> LeftZero a

toMaybe :: LeftZero a -> Maybe a

IsMaybe RightZero

Defined in Control.FX.Functor.RightZero

Methods

fromMaybe :: Maybe a -> RightZero a

toMaybe :: RightZero a -> Maybe a

class (forall m. Monad m => Monad (t m)) => MonadTrans (t :: (* -> *) -> * -> *) where

Class representing monad transformers

Methods

lift :: Monad m => m a -> t m a

Lift a computation from the inner monad to the transformed monad

Instances

MonadTrans IdentityT

Defined in Control.FX.Monad.Trans.IdentityT

Methods

lift :: Monad m => m a -> IdentityT m a

MonadIdentity mark => MonadTrans (HaltT mark)

Defined in Control.FX.Monad.Trans.HaltT

Methods

lift :: Monad m => m a -> HaltT mark m a

MonadTrans t => MonadTrans (IdentityTT t)

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

lift :: Monad m => m a -> IdentityTT t m a

(Monoid w, MonadIdentity mark) => MonadTrans (WriteOnlyT mark w)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

lift :: Monad m => m a -> WriteOnlyT mark w m a

MonadIdentity mark => MonadTrans (WriteOnceT mark w)

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

lift :: Monad m => m a -> WriteOnceT mark w m a

MonadIdentity mark => MonadTrans (StateT mark s)

Defined in Control.FX.Monad.Trans.StateT

Methods

lift :: Monad m => m a -> StateT mark s m a

MonadIdentity mark => MonadTrans (ReadOnlyT mark r)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

lift :: Monad m => m a -> ReadOnlyT mark r m a

MonadIdentity mark => MonadTrans (ExceptT mark e)

Defined in Control.FX.Monad.Trans.ExceptT

Methods

lift :: Monad m => m a -> ExceptT mark e m a

(MonadIdentity mark, Monoid w) => MonadTrans (AppendOnlyT mark w)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

lift :: Monad m => m a -> AppendOnlyT mark w m a

(MonadTrans t1, MonadTrans t2, ComposableT t1) => MonadTrans (ComposeT t1 t2)

Defined in Control.FX.Monad.Trans.ComposeT

Methods

lift :: Monad m => m a -> ComposeT t1 t2 m a

(MonadTrans t, MonadIdentity mark) => MonadTrans (HaltTT mark t)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

lift :: Monad m => m a -> HaltTT mark t m a

(MonadTrans t, MonadIdentity mark, Monoid w) => MonadTrans (WriteOnlyTT mark w t)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

lift :: Monad m => m a -> WriteOnlyTT mark w t m a

(MonadTrans t, MonadIdentity mark) => MonadTrans (WriteOnceTT mark w t)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

lift :: Monad m => m a -> WriteOnceTT mark w t m a

(MonadTrans t, MonadIdentity mark) => MonadTrans (StateTT mark s t)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

lift :: Monad m => m a -> StateTT mark s t m a

(MonadTrans t, MonadIdentity mark) => MonadTrans (ReadOnlyTT mark r t)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

lift :: Monad m => m a -> ReadOnlyTT mark r t m a

(MonadTrans t, MonadTrans v, MonadTransTrans u, OverableT v) => MonadTrans (OverTT v u t)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Methods

lift :: Monad m => m a -> OverTT v u t m a

(MonadTrans t, MonadIdentity mark) => MonadTrans (PromptTT mark p t)

Defined in Control.FX.Monad.Trans.Trans.PromptTT

Methods

lift :: Monad m => m a -> PromptTT mark p t m a

(MonadTrans t, MonadIdentity mark) => MonadTrans (ExceptTT mark e t)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

lift :: Monad m => m a -> ExceptTT mark e t m a

(MonadTrans t, MonadIdentity mark, Monoid w) => MonadTrans (AppendOnlyTT mark w t)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

lift :: Monad m => m a -> AppendOnlyTT mark w t m a

class MonadTrans t => MonadFunctor t where

Class representing monad functors

Methods

hoist :: (Monad m, Monad n) => (forall u. m u -> n u) -> t m a -> t n a

Instances

MonadFunctor IdentityT

Defined in Control.FX.Monad.Trans.IdentityT

Methods

hoist :: (Monad m, Monad n) => (forall u. m u -> n u) -> IdentityT m a -> IdentityT n a

MonadIdentity mark => MonadFunctor (HaltT mark)

Defined in Control.FX.Monad.Trans.HaltT

Methods

hoist :: (Monad m, Monad n) => (forall u. m u -> n u) -> HaltT mark m a -> HaltT mark n a

MonadFunctor t => MonadFunctor (IdentityTT t)

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

hoist :: (Monad m, Monad n) => (forall u. m u -> n u) -> IdentityTT t m a -> IdentityTT t n a

(Monoid w, MonadIdentity mark) => MonadFunctor (WriteOnlyT mark w)

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

hoist :: (Monad m, Monad n) => (forall u. m u -> n u) -> WriteOnlyT mark w m a -> WriteOnlyT mark w n a

MonadIdentity mark => MonadFunctor (WriteOnceT mark w)

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

hoist :: (Monad m, Monad n) => (forall u. m u -> n u) -> WriteOnceT mark w m a -> WriteOnceT mark w n a

MonadIdentity mark => MonadFunctor (StateT mark s)

Defined in Control.FX.Monad.Trans.StateT

Methods

hoist :: (Monad m, Monad n) => (forall u. m u -> n u) -> StateT mark s m a -> StateT mark s n a

MonadIdentity mark => MonadFunctor (ReadOnlyT mark r)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

hoist :: (Monad m, Monad n) => (forall u. m u -> n u) -> ReadOnlyT mark r m a -> ReadOnlyT mark r n a

MonadIdentity mark => MonadFunctor (ExceptT mark e)

Defined in Control.FX.Monad.Trans.ExceptT

Methods

hoist :: (Monad m, Monad n) => (forall u. m u -> n u) -> ExceptT mark e m a -> ExceptT mark e n a

(MonadIdentity mark, Monoid w) => MonadFunctor (AppendOnlyT mark w)

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

hoist :: (Monad m, Monad n) => (forall u. m u -> n u) -> AppendOnlyT mark w m a -> AppendOnlyT mark w n a

(MonadFunctor t1, MonadFunctor t2, ComposableT t1) => MonadFunctor (ComposeT t1 t2)

Defined in Control.FX.Monad.Trans.ComposeT

Methods

hoist :: (Monad m, Monad n) => (forall u. m u -> n u) -> ComposeT t1 t2 m a -> ComposeT t1 t2 n a

(MonadFunctor t, MonadIdentity mark) => MonadFunctor (HaltTT mark t)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

hoist :: (Monad m, Monad n) => (forall u. m u -> n u) -> HaltTT mark t m a -> HaltTT mark t n a

(MonadFunctor t, MonadIdentity mark, Monoid w) => MonadFunctor (WriteOnlyTT mark w t)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

hoist :: (Monad m, Monad n) => (forall u. m u -> n u) -> WriteOnlyTT mark w t m a -> WriteOnlyTT mark w t n a

(MonadFunctor t, MonadIdentity mark) => MonadFunctor (WriteOnceTT mark w t)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

hoist :: (Monad m, Monad n) => (forall u. m u -> n u) -> WriteOnceTT mark w t m a -> WriteOnceTT mark w t n a

(MonadFunctor t, MonadIdentity mark) => MonadFunctor (StateTT mark s t)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

hoist :: (Monad m, Monad n) => (forall u. m u -> n u) -> StateTT mark s t m a -> StateTT mark s t n a

(MonadFunctor t, MonadIdentity mark) => MonadFunctor (ReadOnlyTT mark r t)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

hoist :: (Monad m, Monad n) => (forall u. m u -> n u) -> ReadOnlyTT mark r t m a -> ReadOnlyTT mark r t n a

(MonadFunctor t, MonadIdentity mark) => MonadFunctor (ExceptTT mark e t)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

hoist :: (Monad m, Monad n) => (forall u. m u -> n u) -> ExceptTT mark e t m a -> ExceptTT mark e t n a

(MonadFunctor t, MonadIdentity mark, Monoid w) => MonadFunctor (AppendOnlyTT mark w t)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

hoist :: (Monad m, Monad n) => (forall u. m u -> n u) -> AppendOnlyTT mark w t m a -> AppendOnlyTT mark w t n a

class (forall t. MonadTrans t => MonadTrans (u t), forall t m. (Monad m, MonadTrans t) => Monad (u t m)) => MonadTransTrans (u :: ((* -> *) -> * -> *) -> (* -> *) -> * -> *) where

Class representing monad transformer transformers

Methods

liftT :: (Monad m, MonadTrans t) => t m a -> u t m a

Instances

MonadTransTrans IdentityTT

Defined in Control.FX.Monad.Trans.Trans.IdentityTT

Methods

liftT :: (Monad m, MonadTrans t) => t m a -> IdentityTT t m a

MonadIdentity mark => MonadTransTrans (HaltTT mark)

Defined in Control.FX.Monad.Trans.Trans.HaltTT

Methods

liftT :: (Monad m, MonadTrans t) => t m a -> HaltTT mark t m a

(MonadIdentity mark, Monoid w) => MonadTransTrans (WriteOnlyTT mark w)

Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT

Methods

liftT :: (Monad m, MonadTrans t) => t m a -> WriteOnlyTT mark w t m a

MonadIdentity mark => MonadTransTrans (WriteOnceTT mark w)

Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT

Methods

liftT :: (Monad m, MonadTrans t) => t m a -> WriteOnceTT mark w t m a

MonadIdentity mark => MonadTransTrans (StateTT mark s)

Defined in Control.FX.Monad.Trans.Trans.StateTT

Methods

liftT :: (Monad m, MonadTrans t) => t m a -> StateTT mark s t m a

MonadIdentity mark => MonadTransTrans (ReadOnlyTT mark r)

Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT

Methods

liftT :: (Monad m, MonadTrans t) => t m a -> ReadOnlyTT mark r t m a

(MonadTrans v, MonadTransTrans u, OverableT v) => MonadTransTrans (OverTT v u)

Defined in Control.FX.Monad.Trans.Trans.OverTT

Methods

liftT :: (Monad m, MonadTrans t) => t m a -> OverTT v u t m a

MonadIdentity mark => MonadTransTrans (PromptTT mark p)

Defined in Control.FX.Monad.Trans.Trans.PromptTT

Methods

liftT :: (Monad m, MonadTrans t) => t m a -> PromptTT mark p t m a

MonadIdentity mark => MonadTransTrans (ExceptTT mark e)

Defined in Control.FX.Monad.Trans.Trans.ExceptTT

Methods

liftT :: (Monad m, MonadTrans t) => t m a -> ExceptTT mark e t m a

(MonadIdentity mark, Monoid w) => MonadTransTrans (AppendOnlyTT mark w)

Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT

Methods

liftT :: (Monad m, MonadTrans t) => t m a -> AppendOnlyTT mark w t m a