Text.Grampa

Collection of parsing algorithms with a common interface, operating on grammars represented as records with rank-2 field types.

Parsing methods

class MultiParsing m where

Choose one of the instances of this class to parse with.

Minimal complete definition

parseComplete, parsePrefix

Associated Types

type ResultFunctor m :: * -> *

Some parser types produce a single result, others a list of results.

type GrammarConstraint m (g :: (* -> *) -> *) :: Constraint

Methods

parseComplete :: (GrammarConstraint m g, FactorialMonoid s) => g (m g s) -> s -> g (ResultFunctor m)

Given a rank-2 record of parsers and input, produce a record of parses of the complete input.

parsePrefix :: (GrammarConstraint m g, FactorialMonoid s) => g (m g s) -> s -> g (Compose (ResultFunctor m) ((,) s))

Given a rank-2 record of parsers and input, produce a record of prefix parses paired with the remaining input suffix.

Instances

MultiParsing Parser

Parallel parser produces a list of all possible parses.

parseComplete :: (Rank2.Functor g, FactorialMonoid s) =>
                 g (Parallel.Parser g s) -> s -> g (Compose ParseResults [])

Associated Types

type ResultFunctor (Parser :: ((* -> *) -> *) -> * -> * -> *) :: * -> *

type GrammarConstraint (Parser :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) :: Constraint

Methods

parseComplete :: (GrammarConstraint Parser g, FactorialMonoid s) => g (Parser g s) -> s -> g (ResultFunctor Parser)

parsePrefix :: (GrammarConstraint Parser g, FactorialMonoid s) => g (Parser g s) -> s -> g (Compose * * (ResultFunctor Parser) ((,) s))

MultiParsing Parser

Continuation-passing context-free parser

parseComplete :: (Rank2.Functor g, FactorialMonoid s) =>
                 g (Continued.Parser g s) -> s -> g ParseResults

Associated Types

type ResultFunctor (Parser :: ((* -> *) -> *) -> * -> * -> *) :: * -> *

type GrammarConstraint (Parser :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) :: Constraint

Methods

parseComplete :: (GrammarConstraint Parser g, FactorialMonoid s) => g (Parser g s) -> s -> g (ResultFunctor Parser)

parsePrefix :: (GrammarConstraint Parser g, FactorialMonoid s) => g (Parser g s) -> s -> g (Compose * * (ResultFunctor Parser) ((,) s))

MultiParsing Parser

Backtracking PEG parser

parseComplete :: (Rank2.Functor g, FactorialMonoid s) =>
                 g (Backtrack.Parser g s) -> s -> g ParseResults

Associated Types

type ResultFunctor (Parser :: ((* -> *) -> *) -> * -> * -> *) :: * -> *

type GrammarConstraint (Parser :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) :: Constraint

Methods

parseComplete :: (GrammarConstraint Parser g, FactorialMonoid s) => g (Parser g s) -> s -> g (ResultFunctor Parser)

parsePrefix :: (GrammarConstraint Parser g, FactorialMonoid s) => g (Parser g s) -> s -> g (Compose * * (ResultFunctor Parser) ((,) s))

MultiParsing Parser

Memoizing parser guarantees O(n²) performance for grammars with unambiguous productions, but provides no left recursion support.

parseComplete :: (Rank2.Functor g, FactorialMonoid s) =>
                 g (Memoizing.Parser g s) -> s -> g (Compose ParseResults [])

Associated Types

type ResultFunctor (Parser :: ((* -> *) -> *) -> * -> * -> *) :: * -> *

type GrammarConstraint (Parser :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) :: Constraint

Methods

parseComplete :: (GrammarConstraint Parser g, FactorialMonoid s) => g (Parser g s) -> s -> g (ResultFunctor Parser)

parsePrefix :: (GrammarConstraint Parser g, FactorialMonoid s) => g (Parser g s) -> s -> g (Compose * * (ResultFunctor Parser) ((,) s))

MultiParsing Parser

Memoizing parser guarantees O(n²) performance for grammars with unambiguous productions, but provides no left recursion support.

parseComplete :: (Rank2.Functor g, FactorialMonoid s) =>
                 g (Memoizing.Parser g s) -> s -> g (Compose ParseResults [])

Associated Types

type ResultFunctor (Parser :: ((* -> *) -> *) -> * -> * -> *) :: * -> *

type GrammarConstraint (Parser :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) :: Constraint

Methods

parseComplete :: (GrammarConstraint Parser g, FactorialMonoid s) => g (Parser g s) -> s -> g (ResultFunctor Parser)

parsePrefix :: (GrammarConstraint Parser g, FactorialMonoid s) => g (Parser g s) -> s -> g (Compose * * (ResultFunctor Parser) ((,) s))

MultiParsing Parser

Packrat parser

parseComplete :: (Rank2.Functor g, FactorialMonoid s) =>
                 g (Packrat.Parser g s) -> s -> g ParseResults

Associated Types

type ResultFunctor (Parser :: ((* -> *) -> *) -> * -> * -> *) :: * -> *

type GrammarConstraint (Parser :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) :: Constraint

Methods

parseComplete :: (GrammarConstraint Parser g, FactorialMonoid s) => g (Parser g s) -> s -> g (ResultFunctor Parser)

parsePrefix :: (GrammarConstraint Parser g, FactorialMonoid s) => g (Parser g s) -> s -> g (Compose * * (ResultFunctor Parser) ((,) s))

MultiParsing (Fixed Parser)

Parser of general context-free grammars, including left recursion.

parseComplete :: (Rank2.Apply g, Rank2.Traversable g, FactorialMonoid s) =>
                 g (LeftRecursive.'Fixed g s) -> s -> g (Compose ParseResults [])

Associated Types

type ResultFunctor (Fixed Parser :: ((* -> *) -> *) -> * -> * -> *) :: * -> *

type GrammarConstraint (Fixed Parser :: ((* -> *) -> *) -> * -> * -> *) (g :: (* -> *) -> *) :: Constraint

Methods

parseComplete :: (GrammarConstraint (Fixed Parser) g, FactorialMonoid s) => g (Fixed Parser g s) -> s -> g (ResultFunctor (Fixed Parser))

parsePrefix :: (GrammarConstraint (Fixed Parser) g, FactorialMonoid s) => g (Fixed Parser g s) -> s -> g (Compose * * (ResultFunctor (Fixed Parser)) ((,) s))

showFailure :: TextualMonoid s => s -> ParseFailure -> Int -> String

Given the textual parse input, the parse failure on the input, and the number of lines preceding the failure to show, produce a human-readable failure description.

simply :: (Only r (p (Only r) s) -> s -> Only r f) -> p (Only r) s r -> s -> f r

Apply the given parse function to the given grammar-free parser and its input.

Types

type Grammar (g :: (* -> *) -> *) p s = g (p g s)

A type synonym for a fixed grammar record type g with a given parser type p on input streams of type s

type GrammarBuilder (g :: (* -> *) -> *) (g' :: (* -> *) -> *) (p :: ((* -> *) -> *) -> * -> * -> *) (s :: *) = g (p g' s) -> g (p g' s)

A type synonym for an endomorphic function on a grammar record type g, whose parsers of type p build grammars of type g', parsing input streams of type s

type ParseResults = Either ParseFailure

data ParseFailure

A ParseFailure contains the offset of the parse failure and the list of things expected at that offset.

Constructors

ParseFailure Int [String]

Instances

Eq ParseFailure

Methods

(==) :: ParseFailure -> ParseFailure -> Bool

(/=) :: ParseFailure -> ParseFailure -> Bool

Show ParseFailure

Methods

showsPrec :: Int -> ParseFailure -> ShowS

show :: ParseFailure -> String

showList :: [ParseFailure] -> ShowS

newtype Ambiguous a

An Ambiguous parse result, produced by the ambiguous combinator, contains a NonEmpty list of alternative results.

Constructors

Ambiguous (NonEmpty a)

Instances

Functor Ambiguous

Methods

fmap :: (a -> b) -> Ambiguous a -> Ambiguous b

(<$) :: a -> Ambiguous b -> Ambiguous a

Show1 Ambiguous

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Ambiguous a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Ambiguous a] -> ShowS

Eq a => Eq (Ambiguous a)

Methods

(==) :: Ambiguous a -> Ambiguous a -> Bool

(/=) :: Ambiguous a -> Ambiguous a -> Bool

Data a => Data (Ambiguous a)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ambiguous a -> c (Ambiguous a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Ambiguous a)

toConstr :: Ambiguous a -> Constr

dataTypeOf :: Ambiguous a -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Ambiguous a))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ambiguous a))

gmapT :: (forall b. Data b => b -> b) -> Ambiguous a -> Ambiguous a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ambiguous a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ambiguous a -> r

gmapQ :: (forall d. Data d => d -> u) -> Ambiguous a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Ambiguous a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ambiguous a -> m (Ambiguous a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ambiguous a -> m (Ambiguous a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ambiguous a -> m (Ambiguous a)

Ord a => Ord (Ambiguous a)

Methods

compare :: Ambiguous a -> Ambiguous a -> Ordering

(<) :: Ambiguous a -> Ambiguous a -> Bool

(<=) :: Ambiguous a -> Ambiguous a -> Bool

(>) :: Ambiguous a -> Ambiguous a -> Bool

(>=) :: Ambiguous a -> Ambiguous a -> Bool

max :: Ambiguous a -> Ambiguous a -> Ambiguous a

min :: Ambiguous a -> Ambiguous a -> Ambiguous a

Show a => Show (Ambiguous a)

Methods

showsPrec :: Int -> Ambiguous a -> ShowS

show :: Ambiguous a -> String

showList :: [Ambiguous a] -> ShowS

Parser combinators and primitives

class MultiParsing m => GrammarParsing m where

Parsers that belong to this class can memoize the parse results to avoid exponential performance complexity.

Minimal complete definition

nonTerminal

Associated Types

type GrammarFunctor m :: ((* -> *) -> *) -> * -> * -> *

Methods

nonTerminal :: GrammarConstraint m g => (g (GrammarFunctor m g s) -> GrammarFunctor m g s a) -> m g s a

Used to reference a grammar production, only necessary from outside the grammar itself

selfReferring :: (GrammarConstraint m g, Distributive g) => g (m g s)

Construct a grammar whose every production refers to itself.

fixGrammar :: forall g s. (GrammarConstraint m g, Distributive g) => (g (m g s) -> g (m g s)) -> g (m g s)

Convert a self-referring grammar function to a grammar.

recursive :: m g s a -> m g s a

Mark a parser that relies on primitive recursion to prevent an infinite loop in fixGrammar.

Instances

GrammarParsing Parser

Associated Types

type GrammarFunctor (Parser :: ((* -> *) -> *) -> * -> * -> *) :: ((* -> *) -> *) -> * -> * -> *

Methods

nonTerminal :: GrammarConstraint Parser g => (g (GrammarFunctor Parser g s) -> GrammarFunctor Parser g s a) -> Parser g s a

selfReferring :: (GrammarConstraint Parser g, Distributive * g) => g (Parser g s)

fixGrammar :: (GrammarConstraint Parser g, Distributive * g) => (g (Parser g s) -> g (Parser g s)) -> g (Parser g s)

recursive :: Parser g s a -> Parser g s a

GrammarParsing Parser

Associated Types

type GrammarFunctor (Parser :: ((* -> *) -> *) -> * -> * -> *) :: ((* -> *) -> *) -> * -> * -> *

Methods

nonTerminal :: GrammarConstraint Parser g => (g (GrammarFunctor Parser g s) -> GrammarFunctor Parser g s a) -> Parser g s a

selfReferring :: (GrammarConstraint Parser g, Distributive * g) => g (Parser g s)

fixGrammar :: (GrammarConstraint Parser g, Distributive * g) => (g (Parser g s) -> g (Parser g s)) -> g (Parser g s)

recursive :: Parser g s a -> Parser g s a

GrammarParsing Parser

Associated Types

type GrammarFunctor (Parser :: ((* -> *) -> *) -> * -> * -> *) :: ((* -> *) -> *) -> * -> * -> *

Methods

nonTerminal :: GrammarConstraint Parser g => (g (GrammarFunctor Parser g s) -> GrammarFunctor Parser g s a) -> Parser g s a

selfReferring :: (GrammarConstraint Parser g, Distributive * g) => g (Parser g s)

fixGrammar :: (GrammarConstraint Parser g, Distributive * g) => (g (Parser g s) -> g (Parser g s)) -> g (Parser g s)

recursive :: Parser g s a -> Parser g s a

GrammarParsing (Fixed Parser)

Associated Types

type GrammarFunctor (Fixed Parser :: ((* -> *) -> *) -> * -> * -> *) :: ((* -> *) -> *) -> * -> * -> *

Methods

nonTerminal :: GrammarConstraint (Fixed Parser) g => (g (GrammarFunctor (Fixed Parser) g s) -> GrammarFunctor (Fixed Parser) g s a) -> Fixed Parser g s a

selfReferring :: (GrammarConstraint (Fixed Parser) g, Distributive * g) => g (Fixed Parser g s)

fixGrammar :: (GrammarConstraint (Fixed Parser) g, Distributive * g) => (g (Fixed Parser g s) -> g (Fixed Parser g s)) -> g (Fixed Parser g s)

recursive :: Fixed Parser g s a -> Fixed Parser g s a

class MonoidParsing m where

Methods for parsing monoidal inputs

Minimal complete definition

endOfInput, getInput, anyToken, satisfy, satisfyChar, satisfyCharInput, notSatisfy, notSatisfyChar, scan, scanChars, string, takeWhile, takeWhile1, takeCharsWhile, takeCharsWhile1

Methods

endOfInput :: FactorialMonoid s => m s ()

A parser that fails on any input and succeeds at its end.

getInput :: FactorialMonoid s => m s s

Always sucessful parser that returns the remaining input without consuming it.

anyToken :: FactorialMonoid s => m s s

A parser that accepts any single input atom.

satisfy :: FactorialMonoid s => (s -> Bool) -> m s s

A parser that accepts an input atom only if it satisfies the given predicate.

satisfyChar :: TextualMonoid s => (Char -> Bool) -> m s Char

Specialization of satisfy on TextualMonoid inputs, accepting and returning an input character only if it satisfies the given predicate.

satisfyCharInput :: TextualMonoid s => (Char -> Bool) -> m s s

Specialization of satisfy on TextualMonoid inputs, accepting an input character only if it satisfies the given predicate, and returning the input atom that represents the character. A faster version of singleton $ satisfyChar p and of satisfy (fromMaybe False p . characterPrefix).

notSatisfy :: FactorialMonoid s => (s -> Bool) -> m s ()

A parser that succeeds exactly when satisfy doesn't, equivalent to notFollowedBy . satisfy

notSatisfyChar :: TextualMonoid s => (Char -> Bool) -> m s ()

A parser that succeeds exactly when satisfyChar doesn't, equivalent to notFollowedBy . satisfyChar

scan :: FactorialMonoid t => s -> (s -> t -> Maybe s) -> m t t

A stateful scanner. The predicate modifies a state argument, and each transformed state is passed to successive invocations of the predicate on each token of the input until one returns Nothing or the input ends.

This parser does not fail. It will return an empty string if the predicate returns Nothing on the first character.

Note: Because this parser does not fail, do not use it with combinators such as many, because such parsers loop until a failure occurs. Careless use will thus result in an infinite loop.

scanChars :: TextualMonoid t => s -> (s -> Char -> Maybe s) -> m t t

Stateful scanner like scanChars, but specialized for TextualMonoid inputs.

string :: (FactorialMonoid s, LeftReductiveMonoid s, Show s) => s -> m s s

A parser that consumes and returns the given prefix of the input.

takeWhile :: FactorialMonoid s => (s -> Bool) -> m s s

A parser accepting the longest sequence of input atoms that match the given predicate; an optimized version of 'concatMany . satisfy'.

Note: Because this parser does not fail, do not use it with combinators such as many, because such parsers loop until a failure occurs. Careless use will thus result in an infinite loop.

takeWhile1 :: FactorialMonoid s => (s -> Bool) -> m s s

A parser accepting the longest non-empty sequence of input atoms that match the given predicate; an optimized version of 'concatSome . satisfy'.

takeCharsWhile :: TextualMonoid s => (Char -> Bool) -> m s s

Specialization of takeWhile on TextualMonoid inputs, accepting the longest sequence of input characters that match the given predicate; an optimized version of 'fmap fromString . many . satisfyChar'.

Note: Because this parser does not fail, do not use it with combinators such as many, because such parsers loop until a failure occurs. Careless use will thus result in an infinite loop.

takeCharsWhile1 :: TextualMonoid s => (Char -> Bool) -> m s s

Specialization of takeWhile1 on TextualMonoid inputs, accepting the longest sequence of input characters that match the given predicate; an optimized version of 'fmap fromString . some . satisfyChar'.

concatMany :: Monoid a => m s a -> m s a

Zero or more argument occurrences like many, with concatenated monoidal results.

concatMany :: (Monoid a, Alternative (m s)) => m s a -> m s a

Zero or more argument occurrences like many, with concatenated monoidal results.

Instances

MonoidParsing (Parser g)

Methods

endOfInput :: FactorialMonoid s => Parser g s ()

getInput :: FactorialMonoid s => Parser g s s

anyToken :: FactorialMonoid s => Parser g s s

satisfy :: FactorialMonoid s => (s -> Bool) -> Parser g s s

satisfyChar :: TextualMonoid s => (Char -> Bool) -> Parser g s Char

satisfyCharInput :: TextualMonoid s => (Char -> Bool) -> Parser g s s

notSatisfy :: FactorialMonoid s => (s -> Bool) -> Parser g s ()

notSatisfyChar :: TextualMonoid s => (Char -> Bool) -> Parser g s ()

scan :: FactorialMonoid t => s -> (s -> t -> Maybe s) -> Parser g t t

scanChars :: TextualMonoid t => s -> (s -> Char -> Maybe s) -> Parser g t t

string :: (FactorialMonoid s, LeftReductiveMonoid s, Show s) => s -> Parser g s s

takeWhile :: FactorialMonoid s => (s -> Bool) -> Parser g s s

takeWhile1 :: FactorialMonoid s => (s -> Bool) -> Parser g s s

takeCharsWhile :: TextualMonoid s => (Char -> Bool) -> Parser g s s

takeCharsWhile1 :: TextualMonoid s => (Char -> Bool) -> Parser g s s

concatMany :: Monoid a => Parser g s a -> Parser g s a

MonoidParsing (Parser g)

Methods

endOfInput :: FactorialMonoid s => Parser g s ()

getInput :: FactorialMonoid s => Parser g s s

anyToken :: FactorialMonoid s => Parser g s s

satisfy :: FactorialMonoid s => (s -> Bool) -> Parser g s s

satisfyChar :: TextualMonoid s => (Char -> Bool) -> Parser g s Char

satisfyCharInput :: TextualMonoid s => (Char -> Bool) -> Parser g s s

notSatisfy :: FactorialMonoid s => (s -> Bool) -> Parser g s ()

notSatisfyChar :: TextualMonoid s => (Char -> Bool) -> Parser g s ()

scan :: FactorialMonoid t => s -> (s -> t -> Maybe s) -> Parser g t t

scanChars :: TextualMonoid t => s -> (s -> Char -> Maybe s) -> Parser g t t

string :: (FactorialMonoid s, LeftReductiveMonoid s, Show s) => s -> Parser g s s

takeWhile :: FactorialMonoid s => (s -> Bool) -> Parser g s s

takeWhile1 :: FactorialMonoid s => (s -> Bool) -> Parser g s s

takeCharsWhile :: TextualMonoid s => (Char -> Bool) -> Parser g s s

takeCharsWhile1 :: TextualMonoid s => (Char -> Bool) -> Parser g s s

concatMany :: Monoid a => Parser g s a -> Parser g s a

MonoidParsing (Parser g)

Methods

endOfInput :: FactorialMonoid s => Parser g s ()

getInput :: FactorialMonoid s => Parser g s s

anyToken :: FactorialMonoid s => Parser g s s

satisfy :: FactorialMonoid s => (s -> Bool) -> Parser g s s

satisfyChar :: TextualMonoid s => (Char -> Bool) -> Parser g s Char

satisfyCharInput :: TextualMonoid s => (Char -> Bool) -> Parser g s s

notSatisfy :: FactorialMonoid s => (s -> Bool) -> Parser g s ()

notSatisfyChar :: TextualMonoid s => (Char -> Bool) -> Parser g s ()

scan :: FactorialMonoid t => s -> (s -> t -> Maybe s) -> Parser g t t

scanChars :: TextualMonoid t => s -> (s -> Char -> Maybe s) -> Parser g t t

string :: (FactorialMonoid s, LeftReductiveMonoid s, Show s) => s -> Parser g s s

takeWhile :: FactorialMonoid s => (s -> Bool) -> Parser g s s

takeWhile1 :: FactorialMonoid s => (s -> Bool) -> Parser g s s

takeCharsWhile :: TextualMonoid s => (Char -> Bool) -> Parser g s s

takeCharsWhile1 :: TextualMonoid s => (Char -> Bool) -> Parser g s s

concatMany :: Monoid a => Parser g s a -> Parser g s a

MonoidParsing (Parser g)

Methods

endOfInput :: FactorialMonoid s => Parser g s ()

getInput :: FactorialMonoid s => Parser g s s

anyToken :: FactorialMonoid s => Parser g s s

satisfy :: FactorialMonoid s => (s -> Bool) -> Parser g s s

satisfyChar :: TextualMonoid s => (Char -> Bool) -> Parser g s Char

satisfyCharInput :: TextualMonoid s => (Char -> Bool) -> Parser g s s

notSatisfy :: FactorialMonoid s => (s -> Bool) -> Parser g s ()

notSatisfyChar :: TextualMonoid s => (Char -> Bool) -> Parser g s ()

scan :: FactorialMonoid t => s -> (s -> t -> Maybe s) -> Parser g t t

scanChars :: TextualMonoid t => s -> (s -> Char -> Maybe s) -> Parser g t t

string :: (FactorialMonoid s, LeftReductiveMonoid s, Show s) => s -> Parser g s s

takeWhile :: FactorialMonoid s => (s -> Bool) -> Parser g s s

takeWhile1 :: FactorialMonoid s => (s -> Bool) -> Parser g s s

takeCharsWhile :: TextualMonoid s => (Char -> Bool) -> Parser g s s

takeCharsWhile1 :: TextualMonoid s => (Char -> Bool) -> Parser g s s

concatMany :: Monoid a => Parser g s a -> Parser g s a

MonoidParsing (Parser g)

Methods

endOfInput :: FactorialMonoid s => Parser g s ()

getInput :: FactorialMonoid s => Parser g s s

anyToken :: FactorialMonoid s => Parser g s s

satisfy :: FactorialMonoid s => (s -> Bool) -> Parser g s s

satisfyChar :: TextualMonoid s => (Char -> Bool) -> Parser g s Char

satisfyCharInput :: TextualMonoid s => (Char -> Bool) -> Parser g s s

notSatisfy :: FactorialMonoid s => (s -> Bool) -> Parser g s ()

notSatisfyChar :: TextualMonoid s => (Char -> Bool) -> Parser g s ()

scan :: FactorialMonoid t => s -> (s -> t -> Maybe s) -> Parser g t t

scanChars :: TextualMonoid t => s -> (s -> Char -> Maybe s) -> Parser g t t

string :: (FactorialMonoid s, LeftReductiveMonoid s, Show s) => s -> Parser g s s

takeWhile :: FactorialMonoid s => (s -> Bool) -> Parser g s s

takeWhile1 :: FactorialMonoid s => (s -> Bool) -> Parser g s s

takeCharsWhile :: TextualMonoid s => (Char -> Bool) -> Parser g s s

takeCharsWhile1 :: TextualMonoid s => (Char -> Bool) -> Parser g s s

concatMany :: Monoid a => Parser g s a -> Parser g s a

MonoidParsing (Parser g)

Methods

endOfInput :: FactorialMonoid s => Parser g s ()

getInput :: FactorialMonoid s => Parser g s s

anyToken :: FactorialMonoid s => Parser g s s

satisfy :: FactorialMonoid s => (s -> Bool) -> Parser g s s

satisfyChar :: TextualMonoid s => (Char -> Bool) -> Parser g s Char

satisfyCharInput :: TextualMonoid s => (Char -> Bool) -> Parser g s s

notSatisfy :: FactorialMonoid s => (s -> Bool) -> Parser g s ()

notSatisfyChar :: TextualMonoid s => (Char -> Bool) -> Parser g s ()

scan :: FactorialMonoid t => s -> (s -> t -> Maybe s) -> Parser g t t

scanChars :: TextualMonoid t => s -> (s -> Char -> Maybe s) -> Parser g t t

string :: (FactorialMonoid s, LeftReductiveMonoid s, Show s) => s -> Parser g s s

takeWhile :: FactorialMonoid s => (s -> Bool) -> Parser g s s

takeWhile1 :: FactorialMonoid s => (s -> Bool) -> Parser g s s

takeCharsWhile :: TextualMonoid s => (Char -> Bool) -> Parser g s s

takeCharsWhile1 :: TextualMonoid s => (Char -> Bool) -> Parser g s s

concatMany :: Monoid a => Parser g s a -> Parser g s a

MonoidParsing (Fixed Parser g)

Methods

endOfInput :: FactorialMonoid s => Fixed Parser g s ()

getInput :: FactorialMonoid s => Fixed Parser g s s

anyToken :: FactorialMonoid s => Fixed Parser g s s

satisfy :: FactorialMonoid s => (s -> Bool) -> Fixed Parser g s s

satisfyChar :: TextualMonoid s => (Char -> Bool) -> Fixed Parser g s Char

satisfyCharInput :: TextualMonoid s => (Char -> Bool) -> Fixed Parser g s s

notSatisfy :: FactorialMonoid s => (s -> Bool) -> Fixed Parser g s ()

notSatisfyChar :: TextualMonoid s => (Char -> Bool) -> Fixed Parser g s ()

scan :: FactorialMonoid t => s -> (s -> t -> Maybe s) -> Fixed Parser g t t

scanChars :: TextualMonoid t => s -> (s -> Char -> Maybe s) -> Fixed Parser g t t

string :: (FactorialMonoid s, LeftReductiveMonoid s, Show s) => s -> Fixed Parser g s s

takeWhile :: FactorialMonoid s => (s -> Bool) -> Fixed Parser g s s

takeWhile1 :: FactorialMonoid s => (s -> Bool) -> Fixed Parser g s s

takeCharsWhile :: TextualMonoid s => (Char -> Bool) -> Fixed Parser g s s

takeCharsWhile1 :: TextualMonoid s => (Char -> Bool) -> Fixed Parser g s s

concatMany :: Monoid a => Fixed Parser g s a -> Fixed Parser g s a

class AmbiguousParsing m where

Parsers that can produce alternative parses and collect them into an Ambiguous node

Minimal complete definition

ambiguous

Methods

ambiguous :: m a -> m (Ambiguous a)

Collect all alternative parses of the same length into a NonEmpty list of results.

Instances

AmbiguousParsing (Parser g s)

Methods

ambiguous :: Parser g s a -> Parser g s (Ambiguous a)

AmbiguousParsing (Fixed Parser g s)

Methods

ambiguous :: Fixed Parser g s a -> Fixed Parser g s (Ambiguous a)

class Lexical (g :: (* -> *) -> *) where

If a grammar is Lexical, its parsers can instantiate the TokenParsing class.

Associated Types

type LexicalConstraint (m :: ((* -> *) -> *) -> * -> * -> *) g s :: Constraint

Methods

lexicalWhiteSpace :: LexicalConstraint m g s => m g s ()

Always succeeds, consuming all white space and comments

someLexicalSpace :: LexicalConstraint m g s => m g s ()

Consumes all whitespace and comments, failing if there are none

lexicalComment :: LexicalConstraint m g s => m g s ()

Consumes a single comment, defaults to empty

lexicalSemicolon :: LexicalConstraint m g s => m g s Char

Consumes a single semicolon and any trailing whitespace, returning the character |';'|. The method can be overridden for automatic semicolon insertion, but if it succeeds on semicolon or white space input it must consume it.

lexicalToken :: LexicalConstraint m g s => m g s a -> m g s a

Applies the argument parser and consumes the trailing lexicalWhitespace

identifierToken :: LexicalConstraint m g s => m g s s -> m g s s

Applies the argument parser, determines whether its result is a legal identifier, and consumes the trailing lexicalWhitespace

isIdentifierStartChar :: Char -> Bool

Determines whether the given character can start an identifier token, allows only a letter or underscore by default

isIdentifierFollowChar :: Char -> Bool

Determines whether the given character can be any part of an identifier token, also allows numbers

identifier :: LexicalConstraint m g s => m g s s

Parses a valid identifier and consumes the trailing lexicalWhitespace

keyword :: LexicalConstraint m g s => s -> m g s ()

Parses the argument word whole, not followed by any identifier character, and consumes the trailing lexicalWhitespace

lexicalComment :: Alternative (m g s) => m g s ()

Consumes a single comment, defaults to empty

lexicalWhiteSpace :: (LexicalConstraint m g s, Parsing (m g s), MonoidParsing (m g), TextualMonoid s) => m g s ()

Always succeeds, consuming all white space and comments

someLexicalSpace :: (LexicalConstraint m g s, Parsing (m g s), MonoidParsing (m g), TextualMonoid s) => m g s ()

Consumes all whitespace and comments, failing if there are none

lexicalSemicolon :: (LexicalConstraint m g s, CharParsing (m g s), MonoidParsing (m g), TextualMonoid s) => m g s Char

Consumes a single semicolon and any trailing whitespace, returning the character |';'|. The method can be overridden for automatic semicolon insertion, but if it succeeds on semicolon or white space input it must consume it.

lexicalToken :: (LexicalConstraint m g s, Parsing (m g s), MonoidParsing (m g), TextualMonoid s) => m g s a -> m g s a

Applies the argument parser and consumes the trailing lexicalWhitespace

identifierToken :: (LexicalConstraint m g s, Parsing (m g s), MonoidParsing (m g), TextualMonoid s) => m g s s -> m g s s

Applies the argument parser, determines whether its result is a legal identifier, and consumes the trailing lexicalWhitespace

identifier :: (LexicalConstraint m g s, Monad (m g s), Alternative (m g s), Parsing (m g s), MonoidParsing (m g), TextualMonoid s) => m g s s

Parses a valid identifier and consumes the trailing lexicalWhitespace

keyword :: (LexicalConstraint m g s, Parsing (m g s), MonoidParsing (m g), Show s, TextualMonoid s) => s -> m g s ()

Parses the argument word whole, not followed by any identifier character, and consumes the trailing lexicalWhitespace

module Text.Parser.Char

module Text.Parser.Combinators

module Text.Parser.LookAhead