Safe Haskell	None
Language	Haskell2010

Language.Parser

Contents

The ParserT Type
- The Stream class
- Converting to/from Parsers
Basic combinators
- Specialized utilities
Basic combinators

Description

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

Synopsis

Documentation

module Definitive

The ParserT Type

newtype ParserT s m a Source

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 Source

newtype ParserA m s a Source

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') Source

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 Source

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)]) Source

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

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

Basic combinators

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

The (+) operator with lower priority

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

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

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

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

Consume a token from the Stream

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

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 Source

Parse a member of a set of values

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

Parse anything but a member of a set

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

Consume a single fixed token or fail.

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

Consume a structure of characters or fail

remaining :: Monad m => ParserT s m s Source

The remaining Stream to parse

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

Succeed only at the End Of Input.

Specialized utilities

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

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

Parse a litteral decimal number

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

Parse a single decimal digit

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

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

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

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

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

A single space

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

Many spaces

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

The end of a line

Basic combinators

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

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

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

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 Source

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 Source

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 () Source

Skip many occurences of a parser

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

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 Source

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 Source

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

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

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