Language.Parser

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

Documentation

module Definitive

The ParserT Type

newtype ParserT s m a

Constructors

ParserT (StateT s (LogicT m) a)

Instances

Monad m => MonadState s (ParserT s m)

MonadTrans (ParserT s)

ConcreteMonad (ParserT s)

Functor (ParserT s m)

Applicative (ParserT s m)

Monad m => Monad (ParserT s m)

Monad m => MonadFix (ParserT s m)

Unit (ParserT s m)

(Monad m, Stream Char s) => IsString (ParserT s m a)

Semigroup (ParserT s m a)

Monoid (ParserT s m a)

type Parser c a = ParserT c Id a

newtype ParserA m s a

Constructors

ParserA (ParserT s m a)

Instances

Monad m => Arrow (ParserA m)

Monad m => Deductive (ParserA m)

Monad m => Category (ParserA m)

Monad m => Choice (ParserA m)

Monad m => Split (ParserA m)

i'ParserA :: Iso (ParserA m s a) (ParserA m' s' a') (ParserT s m a) (ParserT 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 Chunk

Stream a [a]

Stream a (StreamC a)

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

Test if a Stream is empty

Converting to/from Parsers

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

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

ioParser :: Parser a b -> a -> IO b

Basic combinators

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

The (+) operator with lower priority

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

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

cut :: Monad m => ParserT s m a -> ParserT s m a

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

Consume a token from the Stream

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

Consume a token and succeed if it verifies a predicate

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

Parse a member of a set of values

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

Parse anything but a member of a set

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

Consume a single fixed token or fail.

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

Consume a structure of characters or fail

remaining :: Monad m => ParserT s m s

The remaining Stream to parse

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

Succeed only at the End Of Input.

Specialized utilities

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

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

Parse a litteral decimal number

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

Parse a single decimal digit

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

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

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

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

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

A single space

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

Many spaces

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

The end of a line

Basic combinators

many :: Monad m => ParserT c m a -> ParserT c m [a]

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

many1 :: Monad m => ParserT c m a -> ParserT c m [a]

Parse one or more successiveé occurences of a parser.

sepBy :: Monad m => ParserT c m a -> ParserT c m b -> ParserT c m [a] infixl 1

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

sepBy1 :: Monad m => ParserT c m a -> ParserT c m b -> ParserT c m [a] infixl 1

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

skipMany :: Monad m => ParserT c m a -> ParserT c m ()

Skip many occurences of a parser

skipMany1 :: Monad m => ParserT c m a -> ParserT c m ()

Skip multiple occurences of a parser

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

Chain an operator with an initial value

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

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

option :: Monad m => a -> ParserT s m a -> ParserT s m a

Try to consume a parser. Return a default value when it fails.