Text.ParserCombinators.MTLParse

MonadParse class

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

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)

MonadParse a m => MonadParse a (StateT r m)

(MonadParse a m, Monoid w) => MonadParse a (WriterT w m)

MonadParse a m => MonadParse a (ReaderT s m)

Monad m => MonadParse a (ParseT a m)

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)

Alternative (Parse p)

Monad (Parse a)

Functor (Parse p)

MonadPlus (Parse a)

Applicative (Parse p)

MonadReader ([a], [a]) (Parse a)

MonadState ([a], [a]) (Parse 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)

Monad m => MonadParse a (ParseT a m)

MonadTrans (ParseT a)

Monad m => Alternative (ParseT a m)

Monad m => Monad (ParseT a m)

Monad m => Functor (ParseT a m)

Monad m => MonadPlus (ParseT a m)

Monad m => Applicative (ParseT a m)

MonadIO m => MonadIO (ParseT a m)

Monad m => MonadReader ([a], [a]) (ParseT a m)

Monad m => MonadState ([a], [a]) (ParseT a m)

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

module Control.Monad

module Control.Monad.Trans

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]