Safe Haskell	None
Language	Haskell2010

Control.FX.Data

Contents

Structure Classes
Effect Classes
Concrete Types
Values in Context

Synopsis

class Functor t => IsStack t where
- stackInit :: t a
- stackPush :: a -> t a -> t a
- stackPop :: t a -> Maybe (a, t a)
class (Monad m, MonadIdentity mark, IsStack f) => MonadStack mark f d m where
- push :: Proxy f -> mark d -> m ()
- pop :: Proxy f -> m (mark (Maybe d))
newtype Stack (mark :: * -> *) (f :: * -> *) (d :: *) (a :: *) = Stack {
- unStack :: f d -> Pair (f d) a
}
runStack :: (MonadIdentity mark, IsStack f) => f d -> Stack mark f d a -> Pair (mark (f d)) a
newtype StackT (mark :: * -> *) (f :: * -> *) (d :: *) (m :: * -> *) (a :: *) = StackT {
- unStackT :: f d -> m (Pair (f d) a)
}
runStackT :: (Monad m, MonadIdentity mark) => mark (f d) -> StackT mark f d m a -> m (Pair (mark (f d)) a)
newtype StackTT (mark :: * -> *) (f :: * -> *) (d :: *) (t :: (* -> *) -> * -> *) (m :: * -> *) (a :: *) = StackTT {
- unStackTT :: StackT mark f d (t m) a
}
runStackTT :: (MonadIdentity mark, Monad m, MonadTrans t, IsStack f) => mark (f d) -> StackTT mark f d t m a -> t m (Pair (mark (f d)) a)
data family Input (m :: Type -> Type) :: Type
data family Output (m :: Type -> Type) a :: Type
data family InputT (t :: (Type -> Type) -> Type -> Type) :: Type
data family OutputT (t :: (Type -> Type) -> Type -> Type) a :: Type
data family InputTT (u :: ((Type -> Type) -> Type -> Type) -> (Type -> Type) -> Type -> Type) (m :: Type -> Type) :: Type
data family OutputTT (u :: ((Type -> Type) -> Type -> Type) -> (Type -> Type) -> Type -> Type) a :: Type
data family Context (t :: Type -> Type) :: Type

Structure Classes

class Functor t => IsStack t where Source #

Methods

stackInit :: t a Source #

stackPush :: a -> t a -> t a Source #

stackPop :: t a -> Maybe (a, t a) Source #

Instances

IsStack [] Source #
Instance details Defined in Control.FX.Structure.Stack Methods stackInit :: [a] Source # stackPush :: a -> [a] -> [a] Source # stackPop :: [a] -> Maybe (a, [a]) Source #

Effect Classes

class (Monad m, MonadIdentity mark, IsStack f) => MonadStack mark f d m where Source #

Class representing monads with access to a stack of data with type d and stack functor f. Instances should satisfy the following laws:

(1) push p a >> pop p  ===  return (Just <$> a)

Minimal complete definition

Nothing

Methods

push :: Proxy f -> mark d -> m () Source #

Push a value to the stack

push :: (Monad m1, MonadTrans t1, m ~ t1 m1, MonadStack mark f d m1) => Proxy f -> mark d -> m () Source #

Push a value to the stack

pop :: Proxy f -> m (mark (Maybe d)) Source #

Try to pop a value from the stack

pop :: (Monad m1, MonadTrans t1, m ~ t1 m1, MonadStack mark f d m1) => Proxy f -> m (mark (Maybe d)) Source #

Try to pop a value from the stack

Instances

(Monad m, MonadIdentity mark, MonadStack mark f d m) => MonadStack mark f d (IdentityT m) Source #
Instance details Defined in Control.FX.Monad.Data.Class Methods push :: Proxy f -> mark d -> IdentityT m () Source # pop :: Proxy f -> IdentityT m (mark (Maybe d)) Source #
(Monad m, MonadTrans t, IsStack f, MonadStack mark f d (t m)) => MonadStack mark f d (IdentityTT t m) Source #
Instance details Defined in Control.FX.Monad.Data.Class Methods push :: Proxy f -> mark d -> IdentityTT t m () Source # pop :: Proxy f -> IdentityTT t m (mark (Maybe d)) Source #
(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadStack mark f d m) => MonadStack mark f d (HaltT mark1 m) Source #
Instance details Defined in Control.FX.Monad.Data.Class Methods push :: Proxy f -> mark d -> HaltT mark1 m () Source # pop :: Proxy f -> HaltT mark1 m (mark (Maybe d)) Source #
(Monad m, MonadTrans t, MonadIdentity mark1, MonadStack mark f d (t m), IsStack f) => MonadStack mark f d (HaltTT mark1 t m) Source #
Instance details Defined in Control.FX.Monad.Data.Class Methods push :: Proxy f -> mark d -> HaltTT mark1 t m () Source # pop :: Proxy f -> HaltTT mark1 t m (mark (Maybe d)) Source #
(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadStack mark f d m) => MonadStack mark f d (StateT mark1 s m) Source #
Instance details Defined in Control.FX.Monad.Data.Class Methods push :: Proxy f -> mark d -> StateT mark1 s m () Source # pop :: Proxy f -> StateT mark1 s m (mark (Maybe d)) Source #
(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadStack mark f d m) => MonadStack mark f d (WriteOnceT mark1 w m) Source #
Instance details Defined in Control.FX.Monad.Data.Class Methods push :: Proxy f -> mark d -> WriteOnceT mark1 w m () Source # pop :: Proxy f -> WriteOnceT mark1 w m (mark (Maybe d)) Source #
(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadStack mark f d m, Monoid w) => MonadStack mark f d (AppendOnlyT mark1 w m) Source #
Instance details Defined in Control.FX.Monad.Data.Class Methods push :: Proxy f -> mark d -> AppendOnlyT mark1 w m () Source # pop :: Proxy f -> AppendOnlyT mark1 w m (mark (Maybe d)) Source #
(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadStack mark f d m, Monoid w) => MonadStack mark f d (WriteOnlyT mark1 w m) Source #
Instance details Defined in Control.FX.Monad.Data.Class Methods push :: Proxy f -> mark d -> WriteOnlyT mark1 w m () Source # pop :: Proxy f -> WriteOnlyT mark1 w m (mark (Maybe d)) Source #
(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadStack mark f d m) => MonadStack mark f d (ReadOnlyT mark1 r m) Source #
Instance details Defined in Control.FX.Monad.Data.Class Methods push :: Proxy f -> mark d -> ReadOnlyT mark1 r m () Source # pop :: Proxy f -> ReadOnlyT mark1 r m (mark (Maybe d)) Source #
(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadStack mark f d m) => MonadStack mark f d (ExceptT mark1 e m) Source #
Instance details Defined in Control.FX.Monad.Data.Class Methods push :: Proxy f -> mark d -> ExceptT mark1 e m () Source # pop :: Proxy f -> ExceptT mark1 e m (mark (Maybe d)) Source #
(Monad m, MonadTrans t1, MonadTrans t2, MonadIdentity mark, ComposableT t1, forall (x :: Type -> Type). Monad x => MonadStack mark f d (t2 x), IsStack f) => MonadStack mark f d (ComposeT t1 t2 m) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods push :: Proxy f -> mark d -> ComposeT t1 t2 m () Source # pop :: Proxy f -> ComposeT t1 t2 m (mark (Maybe d)) Source #
(Monad m, MonadTrans t2, MonadIdentity mark, IsStack f) => MonadStack mark f d (ComposeT (StackT mark f d) t2 m) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods push :: Proxy f -> mark d -> ComposeT (StackT mark f d) t2 m () Source # pop :: Proxy f -> ComposeT (StackT mark f d) t2 m (mark (Maybe d)) Source #
(MonadIdentity mark, IsStack f) => MonadStack mark f d (Stack mark f d) Source #
Instance details Defined in Control.FX.Monad.Data.Stack Methods push :: Proxy f -> mark d -> Stack mark f d () Source # pop :: Proxy f -> Stack mark f d (mark (Maybe d)) Source #
(Monad m, MonadTrans t, MonadIdentity mark1, MonadStack mark f d (t m), IsStack f) => MonadStack mark f d (WriteOnceTT mark1 w t m) Source #
Instance details Defined in Control.FX.Monad.Data.Class Methods push :: Proxy f -> mark d -> WriteOnceTT mark1 w t m () Source # pop :: Proxy f -> WriteOnceTT mark1 w t m (mark (Maybe d)) Source #
(Monad m, MonadTrans t, MonadIdentity mark1, MonadStack mark f d (t m), IsStack f, Monoid w) => MonadStack mark f d (AppendOnlyTT mark1 w t m) Source #
Instance details Defined in Control.FX.Monad.Data.Class Methods push :: Proxy f -> mark d -> AppendOnlyTT mark1 w t m () Source # pop :: Proxy f -> AppendOnlyTT mark1 w t m (mark (Maybe d)) Source #
(Monad m, MonadTrans t, MonadIdentity mark1, MonadStack mark f d (t m), IsStack f) => MonadStack mark f d (ExceptTT mark1 e t m) Source #
Instance details Defined in Control.FX.Monad.Data.Class Methods push :: Proxy f -> mark d -> ExceptTT mark1 e t m () Source # pop :: Proxy f -> ExceptTT mark1 e t m (mark (Maybe d)) Source #
(Monad m, MonadTrans t, MonadIdentity mark1, MonadStack mark f d (t m), IsStack f, Monoid w) => MonadStack mark f d (WriteOnlyTT mark1 w t m) Source #
Instance details Defined in Control.FX.Monad.Data.Class Methods push :: Proxy f -> mark d -> WriteOnlyTT mark1 w t m () Source # pop :: Proxy f -> WriteOnlyTT mark1 w t m (mark (Maybe d)) Source #
(Monad m, MonadTrans t, MonadIdentity mark1, MonadStack mark f d (t m), IsStack f) => MonadStack mark f d (ReadOnlyTT mark1 r t m) Source #
Instance details Defined in Control.FX.Monad.Data.Class Methods push :: Proxy f -> mark d -> ReadOnlyTT mark1 r t m () Source # pop :: Proxy f -> ReadOnlyTT mark1 r t m (mark (Maybe d)) Source #
(Monad m, MonadTrans t, MonadIdentity mark1, MonadStack mark f d (t m), IsStack f) => MonadStack mark f d (StateTT mark1 s t m) Source #
Instance details Defined in Control.FX.Monad.Data.Class Methods push :: Proxy f -> mark d -> StateTT mark1 s t m () Source # pop :: Proxy f -> StateTT mark1 s t m (mark (Maybe d)) Source #
(Monad m, MonadTrans t, MonadIdentity mark1, MonadStack mark f d (t m), IsStack f) => MonadStack mark f d (PromptTT mark1 p t m) Source #
Instance details Defined in Control.FX.Monad.Data.Class Methods push :: Proxy f -> mark d -> PromptTT mark1 p t m () Source # pop :: Proxy f -> PromptTT mark1 p t m (mark (Maybe d)) Source #
(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadStack mark f d m, IsStack f) => MonadStack mark f d (StackT mark1 f1 d1 m) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods push :: Proxy f -> mark d -> StackT mark1 f1 d1 m () Source # pop :: Proxy f -> StackT mark1 f1 d1 m (mark (Maybe d)) Source #
(Monad m, MonadIdentity mark, IsStack f) => MonadStack mark f d (StackT mark f d m) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods push :: Proxy f -> mark d -> StackT mark f d m () Source # pop :: Proxy f -> StackT mark f d m (mark (Maybe d)) Source #
(Monad m, MonadTrans t, MonadTrans v, OverableT v, MonadTransTrans u, MonadIdentity mark, IsStack f, forall (x :: Type -> Type). Monad x => MonadStack mark f d (u t x)) => MonadStack mark f d (OverTT v u t m) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods push :: Proxy f -> mark d -> OverTT v u t m () Source # pop :: Proxy f -> OverTT v u t m (mark (Maybe d)) Source #
(Monad m, MonadTrans t, IsStack f, MonadTransTrans u, MonadIdentity mark) => MonadStack mark f d (OverTT (StackT mark f d) u t m) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods push :: Proxy f -> mark d -> OverTT (StackT mark f d) u t m () Source # pop :: Proxy f -> OverTT (StackT mark f d) u t m (mark (Maybe d)) Source #
(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadStack mark f d (t x), IsStack f) => MonadStack mark f d (StackTT mark1 f1 d1 t m) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT Methods push :: Proxy f -> mark d -> StackTT mark1 f1 d1 t m () Source # pop :: Proxy f -> StackTT mark1 f1 d1 t m (mark (Maybe d)) Source #
(Monad m, MonadTrans t, MonadIdentity mark, IsStack f) => MonadStack mark f d (StackTT mark f d t m) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT Methods push :: Proxy f -> mark d -> StackTT mark f d t m () Source # pop :: Proxy f -> StackTT mark f d t m (mark (Maybe d)) Source #

Concrete Types

Monads

newtype Stack (mark :: * -> *) (f :: * -> *) (d :: *) (a :: *) Source #

Constructors

Stack
Fields unStack :: f d -> Pair (f d) a

Instances

(MonadIdentity mark, IsStack f) => MonadStack mark f d (Stack mark f d) Source #
Instance details Defined in Control.FX.Monad.Data.Stack Methods push :: Proxy f -> mark d -> Stack mark f d () Source # pop :: Proxy f -> Stack mark f d (mark (Maybe d)) Source #
Eq (mark (f d)) => Eq (Input (Stack mark f d)) Source #
Instance details Defined in Control.FX.Monad.Data.Stack Methods (==) :: Input (Stack mark f d) -> Input (Stack mark f d) -> Bool # (/=) :: Input (Stack mark f d) -> Input (Stack mark f d) -> Bool #
Eq (mark (f d)) => Eq (Context (Stack mark f d)) Source #
Instance details Defined in Control.FX.Monad.Data.Stack Methods (==) :: Context (Stack mark f d) -> Context (Stack mark f d) -> Bool # (/=) :: Context (Stack mark f d) -> Context (Stack mark f d) -> Bool #
Show (mark (f d)) => Show (Input (Stack mark f d)) Source #
Instance details Defined in Control.FX.Monad.Data.Stack Methods showsPrec :: Int -> Input (Stack mark f d) -> ShowS # show :: Input (Stack mark f d) -> String # showList :: [Input (Stack mark f d)] -> ShowS #
Show (mark (f d)) => Show (Context (Stack mark f d)) Source #
Instance details Defined in Control.FX.Monad.Data.Stack Methods showsPrec :: Int -> Context (Stack mark f d) -> ShowS # show :: Context (Stack mark f d) -> String # showList :: [Context (Stack mark f d)] -> ShowS #
(Eq (mark (f d)), Eq a) => Eq (Output (Stack mark f d) a) Source #
Instance details Defined in Control.FX.Monad.Data.Stack Methods (==) :: Output (Stack mark f d) a -> Output (Stack mark f d) a -> Bool # (/=) :: Output (Stack mark f d) a -> Output (Stack mark f d) a -> Bool #
(Show (mark (f d)), Show a) => Show (Output (Stack mark f d) a) Source #
Instance details Defined in Control.FX.Monad.Data.Stack Methods showsPrec :: Int -> Output (Stack mark f d) a -> ShowS # show :: Output (Stack mark f d) a -> String # showList :: [Output (Stack mark f d) a] -> ShowS #
MonadIdentity mark => Monad (Stack mark f d) Source #
Instance details Defined in Control.FX.Monad.Data.Stack Methods (>>=) :: Stack mark f d a -> (a -> Stack mark f d b) -> Stack mark f d b # (>>) :: Stack mark f d a -> Stack mark f d b -> Stack mark f d b # return :: a -> Stack mark f d a # fail :: String -> Stack mark f d a #
MonadIdentity mark => Functor (Stack mark f d) Source #
Instance details Defined in Control.FX.Monad.Data.Stack Methods fmap :: (a -> b) -> Stack mark f d a -> Stack mark f d b # (<$) :: a -> Stack mark f d b -> Stack mark f d a #
MonadIdentity mark => Applicative (Stack mark f d) Source #
Instance details Defined in Control.FX.Monad.Data.Stack Methods pure :: a -> Stack mark f d a # (<>) :: Stack mark f d (a -> b) -> Stack mark f d a -> Stack mark f d b # liftA2 :: (a -> b -> c) -> Stack mark f d a -> Stack mark f d b -> Stack mark f d c # (>) :: Stack mark f d a -> Stack mark f d b -> Stack mark f d b # (<*) :: Stack mark f d a -> Stack mark f d b -> Stack mark f d a #
MonadIdentity mark => RunMonad (Stack mark f d) Source #
Instance details Defined in Control.FX.Monad.Data.Stack Associated Types data Input (Stack mark f d) :: Type # data Output (Stack mark f d) a :: Type # Methods run :: Input (Stack mark f d) -> Stack mark f d a -> Output (Stack mark f d) a #
(Eq (f d), MonadIdentity mark) => EqIn (Stack mark f d) Source #
Instance details Defined in Control.FX.Monad.Data.Stack Associated Types data Context (Stack mark f d) :: Type # Methods eqIn :: Eq a => Context (Stack mark f d) -> Stack mark f d a -> Stack mark f d a -> Bool #
(Typeable f, Typeable d, Typeable a, Typeable mark) => Show (Stack mark f d a) Source #
Instance details Defined in Control.FX.Monad.Data.Stack Methods showsPrec :: Int -> Stack mark f d a -> ShowS # show :: Stack mark f d a -> String # showList :: [Stack mark f d a] -> ShowS #
data Output (Stack mark f d) a Source #
Instance details Defined in Control.FX.Monad.Data.Stack data Output (Stack mark f d) a = StackOut { unStackOut :: Pair (mark (f d)) a }
data Input (Stack mark f d) Source #
Instance details Defined in Control.FX.Monad.Data.Stack data Input (Stack mark f d) = StackIn { unStackIn :: mark (f d) }
data Context (Stack mark f d) Source #
Instance details Defined in Control.FX.Monad.Data.Stack data Context (Stack mark f d) = StackCtx { unStackCtx :: mark (f d) }

runStack :: (MonadIdentity mark, IsStack f) => f d -> Stack mark f d a -> Pair (mark (f d)) a Source #

Transformers

newtype StackT (mark :: * -> *) (f :: * -> *) (d :: *) (m :: * -> *) (a :: *) Source #

Constructors

StackT
Fields unStackT :: f d -> m (Pair (f d) a)

Instances

(Monad m, MonadTrans t2, MonadIdentity mark, IsStack f) => MonadStack mark f d (ComposeT (StackT mark f d) t2 m) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods push :: Proxy f -> mark d -> ComposeT (StackT mark f d) t2 m () Source # pop :: Proxy f -> ComposeT (StackT mark f d) t2 m (mark (Maybe d)) Source #
(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadStack mark f d m, IsStack f) => MonadStack mark f d (StackT mark1 f1 d1 m) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods push :: Proxy f -> mark d -> StackT mark1 f1 d1 m () Source # pop :: Proxy f -> StackT mark1 f1 d1 m (mark (Maybe d)) Source #
(Monad m, MonadIdentity mark, IsStack f) => MonadStack mark f d (StackT mark f d m) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods push :: Proxy f -> mark d -> StackT mark f d m () Source # pop :: Proxy f -> StackT mark f d m (mark (Maybe d)) Source #
(Monad m, MonadTrans t, IsStack f, MonadTransTrans u, MonadIdentity mark) => MonadStack mark f d (OverTT (StackT mark f d) u t m) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods push :: Proxy f -> mark d -> OverTT (StackT mark f d) u t m () Source # pop :: Proxy f -> OverTT (StackT mark f d) u t m (mark (Maybe d)) Source #
(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadExcept mark e m) => MonadExcept mark e (StackT mark1 f d m) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods throw :: mark e -> StackT mark1 f d m a # catch :: StackT mark1 f d m a -> (mark e -> StackT mark1 f d m a) -> StackT mark1 f d m a #
(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadState mark s m) => MonadState mark s (StackT mark1 f d1 m) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods get :: StackT mark1 f d1 m (mark s) # put :: mark s -> StackT mark1 f d1 m () #
(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnly mark w m, Monoid w) => MonadWriteOnly mark w (StackT mark1 f d m) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods tell :: mark w -> StackT mark1 f d m () # draft :: StackT mark1 f d m a -> StackT mark1 f d m (Pair (mark w) a) #
(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadReadOnly mark r m) => MonadReadOnly mark r (StackT mark1 f d m) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods ask :: StackT mark1 f d m (mark r) # local :: (mark r -> mark r) -> StackT mark1 f d m a -> StackT mark1 f d m a #
(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadAppendOnly mark w m, Monoid w) => MonadAppendOnly mark w (StackT mark1 f d m) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods look :: StackT mark1 f d m (mark w) # jot :: mark w -> StackT mark1 f d m () #
(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadWriteOnce mark w m) => MonadWriteOnce mark w (StackT mark1 f d m) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods etch :: mark w -> StackT mark1 f d m Bool # press :: StackT mark1 f d m (Maybe (mark w)) #
(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadPrompt mark p m) => MonadPrompt mark p (StackT mark1 f d m) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods prompt :: mark (p a) -> StackT mark1 f d m (mark a) #
(Monad m, MonadIdentity mark1, MonadIdentity mark, MonadHalt mark m) => MonadHalt mark (StackT mark1 f d m) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods halt :: mark () -> StackT mark1 f d m a #
Eq (mark (f d)) => Eq (InputT (StackT mark f d)) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods (==) :: InputT (StackT mark f d) -> InputT (StackT mark f d) -> Bool # (/=) :: InputT (StackT mark f d) -> InputT (StackT mark f d) -> Bool #
(Eq (mark (f d)), Eq (Context m)) => Eq (Context (StackT mark f d m)) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods (==) :: Context (StackT mark f d m) -> Context (StackT mark f d m) -> Bool # (/=) :: Context (StackT mark f d m) -> Context (StackT mark f d m) -> Bool #
Show (mark (f d)) => Show (InputT (StackT mark f d)) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods showsPrec :: Int -> InputT (StackT mark f d) -> ShowS # show :: InputT (StackT mark f d) -> String # showList :: [InputT (StackT mark f d)] -> ShowS #
(Show (mark (f d)), Show (Context m)) => Show (Context (StackT mark f d m)) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods showsPrec :: Int -> Context (StackT mark f d m) -> ShowS # show :: Context (StackT mark f d m) -> String # showList :: [Context (StackT mark f d m)] -> ShowS #
(Eq (mark (f d)), Eq a) => Eq (OutputT (StackT mark f d) a) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods (==) :: OutputT (StackT mark f d) a -> OutputT (StackT mark f d) a -> Bool # (/=) :: OutputT (StackT mark f d) a -> OutputT (StackT mark f d) a -> Bool #
(Show (mark (f d)), Show a) => Show (OutputT (StackT mark f d) a) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods showsPrec :: Int -> OutputT (StackT mark f d) a -> ShowS # show :: OutputT (StackT mark f d) a -> String # showList :: [OutputT (StackT mark f d) a] -> ShowS #
MonadIdentity mark => OverableT (StackT mark f d) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Associated Types data OverTT (StackT mark f d) u t m a :: Type # Methods toOverTT :: StackT mark f d (u t m) a -> OverTT (StackT mark f d) u t m a # unOverTT :: OverTT (StackT mark f d) u t m a -> StackT mark f d (u t m) a #
MonadIdentity mark => ComposableT (StackT mark f d) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Associated Types data ComposeT (StackT mark f d) t2 m a :: Type # Methods toComposeT :: StackT mark f d (t2 m) a -> ComposeT (StackT mark f d) t2 m a # unComposeT :: ComposeT (StackT mark f d) t2 m a -> StackT mark f d (t2 m) a #
MonadIdentity mark => MonadFunctor (StackT mark f d) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods hoist :: (Monad m, Monad n) => (forall u. m u -> n u) -> StackT mark f d m a -> StackT mark f d n a #
MonadIdentity mark => MonadTrans (StackT mark f d) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods lift :: Monad m => m a -> StackT mark f d m a #
MonadIdentity mark => RunMonadTrans (StackT mark f d) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Associated Types data InputT (StackT mark f d) :: Type # data OutputT (StackT mark f d) a :: Type # Methods runT :: Monad m => InputT (StackT mark f d) -> StackT mark f d m a -> m (OutputT (StackT mark f d) a) #
MonadIdentity mark => LiftCatch (StackT mark f d) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods liftCatch :: Monad m => Catch e m (OutputT (StackT mark f d) a) -> Catch e (StackT mark f d m) a #
MonadIdentity mark => LiftDraft (StackT mark f d) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods liftDraft :: (Monad m, Monoid w) => Draft w m (OutputT (StackT mark f d) a) -> Draft w (StackT mark f d m) a #
MonadIdentity mark => LiftLocal (StackT mark f d) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods liftLocal :: Monad m => Local r m (OutputT (StackT mark f d) a) -> Local r (StackT mark f d m) a #
(Monad m, MonadIdentity mark) => Monad (StackT mark f d m) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods (>>=) :: StackT mark f d m a -> (a -> StackT mark f d m b) -> StackT mark f d m b # (>>) :: StackT mark f d m a -> StackT mark f d m b -> StackT mark f d m b # return :: a -> StackT mark f d m a # fail :: String -> StackT mark f d m a #
(Monad m, MonadIdentity mark) => Functor (StackT mark f d m) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods fmap :: (a -> b) -> StackT mark f d m a -> StackT mark f d m b # (<$) :: a -> StackT mark f d m b -> StackT mark f d m a #
(Monad m, MonadIdentity mark) => Applicative (StackT mark f d m) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods pure :: a -> StackT mark f d m a # (<>) :: StackT mark f d m (a -> b) -> StackT mark f d m a -> StackT mark f d m b # liftA2 :: (a -> b -> c) -> StackT mark f d m a -> StackT mark f d m b -> StackT mark f d m c # (>) :: StackT mark f d m a -> StackT mark f d m b -> StackT mark f d m b # (<*) :: StackT mark f d m a -> StackT mark f d m b -> StackT mark f d m a #
(EqIn m, MonadIdentity mark, Eq (f d)) => EqIn (StackT mark f d m) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Associated Types data Context (StackT mark f d m) :: Type # Methods eqIn :: Eq a => Context (StackT mark f d m) -> StackT mark f d m a -> StackT mark f d m a -> Bool #
(Typeable f, Typeable d, Typeable m, Typeable a, Typeable mark) => Show (StackT mark f d m a) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods showsPrec :: Int -> StackT mark f d m a -> ShowS # show :: StackT mark f d m a -> String # showList :: [StackT mark f d m a] -> ShowS #
newtype OverTT (StackT mark f d) u t m a Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT newtype OverTT (StackT mark f d) u t m a = OverTT_StackT { unOverTT_StackT :: StackT mark f d (u t m) a }
newtype ComposeT (StackT mark f d) t2 m a Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT newtype ComposeT (StackT mark f d) t2 m a = ComposeT_StackT { unComposeT_StackT :: StackT mark f d (t2 m) a }
newtype OutputT (StackT mark f d) a Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT newtype OutputT (StackT mark f d) a = StackTOut { unStackTOut :: Pair (mark (f d)) a }
newtype InputT (StackT mark f d) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT newtype InputT (StackT mark f d) = StackTIn { unStackTIn :: mark (f d) }
newtype Context (StackT mark f d m) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT newtype Context (StackT mark f d m) = StackTCtx { unStackTCtx :: (mark (f d), Context m) }

runStackT :: (Monad m, MonadIdentity mark) => mark (f d) -> StackT mark f d m a -> m (Pair (mark (f d)) a) Source #

Transformer Transformers

newtype StackTT (mark :: * -> *) (f :: * -> *) (d :: *) (t :: (* -> *) -> * -> *) (m :: * -> *) (a :: *) Source #

Constructors

StackTT
Fields unStackTT :: StackT mark f d (t m) a

Instances

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadStack mark f d (t x), IsStack f) => MonadStack mark f d (StackTT mark1 f1 d1 t m) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT Methods push :: Proxy f -> mark d -> StackTT mark1 f1 d1 t m () Source # pop :: Proxy f -> StackTT mark1 f1 d1 t m (mark (Maybe d)) Source #
(Monad m, MonadTrans t, MonadIdentity mark, IsStack f) => MonadStack mark f d (StackTT mark f d t m) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT Methods push :: Proxy f -> mark d -> StackTT mark f d t m () Source # pop :: Proxy f -> StackTT mark f d t m (mark (Maybe d)) Source #
(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadExcept mark e (t x), IsStack f) => MonadExcept mark e (StackTT mark1 f d t m) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT Methods throw :: mark e -> StackTT mark1 f d t m a # catch :: StackTT mark1 f d t m a -> (mark e -> StackTT mark1 f d t m a) -> StackTT mark1 f d t m a #
(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadState mark s (t x), IsStack f) => MonadState mark s (StackTT mark1 f d1 t m) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT Methods get :: StackTT mark1 f d1 t m (mark s) # put :: mark s -> StackTT mark1 f d1 t m () #
(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Monoid w, forall (x :: Type -> Type). Monad x => MonadWriteOnly mark w (t x), IsStack f) => MonadWriteOnly mark w (StackTT mark1 f d t m) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT Methods tell :: mark w -> StackTT mark1 f d t m () # draft :: StackTT mark1 f d t m a -> StackTT mark1 f d t m (Pair (mark w) a) #
(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadReadOnly mark r (t x), IsStack f) => MonadReadOnly mark r (StackTT mark1 f d t m) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT Methods ask :: StackTT mark1 f d t m (mark r) # local :: (mark r -> mark r) -> StackTT mark1 f d t m a -> StackTT mark1 f d t m a #
(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, Monoid w, forall (x :: Type -> Type). Monad x => MonadAppendOnly mark w (t x), IsStack f) => MonadAppendOnly mark w (StackTT mark1 f d t m) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT Methods look :: StackTT mark1 f d t m (mark w) # jot :: mark w -> StackTT mark1 f d t m () #
(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadWriteOnce mark w (t x), IsStack f) => MonadWriteOnce mark w (StackTT mark1 f d t m) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT Methods etch :: mark w -> StackTT mark1 f d t m Bool # press :: StackTT mark1 f d t m (Maybe (mark w)) #
(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, forall (x :: Type -> Type). Monad x => MonadPrompt mark p (t x), IsStack f) => MonadPrompt mark p (StackTT mark1 f d t m) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT Methods prompt :: mark (p a) -> StackTT mark1 f d t m (mark a) #
(Monad m, MonadTrans t, MonadIdentity mark1, MonadIdentity mark, forall (x :: Type -> Type). Monad x => MonadHalt mark (t x), IsStack f) => MonadHalt mark (StackTT mark1 f d t m) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT Methods halt :: mark () -> StackTT mark1 f d t m a #
(Eq (mark (f d)), Eq (Context (t m))) => Eq (Context (StackTT mark f d t m)) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT Methods (==) :: Context (StackTT mark f d t m) -> Context (StackTT mark f d t m) -> Bool # (/=) :: Context (StackTT mark f d t m) -> Context (StackTT mark f d t m) -> Bool #
(Show (mark (f d)), Show (Context (t m))) => Show (Context (StackTT mark f d t m)) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT Methods showsPrec :: Int -> Context (StackTT mark f d t m) -> ShowS # show :: Context (StackTT mark f d t m) -> String # showList :: [Context (StackTT mark f d t m)] -> ShowS #
(Eq (mark (f d)), Eq a) => Eq (OutputTT (StackTT mark f d) a) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT Methods (==) :: OutputTT (StackTT mark f d) a -> OutputTT (StackTT mark f d) a -> Bool # (/=) :: OutputTT (StackTT mark f d) a -> OutputTT (StackTT mark f d) a -> Bool #
Eq (mark (f d)) => Eq (InputTT (StackTT mark f d) m) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT Methods (==) :: InputTT (StackTT mark f d) m -> InputTT (StackTT mark f d) m -> Bool # (/=) :: InputTT (StackTT mark f d) m -> InputTT (StackTT mark f d) m -> Bool #
(Show (mark (f d)), Show a) => Show (OutputTT (StackTT mark f d) a) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT Methods showsPrec :: Int -> OutputTT (StackTT mark f d) a -> ShowS # show :: OutputTT (StackTT mark f d) a -> String # showList :: [OutputTT (StackTT mark f d) a] -> ShowS #
Show (mark (f d)) => Show (InputTT (StackTT mark f d) m) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT Methods showsPrec :: Int -> InputTT (StackTT mark f d) m -> ShowS # show :: InputTT (StackTT mark f d) m -> String # showList :: [InputTT (StackTT mark f d) m] -> ShowS #
MonadIdentity mark => MonadTransTrans (StackTT mark f d) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT Methods liftT :: (Monad m, MonadTrans t) => t m a -> StackTT mark f d t m a #
(MonadIdentity mark, IsStack f) => RunMonadTransTrans (StackTT mark f d) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT Associated Types data InputTT (StackTT mark f d) m :: Type # data OutputTT (StackTT mark f d) a :: Type # Methods runTT :: (Monad m, MonadTrans t) => InputTT (StackTT mark f d) m -> StackTT mark f d t m a -> t m (OutputTT (StackTT mark f d) a) #
(MonadIdentity mark, IsStack f) => LiftCatchT (StackTT mark f d) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT Methods liftCatchT :: (Monad m, MonadTrans t) => (forall x. Catch e (t m) (OutputTT (StackTT mark f d) x)) -> forall x. Catch e (StackTT mark f d t m) x #
(MonadIdentity mark, IsStack f) => LiftDraftT (StackTT mark f d) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT Methods liftDraftT :: (Monad m, MonadTrans t, Monoid w) => (forall x. Draft w (t m) (OutputTT (StackTT mark f d) x)) -> forall x. Draft w (StackTT mark f d t m) x #
(MonadIdentity mark, IsStack f) => LiftLocalT (StackTT mark f d) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT Methods liftLocalT :: (Monad m, MonadTrans t) => (forall x. Local r (t m) (OutputTT (StackTT mark f d) x)) -> forall x. Local r (StackTT mark f d t m) x #
(MonadFunctor t, MonadIdentity mark) => MonadFunctor (StackTT mark f d t) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT Methods hoist :: (Monad m, Monad n) => (forall u. m u -> n u) -> StackTT mark f d t m a -> StackTT mark f d t n a #
(MonadTrans t, MonadIdentity mark) => MonadTrans (StackTT mark f d t) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT Methods lift :: Monad m => m a -> StackTT mark f d t m a #
(MonadIdentity mark, Monad (t m)) => Monad (StackTT mark f d t m) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT Methods (>>=) :: StackTT mark f d t m a -> (a -> StackTT mark f d t m b) -> StackTT mark f d t m b # (>>) :: StackTT mark f d t m a -> StackTT mark f d t m b -> StackTT mark f d t m b # return :: a -> StackTT mark f d t m a # fail :: String -> StackTT mark f d t m a #
(MonadIdentity mark, Monad (t m)) => Functor (StackTT mark f d t m) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT Methods fmap :: (a -> b) -> StackTT mark f d t m a -> StackTT mark f d t m b # (<$) :: a -> StackTT mark f d t m b -> StackTT mark f d t m a #
(MonadIdentity mark, Monad (t m)) => Applicative (StackTT mark f d t m) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT Methods pure :: a -> StackTT mark f d t m a # (<>) :: StackTT mark f d t m (a -> b) -> StackTT mark f d t m a -> StackTT mark f d t m b # liftA2 :: (a -> b -> c) -> StackTT mark f d t m a -> StackTT mark f d t m b -> StackTT mark f d t m c # (>) :: StackTT mark f d t m a -> StackTT mark f d t m b -> StackTT mark f d t m b # (<*) :: StackTT mark f d t m a -> StackTT mark f d t m b -> StackTT mark f d t m a #
(Monad m, MonadTrans t, MonadIdentity mark, Eq (f d), EqIn (t m), IsStack f) => EqIn (StackTT mark f d t m) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT Associated Types data Context (StackTT mark f d t m) :: Type # Methods eqIn :: Eq a => Context (StackTT mark f d t m) -> StackTT mark f d t m a -> StackTT mark f d t m a -> Bool #
(Typeable t, Typeable f, Typeable m, Typeable mark, Typeable d, Typeable a) => Show (StackTT mark f d t m a) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT Methods showsPrec :: Int -> StackTT mark f d t m a -> ShowS # show :: StackTT mark f d t m a -> String # showList :: [StackTT mark f d t m a] -> ShowS #
newtype OutputTT (StackTT mark f d) a Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT newtype OutputTT (StackTT mark f d) a = StackTTOut { unStackTTOut :: Pair (mark (f d)) a }
newtype InputTT (StackTT mark f d) m Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT newtype InputTT (StackTT mark f d) m = StackTTIn { unStackTTIn :: mark (f d) }
newtype Context (StackTT mark f d t m) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT newtype Context (StackTT mark f d t m) = StackTTCtx { unStackTTCtx :: (mark (f d), Context (t m)) }

runStackTT :: (MonadIdentity mark, Monad m, MonadTrans t, IsStack f) => mark (f d) -> StackTT mark f d t m a -> t m (Pair (mark (f d)) a) Source #

Values in Context

Monads

data family Input (m :: Type -> Type) :: Type #

Instances

Eq (Input Maybe)
Instance details Defined in Control.FX.Monad.Class Methods (==) :: Input Maybe -> Input Maybe -> Bool # (/=) :: Input Maybe -> Input Maybe -> Bool #
Eq (mark ()) => Eq (Input (WriteOnly mark w))
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 #
Eq (mark ()) => Eq (Input (WriteOnce mark w))
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 #
Eq (mark s) => Eq (Input (State mark s))
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 #
Eq (mark r) => Eq (Input (ReadOnly mark r))
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 #
Eq (Input Identity)
Instance details Defined in Control.FX.Monad.Identity Methods (==) :: Input Identity -> Input Identity -> Bool # (/=) :: Input Identity -> Input Identity -> Bool #
Eq (mark ()) => Eq (Input (Halt mark))
Instance details Defined in Control.FX.Monad.Halt Methods (==) :: Input (Halt mark) -> Input (Halt mark) -> Bool # (/=) :: Input (Halt mark) -> Input (Halt mark) -> Bool #
Eq (mark ()) => Eq (Input (Except mark e))
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 #
(Eq (Input m1), Eq (Input m2)) => Eq (Input (Compose m1 m2))
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 #
Eq (mark ()) => Eq (Input (AppendOnly mark w))
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 #
Eq (mark (f d)) => Eq (Input (Stack mark f d)) Source #
Instance details Defined in Control.FX.Monad.Data.Stack Methods (==) :: Input (Stack mark f d) -> Input (Stack mark f d) -> Bool # (/=) :: Input (Stack mark f d) -> Input (Stack mark f d) -> Bool #
Show (Input Maybe)
Instance details Defined in Control.FX.Monad.Class Methods showsPrec :: Int -> Input Maybe -> ShowS # show :: Input Maybe -> String # showList :: [Input Maybe] -> ShowS #
Show (mark ()) => Show (Input (WriteOnly mark w))
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 #
Show (mark ()) => Show (Input (WriteOnce mark w))
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 #
Show (mark s) => Show (Input (State mark s))
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 #
Show (mark r) => Show (Input (ReadOnly mark r))
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 #
Show (Input Identity)
Instance details Defined in Control.FX.Monad.Identity Methods showsPrec :: Int -> Input Identity -> ShowS # show :: Input Identity -> String # showList :: [Input Identity] -> ShowS #
Show (mark ()) => Show (Input (Halt mark))
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 #
Show (mark ()) => Show (Input (Except mark e))
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 #
(Show (Input m1), Show (Input m2)) => Show (Input (Compose m1 m2))
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 #
Show (mark ()) => Show (Input (AppendOnly mark w))
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 #
Show (mark (f d)) => Show (Input (Stack mark f d)) Source #
Instance details Defined in Control.FX.Monad.Data.Stack Methods showsPrec :: Int -> Input (Stack mark f d) -> ShowS # show :: Input (Stack mark f d) -> String # showList :: [Input (Stack mark f d)] -> ShowS #
data Input Maybe
Instance details Defined in Control.FX.Monad.Class data Input Maybe = MaybeIn { unMaybeIn :: () }
data Input Identity
Instance details Defined in Control.FX.Monad.Identity data Input Identity = IdentityIn { unIdentityIn :: () }
data Input (Halt mark)
Instance details Defined in Control.FX.Monad.Halt data Input (Halt mark) = HaltIn { unHaltIn :: mark () }
newtype Input (WriteOnly mark w)
Instance details Defined in Control.FX.Monad.WriteOnly newtype Input (WriteOnly mark w) = WriteOnlyIn { unWriteOnlyIn :: mark () }
newtype Input (WriteOnce mark w)
Instance details Defined in Control.FX.Monad.WriteOnce newtype Input (WriteOnce mark w) = WriteOnceIn { unWriteOnceIn :: mark () }
data Input (State mark s)
Instance details Defined in Control.FX.Monad.State data Input (State mark s) = StateIn { unStateIn :: mark s }
newtype Input (ReadOnly mark r)
Instance details Defined in Control.FX.Monad.ReadOnly newtype Input (ReadOnly mark r) = ReadOnlyIn { unReadOnlyIn :: mark r }
newtype Input (Except mark e)
Instance details Defined in Control.FX.Monad.Except newtype Input (Except mark e) = ExceptIn { unExceptIn :: mark () }
newtype Input (Compose m1 m2)
Instance details Defined in Control.FX.Monad.Compose newtype Input (Compose m1 m2) = ComposeIn { unComposeIn :: (Input m1, Input m2) }
newtype Input (AppendOnly mark w)
Instance details Defined in Control.FX.Monad.AppendOnly newtype Input (AppendOnly mark w) = AppendOnlyIn { unAppendOnlyIn :: mark () }
data Input (Stack mark f d) Source #
Instance details Defined in Control.FX.Monad.Data.Stack data Input (Stack mark f d) = StackIn { unStackIn :: mark (f d) }

data family Output (m :: Type -> Type) a :: Type #

Instances

Eq a => Eq (Output Maybe a)
Instance details Defined in Control.FX.Monad.Class Methods (==) :: Output Maybe a -> Output Maybe a -> Bool # (/=) :: Output Maybe a -> Output Maybe a -> Bool #
(Eq (mark w), Eq a) => Eq (Output (WriteOnly mark w) a)
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 #
(Eq (mark (Maybe w)), Eq a) => Eq (Output (WriteOnce mark w) a)
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 #
(Eq (mark s), Eq a) => Eq (Output (State mark s) a)
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 #
Eq (mark a) => Eq (Output (ReadOnly mark r) a)
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 #
Eq a => Eq (Output Identity a)
Instance details Defined in Control.FX.Monad.Identity Methods (==) :: Output Identity a -> Output Identity a -> Bool # (/=) :: Output Identity a -> Output Identity a -> Bool #
Eq a => Eq (Output (Halt mark) a)
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 e, Eq a) => Eq (Output (Except mark e) a)
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 #
(Eq (Output m1 (Output m2 a)), Eq (Output m2 a)) => Eq (Output (Compose m1 m2) a)
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 #
(Eq (mark w), Eq a) => Eq (Output (AppendOnly mark w) a)
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 #
(Eq (mark (f d)), Eq a) => Eq (Output (Stack mark f d) a) Source #
Instance details Defined in Control.FX.Monad.Data.Stack Methods (==) :: Output (Stack mark f d) a -> Output (Stack mark f d) a -> Bool # (/=) :: Output (Stack mark f d) a -> Output (Stack mark f d) a -> Bool #
Show a => Show (Output Maybe a)
Instance details Defined in Control.FX.Monad.Class Methods showsPrec :: Int -> Output Maybe a -> ShowS # show :: Output Maybe a -> String # showList :: [Output Maybe a] -> ShowS #
(Show (mark w), Show a) => Show (Output (WriteOnly mark w) a)
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 #
(Show (mark (Maybe w)), Show a) => Show (Output (WriteOnce mark w) a)
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 #
(Show (mark s), Show a) => Show (Output (State mark s) a)
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 #
Show (mark a) => Show (Output (ReadOnly mark r) a)
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 #
Show a => Show (Output Identity a)
Instance details Defined in Control.FX.Monad.Identity Methods showsPrec :: Int -> Output Identity a -> ShowS # show :: Output Identity a -> String # showList :: [Output Identity a] -> ShowS #
Show a => Show (Output (Halt mark) a)
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 e, Show a) => Show (Output (Except mark e) a)
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 #
(Show (Output m1 (Output m2 a)), Show (Output m2 a)) => Show (Output (Compose m1 m2) a)
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 #
(Show (mark w), Show a) => Show (Output (AppendOnly mark w) a)
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 #
(Show (mark (f d)), Show a) => Show (Output (Stack mark f d) a) Source #
Instance details Defined in Control.FX.Monad.Data.Stack Methods showsPrec :: Int -> Output (Stack mark f d) a -> ShowS # show :: Output (Stack mark f d) a -> String # showList :: [Output (Stack mark f d) a] -> ShowS #
data Output Maybe a
Instance details Defined in Control.FX.Monad.Class data Output Maybe a = MaybeOut { unMaybeOut :: Maybe a }
data Output Identity a
Instance details Defined in Control.FX.Monad.Identity data Output Identity a = IdentityOut { unIdentityOut :: Identity a }
data Output (Halt mark) a
Instance details Defined in Control.FX.Monad.Halt data Output (Halt mark) a = HaltOut { unHaltOut :: Halt mark a }
newtype Output (WriteOnly mark w) a
Instance details Defined in Control.FX.Monad.WriteOnly newtype Output (WriteOnly mark w) a = WriteOnlyOut { unWriteOnlyOut :: Pair (mark w) a }
newtype Output (WriteOnce mark w) a
Instance details Defined in Control.FX.Monad.WriteOnce newtype Output (WriteOnce mark w) a = WriteOnceOut { unWriteOnceOut :: Pair (mark (Maybe w)) a }
data Output (State mark s) a
Instance details Defined in Control.FX.Monad.State data Output (State mark s) a = StateOut { unStateOut :: Pair (mark s) a }
newtype Output (ReadOnly mark r) a
Instance details Defined in Control.FX.Monad.ReadOnly newtype Output (ReadOnly mark r) a = ReadOnlyOut { unReadOnlyOut :: mark a }
newtype Output (Except mark e) a
Instance details Defined in Control.FX.Monad.Except newtype Output (Except mark e) a = ExceptOut { unExceptOut :: Except mark e a }
newtype Output (Compose m1 m2) a
Instance details Defined in Control.FX.Monad.Compose newtype Output (Compose m1 m2) a = ComposeOut { unComposeOut :: Compose (Output m1) (Output m2) a }
newtype Output (AppendOnly mark w) a
Instance details Defined in Control.FX.Monad.AppendOnly newtype Output (AppendOnly mark w) a = AppendOnlyOut { unAppendOnlyOut :: Pair (mark w) a }
data Output (Stack mark f d) a Source #
Instance details Defined in Control.FX.Monad.Data.Stack data Output (Stack mark f d) a = StackOut { unStackOut :: Pair (mark (f d)) a }

Transformers

data family InputT (t :: (Type -> Type) -> Type -> Type) :: Type #

Instances

(Eq (InputT t1), Eq (InputT t2)) => Eq (InputT (ComposeT t1 t2))
Instance details Defined in Control.FX.Monad.Trans.ComposeT Methods (==) :: InputT (ComposeT t1 t2) -> InputT (ComposeT t1 t2) -> Bool # (/=) :: InputT (ComposeT t1 t2) -> InputT (ComposeT t1 t2) -> Bool #
Eq (mark ()) => Eq (InputT (AppendOnlyT mark w))
Instance details Defined in Control.FX.Monad.Trans.AppendOnlyT Methods (==) :: InputT (AppendOnlyT mark w) -> InputT (AppendOnlyT mark w) -> Bool # (/=) :: InputT (AppendOnlyT mark w) -> InputT (AppendOnlyT mark w) -> Bool #
Eq (mark ()) => Eq (InputT (ExceptT mark e))
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 #
Eq (mark ()) => Eq (InputT (HaltT mark))
Instance details Defined in Control.FX.Monad.Trans.HaltT Methods (==) :: InputT (HaltT mark) -> InputT (HaltT mark) -> Bool # (/=) :: InputT (HaltT mark) -> InputT (HaltT mark) -> Bool #
Eq (InputT IdentityT)
Instance details Defined in Control.FX.Monad.Trans.IdentityT Methods (==) :: InputT IdentityT -> InputT IdentityT -> Bool # (/=) :: InputT IdentityT -> InputT IdentityT -> Bool #
Eq (mark r) => Eq (InputT (ReadOnlyT mark r))
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 #
Eq (mark s) => Eq (InputT (StateT mark s))
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 #
Eq (mark ()) => Eq (InputT (WriteOnceT mark w))
Instance details Defined in Control.FX.Monad.Trans.WriteOnceT Methods (==) :: InputT (WriteOnceT mark w) -> InputT (WriteOnceT mark w) -> Bool # (/=) :: InputT (WriteOnceT mark w) -> InputT (WriteOnceT mark w) -> Bool #
Eq (mark ()) => Eq (InputT (WriteOnlyT mark w))
Instance details Defined in Control.FX.Monad.Trans.WriteOnlyT Methods (==) :: InputT (WriteOnlyT mark w) -> InputT (WriteOnlyT mark w) -> Bool # (/=) :: InputT (WriteOnlyT mark w) -> InputT (WriteOnlyT mark w) -> Bool #
Eq (mark (f d)) => Eq (InputT (StackT mark f d)) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods (==) :: InputT (StackT mark f d) -> InputT (StackT mark f d) -> Bool # (/=) :: InputT (StackT mark f d) -> InputT (StackT mark f d) -> Bool #
(Show (InputT t1), Show (InputT t2)) => Show (InputT (ComposeT t1 t2))
Instance details Defined in Control.FX.Monad.Trans.ComposeT Methods showsPrec :: Int -> InputT (ComposeT t1 t2) -> ShowS # show :: InputT (ComposeT t1 t2) -> String # showList :: [InputT (ComposeT t1 t2)] -> ShowS #
Show (mark ()) => Show (InputT (AppendOnlyT mark w))
Instance details Defined in Control.FX.Monad.Trans.AppendOnlyT Methods showsPrec :: Int -> InputT (AppendOnlyT mark w) -> ShowS # show :: InputT (AppendOnlyT mark w) -> String # showList :: [InputT (AppendOnlyT mark w)] -> ShowS #
Show (mark ()) => Show (InputT (ExceptT mark e))
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 #
Show (mark ()) => Show (InputT (HaltT mark))
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 #
Show (InputT IdentityT)
Instance details Defined in Control.FX.Monad.Trans.IdentityT Methods showsPrec :: Int -> InputT IdentityT -> ShowS # show :: InputT IdentityT -> String # showList :: [InputT IdentityT] -> ShowS #
Show (mark r) => Show (InputT (ReadOnlyT mark r))
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 #
Show (mark s) => Show (InputT (StateT mark s))
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 #
Show (mark ()) => Show (InputT (WriteOnceT mark w))
Instance details Defined in Control.FX.Monad.Trans.WriteOnceT Methods showsPrec :: Int -> InputT (WriteOnceT mark w) -> ShowS # show :: InputT (WriteOnceT mark w) -> String # showList :: [InputT (WriteOnceT mark w)] -> ShowS #
Show (mark ()) => Show (InputT (WriteOnlyT mark w))
Instance details Defined in Control.FX.Monad.Trans.WriteOnlyT Methods showsPrec :: Int -> InputT (WriteOnlyT mark w) -> ShowS # show :: InputT (WriteOnlyT mark w) -> String # showList :: [InputT (WriteOnlyT mark w)] -> ShowS #
Show (mark (f d)) => Show (InputT (StackT mark f d)) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods showsPrec :: Int -> InputT (StackT mark f d) -> ShowS # show :: InputT (StackT mark f d) -> String # showList :: [InputT (StackT mark f d)] -> ShowS #
data InputT IdentityT
Instance details Defined in Control.FX.Monad.Trans.IdentityT data InputT IdentityT = IdentityTIn { unIdentityTIn :: () }
newtype InputT (HaltT mark)
Instance details Defined in Control.FX.Monad.Trans.HaltT newtype InputT (HaltT mark) = HaltTIn { unHaltTIn :: mark () }
newtype InputT (ComposeT t1 t2)
Instance details Defined in Control.FX.Monad.Trans.ComposeT newtype InputT (ComposeT t1 t2) = ComposeTIn { unComposeTIn :: (InputT t1, InputT t2) }
newtype InputT (AppendOnlyT mark w)
Instance details Defined in Control.FX.Monad.Trans.AppendOnlyT newtype InputT (AppendOnlyT mark w) = AppendOnlyTIn { unAppendOnlyTIn :: mark () }
newtype InputT (ExceptT mark e)
Instance details Defined in Control.FX.Monad.Trans.ExceptT newtype InputT (ExceptT mark e) = ExceptTIn { unExceptTIn :: mark () }
newtype InputT (ReadOnlyT mark r)
Instance details Defined in Control.FX.Monad.Trans.ReadOnlyT newtype InputT (ReadOnlyT mark r) = ReadOnlyTIn { unReadOnlyTIn :: mark r }
newtype InputT (StateT mark s)
Instance details Defined in Control.FX.Monad.Trans.StateT newtype InputT (StateT mark s) = StateTIn { unStateTIn :: mark s }
newtype InputT (WriteOnceT mark w)
Instance details Defined in Control.FX.Monad.Trans.WriteOnceT newtype InputT (WriteOnceT mark w) = WriteOnceTIn { unWriteOnceTIn :: mark () }
data InputT (WriteOnlyT mark w)
Instance details Defined in Control.FX.Monad.Trans.WriteOnlyT data InputT (WriteOnlyT mark w) = WriteOnlyTIn { unWriteOnlyTIn :: mark () }
newtype InputT (StackT mark f d) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT newtype InputT (StackT mark f d) = StackTIn { unStackTIn :: mark (f d) }

data family OutputT (t :: (Type -> Type) -> Type -> Type) a :: Type #

Instances

MonadIdentity mark => Monad (OutputT (ReadOnlyT mark r))
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 (ExceptT mark e))
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 #
MonadIdentity mark => Functor (OutputT (HaltT mark))
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 #
MonadIdentity mark => Functor (OutputT (ReadOnlyT mark r))
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 #
(Monoid w, MonadIdentity mark) => Functor (OutputT (WriteOnlyT mark w))
Instance details Defined in Control.FX.Monad.Trans.WriteOnlyT Methods fmap :: (a -> b) -> OutputT (WriteOnlyT mark w) a -> OutputT (WriteOnlyT mark w) b # (<$) :: a -> OutputT (WriteOnlyT mark w) b -> OutputT (WriteOnlyT mark w) a #
MonadIdentity mark => Applicative (OutputT (ExceptT mark e))
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 #
MonadIdentity mark => Applicative (OutputT (HaltT mark))
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 => Applicative (OutputT (ReadOnlyT mark r))
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 #
(Monoid w, MonadIdentity mark) => Applicative (OutputT (WriteOnlyT mark w))
Instance details Defined in Control.FX.Monad.Trans.WriteOnlyT Methods pure :: a -> OutputT (WriteOnlyT mark w) a # (<>) :: OutputT (WriteOnlyT mark w) (a -> b) -> OutputT (WriteOnlyT mark w) a -> OutputT (WriteOnlyT mark w) b # liftA2 :: (a -> b -> c) -> OutputT (WriteOnlyT mark w) a -> OutputT (WriteOnlyT mark w) b -> OutputT (WriteOnlyT mark w) c # (>) :: OutputT (WriteOnlyT mark w) a -> OutputT (WriteOnlyT mark w) b -> OutputT (WriteOnlyT mark w) b # (<*) :: OutputT (WriteOnlyT mark w) a -> OutputT (WriteOnlyT mark w) b -> OutputT (WriteOnlyT mark w) a #
MonadIdentity mark => MonadIdentity (OutputT (ReadOnlyT mark r))
Instance details Defined in Control.FX.Monad.Trans.ReadOnlyT Methods unwrap :: OutputT (ReadOnlyT mark r) a -> a #
Eq (OutputT t2 (OutputT t1 a)) => Eq (OutputT (ComposeT t1 t2) a)
Instance details Defined in Control.FX.Monad.Trans.ComposeT Methods (==) :: OutputT (ComposeT t1 t2) a -> OutputT (ComposeT t1 t2) a -> Bool # (/=) :: OutputT (ComposeT t1 t2) a -> OutputT (ComposeT t1 t2) a -> Bool #
(Eq (mark w), Eq a) => Eq (OutputT (AppendOnlyT mark w) a)
Instance details Defined in Control.FX.Monad.Trans.AppendOnlyT Methods (==) :: OutputT (AppendOnlyT mark w) a -> OutputT (AppendOnlyT mark w) a -> Bool # (/=) :: OutputT (AppendOnlyT mark w) a -> OutputT (AppendOnlyT mark w) a -> Bool #
(Eq e, Eq a) => Eq (OutputT (ExceptT mark e) a)
Instance details Defined in Control.FX.Monad.Trans.ExceptT Methods (==) :: OutputT (ExceptT mark e) a -> OutputT (ExceptT mark e) a -> Bool # (/=) :: OutputT (ExceptT mark e) a -> OutputT (ExceptT mark e) a -> Bool #
Eq a => Eq (OutputT (HaltT mark) a)
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 #
Eq a => Eq (OutputT IdentityT a)
Instance details Defined in Control.FX.Monad.Trans.IdentityT Methods (==) :: OutputT IdentityT a -> OutputT IdentityT a -> Bool # (/=) :: OutputT IdentityT a -> OutputT IdentityT a -> Bool #
Eq (mark a) => Eq (OutputT (ReadOnlyT mark r) a)
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 #
(Eq (mark s), Eq a) => Eq (OutputT (StateT mark s) a)
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 #
(Eq (mark (Maybe w)), Eq a) => Eq (OutputT (WriteOnceT mark w) a)
Instance details Defined in Control.FX.Monad.Trans.WriteOnceT Methods (==) :: OutputT (WriteOnceT mark w) a -> OutputT (WriteOnceT mark w) a -> Bool # (/=) :: OutputT (WriteOnceT mark w) a -> OutputT (WriteOnceT mark w) a -> Bool #
(Eq a, Eq (mark w)) => Eq (OutputT (WriteOnlyT mark w) a)
Instance details Defined in Control.FX.Monad.Trans.WriteOnlyT Methods (==) :: OutputT (WriteOnlyT mark w) a -> OutputT (WriteOnlyT mark w) a -> Bool # (/=) :: OutputT (WriteOnlyT mark w) a -> OutputT (WriteOnlyT mark w) a -> Bool #
(Eq (mark (f d)), Eq a) => Eq (OutputT (StackT mark f d) a) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods (==) :: OutputT (StackT mark f d) a -> OutputT (StackT mark f d) a -> Bool # (/=) :: OutputT (StackT mark f d) a -> OutputT (StackT mark f d) a -> Bool #
Show (OutputT t2 (OutputT t1 a)) => Show (OutputT (ComposeT t1 t2) a)
Instance details Defined in Control.FX.Monad.Trans.ComposeT Methods showsPrec :: Int -> OutputT (ComposeT t1 t2) a -> ShowS # show :: OutputT (ComposeT t1 t2) a -> String # showList :: [OutputT (ComposeT t1 t2) a] -> ShowS #
(Show (mark w), Show a) => Show (OutputT (AppendOnlyT mark w) a)
Instance details Defined in Control.FX.Monad.Trans.AppendOnlyT Methods showsPrec :: Int -> OutputT (AppendOnlyT mark w) a -> ShowS # show :: OutputT (AppendOnlyT mark w) a -> String # showList :: [OutputT (AppendOnlyT mark w) a] -> ShowS #
(Show e, Show a) => Show (OutputT (ExceptT mark e) a)
Instance details Defined in Control.FX.Monad.Trans.ExceptT Methods showsPrec :: Int -> OutputT (ExceptT mark e) a -> ShowS # show :: OutputT (ExceptT mark e) a -> String # showList :: [OutputT (ExceptT mark e) a] -> ShowS #
Show a => Show (OutputT (HaltT mark) a)
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 #
Show a => Show (OutputT IdentityT a)
Instance details Defined in Control.FX.Monad.Trans.IdentityT Methods showsPrec :: Int -> OutputT IdentityT a -> ShowS # show :: OutputT IdentityT a -> String # showList :: [OutputT IdentityT a] -> ShowS #
Show (mark a) => Show (OutputT (ReadOnlyT mark r) a)
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 #
(Show (mark s), Show a) => Show (OutputT (StateT mark s) a)
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 #
(Show (mark (Maybe w)), Show a) => Show (OutputT (WriteOnceT mark w) a)
Instance details Defined in Control.FX.Monad.Trans.WriteOnceT Methods showsPrec :: Int -> OutputT (WriteOnceT mark w) a -> ShowS # show :: OutputT (WriteOnceT mark w) a -> String # showList :: [OutputT (WriteOnceT mark w) a] -> ShowS #
(Show a, Show (mark w)) => Show (OutputT (WriteOnlyT mark w) a)
Instance details Defined in Control.FX.Monad.Trans.WriteOnlyT Methods showsPrec :: Int -> OutputT (WriteOnlyT mark w) a -> ShowS # show :: OutputT (WriteOnlyT mark w) a -> String # showList :: [OutputT (WriteOnlyT mark w) a] -> ShowS #
(Show (mark (f d)), Show a) => Show (OutputT (StackT mark f d) a) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods showsPrec :: Int -> OutputT (StackT mark f d) a -> ShowS # show :: OutputT (StackT mark f d) a -> String # showList :: [OutputT (StackT mark f d) a] -> ShowS #
(Semigroup a, MonadIdentity mark) => Semigroup (OutputT (ReadOnlyT mark r) a)
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)
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 #
data OutputT IdentityT a
Instance details Defined in Control.FX.Monad.Trans.IdentityT data OutputT IdentityT a = IdentityTOut { unIdentityTOut :: Identity a }
newtype OutputT (HaltT mark) a
Instance details Defined in Control.FX.Monad.Trans.HaltT newtype OutputT (HaltT mark) a = HaltTOut { unHaltTOut :: Halt mark a }
newtype OutputT (ComposeT t1 t2) a
Instance details Defined in Control.FX.Monad.Trans.ComposeT newtype OutputT (ComposeT t1 t2) a = ComposeTOut { unComposeTOut :: Compose (OutputT t2) (OutputT t1) a }
newtype OutputT (AppendOnlyT mark w) a
Instance details Defined in Control.FX.Monad.Trans.AppendOnlyT newtype OutputT (AppendOnlyT mark w) a = AppendOnlyTOut { unAppendOnlyTOut :: Pair (mark w) a }
newtype OutputT (ExceptT mark e) a
Instance details Defined in Control.FX.Monad.Trans.ExceptT newtype OutputT (ExceptT mark e) a = ExceptTOut { unExceptTOut :: Except mark e a }
newtype OutputT (ReadOnlyT mark r) a
Instance details Defined in Control.FX.Monad.Trans.ReadOnlyT newtype OutputT (ReadOnlyT mark r) a = ReadOnlyTOut { unReadOnlyTOut :: mark a }
newtype OutputT (StateT mark s) a
Instance details Defined in Control.FX.Monad.Trans.StateT newtype OutputT (StateT mark s) a = StateTOut { unStateTOut :: Pair (mark s) a }
newtype OutputT (WriteOnceT mark w) a
Instance details Defined in Control.FX.Monad.Trans.WriteOnceT newtype OutputT (WriteOnceT mark w) a = WriteOnceTOut { unWriteOnceTOut :: Pair (mark (Maybe w)) a }
data OutputT (WriteOnlyT mark w) a
Instance details Defined in Control.FX.Monad.Trans.WriteOnlyT data OutputT (WriteOnlyT mark w) a = WriteOnlyTOut { unWriteOnlyTOut :: Pair (mark w) a }
newtype OutputT (StackT mark f d) a Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT newtype OutputT (StackT mark f d) a = StackTOut { unStackTOut :: Pair (mark (f d)) a }

Transformer Transformers

data family InputTT (u :: ((Type -> Type) -> Type -> Type) -> (Type -> Type) -> Type -> Type) (m :: Type -> Type) :: Type #

Instances

Eq (mark ()) => Eq (InputTT (AppendOnlyTT mark w) m)
Instance details Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT Methods (==) :: InputTT (AppendOnlyTT mark w) m -> InputTT (AppendOnlyTT mark w) m -> Bool # (/=) :: InputTT (AppendOnlyTT mark w) m -> InputTT (AppendOnlyTT mark w) m -> Bool #
Eq (mark ()) => Eq (InputTT (ExceptTT mark e) m)
Instance details Defined in Control.FX.Monad.Trans.Trans.ExceptTT Methods (==) :: InputTT (ExceptTT mark e) m -> InputTT (ExceptTT mark e) m -> Bool # (/=) :: InputTT (ExceptTT mark e) m -> InputTT (ExceptTT mark e) m -> Bool #
Eq (mark ()) => Eq (InputTT (HaltTT mark) m)
Instance details Defined in Control.FX.Monad.Trans.Trans.HaltTT Methods (==) :: InputTT (HaltTT mark) m -> InputTT (HaltTT mark) m -> Bool # (/=) :: InputTT (HaltTT mark) m -> InputTT (HaltTT mark) m -> Bool #
Eq (InputTT IdentityTT m)
Instance details Defined in Control.FX.Monad.Trans.Trans.IdentityTT Methods (==) :: InputTT IdentityTT m -> InputTT IdentityTT m -> Bool # (/=) :: InputTT IdentityTT m -> InputTT IdentityTT m -> Bool #
(Eq (InputTT u m), Eq (InputT v)) => Eq (InputTT (OverTT v u) m)
Instance details Defined in Control.FX.Monad.Trans.Trans.OverTT Methods (==) :: InputTT (OverTT v u) m -> InputTT (OverTT v u) m -> Bool # (/=) :: InputTT (OverTT v u) m -> InputTT (OverTT v u) m -> Bool #
Eq (mark r) => Eq (InputTT (ReadOnlyTT mark r) m)
Instance details Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT Methods (==) :: InputTT (ReadOnlyTT mark r) m -> InputTT (ReadOnlyTT mark r) m -> Bool # (/=) :: InputTT (ReadOnlyTT mark r) m -> InputTT (ReadOnlyTT mark r) m -> Bool #
Eq (mark s) => Eq (InputTT (StateTT mark s) m)
Instance details Defined in Control.FX.Monad.Trans.Trans.StateTT Methods (==) :: InputTT (StateTT mark s) m -> InputTT (StateTT mark s) m -> Bool # (/=) :: InputTT (StateTT mark s) m -> InputTT (StateTT mark s) m -> Bool #
Eq (mark ()) => Eq (InputTT (WriteOnceTT mark w) m)
Instance details Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT Methods (==) :: InputTT (WriteOnceTT mark w) m -> InputTT (WriteOnceTT mark w) m -> Bool # (/=) :: InputTT (WriteOnceTT mark w) m -> InputTT (WriteOnceTT mark w) m -> Bool #
Eq (mark ()) => Eq (InputTT (WriteOnlyTT mark w) m)
Instance details Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT Methods (==) :: InputTT (WriteOnlyTT mark w) m -> InputTT (WriteOnlyTT mark w) m -> Bool # (/=) :: InputTT (WriteOnlyTT mark w) m -> InputTT (WriteOnlyTT mark w) m -> Bool #
Eq (mark (f d)) => Eq (InputTT (StackTT mark f d) m) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT Methods (==) :: InputTT (StackTT mark f d) m -> InputTT (StackTT mark f d) m -> Bool # (/=) :: InputTT (StackTT mark f d) m -> InputTT (StackTT mark f d) m -> Bool #
Show (mark ()) => Show (InputTT (AppendOnlyTT mark w) m)
Instance details Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT Methods showsPrec :: Int -> InputTT (AppendOnlyTT mark w) m -> ShowS # show :: InputTT (AppendOnlyTT mark w) m -> String # showList :: [InputTT (AppendOnlyTT mark w) m] -> ShowS #
Show (mark ()) => Show (InputTT (ExceptTT mark e) m)
Instance details Defined in Control.FX.Monad.Trans.Trans.ExceptTT Methods showsPrec :: Int -> InputTT (ExceptTT mark e) m -> ShowS # show :: InputTT (ExceptTT mark e) m -> String # showList :: [InputTT (ExceptTT mark e) m] -> ShowS #
Show (mark ()) => Show (InputTT (HaltTT mark) m)
Instance details Defined in Control.FX.Monad.Trans.Trans.HaltTT Methods showsPrec :: Int -> InputTT (HaltTT mark) m -> ShowS # show :: InputTT (HaltTT mark) m -> String # showList :: [InputTT (HaltTT mark) m] -> ShowS #
(Typeable mark, Typeable p, Typeable m) => Show (InputTT (PromptTT mark p) m)
Instance details Defined in Control.FX.Monad.Trans.Trans.PromptTT Methods showsPrec :: Int -> InputTT (PromptTT mark p) m -> ShowS # show :: InputTT (PromptTT mark p) m -> String # showList :: [InputTT (PromptTT mark p) m] -> ShowS #
Show (InputTT IdentityTT m)
Instance details Defined in Control.FX.Monad.Trans.Trans.IdentityTT Methods showsPrec :: Int -> InputTT IdentityTT m -> ShowS # show :: InputTT IdentityTT m -> String # showList :: [InputTT IdentityTT m] -> ShowS #
(Show (InputTT u m), Show (InputT v)) => Show (InputTT (OverTT v u) m)
Instance details Defined in Control.FX.Monad.Trans.Trans.OverTT Methods showsPrec :: Int -> InputTT (OverTT v u) m -> ShowS # show :: InputTT (OverTT v u) m -> String # showList :: [InputTT (OverTT v u) m] -> ShowS #
Show (mark r) => Show (InputTT (ReadOnlyTT mark r) m)
Instance details Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT Methods showsPrec :: Int -> InputTT (ReadOnlyTT mark r) m -> ShowS # show :: InputTT (ReadOnlyTT mark r) m -> String # showList :: [InputTT (ReadOnlyTT mark r) m] -> ShowS #
Show (mark s) => Show (InputTT (StateTT mark s) m)
Instance details Defined in Control.FX.Monad.Trans.Trans.StateTT Methods showsPrec :: Int -> InputTT (StateTT mark s) m -> ShowS # show :: InputTT (StateTT mark s) m -> String # showList :: [InputTT (StateTT mark s) m] -> ShowS #
Show (mark ()) => Show (InputTT (WriteOnceTT mark w) m)
Instance details Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT Methods showsPrec :: Int -> InputTT (WriteOnceTT mark w) m -> ShowS # show :: InputTT (WriteOnceTT mark w) m -> String # showList :: [InputTT (WriteOnceTT mark w) m] -> ShowS #
Show (mark ()) => Show (InputTT (WriteOnlyTT mark w) m)
Instance details Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT Methods showsPrec :: Int -> InputTT (WriteOnlyTT mark w) m -> ShowS # show :: InputTT (WriteOnlyTT mark w) m -> String # showList :: [InputTT (WriteOnlyTT mark w) m] -> ShowS #
Show (mark (f d)) => Show (InputTT (StackTT mark f d) m) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT Methods showsPrec :: Int -> InputTT (StackTT mark f d) m -> ShowS # show :: InputTT (StackTT mark f d) m -> String # showList :: [InputTT (StackTT mark f d) m] -> ShowS #
newtype InputTT IdentityTT m
Instance details Defined in Control.FX.Monad.Trans.Trans.IdentityTT newtype InputTT IdentityTT m = IdentityTTIn { unIdentityTTIn :: () }
newtype InputTT (HaltTT mark) m
Instance details Defined in Control.FX.Monad.Trans.Trans.HaltTT newtype InputTT (HaltTT mark) m = HaltTTIn { unHaltTTIn :: mark () }
newtype InputTT (AppendOnlyTT mark w) m
Instance details Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT newtype InputTT (AppendOnlyTT mark w) m = AppendOnlyTTIn { unAppendOnlyTTIn :: mark () }
newtype InputTT (ExceptTT mark e) m
Instance details Defined in Control.FX.Monad.Trans.Trans.ExceptTT newtype InputTT (ExceptTT mark e) m = ExceptTTIn { unExceptTTIn :: mark () }
newtype InputTT (PromptTT mark p) m
Instance details Defined in Control.FX.Monad.Trans.Trans.PromptTT newtype InputTT (PromptTT mark p) m = PromptTTIn { unPromptTTIn :: Eval p m }
newtype InputTT (OverTT v u) m
Instance details Defined in Control.FX.Monad.Trans.Trans.OverTT newtype InputTT (OverTT v u) m = OverTTIn { unOverTTIn :: (InputTT u m, InputT v) }
newtype InputTT (ReadOnlyTT mark r) m
Instance details Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT newtype InputTT (ReadOnlyTT mark r) m = ReadOnlyTTIn { unReadOnlyTTIn :: mark r }
newtype InputTT (StateTT mark s) m
Instance details Defined in Control.FX.Monad.Trans.Trans.StateTT newtype InputTT (StateTT mark s) m = StateTTIn { unStateTTIn :: mark s }
newtype InputTT (WriteOnceTT mark w) m
Instance details Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT newtype InputTT (WriteOnceTT mark w) m = WriteOnceTTIn { unWriteOnceTTIn :: mark () }
newtype InputTT (WriteOnlyTT mark w) m
Instance details Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT newtype InputTT (WriteOnlyTT mark w) m = WriteOnlyTTIn { unWriteOnlyTTIn :: mark () }
newtype InputTT (StackTT mark f d) m Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT newtype InputTT (StackTT mark f d) m = StackTTIn { unStackTTIn :: mark (f d) }

data family OutputTT (u :: ((Type -> Type) -> Type -> Type) -> (Type -> Type) -> Type -> Type) a :: Type #

Instances

MonadIdentity mark => Monad (OutputTT (PromptTT mark p))
Instance details Defined in Control.FX.Monad.Trans.Trans.PromptTT Methods (>>=) :: OutputTT (PromptTT mark p) a -> (a -> OutputTT (PromptTT mark p) b) -> OutputTT (PromptTT mark p) b # (>>) :: OutputTT (PromptTT mark p) a -> OutputTT (PromptTT mark p) b -> OutputTT (PromptTT mark p) b # return :: a -> OutputTT (PromptTT mark p) a # fail :: String -> OutputTT (PromptTT mark p) a #
MonadIdentity mark => Functor (OutputTT (PromptTT mark p))
Instance details Defined in Control.FX.Monad.Trans.Trans.PromptTT Methods fmap :: (a -> b) -> OutputTT (PromptTT mark p) a -> OutputTT (PromptTT mark p) b # (<$) :: a -> OutputTT (PromptTT mark p) b -> OutputTT (PromptTT mark p) a #
MonadIdentity mark => Applicative (OutputTT (PromptTT mark p))
Instance details Defined in Control.FX.Monad.Trans.Trans.PromptTT Methods pure :: a -> OutputTT (PromptTT mark p) a # (<>) :: OutputTT (PromptTT mark p) (a -> b) -> OutputTT (PromptTT mark p) a -> OutputTT (PromptTT mark p) b # liftA2 :: (a -> b -> c) -> OutputTT (PromptTT mark p) a -> OutputTT (PromptTT mark p) b -> OutputTT (PromptTT mark p) c # (>) :: OutputTT (PromptTT mark p) a -> OutputTT (PromptTT mark p) b -> OutputTT (PromptTT mark p) b # (<*) :: OutputTT (PromptTT mark p) a -> OutputTT (PromptTT mark p) b -> OutputTT (PromptTT mark p) a #
MonadIdentity mark => MonadIdentity (OutputTT (PromptTT mark p))
Instance details Defined in Control.FX.Monad.Trans.Trans.PromptTT Methods unwrap :: OutputTT (PromptTT mark p) a -> a #
(Eq (mark w), Eq a) => Eq (OutputTT (AppendOnlyTT mark w) a)
Instance details Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT Methods (==) :: OutputTT (AppendOnlyTT mark w) a -> OutputTT (AppendOnlyTT mark w) a -> Bool # (/=) :: OutputTT (AppendOnlyTT mark w) a -> OutputTT (AppendOnlyTT mark w) a -> Bool #
(Eq e, Eq a) => Eq (OutputTT (ExceptTT mark e) a)
Instance details Defined in Control.FX.Monad.Trans.Trans.ExceptTT Methods (==) :: OutputTT (ExceptTT mark e) a -> OutputTT (ExceptTT mark e) a -> Bool # (/=) :: OutputTT (ExceptTT mark e) a -> OutputTT (ExceptTT mark e) a -> Bool #
(Eq (mark ()), Eq a) => Eq (OutputTT (HaltTT mark) a)
Instance details Defined in Control.FX.Monad.Trans.Trans.HaltTT Methods (==) :: OutputTT (HaltTT mark) a -> OutputTT (HaltTT mark) a -> Bool # (/=) :: OutputTT (HaltTT mark) a -> OutputTT (HaltTT mark) a -> Bool #
Eq (mark a) => Eq (OutputTT (PromptTT mark p) a)
Instance details Defined in Control.FX.Monad.Trans.Trans.PromptTT Methods (==) :: OutputTT (PromptTT mark p) a -> OutputTT (PromptTT mark p) a -> Bool # (/=) :: OutputTT (PromptTT mark p) a -> OutputTT (PromptTT mark p) a -> Bool #
Eq a => Eq (OutputTT IdentityTT a)
Instance details Defined in Control.FX.Monad.Trans.Trans.IdentityTT Methods (==) :: OutputTT IdentityTT a -> OutputTT IdentityTT a -> Bool # (/=) :: OutputTT IdentityTT a -> OutputTT IdentityTT a -> Bool #
(Eq (OutputTT u a), Eq (OutputTT u (OutputT v a))) => Eq (OutputTT (OverTT v u) a)
Instance details Defined in Control.FX.Monad.Trans.Trans.OverTT Methods (==) :: OutputTT (OverTT v u) a -> OutputTT (OverTT v u) a -> Bool # (/=) :: OutputTT (OverTT v u) a -> OutputTT (OverTT v u) a -> Bool #
Eq (mark a) => Eq (OutputTT (ReadOnlyTT mark r) a)
Instance details Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT Methods (==) :: OutputTT (ReadOnlyTT mark r) a -> OutputTT (ReadOnlyTT mark r) a -> Bool # (/=) :: OutputTT (ReadOnlyTT mark r) a -> OutputTT (ReadOnlyTT mark r) a -> Bool #
(Eq (mark s), Eq a) => Eq (OutputTT (StateTT mark s) a)
Instance details Defined in Control.FX.Monad.Trans.Trans.StateTT Methods (==) :: OutputTT (StateTT mark s) a -> OutputTT (StateTT mark s) a -> Bool # (/=) :: OutputTT (StateTT mark s) a -> OutputTT (StateTT mark s) a -> Bool #
(Eq (mark (Maybe w)), Eq a) => Eq (OutputTT (WriteOnceTT mark w) a)
Instance details Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT Methods (==) :: OutputTT (WriteOnceTT mark w) a -> OutputTT (WriteOnceTT mark w) a -> Bool # (/=) :: OutputTT (WriteOnceTT mark w) a -> OutputTT (WriteOnceTT mark w) a -> Bool #
(Eq (mark w), Eq a) => Eq (OutputTT (WriteOnlyTT mark w) a)
Instance details Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT Methods (==) :: OutputTT (WriteOnlyTT mark w) a -> OutputTT (WriteOnlyTT mark w) a -> Bool # (/=) :: OutputTT (WriteOnlyTT mark w) a -> OutputTT (WriteOnlyTT mark w) a -> Bool #
(Eq (mark (f d)), Eq a) => Eq (OutputTT (StackTT mark f d) a) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT Methods (==) :: OutputTT (StackTT mark f d) a -> OutputTT (StackTT mark f d) a -> Bool # (/=) :: OutputTT (StackTT mark f d) a -> OutputTT (StackTT mark f d) a -> Bool #
(Show (mark w), Show a) => Show (OutputTT (AppendOnlyTT mark w) a)
Instance details Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT Methods showsPrec :: Int -> OutputTT (AppendOnlyTT mark w) a -> ShowS # show :: OutputTT (AppendOnlyTT mark w) a -> String # showList :: [OutputTT (AppendOnlyTT mark w) a] -> ShowS #
(Show e, Show a) => Show (OutputTT (ExceptTT mark e) a)
Instance details Defined in Control.FX.Monad.Trans.Trans.ExceptTT Methods showsPrec :: Int -> OutputTT (ExceptTT mark e) a -> ShowS # show :: OutputTT (ExceptTT mark e) a -> String # showList :: [OutputTT (ExceptTT mark e) a] -> ShowS #
(Show (mark ()), Show a) => Show (OutputTT (HaltTT mark) a)
Instance details Defined in Control.FX.Monad.Trans.Trans.HaltTT Methods showsPrec :: Int -> OutputTT (HaltTT mark) a -> ShowS # show :: OutputTT (HaltTT mark) a -> String # showList :: [OutputTT (HaltTT mark) a] -> ShowS #
Show (mark a) => Show (OutputTT (PromptTT mark p) a)
Instance details Defined in Control.FX.Monad.Trans.Trans.PromptTT Methods showsPrec :: Int -> OutputTT (PromptTT mark p) a -> ShowS # show :: OutputTT (PromptTT mark p) a -> String # showList :: [OutputTT (PromptTT mark p) a] -> ShowS #
Show a => Show (OutputTT IdentityTT a)
Instance details Defined in Control.FX.Monad.Trans.Trans.IdentityTT Methods showsPrec :: Int -> OutputTT IdentityTT a -> ShowS # show :: OutputTT IdentityTT a -> String # showList :: [OutputTT IdentityTT a] -> ShowS #
(Show (OutputTT u a), Show (OutputTT u (OutputT v a))) => Show (OutputTT (OverTT v u) a)
Instance details Defined in Control.FX.Monad.Trans.Trans.OverTT Methods showsPrec :: Int -> OutputTT (OverTT v u) a -> ShowS # show :: OutputTT (OverTT v u) a -> String # showList :: [OutputTT (OverTT v u) a] -> ShowS #
Show (mark a) => Show (OutputTT (ReadOnlyTT mark r) a)
Instance details Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT Methods showsPrec :: Int -> OutputTT (ReadOnlyTT mark r) a -> ShowS # show :: OutputTT (ReadOnlyTT mark r) a -> String # showList :: [OutputTT (ReadOnlyTT mark r) a] -> ShowS #
(Show (mark s), Show a) => Show (OutputTT (StateTT mark s) a)
Instance details Defined in Control.FX.Monad.Trans.Trans.StateTT Methods showsPrec :: Int -> OutputTT (StateTT mark s) a -> ShowS # show :: OutputTT (StateTT mark s) a -> String # showList :: [OutputTT (StateTT mark s) a] -> ShowS #
(Show (mark (Maybe w)), Show a) => Show (OutputTT (WriteOnceTT mark w) a)
Instance details Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT Methods showsPrec :: Int -> OutputTT (WriteOnceTT mark w) a -> ShowS # show :: OutputTT (WriteOnceTT mark w) a -> String # showList :: [OutputTT (WriteOnceTT mark w) a] -> ShowS #
(Show (mark w), Show a) => Show (OutputTT (WriteOnlyTT mark w) a)
Instance details Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT Methods showsPrec :: Int -> OutputTT (WriteOnlyTT mark w) a -> ShowS # show :: OutputTT (WriteOnlyTT mark w) a -> String # showList :: [OutputTT (WriteOnlyTT mark w) a] -> ShowS #
(Show (mark (f d)), Show a) => Show (OutputTT (StackTT mark f d) a) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT Methods showsPrec :: Int -> OutputTT (StackTT mark f d) a -> ShowS # show :: OutputTT (StackTT mark f d) a -> String # showList :: [OutputTT (StackTT mark f d) a] -> ShowS #
(MonadIdentity mark, Semigroup a) => Semigroup (OutputTT (PromptTT mark p) a)
Instance details Defined in Control.FX.Monad.Trans.Trans.PromptTT Methods (<>) :: OutputTT (PromptTT mark p) a -> OutputTT (PromptTT mark p) a -> OutputTT (PromptTT mark p) a # sconcat :: NonEmpty (OutputTT (PromptTT mark p) a) -> OutputTT (PromptTT mark p) a # stimes :: Integral b => b -> OutputTT (PromptTT mark p) a -> OutputTT (PromptTT mark p) a #
(MonadIdentity mark, Monoid a) => Monoid (OutputTT (PromptTT mark p) a)
Instance details Defined in Control.FX.Monad.Trans.Trans.PromptTT Methods mempty :: OutputTT (PromptTT mark p) a # mappend :: OutputTT (PromptTT mark p) a -> OutputTT (PromptTT mark p) a -> OutputTT (PromptTT mark p) a # mconcat :: [OutputTT (PromptTT mark p) a] -> OutputTT (PromptTT mark p) a #
newtype OutputTT IdentityTT a
Instance details Defined in Control.FX.Monad.Trans.Trans.IdentityTT newtype OutputTT IdentityTT a = IdentityTTOut { unIdentityTTOut :: Identity a }
newtype OutputTT (HaltTT mark) a
Instance details Defined in Control.FX.Monad.Trans.Trans.HaltTT newtype OutputTT (HaltTT mark) a = HaltTTOut { unHaltTTOut :: Halt mark a }
newtype OutputTT (AppendOnlyTT mark w) a
Instance details Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT newtype OutputTT (AppendOnlyTT mark w) a = AppendOnlyTTOut { unAppendOnlyTTOut :: Pair (mark w) a }
newtype OutputTT (ExceptTT mark e) a
Instance details Defined in Control.FX.Monad.Trans.Trans.ExceptTT newtype OutputTT (ExceptTT mark e) a = ExceptTTOut { unExceptTTOut :: Except mark e a }
newtype OutputTT (PromptTT mark p) a
Instance details Defined in Control.FX.Monad.Trans.Trans.PromptTT newtype OutputTT (PromptTT mark p) a = PromptTTOut { unPromptTTOut :: mark a }
newtype OutputTT (OverTT v u) a
Instance details Defined in Control.FX.Monad.Trans.Trans.OverTT newtype OutputTT (OverTT v u) a = OverTTOut { unOverTTOut :: Compose (OutputTT u) (OutputT v) a }
newtype OutputTT (ReadOnlyTT mark r) a
Instance details Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT newtype OutputTT (ReadOnlyTT mark r) a = ReadOnlyTTOut { unReadOnlyTTOut :: mark a }
newtype OutputTT (StateTT mark s) a
Instance details Defined in Control.FX.Monad.Trans.Trans.StateTT newtype OutputTT (StateTT mark s) a = StateTTOut { unStateTTOut :: Pair (mark s) a }
newtype OutputTT (WriteOnceTT mark w) a
Instance details Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT newtype OutputTT (WriteOnceTT mark w) a = WriteOnceTTOut { unWriteOnceTTOut :: Pair (mark (Maybe w)) a }
newtype OutputTT (WriteOnlyTT mark w) a
Instance details Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT newtype OutputTT (WriteOnlyTT mark w) a = WriteOnlyTTOut { unWriteOnlyTTOut :: Pair (mark w) a }
newtype OutputTT (StackTT mark f d) a Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT newtype OutputTT (StackTT mark f d) a = StackTTOut { unStackTTOut :: Pair (mark (f d)) a }

Equality

data family Context (t :: Type -> Type) :: Type #

Instances

Eq (Context Maybe)
Instance details Defined in Control.FX.EqIn Methods (==) :: Context Maybe -> Context Maybe -> Bool # (/=) :: Context Maybe -> Context Maybe -> Bool #
Eq (Context (Either a))
Instance details Defined in Control.FX.EqIn Methods (==) :: Context (Either a) -> Context (Either a) -> Bool # (/=) :: Context (Either a) -> Context (Either a) -> Bool #
(Eq (mark ()), Eq (Context (t m))) => Eq (Context (AppendOnlyTT mark w t m))
Instance details Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT Methods (==) :: Context (AppendOnlyTT mark w t m) -> Context (AppendOnlyTT mark w t m) -> Bool # (/=) :: Context (AppendOnlyTT mark w t m) -> Context (AppendOnlyTT mark w t m) -> Bool #
(Eq (mark ()), Eq (Context (t m))) => Eq (Context (ExceptTT mark e t m))
Instance details Defined in Control.FX.Monad.Trans.Trans.ExceptTT Methods (==) :: Context (ExceptTT mark e t m) -> Context (ExceptTT mark e t m) -> Bool # (/=) :: Context (ExceptTT mark e t m) -> Context (ExceptTT mark e t m) -> Bool #
(Eq (mark ()), Eq (Context (t m))) => Eq (Context (HaltTT mark t m))
Instance details Defined in Control.FX.Monad.Trans.Trans.HaltTT Methods (==) :: Context (HaltTT mark t m) -> Context (HaltTT mark t m) -> Bool # (/=) :: Context (HaltTT mark t m) -> Context (HaltTT mark t m) -> Bool #
Eq (Context (t m)) => Eq (Context (IdentityTT t m))
Instance details Defined in Control.FX.Monad.Trans.Trans.IdentityTT Methods (==) :: Context (IdentityTT t m) -> Context (IdentityTT t m) -> Bool # (/=) :: Context (IdentityTT t m) -> Context (IdentityTT t m) -> Bool #
(Eq (InputTT u m), Eq (InputT v), Eq (Context (t m))) => Eq (Context (OverTT v u t m))
Instance details Defined in Control.FX.Monad.Trans.Trans.OverTT Methods (==) :: Context (OverTT v u t m) -> Context (OverTT v u t m) -> Bool # (/=) :: Context (OverTT v u t m) -> Context (OverTT v u t m) -> Bool #
(Eq (mark r), Eq (Context (t m))) => Eq (Context (ReadOnlyTT mark r t m))
Instance details Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT Methods (==) :: Context (ReadOnlyTT mark r t m) -> Context (ReadOnlyTT mark r t m) -> Bool # (/=) :: Context (ReadOnlyTT mark r t m) -> Context (ReadOnlyTT mark r t m) -> Bool #
(Eq (mark s), Eq (Context (t m))) => Eq (Context (StateTT mark s t m))
Instance details Defined in Control.FX.Monad.Trans.Trans.StateTT Methods (==) :: Context (StateTT mark s t m) -> Context (StateTT mark s t m) -> Bool # (/=) :: Context (StateTT mark s t m) -> Context (StateTT mark s t m) -> Bool #
(Eq (mark ()), Eq (Context (t m))) => Eq (Context (WriteOnceTT mark w t m))
Instance details Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT Methods (==) :: Context (WriteOnceTT mark w t m) -> Context (WriteOnceTT mark w t m) -> Bool # (/=) :: Context (WriteOnceTT mark w t m) -> Context (WriteOnceTT mark w t m) -> Bool #
(Eq (mark ()), Eq (Context (t m))) => Eq (Context (WriteOnlyTT mark w t m))
Instance details Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT Methods (==) :: Context (WriteOnlyTT mark w t m) -> Context (WriteOnlyTT mark w t m) -> Bool # (/=) :: Context (WriteOnlyTT mark w t m) -> Context (WriteOnlyTT mark w t m) -> Bool #
Eq (Context (t1 (t2 m))) => Eq (Context (ComposeT t1 t2 m))
Instance details Defined in Control.FX.Monad.Trans.ComposeT Methods (==) :: Context (ComposeT t1 t2 m) -> Context (ComposeT t1 t2 m) -> Bool # (/=) :: Context (ComposeT t1 t2 m) -> Context (ComposeT t1 t2 m) -> Bool #
(Eq (mark w), Eq (Context m)) => Eq (Context (AppendOnlyT mark w m))
Instance details Defined in Control.FX.Monad.Trans.AppendOnlyT Methods (==) :: Context (AppendOnlyT mark w m) -> Context (AppendOnlyT mark w m) -> Bool # (/=) :: Context (AppendOnlyT mark w m) -> Context (AppendOnlyT mark w m) -> Bool #
(Eq (mark ()), Eq (Context m)) => Eq (Context (ExceptT mark e m))
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 (Context m)) => Eq (Context (HaltT mark m))
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 (Context m) => Eq (Context (IdentityT m))
Instance details Defined in Control.FX.Monad.Trans.IdentityT Methods (==) :: Context (IdentityT m) -> Context (IdentityT m) -> Bool # (/=) :: Context (IdentityT m) -> Context (IdentityT m) -> Bool #
(Eq (mark r), Eq (Context m)) => Eq (Context (ReadOnlyT mark r m))
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 s), Eq (Context m)) => Eq (Context (StateT mark s m))
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 ()), Eq (Context m)) => Eq (Context (WriteOnceT mark w m))
Instance details Defined in Control.FX.Monad.Trans.WriteOnceT Methods (==) :: Context (WriteOnceT mark w m) -> Context (WriteOnceT mark w m) -> Bool # (/=) :: Context (WriteOnceT mark w m) -> Context (WriteOnceT mark w m) -> Bool #
(Eq (mark ()), Eq (Context m)) => Eq (Context (WriteOnlyT mark w m))
Instance details Defined in Control.FX.Monad.Trans.WriteOnlyT Methods (==) :: Context (WriteOnlyT mark w m) -> Context (WriteOnlyT mark w m) -> Bool # (/=) :: Context (WriteOnlyT mark w m) -> Context (WriteOnlyT mark w m) -> Bool #
Eq (mark ()) => Eq (Context (WriteOnly mark w))
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 (Context (WriteOnce mark w))
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 s) => Eq (Context (State mark s))
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 r) => Eq (Context (ReadOnly mark r))
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 (Context Identity)
Instance details Defined in Control.FX.Monad.Identity Methods (==) :: Context Identity -> Context Identity -> Bool # (/=) :: Context Identity -> Context Identity -> Bool #
Eq (mark ()) => Eq (Context (Halt mark))
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 (Context (Except mark e))
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 (Context (AppendOnly mark w))
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 (Context RightZero)
Instance details Defined in Control.FX.Functor.RightZero Methods (==) :: Context RightZero -> Context RightZero -> Bool # (/=) :: Context RightZero -> Context RightZero -> Bool #
Eq (Context (Pair a))
Instance details Defined in Control.FX.Functor.Pair Methods (==) :: Context (Pair a) -> Context (Pair a) -> Bool # (/=) :: Context (Pair a) -> Context (Pair a) -> Bool #
Eq (Context LeftZero)
Instance details Defined in Control.FX.Functor.LeftZero Methods (==) :: Context LeftZero -> Context LeftZero -> Bool # (/=) :: Context LeftZero -> Context LeftZero -> Bool #
(Eq (mark (f d)), Eq (Context m)) => Eq (Context (StackT mark f d m)) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods (==) :: Context (StackT mark f d m) -> Context (StackT mark f d m) -> Bool # (/=) :: Context (StackT mark f d m) -> Context (StackT mark f d m) -> Bool #
(Eq (mark (f d)), Eq (Context (t m))) => Eq (Context (StackTT mark f d t m)) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT Methods (==) :: Context (StackTT mark f d t m) -> Context (StackTT mark f d t m) -> Bool # (/=) :: Context (StackTT mark f d t m) -> Context (StackTT mark f d t m) -> Bool #
Eq (mark (f d)) => Eq (Context (Stack mark f d)) Source #
Instance details Defined in Control.FX.Monad.Data.Stack Methods (==) :: Context (Stack mark f d) -> Context (Stack mark f d) -> Bool # (/=) :: Context (Stack mark f d) -> Context (Stack mark f d) -> Bool #
Show (Context Maybe)
Instance details Defined in Control.FX.EqIn Methods showsPrec :: Int -> Context Maybe -> ShowS # show :: Context Maybe -> String # showList :: [Context Maybe] -> ShowS #
Show (Context (Either a))
Instance details Defined in Control.FX.EqIn Methods showsPrec :: Int -> Context (Either a) -> ShowS # show :: Context (Either a) -> String # showList :: [Context (Either a)] -> ShowS #
(Show (mark ()), Show (Context (t m))) => Show (Context (AppendOnlyTT mark w t m))
Instance details Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT Methods showsPrec :: Int -> Context (AppendOnlyTT mark w t m) -> ShowS # show :: Context (AppendOnlyTT mark w t m) -> String # showList :: [Context (AppendOnlyTT mark w t m)] -> ShowS #
(Show (mark ()), Show (Context (t m))) => Show (Context (ExceptTT mark e t m))
Instance details Defined in Control.FX.Monad.Trans.Trans.ExceptTT Methods showsPrec :: Int -> Context (ExceptTT mark e t m) -> ShowS # show :: Context (ExceptTT mark e t m) -> String # showList :: [Context (ExceptTT mark e t m)] -> ShowS #
(Show (mark ()), Show (Context (t m))) => Show (Context (HaltTT mark t m))
Instance details Defined in Control.FX.Monad.Trans.Trans.HaltTT Methods showsPrec :: Int -> Context (HaltTT mark t m) -> ShowS # show :: Context (HaltTT mark t m) -> String # showList :: [Context (HaltTT mark t m)] -> ShowS #
(Typeable mark, Typeable p, Typeable t, Typeable m) => Show (Context (PromptTT mark p t m))
Instance details Defined in Control.FX.Monad.Trans.Trans.PromptTT Methods showsPrec :: Int -> Context (PromptTT mark p t m) -> ShowS # show :: Context (PromptTT mark p t m) -> String # showList :: [Context (PromptTT mark p t m)] -> ShowS #
Show (Context (t m)) => Show (Context (IdentityTT t m))
Instance details Defined in Control.FX.Monad.Trans.Trans.IdentityTT Methods showsPrec :: Int -> Context (IdentityTT t m) -> ShowS # show :: Context (IdentityTT t m) -> String # showList :: [Context (IdentityTT t m)] -> ShowS #
(Show (InputTT u m), Show (InputT v), Show (Context (t m))) => Show (Context (OverTT v u t m))
Instance details Defined in Control.FX.Monad.Trans.Trans.OverTT Methods showsPrec :: Int -> Context (OverTT v u t m) -> ShowS # show :: Context (OverTT v u t m) -> String # showList :: [Context (OverTT v u t m)] -> ShowS #
(Show (mark r), Show (Context (t m))) => Show (Context (ReadOnlyTT mark r t m))
Instance details Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT Methods showsPrec :: Int -> Context (ReadOnlyTT mark r t m) -> ShowS # show :: Context (ReadOnlyTT mark r t m) -> String # showList :: [Context (ReadOnlyTT mark r t m)] -> ShowS #
(Show (mark s), Show (Context (t m))) => Show (Context (StateTT mark s t m))
Instance details Defined in Control.FX.Monad.Trans.Trans.StateTT Methods showsPrec :: Int -> Context (StateTT mark s t m) -> ShowS # show :: Context (StateTT mark s t m) -> String # showList :: [Context (StateTT mark s t m)] -> ShowS #
(Show (mark ()), Show (Context (t m))) => Show (Context (WriteOnceTT mark w t m))
Instance details Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT Methods showsPrec :: Int -> Context (WriteOnceTT mark w t m) -> ShowS # show :: Context (WriteOnceTT mark w t m) -> String # showList :: [Context (WriteOnceTT mark w t m)] -> ShowS #
(Show (mark ()), Show (Context (t m))) => Show (Context (WriteOnlyTT mark w t m))
Instance details Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT Methods showsPrec :: Int -> Context (WriteOnlyTT mark w t m) -> ShowS # show :: Context (WriteOnlyTT mark w t m) -> String # showList :: [Context (WriteOnlyTT mark w t m)] -> ShowS #
Show (Context (t1 (t2 m))) => Show (Context (ComposeT t1 t2 m))
Instance details Defined in Control.FX.Monad.Trans.ComposeT Methods showsPrec :: Int -> Context (ComposeT t1 t2 m) -> ShowS # show :: Context (ComposeT t1 t2 m) -> String # showList :: [Context (ComposeT t1 t2 m)] -> ShowS #
(Show (mark w), Show (Context m)) => Show (Context (AppendOnlyT mark w m))
Instance details Defined in Control.FX.Monad.Trans.AppendOnlyT Methods showsPrec :: Int -> Context (AppendOnlyT mark w m) -> ShowS # show :: Context (AppendOnlyT mark w m) -> String # showList :: [Context (AppendOnlyT mark w m)] -> ShowS #
(Show (mark ()), Show (Context m)) => Show (Context (ExceptT mark e m))
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 (Context m)) => Show (Context (HaltT mark m))
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 (Context m) => Show (Context (IdentityT m))
Instance details Defined in Control.FX.Monad.Trans.IdentityT Methods showsPrec :: Int -> Context (IdentityT m) -> ShowS # show :: Context (IdentityT m) -> String # showList :: [Context (IdentityT m)] -> ShowS #
(Show (mark r), Show (Context m)) => Show (Context (ReadOnlyT mark r m))
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 s), Show (Context m)) => Show (Context (StateT mark s m))
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 ()), Show (Context m)) => Show (Context (WriteOnceT mark w m))
Instance details Defined in Control.FX.Monad.Trans.WriteOnceT Methods showsPrec :: Int -> Context (WriteOnceT mark w m) -> ShowS # show :: Context (WriteOnceT mark w m) -> String # showList :: [Context (WriteOnceT mark w m)] -> ShowS #
(Show (mark ()), Show (Context m)) => Show (Context (WriteOnlyT mark w m))
Instance details Defined in Control.FX.Monad.Trans.WriteOnlyT Methods showsPrec :: Int -> Context (WriteOnlyT mark w m) -> ShowS # show :: Context (WriteOnlyT mark w m) -> String # showList :: [Context (WriteOnlyT mark w m)] -> ShowS #
Show (mark ()) => Show (Context (WriteOnly mark w))
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 (Context (WriteOnce mark w))
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 s) => Show (Context (State mark s))
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 r) => Show (Context (ReadOnly mark r))
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 (Context Identity)
Instance details Defined in Control.FX.Monad.Identity Methods showsPrec :: Int -> Context Identity -> ShowS # show :: Context Identity -> String # showList :: [Context Identity] -> ShowS #
Show (mark ()) => Show (Context (Halt mark))
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 (Context (Except mark e))
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 (Context (AppendOnly mark w))
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 (Context RightZero)
Instance details Defined in Control.FX.Functor.RightZero Methods showsPrec :: Int -> Context RightZero -> ShowS # show :: Context RightZero -> String # showList :: [Context RightZero] -> ShowS #
Show (Context (Pair a))
Instance details Defined in Control.FX.Functor.Pair Methods showsPrec :: Int -> Context (Pair a) -> ShowS # show :: Context (Pair a) -> String # showList :: [Context (Pair a)] -> ShowS #
Show (Context LeftZero)
Instance details Defined in Control.FX.Functor.LeftZero Methods showsPrec :: Int -> Context LeftZero -> ShowS # show :: Context LeftZero -> String # showList :: [Context LeftZero] -> ShowS #
(Show (mark (f d)), Show (Context m)) => Show (Context (StackT mark f d m)) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT Methods showsPrec :: Int -> Context (StackT mark f d m) -> ShowS # show :: Context (StackT mark f d m) -> String # showList :: [Context (StackT mark f d m)] -> ShowS #
(Show (mark (f d)), Show (Context (t m))) => Show (Context (StackTT mark f d t m)) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT Methods showsPrec :: Int -> Context (StackTT mark f d t m) -> ShowS # show :: Context (StackTT mark f d t m) -> String # showList :: [Context (StackTT mark f d t m)] -> ShowS #
Show (mark (f d)) => Show (Context (Stack mark f d)) Source #
Instance details Defined in Control.FX.Monad.Data.Stack Methods showsPrec :: Int -> Context (Stack mark f d) -> ShowS # show :: Context (Stack mark f d) -> String # showList :: [Context (Stack mark f d)] -> ShowS #
data Context Maybe
Instance details Defined in Control.FX.EqIn data Context Maybe = MaybeCtx { unMaybeCtx :: () }
data Context Identity
Instance details Defined in Control.FX.Monad.Identity data Context Identity = IdentityCtx { unIdentityCtx :: () }
newtype Context RightZero
Instance details Defined in Control.FX.Functor.RightZero newtype Context RightZero = RightZeroCtx { unRightZeroCtx :: () }
newtype Context LeftZero
Instance details Defined in Control.FX.Functor.LeftZero newtype Context LeftZero = LeftZeroCtx { unLeftZeroCtx :: () }
data Context (Either a)
Instance details Defined in Control.FX.EqIn data Context (Either a) = EitherCtx { unEitherCtx :: () }
data Context (IdentityT m)
Instance details Defined in Control.FX.Monad.Trans.IdentityT data Context (IdentityT m) = IdentityTCtx { unIdentityTCtx :: Context m }
data Context (Halt mark)
Instance details Defined in Control.FX.Monad.Halt data Context (Halt mark) = HaltCtx { unHaltCtx :: mark () }
newtype Context (Pair a)
Instance details Defined in Control.FX.Functor.Pair newtype Context (Pair a) = PairCtx { unPairCtx :: () }
newtype Context (IdentityTT t m)
Instance details Defined in Control.FX.Monad.Trans.Trans.IdentityTT newtype Context (IdentityTT t m) = IdentityTTCtx { unIdentityTTCtx :: Context (t m) }
newtype Context (HaltT mark m)
Instance details Defined in Control.FX.Monad.Trans.HaltT newtype Context (HaltT mark m) = HaltTCtx { unHaltTCtx :: (mark (), Context m) }
newtype Context (WriteOnly mark w)
Instance details Defined in Control.FX.Monad.WriteOnly newtype Context (WriteOnly mark w) = WriteOnlyCtx { unWriteOnlyCtx :: mark () }
newtype Context (WriteOnce mark w)
Instance details Defined in Control.FX.Monad.WriteOnce newtype Context (WriteOnce mark w) = WriteOnceCtx { unWriteOnceCtx :: mark () }
data Context (State mark s)
Instance details Defined in Control.FX.Monad.State data Context (State mark s) = StateCtx { unStateCtx :: mark s }
newtype Context (ReadOnly mark r)
Instance details Defined in Control.FX.Monad.ReadOnly newtype Context (ReadOnly mark r) = ReadOnlyCtx { unReadOnlyCtx :: mark r }
newtype Context (Except mark e)
Instance details Defined in Control.FX.Monad.Except newtype Context (Except mark e) = ExceptCtx { unExceptCtx :: mark () }
newtype Context (AppendOnly mark w)
Instance details Defined in Control.FX.Monad.AppendOnly newtype Context (AppendOnly mark w) = AppendOnlyCtx { unAppendOnlyCtx :: mark () }
newtype Context (HaltTT mark t m)
Instance details Defined in Control.FX.Monad.Trans.Trans.HaltTT newtype Context (HaltTT mark t m) = HaltTTCtx { unHaltTTCtx :: (mark (), Context (t m)) }
newtype Context (ComposeT t1 t2 m)
Instance details Defined in Control.FX.Monad.Trans.ComposeT newtype Context (ComposeT t1 t2 m) = ComposeTCtx { unComposeTCtx :: Context (t1 (t2 m)) }
newtype Context (AppendOnlyT mark w m)
Instance details Defined in Control.FX.Monad.Trans.AppendOnlyT newtype Context (AppendOnlyT mark w m) = AppendOnlyTCtx { unAppendOnlyTCtx :: (mark w, Context m) }
newtype Context (ExceptT mark e m)
Instance details Defined in Control.FX.Monad.Trans.ExceptT newtype Context (ExceptT mark e m) = ExceptTCtx { unExceptTCtx :: (mark (), Context m) }
newtype Context (ReadOnlyT mark r m)
Instance details Defined in Control.FX.Monad.Trans.ReadOnlyT newtype Context (ReadOnlyT mark r m) = ReadOnlyTCtx { unReadOnlyTCtx :: (mark r, Context m) }
newtype Context (StateT mark s m)
Instance details Defined in Control.FX.Monad.Trans.StateT newtype Context (StateT mark s m) = StateTCtx { unStateTCtx :: (mark s, Context m) }
newtype Context (WriteOnceT mark w m)
Instance details Defined in Control.FX.Monad.Trans.WriteOnceT newtype Context (WriteOnceT mark w m) = WriteOnceTCtx { unWriteOnceTCtx :: (mark (), Context m) }
data Context (WriteOnlyT mark w m)
Instance details Defined in Control.FX.Monad.Trans.WriteOnlyT data Context (WriteOnlyT mark w m) = WriteOnlyTCtx { unWriteOnlyTCtx :: (mark (), Context m) }
data Context (Stack mark f d) Source #
Instance details Defined in Control.FX.Monad.Data.Stack data Context (Stack mark f d) = StackCtx { unStackCtx :: mark (f d) }
newtype Context (AppendOnlyTT mark w t m)
Instance details Defined in Control.FX.Monad.Trans.Trans.AppendOnlyTT newtype Context (AppendOnlyTT mark w t m) = AppendOnlyTTCtx { unAppendOnlyTTCtx :: (mark (), Context (t m)) }
newtype Context (ExceptTT mark e t m)
Instance details Defined in Control.FX.Monad.Trans.Trans.ExceptTT newtype Context (ExceptTT mark e t m) = ExceptTTCtx { unExceptTTCtx :: (mark (), Context (t m)) }
newtype Context (PromptTT mark p t m)
Instance details Defined in Control.FX.Monad.Trans.Trans.PromptTT newtype Context (PromptTT mark p t m) = PromptTTCtx { unPromptTTCtx :: (Eval p m, Context (t m)) }
newtype Context (OverTT v u t m)
Instance details Defined in Control.FX.Monad.Trans.Trans.OverTT newtype Context (OverTT v u t m) = OverTTCtx { unOverTTCtx :: ((InputTT u m, InputT v), Context (t m)) }
newtype Context (ReadOnlyTT mark r t m)
Instance details Defined in Control.FX.Monad.Trans.Trans.ReadOnlyTT newtype Context (ReadOnlyTT mark r t m) = ReadOnlyTTCtx { unReadOnlyTTCtx :: (mark r, Context (t m)) }
newtype Context (StateTT mark s t m)
Instance details Defined in Control.FX.Monad.Trans.Trans.StateTT newtype Context (StateTT mark s t m) = StateTTCtx { unStateTTCtx :: (mark s, Context (t m)) }
newtype Context (WriteOnceTT mark w t m)
Instance details Defined in Control.FX.Monad.Trans.Trans.WriteOnceTT newtype Context (WriteOnceTT mark w t m) = WriteOnceTTCtx { unWriteOnceTTCtx :: (mark (), Context (t m)) }
newtype Context (WriteOnlyTT mark w t m)
Instance details Defined in Control.FX.Monad.Trans.Trans.WriteOnlyTT newtype Context (WriteOnlyTT mark w t m) = WriteOnlyTTCtx { unWriteOnlyTTCtx :: (mark (), Context (t m)) }
newtype Context (StackT mark f d m) Source #
Instance details Defined in Control.FX.Monad.Trans.Data.StackT newtype Context (StackT mark f d m) = StackTCtx { unStackTCtx :: (mark (f d), Context m) }
newtype Context (StackTT mark f d t m) Source #
Instance details Defined in Control.FX.Monad.Trans.Trans.Data.StackTT newtype Context (StackTT mark f d t m) = StackTTCtx { unStackTTCtx :: (mark (f d), Context (t m)) }