Safe Haskell	Safe
Language	Haskell98

Text.ParserCombinators.MTLParse

Contents

MonadParse class
The Parse Monad
The ParseT Monad

Synopsis

MonadParse class

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

Minimal complete definition

spot, spotBack, still, parseNot, getHere, putHere, noBacktrack

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

MonadParse a (Parse a) Source #
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 #
MonadParse a m => MonadParse a (StateT r m) Source #
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 #
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 #
Monad m => MonadParse a (ParseT a m) Source #
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 #
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 #

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

MonadParse a (Parse a) Source #
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 (Parse a) Source #
Methods (>>=) :: Parse a a -> (a -> Parse a b) -> Parse a b # (>>) :: Parse a a -> Parse a b -> Parse a b # return :: a -> Parse a a # fail :: String -> Parse a a #
Functor (Parse p) Source #
Methods fmap :: (a -> b) -> Parse p a -> Parse p b # (<$) :: a -> Parse p b -> Parse p a #
Applicative (Parse p) Source #
Methods pure :: a -> Parse p a # (<>) :: Parse p (a -> b) -> Parse p a -> Parse p b # (>) :: Parse p a -> Parse p b -> Parse p b # (<*) :: Parse p a -> Parse p b -> Parse p a #
Alternative (Parse p) Source #
Methods empty :: Parse p a # (<\|>) :: Parse p a -> Parse p a -> Parse p a # some :: Parse p a -> Parse p [a] # many :: Parse p a -> Parse p [a] #
MonadPlus (Parse a) Source #
Methods mzero :: Parse a a # mplus :: Parse a a -> Parse a a -> Parse a a #
MonadReader ([a], [a]) (Parse a) Source #
Methods ask :: Parse a ([a], [a]) # local :: (([a], [a]) -> ([a], [a])) -> Parse a a -> Parse a a # reader :: (([a], [a]) -> a) -> Parse a a #
MonadState ([a], [a]) (Parse a) Source #
Methods get :: Parse a ([a], [a]) # put :: ([a], [a]) -> Parse a () # state :: (([a], [a]) -> (a, ([a], [a]))) -> Parse a a #

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

MonadWriter w m => MonadWriter w (ParseT a m) Source #
Methods writer :: (a, w) -> ParseT a m a # tell :: w -> ParseT a m () # listen :: ParseT a m a -> ParseT a m (a, w) # pass :: ParseT a m (a, w -> w) -> ParseT a m a #
Monad m => MonadParse a (ParseT a m) Source #
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 #
Methods lift :: Monad m => m a -> ParseT a m a #
Monad m => Monad (ParseT a m) Source #
Methods (>>=) :: ParseT a m a -> (a -> ParseT a m b) -> ParseT a m b # (>>) :: ParseT a m a -> ParseT a m b -> ParseT a m b # return :: a -> ParseT a m a # fail :: String -> ParseT a m a #
Monad m => Functor (ParseT a m) Source #
Methods fmap :: (a -> b) -> ParseT a m a -> ParseT a m b # (<$) :: a -> ParseT a m b -> ParseT a m a #
Monad m => Applicative (ParseT a m) Source #
Methods pure :: a -> ParseT a m a # (<>) :: ParseT a m (a -> b) -> ParseT a m a -> ParseT a m b # (>) :: ParseT a m a -> ParseT a m b -> ParseT a m b # (<*) :: ParseT a m a -> ParseT a m b -> ParseT a m a #
MonadIO m => MonadIO (ParseT a m) Source #
Methods liftIO :: IO a -> ParseT a m a #
Monad m => Alternative (ParseT a m) Source #
Methods empty :: ParseT a m a # (<\|>) :: ParseT a m a -> ParseT a m a -> ParseT a m a # some :: ParseT a m a -> ParseT a m [a] # many :: ParseT a m a -> ParseT a m [a] #
Monad m => MonadPlus (ParseT a m) Source #
Methods mzero :: ParseT a m a # mplus :: ParseT a m a -> ParseT a m a -> ParseT a m a #
Monad m => MonadReader ([a], [a]) (ParseT a m) Source #
Methods ask :: ParseT a m ([a], [a]) # local :: (([a], [a]) -> ([a], [a])) -> ParseT a m a -> ParseT a m a # reader :: (([a], [a]) -> a) -> ParseT a m a #
Monad m => MonadState ([a], [a]) (ParseT a m) Source #
Methods get :: ParseT a m ([a], [a]) # put :: ([a], [a]) -> ParseT a m () # state :: (([a], [a]) -> (a, ([a], [a]))) -> ParseT a m a #