Control.Monad.Parser.Class

Documentation

class (Monad m, Stream (Input m)) => MonadParser m where

A monad with parsing capabilities.

Associated Types

type Input m :: Type

Methods

parseStream :: m (Input m)

The current input stream.

setParseStream :: Input m -> m ()

Replace the input stream.

noParse :: m a

A parser that always fails.

item :: m (Item (Input m))

A parser that returns the next item.

followedBy :: m a -> m ()

followedBy p is a parser that succeeds if p succeeds, but it does not consume any input.

notFollowedBy :: m a -> m ()

notFollowedBy p is a parser that only succeeds if p fails. This parser will not consume any input.

try :: m a -> m a

try p is a parser that does everything like p, except it forcefully resets the position of any error reported by p to the current position.

(<|>) :: m a -> m a -> m a infixl 3

p | q is a parser that is equivalent to p when p succeeds and q when p fails to parse anything.

(<?>) :: m a -> String -> m a infixl 1

p ? msg is a parser that behaves like p, but when p fails, it reports an error indicating that msg was the expected input.

Instances

(Monad m, Stream s) => MonadParser (ParserT s m)

Defined in Control.Monad.Trans.Parser

Associated Types

type Input (ParserT s m)

Methods

parseStream :: ParserT s m (Input (ParserT s m))

setParseStream :: Input (ParserT s m) -> ParserT s m ()

noParse :: ParserT s m a

item :: ParserT s m (Item (Input (ParserT s m)))

followedBy :: ParserT s m a -> ParserT s m ()

notFollowedBy :: ParserT s m a -> ParserT s m ()

try :: ParserT s m a -> ParserT s m a

(<|>) :: ParserT s m a -> ParserT s m a -> ParserT s m a

(<?>) :: ParserT s m a -> String -> ParserT s m a

eof :: MonadParser m => m ()

Parser that succeeds if the stream is empty. Does not consume any items.

expected :: MonadParser m => String -> m a

Fail with an "expected" message.

satisfy :: MonadParser m => m a -> (a -> Bool) -> m a

Succeeds only if the value parsed by the parser satisfies the predicate.

match :: MonadParser m => (Item (Input m) -> Bool) -> m (Item (Input m))

Parse a single item satisfying the given predicate.

optional :: MonadParser m => m a -> m (Maybe a)

Make a parser optional.

choice :: MonadParser m => [m a] -> m a

Try a series of parsers in order, returning the first one that succeeds.

many :: MonadParser m => m a -> m [a]

Try to run the given parser as many times as possible.

many1 :: MonadParser m => m a -> m [a]

Try to run the given parser as many times as possible, but at least once. The result is returned as a regular list, but is guaranteed to be non-empty.

some :: MonadParser m => m a -> m (NonEmpty a)

Try to run the given parser as many times as possible, but at least once.

sepBy1 :: MonadParser m => m a -> m b -> m (NonEmpty a)

Parse a non-empty series of a separated by bs (without a trailing b).

sepBy :: MonadParser m => m a -> m b -> m [a]

Parse a potentially empty series of a separated by bs (without a trailing b).

like :: (MonadParser m, Eq (Item (Input m)), Show (Item (Input m))) => Item (Input m) -> m (Item (Input m))

Parse any value equal to a.

unlike :: (MonadParser m, Eq (Item (Input m)), Show (Item (Input m))) => Item (Input m) -> m (Item (Input m))

Parse any value not equal to a.

string :: (MonadParser m, Eq (Item (Input m)), Show (Item (Input m))) => [Item (Input m)] -> m [Item (Input m)]

Parse a continuous sequence of items equal to the given one.

oneOf :: (MonadParser m, Eq (Item (Input m)), Show (Item (Input m))) => [Item (Input m)] -> m (Item (Input m))

Parse any value equal to at least one element of the given list.

noneOf :: (MonadParser m, Eq (Item (Input m)), Show (Item (Input m))) => [Item (Input m)] -> m (Item (Input m))

Parse any value not equivalent to any element of the given list. For a version that accepts non-Show items, see noneOf'.

chainl1 :: MonadParser m => m a -> m (a -> a -> a) -> m a

chainl1 p op Parse a chain of *one* or more occurrences of p, separated by op. Return a value obtained by a left associative application of all functions returned by op to the values returned by p.

This is particularly useful for parsing left associative infix operators.

chainr1 :: MonadParser m => m a -> m (a -> a -> a) -> m a

chainr1 p op Parse a chain of *one* or more occurrences of p, separated by op. Return a value obtained by a right associative application of all functions returned by op to the values returned by p.

This is particularly useful for parsing right associative infix operators.

withInput :: MonadParser m => Input m -> m a -> m (a, Input m)

Run a parser on a different stream of items.