Safe Haskell	Safe-Inferred
Language	Haskell98

Text.ParserCombinators.MTLParse

Contents

MonadParse class
The Parse Monad
The ParseT Monad

Synopsis

class Monad m => MonadParse a m | m -> a where
- spot :: (a -> Bool) -> m a
- spotBack :: (a -> Bool) -> m a
- still :: m b -> m b
- parseNot :: c -> m b -> m c
- getHere :: m ([a], [a])
- putHere :: ([a], [a]) -> m ()
- noBacktrack :: m b -> m b
token :: (Eq a, MonadParse a m) => a -> m a
tokenBack :: (Eq a, MonadParse a m) => a -> m a
getsHere :: MonadParse a m => (([a], [a]) -> b) -> m b
modifyHere :: MonadParse a m => (([a], [a]) -> ([a], [a])) -> m ()
getForward :: MonadParse a m => m [a]
getsForward :: MonadParse a m => ([a] -> [a]) -> m [a]
putForward :: MonadParse a m => [a] -> m ()
modifyForward :: MonadParse a m => ([a] -> [a]) -> m ()
getBack :: MonadParse a m => m [a]
getsBack :: MonadParse a m => ([a] -> [a]) -> m [a]
putBack :: MonadParse a m => [a] -> m ()
modifyBack :: MonadParse a m => ([a] -> [a]) -> m ()
newtype Parse a b = Parse {
- runParse :: ([a], [a]) -> [(b, ([a], [a]))]
}
evalParse :: Parse a b -> ([a], [a]) -> [b]
execParse :: Parse a b -> ([a], [a]) -> [([a], [a])]
mapParse :: ((b, ([a], [a])) -> (c, ([a], [a]))) -> Parse a b -> Parse a c
withParse :: (([a], [a]) -> ([a], [a])) -> Parse a b -> Parse a b
newtype ParseT a m b = ParseT {
- runParseT :: ([a], [a]) -> m [(b, ([a], [a]))]
}
evalParseT :: Monad m => ParseT a m b -> ([a], [a]) -> m [b]
execParseT :: Monad m => ParseT a m b -> ([a], [a]) -> m [([a], [a])]
mapParseT :: (m [(b, ([a], [a]))] -> n [(c, ([a], [a]))]) -> ParseT a m b -> ParseT a n c
withParseT :: (([a], [a]) -> ([a], [a])) -> ParseT a m b -> ParseT a m b
class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) where
- mzero :: m a
- mplus :: m a -> m a -> m a
liftM :: Monad m => (a1 -> r) -> m a1 -> m r
ap :: Monad m => m (a -> b) -> m a -> m b
class Monad m => MonadIO (m :: Type -> Type) where
- liftIO :: IO a -> m a
class MonadTrans (t :: (Type -> Type) -> Type -> Type) where
- lift :: Monad m => m a -> t m a
tokens :: (Eq a, MonadParse a m) => [a] -> m [a]
tokensBack :: (Eq a, MonadParse a m) => [a] -> m [a]
build :: Monad m => m a -> (a -> b) -> m b
repeatParse :: MonadPlus m => Int -> Maybe Int -> m b -> m [b]
optional :: MonadPlus m => m a -> m [a]
list :: MonadPlus m => m a -> m [a]
neList :: MonadPlus m => m a -> m [a]
greedyRepeatParse :: MonadPlus m => Int -> Maybe Int -> m b -> m [b]
greedyOptional :: MonadPlus m => m a -> m [a]
greedyList :: MonadPlus m => m a -> m [a]
greedyNeList :: MonadPlus m => m a -> m [a]
beginningOfInput :: (MonadPlus m, MonadParse a m) => b -> m b
endOfInput :: (MonadPlus m, MonadParse a m) => b -> m b
apply2M :: Monad m => (a -> b -> c) -> m a -> m b -> m c
(>++>) :: Monad m => m [a] -> m [a] -> m [a]
(>:>) :: Monad m => m a -> m [a] -> m [a]

MonadParse class

class Monad m => MonadParse a m | m -> a where Source #

Methods

spot :: (a -> Bool) -> m a Source #

spotBack :: (a -> Bool) -> m a Source #

still :: m b -> m b Source #

parseNot :: c -> m b -> m c Source #

getHere :: m ([a], [a]) Source #

putHere :: ([a], [a]) -> m () Source #

noBacktrack :: m b -> m b Source #

Instances

Instances details

MonadParse a (Parse a) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods spot :: (a -> Bool) -> Parse a a Source # spotBack :: (a -> Bool) -> Parse a a Source # still :: Parse a b -> Parse a b Source # parseNot :: c -> Parse a b -> Parse a c Source # getHere :: Parse a ([a], [a]) Source # putHere :: ([a], [a]) -> Parse a () Source # noBacktrack :: Parse a b -> Parse a b Source #
Monad m => MonadParse a (ParseT a m) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods spot :: (a -> Bool) -> ParseT a m a Source # spotBack :: (a -> Bool) -> ParseT a m a Source # still :: ParseT a m b -> ParseT a m b Source # parseNot :: c -> ParseT a m b -> ParseT a m c Source # getHere :: ParseT a m ([a], [a]) Source # putHere :: ([a], [a]) -> ParseT a m () Source # noBacktrack :: ParseT a m b -> ParseT a m b Source #
MonadParse a m => MonadParse a (ReaderT s m) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods spot :: (a -> Bool) -> ReaderT s m a Source # spotBack :: (a -> Bool) -> ReaderT s m a Source # still :: ReaderT s m b -> ReaderT s m b Source # parseNot :: c -> ReaderT s m b -> ReaderT s m c Source # getHere :: ReaderT s m ([a], [a]) Source # putHere :: ([a], [a]) -> ReaderT s m () Source # noBacktrack :: ReaderT s m b -> ReaderT s m b Source #
MonadParse a m => MonadParse a (StateT r m) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods spot :: (a -> Bool) -> StateT r m a Source # spotBack :: (a -> Bool) -> StateT r m a Source # still :: StateT r m b -> StateT r m b Source # parseNot :: c -> StateT r m b -> StateT r m c Source # getHere :: StateT r m ([a], [a]) Source # putHere :: ([a], [a]) -> StateT r m () Source # noBacktrack :: StateT r m b -> StateT r m b Source #
(MonadParse a m, Monoid w) => MonadParse a (WriterT w m) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods spot :: (a -> Bool) -> WriterT w m a Source # spotBack :: (a -> Bool) -> WriterT w m a Source # still :: WriterT w m b -> WriterT w m b Source # parseNot :: c -> WriterT w m b -> WriterT w m c Source # getHere :: WriterT w m ([a], [a]) Source # putHere :: ([a], [a]) -> WriterT w m () Source # noBacktrack :: WriterT w m b -> WriterT w m b Source #

token :: (Eq a, MonadParse a m) => a -> m a Source #

tokenBack :: (Eq a, MonadParse a m) => a -> m a Source #

getsHere :: MonadParse a m => (([a], [a]) -> b) -> m b Source #

modifyHere :: MonadParse a m => (([a], [a]) -> ([a], [a])) -> m () Source #

getForward :: MonadParse a m => m [a] Source #

getsForward :: MonadParse a m => ([a] -> [a]) -> m [a] Source #

putForward :: MonadParse a m => [a] -> m () Source #

modifyForward :: MonadParse a m => ([a] -> [a]) -> m () Source #

getBack :: MonadParse a m => m [a] Source #

getsBack :: MonadParse a m => ([a] -> [a]) -> m [a] Source #

putBack :: MonadParse a m => [a] -> m () Source #

modifyBack :: MonadParse a m => ([a] -> [a]) -> m () Source #

The Parse Monad

newtype Parse a b Source #

A parse monad where a is the type of the token to parse and b is the type of the return value.

Constructors

Parse
Fields runParse :: ([a], [a]) -> [(b, ([a], [a]))]

Instances

Instances details

MonadParse a (Parse a) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods spot :: (a -> Bool) -> Parse a a Source # spotBack :: (a -> Bool) -> Parse a a Source # still :: Parse a b -> Parse a b Source # parseNot :: c -> Parse a b -> Parse a c Source # getHere :: Parse a ([a], [a]) Source # putHere :: ([a], [a]) -> Parse a () Source # noBacktrack :: Parse a b -> Parse a b Source #
Alternative (Parse p) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods empty :: Parse p a Source # (<\|>) :: Parse p a -> Parse p a -> Parse p a Source # some :: Parse p a -> Parse p [a] Source # many :: Parse p a -> Parse p [a] Source #
Applicative (Parse p) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods pure :: a -> Parse p a Source # (<>) :: Parse p (a -> b) -> Parse p a -> Parse p b Source # liftA2 :: (a -> b -> c) -> Parse p a -> Parse p b -> Parse p c Source # (>) :: Parse p a -> Parse p b -> Parse p b Source # (<*) :: Parse p a -> Parse p b -> Parse p a Source #
Functor (Parse p) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods fmap :: (a -> b) -> Parse p a -> Parse p b Source # (<$) :: a -> Parse p b -> Parse p a Source #
Monad (Parse a) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods (>>=) :: Parse a a0 -> (a0 -> Parse a b) -> Parse a b Source # (>>) :: Parse a a0 -> Parse a b -> Parse a b Source # return :: a0 -> Parse a a0 Source #
MonadPlus (Parse a) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods mzero :: Parse a a0 Source # mplus :: Parse a a0 -> Parse a a0 -> Parse a a0 Source #
MonadReader ([a], [a]) (Parse a) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods ask :: Parse a ([a], [a]) Source # local :: (([a], [a]) -> ([a], [a])) -> Parse a a0 -> Parse a a0 Source # reader :: (([a], [a]) -> a0) -> Parse a a0 Source #
MonadState ([a], [a]) (Parse a) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods get :: Parse a ([a], [a]) Source # put :: ([a], [a]) -> Parse a () Source # state :: (([a], [a]) -> (a0, ([a], [a]))) -> Parse a a0 Source #

evalParse :: Parse a b -> ([a], [a]) -> [b] Source #

execParse :: Parse a b -> ([a], [a]) -> [([a], [a])] Source #

mapParse :: ((b, ([a], [a])) -> (c, ([a], [a]))) -> Parse a b -> Parse a c Source #

withParse :: (([a], [a]) -> ([a], [a])) -> Parse a b -> Parse a b Source #

The ParseT Monad

newtype ParseT a m b Source #

A parse monad for encaplulating an inner monad.

Constructors

ParseT
Fields runParseT :: ([a], [a]) -> m [(b, ([a], [a]))]

Instances

Instances details

MonadWriter w m => MonadWriter w (ParseT a m) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods writer :: (a0, w) -> ParseT a m a0 Source # tell :: w -> ParseT a m () Source # listen :: ParseT a m a0 -> ParseT a m (a0, w) Source # pass :: ParseT a m (a0, w -> w) -> ParseT a m a0 Source #
Monad m => MonadParse a (ParseT a m) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods spot :: (a -> Bool) -> ParseT a m a Source # spotBack :: (a -> Bool) -> ParseT a m a Source # still :: ParseT a m b -> ParseT a m b Source # parseNot :: c -> ParseT a m b -> ParseT a m c Source # getHere :: ParseT a m ([a], [a]) Source # putHere :: ([a], [a]) -> ParseT a m () Source # noBacktrack :: ParseT a m b -> ParseT a m b Source #
MonadTrans (ParseT a) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods lift :: Monad m => m a0 -> ParseT a m a0 Source #
MonadIO m => MonadIO (ParseT a m) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods liftIO :: IO a0 -> ParseT a m a0 Source #
Monad m => Alternative (ParseT a m) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods empty :: ParseT a m a0 Source # (<\|>) :: ParseT a m a0 -> ParseT a m a0 -> ParseT a m a0 Source # some :: ParseT a m a0 -> ParseT a m [a0] Source # many :: ParseT a m a0 -> ParseT a m [a0] Source #
Monad m => Applicative (ParseT a m) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods pure :: a0 -> ParseT a m a0 Source # (<>) :: ParseT a m (a0 -> b) -> ParseT a m a0 -> ParseT a m b Source # liftA2 :: (a0 -> b -> c) -> ParseT a m a0 -> ParseT a m b -> ParseT a m c Source # (>) :: ParseT a m a0 -> ParseT a m b -> ParseT a m b Source # (<*) :: ParseT a m a0 -> ParseT a m b -> ParseT a m a0 Source #
Monad m => Functor (ParseT a m) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods fmap :: (a0 -> b) -> ParseT a m a0 -> ParseT a m b Source # (<$) :: a0 -> ParseT a m b -> ParseT a m a0 Source #
Monad m => Monad (ParseT a m) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods (>>=) :: ParseT a m a0 -> (a0 -> ParseT a m b) -> ParseT a m b Source # (>>) :: ParseT a m a0 -> ParseT a m b -> ParseT a m b Source # return :: a0 -> ParseT a m a0 Source #
Monad m => MonadPlus (ParseT a m) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods mzero :: ParseT a m a0 Source # mplus :: ParseT a m a0 -> ParseT a m a0 -> ParseT a m a0 Source #
Monad m => MonadReader ([a], [a]) (ParseT a m) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods ask :: ParseT a m ([a], [a]) Source # local :: (([a], [a]) -> ([a], [a])) -> ParseT a m a0 -> ParseT a m a0 Source # reader :: (([a], [a]) -> a0) -> ParseT a m a0 Source #
Monad m => MonadState ([a], [a]) (ParseT a m) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods get :: ParseT a m ([a], [a]) Source # put :: ([a], [a]) -> ParseT a m () Source # state :: (([a], [a]) -> (a0, ([a], [a]))) -> ParseT a m a0 Source #

evalParseT :: Monad m => ParseT a m b -> ([a], [a]) -> m [b] Source #

execParseT :: Monad m => ParseT a m b -> ([a], [a]) -> m [([a], [a])] Source #

mapParseT :: (m [(b, ([a], [a]))] -> n [(c, ([a], [a]))]) -> ParseT a m b -> ParseT a n c Source #

withParseT :: (([a], [a]) -> ([a], [a])) -> ParseT a m b -> ParseT a m b Source #

class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type) where Source #

Monads that also support choice and failure.

Minimal complete definition

Nothing

Methods

mzero :: m a Source #

The identity of mplus. It should also satisfy the equations

mzero >>= f  =  mzero
v >> mzero   =  mzero

The default definition is

mzero = empty

mplus :: m a -> m a -> m a Source #

An associative operation. The default definition is

mplus = (<|>)

Instances

Instances details

MonadPlus P	Since: base-2.1
Instance details Defined in Text.ParserCombinators.ReadP Methods mzero :: P a Source # mplus :: P a -> P a -> P a Source #
MonadPlus ReadP	Since: base-2.1
Instance details Defined in Text.ParserCombinators.ReadP Methods mzero :: ReadP a Source # mplus :: ReadP a -> ReadP a -> ReadP a Source #
MonadPlus IO	Since: base-4.9.0.0
Instance details Defined in GHC.Base Methods mzero :: IO a Source # mplus :: IO a -> IO a -> IO a Source #
MonadPlus Maybe	Since: base-2.1
Instance details Defined in GHC.Base Methods mzero :: Maybe a Source # mplus :: Maybe a -> Maybe a -> Maybe a Source #
MonadPlus []	Since: base-2.1
Instance details Defined in GHC.Base Methods mzero :: [a] Source # mplus :: [a] -> [a] -> [a] Source #
(ArrowApply a, ArrowPlus a) => MonadPlus (ArrowMonad a)	Since: base-4.6.0.0
Instance details Defined in Control.Arrow Methods mzero :: ArrowMonad a a0 Source # mplus :: ArrowMonad a a0 -> ArrowMonad a a0 -> ArrowMonad a a0 Source #
MonadPlus (Parse a) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods mzero :: Parse a a0 Source # mplus :: Parse a a0 -> Parse a a0 -> Parse a a0 Source #
Monad m => MonadPlus (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods mzero :: MaybeT m a Source # mplus :: MaybeT m a -> MaybeT m a -> MaybeT m a Source #
MonadPlus m => MonadPlus (Kleisli m a)	Since: base-4.14.0.0
Instance details Defined in Control.Arrow Methods mzero :: Kleisli m a a0 Source # mplus :: Kleisli m a a0 -> Kleisli m a a0 -> Kleisli m a a0 Source #
MonadPlus f => MonadPlus (Ap f)	Since: base-4.12.0.0
Instance details Defined in Data.Monoid Methods mzero :: Ap f a Source # mplus :: Ap f a -> Ap f a -> Ap f a Source #
Monad m => MonadPlus (ParseT a m) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods mzero :: ParseT a m a0 Source # mplus :: ParseT a m a0 -> ParseT a m a0 -> ParseT a m a0 Source #
(Monad m, Error e) => MonadPlus (ErrorT e m)
Instance details Defined in Control.Monad.Trans.Error Methods mzero :: ErrorT e m a Source # mplus :: ErrorT e m a -> ErrorT e m a -> ErrorT e m a Source #
(Monad m, Monoid e) => MonadPlus (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods mzero :: ExceptT e m a Source # mplus :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a Source #
MonadPlus m => MonadPlus (IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods mzero :: IdentityT m a Source # mplus :: IdentityT m a -> IdentityT m a -> IdentityT m a Source #
MonadPlus m => MonadPlus (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods mzero :: ReaderT r m a Source # mplus :: ReaderT r m a -> ReaderT r m a -> ReaderT r m a Source #
MonadPlus m => MonadPlus (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods mzero :: StateT s m a Source # mplus :: StateT s m a -> StateT s m a -> StateT s m a Source #
MonadPlus m => MonadPlus (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods mzero :: StateT s m a Source # mplus :: StateT s m a -> StateT s m a -> StateT s m a Source #
(Monoid w, MonadPlus m) => MonadPlus (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods mzero :: WriterT w m a Source # mplus :: WriterT w m a -> WriterT w m a -> WriterT w m a Source #
(Monoid w, MonadPlus m) => MonadPlus (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods mzero :: WriterT w m a Source # mplus :: WriterT w m a -> WriterT w m a -> WriterT w m a Source #
(Monoid w, MonadPlus m) => MonadPlus (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Lazy Methods mzero :: RWST r w s m a Source # mplus :: RWST r w s m a -> RWST r w s m a -> RWST r w s m a Source #
(Monoid w, MonadPlus m) => MonadPlus (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Strict Methods mzero :: RWST r w s m a Source # mplus :: RWST r w s m a -> RWST r w s m a -> RWST r w s m a Source #

liftM :: Monad m => (a1 -> r) -> m a1 -> m r Source #

Promote a function to a monad.

ap :: Monad m => m (a -> b) -> m a -> m b Source #

In many situations, the liftM operations can be replaced by uses of ap, which promotes function application.

return f `ap` x1 `ap` ... `ap` xn

is equivalent to

liftMn f x1 x2 ... xn

class Monad m => MonadIO (m :: Type -> Type) where Source #

Monads in which IO computations may be embedded. Any monad built by applying a sequence of monad transformers to the IO monad will be an instance of this class.

Instances should satisfy the following laws, which state that liftIO is a transformer of monads:

```
liftIO . return = return
```

liftIO (m >>= f) = liftIO m >>= (liftIO . f)

Methods

liftIO :: IO a -> m a Source #

Lift a computation from the IO monad. This allows us to run IO computations in any monadic stack, so long as it supports these kinds of operations (i.e. IO is the base monad for the stack).

Example

Expand

import Control.Monad.Trans.State -- from the "transformers" library

printState :: Show s => StateT s IO ()
printState = do
  state <- get
  liftIO $ print state

Had we omitted liftIO, we would have ended up with this error:

• Couldn't match type ‘IO’ with ‘StateT s IO’
 Expected type: StateT s IO ()
   Actual type: IO ()

The important part here is the mismatch between StateT s IO () and IO ().

Luckily, we know of a function that takes an IO a and returns an (m a): liftIO, enabling us to run the program and see the expected results:

> evalStateT printState "hello"
"hello"

> evalStateT printState 3
3

Instances

Instances details

MonadIO IO	Since: base-4.9.0.0
Instance details Defined in Control.Monad.IO.Class Methods liftIO :: IO a -> IO a Source #
MonadIO m => MonadIO (MaybeT m)
Instance details Defined in Control.Monad.Trans.Maybe Methods liftIO :: IO a -> MaybeT m a Source #
MonadIO m => MonadIO (ParseT a m) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods liftIO :: IO a0 -> ParseT a m a0 Source #
(Error e, MonadIO m) => MonadIO (ErrorT e m)
Instance details Defined in Control.Monad.Trans.Error Methods liftIO :: IO a -> ErrorT e m a Source #
MonadIO m => MonadIO (ExceptT e m)
Instance details Defined in Control.Monad.Trans.Except Methods liftIO :: IO a -> ExceptT e m a Source #
MonadIO m => MonadIO (IdentityT m)
Instance details Defined in Control.Monad.Trans.Identity Methods liftIO :: IO a -> IdentityT m a Source #
MonadIO m => MonadIO (ReaderT r m)
Instance details Defined in Control.Monad.Trans.Reader Methods liftIO :: IO a -> ReaderT r m a Source #
MonadIO m => MonadIO (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods liftIO :: IO a -> StateT s m a Source #
MonadIO m => MonadIO (StateT s m)
Instance details Defined in Control.Monad.Trans.State.Strict Methods liftIO :: IO a -> StateT s m a Source #
(Monoid w, MonadIO m) => MonadIO (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods liftIO :: IO a -> WriterT w m a Source #
(Monoid w, MonadIO m) => MonadIO (WriterT w m)
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods liftIO :: IO a -> WriterT w m a Source #
(Monoid w, MonadIO m) => MonadIO (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Lazy Methods liftIO :: IO a -> RWST r w s m a Source #
(Monoid w, MonadIO m) => MonadIO (RWST r w s m)
Instance details Defined in Control.Monad.Trans.RWS.Strict Methods liftIO :: IO a -> RWST r w s m a Source #

class MonadTrans (t :: (Type -> Type) -> Type -> Type) where Source #

The class of monad transformers. Instances should satisfy the following laws, which state that lift is a monad transformation:

```
lift . return = return
```
```
lift (m >>= f) = lift m >>= (lift . f)
```

Methods

lift :: Monad m => m a -> t m a Source #

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

Instances

Instances details

MonadTrans MaybeT
Instance details Defined in Control.Monad.Trans.Maybe Methods lift :: Monad m => m a -> MaybeT m a Source #
MonadTrans (ParseT a) Source #
Instance details Defined in Text.ParserCombinators.MTLParse.MTLParseCore Methods lift :: Monad m => m a0 -> ParseT a m a0 Source #
MonadTrans (ErrorT e)
Instance details Defined in Control.Monad.Trans.Error Methods lift :: Monad m => m a -> ErrorT e m a Source #
MonadTrans (ExceptT e)
Instance details Defined in Control.Monad.Trans.Except Methods lift :: Monad m => m a -> ExceptT e m a Source #
MonadTrans (IdentityT :: (Type -> Type) -> Type -> Type)
Instance details Defined in Control.Monad.Trans.Identity Methods lift :: Monad m => m a -> IdentityT m a Source #
MonadTrans (ReaderT r)
Instance details Defined in Control.Monad.Trans.Reader Methods lift :: Monad m => m a -> ReaderT r m a Source #
MonadTrans (StateT s)
Instance details Defined in Control.Monad.Trans.State.Lazy Methods lift :: Monad m => m a -> StateT s m a Source #
MonadTrans (StateT s)
Instance details Defined in Control.Monad.Trans.State.Strict Methods lift :: Monad m => m a -> StateT s m a Source #
Monoid w => MonadTrans (WriterT w)
Instance details Defined in Control.Monad.Trans.Writer.Lazy Methods lift :: Monad m => m a -> WriterT w m a Source #
Monoid w => MonadTrans (WriterT w)
Instance details Defined in Control.Monad.Trans.Writer.Strict Methods lift :: Monad m => m a -> WriterT w m a Source #
Monoid w => MonadTrans (RWST r w s)
Instance details Defined in Control.Monad.Trans.RWS.Lazy Methods lift :: Monad m => m a -> RWST r w s m a Source #
Monoid w => MonadTrans (RWST r w s)
Instance details Defined in Control.Monad.Trans.RWS.Strict Methods lift :: Monad m => m a -> RWST r w s m a Source #

tokens :: (Eq a, MonadParse a m) => [a] -> m [a] Source #

tokensBack :: (Eq a, MonadParse a m) => [a] -> m [a] Source #

build :: Monad m => m a -> (a -> b) -> m b Source #

repeatParse :: MonadPlus m => Int -> Maybe Int -> m b -> m [b] Source #

optional :: MonadPlus m => m a -> m [a] Source #

list :: MonadPlus m => m a -> m [a] Source #

neList :: MonadPlus m => m a -> m [a] Source #

greedyRepeatParse :: MonadPlus m => Int -> Maybe Int -> m b -> m [b] Source #

greedyOptional :: MonadPlus m => m a -> m [a] Source #

greedyList :: MonadPlus m => m a -> m [a] Source #

greedyNeList :: MonadPlus m => m a -> m [a] Source #

beginningOfInput :: (MonadPlus m, MonadParse a m) => b -> m b Source #

endOfInput :: (MonadPlus m, MonadParse a m) => b -> m b Source #

apply2M :: Monad m => (a -> b -> c) -> m a -> m b -> m c Source #

(>++>) :: Monad m => m [a] -> m [a] -> m [a] Source #

(>:>) :: Monad m => m a -> m [a] -> m [a] Source #