Vgrep.Type

The VgrepT monad transformer allows reading from the Environment and changing the state of the App or a Widget.

The VgrepT monad transformer

data VgrepT s m a

The VgrepT monad transformer is parameterized over the state s of a Widget or an App.

Instances

Monad m => MonadReader Environment (VgrepT s m)

VgrepT can read from the Environment. Modifications to the enviromnent are only possible globally (see modifyEnvironment), the local environment is pure.

Defined in Vgrep.Type

Methods

ask :: VgrepT s m Environment

local :: (Environment -> Environment) -> VgrepT s m a -> VgrepT s m a

reader :: (Environment -> a) -> VgrepT s m a

Monad m => MonadState s (VgrepT s m)

Defined in Vgrep.Type

Methods

get :: VgrepT s m s

put :: s -> VgrepT s m ()

state :: (s -> (a, s)) -> VgrepT s m a

MonadTrans (VgrepT s)

Defined in Vgrep.Type

Methods

lift :: Monad m => m a -> VgrepT s m a

MFunctor (VgrepT s :: (Type -> Type) -> Type -> Type)

Defined in Vgrep.Type

Methods

hoist :: forall m n (b :: k). Monad m => (forall a. m a -> n a) -> VgrepT s m b -> VgrepT s n b

Monad m => Monad (VgrepT s m)

Defined in Vgrep.Type

Methods

(>>=) :: VgrepT s m a -> (a -> VgrepT s m b) -> VgrepT s m b

(>>) :: VgrepT s m a -> VgrepT s m b -> VgrepT s m b

return :: a -> VgrepT s m a

Functor m => Functor (VgrepT s m)

Defined in Vgrep.Type

Methods

fmap :: (a -> b) -> VgrepT s m a -> VgrepT s m b

(<$) :: a -> VgrepT s m b -> VgrepT s m a

Monad m => Applicative (VgrepT s m)

Defined in Vgrep.Type

Methods

pure :: a -> VgrepT s m a

(<*>) :: VgrepT s m (a -> b) -> VgrepT s m a -> VgrepT s m b

liftA2 :: (a -> b -> c) -> VgrepT s m a -> VgrepT s m b -> VgrepT s m c

(*>) :: VgrepT s m a -> VgrepT s m b -> VgrepT s m b

(<*) :: VgrepT s m a -> VgrepT s m b -> VgrepT s m a

MonadIO m => MonadIO (VgrepT s m)

Defined in Vgrep.Type

Methods

liftIO :: IO a -> VgrepT s m a

Monad m => Zoom (VgrepT s m) (VgrepT t m) s t

Defined in Vgrep.Type

Methods

zoom :: LensLike' (Zoomed (VgrepT s m) c) t s -> VgrepT s m c -> VgrepT t m c

type Zoomed (VgrepT s m)

Defined in Vgrep.Type

type Zoomed (VgrepT s m) = Zoomed (StateT s (StateT Environment m))

type Vgrep s = VgrepT s Identity

mkVgrepT :: Monad m => (s -> Environment -> m (a, s)) -> VgrepT s m a

Lift a monadic action to VgrepT.

runVgrepT :: Monad m => VgrepT s m a -> s -> Environment -> m (a, s)

Pass an initial state and an Environment and reduce a VgrepT action to an action in the base monad.

Modifying the environment

modifyEnvironment :: Monad m => (Environment -> Environment) -> VgrepT s m ()

The Environment of VgrepT is not stateful, however it can be modified globally. An example is resizing the application by changing the display bounds.

Utilities

vgrepBracket :: IO a -> (a -> IO c) -> (a -> VgrepT s IO b) -> VgrepT s IO b

A version of bracket where the action is lifted to VgrepT.

Re-exports

lift :: (MonadTrans t, Monad m) => m a -> t m a

Lift a computation from the argument monad to the constructed monad.

hoist :: forall m n (b :: k). (MFunctor t, Monad m) => (forall a. m a -> n a) -> t m b -> t n b

Lift a monad morphism from m to n into a monad morphism from (t m) to (t n)

The first argument to hoist must be a monad morphism, even though the type system does not enforce this

module Vgrep.Environment

modify :: MonadState s m => (s -> s) -> m ()

Monadic state transformer.

Maps an old state to a new state inside a state monad. The old state is thrown away.

     Main> :t modify ((+1) :: Int -> Int)
     modify (...) :: (MonadState Int a) => a ()

This says that modify (+1) acts over any Monad that is a member of the MonadState class, with an Int state.

class Monad m => MonadReader r (m :: Type -> Type) | m -> r where

See examples in Control.Monad.Reader. Note, the partially applied function type (->) r is a simple reader monad. See the instance declaration below.

Minimal complete definition

(ask | reader), local

Methods

ask :: m r

Retrieves the monad environment.

local

Arguments

:: (r -> r)

The function to modify the environment.

-> m a

Reader to run in the modified environment.

-> m a

Executes a computation in a modified environment.

Instances

MonadReader i m => MonadReader i (ListT m)

Defined in Pipes

Methods

ask :: ListT m i

local :: (i -> i) -> ListT m a -> ListT m a

reader :: (i -> a) -> ListT m a

MonadReader r m => MonadReader r (ResourceT m)

Defined in Control.Monad.Trans.Resource.Internal

Methods

ask :: ResourceT m r

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

reader :: (r -> a) -> ResourceT m a

MonadReader r m => MonadReader r (MaybeT m)

Defined in Control.Monad.Reader.Class

Methods

ask :: MaybeT m r

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

reader :: (r -> a) -> MaybeT m a

MonadReader r m => MonadReader r (ListT m)

Defined in Control.Monad.Reader.Class

Methods

ask :: ListT m r

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

reader :: (r -> a) -> ListT m a

(Monoid w, MonadReader r m) => MonadReader r (WriterT w m)

Defined in Control.Monad.Reader.Class

Methods

ask :: WriterT w m r

local :: (r -> r) -> WriterT w m a -> WriterT w m a

reader :: (r -> a) -> WriterT w m a

(Monoid w, MonadReader r m) => MonadReader r (WriterT w m)

Defined in Control.Monad.Reader.Class

Methods

ask :: WriterT w m r

local :: (r -> r) -> WriterT w m a -> WriterT w m a

reader :: (r -> a) -> WriterT w m a

MonadReader r m => MonadReader r (StateT s m)

Defined in Control.Monad.Reader.Class

Methods

ask :: StateT s m r

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

reader :: (r -> a) -> StateT s m a

MonadReader r m => MonadReader r (StateT s m)

Defined in Control.Monad.Reader.Class

Methods

ask :: StateT s m r

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

reader :: (r -> a) -> StateT s m a

Monad m => MonadReader r (ReaderT r m)

Defined in Control.Monad.Reader.Class

Methods

ask :: ReaderT r m r

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

reader :: (r -> a) -> ReaderT r m a

MonadReader r m => MonadReader r (IdentityT m)

Defined in Control.Monad.Reader.Class

Methods

ask :: IdentityT m r

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

reader :: (r -> a) -> IdentityT m a

MonadReader r m => MonadReader r (ExceptT e m)

Since: mtl-2.2

Defined in Control.Monad.Reader.Class

Methods

ask :: ExceptT e m r

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

reader :: (r -> a) -> ExceptT e m a

(Error e, MonadReader r m) => MonadReader r (ErrorT e m)

Defined in Control.Monad.Reader.Class

Methods

ask :: ErrorT e m r

local :: (r -> r) -> ErrorT e m a -> ErrorT e m a

reader :: (r -> a) -> ErrorT e m a

Monad m => MonadReader Environment (VgrepT s m)

VgrepT can read from the Environment. Modifications to the enviromnent are only possible globally (see modifyEnvironment), the local environment is pure.

Defined in Vgrep.Type

Methods

ask :: VgrepT s m Environment

local :: (Environment -> Environment) -> VgrepT s m a -> VgrepT s m a

reader :: (Environment -> a) -> VgrepT s m a

MonadReader r ((->) r :: Type -> Type)

Defined in Control.Monad.Reader.Class

Methods

ask :: r -> r

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

reader :: (r -> a) -> r -> a

MonadReader r m => MonadReader r (ConduitT i o m)

Defined in Data.Conduit.Internal.Conduit

Methods

ask :: ConduitT i o m r

local :: (r -> r) -> ConduitT i o m a -> ConduitT i o m a

reader :: (r -> a) -> ConduitT i o m a

MonadReader r' m => MonadReader r' (ContT r m)

Defined in Control.Monad.Reader.Class

Methods

ask :: ContT r m r'

local :: (r' -> r') -> ContT r m a -> ContT r m a

reader :: (r' -> a) -> ContT r m a

(Monad m, Monoid w) => MonadReader r (RWST r w s m)

Defined in Control.Monad.Reader.Class

Methods

ask :: RWST r w s m r

local :: (r -> r) -> RWST r w s m a -> RWST r w s m a

reader :: (r -> a) -> RWST r w s m a

(Monad m, Monoid w) => MonadReader r (RWST r w s m)

Defined in Control.Monad.Reader.Class

Methods

ask :: RWST r w s m r

local :: (r -> r) -> RWST r w s m a -> RWST r w s m a

reader :: (r -> a) -> RWST r w s m a

MonadReader r m => MonadReader r (Proxy a' a b' b m)

Defined in Pipes.Internal

Methods

ask :: Proxy a' a b' b m r

local :: (r -> r) -> Proxy a' a b' b m a0 -> Proxy a' a b' b m a0

reader :: (r -> a0) -> Proxy a' a b' b m a0

MonadReader r m => MonadReader r (Pipe l i o u m)

Defined in Data.Conduit.Internal.Pipe

Methods

ask :: Pipe l i o u m r

local :: (r -> r) -> Pipe l i o u m a -> Pipe l i o u m a

reader :: (r -> a) -> Pipe l i o u m a

class Monad m => MonadState s (m :: Type -> Type) | m -> s where

Minimal definition is either both of get and put or just state

Minimal complete definition

state | get, put

Methods

get :: m s

Return the state from the internals of the monad.

put :: s -> m ()

Replace the state inside the monad.

Instances

MonadState s m => MonadState s (MaybeT m)

Defined in Control.Monad.State.Class

Methods

get :: MaybeT m s

put :: s -> MaybeT m ()

state :: (s -> (a, s)) -> MaybeT m a

MonadState s m => MonadState s (ListT m)

Defined in Control.Monad.State.Class

Methods

get :: ListT m s

put :: s -> ListT m ()

state :: (s -> (a, s)) -> ListT m a

MonadState s m => MonadState s (ListT m)

Defined in Pipes

Methods

get :: ListT m s

put :: s -> ListT m ()

state :: (s -> (a, s)) -> ListT m a

MonadState s m => MonadState s (ResourceT m)

Defined in Control.Monad.Trans.Resource.Internal

Methods

get :: ResourceT m s

put :: s -> ResourceT m ()

state :: (s -> (a, s)) -> ResourceT m a

(Monoid w, MonadState s m) => MonadState s (WriterT w m)

Defined in Control.Monad.State.Class

Methods

get :: WriterT w m s

put :: s -> WriterT w m ()

state :: (s -> (a, s)) -> WriterT w m a

(Monoid w, MonadState s m) => MonadState s (WriterT w m)

Defined in Control.Monad.State.Class

Methods

get :: WriterT w m s

put :: s -> WriterT w m ()

state :: (s -> (a, s)) -> WriterT w m a

Monad m => MonadState s (StateT s m)

Defined in Control.Monad.State.Class

Methods

get :: StateT s m s

put :: s -> StateT s m ()

state :: (s -> (a, s)) -> StateT s m a

Monad m => MonadState s (StateT s m)

Defined in Control.Monad.State.Class

Methods

get :: StateT s m s

put :: s -> StateT s m ()

state :: (s -> (a, s)) -> StateT s m a

MonadState s m => MonadState s (ReaderT r m)

Defined in Control.Monad.State.Class

Methods

get :: ReaderT r m s

put :: s -> ReaderT r m ()

state :: (s -> (a, s)) -> ReaderT r m a

MonadState s m => MonadState s (IdentityT m)

Defined in Control.Monad.State.Class

Methods

get :: IdentityT m s

put :: s -> IdentityT m ()

state :: (s -> (a, s)) -> IdentityT m a

MonadState s m => MonadState s (ExceptT e m)

Since: mtl-2.2

Defined in Control.Monad.State.Class

Methods

get :: ExceptT e m s

put :: s -> ExceptT e m ()

state :: (s -> (a, s)) -> ExceptT e m a

(Error e, MonadState s m) => MonadState s (ErrorT e m)

Defined in Control.Monad.State.Class

Methods

get :: ErrorT e m s

put :: s -> ErrorT e m ()

state :: (s -> (a, s)) -> ErrorT e m a

Monad m => MonadState s (VgrepT s m)

Defined in Vgrep.Type

Methods

get :: VgrepT s m s

put :: s -> VgrepT s m ()

state :: (s -> (a, s)) -> VgrepT s m a

MonadState s m => MonadState s (ContT r m)

Defined in Control.Monad.State.Class

Methods

get :: ContT r m s

put :: s -> ContT r m ()

state :: (s -> (a, s)) -> ContT r m a

MonadState s m => MonadState s (ConduitT i o m)

Defined in Data.Conduit.Internal.Conduit

Methods

get :: ConduitT i o m s

put :: s -> ConduitT i o m ()

state :: (s -> (a, s)) -> ConduitT i o m a

(Monad m, Monoid w) => MonadState s (RWST r w s m)

Defined in Control.Monad.State.Class

Methods

get :: RWST r w s m s

put :: s -> RWST r w s m ()

state :: (s -> (a, s)) -> RWST r w s m a

(Monad m, Monoid w) => MonadState s (RWST r w s m)

Defined in Control.Monad.State.Class

Methods

get :: RWST r w s m s

put :: s -> RWST r w s m ()

state :: (s -> (a, s)) -> RWST r w s m a

MonadState s m => MonadState s (Proxy a' a b' b m)

Defined in Pipes.Internal

Methods

get :: Proxy a' a b' b m s

put :: s -> Proxy a' a b' b m ()

state :: (s -> (a0, s)) -> Proxy a' a b' b m a0

MonadState s m => MonadState s (Pipe l i o u m)

Defined in Data.Conduit.Internal.Pipe

Methods

get :: Pipe l i o u m s

put :: s -> Pipe l i o u m ()

state :: (s -> (a, s)) -> Pipe l i o u m a