Control.Parser

A module providing simple Parser combinator functionality. Useful for small parsing tasks such as identifier parsing or command-line argument parsing

Documentation

module SimpleH

The ParserT Type

newtype ParserT w s m a

Constructors

ParserT (StateT s (ListT (WriterT w m)) a)

Instances

(Monad m, Monoid w) => MonadError Void (ParserT w c m)

(Monoid w, Monad m) => MonadWriter w (ParserT w s m)

(Monoid w, Monad m) => MonadState s (ParserT w s m)

Monoid w => MonadTrans (ParserT w s)

(Unit m, Monoid w) => Unit (ParserT w s m)

(Monoid w, MonadFix m) => MonadFix (ParserT w s m)

(Monoid w, Monad m) => Monad (ParserT w s m)

(Monoid w, Monad m) => Applicative (ParserT w s m)

Functor m => Functor (ParserT w s m)

(Monoid w, Monad m) => Monoid (ParserT w s m a)

(Monoid w, Monad m) => Semigroup (ParserT w s m a)

type Parser w c a = ParserT w c Id a

newtype ParserA w m s a

Constructors

ParserA (ParserT w s m a)

Instances

(Monoid w, Monad m) => Split (ParserA w m)

(Monoid w, Monad m) => Choice (ParserA w m)

(Monoid w, Monad m) => Category (ParserA w m)

(Monoid w, Monad m) => Arrow (ParserA w m)

_ParserA :: Iso (ParserA w m s a) (ParserA w' m' s' a') (ParserT w s m a) (ParserT w' s' m' a')

The Stream class

class Stream c s | s -> c where

Methods

uncons :: s -> Maybe (c, s)

cons :: c -> s -> s

Instances

Stream Char ByteString

Stream a [a]

emptyStream :: Stream c s => s -> Bool

Test if a Stream is empty

Converting to/from Parsers

parserT :: (Functor n, Functor m) => Iso (ParserT w s m a) (ParserT x t n b) (s -> m (w, [(s, a)])) (t -> n (x, [(t, b)]))

parser :: Iso (Parser w s a) (Parser x t b) (s -> (w, [(s, a)])) (t -> (x, [(t, b)]))

runParser :: Parser Void s a -> s -> [(s, a)]

runParserT :: Functor m => ParserT Void s m a -> s -> m [(s, a)]

pureParser :: (Monoid w, Monad m) => (s -> [a]) -> ParserT w s m a

eitherParser :: Monoid w => (s -> Either w a) :<->: Parser w s a

Basic combinators

(<+>) :: Semigroup m => m -> m -> m

The (+) operator with lower priority

(>*>) :: (Monoid w, Monad m) => ParserT w a m b -> ParserT w b m c -> ParserT w a m c

(<*<) :: (Monoid w, Monad m) => ParserT w b m c -> ParserT w a m b -> ParserT w a m c

token :: (Monad m, Monoid w, Stream c s) => ParserT w s m c

Consume a token from the Stream

satisfy :: (Monoid w, Monad m, Stream c s) => (c -> Bool) -> ParserT w s m c

Consume a token and succeed if it verifies a predicate

oneOf :: (Eq c, Monoid w, Monad m, Foldable t, Stream c s) => t c -> ParserT w s m c

Parse a member of a set of values

noneOf :: (Eq c, Monoid w, Monad m, Foldable t, Stream c s) => t c -> ParserT w s m c

Parse anything but a member of a set

single :: (Eq c, Monoid w, Monad m, Stream c s) => c -> ParserT w s m ()

Consume a single fixed token or fail.

several :: (Eq c, Monoid w, Monad m, Foldable t, Stream c s) => t c -> ParserT w s m ()

Consume a structure of characters or fail

remaining :: (Monad m, Monoid w) => ParserT w s m s

The remaining Stream to parse

eoi :: (Monad m, Monoid w, Stream c s) => ParserT w s m ()

Succeed only if we are by the End Of Input.

Specialized utilities

readable :: (Monoid w, Monad m, Read a) => ParserT w String m a

number :: (Monoid w, Monad m, Stream Char s, Num n) => ParserT w s m n

Parse a litteral decimal number

digit :: (Monoid w, Monad m, Stream Char s) => ParserT w s m Char

Parse a single decimal digit

letter :: (Monoid w, Monad m, Stream Char s) => ParserT w s m Char

alNum :: (Monoid w, Monad m, Stream Char s) => ParserT w s m Char

quotedString :: (Monoid w, Monad m, Stream Char s) => Char -> ParserT w s m String

Parse a delimited string, unsing \\ as the quoting character

space :: (Monoid w, Monad m, Stream Char s) => ParserT w s m Char

A single space

spaces :: (Monoid w, Monad m, Stream Char s) => ParserT w s m String

Many spaces

eol :: (Monad m, Monoid w, Stream Char s) => ParserT w s m ()

The end of line

Basic combinators

many :: (Monoid w, Monad m) => ParserT w c m a -> ParserT w c m [a]

Parse zero, one or more successive occurences of a parser.

many1 :: (Monoid w, Monad m) => ParserT w c m a -> ParserT w c m [a]

Parse one or more successiveé occurences of a parser.

sepBy :: (Monoid w, Monad m) => ParserT w c m a -> ParserT w c m b -> ParserT w c m [a]

Parse zero or more successive occurences of a parser separated by occurences of a second parser.

sepBy1 :: (Monoid w, Monad m) => ParserT w c m a -> ParserT w c m b -> ParserT w c m [a]

Parse one or more successive occurences of a parser separated by occurences of a second parser.

chainl :: (Monoid w, Stream c s, Monad m) => ParserT w s m a -> ParserT w s m (a -> b -> a) -> ParserT w s m b -> ParserT w s m a

Chain an operator with an initial value

chainr :: (Monoid w, Stream c s, Monad m) => ParserT w s m a -> ParserT w s m (b -> a -> a) -> ParserT w s m b -> ParserT w s m a

Chain an operator with an initial value and several tail values.