Control.FX.IO

Effect Classes

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

Class representing monads which can interact with a teletype-style interface. This is an effects-only typeclass with no laws, so lifting through any transformer is safe.

Minimal complete definition

Nothing

Methods

readLine :: m (mark String)

Read a line of input

readLine :: (Monad m1, MonadTrans t1, m ~ t1 m1, MonadTeletype mark m1) => m (mark String)

Read a line of input

printLine :: mark String -> m ()

Print a line of output

printLine :: (Monad m1, MonadTrans t1, m ~ t1 m1, MonadTeletype mark m1) => mark String -> m ()

Print a line of output

Instances

(Monad m, MonadIdentity mark, MonadTeletype mark m) => MonadTeletype mark (IdentityT m)

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

readLine :: IdentityT m (mark String)

printLine :: mark String -> IdentityT m ()

(Monad m, MonadTrans t, MonadTeletype mark (t m)) => MonadTeletype mark (IdentityTT t m)

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

readLine :: IdentityTT t m (mark String)

printLine :: mark String -> IdentityTT t m ()

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadTeletype mark m) => MonadTeletype mark (HaltT mark1 m)

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

readLine :: HaltT mark1 m (mark String)

printLine :: mark String -> HaltT mark1 m ()

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

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

readLine :: HaltTT mark1 t m (mark String)

printLine :: mark String -> HaltTT mark1 t m ()

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

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

readLine :: StateT mark1 s m (mark String)

printLine :: mark String -> StateT mark1 s m ()

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

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

readLine :: WriteOnceT mark1 w m (mark String)

printLine :: mark String -> WriteOnceT mark1 w m ()

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

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

readLine :: AppendOnlyT mark1 w m (mark String)

printLine :: mark String -> AppendOnlyT mark1 w m ()

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

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

readLine :: WriteOnlyT mark1 w m (mark String)

printLine :: mark String -> WriteOnlyT mark1 w m ()

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

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

readLine :: ReadOnlyT mark1 r m (mark String)

printLine :: mark String -> ReadOnlyT mark1 r m ()

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

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

readLine :: ExceptT mark1 e m (mark String)

printLine :: mark String -> ExceptT mark1 e m ()

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

Defined in Control.FX.Monad.Trans.Trans.IO.SystemClockTT

Methods

readLine :: SystemClockTT mark1 t m (mark String)

printLine :: mark String -> SystemClockTT mark1 t m ()

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

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

readLine :: TeletypeTT mark1 t m (mark String)

printLine :: mark String -> TeletypeTT mark1 t m ()

(Monad m, MonadTrans t, MonadIdentity mark) => MonadTeletype mark (TeletypeTT mark t m)

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

readLine :: TeletypeTT mark t m (mark String)

printLine :: mark String -> TeletypeTT mark t m ()

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

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

readLine :: ExceptTT mark1 e t m (mark String)

printLine :: mark String -> ExceptTT mark1 e t m ()

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

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

readLine :: WriteOnceTT mark1 w t m (mark String)

printLine :: mark String -> WriteOnceTT mark1 w t m ()

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

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

readLine :: AppendOnlyTT mark1 w t m (mark String)

printLine :: mark String -> AppendOnlyTT mark1 w t m ()

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

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

readLine :: WriteOnlyTT mark1 w t m (mark String)

printLine :: mark String -> WriteOnlyTT mark1 w t m ()

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

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

readLine :: ReadOnlyTT mark1 r t m (mark String)

printLine :: mark String -> ReadOnlyTT mark1 r t m ()

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

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

readLine :: StateTT mark1 s t m (mark String)

printLine :: mark String -> StateTT mark1 s t m ()

(Monad m, MonadTrans t, MonadTransTrans u, MonadFunctor w, MonadTeletype mark (u t m), OverableT w) => MonadTeletype mark (OverTT w u t m)

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

readLine :: OverTT w u t m (mark String)

printLine :: mark String -> OverTT w u t m ()

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

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

readLine :: PromptTT mark1 p t m (mark String)

printLine :: mark String -> PromptTT mark1 p t m ()

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

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

readLine :: StackT mark1 f d m (mark String)

printLine :: mark String -> StackT mark1 f d m ()

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, MonadTeletype mark (t m)) => MonadTeletype mark (StackTT mark1 f d t m)

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

readLine :: StackTT mark1 f d t m (mark String)

printLine :: mark String -> StackTT mark1 f d t m ()

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

Class representing monads which have access to the current time in UTC format.

Minimal complete definition

Nothing

Methods

getSystemTime :: m (mark SystemTime)

Get the current SystemTime

getSystemTime :: (Monad m1, MonadTrans t1, m ~ t1 m1, MonadSystemClock mark m1) => m (mark SystemTime)

Get the current SystemTime

Instances

(Monad m, MonadIdentity mark, MonadSystemClock mark m) => MonadSystemClock mark (IdentityT m)

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

getSystemTime :: IdentityT m (mark SystemTime)

(Monad m, MonadTrans t, MonadSystemClock mark (t m)) => MonadSystemClock mark (IdentityTT t m)

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

getSystemTime :: IdentityTT t m (mark SystemTime)

(Monad m, MonadIdentity mark, MonadIdentity mark1, MonadSystemClock mark m) => MonadSystemClock mark (HaltT mark1 m)

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

getSystemTime :: HaltT mark1 m (mark SystemTime)

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

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

getSystemTime :: HaltTT mark1 t m (mark SystemTime)

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

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

getSystemTime :: StateT mark1 s m (mark SystemTime)

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

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

getSystemTime :: WriteOnceT mark1 w m (mark SystemTime)

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

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

getSystemTime :: AppendOnlyT mark1 w m (mark SystemTime)

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

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

getSystemTime :: WriteOnlyT mark1 w m (mark SystemTime)

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

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

getSystemTime :: ReadOnlyT mark1 r m (mark SystemTime)

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

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

getSystemTime :: ExceptT mark1 e m (mark SystemTime)

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

Defined in Control.FX.Monad.Trans.Trans.IO.SystemClockTT

Methods

getSystemTime :: SystemClockTT mark1 t m (mark SystemTime)

(Monad m, MonadTrans t, MonadIdentity mark) => MonadSystemClock mark (SystemClockTT mark t m)

Defined in Control.FX.Monad.Trans.Trans.IO.SystemClockTT

Methods

getSystemTime :: SystemClockTT mark t m (mark SystemTime)

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

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

getSystemTime :: TeletypeTT mark1 t m (mark SystemTime)

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

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

getSystemTime :: ExceptTT mark1 e t m (mark SystemTime)

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

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

getSystemTime :: WriteOnceTT mark1 w t m (mark SystemTime)

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

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

getSystemTime :: AppendOnlyTT mark1 w t m (mark SystemTime)

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

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

getSystemTime :: WriteOnlyTT mark1 w t m (mark SystemTime)

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

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

getSystemTime :: ReadOnlyTT mark1 r t m (mark SystemTime)

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

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

getSystemTime :: StateTT mark1 s t m (mark SystemTime)

(Monad m, MonadTrans t, MonadTransTrans u, MonadFunctor w, MonadSystemClock mark (u t m), OverableT w) => MonadSystemClock mark (OverTT w u t m)

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

getSystemTime :: OverTT w u t m (mark SystemTime)

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

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

getSystemTime :: PromptTT mark1 p t m (mark SystemTime)

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

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

getSystemTime :: StackT mark1 f d m (mark SystemTime)

(Monad m, MonadTrans t, MonadIdentity mark, MonadIdentity mark1, MonadSystemClock mark (t m)) => MonadSystemClock mark (StackTT mark1 f d t m)

Defined in Control.FX.Monad.Trans.Trans.IO.Class

Methods

getSystemTime :: StackTT mark1 f d t m (mark SystemTime)

Concrete Types

Teletype

newtype TeletypeTT (mark :: * -> *) (t :: (* -> *) -> * -> *) (m :: * -> *) (a :: *)

Teletype monad transformer transformer

Constructors

TeletypeTT

Fields

• unTeletypeTT :: OverTT (ExceptT TeletypeError (mark IOException)) (PromptTT mark (TeletypeAction mark)) 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 (TeletypeTT mark1 t m)

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

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

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

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

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

get :: TeletypeTT mark1 t m (mark s)

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

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

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

ask :: TeletypeTT mark1 t m (mark r)

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

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

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

look :: TeletypeTT mark1 t m (mark w)

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

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

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

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

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

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

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

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

(Monad m, MonadTrans t, MonadIdentity mark) => MonadExcept TeletypeError (mark IOException) (TeletypeTT mark t m)

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

throw :: TeletypeError (mark IOException) -> TeletypeTT mark t m a

catch :: TeletypeTT mark t m a -> (TeletypeError (mark IOException) -> TeletypeTT mark t m a) -> TeletypeTT mark t m a

(MonadTrans t, MonadIdentity mark, Monad m) => MonadPrompt mark (TeletypeAction mark) (TeletypeTT mark t m)

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

prompt :: mark (TeletypeAction mark a) -> TeletypeTT mark t m (mark a)

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

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

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

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

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

getSystemTime :: TeletypeTT mark1 t m (mark SystemTime)

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

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

readLine :: TeletypeTT mark1 t m (mark String)

printLine :: mark String -> TeletypeTT mark1 t m ()

(Monad m, MonadTrans t, MonadIdentity mark) => MonadTeletype mark (TeletypeTT mark t m)

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

readLine :: TeletypeTT mark t m (mark String)

printLine :: mark String -> TeletypeTT mark t m ()

(Typeable mark, Typeable t, Typeable m) => Show (Context (TeletypeTT mark t m))

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

showsPrec :: Int -> Context (TeletypeTT mark t m) -> ShowS

show :: Context (TeletypeTT mark t m) -> String

showList :: [Context (TeletypeTT mark t m)] -> ShowS

MonadIdentity mark => MonadTransTrans (TeletypeTT mark)

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

liftT :: (Monad m, MonadTrans t) => t m a -> TeletypeTT mark t m a

(MonadIdentity mark, Commutant mark) => RunMonadTransTrans (TeletypeTT mark)

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Associated Types

data InputTT (TeletypeTT mark) m :: Type

data OutputTT (TeletypeTT mark) a :: Type

Methods

runTT :: (Monad m, MonadTrans t) => InputTT (TeletypeTT mark) m -> TeletypeTT mark t m a -> t m (OutputTT (TeletypeTT mark) a)

(Show a, Show (mark IOException)) => Show (OutputTT (TeletypeTT mark) a)

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

showsPrec :: Int -> OutputTT (TeletypeTT mark) a -> ShowS

show :: OutputTT (TeletypeTT mark) a -> String

showList :: [OutputTT (TeletypeTT mark) a] -> ShowS

(Typeable mark, Typeable m) => Show (InputTT (TeletypeTT mark) m)

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

showsPrec :: Int -> InputTT (TeletypeTT mark) m -> ShowS

show :: InputTT (TeletypeTT mark) m -> String

showList :: [InputTT (TeletypeTT mark) m] -> ShowS

(MonadTrans t, MonadIdentity mark) => MonadTrans (TeletypeTT mark t)

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

lift :: Monad m => m a -> TeletypeTT mark t m a

(MonadTrans t, MonadIdentity mark, Monad m) => Monad (TeletypeTT mark t m)

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

(>>=) :: TeletypeTT mark t m a -> (a -> TeletypeTT mark t m b) -> TeletypeTT mark t m b

(>>) :: TeletypeTT mark t m a -> TeletypeTT mark t m b -> TeletypeTT mark t m b

return :: a -> TeletypeTT mark t m a

fail :: String -> TeletypeTT mark t m a

(MonadTrans t, MonadIdentity mark, Monad m) => Functor (TeletypeTT mark t m)

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

fmap :: (a -> b) -> TeletypeTT mark t m a -> TeletypeTT mark t m b

(<$) :: a -> TeletypeTT mark t m b -> TeletypeTT mark t m a

(MonadTrans t, MonadIdentity mark, Monad m) => Applicative (TeletypeTT mark t m)

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

pure :: a -> TeletypeTT mark t m a

(<*>) :: TeletypeTT mark t m (a -> b) -> TeletypeTT mark t m a -> TeletypeTT mark t m b

liftA2 :: (a -> b -> c) -> TeletypeTT mark t m a -> TeletypeTT mark t m b -> TeletypeTT mark t m c

(*>) :: TeletypeTT mark t m a -> TeletypeTT mark t m b -> TeletypeTT mark t m b

(<*) :: TeletypeTT mark t m a -> TeletypeTT mark t m b -> TeletypeTT mark t m a

(Monad m, MonadTrans t, MonadIdentity mark, Commutant mark, EqIn (t m)) => EqIn (TeletypeTT mark t m)

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Associated Types

data Context (TeletypeTT mark t m) :: Type

Methods

eqIn :: Eq a => Context (TeletypeTT mark t m) -> TeletypeTT mark t m a -> TeletypeTT mark t m a -> Bool

(Typeable mark, Typeable t, Typeable m, Typeable a) => Show (TeletypeTT mark t m a)

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

showsPrec :: Int -> TeletypeTT mark t m a -> ShowS

show :: TeletypeTT mark t m a -> String

showList :: [TeletypeTT mark t m a] -> ShowS

newtype OutputTT (TeletypeTT mark) a

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

newtype OutputTT (TeletypeTT mark) a = TeletypeTTOut {

• unTeletypeTTOut :: Except TeletypeError (mark IOException) a

}

newtype InputTT (TeletypeTT mark) m

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

newtype InputTT (TeletypeTT mark) m = TeletypeTTIn {

• unTeletypeTTIn :: Eval (TeletypeAction mark) m

}

newtype Context (TeletypeTT mark t m)

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

newtype Context (TeletypeTT mark t m) = TeletypeTTCtx {

• unTeletypeTTCtx :: (Eval (TeletypeAction mark) m, Context (t m))

}

runTeletypeTT :: (Monad m, MonadTrans t, MonadIdentity mark, Commutant mark) => Eval (TeletypeAction mark) m -> TeletypeTT mark t m a -> t m (Except TeletypeError (mark IOException) a)

data TeletypeAction mark a where

Type representing atomic teletype actions

Constructors

ReadLine :: TeletypeAction mark (Except TeletypeError (mark IOException) String)

PrintLine :: String -> TeletypeAction mark (Except TeletypeError (mark IOException) ())

Instances

(MonadTrans t, MonadIdentity mark, Monad m) => MonadPrompt mark (TeletypeAction mark) (TeletypeTT mark t m)

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

prompt :: mark (TeletypeAction mark a) -> TeletypeTT mark t m (mark a)

data TeletypeError (a :: *)

Constructors

TeletypeError

Fields

• unTeletypeError :: a

Instances

Monad TeletypeError

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

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

(>>) :: TeletypeError a -> TeletypeError b -> TeletypeError b

return :: a -> TeletypeError a

fail :: String -> TeletypeError a

Functor TeletypeError

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

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

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

Applicative TeletypeError

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

pure :: a -> TeletypeError a

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

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

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

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

MonadIdentity TeletypeError

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

unwrap :: TeletypeError a -> a

(Monad m, MonadTrans t, MonadIdentity mark) => MonadExcept TeletypeError (mark IOException) (TeletypeTT mark t m)

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

throw :: TeletypeError (mark IOException) -> TeletypeTT mark t m a

catch :: TeletypeTT mark t m a -> (TeletypeError (mark IOException) -> TeletypeTT mark t m a) -> TeletypeTT mark t m a

Eq a => Eq (TeletypeError a)

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

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

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

Show a => Show (TeletypeError a)

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

showsPrec :: Int -> TeletypeError a -> ShowS

show :: TeletypeError a -> String

showList :: [TeletypeError a] -> ShowS

Semigroup a => Semigroup (TeletypeError a)

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

(<>) :: TeletypeError a -> TeletypeError a -> TeletypeError a

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

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

Monoid a => Monoid (TeletypeError a)

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

mempty :: TeletypeError a

mappend :: TeletypeError a -> TeletypeError a -> TeletypeError a

mconcat :: [TeletypeError a] -> TeletypeError a

evalTeletypeStdIO :: MonadIdentity mark => TeletypeAction mark a -> IO a

Default IO evaluator

evalTeletypeHandleIO

Arguments

:: MonadIdentity mark

=> Handle

Input

-> Handle

Output

-> TeletypeAction mark a

-> IO a

System Clock

newtype SystemClockTT (mark :: * -> *) (t :: (* -> *) -> * -> *) (m :: * -> *) (a :: *)

System clock monad transformer transformer

Constructors

SystemClockTT

Fields

• unSystemClockTT :: PromptTT mark (SystemClockAction mark) 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 (SystemClockTT mark1 t m)

Defined in Control.FX.Monad.Trans.Trans.IO.SystemClockTT

Methods

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

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

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

Defined in Control.FX.Monad.Trans.Trans.IO.SystemClockTT

Methods

get :: SystemClockTT mark1 t m (mark s)

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

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

Defined in Control.FX.Monad.Trans.Trans.IO.SystemClockTT

Methods

ask :: SystemClockTT mark1 t m (mark r)

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

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

Defined in Control.FX.Monad.Trans.Trans.IO.SystemClockTT

Methods

look :: SystemClockTT mark1 t m (mark w)

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

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

Defined in Control.FX.Monad.Trans.Trans.IO.SystemClockTT

Methods

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

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

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

Defined in Control.FX.Monad.Trans.Trans.IO.SystemClockTT

Methods

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

(MonadTrans t, MonadIdentity mark, Monad m) => MonadPrompt mark (SystemClockAction mark) (SystemClockTT mark t m)

Defined in Control.FX.Monad.Trans.Trans.IO.SystemClockTT

Methods

prompt :: mark (SystemClockAction mark a) -> SystemClockTT mark t m (mark a)

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

Defined in Control.FX.Monad.Trans.Trans.IO.SystemClockTT

Methods

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

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

Defined in Control.FX.Monad.Trans.Trans.IO.SystemClockTT

Methods

getSystemTime :: SystemClockTT mark1 t m (mark SystemTime)

(Monad m, MonadTrans t, MonadIdentity mark) => MonadSystemClock mark (SystemClockTT mark t m)

Defined in Control.FX.Monad.Trans.Trans.IO.SystemClockTT

Methods

getSystemTime :: SystemClockTT mark t m (mark SystemTime)

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

Defined in Control.FX.Monad.Trans.Trans.IO.SystemClockTT

Methods

readLine :: SystemClockTT mark1 t m (mark String)

printLine :: mark String -> SystemClockTT mark1 t m ()

(Typeable mark, Typeable t, Typeable m) => Show (Context (SystemClockTT mark t m))

Defined in Control.FX.Monad.Trans.Trans.IO.SystemClockTT

Methods

showsPrec :: Int -> Context (SystemClockTT mark t m) -> ShowS

show :: Context (SystemClockTT mark t m) -> String

showList :: [Context (SystemClockTT mark t m)] -> ShowS

MonadIdentity mark => MonadTransTrans (SystemClockTT mark)

Defined in Control.FX.Monad.Trans.Trans.IO.SystemClockTT

Methods

liftT :: (Monad m, MonadTrans t) => t m a -> SystemClockTT mark t m a

(MonadIdentity mark, Commutant mark) => RunMonadTransTrans (SystemClockTT mark)

Defined in Control.FX.Monad.Trans.Trans.IO.SystemClockTT

Associated Types

data InputTT (SystemClockTT mark) m :: Type

data OutputTT (SystemClockTT mark) a :: Type

Methods

runTT :: (Monad m, MonadTrans t) => InputTT (SystemClockTT mark) m -> SystemClockTT mark t m a -> t m (OutputTT (SystemClockTT mark) a)

(Show a, Show (mark IOException)) => Show (OutputTT (SystemClockTT mark) a)

Defined in Control.FX.Monad.Trans.Trans.IO.SystemClockTT

Methods

showsPrec :: Int -> OutputTT (SystemClockTT mark) a -> ShowS

show :: OutputTT (SystemClockTT mark) a -> String

showList :: [OutputTT (SystemClockTT mark) a] -> ShowS

(Typeable mark, Typeable m) => Show (InputTT (SystemClockTT mark) m)

Defined in Control.FX.Monad.Trans.Trans.IO.SystemClockTT

Methods

showsPrec :: Int -> InputTT (SystemClockTT mark) m -> ShowS

show :: InputTT (SystemClockTT mark) m -> String

showList :: [InputTT (SystemClockTT mark) m] -> ShowS

(MonadTrans t, MonadIdentity mark) => MonadTrans (SystemClockTT mark t)

Defined in Control.FX.Monad.Trans.Trans.IO.SystemClockTT

Methods

lift :: Monad m => m a -> SystemClockTT mark t m a

(MonadTrans t, MonadIdentity mark, Monad m) => Monad (SystemClockTT mark t m)

Defined in Control.FX.Monad.Trans.Trans.IO.SystemClockTT

Methods

(>>=) :: SystemClockTT mark t m a -> (a -> SystemClockTT mark t m b) -> SystemClockTT mark t m b

(>>) :: SystemClockTT mark t m a -> SystemClockTT mark t m b -> SystemClockTT mark t m b

return :: a -> SystemClockTT mark t m a

fail :: String -> SystemClockTT mark t m a

(MonadTrans t, MonadIdentity mark, Monad m) => Functor (SystemClockTT mark t m)

Defined in Control.FX.Monad.Trans.Trans.IO.SystemClockTT

Methods

fmap :: (a -> b) -> SystemClockTT mark t m a -> SystemClockTT mark t m b

(<$) :: a -> SystemClockTT mark t m b -> SystemClockTT mark t m a

(MonadTrans t, MonadIdentity mark, Monad m) => Applicative (SystemClockTT mark t m)

Defined in Control.FX.Monad.Trans.Trans.IO.SystemClockTT

Methods

pure :: a -> SystemClockTT mark t m a

(<*>) :: SystemClockTT mark t m (a -> b) -> SystemClockTT mark t m a -> SystemClockTT mark t m b

liftA2 :: (a -> b -> c) -> SystemClockTT mark t m a -> SystemClockTT mark t m b -> SystemClockTT mark t m c

(*>) :: SystemClockTT mark t m a -> SystemClockTT mark t m b -> SystemClockTT mark t m b

(<*) :: SystemClockTT mark t m a -> SystemClockTT mark t m b -> SystemClockTT mark t m a

(Monad m, MonadTrans t, MonadIdentity mark, Commutant mark, EqIn (t m)) => EqIn (SystemClockTT mark t m)

Defined in Control.FX.Monad.Trans.Trans.IO.SystemClockTT

Associated Types

data Context (SystemClockTT mark t m) :: Type

Methods

eqIn :: Eq a => Context (SystemClockTT mark t m) -> SystemClockTT mark t m a -> SystemClockTT mark t m a -> Bool

(Typeable mark, Typeable t, Typeable m, Typeable a) => Show (SystemClockTT mark t m a)

Defined in Control.FX.Monad.Trans.Trans.IO.SystemClockTT

Methods

showsPrec :: Int -> SystemClockTT mark t m a -> ShowS

show :: SystemClockTT mark t m a -> String

showList :: [SystemClockTT mark t m a] -> ShowS

newtype OutputTT (SystemClockTT mark) a

Defined in Control.FX.Monad.Trans.Trans.IO.SystemClockTT

newtype OutputTT (SystemClockTT mark) a = SystemClockTTOut {

• unSystemClockTTOut :: a

}

newtype InputTT (SystemClockTT mark) m

Defined in Control.FX.Monad.Trans.Trans.IO.SystemClockTT

newtype InputTT (SystemClockTT mark) m = SystemClockTTIn {

• unSystemClockTTIn :: Eval (SystemClockAction mark) m

}

newtype Context (SystemClockTT mark t m)

Defined in Control.FX.Monad.Trans.Trans.IO.SystemClockTT

newtype Context (SystemClockTT mark t m) = SystemClockTTCtx {

• unSystemClockTTCtx :: (Eval (SystemClockAction mark) m, Context (t m))

}

runSystemClockTT :: (Monad m, MonadTrans t, MonadIdentity mark, Commutant mark) => Eval (SystemClockAction mark) m -> SystemClockTT mark t m a -> t m a

data SystemClockAction (mark :: * -> *) a where

Type representing atomic system clock actions

Constructors

GetSystemTime :: SystemClockAction mark SystemTime

Instances

(MonadTrans t, MonadIdentity mark, Monad m) => MonadPrompt mark (SystemClockAction mark) (SystemClockTT mark t m)

Defined in Control.FX.Monad.Trans.Trans.IO.SystemClockTT

Methods

prompt :: mark (SystemClockAction mark a) -> SystemClockTT mark t m (mark a)

evalSystemTimeIO :: MonadIdentity mark => SystemClockAction mark a -> IO a

Default IO evaluator

Values in Context

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

(Typeable mark, Typeable m) => Show (InputTT (SystemClockTT mark) m)

Defined in Control.FX.Monad.Trans.Trans.IO.SystemClockTT

Methods

showsPrec :: Int -> InputTT (SystemClockTT mark) m -> ShowS

show :: InputTT (SystemClockTT mark) m -> String

showList :: [InputTT (SystemClockTT mark) m] -> ShowS

(Typeable mark, Typeable m) => Show (InputTT (TeletypeTT mark) m)

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

showsPrec :: Int -> InputTT (TeletypeTT mark) m -> ShowS

show :: InputTT (TeletypeTT mark) m -> String

showList :: [InputTT (TeletypeTT mark) 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 (SystemClockTT mark) m

Defined in Control.FX.Monad.Trans.Trans.IO.SystemClockTT

newtype InputTT (SystemClockTT mark) m = SystemClockTTIn {

• unSystemClockTTIn :: Eval (SystemClockAction mark) m

}

newtype InputTT (TeletypeTT mark) m

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

newtype InputTT (TeletypeTT mark) m = TeletypeTTIn {

• unTeletypeTTIn :: Eval (TeletypeAction mark) m

}

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

(Show a, Show (mark IOException)) => Show (OutputTT (SystemClockTT mark) a)

Defined in Control.FX.Monad.Trans.Trans.IO.SystemClockTT

Methods

showsPrec :: Int -> OutputTT (SystemClockTT mark) a -> ShowS

show :: OutputTT (SystemClockTT mark) a -> String

showList :: [OutputTT (SystemClockTT mark) a] -> ShowS

(Show a, Show (mark IOException)) => Show (OutputTT (TeletypeTT mark) a)

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

showsPrec :: Int -> OutputTT (TeletypeTT mark) a -> ShowS

show :: OutputTT (TeletypeTT mark) a -> String

showList :: [OutputTT (TeletypeTT mark) 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 (SystemClockTT mark) a

Defined in Control.FX.Monad.Trans.Trans.IO.SystemClockTT

newtype OutputTT (SystemClockTT mark) a = SystemClockTTOut {

• unSystemClockTTOut :: a

}

newtype OutputTT (TeletypeTT mark) a

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

newtype OutputTT (TeletypeTT mark) a = TeletypeTTOut {

• unTeletypeTTOut :: Except TeletypeError (mark IOException) 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

}

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

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

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

(Typeable mark, Typeable t, Typeable m) => Show (Context (SystemClockTT mark t m))

Defined in Control.FX.Monad.Trans.Trans.IO.SystemClockTT

Methods

showsPrec :: Int -> Context (SystemClockTT mark t m) -> ShowS

show :: Context (SystemClockTT mark t m) -> String

showList :: [Context (SystemClockTT mark t m)] -> ShowS

(Typeable mark, Typeable t, Typeable m) => Show (Context (TeletypeTT mark t m))

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

showsPrec :: Int -> Context (TeletypeTT mark t m) -> ShowS

show :: Context (TeletypeTT mark t m) -> String

showList :: [Context (TeletypeTT mark t m)] -> 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 (SystemClockTT mark t m)

Defined in Control.FX.Monad.Trans.Trans.IO.SystemClockTT

newtype Context (SystemClockTT mark t m) = SystemClockTTCtx {

• unSystemClockTTCtx :: (Eval (SystemClockAction mark) m, Context (t m))

}

newtype Context (TeletypeTT mark t m)

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

newtype Context (TeletypeTT mark t m) = TeletypeTTCtx {

• unTeletypeTTCtx :: (Eval (TeletypeAction mark) m, Context (t m))

}

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

}

Misc

data IOException

Exceptions that occur in the IO monad. An IOException records a more specific error type, a descriptive string and maybe the handle that was used when the error was flagged.

Instances

Eq IOException

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

(==) :: IOException -> IOException -> Bool

(/=) :: IOException -> IOException -> Bool

Show IOException

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

showsPrec :: Int -> IOException -> ShowS

show :: IOException -> String

showList :: [IOException] -> ShowS

Exception IOException

Since: base-4.1.0.0

Defined in GHC.IO.Exception

Methods

toException :: IOException -> SomeException

fromException :: SomeException -> Maybe IOException

displayException :: IOException -> String

(Monad m, MonadTrans t, MonadIdentity mark) => MonadExcept TeletypeError (mark IOException) (TeletypeTT mark t m)

Defined in Control.FX.Monad.Trans.Trans.IO.TeletypeTT

Methods

throw :: TeletypeError (mark IOException) -> TeletypeTT mark t m a

catch :: TeletypeTT mark t m a -> (TeletypeError (mark IOException) -> TeletypeTT mark t m a) -> TeletypeTT mark t m a

data SystemTime

SystemTime is time returned by system clock functions. Its semantics depends on the clock function, but the epoch is typically the beginning of 1970. Note that systemNanoseconds of 1E9 to 2E9-1 can be used to represent leap seconds.

Instances

Eq SystemTime

Defined in Data.Time.Clock.Internal.SystemTime

Methods

(==) :: SystemTime -> SystemTime -> Bool

(/=) :: SystemTime -> SystemTime -> Bool

Ord SystemTime

Defined in Data.Time.Clock.Internal.SystemTime

Methods

compare :: SystemTime -> SystemTime -> Ordering

(<) :: SystemTime -> SystemTime -> Bool

(<=) :: SystemTime -> SystemTime -> Bool

(>) :: SystemTime -> SystemTime -> Bool

(>=) :: SystemTime -> SystemTime -> Bool

max :: SystemTime -> SystemTime -> SystemTime

min :: SystemTime -> SystemTime -> SystemTime

Show SystemTime

Defined in Data.Time.Clock.Internal.SystemTime

Methods

showsPrec :: Int -> SystemTime -> ShowS

show :: SystemTime -> String

showList :: [SystemTime] -> ShowS

NFData SystemTime

Defined in Data.Time.Clock.Internal.SystemTime

Methods

rnf :: SystemTime -> ()