Control.FX.Data

Structure Classes

class Functor t => IsStack t where

Methods

stackInit :: t a

stackPush :: a -> t a -> t a

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

Instances

IsStack []

Defined in Control.FX.Structure.Stack

Methods

stackInit :: [a]

stackPush :: a -> [a] -> [a]

stackPop :: [a] -> Maybe (a, [a])

Effect Classes

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

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

Push a value to the stack

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

Push a value to the stack

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

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

Try to pop a value from the stack

Instances

(Monad m, MonadIdentity mark, MonadStack mark f d m) => MonadStack mark f d (IdentityT m)

Defined in Control.FX.Monad.Data.Class

Methods

push :: Proxy f -> mark d -> IdentityT m ()

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

(Monad m, MonadTrans t, IsStack f, MonadStack mark f d (t m)) => MonadStack mark f d (IdentityTT t m)

Defined in Control.FX.Monad.Data.Class

Methods

push :: Proxy f -> mark d -> IdentityTT t m ()

pop :: Proxy f -> IdentityTT t m (mark (Maybe d))

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadStack mark f d m) => MonadStack mark f d (HaltT mark1 m)

Defined in Control.FX.Monad.Data.Class

Methods

push :: Proxy f -> mark d -> HaltT mark1 m ()

pop :: Proxy f -> HaltT mark1 m (mark (Maybe d))

(Monad m, MonadTrans t, MonadIdentity mark1, MonadStack mark f d (t m), IsStack f) => MonadStack mark f d (HaltTT mark1 t m)

Defined in Control.FX.Monad.Data.Class

Methods

push :: Proxy f -> mark d -> HaltTT mark1 t m ()

pop :: Proxy f -> HaltTT mark1 t m (mark (Maybe d))

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadStack mark f d m) => MonadStack mark f d (StateT mark1 s m)

Defined in Control.FX.Monad.Data.Class

Methods

push :: Proxy f -> mark d -> StateT mark1 s m ()

pop :: Proxy f -> StateT mark1 s m (mark (Maybe d))

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadStack mark f d m) => MonadStack mark f d (WriteOnceT mark1 w m)

Defined in Control.FX.Monad.Data.Class

Methods

push :: Proxy f -> mark d -> WriteOnceT mark1 w m ()

pop :: Proxy f -> WriteOnceT mark1 w m (mark (Maybe d))

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadStack mark f d m, Monoid w) => MonadStack mark f d (AppendOnlyT mark1 w m)

Defined in Control.FX.Monad.Data.Class

Methods

push :: Proxy f -> mark d -> AppendOnlyT mark1 w m ()

pop :: Proxy f -> AppendOnlyT mark1 w m (mark (Maybe d))

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadStack mark f d m, Monoid w) => MonadStack mark f d (WriteOnlyT mark1 w m)

Defined in Control.FX.Monad.Data.Class

Methods

push :: Proxy f -> mark d -> WriteOnlyT mark1 w m ()

pop :: Proxy f -> WriteOnlyT mark1 w m (mark (Maybe d))

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadStack mark f d m) => MonadStack mark f d (ReadOnlyT mark1 r m)

Defined in Control.FX.Monad.Data.Class

Methods

push :: Proxy f -> mark d -> ReadOnlyT mark1 r m ()

pop :: Proxy f -> ReadOnlyT mark1 r m (mark (Maybe d))

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadStack mark f d m) => MonadStack mark f d (ExceptT mark1 e m)

Defined in Control.FX.Monad.Data.Class

Methods

push :: Proxy f -> mark d -> ExceptT mark1 e m ()

pop :: Proxy f -> ExceptT mark1 e m (mark (Maybe d))

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

Defined in Control.FX.Monad.Trans.Data.StackT

Methods

push :: Proxy f -> mark d -> ComposeT t1 t2 m ()

pop :: Proxy f -> ComposeT t1 t2 m (mark (Maybe d))

(Monad m, MonadTrans t2, MonadIdentity mark, IsStack f) => MonadStack mark f d (ComposeT (StackT mark f d) t2 m)

Defined in Control.FX.Monad.Trans.Data.StackT

Methods

push :: Proxy f -> mark d -> ComposeT (StackT mark f d) t2 m ()

pop :: Proxy f -> ComposeT (StackT mark f d) t2 m (mark (Maybe d))

(MonadIdentity mark, IsStack f) => MonadStack mark f d (Stack mark f d)

Defined in Control.FX.Monad.Data.Stack

Methods

push :: Proxy f -> mark d -> Stack mark f d ()

pop :: Proxy f -> Stack mark f d (mark (Maybe d))

(Monad m, MonadTrans t, MonadIdentity mark1, MonadStack mark f d (t m), IsStack f) => MonadStack mark f d (WriteOnceTT mark1 w t m)

Defined in Control.FX.Monad.Data.Class

Methods

push :: Proxy f -> mark d -> WriteOnceTT mark1 w t m ()

pop :: Proxy f -> WriteOnceTT mark1 w t m (mark (Maybe d))

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

Defined in Control.FX.Monad.Data.Class

Methods

push :: Proxy f -> mark d -> AppendOnlyTT mark1 w t m ()

pop :: Proxy f -> AppendOnlyTT mark1 w t m (mark (Maybe d))

(Monad m, MonadTrans t, MonadIdentity mark1, MonadStack mark f d (t m), IsStack f) => MonadStack mark f d (ExceptTT mark1 e t m)

Defined in Control.FX.Monad.Data.Class

Methods

push :: Proxy f -> mark d -> ExceptTT mark1 e t m ()

pop :: Proxy f -> ExceptTT mark1 e t m (mark (Maybe d))

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

Defined in Control.FX.Monad.Data.Class

Methods

push :: Proxy f -> mark d -> WriteOnlyTT mark1 w t m ()

pop :: Proxy f -> WriteOnlyTT mark1 w t m (mark (Maybe d))

(Monad m, MonadTrans t, MonadIdentity mark1, MonadStack mark f d (t m), IsStack f) => MonadStack mark f d (ReadOnlyTT mark1 r t m)

Defined in Control.FX.Monad.Data.Class

Methods

push :: Proxy f -> mark d -> ReadOnlyTT mark1 r t m ()

pop :: Proxy f -> ReadOnlyTT mark1 r t m (mark (Maybe d))

(Monad m, MonadTrans t, MonadIdentity mark1, MonadStack mark f d (t m), IsStack f) => MonadStack mark f d (StateTT mark1 s t m)

Defined in Control.FX.Monad.Data.Class

Methods

push :: Proxy f -> mark d -> StateTT mark1 s t m ()

pop :: Proxy f -> StateTT mark1 s t m (mark (Maybe d))

(Monad m, MonadTrans t, MonadIdentity mark1, MonadStack mark f d (t m), IsStack f) => MonadStack mark f d (PromptTT mark1 p t m)

Defined in Control.FX.Monad.Data.Class

Methods

push :: Proxy f -> mark d -> PromptTT mark1 p t m ()

pop :: Proxy f -> PromptTT mark1 p t m (mark (Maybe d))

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadStack mark f d m, IsStack f) => MonadStack mark f d (StackT mark1 f1 d1 m)

Defined in Control.FX.Monad.Trans.Data.StackT

Methods

push :: Proxy f -> mark d -> StackT mark1 f1 d1 m ()

pop :: Proxy f -> StackT mark1 f1 d1 m (mark (Maybe d))

(Monad m, MonadIdentity mark, IsStack f) => MonadStack mark f d (StackT mark f d m)

Defined in Control.FX.Monad.Trans.Data.StackT

Methods

push :: Proxy f -> mark d -> StackT mark f d m ()

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

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

Defined in Control.FX.Monad.Trans.Data.StackT

Methods

push :: Proxy f -> mark d -> OverTT v u t m ()

pop :: Proxy f -> OverTT v u t m (mark (Maybe d))

(Monad m, MonadTrans t, IsStack f, MonadTransTrans u, MonadIdentity mark) => MonadStack mark f d (OverTT (StackT mark f d) u t m)

Defined in Control.FX.Monad.Trans.Data.StackT

Methods

push :: Proxy f -> mark d -> OverTT (StackT mark f d) u t m ()

pop :: Proxy f -> OverTT (StackT mark f d) u t m (mark (Maybe d))

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

Defined in Control.FX.Monad.Trans.Trans.Data.StackTT

Methods

push :: Proxy f -> mark d -> StackTT mark1 f1 d1 t m ()

pop :: Proxy f -> StackTT mark1 f1 d1 t m (mark (Maybe d))

(Monad m, MonadTrans t, MonadIdentity mark, IsStack f) => MonadStack mark f d (StackTT mark f d t m)

Defined in Control.FX.Monad.Trans.Trans.Data.StackTT

Methods

push :: Proxy f -> mark d -> StackTT mark f d t m ()

pop :: Proxy f -> StackTT mark f d t m (mark (Maybe d))

Concrete Types

Monads

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

Constructors

Stack

Fields

• unStack :: f d -> Pair (f d) a

Instances

(MonadIdentity mark, IsStack f) => MonadStack mark f d (Stack mark f d)

Defined in Control.FX.Monad.Data.Stack

Methods

push :: Proxy f -> mark d -> Stack mark f d ()

pop :: Proxy f -> Stack mark f d (mark (Maybe d))

Eq (mark (f d)) => Eq (Input (Stack mark f d))

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

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

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

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)

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)

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)

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)

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)

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)

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)

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)

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

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)

Defined in Control.FX.Monad.Data.Stack

data Input (Stack mark f d) = StackIn {

• unStackIn :: mark (f d)

}

data Context (Stack mark f d)

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

Transformers

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

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)

Defined in Control.FX.Monad.Trans.Data.StackT

Methods

push :: Proxy f -> mark d -> ComposeT (StackT mark f d) t2 m ()

pop :: Proxy f -> ComposeT (StackT mark f d) t2 m (mark (Maybe d))

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadStack mark f d m, IsStack f) => MonadStack mark f d (StackT mark1 f1 d1 m)

Defined in Control.FX.Monad.Trans.Data.StackT

Methods

push :: Proxy f -> mark d -> StackT mark1 f1 d1 m ()

pop :: Proxy f -> StackT mark1 f1 d1 m (mark (Maybe d))

(Monad m, MonadIdentity mark, IsStack f) => MonadStack mark f d (StackT mark f d m)

Defined in Control.FX.Monad.Trans.Data.StackT

Methods

push :: Proxy f -> mark d -> StackT mark f d m ()

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

(Monad m, MonadTrans t, IsStack f, MonadTransTrans u, MonadIdentity mark) => MonadStack mark f d (OverTT (StackT mark f d) u t m)

Defined in Control.FX.Monad.Trans.Data.StackT

Methods

push :: Proxy f -> mark d -> OverTT (StackT mark f d) u t m ()

pop :: Proxy f -> OverTT (StackT mark f d) u t m (mark (Maybe d))

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadExcept mark e m) => MonadExcept mark e (StackT mark1 f d m)

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)

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)

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)

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)

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)

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)

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)

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

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

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

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

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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

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

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

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)

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)

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)

Transformer Transformers

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

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)

Defined in Control.FX.Monad.Trans.Trans.Data.StackTT

Methods

push :: Proxy f -> mark d -> StackTT mark1 f1 d1 t m ()

pop :: Proxy f -> StackTT mark1 f1 d1 t m (mark (Maybe d))

(Monad m, MonadTrans t, MonadIdentity mark, IsStack f) => MonadStack mark f d (StackTT mark f d t m)

Defined in Control.FX.Monad.Trans.Trans.Data.StackTT

Methods

push :: Proxy f -> mark d -> StackTT mark f d t m ()

pop :: Proxy f -> StackTT mark f d t m (mark (Maybe d))

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

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)

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)

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)

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)

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)

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)

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)

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

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

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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

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

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)

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)

Values in Context

Monads

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

Instances

Eq (Input Maybe)

Defined in Control.FX.Monad.Class

Methods

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

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

Eq (mark ()) => Eq (Input (WriteOnly mark w))

Defined in Control.FX.Monad.WriteOnly

Methods

(==) :: Input (WriteOnly mark w) -> Input (WriteOnly mark w) -> Bool

(/=) :: Input (WriteOnly mark w) -> Input (WriteOnly mark w) -> Bool

Eq (mark ()) => Eq (Input (WriteOnce mark w))

Defined in Control.FX.Monad.WriteOnce

Methods

(==) :: Input (WriteOnce mark w) -> Input (WriteOnce mark w) -> Bool

(/=) :: Input (WriteOnce mark w) -> Input (WriteOnce mark w) -> Bool

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

Defined in Control.FX.Monad.State

Methods

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

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

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

Defined in Control.FX.Monad.ReadOnly

Methods

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

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

Eq (Input Identity)

Defined in Control.FX.Monad.Identity

Methods

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

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

Eq (mark ()) => Eq (Input (Halt mark))

Defined in Control.FX.Monad.Halt

Methods

(==) :: Input (Halt mark) -> Input (Halt mark) -> Bool

(/=) :: Input (Halt mark) -> Input (Halt mark) -> Bool

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

Defined in Control.FX.Monad.Except

Methods

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

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

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

Defined in Control.FX.Monad.Compose

Methods

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

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

Eq (mark ()) => Eq (Input (AppendOnly mark w))

Defined in Control.FX.Monad.AppendOnly

Methods

(==) :: Input (AppendOnly mark w) -> Input (AppendOnly mark w) -> Bool

(/=) :: Input (AppendOnly mark w) -> Input (AppendOnly mark w) -> Bool

Eq (mark (f d)) => Eq (Input (Stack mark f d))

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)

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

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

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

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

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)

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

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

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

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

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

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

Defined in Control.FX.Monad.Class

data Input Maybe = MaybeIn {

• unMaybeIn :: ()

}

data Input Identity

Defined in Control.FX.Monad.Identity

data Input Identity = IdentityIn {

• unIdentityIn :: ()

}

data Input (Halt mark)

Defined in Control.FX.Monad.Halt

data Input (Halt mark) = HaltIn {

• unHaltIn :: mark ()

}

newtype Input (WriteOnly mark w)

Defined in Control.FX.Monad.WriteOnly

newtype Input (WriteOnly mark w) = WriteOnlyIn {

• unWriteOnlyIn :: mark ()

}

newtype Input (WriteOnce mark w)

Defined in Control.FX.Monad.WriteOnce

newtype Input (WriteOnce mark w) = WriteOnceIn {

• unWriteOnceIn :: mark ()

}

data Input (State mark s)

Defined in Control.FX.Monad.State

data Input (State mark s) = StateIn {

• unStateIn :: mark s

}

newtype Input (ReadOnly mark r)

Defined in Control.FX.Monad.ReadOnly

newtype Input (ReadOnly mark r) = ReadOnlyIn {

• unReadOnlyIn :: mark r

}

newtype Input (Except mark e)

Defined in Control.FX.Monad.Except

newtype Input (Except mark e) = ExceptIn {

• unExceptIn :: mark ()

}

newtype Input (Compose m1 m2)

Defined in Control.FX.Monad.Compose

newtype Input (Compose m1 m2) = ComposeIn {

• unComposeIn :: (Input m1, Input m2)

}

newtype Input (AppendOnly mark w)

Defined in Control.FX.Monad.AppendOnly

newtype Input (AppendOnly mark w) = AppendOnlyIn {

• unAppendOnlyIn :: mark ()

}

data Input (Stack mark f d)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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

Defined in Control.FX.Monad.Class

data Output Maybe a = MaybeOut {

• unMaybeOut :: Maybe a

}

data Output Identity a

Defined in Control.FX.Monad.Identity

data Output Identity a = IdentityOut {

• unIdentityOut :: Identity a

}

data Output (Halt mark) a

Defined in Control.FX.Monad.Halt

data Output (Halt mark) a = HaltOut {

• unHaltOut :: Halt mark a

}

newtype Output (WriteOnly mark w) a

Defined in Control.FX.Monad.WriteOnly

newtype Output (WriteOnly mark w) a = WriteOnlyOut {

• unWriteOnlyOut :: Pair (mark w) a

}

newtype Output (WriteOnce mark w) a

Defined in Control.FX.Monad.WriteOnce

newtype Output (WriteOnce mark w) a = WriteOnceOut {

• unWriteOnceOut :: Pair (mark (Maybe w)) a

}

data Output (State mark s) a

Defined in Control.FX.Monad.State

data Output (State mark s) a = StateOut {

• unStateOut :: Pair (mark s) a

}

newtype Output (ReadOnly mark r) a

Defined in Control.FX.Monad.ReadOnly

newtype Output (ReadOnly mark r) a = ReadOnlyOut {

• unReadOnlyOut :: mark a

}

newtype Output (Except mark e) a

Defined in Control.FX.Monad.Except

newtype Output (Except mark e) a = ExceptOut {

• unExceptOut :: Except mark e a

}

newtype Output (Compose m1 m2) a

Defined in Control.FX.Monad.Compose

newtype Output (Compose m1 m2) a = ComposeOut {

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

}

newtype Output (AppendOnly mark w) a

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

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

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

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

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

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)

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

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

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

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

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

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

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

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

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

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)

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

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

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

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

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

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

Defined in Control.FX.Monad.Trans.IdentityT

data InputT IdentityT = IdentityTIn {

• unIdentityTIn :: ()

}

newtype InputT (HaltT mark)

Defined in Control.FX.Monad.Trans.HaltT

newtype InputT (HaltT mark) = HaltTIn {

• unHaltTIn :: mark ()

}

newtype InputT (ComposeT t1 t2)

Defined in Control.FX.Monad.Trans.ComposeT

newtype InputT (ComposeT t1 t2) = ComposeTIn {

• unComposeTIn :: (InputT t1, InputT t2)

}

newtype InputT (AppendOnlyT mark w)

Defined in Control.FX.Monad.Trans.AppendOnlyT

newtype InputT (AppendOnlyT mark w) = AppendOnlyTIn {

• unAppendOnlyTIn :: mark ()

}

newtype InputT (ExceptT mark e)

Defined in Control.FX.Monad.Trans.ExceptT

newtype InputT (ExceptT mark e) = ExceptTIn {

• unExceptTIn :: mark ()

}

newtype InputT (ReadOnlyT mark r)

Defined in Control.FX.Monad.Trans.ReadOnlyT

newtype InputT (ReadOnlyT mark r) = ReadOnlyTIn {

• unReadOnlyTIn :: mark r

}

newtype InputT (StateT mark s)

Defined in Control.FX.Monad.Trans.StateT

newtype InputT (StateT mark s) = StateTIn {

• unStateTIn :: mark s

}

newtype InputT (WriteOnceT mark w)

Defined in Control.FX.Monad.Trans.WriteOnceT

newtype InputT (WriteOnceT mark w) = WriteOnceTIn {

• unWriteOnceTIn :: mark ()

}

data InputT (WriteOnlyT mark w)

Defined in Control.FX.Monad.Trans.WriteOnlyT

data InputT (WriteOnlyT mark w) = WriteOnlyTIn {

• unWriteOnlyTIn :: mark ()

}

newtype InputT (StackT mark f d)

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

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

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

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

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

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

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

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

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

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

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

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

sconcat :: NonEmpty (OutputT (ReadOnlyT mark r) a) -> OutputT (ReadOnlyT mark r) a

stimes :: Integral b => b -> OutputT (ReadOnlyT mark r) a -> OutputT (ReadOnlyT mark r) a

(Monoid a, MonadIdentity mark) => Monoid (OutputT (ReadOnlyT mark r) a)

Defined in Control.FX.Monad.Trans.ReadOnlyT

Methods

mempty :: OutputT (ReadOnlyT mark r) a

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

mconcat :: [OutputT (ReadOnlyT mark r) a] -> OutputT (ReadOnlyT mark r) a

data OutputT IdentityT a

Defined in Control.FX.Monad.Trans.IdentityT

data OutputT IdentityT a = IdentityTOut {

• unIdentityTOut :: Identity a

}

newtype OutputT (HaltT mark) a

Defined in Control.FX.Monad.Trans.HaltT

newtype OutputT (HaltT mark) a = HaltTOut {

• unHaltTOut :: Halt mark a

}

newtype OutputT (ComposeT t1 t2) a

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

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

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

Defined in Control.FX.Monad.Trans.ReadOnlyT

newtype OutputT (ReadOnlyT mark r) a = ReadOnlyTOut {

• unReadOnlyTOut :: mark a

}

newtype OutputT (StateT mark s) a

Defined in Control.FX.Monad.Trans.StateT

newtype OutputT (StateT mark s) a = StateTOut {

• unStateTOut :: Pair (mark s) a

}

newtype OutputT (WriteOnceT mark w) a

Defined in Control.FX.Monad.Trans.WriteOnceT

newtype OutputT (WriteOnceT mark w) a = WriteOnceTOut {

• unWriteOnceTOut :: Pair (mark (Maybe w)) a

}

data OutputT (WriteOnlyT mark w) a

Defined in Control.FX.Monad.Trans.WriteOnlyT

data OutputT (WriteOnlyT mark w) a = WriteOnlyTOut {

• unWriteOnlyTOut :: Pair (mark w) a

}

newtype OutputT (StackT mark f d) a

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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

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

newtype InputTT IdentityTT m = IdentityTTIn {

• unIdentityTTIn :: ()

}

newtype InputTT (HaltTT mark) m

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

newtype InputTT (HaltTT mark) m = HaltTTIn {

• unHaltTTIn :: mark ()

}

newtype InputTT (AppendOnlyTT mark w) m

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

newtype InputTT (AppendOnlyTT mark w) m = AppendOnlyTTIn {

• unAppendOnlyTTIn :: mark ()

}

newtype InputTT (ExceptTT mark e) m

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

newtype InputTT (ExceptTT mark e) m = ExceptTTIn {

• unExceptTTIn :: mark ()

}

newtype InputTT (PromptTT mark p) m

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

newtype InputTT (PromptTT mark p) m = PromptTTIn {

• unPromptTTIn :: Eval p m

}

newtype InputTT (OverTT v u) m

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

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

newtype InputTT (ReadOnlyTT mark r) m = ReadOnlyTTIn {

• unReadOnlyTTIn :: mark r

}

newtype InputTT (StateTT mark s) m

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

newtype InputTT (StateTT mark s) m = StateTTIn {

• unStateTTIn :: mark s

}

newtype InputTT (WriteOnceTT mark w) m

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

newtype InputTT (WriteOnceTT mark w) m = WriteOnceTTIn {

• unWriteOnceTTIn :: mark ()

}

newtype InputTT (WriteOnlyTT mark w) m

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

newtype InputTT (WriteOnlyTT mark w) m = WriteOnlyTTIn {

• unWriteOnlyTTIn :: mark ()

}

newtype InputTT (StackTT mark f d) m

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

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

Methods

(>>=) :: OutputTT (PromptTT mark p) a -> (a -> OutputTT (PromptTT mark p) b) -> OutputTT (PromptTT mark p) b

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

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

fail :: String -> OutputTT (PromptTT mark p) a

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

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

Methods

fmap :: (a -> b) -> OutputTT (PromptTT mark p) a -> OutputTT (PromptTT mark p) b

(<$) :: a -> OutputTT (PromptTT mark p) b -> OutputTT (PromptTT mark p) a

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

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

Methods

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

(<*>) :: OutputTT (PromptTT mark p) (a -> b) -> OutputTT (PromptTT mark p) a -> OutputTT (PromptTT mark p) b

liftA2 :: (a -> b -> c) -> OutputTT (PromptTT mark p) a -> OutputTT (PromptTT mark p) b -> OutputTT (PromptTT mark p) c

(*>) :: OutputTT (PromptTT mark p) a -> OutputTT (PromptTT mark p) b -> OutputTT (PromptTT mark p) b

(<*) :: OutputTT (PromptTT mark p) a -> OutputTT (PromptTT mark p) b -> OutputTT (PromptTT mark p) a

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

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

Methods

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

(Eq (mark w), Eq a) => Eq (OutputTT (AppendOnlyTT mark w) a)

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

Methods

(==) :: OutputTT (AppendOnlyTT mark w) a -> OutputTT (AppendOnlyTT mark w) a -> Bool

(/=) :: OutputTT (AppendOnlyTT mark w) a -> OutputTT (AppendOnlyTT mark w) a -> Bool

(Eq e, Eq a) => Eq (OutputTT (ExceptTT mark e) a)

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

Methods

(==) :: OutputTT (ExceptTT mark e) a -> OutputTT (ExceptTT mark e) a -> Bool

(/=) :: OutputTT (ExceptTT mark e) a -> OutputTT (ExceptTT mark e) a -> Bool

(Eq (mark ()), Eq a) => Eq (OutputTT (HaltTT mark) a)

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

Methods

(==) :: OutputTT (HaltTT mark) a -> OutputTT (HaltTT mark) a -> Bool

(/=) :: OutputTT (HaltTT mark) a -> OutputTT (HaltTT mark) a -> Bool

Eq (mark a) => Eq (OutputTT (PromptTT mark p) a)

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

Methods

(==) :: OutputTT (PromptTT mark p) a -> OutputTT (PromptTT mark p) a -> Bool

(/=) :: OutputTT (PromptTT mark p) a -> OutputTT (PromptTT mark p) a -> Bool

Eq a => Eq (OutputTT IdentityTT a)

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

Methods

(==) :: OutputTT IdentityTT a -> OutputTT IdentityTT a -> Bool

(/=) :: OutputTT IdentityTT a -> OutputTT IdentityTT a -> Bool

(Eq (OutputTT u a), Eq (OutputTT u (OutputT v a))) => Eq (OutputTT (OverTT v u) a)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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

Methods

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

sconcat :: NonEmpty (OutputTT (PromptTT mark p) a) -> OutputTT (PromptTT mark p) a

stimes :: Integral b => b -> OutputTT (PromptTT mark p) a -> OutputTT (PromptTT mark p) a

(MonadIdentity mark, Monoid a) => Monoid (OutputTT (PromptTT mark p) a)

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

Methods

mempty :: OutputTT (PromptTT mark p) a

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

mconcat :: [OutputTT (PromptTT mark p) a] -> OutputTT (PromptTT mark p) a

newtype OutputTT IdentityTT a

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

newtype OutputTT IdentityTT a = IdentityTTOut {

• unIdentityTTOut :: Identity a

}

newtype OutputTT (HaltTT mark) a

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

newtype OutputTT (HaltTT mark) a = HaltTTOut {

• unHaltTTOut :: Halt mark a

}

newtype OutputTT (AppendOnlyTT mark w) a

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

newtype OutputTT (AppendOnlyTT mark w) a = AppendOnlyTTOut {

• unAppendOnlyTTOut :: Pair (mark w) a

}

newtype OutputTT (ExceptTT mark e) a

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

newtype OutputTT (ExceptTT mark e) a = ExceptTTOut {

• unExceptTTOut :: Except mark e a

}

newtype OutputTT (PromptTT mark p) a

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

newtype OutputTT (PromptTT mark p) a = PromptTTOut {

• unPromptTTOut :: mark a

}

newtype OutputTT (OverTT v u) a

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

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

newtype OutputTT (ReadOnlyTT mark r) a = ReadOnlyTTOut {

• unReadOnlyTTOut :: mark a

}

newtype OutputTT (StateTT mark s) a

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

newtype OutputTT (StateTT mark s) a = StateTTOut {

• unStateTTOut :: Pair (mark s) a

}

newtype OutputTT (WriteOnceTT mark w) a

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

newtype OutputTT (WriteOnceTT mark w) a = WriteOnceTTOut {

• unWriteOnceTTOut :: Pair (mark (Maybe w)) a

}

newtype OutputTT (WriteOnlyTT mark w) a

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

newtype OutputTT (WriteOnlyTT mark w) a = WriteOnlyTTOut {

• unWriteOnlyTTOut :: Pair (mark w) a

}

newtype OutputTT (StackTT mark f d) a

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)

Defined in Control.FX.EqIn

Methods

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

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

Eq (Context (Either a))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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)

Defined in Control.FX.Monad.Identity

Methods

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

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

Eq (mark ()) => Eq (Context (Halt mark))

Defined in Control.FX.Monad.Halt

Methods

(==) :: Context (Halt mark) -> Context (Halt mark) -> Bool

(/=) :: Context (Halt mark) -> Context (Halt mark) -> Bool

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

Defined in Control.FX.Monad.Except

Methods

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

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

Eq (mark ()) => Eq (Context (AppendOnly mark w))

Defined in Control.FX.Monad.AppendOnly

Methods

(==) :: Context (AppendOnly mark w) -> Context (AppendOnly mark w) -> Bool

(/=) :: Context (AppendOnly mark w) -> Context (AppendOnly mark w) -> Bool

Eq (Context RightZero)

Defined in Control.FX.Functor.RightZero

Methods

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

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

Eq (Context (Pair a))

Defined in Control.FX.Functor.Pair

Methods

(==) :: Context (Pair a) -> Context (Pair a) -> Bool

(/=) :: Context (Pair a) -> Context (Pair a) -> Bool

Eq (Context LeftZero)

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

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

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

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)

Defined in Control.FX.EqIn

Methods

showsPrec :: Int -> Context Maybe -> ShowS

show :: Context Maybe -> String

showList :: [Context Maybe] -> ShowS

Show (Context (Either a))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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)

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

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

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

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)

Defined in Control.FX.Functor.RightZero

Methods

showsPrec :: Int -> Context RightZero -> ShowS

show :: Context RightZero -> String

showList :: [Context RightZero] -> ShowS

Show (Context (Pair a))

Defined in Control.FX.Functor.Pair

Methods

showsPrec :: Int -> Context (Pair a) -> ShowS

show :: Context (Pair a) -> String

showList :: [Context (Pair a)] -> ShowS

Show (Context LeftZero)

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

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

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

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

Defined in Control.FX.EqIn

data Context Maybe = MaybeCtx {

• unMaybeCtx :: ()

}

data Context Identity

Defined in Control.FX.Monad.Identity

data Context Identity = IdentityCtx {

• unIdentityCtx :: ()

}

newtype Context RightZero

Defined in Control.FX.Functor.RightZero

newtype Context RightZero = RightZeroCtx {

• unRightZeroCtx :: ()

}

newtype Context LeftZero

Defined in Control.FX.Functor.LeftZero

newtype Context LeftZero = LeftZeroCtx {

• unLeftZeroCtx :: ()

}

data Context (Either a)

Defined in Control.FX.EqIn

data Context (Either a) = EitherCtx {

• unEitherCtx :: ()

}

data Context (IdentityT m)

Defined in Control.FX.Monad.Trans.IdentityT

data Context (IdentityT m) = IdentityTCtx {

• unIdentityTCtx :: Context m

}

data Context (Halt mark)

Defined in Control.FX.Monad.Halt

data Context (Halt mark) = HaltCtx {

• unHaltCtx :: mark ()

}

newtype Context (Pair a)

Defined in Control.FX.Functor.Pair

newtype Context (Pair a) = PairCtx {

• unPairCtx :: ()

}

newtype Context (IdentityTT t m)

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

newtype Context (IdentityTT t m) = IdentityTTCtx {

• unIdentityTTCtx :: Context (t m)

}

newtype Context (HaltT mark m)

Defined in Control.FX.Monad.Trans.HaltT

newtype Context (HaltT mark m) = HaltTCtx {

• unHaltTCtx :: (mark (), Context m)

}

newtype Context (WriteOnly mark w)

Defined in Control.FX.Monad.WriteOnly

newtype Context (WriteOnly mark w) = WriteOnlyCtx {

• unWriteOnlyCtx :: mark ()

}

newtype Context (WriteOnce mark w)

Defined in Control.FX.Monad.WriteOnce

newtype Context (WriteOnce mark w) = WriteOnceCtx {

• unWriteOnceCtx :: mark ()

}

data Context (State mark s)

Defined in Control.FX.Monad.State

data Context (State mark s) = StateCtx {

• unStateCtx :: mark s

}

newtype Context (ReadOnly mark r)

Defined in Control.FX.Monad.ReadOnly

newtype Context (ReadOnly mark r) = ReadOnlyCtx {

• unReadOnlyCtx :: mark r

}

newtype Context (Except mark e)

Defined in Control.FX.Monad.Except

newtype Context (Except mark e) = ExceptCtx {

• unExceptCtx :: mark ()

}

newtype Context (AppendOnly mark w)

Defined in Control.FX.Monad.AppendOnly

newtype Context (AppendOnly mark w) = AppendOnlyCtx {

• unAppendOnlyCtx :: mark ()

}

newtype Context (HaltTT mark t m)

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

newtype Context (HaltTT mark t m) = HaltTTCtx {

• unHaltTTCtx :: (mark (), Context (t m))

}

newtype Context (ComposeT t1 t2 m)

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)

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)

Defined in Control.FX.Monad.Trans.ExceptT

newtype Context (ExceptT mark e m) = ExceptTCtx {

• unExceptTCtx :: (mark (), Context m)

}

newtype Context (ReadOnlyT mark r m)

Defined in Control.FX.Monad.Trans.ReadOnlyT

newtype Context (ReadOnlyT mark r m) = ReadOnlyTCtx {

• unReadOnlyTCtx :: (mark r, Context m)

}

newtype Context (StateT mark s m)

Defined in Control.FX.Monad.Trans.StateT

newtype Context (StateT mark s m) = StateTCtx {

• unStateTCtx :: (mark s, Context m)

}

newtype Context (WriteOnceT mark w m)

Defined in Control.FX.Monad.Trans.WriteOnceT

newtype Context (WriteOnceT mark w m) = WriteOnceTCtx {

• unWriteOnceTCtx :: (mark (), Context m)

}

data Context (WriteOnlyT mark w m)

Defined in Control.FX.Monad.Trans.WriteOnlyT

data Context (WriteOnlyT mark w m) = WriteOnlyTCtx {

• unWriteOnlyTCtx :: (mark (), Context m)

}

data Context (Stack mark f d)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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

}