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 #

Minimal complete definition

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

Methods

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 #

Instances

MonadParse a (Parse a) #
Methods spot :: (a -> Bool) -> Parse a a # spotBack :: (a -> Bool) -> Parse a a # still :: Parse a b -> Parse a b # parseNot :: c -> Parse a b -> Parse a c # getHere :: Parse a ([a], [a]) # putHere :: ([a], [a]) -> Parse a () # noBacktrack :: Parse a b -> Parse a b #
MonadParse a m => MonadParse a (StateT r m) #
Methods spot :: (a -> Bool) -> StateT r m a # spotBack :: (a -> Bool) -> StateT r m a # still :: StateT r m b -> StateT r m b # parseNot :: c -> StateT r m b -> StateT r m c # getHere :: StateT r m ([a], [a]) # putHere :: ([a], [a]) -> StateT r m () # noBacktrack :: StateT r m b -> StateT r m b #
(MonadParse a m, Monoid w) => MonadParse a (WriterT w m) #
Methods spot :: (a -> Bool) -> WriterT w m a # spotBack :: (a -> Bool) -> WriterT w m a # still :: WriterT w m b -> WriterT w m b # parseNot :: c -> WriterT w m b -> WriterT w m c # getHere :: WriterT w m ([a], [a]) # putHere :: ([a], [a]) -> WriterT w m () # noBacktrack :: WriterT w m b -> WriterT w m b #
Monad m => MonadParse a (ParseT a m) #
Methods spot :: (a -> Bool) -> ParseT a m a # spotBack :: (a -> Bool) -> ParseT a m a # still :: ParseT a m b -> ParseT a m b # parseNot :: c -> ParseT a m b -> ParseT a m c # getHere :: ParseT a m ([a], [a]) # putHere :: ([a], [a]) -> ParseT a m () # noBacktrack :: ParseT a m b -> ParseT a m b #
MonadParse a m => MonadParse a (ReaderT * s m) #
Methods spot :: (a -> Bool) -> ReaderT * s m a # spotBack :: (a -> Bool) -> ReaderT * s m a # still :: ReaderT * s m b -> ReaderT * s m b # parseNot :: c -> ReaderT * s m b -> ReaderT * s m c # getHere :: ReaderT * s m ([a], [a]) # putHere :: ([a], [a]) -> ReaderT * s m () # noBacktrack :: ReaderT * s m b -> ReaderT * s 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 () #

The Parse Monad

newtype Parse a b #

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) #
Methods spot :: (a -> Bool) -> Parse a a # spotBack :: (a -> Bool) -> Parse a a # still :: Parse a b -> Parse a b # parseNot :: c -> Parse a b -> Parse a c # getHere :: Parse a ([a], [a]) # putHere :: ([a], [a]) -> Parse a () # noBacktrack :: Parse a b -> Parse a b #
Monad (Parse a) #
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) #
Methods fmap :: (a -> b) -> Parse p a -> Parse p b # (<$) :: a -> Parse p b -> Parse p a #
Applicative (Parse p) #
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) #
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) #
Methods mzero :: Parse a a # mplus :: Parse a a -> Parse a a -> Parse a a #
MonadReader ([a], [a]) (Parse a) #
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) #
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] #

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 #

The ParseT Monad

newtype ParseT a m b #

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) #
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) #
Methods spot :: (a -> Bool) -> ParseT a m a # spotBack :: (a -> Bool) -> ParseT a m a # still :: ParseT a m b -> ParseT a m b # parseNot :: c -> ParseT a m b -> ParseT a m c # getHere :: ParseT a m ([a], [a]) # putHere :: ([a], [a]) -> ParseT a m () # noBacktrack :: ParseT a m b -> ParseT a m b #
MonadTrans (ParseT a) #
Methods lift :: Monad m => m a -> ParseT a m a #
Monad m => Monad (ParseT a m) #
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) #
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) #
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) #
Methods liftIO :: IO a -> ParseT a m a #
Monad m => Alternative (ParseT a m) #
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) #
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) #
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) #
Methods get :: ParseT a m ([a], [a]) put :: ([a], [a]) -> ParseT a m () state :: (([a], [a]) -> (a, ([a], [a]))) -> ParseT a m a