trans-fx-core-0.0.1: Monadic effect framework

Safe HaskellNone
LanguageHaskell2010

Control.FX

Contents

Description

 
Synopsis

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 Source #

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 Source #

Extract a pure value

Instances
MonadIdentity Identity Source # 
Instance details

Defined in Control.FX.Monad.Identity

Methods

unwrap :: Identity a -> a Source #

Renaming f => MonadIdentity (Wrap f) Source # 
Instance details

Defined in Control.FX.Monad.Class

Methods

unwrap :: Wrap f a -> a Source #

MonadIdentity mark => MonadIdentity (OutputT (ReadOnlyT mark r)) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

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

(MonadIdentity m, Central m) => MonadIdentity (IdentityT m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.IdentityT

Methods

unwrap :: IdentityT m a -> a Source #

MonadIdentity mark => MonadIdentity (OutputTT (PromptTT mark p)) Source # 
Instance details

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

Methods

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

(Monad m, MonadTrans t, MonadIdentity (t m)) => MonadIdentity (IdentityTT t m) Source # 
Instance details

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

Methods

unwrap :: IdentityTT t m a -> a Source #

(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) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ComposeT

Methods

unwrap :: ComposeT t1 t2 m a -> a Source #

(Monad m, MonadTrans t, MonadTrans v, OverableT v, MonadTransTrans u, MonadIdentity (v (u t m))) => MonadIdentity (OverTT v u t m) Source # 
Instance details

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

Methods

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

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

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 Source #

Fail catastrophically, returning nothing.

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

Fail catastrophically, returning nothing.

Instances
MonadIdentity mark => MonadHalt mark (Halt mark) Source # 
Instance details

Defined in Control.FX.Monad.Halt

Methods

halt :: mark () -> Halt mark a Source #

MonadHalt mark m => MonadHalt mark (IdentityT m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.IdentityT

Methods

halt :: mark () -> IdentityT m a Source #

(MonadHalt mark m, MonadIdentity mark, MonadIdentity mark1) => MonadHalt mark (HaltT mark1 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.HaltT

Methods

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

(Monad m, MonadIdentity mark) => MonadHalt mark (HaltT mark m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.HaltT

Methods

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

(Monad m, MonadTrans t, MonadIdentity mark, MonadHalt mark (t m)) => MonadHalt mark (IdentityTT t m) Source # 
Instance details

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

Methods

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

(Monad m, MonadIdentity mark1, Monoid w, MonadIdentity mark, MonadHalt mark m) => MonadHalt mark (WriteOnlyT mark1 w m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

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

(Monad m, MonadIdentity mark1, MonadIdentity mark, MonadHalt mark m) => MonadHalt mark (WriteOnceT mark1 w m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

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

(Monad m, MonadIdentity mark1, MonadIdentity mark, MonadHalt mark m) => MonadHalt mark (StateT mark1 s m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.StateT

Methods

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

(Monad m, MonadIdentity mark1, Commutant mark1, MonadIdentity mark, MonadHalt mark m) => MonadHalt mark (ReadOnlyT mark1 r m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadHalt mark m) => MonadHalt mark (ExceptT mark1 e m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ExceptT

Methods

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

(Monad m, MonadIdentity mark1, MonadIdentity mark, Monoid w, MonadHalt mark m) => MonadHalt mark (AppendOnlyT mark1 w m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

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

(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) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ComposeT

Methods

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

(Monad m, MonadTrans t2, MonadIdentity mark) => MonadHalt mark (ComposeT (HaltT mark) t2 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ComposeT

Methods

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

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

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

Methods

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

(Monad m, MonadTrans t, MonadIdentity mark) => MonadHalt mark (HaltTT mark t m) Source # 
Instance details

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

Methods

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

(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) Source # 
Instance details

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

Methods

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

(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) Source # 
Instance details

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

Methods

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

(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) Source # 
Instance details

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

Methods

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

(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) Source # 
Instance details

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

Methods

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

(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) Source # 
Instance details

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

Methods

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

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

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

Methods

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

(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) Source # 
Instance details

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

Methods

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

(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) Source # 
Instance details

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

Methods

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

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

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 Source #

Raise an exception

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

Raise an exception

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

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 Source #

Run a computation, applying a handler to any raised exceptions

Instances
MonadExcept mark e m => MonadExcept mark e (IdentityT m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.IdentityT

Methods

throw :: mark e -> IdentityT m a Source #

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

MonadIdentity mark => MonadExcept mark e (Except mark e) Source # 
Instance details

Defined in Control.FX.Monad.Except

Methods

throw :: mark e -> Except mark e a Source #

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadExcept mark e m) => MonadExcept mark e (HaltT mark1 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.HaltT

Methods

throw :: mark e -> HaltT mark1 m a Source #

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

(Monad m, MonadTrans t, MonadIdentity mark, MonadExcept mark e (t m)) => MonadExcept mark e (IdentityTT t m) Source # 
Instance details

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

Methods

throw :: mark e -> IdentityTT t m a Source #

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, Monoid w, MonadExcept mark e m) => MonadExcept mark e (WriteOnlyT mark1 w m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

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

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadExcept mark e m) => MonadExcept mark e (WriteOnceT mark1 w m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

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

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadExcept mark e m) => MonadExcept mark e (StateT mark1 s m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.StateT

Methods

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

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadExcept mark e m, Commutant mark1) => MonadExcept mark e (ReadOnlyT mark1 r m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

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

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadExcept mark e m) => MonadExcept mark e (ExceptT mark1 e1 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ExceptT

Methods

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

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

(Monad m, MonadIdentity mark) => MonadExcept mark e (ExceptT mark e m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ExceptT

Methods

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

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, Monoid w, MonadExcept mark e m) => MonadExcept mark e (AppendOnlyT mark1 w m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

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

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

(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) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ComposeT

Methods

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

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

(Monad m, MonadTrans t2, MonadIdentity mark) => MonadExcept mark e (ComposeT (ExceptT mark e) t2 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ComposeT

Methods

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

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

(Monad m, MonadTrans t, MonadIdentity mark1, MonadExcept mark e (t m)) => MonadExcept mark e (HaltTT mark1 t m) Source # 
Instance details

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

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

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

Methods

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

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 Source #

(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) Source # 
Instance details

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

Methods

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

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

(Monad m, MonadTrans t, MonadIdentity mark) => MonadExcept mark e (ExceptTT mark e t m) Source # 
Instance details

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

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

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) Source #

Retrieve the current state

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

Retrieve the current state

put :: mark s -> m () Source #

Replace the current state

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

Replace the current state

Instances
MonadState mark s m => MonadState mark s (IdentityT m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.IdentityT

Methods

get :: IdentityT m (mark s) Source #

put :: mark s -> IdentityT m () Source #

MonadIdentity mark => MonadState mark s (State mark s) Source # 
Instance details

Defined in Control.FX.Monad.State

Methods

get :: State mark s (mark s) Source #

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadState mark s m) => MonadState mark s (HaltT mark1 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.HaltT

Methods

get :: HaltT mark1 m (mark s) Source #

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

(Monad m, MonadTrans t, MonadIdentity mark, MonadState mark s (t m)) => MonadState mark s (IdentityTT t m) Source # 
Instance details

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

Methods

get :: IdentityTT t m (mark s) Source #

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadState mark s m, Monoid w) => MonadState mark s (WriteOnlyT mark1 w m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

get :: WriteOnlyT mark1 w m (mark s) Source #

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadState mark s m) => MonadState mark s (WriteOnceT mark1 w m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

get :: WriteOnceT mark1 w m (mark s) Source #

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadState mark s m) => MonadState mark s (StateT mark1 s1 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.StateT

Methods

get :: StateT mark1 s1 m (mark s) Source #

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

(Monad m, MonadIdentity mark) => MonadState mark s (StateT mark s m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.StateT

Methods

get :: StateT mark s m (mark s) Source #

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadState mark s m, Commutant mark1) => MonadState mark s (ReadOnlyT mark1 r m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

get :: ReadOnlyT mark1 r m (mark s) Source #

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadState mark s m) => MonadState mark s (ExceptT mark1 e m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ExceptT

Methods

get :: ExceptT mark1 e m (mark s) Source #

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, Monoid w, MonadState mark s m) => MonadState mark s (AppendOnlyT mark1 w m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

get :: AppendOnlyT mark1 w m (mark s) Source #

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

(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) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ComposeT

Methods

get :: ComposeT t1 t2 m (mark s) Source #

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

(Monad m, MonadTrans t2, MonadIdentity mark) => MonadState mark s (ComposeT (StateT mark s) t2 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ComposeT

Methods

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

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

(Monad m, MonadTrans t, MonadIdentity mark1, MonadState mark s (t m)) => MonadState mark s (HaltTT mark1 t m) Source # 
Instance details

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

Methods

get :: HaltTT mark1 t m (mark s) Source #

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

(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) Source # 
Instance details

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

(Monad m, MonadTrans t, MonadIdentity mark) => MonadState mark s (StateTT mark s t m) Source # 
Instance details

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

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

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

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

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 () Source #

Combine a value with the current write-only state

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

Combine a value with the current write-only state

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

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) Source #

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) Source # 
Instance details

Defined in Control.FX.Monad.Trans.IdentityT

Methods

tell :: mark w -> IdentityT m () Source #

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

(Monoid w, MonadIdentity mark) => MonadWriteOnly mark w (WriteOnly mark w) Source # 
Instance details

Defined in Control.FX.Monad.WriteOnly

Methods

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

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnly mark w m, Monoid w) => MonadWriteOnly mark w (HaltT mark1 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.HaltT

Methods

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

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

(Monad m, MonadTrans t, MonadIdentity mark, MonadWriteOnly mark w (t m), Monoid w) => MonadWriteOnly mark w (IdentityTT t m) Source # 
Instance details

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

Methods

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

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnly mark w m, Monoid w, Monoid w1) => MonadWriteOnly mark w (WriteOnlyT mark1 w1 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

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

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

(Monoid w, Monad m, MonadIdentity mark) => MonadWriteOnly mark w (WriteOnlyT mark w m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

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

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnly mark w m) => MonadWriteOnly mark w (WriteOnceT mark1 w1 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

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

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnly mark w m, Monoid w) => MonadWriteOnly mark w (StateT mark1 s m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.StateT

Methods

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

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

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

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

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

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, Monoid w, MonadWriteOnly mark w m) => MonadWriteOnly mark w (ExceptT mark1 e m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ExceptT

Methods

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

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnly mark w m, Monoid w, Monoid w1) => MonadWriteOnly mark w (AppendOnlyT mark1 w1 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

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

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

(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) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ComposeT

Methods

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

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

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

Defined in Control.FX.Monad.Trans.ComposeT

Methods

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

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

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

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

(Monad m, MonadTrans t, MonadIdentity mark, Monoid w) => MonadWriteOnly mark w (WriteOnlyTT mark w t m) Source # 
Instance details

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

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

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

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

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) Source #

Retrieve the read-only state

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

Retrieve the read-only state

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

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 Source #

Run a computation with a locally modified read-only state

Instances
MonadReadOnly mark r m => MonadReadOnly mark r (IdentityT m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.IdentityT

Methods

ask :: IdentityT m (mark r) Source #

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

MonadIdentity mark => MonadReadOnly mark r (ReadOnly mark r) Source # 
Instance details

Defined in Control.FX.Monad.ReadOnly

Methods

ask :: ReadOnly mark r (mark r) Source #

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadReadOnly mark r m) => MonadReadOnly mark r (HaltT mark1 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.HaltT

Methods

ask :: HaltT mark1 m (mark r) Source #

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

(Monad m, MonadTrans t, MonadIdentity mark, MonadReadOnly mark r (t m)) => MonadReadOnly mark r (IdentityTT t m) Source # 
Instance details

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

Methods

ask :: IdentityTT t m (mark r) Source #

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadReadOnly mark r m, Monoid w) => MonadReadOnly mark r (WriteOnlyT mark1 w m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

ask :: WriteOnlyT mark1 w m (mark r) Source #

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadReadOnly mark r m) => MonadReadOnly mark r (WriteOnceT mark1 w m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

ask :: WriteOnceT mark1 w m (mark r) Source #

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadReadOnly mark r m) => MonadReadOnly mark r (StateT mark1 s m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.StateT

Methods

ask :: StateT mark1 s m (mark r) Source #

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadReadOnly mark r m, Commutant mark1) => MonadReadOnly mark r (ReadOnlyT mark1 r1 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

ask :: ReadOnlyT mark1 r1 m (mark r) Source #

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

(Monad m, MonadIdentity mark) => MonadReadOnly mark r (ReadOnlyT mark r m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

ask :: ReadOnlyT mark r m (mark r) Source #

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadReadOnly mark r m) => MonadReadOnly mark r (ExceptT mark1 e m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ExceptT

Methods

ask :: ExceptT mark1 e m (mark r) Source #

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, Monoid w, MonadReadOnly mark r m) => MonadReadOnly mark r (AppendOnlyT mark1 w m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

ask :: AppendOnlyT mark1 w m (mark r) Source #

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

(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) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ComposeT

Methods

ask :: ComposeT t1 t2 m (mark r) Source #

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

(Monad m, MonadTrans t2, MonadIdentity mark) => MonadReadOnly mark r (ComposeT (ReadOnlyT mark r) t2 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ComposeT

Methods

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

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

(Monad m, MonadTrans t, MonadIdentity mark1, MonadReadOnly mark r (t m)) => MonadReadOnly mark r (HaltTT mark1 t m) Source # 
Instance details

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

Methods

ask :: HaltTT mark1 t m (mark r) Source #

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

(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) Source # 
Instance details

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

(Monad m, MonadTrans t, MonadIdentity mark) => MonadReadOnly mark r (ReadOnlyTT mark r t m) Source # 
Instance details

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

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

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

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

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) Source #

Retrieve the append-only state

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

Retrieve the append-only state

jot :: mark w -> m () Source #

Append a value to the state

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

Append a value to the state

Instances
MonadAppendOnly mark w m => MonadAppendOnly mark w (IdentityT m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.IdentityT

Methods

look :: IdentityT m (mark w) Source #

jot :: mark w -> IdentityT m () Source #

(Monoid w, MonadIdentity mark) => MonadAppendOnly mark w (AppendOnly mark w) Source # 
Instance details

Defined in Control.FX.Monad.AppendOnly

Methods

look :: AppendOnly mark w (mark w) Source #

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadAppendOnly mark w m, Monoid w) => MonadAppendOnly mark w (HaltT mark1 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.HaltT

Methods

look :: HaltT mark1 m (mark w) Source #

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

(Monad m, MonadTrans t, MonadIdentity mark, MonadAppendOnly mark w (t m), Monoid w) => MonadAppendOnly mark w (IdentityTT t m) Source # 
Instance details

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

Methods

look :: IdentityTT t m (mark w) Source #

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadAppendOnly mark w m, Monoid w, Monoid w1) => MonadAppendOnly mark w (WriteOnlyT mark1 w1 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

look :: WriteOnlyT mark1 w1 m (mark w) Source #

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadAppendOnly mark w m) => MonadAppendOnly mark w (WriteOnceT mark1 w1 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

look :: WriteOnceT mark1 w1 m (mark w) Source #

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadAppendOnly mark w m, Monoid w) => MonadAppendOnly mark w (StateT mark1 s m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.StateT

Methods

look :: StateT mark1 s m (mark w) Source #

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

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

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

look :: ReadOnlyT mark1 r m (mark w) Source #

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, Monoid w, MonadAppendOnly mark w m) => MonadAppendOnly mark w (ExceptT mark1 e m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ExceptT

Methods

look :: ExceptT mark1 e m (mark w) Source #

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, Monoid w, Monoid w1, MonadAppendOnly mark w m) => MonadAppendOnly mark w (AppendOnlyT mark1 w1 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

look :: AppendOnlyT mark1 w1 m (mark w) Source #

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

(Monad m, MonadIdentity mark, Monoid w) => MonadAppendOnly mark w (AppendOnlyT mark w m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

look :: AppendOnlyT mark w m (mark w) Source #

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

(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) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ComposeT

Methods

look :: ComposeT t1 t2 m (mark w) Source #

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

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

Defined in Control.FX.Monad.Trans.ComposeT

Methods

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

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

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

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

Methods

look :: HaltTT mark1 t m (mark w) Source #

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

(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) Source # 
Instance details

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

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

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

(Monad m, MonadTrans t, MonadIdentity mark, Monoid w) => MonadAppendOnly mark w (AppendOnlyTT mark w t m) Source # 
Instance details

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

Methods

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

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

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

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 Source #

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 Source #

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

press :: m (Maybe (mark w)) Source #

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)) Source #

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

Instances
MonadWriteOnce mark w m => MonadWriteOnce mark w (IdentityT m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.IdentityT

Methods

etch :: mark w -> IdentityT m Bool Source #

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

MonadIdentity mark => MonadWriteOnce mark w (WriteOnce mark w) Source # 
Instance details

Defined in Control.FX.Monad.WriteOnce

Methods

etch :: mark w -> WriteOnce mark w Bool Source #

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnce mark w m) => MonadWriteOnce mark w (HaltT mark1 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.HaltT

Methods

etch :: mark w -> HaltT mark1 m Bool Source #

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

(Monad m, MonadTrans t, MonadIdentity mark, MonadWriteOnce mark w (t m)) => MonadWriteOnce mark w (IdentityTT t m) Source # 
Instance details

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

Methods

etch :: mark w -> IdentityTT t m Bool Source #

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnce mark w m, Monoid w1) => MonadWriteOnce mark w (WriteOnlyT mark1 w1 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

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

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnce mark w m) => MonadWriteOnce mark w (WriteOnceT mark1 w1 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

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

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

(Monad m, MonadIdentity mark) => MonadWriteOnce mark w (WriteOnceT mark w m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

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

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnce mark w m) => MonadWriteOnce mark w (StateT mark1 s m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.StateT

Methods

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

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnce mark w m, Commutant mark1) => MonadWriteOnce mark w (ReadOnlyT mark1 r m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

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

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnce mark w m) => MonadWriteOnce mark w (ExceptT mark1 e m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ExceptT

Methods

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

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, Monoid w, Monoid w1, MonadWriteOnce mark w m) => MonadWriteOnce mark w (AppendOnlyT mark1 w1 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

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

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

(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) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ComposeT

Methods

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

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

(Monad m, MonadTrans t2, MonadIdentity mark) => MonadWriteOnce mark w (ComposeT (WriteOnceT mark w) t2 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ComposeT

Methods

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

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

(Monad m, MonadTrans t, MonadIdentity mark1, MonadWriteOnce mark w (t m)) => MonadWriteOnce mark w (HaltTT mark1 t m) Source # 
Instance details

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

(Monad m, MonadTrans t, MonadIdentity mark) => MonadWriteOnce mark w (WriteOnceTT mark w t m) Source # 
Instance details

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

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

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

(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) Source # 
Instance details

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

Methods

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

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

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

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

Minimal complete definition

Nothing

Methods

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

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) Source #

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

Instances
MonadPrompt mark p m => MonadPrompt mark p (IdentityT m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.IdentityT

Methods

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadPrompt mark p m) => MonadPrompt mark p (HaltT mark1 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.HaltT

Methods

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

(Monad m, MonadTrans t, MonadIdentity mark, MonadPrompt mark p (t m)) => MonadPrompt mark p (IdentityTT t m) Source # 
Instance details

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

Methods

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, Monoid w, MonadPrompt mark p m) => MonadPrompt mark p (WriteOnlyT mark1 w m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.WriteOnlyT

Methods

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadPrompt mark p m) => MonadPrompt mark p (WriteOnceT mark1 w m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.WriteOnceT

Methods

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadPrompt mark p m) => MonadPrompt mark p (StateT mark1 s m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.StateT

Methods

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadPrompt mark p m, Commutant mark1) => MonadPrompt mark p (ReadOnlyT mark1 r m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadPrompt mark p m) => MonadPrompt mark p (ExceptT mark1 e m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ExceptT

Methods

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, Monoid w, MonadPrompt mark p m) => MonadPrompt mark p (AppendOnlyT mark1 w m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.AppendOnlyT

Methods

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

(Monad m, MonadTrans t, MonadIdentity mark1, MonadPrompt mark p (t m)) => MonadPrompt mark p (HaltTT mark1 t m) Source # 
Instance details

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

Methods

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

(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) Source # 
Instance details

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

Methods

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

(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) Source # 
Instance details

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

Methods

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

(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) Source # 
Instance details

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

Methods

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

(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) Source # 
Instance details

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

Methods

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

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

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

Methods

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

(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) Source # 
Instance details

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

Methods

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

(Monad m, MonadTrans t, MonadIdentity mark) => MonadPrompt mark p (PromptTT mark p t m) Source # 
Instance details

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

Methods

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

(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) Source # 
Instance details

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

Methods

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

(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) Source # 
Instance details

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

Methods

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

Concrete Types

Monads

data Identity (a :: *) Source #

Concrete identity monad

Constructors

Identity 

Fields

Instances
Monad Identity Source # 
Instance details

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 Source # 
Instance details

Defined in Control.FX.Monad.Identity

Methods

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

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

Applicative Identity Source # 
Instance details

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 Source # 
Instance details

Defined in Control.FX.Monad.Identity

Associated Types

data Context Identity :: Type Source #

Methods

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

Commutant Identity Source # 
Instance details

Defined in Control.FX.Monad.Identity

Methods

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

MonadIdentity Identity Source # 
Instance details

Defined in Control.FX.Monad.Identity

Methods

unwrap :: Identity a -> a Source #

RunMonad Identity Source # 
Instance details

Defined in Control.FX.Monad.Identity

Associated Types

data Input Identity :: Type Source #

data Output Identity a :: Type Source #

Central Identity Source # 
Instance details

Defined in Control.FX.Monad.Identity

Eq (Context Identity) Source # 
Instance details

Defined in Control.FX.Monad.Identity

Eq (Input Identity) Source # 
Instance details

Defined in Control.FX.Monad.Identity

Eq a => Eq (Identity a) Source # 
Instance details

Defined in Control.FX.Monad.Identity

Methods

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

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

Show (Context Identity) Source # 
Instance details

Defined in Control.FX.Monad.Identity

Show (Input Identity) Source # 
Instance details

Defined in Control.FX.Monad.Identity

Show a => Show (Identity a) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

Defined in Control.FX.Monad.Identity

Show a => Show (Output Identity a) Source # 
Instance details

Defined in Control.FX.Monad.Identity

data Context Identity Source # 
Instance details

Defined in Control.FX.Monad.Identity

data Input Identity Source # 
Instance details

Defined in Control.FX.Monad.Identity

data Output Identity a Source # 
Instance details

Defined in Control.FX.Monad.Identity

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

Concrete composite monad

Constructors

Compose 

Fields

Instances
(Eq (Input m1), Eq (Input m2)) => Eq (Input (Compose m1 m2)) Source # 
Instance details

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)) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

Defined in Control.FX.Monad.Compose

Methods

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

(RunMonad m1, RunMonad m2, Central m2, Functor (Output m1)) => RunMonad (Compose m1 m2) Source # 
Instance details

Defined in Control.FX.Monad.Compose

Associated Types

data Input (Compose m1 m2) :: Type Source #

data Output (Compose m1 m2) a :: Type Source #

Methods

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

(Central c1, Central c2) => Central (Compose c1 c2) Source # 
Instance details

Defined in Control.FX.Monad.Compose

Eq (m1 (m2 a)) => Eq (Compose m1 m2 a) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

Defined in Control.FX.Monad.Compose

newtype Input (Compose m1 m2) = ComposeIn {}
newtype Output (Compose m1 m2) a Source # 
Instance details

Defined in Control.FX.Monad.Compose

newtype Output (Compose m1 m2) a = ComposeOut {}

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

Concrete read-only state monad with state type r

Constructors

ReadOnly 

Fields

Instances
MonadIdentity mark => MonadReadOnly mark r (ReadOnly mark r) Source # 
Instance details

Defined in Control.FX.Monad.ReadOnly

Methods

ask :: ReadOnly mark r (mark r) Source #

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

Eq (mark r) => Eq (Context (ReadOnly mark r)) Source # 
Instance details

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)) Source # 
Instance details

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)) Source # 
Instance details

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)) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

Defined in Control.FX.Monad.ReadOnly

Associated Types

data Context (ReadOnly mark r) :: Type Source #

Methods

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

(MonadIdentity mark, Commutant mark) => RunMonad (ReadOnly mark r) Source # 
Instance details

Defined in Control.FX.Monad.ReadOnly

Associated Types

data Input (ReadOnly mark r) :: Type Source #

data Output (ReadOnly mark r) a :: Type Source #

Methods

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

(Typeable r, Typeable a, Typeable mark) => Show (ReadOnly mark r a) Source # 
Instance details

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) Source # 
Instance details

Defined in Control.FX.Monad.ReadOnly

newtype Context (ReadOnly mark r) = ReadOnlyCtx {}
newtype Input (ReadOnly mark r) Source # 
Instance details

Defined in Control.FX.Monad.ReadOnly

newtype Input (ReadOnly mark r) = ReadOnlyIn {}
newtype Output (ReadOnly mark r) a Source # 
Instance details

Defined in Control.FX.Monad.ReadOnly

newtype Output (ReadOnly mark r) a = ReadOnlyOut {}

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

Concrete state monad

Constructors

State 

Fields

Instances
MonadIdentity mark => MonadState mark s (State mark s) Source # 
Instance details

Defined in Control.FX.Monad.State

Methods

get :: State mark s (mark s) Source #

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

Eq (mark s) => Eq (Context (State mark s)) Source # 
Instance details

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)) Source # 
Instance details

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)) Source # 
Instance details

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)) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

Defined in Control.FX.Monad.State

Associated Types

data Context (State mark s) :: Type Source #

Methods

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

MonadIdentity mark => RunMonad (State mark s) Source # 
Instance details

Defined in Control.FX.Monad.State

Associated Types

data Input (State mark s) :: Type Source #

data Output (State mark s) a :: Type Source #

Methods

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

(Typeable s, Typeable a, Typeable mark) => Show (State mark s a) Source # 
Instance details

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) Source # 
Instance details

Defined in Control.FX.Monad.State

data Context (State mark s) = StateCtx {}
data Input (State mark s) Source # 
Instance details

Defined in Control.FX.Monad.State

data Input (State mark s) = StateIn {}
data Output (State mark s) a Source # 
Instance details

Defined in Control.FX.Monad.State

data Output (State mark s) a = StateOut {}

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

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) Source # 
Instance details

Defined in Control.FX.Monad.Except

Methods

throw :: mark e -> Except mark e a Source #

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

Eq (mark ()) => Eq (Context (Except mark e)) Source # 
Instance details

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)) Source # 
Instance details

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)) Source # 
Instance details

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)) Source # 
Instance details

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) Source # 
Instance details

Defined in Control.FX.Monad.Except

Methods

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

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

(Eq e, Eq a) => Eq (Output (Except mark e) a) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

Defined in Control.FX.Monad.Except

Associated Types

data Context (Except mark e) :: Type Source #

Methods

eqIn :: Eq a => Context (Except mark e) -> Except mark e a -> Except mark e a -> Bool Source #

MonadIdentity mark => Commutant (Except mark e) Source # 
Instance details

Defined in Control.FX.Monad.Except

Methods

commute :: Applicative f => Except mark e (f a) -> f (Except mark e a) Source #

MonadIdentity mark => RunMonad (Except mark e) Source # 
Instance details

Defined in Control.FX.Monad.Except

Associated Types

data Input (Except mark e) :: Type Source #

data Output (Except mark e) a :: Type Source #

Methods

run :: Input (Except mark e) -> Except mark e a -> Output (Except mark e) a Source #

MonadIdentity mark => Central (Except mark e) Source # 
Instance details

Defined in Control.FX.Monad.Except

(Eq e, Eq a) => Eq (Except mark e a) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

Defined in Control.FX.Monad.Except

newtype Context (Except mark e) = ExceptCtx {}
newtype Input (Except mark e) Source # 
Instance details

Defined in Control.FX.Monad.Except

newtype Input (Except mark e) = ExceptIn {}
newtype Output (Except mark e) a Source # 
Instance details

Defined in Control.FX.Monad.Except

newtype Output (Except mark e) a = ExceptOut {}

newtype WriteOnly (mark :: * -> *) (w :: *) (a :: *) Source #

Concrete write-only state monad with state type w

Constructors

WriteOnly 

Fields

Instances
(Monoid w, MonadIdentity mark) => MonadWriteOnly mark w (WriteOnly mark w) Source # 
Instance details

Defined in Control.FX.Monad.WriteOnly

Methods

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

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

Eq (mark ()) => Eq (Context (WriteOnly mark w)) Source # 
Instance details

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)) Source # 
Instance details

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)) Source # 
Instance details

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)) Source # 
Instance details

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) Source # 
Instance details

Defined in Control.FX.Monad.WriteOnly

Methods

bimap1 :: (a -> c) -> WriteOnly mark a b -> WriteOnly mark c b Source #

bimap2 :: (b -> c) -> WriteOnly mark a b -> WriteOnly mark a c Source #

(Eq (mark w), Eq a) => Eq (Output (WriteOnly mark w) a) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

Defined in Control.FX.Monad.WriteOnly

Associated Types

data Context (WriteOnly mark w) :: Type Source #

Methods

eqIn :: Eq a => Context (WriteOnly mark w) -> WriteOnly mark w a -> WriteOnly mark w a -> Bool Source #

(Monoid w, MonadIdentity mark) => Commutant (WriteOnly mark w) Source # 
Instance details

Defined in Control.FX.Monad.WriteOnly

Methods

commute :: Applicative f => WriteOnly mark w (f a) -> f (WriteOnly mark w a) Source #

(Monoid w, MonadIdentity mark) => RunMonad (WriteOnly mark w) Source # 
Instance details

Defined in Control.FX.Monad.WriteOnly

Associated Types

data Input (WriteOnly mark w) :: Type Source #

data Output (WriteOnly mark w) a :: Type Source #

Methods

run :: Input (WriteOnly mark w) -> WriteOnly mark w a -> Output (WriteOnly mark w) a Source #

(Monoid w, MonadIdentity mark) => Central (WriteOnly mark w) Source # 
Instance details

Defined in Control.FX.Monad.WriteOnly

(Eq w, Eq a) => Eq (WriteOnly mark w a) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

Defined in Control.FX.Monad.WriteOnly

newtype Context (WriteOnly mark w) = WriteOnlyCtx {}
newtype Input (WriteOnly mark w) Source # 
Instance details

Defined in Control.FX.Monad.WriteOnly

newtype Input (WriteOnly mark w) = WriteOnlyIn {}
newtype Output (WriteOnly mark w) a Source # 
Instance details

Defined in Control.FX.Monad.WriteOnly

newtype Output (WriteOnly mark w) a = WriteOnlyOut {}

data Halt (mark :: * -> *) (a :: *) Source #

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) Source # 
Instance details

Defined in Control.FX.Monad.Halt

Methods

halt :: mark () -> Halt mark a Source #

Eq (mark ()) => Eq (Context (Halt mark)) Source # 
Instance details

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)) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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)) Source # 
Instance details

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)) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

Defined in Control.FX.Monad.Halt

Associated Types

data Context (Halt mark) :: Type Source #

Methods

eqIn :: Eq a => Context (Halt mark) -> Halt mark a -> Halt mark a -> Bool Source #

MonadIdentity mark => Commutant (Halt mark) Source # 
Instance details

Defined in Control.FX.Monad.Halt

Methods

commute :: Applicative f => Halt mark (f a) -> f (Halt mark a) Source #

MonadIdentity mark => RunMonad (Halt mark) Source # 
Instance details

Defined in Control.FX.Monad.Halt

Associated Types

data Input (Halt mark) :: Type Source #

data Output (Halt mark) a :: Type Source #

Methods

run :: Input (Halt mark) -> Halt mark a -> Output (Halt mark) a Source #

MonadIdentity mark => Central (Halt mark) Source # 
Instance details

Defined in Control.FX.Monad.Halt

Eq a => Eq (Output (Halt mark) a) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

Defined in Control.FX.Monad.Halt

data Context (Halt mark) = HaltCtx {}
data Input (Halt mark) Source # 
Instance details

Defined in Control.FX.Monad.Halt

data Input (Halt mark) = HaltIn {}
data Output (Halt mark) a Source # 
Instance details

Defined in Control.FX.Monad.Halt

data Output (Halt mark) a = HaltOut {}

newtype AppendOnly (mark :: * -> *) (w :: *) (a :: *) Source #

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) Source # 
Instance details

Defined in Control.FX.Monad.AppendOnly

Methods

look :: AppendOnly mark w (mark w) Source #

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

Eq (mark ()) => Eq (Context (AppendOnly mark w)) Source # 
Instance details

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)) Source # 
Instance details

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)) Source # 
Instance details

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)) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

Defined in Control.FX.Monad.AppendOnly

Associated Types

data Context (AppendOnly mark w) :: Type Source #

Methods

eqIn :: Eq a => Context (AppendOnly mark w) -> AppendOnly mark w a -> AppendOnly mark w a -> Bool Source #

(Monoid w, MonadIdentity mark) => RunMonad (AppendOnly mark w) Source # 
Instance details

Defined in Control.FX.Monad.AppendOnly

Associated Types

data Input (AppendOnly mark w) :: Type Source #

data Output (AppendOnly mark w) a :: Type Source #

Methods

run :: Input (AppendOnly mark w) -> AppendOnly mark w a -> Output (AppendOnly mark w) a Source #

(Typeable w, Typeable a, Typeable mark) => Show (AppendOnly mark w a) Source # 
Instance details

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) Source # 
Instance details

Defined in Control.FX.Monad.AppendOnly

newtype Context (AppendOnly mark w) = AppendOnlyCtx {}
newtype Input (AppendOnly mark w) Source # 
Instance details

Defined in Control.FX.Monad.AppendOnly

newtype Input (AppendOnly mark w) = AppendOnlyIn {}
newtype Output (AppendOnly mark w) a Source # 
Instance details

Defined in Control.FX.Monad.AppendOnly

newtype Output (AppendOnly mark w) a = AppendOnlyOut {}

newtype WriteOnce (mark :: * -> *) (w :: *) (a :: *) Source #

Concrete write-once state monad

Constructors

WriteOnce 

Fields

Instances
MonadIdentity mark => MonadWriteOnce mark w (WriteOnce mark w) Source # 
Instance details

Defined in Control.FX.Monad.WriteOnce

Methods

etch :: mark w -> WriteOnce mark w Bool Source #

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

Eq (mark ()) => Eq (Context (WriteOnce mark w)) Source # 
Instance details

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)) Source # 
Instance details

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)) Source # 
Instance details

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)) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

Defined in Control.FX.Monad.WriteOnce

Associated Types

data Context (WriteOnce mark w) :: Type Source #

Methods

eqIn :: Eq a => Context (WriteOnce mark w) -> WriteOnce mark w a -> WriteOnce mark w a -> Bool Source #

MonadIdentity mark => RunMonad (WriteOnce mark w) Source # 
Instance details

Defined in Control.FX.Monad.WriteOnce

Associated Types

data Input (WriteOnce mark w) :: Type Source #

data Output (WriteOnce mark w) a :: Type Source #

Methods

run :: Input (WriteOnce mark w) -> WriteOnce mark w a -> Output (WriteOnce mark w) a Source #

(Typeable w, Typeable a, Typeable mark) => Show (WriteOnce mark w a) Source # 
Instance details

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) Source # 
Instance details

Defined in Control.FX.Monad.WriteOnce

newtype Context (WriteOnce mark w) = WriteOnceCtx {}
newtype Input (WriteOnce mark w) Source # 
Instance details

Defined in Control.FX.Monad.WriteOnce

newtype Input (WriteOnce mark w) = WriteOnceIn {}
newtype Output (WriteOnce mark w) a Source # 
Instance details

Defined in Control.FX.Monad.WriteOnce

newtype Output (WriteOnce mark w) a = WriteOnceOut {}

Transformers

newtype IdentityT (m :: * -> *) (a :: *) Source #

Concrete identity monad transformer

Constructors

IdentityT 

Fields

Instances
LiftLocal IdentityT Source # 
Instance details

Defined in Control.FX.Monad.Trans.IdentityT

Methods

liftLocal :: Monad m => Local r m (OutputT IdentityT a) -> Local r (IdentityT m) a Source #

LiftDraft IdentityT Source # 
Instance details

Defined in Control.FX.Monad.Trans.IdentityT

Methods

liftDraft :: (Monad m, Monoid w) => Draft w m (OutputT IdentityT a) -> Draft w (IdentityT m) a Source #

LiftCatch IdentityT Source # 
Instance details

Defined in Control.FX.Monad.Trans.IdentityT

Methods

liftCatch :: Monad m => Catch e m (OutputT IdentityT a) -> Catch e (IdentityT m) a Source #

RunMonadTrans IdentityT Source # 
Instance details

Defined in Control.FX.Monad.Trans.IdentityT

Associated Types

data InputT IdentityT :: Type Source #

data OutputT IdentityT a :: Type Source #

Methods

runT :: Monad m => InputT IdentityT -> IdentityT m a -> m (OutputT IdentityT a) Source #

MonadTrans IdentityT Source # 
Instance details

Defined in Control.FX.Monad.Trans.IdentityT

Methods

lift :: Monad m => m a -> IdentityT m a Source #

MonadFunctor IdentityT Source # 
Instance details

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 Source #

ComposableT IdentityT Source # 
Instance details

Defined in Control.FX.Monad.Trans.ComposeT

Associated Types

data ComposeT IdentityT t2 m a :: Type Source #

Methods

toComposeT :: IdentityT (t2 m) a -> ComposeT IdentityT t2 m a Source #

unComposeT :: ComposeT IdentityT t2 m a -> IdentityT (t2 m) a Source #

OverableT IdentityT Source # 
Instance details

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

Associated Types

data OverTT IdentityT u t m a :: Type Source #

Methods

toOverTT :: IdentityT (u t m) a -> OverTT IdentityT u t m a Source #

unOverTT :: OverTT IdentityT u t m a -> IdentityT (u t m) a Source #

MonadPrompt mark p m => MonadPrompt mark p (IdentityT m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.IdentityT

Methods

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

MonadWriteOnce mark w m => MonadWriteOnce mark w (IdentityT m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.IdentityT

Methods

etch :: mark w -> IdentityT m Bool Source #

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

MonadAppendOnly mark w m => MonadAppendOnly mark w (IdentityT m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.IdentityT

Methods

look :: IdentityT m (mark w) Source #

jot :: mark w -> IdentityT m () Source #

MonadReadOnly mark r m => MonadReadOnly mark r (IdentityT m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.IdentityT

Methods

ask :: IdentityT m (mark r) Source #

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

(MonadWriteOnly mark w m, Monoid w) => MonadWriteOnly mark w (IdentityT m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.IdentityT

Methods

tell :: mark w -> IdentityT m () Source #

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

MonadState mark s m => MonadState mark s (IdentityT m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.IdentityT

Methods

get :: IdentityT m (mark s) Source #

put :: mark s -> IdentityT m () Source #

MonadExcept mark e m => MonadExcept mark e (IdentityT m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.IdentityT

Methods

throw :: mark e -> IdentityT m a Source #

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

MonadHalt mark m => MonadHalt mark (IdentityT m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.IdentityT

Methods

halt :: mark () -> IdentityT m a Source #

Eq (Context m) => Eq (Context (IdentityT m)) Source # 
Instance details

Defined in Control.FX.Monad.Trans.IdentityT

Eq (InputT IdentityT) Source # 
Instance details

Defined in Control.FX.Monad.Trans.IdentityT

Monad m => Monad (IdentityT m) Source # 
Instance details

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) Source # 
Instance details

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)) Source # 
Instance details

Defined in Control.FX.Monad.Trans.IdentityT

Show (InputT IdentityT) Source # 
Instance details

Defined in Control.FX.Monad.Trans.IdentityT

Applicative m => Applicative (IdentityT m) Source # 
Instance details

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) Source # 
Instance details

Defined in Control.FX.Monad.Trans.IdentityT

Associated Types

data Context (IdentityT m) :: Type Source #

Methods

eqIn :: Eq a => Context (IdentityT m) -> IdentityT m a -> IdentityT m a -> Bool Source #

Central c => Commutant (IdentityT c) Source # 
Instance details

Defined in Control.FX.Monad.Trans.IdentityT

Methods

commute :: Applicative f => IdentityT c (f a) -> f (IdentityT c a) Source #

(MonadIdentity m, Central m) => MonadIdentity (IdentityT m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.IdentityT

Methods

unwrap :: IdentityT m a -> a Source #

Central c => Central (IdentityT c) Source # 
Instance details

Defined in Control.FX.Monad.Trans.IdentityT

Eq a => Eq (OutputT IdentityT a) Source # 
Instance details

Defined in Control.FX.Monad.Trans.IdentityT

(MonadIdentity m, Eq a) => Eq (IdentityT m a) Source # 
Instance details

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) Source # 
Instance details

Defined in Control.FX.Monad.Trans.IdentityT

Show (m a) => Show (IdentityT m a) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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 Source # 
Instance details

Defined in Control.FX.Monad.Trans.IdentityT

data OutputT IdentityT a Source # 
Instance details

Defined in Control.FX.Monad.Trans.IdentityT

newtype ComposeT IdentityT t2 m a Source # 
Instance details

Defined in Control.FX.Monad.Trans.ComposeT

newtype OverTT IdentityT u t m a Source # 
Instance details

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

data Context (IdentityT m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.IdentityT

class MonadTrans t1 => ComposableT t1 where Source #

Class representing monad transformers which can be composed on top of an arbitrary monad transformer.

Associated Types

data ComposeT (t1 :: (* -> *) -> * -> *) (t2 :: (* -> *) -> * -> *) (m :: * -> *) (a :: *) Source #

Concrete composite monad transformer

Methods

toComposeT :: t1 (t2 m) a -> ComposeT t1 t2 m a Source #

unComposeT :: ComposeT t1 t2 m a -> t1 (t2 m) a Source #

Instances
ComposableT IdentityT Source # 
Instance details

Defined in Control.FX.Monad.Trans.ComposeT

Associated Types

data ComposeT IdentityT t2 m a :: Type Source #

Methods

toComposeT :: IdentityT (t2 m) a -> ComposeT IdentityT t2 m a Source #

unComposeT :: ComposeT IdentityT t2 m a -> IdentityT (t2 m) a Source #

MonadIdentity mark => ComposableT (HaltT mark) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ComposeT

Associated Types

data ComposeT (HaltT mark) t2 m a :: Type Source #

Methods

toComposeT :: HaltT mark (t2 m) a -> ComposeT (HaltT mark) t2 m a Source #

unComposeT :: ComposeT (HaltT mark) t2 m a -> HaltT mark (t2 m) a Source #

(MonadIdentity mark, Monoid w) => ComposableT (WriteOnlyT mark w) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ComposeT

Associated Types

data ComposeT (WriteOnlyT mark w) t2 m a :: Type Source #

Methods

toComposeT :: WriteOnlyT mark w (t2 m) a -> ComposeT (WriteOnlyT mark w) t2 m a Source #

unComposeT :: ComposeT (WriteOnlyT mark w) t2 m a -> WriteOnlyT mark w (t2 m) a Source #

MonadIdentity mark => ComposableT (WriteOnceT mark w) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ComposeT

Associated Types

data ComposeT (WriteOnceT mark w) t2 m a :: Type Source #

Methods

toComposeT :: WriteOnceT mark w (t2 m) a -> ComposeT (WriteOnceT mark w) t2 m a Source #

unComposeT :: ComposeT (WriteOnceT mark w) t2 m a -> WriteOnceT mark w (t2 m) a Source #

MonadIdentity mark => ComposableT (StateT mark s) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ComposeT

Associated Types

data ComposeT (StateT mark s) t2 m a :: Type Source #

Methods

toComposeT :: StateT mark s (t2 m) a -> ComposeT (StateT mark s) t2 m a Source #

unComposeT :: ComposeT (StateT mark s) t2 m a -> StateT mark s (t2 m) a Source #

MonadIdentity mark => ComposableT (ReadOnlyT mark r) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ComposeT

Associated Types

data ComposeT (ReadOnlyT mark r) t2 m a :: Type Source #

Methods

toComposeT :: ReadOnlyT mark r (t2 m) a -> ComposeT (ReadOnlyT mark r) t2 m a Source #

unComposeT :: ComposeT (ReadOnlyT mark r) t2 m a -> ReadOnlyT mark r (t2 m) a Source #

MonadIdentity mark => ComposableT (ExceptT mark e) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ComposeT

Associated Types

data ComposeT (ExceptT mark e) t2 m a :: Type Source #

Methods

toComposeT :: ExceptT mark e (t2 m) a -> ComposeT (ExceptT mark e) t2 m a Source #

unComposeT :: ComposeT (ExceptT mark e) t2 m a -> ExceptT mark e (t2 m) a Source #

(MonadIdentity mark, Monoid w) => ComposableT (AppendOnlyT mark w) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ComposeT

Associated Types

data ComposeT (AppendOnlyT mark w) t2 m a :: Type Source #

Methods

toComposeT :: AppendOnlyT mark w (t2 m) a -> ComposeT (AppendOnlyT mark w) t2 m a Source #

unComposeT :: ComposeT (AppendOnlyT mark w) t2 m a -> AppendOnlyT mark w (t2 m) a Source #

newtype ReadOnlyT (mark :: * -> *) (r :: *) (m :: * -> *) (a :: *) Source #

Concrete ReadOnly monad transformer

Constructors

ReadOnlyT 

Fields

Instances
(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadPrompt mark p m, Commutant mark1) => MonadPrompt mark p (ReadOnlyT mark1 r m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnce mark w m, Commutant mark1) => MonadWriteOnce mark w (ReadOnlyT mark1 r m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

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

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

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

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

look :: ReadOnlyT mark1 r m (mark w) Source #

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadReadOnly mark r m, Commutant mark1) => MonadReadOnly mark r (ReadOnlyT mark1 r1 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

ask :: ReadOnlyT mark1 r1 m (mark r) Source #

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

(Monad m, MonadIdentity mark) => MonadReadOnly mark r (ReadOnlyT mark r m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

ask :: ReadOnlyT mark r m (mark r) Source #

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

(Monad m, MonadTrans t2, MonadIdentity mark) => MonadReadOnly mark r (ComposeT (ReadOnlyT mark r) t2 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ComposeT

Methods

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

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

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

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

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

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadState mark s m, Commutant mark1) => MonadState mark s (ReadOnlyT mark1 r m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

get :: ReadOnlyT mark1 r m (mark s) Source #

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadExcept mark e m, Commutant mark1) => MonadExcept mark e (ReadOnlyT mark1 r m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

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

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

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

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

Methods

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

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

(Monad m, MonadIdentity mark1, Commutant mark1, MonadIdentity mark, MonadHalt mark m) => MonadHalt mark (ReadOnlyT mark1 r m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

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

(Eq (mark r), Eq (Context m)) => Eq (Context (ReadOnlyT mark r m)) Source # 
Instance details

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)) Source # 
Instance details

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)) Source # 
Instance details

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)) Source # 
Instance details

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)) Source # 
Instance details

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)) Source # 
Instance details

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)) Source # 
Instance details

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)) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

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

Eq (mark a) => Eq (OutputT (ReadOnlyT mark r) a) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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 Source #

(MonadIdentity mark, Commutant mark) => LiftDraft (ReadOnlyT mark r) Source # 
Instance details

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 Source #

(MonadIdentity mark, Commutant mark) => LiftCatch (ReadOnlyT mark r) Source # 
Instance details

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 Source #

(MonadIdentity mark, Commutant mark) => RunMonadTrans (ReadOnlyT mark r) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ReadOnlyT

Associated Types

data InputT (ReadOnlyT mark r) :: Type Source #

data OutputT (ReadOnlyT mark r) a :: Type Source #

Methods

runT :: Monad m => InputT (ReadOnlyT mark r) -> ReadOnlyT mark r m a -> m (OutputT (ReadOnlyT mark r) a) Source #

MonadIdentity mark => MonadTrans (ReadOnlyT mark r) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

lift :: Monad m => m a -> ReadOnlyT mark r m a Source #

MonadIdentity mark => MonadFunctor (ReadOnlyT mark r) Source # 
Instance details

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 Source #

MonadIdentity mark => ComposableT (ReadOnlyT mark r) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ComposeT

Associated Types

data ComposeT (ReadOnlyT mark r) t2 m a :: Type Source #

Methods

toComposeT :: ReadOnlyT mark r (t2 m) a -> ComposeT (ReadOnlyT mark r) t2 m a Source #

unComposeT :: ComposeT (ReadOnlyT mark r) t2 m a -> ReadOnlyT mark r (t2 m) a Source #

MonadIdentity mark => OverableT (ReadOnlyT mark r) Source # 
Instance details

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

Associated Types

data OverTT (ReadOnlyT mark r) u t m a :: Type Source #

Methods

toOverTT :: ReadOnlyT mark r (u t m) a -> OverTT (ReadOnlyT mark r) u t m a Source #

unOverTT :: OverTT (ReadOnlyT mark r) u t m a -> ReadOnlyT mark r (u t m) a Source #

(Monad m, MonadIdentity mark) => Monad (ReadOnlyT mark r m) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ReadOnlyT

Associated Types

data Context (ReadOnlyT mark r m) :: Type Source #

Methods

eqIn :: Eq a => Context (ReadOnlyT mark r m) -> ReadOnlyT mark r m a -> ReadOnlyT mark r m a -> Bool Source #

(Typeable r, Typeable m, Typeable a, Typeable mark) => Show (ReadOnlyT mark r m a) Source # 
Instance details

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) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ReadOnlyT

newtype InputT (ReadOnlyT mark r) = ReadOnlyTIn {}
newtype OutputT (ReadOnlyT mark r) a Source # 
Instance details

Defined in Control.FX.Monad.Trans.ReadOnlyT

newtype OutputT (ReadOnlyT mark r) a = ReadOnlyTOut {}
newtype ComposeT (ReadOnlyT mark r) t2 m a Source # 
Instance details

Defined in Control.FX.Monad.Trans.ComposeT

newtype ComposeT (ReadOnlyT mark r) t2 m a = ComposeT_ReadOnlyT {}
newtype OverTT (ReadOnlyT mark r) u t m a Source # 
Instance details

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

newtype OverTT (ReadOnlyT mark r) u t m a = OverTT_ReadOnlyT {}
newtype Context (ReadOnlyT mark r m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ReadOnlyT

newtype Context (ReadOnlyT mark r m) = ReadOnlyTCtx {}

runReadOnlyT :: (Monad m, MonadIdentity mark, Commutant mark) => mark r -> ReadOnlyT mark r m a -> m (mark a) Source #

newtype StateT (mark :: * -> *) (s :: *) (m :: * -> *) (a :: *) Source #

Concrete State monad transformer

Constructors

StateT 

Fields

Instances
(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadPrompt mark p m) => MonadPrompt mark p (StateT mark1 s m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.StateT

Methods

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnce mark w m) => MonadWriteOnce mark w (StateT mark1 s m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.StateT

Methods

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

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadAppendOnly mark w m, Monoid w) => MonadAppendOnly mark w (StateT mark1 s m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.StateT

Methods

look :: StateT mark1 s m (mark w) Source #

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadReadOnly mark r m) => MonadReadOnly mark r (StateT mark1 s m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.StateT

Methods

ask :: StateT mark1 s m (mark r) Source #

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnly mark w m, Monoid w) => MonadWriteOnly mark w (StateT mark1 s m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.StateT

Methods

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

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadState mark s m) => MonadState mark s (StateT mark1 s1 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.StateT

Methods

get :: StateT mark1 s1 m (mark s) Source #

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

(Monad m, MonadIdentity mark) => MonadState mark s (StateT mark s m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.StateT

Methods

get :: StateT mark s m (mark s) Source #

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

(Monad m, MonadTrans t2, MonadIdentity mark) => MonadState mark s (ComposeT (StateT mark s) t2 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ComposeT

Methods

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

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadExcept mark e m) => MonadExcept mark e (StateT mark1 s m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.StateT

Methods

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

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

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

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

Methods

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

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

(Monad m, MonadIdentity mark1, MonadIdentity mark, MonadHalt mark m) => MonadHalt mark (StateT mark1 s m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.StateT

Methods

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

(Eq (mark s), Eq (Context m)) => Eq (Context (StateT mark s m)) Source # 
Instance details

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)) Source # 
Instance details

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)) Source # 
Instance details

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)) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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 Source #

MonadIdentity mark => LiftDraft (StateT mark s) Source # 
Instance details

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 Source #

MonadIdentity mark => LiftCatch (StateT mark s) Source # 
Instance details

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 Source #

MonadIdentity mark => RunMonadTrans (StateT mark s) Source # 
Instance details

Defined in Control.FX.Monad.Trans.StateT

Associated Types

data InputT (StateT mark s) :: Type Source #

data OutputT (StateT mark s) a :: Type Source #

Methods

runT :: Monad m => InputT (StateT mark s) -> StateT mark s m a -> m (OutputT (StateT mark s) a) Source #

MonadIdentity mark => MonadTrans (StateT mark s) Source # 
Instance details

Defined in Control.FX.Monad.Trans.StateT

Methods

lift :: Monad m => m a -> StateT mark s m a Source #

MonadIdentity mark => MonadFunctor (StateT mark s) Source # 
Instance details

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 Source #

MonadIdentity mark => ComposableT (StateT mark s) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ComposeT

Associated Types

data ComposeT (StateT mark s) t2 m a :: Type Source #

Methods

toComposeT :: StateT mark s (t2 m) a -> ComposeT (StateT mark s) t2 m a Source #

unComposeT :: ComposeT (StateT mark s) t2 m a -> StateT mark s (t2 m) a Source #

MonadIdentity mark => OverableT (StateT mark s) Source # 
Instance details

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

Associated Types

data OverTT (StateT mark s) u t m a :: Type Source #

Methods

toOverTT :: StateT mark s (u t m) a -> OverTT (StateT mark s) u t m a Source #

unOverTT :: OverTT (StateT mark s) u t m a -> StateT mark s (u t m) a Source #

(Monad m, MonadIdentity mark) => Monad (StateT mark s m) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

Defined in Control.FX.Monad.Trans.StateT

Associated Types

data Context (StateT mark s m) :: Type Source #

Methods

eqIn :: Eq a => Context (StateT mark s m) -> StateT mark s m a -> StateT mark s m a -> Bool Source #

(Typeable s, Typeable m, Typeable a, Typeable mark) => Show (StateT mark s m a) Source # 
Instance details

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) Source # 
Instance details

Defined in Control.FX.Monad.Trans.StateT

newtype InputT (StateT mark s) = StateTIn {}
newtype OutputT (StateT mark s) a Source # 
Instance details

Defined in Control.FX.Monad.Trans.StateT

newtype OutputT (StateT mark s) a = StateTOut {}
newtype ComposeT (StateT mark s) t2 m a Source # 
Instance details

Defined in Control.FX.Monad.Trans.ComposeT

newtype ComposeT (StateT mark s) t2 m a = ComposeT_StateT {}
newtype OverTT (StateT mark s) u t m a Source # 
Instance details

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

newtype OverTT (StateT mark s) u t m a = OverTT_StateT {}
newtype Context (StateT mark s m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.StateT

newtype Context (StateT mark s m) = StateTCtx {}

runStateT :: (Monad m, MonadIdentity mark) => mark s -> StateT mark s m a -> m (Pair (mark s) a) Source #

newtype HaltT (mark :: * -> *) (m :: * -> *) (a :: *) Source #

Concrete Maybe monad transformer

Constructors

HaltT 

Fields

Instances
(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadPrompt mark p m) => MonadPrompt mark p (HaltT mark1 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.HaltT

Methods

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnce mark w m) => MonadWriteOnce mark w (HaltT mark1 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.HaltT

Methods

etch :: mark w -> HaltT mark1 m Bool Source #

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadAppendOnly mark w m, Monoid w) => MonadAppendOnly mark w (HaltT mark1 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.HaltT

Methods

look :: HaltT mark1 m (mark w) Source #

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadReadOnly mark r m) => MonadReadOnly mark r (HaltT mark1 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.HaltT

Methods

ask :: HaltT mark1 m (mark r) Source #

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnly mark w m, Monoid w) => MonadWriteOnly mark w (HaltT mark1 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.HaltT

Methods

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

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadState mark s m) => MonadState mark s (HaltT mark1 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.HaltT

Methods

get :: HaltT mark1 m (mark s) Source #

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadExcept mark e m) => MonadExcept mark e (HaltT mark1 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.HaltT

Methods

throw :: mark e -> HaltT mark1 m a Source #

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

(MonadHalt mark m, MonadIdentity mark, MonadIdentity mark1) => MonadHalt mark (HaltT mark1 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.HaltT

Methods

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

(Monad m, MonadIdentity mark) => MonadHalt mark (HaltT mark m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.HaltT

Methods

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

(Monad m, MonadTrans t2, MonadIdentity mark) => MonadHalt mark (ComposeT (HaltT mark) t2 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ComposeT

Methods

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

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

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

Methods

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

(Eq (mark ()), Eq (Context m)) => Eq (Context (HaltT mark m)) Source # 
Instance details

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)) Source # 
Instance details

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)) Source # 
Instance details

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)) Source # 
Instance details

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)) Source # 
Instance details

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)) Source # 
Instance details

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) Source # 
Instance details

Defined in Control.FX.Monad.Trans.HaltT

Methods

liftLocal :: Monad m => Local r m (OutputT (HaltT mark) a) -> Local r (HaltT mark m) a Source #

MonadIdentity mark => LiftDraft (HaltT mark) Source # 
Instance details

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 Source #

MonadIdentity mark => LiftCatch (HaltT mark) Source # 
Instance details

Defined in Control.FX.Monad.Trans.HaltT

Methods

liftCatch :: Monad m => Catch e m (OutputT (HaltT mark) a) -> Catch e (HaltT mark m) a Source #

MonadIdentity mark => RunMonadTrans (HaltT mark) Source # 
Instance details

Defined in Control.FX.Monad.Trans.HaltT

Associated Types

data InputT (HaltT mark) :: Type Source #

data OutputT (HaltT mark) a :: Type Source #

Methods

runT :: Monad m => InputT (HaltT mark) -> HaltT mark m a -> m (OutputT (HaltT mark) a) Source #

MonadIdentity mark => MonadTrans (HaltT mark) Source # 
Instance details

Defined in Control.FX.Monad.Trans.HaltT

Methods

lift :: Monad m => m a -> HaltT mark m a Source #

MonadIdentity mark => MonadFunctor (HaltT mark) Source # 
Instance details

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 Source #

MonadIdentity mark => ComposableT (HaltT mark) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ComposeT

Associated Types

data ComposeT (HaltT mark) t2 m a :: Type Source #

Methods

toComposeT :: HaltT mark (t2 m) a -> ComposeT (HaltT mark) t2 m a Source #

unComposeT :: ComposeT (HaltT mark) t2 m a -> HaltT mark (t2 m) a Source #

MonadIdentity mark => OverableT (HaltT mark) Source # 
Instance details

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

Associated Types

data OverTT (HaltT mark) u t m a :: Type Source #

Methods

toOverTT :: HaltT mark (u t m) a -> OverTT (HaltT mark) u t m a Source #

unOverTT :: OverTT (HaltT mark) u t m a -> HaltT mark (u t m) a Source #

Eq a => Eq (OutputT (HaltT mark) a) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

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) Source # 
Instance details

Defined in Control.FX.Monad.Trans.HaltT

Associated Types

data Context (HaltT mark m) :: Type Source #

Methods

eqIn :: Eq a => Context (HaltT mark m) -> HaltT mark m a -> HaltT mark m a -> Bool Source #

(Central c, MonadIdentity mark) => Commutant (HaltT mark c) Source # 
Instance details

Defined in Control.FX.Monad.Trans.HaltT

Methods

commute :: Applicative f => HaltT mark c (f a) -> f (HaltT mark c a) Source #

(Central c, MonadIdentity mark) => Central (HaltT mark c) Source # 
Instance details

Defined in Control.FX.Monad.Trans.HaltT

Show (m (Halt mark a)) => Show (HaltT mark m a) Source # 
Instance details

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) Source # 
Instance details

Defined in Control.FX.Monad.Trans.HaltT

newtype InputT (HaltT mark) = HaltTIn {}
newtype OutputT (HaltT mark) a Source # 
Instance details

Defined in Control.FX.Monad.Trans.HaltT

newtype OutputT (HaltT mark) a = HaltTOut {}
newtype ComposeT (HaltT mark) t2 m a Source # 
Instance details

Defined in Control.FX.Monad.Trans.ComposeT

newtype ComposeT (HaltT mark) t2 m a = ComposeT_HaltT {}
newtype OverTT (HaltT mark) u t m a Source # 
Instance details

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

newtype OverTT (HaltT mark) u t m a = OverTT_HaltT {}
newtype Context (HaltT mark m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.HaltT

newtype Context (HaltT mark m) = HaltTCtx {}

runHaltT :: (Monad m, MonadIdentity mark) => HaltT mark m a -> m (Halt mark a) Source #

newtype ExceptT (mark :: * -> *) (e :: *) (m :: * -> *) (a :: *) Source #

Concrete exception monad transformer

Constructors

ExceptT 

Fields

Instances
(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadPrompt mark p m) => MonadPrompt mark p (ExceptT mark1 e m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ExceptT

Methods

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnce mark w m) => MonadWriteOnce mark w (ExceptT mark1 e m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ExceptT

Methods

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

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, Monoid w, MonadAppendOnly mark w m) => MonadAppendOnly mark w (ExceptT mark1 e m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ExceptT

Methods

look :: ExceptT mark1 e m (mark w) Source #

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadReadOnly mark r m) => MonadReadOnly mark r (ExceptT mark1 e m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ExceptT

Methods

ask :: ExceptT mark1 e m (mark r) Source #

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, Monoid w, MonadWriteOnly mark w m) => MonadWriteOnly mark w (ExceptT mark1 e m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ExceptT

Methods

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

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadState mark s m) => MonadState mark s (ExceptT mark1 e m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ExceptT

Methods

get :: ExceptT mark1 e m (mark s) Source #

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

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadExcept mark e m) => MonadExcept mark e (ExceptT mark1 e1 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ExceptT

Methods

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

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

(Monad m, MonadIdentity mark) => MonadExcept mark e (ExceptT mark e m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ExceptT

Methods

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

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

(Monad m, MonadTrans t2, MonadIdentity mark) => MonadExcept mark e (ComposeT (ExceptT mark e) t2 m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ComposeT

Methods

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

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

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

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

Methods

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

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 Source #

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadHalt mark m) => MonadHalt mark (ExceptT mark1 e m) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ExceptT

Methods

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

(Eq (mark ()), Eq (Context m)) => Eq (Context (ExceptT mark e m)) Source # 
Instance details

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)) Source # 
Instance details

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)) Source # 
Instance details

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)) Source # 
Instance details

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)) Source # 
Instance details

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)) Source # 
Instance details

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) Source # 
Instance details

Defined in Control.FX.Monad.Trans.ExceptT

Methods

(==) :: OutputT (ExceptT mark e) a -> OutputT