| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Text.Grampa
Description
This library consists of a collection of parsing algorithms and a common interface for representing grammars as records with rank-2 field types.
To implement a grammar, first determine if it is a context-free grammar or perhaps a parsing expression grammar. In the latter case, you should import your parser type from either Text.Grampa.PEG.Backtrack or the Text.Grampa.PEG.Packrat module. The former is faster on simple grammars but may require exponential time on more complex cases. The Packrat parser on the other hand guarantees linear time complexity but has more overhead and consumes more memory.
If your grammar is context-free, there are more possibilities to choose from:
- If the grammar is neither left-recursive nor ambiguous, you can import your parser type from Text.Grampa.ContextFree.Continued.
- If the grammar is ambiguous and you need to see all the results, there's Text.Grampa.ContextFree.Parallel.
- For a complex but non-left-recursive grammar, you can use Text.Grampa.ContextFree.SortedMemoizing.
- If you need to carry a monadic computation, there's Text.Grampa.ContextFree.SortedMemoizing.Transformer.
- If the grammar is left-recursive, Text.Grampa.ContextFree.SortedMemoizing.LeftRecursive is the ticket.
- If the grammar is left-recursive and you require monadic context, the final option is Text.Grampa.ContextFree.SortedMemoizing.Transformer.LeftRecursive.
Regardless of the chosen parer type, you'll construct your grammar the same way. A grammar is a set of productions
using the same parser type, collected and abstracted inside a rank-2 record type. Each production is built using
the standard parser combinators from the usual Applicative and Alternative classes, plus some additional
classes provided by this library. The Monad operations are available as well, but should not be
used in left-recursive positions.
Once the grammar is complete, you can use parseComplete or parsePrefix to apply it to your input.
Synopsis
- failureDescription :: (Ord s, TextualMonoid s, Position pos) => s -> ParseFailure pos s -> Int -> s
- simply :: (Only r (p (Only r) s) -> s -> Only r f) -> p (Only r) s r -> s -> f r
- type Grammar (g :: (Type -> Type) -> Type) (p :: ((Type -> Type) -> Type) -> Type -> Type -> Type) s = g (p g s)
- type GrammarBuilder (g :: (Type -> Type) -> Type) (g' :: (Type -> Type) -> Type) (p :: ((Type -> Type) -> Type) -> Type -> Type -> Type) s = g (p g' s) -> g (p g' s)
- type GrammarOverlay (g :: (Type -> Type) -> Type) (m :: Type -> Type) = g m -> g m -> g m
- type ParseResults s = Either (ParseFailure Pos s)
- data ParseFailure pos s = ParseFailure {
- failurePosition :: pos
- expectedAlternatives :: FailureDescription s
- errorAlternatives :: [String]
- data FailureDescription s = FailureDescription {
- staticDescriptions :: [String]
- literalDescriptions :: [s]
- newtype Ambiguous a = Ambiguous {
- getAmbiguous :: NonEmpty a
- type Pos = Down Int
- class Parsing m => DeterministicParsing (m :: Type -> Type) where
- class Alternative m => AmbiguousParsing (m :: Type -> Type) where
- class Alternative m => CommittedParsing (m :: Type -> Type) where
- type CommittedResults (m :: Type -> Type) :: Type -> Type
- commit :: m a -> m (CommittedResults m a)
- admit :: m (CommittedResults m a) -> m a
- class InputParsing m => TraceableParsing (m :: Type -> Type) where
- traceInput :: (ParserInput m -> String) -> m a -> m a
- traceAs :: Show (ParserInput m) => String -> m a -> m a
- class (DeterministicParsing m, InputCharParsing m, TokenParsing m) => LexicalParsing (m :: Type -> Type) where
- lexicalWhiteSpace :: m ()
- someLexicalSpace :: m ()
- lexicalComment :: m ()
- lexicalSemicolon :: m Char
- lexicalToken :: m a -> m a
- identifierToken :: m (ParserInput m) -> m (ParserInput m)
- isIdentifierStartChar :: Char -> Bool
- isIdentifierFollowChar :: Char -> Bool
- identifier :: m (ParserInput m)
- keyword :: ParserInput m -> m ()
- class InputParsing m => MultiParsing (m :: Type -> Type) where
- type ResultFunctor (m :: Type -> Type) :: Type -> Type
- type GrammarConstraint (m :: Type -> Type) (g :: (Type -> Type) -> Type)
- parseComplete :: (ParserInput m ~ s, GrammarConstraint m g, Eq s, FactorialMonoid s) => g m -> s -> g (ResultFunctor m)
- parsePrefix :: (ParserInput m ~ s, GrammarConstraint m g, Eq s, FactorialMonoid s) => g m -> s -> g (Compose (ResultFunctor m) ((,) s))
- class MultiParsing m => GrammarParsing (m :: Type -> Type) where
- type ParserGrammar (m :: Type -> Type) :: (Type -> Type) -> Type
- type GrammarFunctor (m :: Type -> Type) :: Type -> Type
- parsingResult :: ParserInput m -> GrammarFunctor m a -> ResultFunctor m (ParserInput m, a)
- nonTerminal :: (g ~ ParserGrammar m, GrammarConstraint m g) => (g (GrammarFunctor m) -> GrammarFunctor m a) -> m a
- selfReferring :: (g ~ ParserGrammar m, GrammarConstraint m g, Distributive g) => g m
- fixGrammar :: (g ~ ParserGrammar m, GrammarConstraint m g, Distributive g) => (g m -> g m) -> g m
- recursive :: m a -> m a
- chainRecursive :: (g ~ ParserGrammar m, f ~ GrammarFunctor m, GrammarConstraint m g) => (f a -> g f -> g f) -> m a -> m a -> m a
- chainLongestRecursive :: (g ~ ParserGrammar m, f ~ GrammarFunctor m, GrammarConstraint m g) => (f a -> g f -> g f) -> m a -> m a -> m a
- overlay :: forall (m :: Type -> Type) g f. (GrammarParsing m, g ~ ParserGrammar m, GrammarConstraint m g, Distributive g, Foldable f) => (g m -> g m) -> f (GrammarOverlay g m) -> g m
- class LookAheadParsing m => InputParsing (m :: Type -> Type) where
- type ParserInput (m :: Type -> Type)
- type ParserPosition (m :: Type -> Type)
- getInput :: m (ParserInput m)
- getSourcePos :: m (ParserPosition m)
- anyToken :: m (ParserInput m)
- take :: Int -> m (ParserInput m)
- satisfy :: (ParserInput m -> Bool) -> m (ParserInput m)
- notSatisfy :: (ParserInput m -> Bool) -> m ()
- scan :: state -> (state -> ParserInput m -> Maybe state) -> m (ParserInput m)
- string :: ParserInput m -> m (ParserInput m)
- takeWhile :: (ParserInput m -> Bool) -> m (ParserInput m)
- takeWhile1 :: (ParserInput m -> Bool) -> m (ParserInput m)
- class (CharParsing m, InputParsing m) => InputCharParsing (m :: Type -> Type) where
- satisfyCharInput :: (Char -> Bool) -> m (ParserInput m)
- notSatisfyChar :: (Char -> Bool) -> m ()
- scanChars :: state -> (state -> Char -> Maybe state) -> m (ParserInput m)
- takeCharsWhile :: (Char -> Bool) -> m (ParserInput m)
- takeCharsWhile1 :: (Char -> Bool) -> m (ParserInput m)
- class InputParsing m => ConsumedInputParsing (m :: Type -> Type) where
- match :: m a -> m (ParserInput m, a)
- class Ord p => Position p where
- class Parsing m => CharParsing (m :: Type -> Type) where
- class Alternative m => Parsing (m :: Type -> Type) where
- (<?>) :: m a -> String -> m a
- skipMany :: m a -> m ()
- skipSome :: m a -> m ()
- unexpected :: String -> m a
- notFollowedBy :: Show a => m a -> m ()
- module Text.Parser.LookAhead
- class CharParsing m => TokenParsing (m :: Type -> Type) where
- concatMany :: (Alternative p, Monoid a) => p a -> p a
- concatSome :: (Alternative p, Semigroup a) => p a -> p a
Applying parsers
failureDescription :: (Ord s, TextualMonoid s, Position pos) => s -> ParseFailure pos s -> Int -> s Source #
Given the textual parse input, the parse failure on the input, and the number of preceding lines of context you want 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 Source #
Apply the given parsing function (typically parseComplete or parsePrefix) to the given grammar-agnostic
parser and its input. A typical invocation might be
getCompose $ simply parsePrefix myParser myInput
Types
type Grammar (g :: (Type -> Type) -> Type) (p :: ((Type -> Type) -> Type) -> Type -> Type -> Type) s = g (p g s) Source #
A grammar is a record type g whose fields are parsers of type p on input streams of type s. A value of a
Grammar type is typically produced by applying fixGrammar or overlay to a GrammarBuilder.
type GrammarBuilder (g :: (Type -> Type) -> Type) (g' :: (Type -> Type) -> Type) (p :: ((Type -> Type) -> Type) -> Type -> Type -> Type) s = g (p g' s) -> g (p g' s) Source #
A GrammarBuilder g g' p s is an endomorphic function on a grammar g, whose parsers of type p build on
grammars of type g' and parse an input stream of type s. Grammar parameters g and g' are typically
identical in simple monolithic grammars, but when composing complex grammars the first grammar parameter g would
be just a building block for the final grammar g'.
type GrammarOverlay (g :: (Type -> Type) -> Type) (m :: Type -> Type) = g m -> g m -> g m Source #
A grammar overlay is a function that takes a final grammar self and the parent grammar super and builds a new
grammar from them. Use overlay to apply a colection of overlays on top of a base grammar.
type ParseResults s = Either (ParseFailure Pos s) Source #
A parse results in either a ParseFailure or the result of the appropriate type.
data ParseFailure pos s Source #
A ParseFailure contains the offset of the parse failure and the list of things expected at that offset.
Constructors
| ParseFailure | |
Fields
| |
Instances
data FailureDescription s Source #
An expected or erroneous input can be described using String or using the input type
Constructors
| FailureDescription | |
Fields
| |
Instances
An Ambiguous parse result, produced by the ambiguous combinator, contains a NonEmpty list of
alternative results.
Constructors
| Ambiguous | |
Fields
| |
Instances
| Foldable Ambiguous Source # | |
Defined in Text.Grampa.Class Methods fold :: Monoid m => Ambiguous m -> m # foldMap :: Monoid m => (a -> m) -> Ambiguous a -> m # foldMap' :: Monoid m => (a -> m) -> Ambiguous a -> m # foldr :: (a -> b -> b) -> b -> Ambiguous a -> b # foldr' :: (a -> b -> b) -> b -> Ambiguous a -> b # foldl :: (b -> a -> b) -> b -> Ambiguous a -> b # foldl' :: (b -> a -> b) -> b -> Ambiguous a -> b # foldr1 :: (a -> a -> a) -> Ambiguous a -> a # foldl1 :: (a -> a -> a) -> Ambiguous a -> a # toList :: Ambiguous a -> [a] # length :: Ambiguous a -> Int # elem :: Eq a => a -> Ambiguous a -> Bool # maximum :: Ord a => Ambiguous a -> a # minimum :: Ord a => Ambiguous a -> a # | |
| Show1 Ambiguous Source # | |
| Traversable Ambiguous Source # | |
Defined in Text.Grampa.Class | |
| Applicative Ambiguous Source # | |
| Functor Ambiguous Source # | |
| Monad Ambiguous Source # | |
| Data a => Data (Ambiguous a) Source # | |
Defined in Text.Grampa.Class 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 :: forall r r'. (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) # | |
| Monoid a => Monoid (Ambiguous a) Source # | |
| Semigroup a => Semigroup (Ambiguous a) Source # | |
| Show a => Show (Ambiguous a) Source # | |
| Eq a => Eq (Ambiguous a) Source # | |
| Ord a => Ord (Ambiguous a) Source # | |
Defined in Text.Grampa.Class | |
| AmbiguityDecidable (Ambiguous a) Source # | |
Defined in Text.Grampa.Internal Methods ambiguityWitness :: Maybe (AmbiguityWitness (Ambiguous a)) | |
Classes
Parsing
class Parsing m => DeterministicParsing (m :: Type -> Type) where #
Combinator methods for constructing deterministic parsers, i.e., parsers that can succeed with only a single result.
Minimal complete definition
Nothing
Methods
(<<|>) :: m a -> m a -> m a infixl 3 #
Left-biased choice: if the left alternative succeeds, the right one is never tried.
takeOptional :: m a -> m (Maybe a) #
Like optional, but never succeeds with Nothing if the argument parser can succeed.
Like many, but always consuming the longest matching sequence of input.
Like some, but always consuming the longest matching sequence of input.
concatAll :: Monoid a => m a -> m a #
Like concatMany, but always consuming the longest matching sequence of input.
Like skipMany, but always consuming the longest matching sequence of input.
Instances
class Alternative m => AmbiguousParsing (m :: Type -> Type) where Source #
Parsers that can produce alternative parses and collect them into an Ambiguous node
Methods
ambiguous :: m a -> m (Ambiguous a) Source #
Collect all alternative parses of the same length into a NonEmpty list of results.
Instances
| Ord s => AmbiguousParsing (Parser g s) Source # | |
| (Applicative m, Eq (m ()), Ord s) => AmbiguousParsing (ParserT m g s) Source # | |
| (AmbiguousParsing (p g s), Apply g) => AmbiguousParsing (Fixed p g s) Source # | |
class Alternative m => CommittedParsing (m :: Type -> Type) where Source #
Parsers that can temporarily package and delay failure, in a way dual to Parsec's try combinator. Where Parsec
would require something like
alternatives = try intro1 *> expected1
<|> try intro2 *> expected2
<|> fallbackyou can instead say
alternatives = admit $ intro1 *> commit expected1
<|> intro2 *> commit expected2
<|> commit fallbackA parsing failure inside an intro parser leaves the other alternatives open, a failure inside an expected
parser bubbles up and out of the whole admit block.
Methods
commit :: m a -> m (CommittedResults m a) Source #
Commits the argument parser to success.
admit :: m (CommittedResults m a) -> m a Source #
Admits a possible defeat of the argument parser.
Instances
class InputParsing m => TraceableParsing (m :: Type -> Type) where Source #
The class of parsers whose execution can be traced for debugging purposes
Minimal complete definition
Methods
traceInput :: (ParserInput m -> String) -> m a -> m a Source #
Modify the argument parser to log its input whenever invoked.
traceAs :: Show (ParserInput m) => String -> m a -> m a Source #
Modify the argument parser to log the given description and its input whenever invoked.
Instances
| (InputParsing (Parser g s), FactorialMonoid s) => TraceableParsing (Parser g s) Source # | |
Defined in Text.Grampa.ContextFree.Continued | |
| InputParsing (Parser g s) => TraceableParsing (Parser g s) Source # | |
Defined in Text.Grampa.ContextFree.Memoizing | |
| (FactorialMonoid s, InputParsing (Parser g s)) => TraceableParsing (Parser g s) Source # | |
Defined in Text.Grampa.ContextFree.Parallel | |
| (InputParsing (Parser g s), FactorialMonoid s) => TraceableParsing (Parser g s) Source # | |
Defined in Text.Grampa.ContextFree.SortedMemoizing | |
| (InputParsing (Parser g s), FactorialMonoid s) => TraceableParsing (Parser g s) Source # | |
Defined in Text.Grampa.PEG.Backtrack | |
| (InputParsing (Parser g s), FactorialMonoid s) => TraceableParsing (Parser g s) Source # | |
Defined in Text.Grampa.PEG.Packrat | |
| (InputParsing (ParserT m g s), FactorialMonoid s) => TraceableParsing (ParserT m g s) Source # | |
| (Apply g, LeftReductive s, FactorialMonoid s, Show s, TraceableParsing (p g s), ParserInput (p g s) ~ s) => TraceableParsing (Fixed p g s) Source # | |
Defined in Text.Grampa.Internal.LeftRecursive | |
class (DeterministicParsing m, InputCharParsing m, TokenParsing m) => LexicalParsing (m :: Type -> Type) where Source #
If a grammar is Lexical, its parsers can instantiate the TokenParsing class.
Minimal complete definition
Nothing
Methods
lexicalWhiteSpace :: m () Source #
Always succeeds, consuming all white space and comments
someLexicalSpace :: m () Source #
Consumes all whitespace and comments, failing if there are none
lexicalComment :: m () Source #
Consumes a single comment, defaults to empty
lexicalSemicolon :: m Char Source #
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 :: m a -> m a Source #
Applies the argument parser and consumes the trailing lexicalWhitespace
identifierToken :: m (ParserInput m) -> m (ParserInput m) Source #
Applies the argument parser, determines whether its result is a legal identifier, and consumes the trailing
lexicalWhitespace
isIdentifierStartChar :: Char -> Bool Source #
Determines whether the given character can start an identifier token, allows only a letter or underscore by default
isIdentifierFollowChar :: Char -> Bool Source #
Determines whether the given character can be any part of an identifier token, also allows numbers
identifier :: m (ParserInput m) Source #
Parses a valid identifier and consumes the trailing lexicalWhitespace
default identifier :: TextualMonoid (ParserInput m) => m (ParserInput m) Source #
keyword :: ParserInput m -> m () Source #
Parses the argument word whole, not followed by any identifier character, and consumes the trailing
lexicalWhitespace
default keyword :: (Show (ParserInput m), TextualMonoid (ParserInput m)) => ParserInput m -> m () Source #
Grammars
class InputParsing m => MultiParsing (m :: Type -> Type) where Source #
Choose one of the instances of this class to parse with.
Associated Types
type ResultFunctor (m :: Type -> Type) :: Type -> Type Source #
Some parser types produce a single result, others a list of results.
type GrammarConstraint (m :: Type -> Type) (g :: (Type -> Type) -> Type) Source #
Methods
parseComplete :: (ParserInput m ~ s, GrammarConstraint m g, Eq s, FactorialMonoid s) => g m -> s -> g (ResultFunctor m) Source #
Given a rank-2 record of parsers and input, produce a record of parses of the complete input.
parsePrefix :: (ParserInput m ~ s, GrammarConstraint m g, Eq s, FactorialMonoid s) => g m -> s -> g (Compose (ResultFunctor m) ((,) s)) Source #
Given a rank-2 record of parsers and input, produce a record of prefix parses paired with the remaining input suffix.
Instances
| (LeftReductive s, FactorialMonoid s, Ord s) => MultiParsing (Parser g s) Source # | Continuation-passing context-free parser
| ||||
Defined in Text.Grampa.ContextFree.Continued Associated Types
Methods parseComplete :: (ParserInput (Parser g s) ~ s0, GrammarConstraint (Parser g s) g0, Eq s0, FactorialMonoid s0) => g0 (Parser g s) -> s0 -> g0 (ResultFunctor (Parser g s)) Source # parsePrefix :: (ParserInput (Parser g s) ~ s0, GrammarConstraint (Parser g s) g0, Eq s0, FactorialMonoid s0) => g0 (Parser g s) -> s0 -> g0 (Compose (ResultFunctor (Parser g s)) ((,) s0)) Source # | |||||
| (LeftReductive s, FactorialMonoid s, Ord s) => MultiParsing (Parser g s) Source # | Memoizing parser guarantees O(n²) performance for grammars with unambiguous productions, but provides no left recursion support.
| ||||
Defined in Text.Grampa.ContextFree.Memoizing Associated Types
Methods parseComplete :: (ParserInput (Parser g s) ~ s0, GrammarConstraint (Parser g s) g0, Eq s0, FactorialMonoid s0) => g0 (Parser g s) -> s0 -> g0 (ResultFunctor (Parser g s)) Source # parsePrefix :: (ParserInput (Parser g s) ~ s0, GrammarConstraint (Parser g s) g0, Eq s0, FactorialMonoid s0) => g0 (Parser g s) -> s0 -> g0 (Compose (ResultFunctor (Parser g s)) ((,) s0)) Source # | |||||
| (LeftReductive s, FactorialMonoid s, Ord s) => MultiParsing (Parser g s) Source # | Parallel parser produces a list of all possible parses.
| ||||
Defined in Text.Grampa.ContextFree.Parallel Associated Types
Methods parseComplete :: (ParserInput (Parser g s) ~ s0, GrammarConstraint (Parser g s) g0, Eq s0, FactorialMonoid s0) => g0 (Parser g s) -> s0 -> g0 (ResultFunctor (Parser g s)) Source # parsePrefix :: (ParserInput (Parser g s) ~ s0, GrammarConstraint (Parser g s) g0, Eq s0, FactorialMonoid s0) => g0 (Parser g s) -> s0 -> g0 (Compose (ResultFunctor (Parser g s)) ((,) s0)) Source # | |||||
| (LeftReductive s, FactorialMonoid s, Ord s) => MultiParsing (Parser g s) Source # | Memoizing parser guarantees O(n²) performance for grammars with unambiguous productions. Can be wrapped with
| ||||
Defined in Text.Grampa.ContextFree.SortedMemoizing Associated Types
Methods parseComplete :: (ParserInput (Parser g s) ~ s0, GrammarConstraint (Parser g s) g0, Eq s0, FactorialMonoid s0) => g0 (Parser g s) -> s0 -> g0 (ResultFunctor (Parser g s)) Source # parsePrefix :: (ParserInput (Parser g s) ~ s0, GrammarConstraint (Parser g s) g0, Eq s0, FactorialMonoid s0) => g0 (Parser g s) -> s0 -> g0 (Compose (ResultFunctor (Parser g s)) ((,) s0)) Source # | |||||
| (LeftReductive s, FactorialMonoid s) => MultiParsing (Parser g s) Source # | Backtracking PEG parser
| ||||
Defined in Text.Grampa.PEG.Backtrack Associated Types
Methods parseComplete :: (ParserInput (Parser g s) ~ s0, GrammarConstraint (Parser g s) g0, Eq s0, FactorialMonoid s0) => g0 (Parser g s) -> s0 -> g0 (ResultFunctor (Parser g s)) Source # parsePrefix :: (ParserInput (Parser g s) ~ s0, GrammarConstraint (Parser g s) g0, Eq s0, FactorialMonoid s0) => g0 (Parser g s) -> s0 -> g0 (Compose (ResultFunctor (Parser g s)) ((,) s0)) Source # | |||||
| (LeftReductive s, FactorialMonoid s) => MultiParsing (Parser g s) Source # | Packrat parser
| ||||
Defined in Text.Grampa.PEG.Packrat Associated Types
Methods parseComplete :: (ParserInput (Parser g s) ~ s0, GrammarConstraint (Parser g s) g0, Eq s0, FactorialMonoid s0) => g0 (Parser g s) -> s0 -> g0 (ResultFunctor (Parser g s)) Source # parsePrefix :: (ParserInput (Parser g s) ~ s0, GrammarConstraint (Parser g s) g0, Eq s0, FactorialMonoid s0) => g0 (Parser g s) -> s0 -> g0 (Compose (ResultFunctor (Parser g s)) ((,) s0)) Source # | |||||
| (Applicative m, LeftReductive s, FactorialMonoid s, Ord s) => MultiParsing (ParserT m g s) Source # | Memoizing parser that carries an applicative computation. Can be wrapped with
| ||||
Defined in Text.Grampa.ContextFree.SortedMemoizing.Transformer Associated Types
Methods parseComplete :: (ParserInput (ParserT m g s) ~ s0, GrammarConstraint (ParserT m g s) g0, Eq s0, FactorialMonoid s0) => g0 (ParserT m g s) -> s0 -> g0 (ResultFunctor (ParserT m g s)) Source # parsePrefix :: (ParserInput (ParserT m g s) ~ s0, GrammarConstraint (ParserT m g s) g0, Eq s0, FactorialMonoid s0) => g0 (ParserT m g s) -> s0 -> g0 (Compose (ResultFunctor (ParserT m g s)) ((,) s0)) Source # | |||||
| (Apply g, GrammarFunctor (p g s) ~ f s, LeftRecParsing p g s f) => MultiParsing (Fixed p g s) Source # | Parser transformer for left-recursive grammars.
| ||||
Defined in Text.Grampa.Internal.LeftRecursive Associated Types
Methods parseComplete :: (ParserInput (Fixed p g s) ~ s0, GrammarConstraint (Fixed p g s) g0, Eq s0, FactorialMonoid s0) => g0 (Fixed p g s) -> s0 -> g0 (ResultFunctor (Fixed p g s)) Source # parsePrefix :: (ParserInput (Fixed p g s) ~ s0, GrammarConstraint (Fixed p g s) g0, Eq s0, FactorialMonoid s0) => g0 (Fixed p g s) -> s0 -> g0 (Compose (ResultFunctor (Fixed p g s)) ((,) s0)) Source # | |||||
class MultiParsing m => GrammarParsing (m :: Type -> Type) where Source #
Parsers that belong to this class can memoize the parse results to avoid exponential performance complexity.
Minimal complete definition
parsingResult, nonTerminal, chainRecursive, chainLongestRecursive
Associated Types
type ParserGrammar (m :: Type -> Type) :: (Type -> Type) -> Type Source #
The record of grammar productions associated with the parser
type GrammarFunctor (m :: Type -> Type) :: Type -> Type Source #
For internal use by notTerminal
Methods
parsingResult :: ParserInput m -> GrammarFunctor m a -> ResultFunctor m (ParserInput m, a) Source #
Converts the intermediate to final parsing result.
nonTerminal :: (g ~ ParserGrammar m, GrammarConstraint m g) => (g (GrammarFunctor m) -> GrammarFunctor m a) -> m a Source #
Used to reference a grammar production, only necessary from outside the grammar itself
selfReferring :: (g ~ ParserGrammar m, GrammarConstraint m g, Distributive g) => g m Source #
Construct a grammar whose every production refers to itself.
fixGrammar :: (g ~ ParserGrammar m, GrammarConstraint m g, Distributive g) => (g m -> g m) -> g m Source #
Convert a self-referring grammar function to a grammar.
recursive :: m a -> m a Source #
Mark a parser that relies on primitive recursion to prevent an infinite loop in fixGrammar.
Arguments
| :: (g ~ ParserGrammar m, f ~ GrammarFunctor m, GrammarConstraint m g) | |
| => (f a -> g f -> g f) | setter for the parsed results of each iteration |
| -> m a | the non-recursive base case |
| -> m a | the recursive case to iterate |
| -> m a |
Convert a left-recursive parser to a non-left-recursive one. For example, you can replace the left-recursive production
foo = BinOp <$> foo <*> bar <|> baz
in the field foo of grammar g with
foo = chainRecursive (\x g-> g{foo = x}) baz (BinOp <$> foo <*> bar)This method works on individual parsers left-recursive on themselves, not on grammars with mutually left-recursive productions. Use Text.Grampa.ContextFree.Memoizing.LeftRecursive for the latter.
chainLongestRecursive Source #
Arguments
| :: (g ~ ParserGrammar m, f ~ GrammarFunctor m, GrammarConstraint m g) | |
| => (f a -> g f -> g f) | setter for the parsed results of each iteration |
| -> m a | the non-recursive base case |
| -> m a | the recursive case to iterate |
| -> m a |
Line chainRecursive but produces only the longest possible parse. The modified example
foo = chainLongestRecursive (\x g-> g{foo = x}) baz (BinOp <$> foo <*> bar)would be equivalent to the left-recursive production with biased choice
foo = BinOp <$> foo <*> bar <<|> baz
Instances
| (Ord s, LeftReductive s, FactorialMonoid s) => GrammarParsing (Parser g s) Source # | |||||||||
Defined in Text.Grampa.ContextFree.Memoizing Associated Types
Methods parsingResult :: ParserInput (Parser g s) -> GrammarFunctor (Parser g s) a -> ResultFunctor (Parser g s) (ParserInput (Parser g s), a) Source # nonTerminal :: (g0 ~ ParserGrammar (Parser g s), GrammarConstraint (Parser g s) g0) => (g0 (GrammarFunctor (Parser g s)) -> GrammarFunctor (Parser g s) a) -> Parser g s a Source # selfReferring :: (g0 ~ ParserGrammar (Parser g s), GrammarConstraint (Parser g s) g0, Distributive g0) => g0 (Parser g s) Source # fixGrammar :: (g0 ~ ParserGrammar (Parser g s), GrammarConstraint (Parser g s) g0, Distributive g0) => (g0 (Parser g s) -> g0 (Parser g s)) -> g0 (Parser g s) Source # recursive :: Parser g s a -> Parser g s a Source # chainRecursive :: (g0 ~ ParserGrammar (Parser g s), f ~ GrammarFunctor (Parser g s), GrammarConstraint (Parser g s) g0) => (f a -> g0 f -> g0 f) -> Parser g s a -> Parser g s a -> Parser g s a Source # chainLongestRecursive :: (g0 ~ ParserGrammar (Parser g s), f ~ GrammarFunctor (Parser g s), GrammarConstraint (Parser g s) g0) => (f a -> g0 f -> g0 f) -> Parser g s a -> Parser g s a -> Parser g s a Source # | |||||||||
| (Ord s, LeftReductive s, FactorialMonoid s) => GrammarParsing (Parser g s) Source # | Memoizing parser guarantees O(n²) performance for grammars with unambiguous productions. Can be wrapped with
| ||||||||
Defined in Text.Grampa.ContextFree.SortedMemoizing Associated Types
Methods parsingResult :: ParserInput (Parser g s) -> GrammarFunctor (Parser g s) a -> ResultFunctor (Parser g s) (ParserInput (Parser g s), a) Source # nonTerminal :: (g0 ~ ParserGrammar (Parser g s), GrammarConstraint (Parser g s) g0) => (g0 (GrammarFunctor (Parser g s)) -> GrammarFunctor (Parser g s) a) -> Parser g s a Source # selfReferring :: (g0 ~ ParserGrammar (Parser g s), GrammarConstraint (Parser g s) g0, Distributive g0) => g0 (Parser g s) Source # fixGrammar :: (g0 ~ ParserGrammar (Parser g s), GrammarConstraint (Parser g s) g0, Distributive g0) => (g0 (Parser g s) -> g0 (Parser g s)) -> g0 (Parser g s) Source # recursive :: Parser g s a -> Parser g s a Source # chainRecursive :: (g0 ~ ParserGrammar (Parser g s), f ~ GrammarFunctor (Parser g s), GrammarConstraint (Parser g s) g0) => (f a -> g0 f -> g0 f) -> Parser g s a -> Parser g s a -> Parser g s a Source # chainLongestRecursive :: (g0 ~ ParserGrammar (Parser g s), f ~ GrammarFunctor (Parser g s), GrammarConstraint (Parser g s) g0) => (f a -> g0 f -> g0 f) -> Parser g s a -> Parser g s a -> Parser g s a Source # | |||||||||
| (Eq s, LeftReductive s, FactorialMonoid s) => GrammarParsing (Parser g s) Source # | Packrat parser | ||||||||
Defined in Text.Grampa.PEG.Packrat Associated Types
Methods parsingResult :: ParserInput (Parser g s) -> GrammarFunctor (Parser g s) a -> ResultFunctor (Parser g s) (ParserInput (Parser g s), a) Source # nonTerminal :: (g0 ~ ParserGrammar (Parser g s), GrammarConstraint (Parser g s) g0) => (g0 (GrammarFunctor (Parser g s)) -> GrammarFunctor (Parser g s) a) -> Parser g s a Source # selfReferring :: (g0 ~ ParserGrammar (Parser g s), GrammarConstraint (Parser g s) g0, Distributive g0) => g0 (Parser g s) Source # fixGrammar :: (g0 ~ ParserGrammar (Parser g s), GrammarConstraint (Parser g s) g0, Distributive g0) => (g0 (Parser g s) -> g0 (Parser g s)) -> g0 (Parser g s) Source # recursive :: Parser g s a -> Parser g s a Source # chainRecursive :: (g0 ~ ParserGrammar (Parser g s), f ~ GrammarFunctor (Parser g s), GrammarConstraint (Parser g s) g0) => (f a -> g0 f -> g0 f) -> Parser g s a -> Parser g s a -> Parser g s a Source # chainLongestRecursive :: (g0 ~ ParserGrammar (Parser g s), f ~ GrammarFunctor (Parser g s), GrammarConstraint (Parser g s) g0) => (f a -> g0 f -> g0 f) -> Parser g s a -> Parser g s a -> Parser g s a Source # | |||||||||
| (Applicative m, Ord s, LeftReductive s, FactorialMonoid s) => GrammarParsing (ParserT m g s) Source # | Memoizing parser that carries an applicative computation. Can be wrapped with
| ||||||||
Defined in Text.Grampa.ContextFree.SortedMemoizing.Transformer Associated Types
Methods parsingResult :: ParserInput (ParserT m g s) -> GrammarFunctor (ParserT m g s) a -> ResultFunctor (ParserT m g s) (ParserInput (ParserT m g s), a) Source # nonTerminal :: (g0 ~ ParserGrammar (ParserT m g s), GrammarConstraint (ParserT m g s) g0) => (g0 (GrammarFunctor (ParserT m g s)) -> GrammarFunctor (ParserT m g s) a) -> ParserT m g s a Source # selfReferring :: (g0 ~ ParserGrammar (ParserT m g s), GrammarConstraint (ParserT m g s) g0, Distributive g0) => g0 (ParserT m g s) Source # fixGrammar :: (g0 ~ ParserGrammar (ParserT m g s), GrammarConstraint (ParserT m g s) g0, Distributive g0) => (g0 (ParserT m g s) -> g0 (ParserT m g s)) -> g0 (ParserT m g s) Source # recursive :: ParserT m g s a -> ParserT m g s a Source # chainRecursive :: (g0 ~ ParserGrammar (ParserT m g s), f ~ GrammarFunctor (ParserT m g s), GrammarConstraint (ParserT m g s) g0) => (f a -> g0 f -> g0 f) -> ParserT m g s a -> ParserT m g s a -> ParserT m g s a Source # chainLongestRecursive :: (g0 ~ ParserGrammar (ParserT m g s), f ~ GrammarFunctor (ParserT m g s), GrammarConstraint (ParserT m g s) g0) => (f a -> g0 f -> g0 f) -> ParserT m g s a -> ParserT m g s a -> ParserT m g s a Source # | |||||||||
| (Apply g, GrammarFunctor (p g s) ~ f s, LeftRecParsing p g s f) => GrammarParsing (Fixed p g s) Source # | Parser transformer for left-recursive grammars. | ||||||||
Defined in Text.Grampa.Internal.LeftRecursive Associated Types
Methods parsingResult :: ParserInput (Fixed p g s) -> GrammarFunctor (Fixed p g s) a -> ResultFunctor (Fixed p g s) (ParserInput (Fixed p g s), a) Source # nonTerminal :: (g0 ~ ParserGrammar (Fixed p g s), GrammarConstraint (Fixed p g s) g0) => (g0 (GrammarFunctor (Fixed p g s)) -> GrammarFunctor (Fixed p g s) a) -> Fixed p g s a Source # selfReferring :: (g0 ~ ParserGrammar (Fixed p g s), GrammarConstraint (Fixed p g s) g0, Distributive g0) => g0 (Fixed p g s) Source # fixGrammar :: (g0 ~ ParserGrammar (Fixed p g s), GrammarConstraint (Fixed p g s) g0, Distributive g0) => (g0 (Fixed p g s) -> g0 (Fixed p g s)) -> g0 (Fixed p g s) Source # recursive :: Fixed p g s a -> Fixed p g s a Source # chainRecursive :: (g0 ~ ParserGrammar (Fixed p g s), f0 ~ GrammarFunctor (Fixed p g s), GrammarConstraint (Fixed p g s) g0) => (f0 a -> g0 f0 -> g0 f0) -> Fixed p g s a -> Fixed p g s a -> Fixed p g s a Source # chainLongestRecursive :: (g0 ~ ParserGrammar (Fixed p g s), f0 ~ GrammarFunctor (Fixed p g s), GrammarConstraint (Fixed p g s) g0) => (f0 a -> g0 f0 -> g0 f0) -> Fixed p g s a -> Fixed p g s a -> Fixed p g s a Source # | |||||||||
overlay :: forall (m :: Type -> Type) g f. (GrammarParsing m, g ~ ParserGrammar m, GrammarConstraint m g, Distributive g, Foldable f) => (g m -> g m) -> f (GrammarOverlay g m) -> g m Source #
Layers a sequence of GrammarOverlay on top of a base GrammarBuilder to produce a new grammar.
From the input-parsers library
class LookAheadParsing m => InputParsing (m :: Type -> Type) where #
Methods for parsing monoidal inputs
Associated Types
type ParserInput (m :: Type -> Type) #
The type of the input stream that the parser m expects to parse.
type ParserPosition (m :: Type -> Type) #
type ParserPosition (m :: Type -> Type) = Down Int
Methods
getInput :: m (ParserInput m) #
Always sucessful parser that returns the entire remaining input without consuming it.
getSourcePos :: m (ParserPosition m) #
Retrieve the Position reached by the parser in the input source.
default getSourcePos :: (FactorialMonoid (ParserInput m), Functor m, ParserPosition m ~ Down Int) => m (ParserPosition m) #
anyToken :: m (ParserInput m) #
A parser that accepts any single atomic prefix of the input stream.
anyToken == satisfy (const True) anyToken == take 1
take :: Int -> m (ParserInput m) #
A parser that accepts exactly the given number of input atoms.
take n == count n anyToken
satisfy :: (ParserInput m -> Bool) -> m (ParserInput m) #
A parser that accepts an input atom only if it satisfies the given predicate.
default satisfy :: Monad m => (ParserInput m -> Bool) -> m (ParserInput m) #
notSatisfy :: (ParserInput m -> Bool) -> m () #
A parser that succeeds exactly when satisfy doesn't, equivalent to
notFollowedBy . satisfy
scan :: state -> (state -> ParserInput m -> Maybe state) -> m (ParserInput m) #
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.
default scan :: (Monad m, FactorialMonoid (ParserInput m)) => state -> (state -> ParserInput m -> Maybe state) -> m (ParserInput m) #
string :: ParserInput m -> m (ParserInput m) #
A parser that consumes and returns the given prefix of the input.
default string :: (Monad m, LeftReductive (ParserInput m), FactorialMonoid (ParserInput m), Show (ParserInput m)) => ParserInput m -> m (ParserInput m) #
takeWhile :: (ParserInput m -> Bool) -> m (ParserInput m) #
A parser accepting the longest sequence of input atoms that match the given predicate; an optimized version of
concat . many . 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.
default takeWhile :: (Monad m, FactorialMonoid (ParserInput m)) => (ParserInput m -> Bool) -> m (ParserInput m) #
takeWhile1 :: (ParserInput m -> Bool) -> m (ParserInput m) #
A parser accepting the longest non-empty sequence of input atoms that match the given predicate; an optimized
version of concat . some . satisfy.
default takeWhile1 :: (Monad m, FactorialMonoid (ParserInput m)) => (ParserInput m -> Bool) -> m (ParserInput m) #
Instances
| InputParsing Parser | |||||||||
Defined in Text.Parser.Input Associated Types
Methods getInput :: Parser (ParserInput Parser) # getSourcePos :: Parser (ParserPosition Parser) # anyToken :: Parser (ParserInput Parser) # take :: Int -> Parser (ParserInput Parser) # satisfy :: (ParserInput Parser -> Bool) -> Parser (ParserInput Parser) # notSatisfy :: (ParserInput Parser -> Bool) -> Parser () # scan :: state -> (state -> ParserInput Parser -> Maybe state) -> Parser (ParserInput Parser) # string :: ParserInput Parser -> Parser (ParserInput Parser) # takeWhile :: (ParserInput Parser -> Bool) -> Parser (ParserInput Parser) # takeWhile1 :: (ParserInput Parser -> Bool) -> Parser (ParserInput Parser) # | |||||||||
| InputParsing Parser | |||||||||
Defined in Text.Parser.Input Associated Types
Methods getInput :: Parser (ParserInput Parser) # getSourcePos :: Parser (ParserPosition Parser) # anyToken :: Parser (ParserInput Parser) # take :: Int -> Parser (ParserInput Parser) # satisfy :: (ParserInput Parser -> Bool) -> Parser (ParserInput Parser) # notSatisfy :: (ParserInput Parser -> Bool) -> Parser () # scan :: state -> (state -> ParserInput Parser -> Maybe state) -> Parser (ParserInput Parser) # string :: ParserInput Parser -> Parser (ParserInput Parser) # takeWhile :: (ParserInput Parser -> Bool) -> Parser (ParserInput Parser) # takeWhile1 :: (ParserInput Parser -> Bool) -> Parser (ParserInput Parser) # | |||||||||
| InputParsing ReadP | |||||||||
Defined in Text.Parser.Input Associated Types
Methods getInput :: ReadP (ParserInput ReadP) # getSourcePos :: ReadP (ParserPosition ReadP) # anyToken :: ReadP (ParserInput ReadP) # take :: Int -> ReadP (ParserInput ReadP) # satisfy :: (ParserInput ReadP -> Bool) -> ReadP (ParserInput ReadP) # notSatisfy :: (ParserInput ReadP -> Bool) -> ReadP () # scan :: state -> (state -> ParserInput ReadP -> Maybe state) -> ReadP (ParserInput ReadP) # string :: ParserInput ReadP -> ReadP (ParserInput ReadP) # takeWhile :: (ParserInput ReadP -> Bool) -> ReadP (ParserInput ReadP) # takeWhile1 :: (ParserInput ReadP -> Bool) -> ReadP (ParserInput ReadP) # | |||||||||
| InputParsing (Lazy Get) | |||||||||
Defined in Text.Parser.Input Associated Types
Methods getInput :: Lazy Get (ParserInput (Lazy Get)) # getSourcePos :: Lazy Get (ParserPosition (Lazy Get)) # anyToken :: Lazy Get (ParserInput (Lazy Get)) # take :: Int -> Lazy Get (ParserInput (Lazy Get)) # satisfy :: (ParserInput (Lazy Get) -> Bool) -> Lazy Get (ParserInput (Lazy Get)) # notSatisfy :: (ParserInput (Lazy Get) -> Bool) -> Lazy Get () # scan :: state -> (state -> ParserInput (Lazy Get) -> Maybe state) -> Lazy Get (ParserInput (Lazy Get)) # string :: ParserInput (Lazy Get) -> Lazy Get (ParserInput (Lazy Get)) # takeWhile :: (ParserInput (Lazy Get) -> Bool) -> Lazy Get (ParserInput (Lazy Get)) # takeWhile1 :: (ParserInput (Lazy Get) -> Bool) -> Lazy Get (ParserInput (Lazy Get)) # | |||||||||
| InputParsing (Strict Get) | |||||||||
Defined in Text.Parser.Input Associated Types
Methods getInput :: Strict Get (ParserInput (Strict Get)) # getSourcePos :: Strict Get (ParserPosition (Strict Get)) # anyToken :: Strict Get (ParserInput (Strict Get)) # take :: Int -> Strict Get (ParserInput (Strict Get)) # satisfy :: (ParserInput (Strict Get) -> Bool) -> Strict Get (ParserInput (Strict Get)) # notSatisfy :: (ParserInput (Strict Get) -> Bool) -> Strict Get () # scan :: state -> (state -> ParserInput (Strict Get) -> Maybe state) -> Strict Get (ParserInput (Strict Get)) # string :: ParserInput (Strict Get) -> Strict Get (ParserInput (Strict Get)) # takeWhile :: (ParserInput (Strict Get) -> Bool) -> Strict Get (ParserInput (Strict Get)) # takeWhile1 :: (ParserInput (Strict Get) -> Bool) -> Strict Get (ParserInput (Strict Get)) # | |||||||||
| (LeftReductive s, FactorialMonoid s, Ord s) => InputParsing (Parser g s) Source # | |||||||||
Defined in Text.Grampa.ContextFree.Continued Associated Types
Methods getInput :: Parser g s (ParserInput (Parser g s)) # getSourcePos :: Parser g s (ParserPosition (Parser g s)) # anyToken :: Parser g s (ParserInput (Parser g s)) # take :: Int -> Parser g s (ParserInput (Parser g s)) # satisfy :: (ParserInput (Parser g s) -> Bool) -> Parser g s (ParserInput (Parser g s)) # notSatisfy :: (ParserInput (Parser g s) -> Bool) -> Parser g s () # scan :: state -> (state -> ParserInput (Parser g s) -> Maybe state) -> Parser g s (ParserInput (Parser g s)) # string :: ParserInput (Parser g s) -> Parser g s (ParserInput (Parser g s)) # takeWhile :: (ParserInput (Parser g s) -> Bool) -> Parser g s (ParserInput (Parser g s)) # takeWhile1 :: (ParserInput (Parser g s) -> Bool) -> Parser g s (ParserInput (Parser g s)) # | |||||||||
| (LeftReductive s, FactorialMonoid s, Ord s) => InputParsing (Parser g s) Source # | |||||||||
Defined in Text.Grampa.ContextFree.Memoizing Associated Types
Methods getInput :: Parser g s (ParserInput (Parser g s)) # getSourcePos :: Parser g s (ParserPosition (Parser g s)) # anyToken :: Parser g s (ParserInput (Parser g s)) # take :: Int -> Parser g s (ParserInput (Parser g s)) # satisfy :: (ParserInput (Parser g s) -> Bool) -> Parser g s (ParserInput (Parser g s)) # notSatisfy :: (ParserInput (Parser g s) -> Bool) -> Parser g s () # scan :: state -> (state -> ParserInput (Parser g s) -> Maybe state) -> Parser g s (ParserInput (Parser g s)) # string :: ParserInput (Parser g s) -> Parser g s (ParserInput (Parser g s)) # takeWhile :: (ParserInput (Parser g s) -> Bool) -> Parser g s (ParserInput (Parser g s)) # takeWhile1 :: (ParserInput (Parser g s) -> Bool) -> Parser g s (ParserInput (Parser g s)) # | |||||||||
| (LeftReductive s, FactorialMonoid s, Ord s) => InputParsing (Parser g s) Source # | |||||||||
Defined in Text.Grampa.ContextFree.Parallel Associated Types
Methods getInput :: Parser g s (ParserInput (Parser g s)) # getSourcePos :: Parser g s (ParserPosition (Parser g s)) # anyToken :: Parser g s (ParserInput (Parser g s)) # take :: Int -> Parser g s (ParserInput (Parser g s)) # satisfy :: (ParserInput (Parser g s) -> Bool) -> Parser g s (ParserInput (Parser g s)) # notSatisfy :: (ParserInput (Parser g s) -> Bool) -> Parser g s () # scan :: state -> (state -> ParserInput (Parser g s) -> Maybe state) -> Parser g s (ParserInput (Parser g s)) # string :: ParserInput (Parser g s) -> Parser g s (ParserInput (Parser g s)) # takeWhile :: (ParserInput (Parser g s) -> Bool) -> Parser g s (ParserInput (Parser g s)) # takeWhile1 :: (ParserInput (Parser g s) -> Bool) -> Parser g s (ParserInput (Parser g s)) # | |||||||||
| (LeftReductive s, FactorialMonoid s, Ord s) => InputParsing (Parser g s) Source # | |||||||||
Defined in Text.Grampa.ContextFree.SortedMemoizing Associated Types
Methods getInput :: Parser g s (ParserInput (Parser g s)) # getSourcePos :: Parser g s (ParserPosition (Parser g s)) # anyToken :: Parser g s (ParserInput (Parser g s)) # take :: Int -> Parser g s (ParserInput (Parser g s)) # satisfy :: (ParserInput (Parser g s) -> Bool) -> Parser g s (ParserInput (Parser g s)) # notSatisfy :: (ParserInput (Parser g s) -> Bool) -> Parser g s () # scan :: state -> (state -> ParserInput (Parser g s) -> Maybe state) -> Parser g s (ParserInput (Parser g s)) # string :: ParserInput (Parser g s) -> Parser g s (ParserInput (Parser g s)) # takeWhile :: (ParserInput (Parser g s) -> Bool) -> Parser g s (ParserInput (Parser g s)) # takeWhile1 :: (ParserInput (Parser g s) -> Bool) -> Parser g s (ParserInput (Parser g s)) # | |||||||||
| (LeftReductive s, FactorialMonoid s) => InputParsing (Parser g s) Source # | |||||||||
Defined in Text.Grampa.PEG.Backtrack Associated Types
Methods getInput :: Parser g s (ParserInput (Parser g s)) # getSourcePos :: Parser g s (ParserPosition (Parser g s)) # anyToken :: Parser g s (ParserInput (Parser g s)) # take :: Int -> Parser g s (ParserInput (Parser g s)) # satisfy :: (ParserInput (Parser g s) -> Bool) -> Parser g s (ParserInput (Parser g s)) # notSatisfy :: (ParserInput (Parser g s) -> Bool) -> Parser g s () # scan :: state -> (state -> ParserInput (Parser g s) -> Maybe state) -> Parser g s (ParserInput (Parser g s)) # string :: ParserInput (Parser g s) -> Parser g s (ParserInput (Parser g s)) # takeWhile :: (ParserInput (Parser g s) -> Bool) -> Parser g s (ParserInput (Parser g s)) # takeWhile1 :: (ParserInput (Parser g s) -> Bool) -> Parser g s (ParserInput (Parser g s)) # | |||||||||
| (LeftReductive s, FactorialMonoid s) => InputParsing (Parser g s) Source # | |||||||||
Defined in Text.Grampa.PEG.Packrat Associated Types
Methods getInput :: Parser g s (ParserInput (Parser g s)) # getSourcePos :: Parser g s (ParserPosition (Parser g s)) # anyToken :: Parser g s (ParserInput (Parser g s)) # take :: Int -> Parser g s (ParserInput (Parser g s)) # satisfy :: (ParserInput (Parser g s) -> Bool) -> Parser g s (ParserInput (Parser g s)) # notSatisfy :: (ParserInput (Parser g s) -> Bool) -> Parser g s () # scan :: state -> (state -> ParserInput (Parser g s) -> Maybe state) -> Parser g s (ParserInput (Parser g s)) # string :: ParserInput (Parser g s) -> Parser g s (ParserInput (Parser g s)) # takeWhile :: (ParserInput (Parser g s) -> Bool) -> Parser g s (ParserInput (Parser g s)) # takeWhile1 :: (ParserInput (Parser g s) -> Bool) -> Parser g s (ParserInput (Parser g s)) # | |||||||||
| (Monad m, InputParsing m) => InputParsing (IdentityT m) | |||||||||
Defined in Text.Parser.Input Associated Types
Methods getInput :: IdentityT m (ParserInput (IdentityT m)) # getSourcePos :: IdentityT m (ParserPosition (IdentityT m)) # anyToken :: IdentityT m (ParserInput (IdentityT m)) # take :: Int -> IdentityT m (ParserInput (IdentityT m)) # satisfy :: (ParserInput (IdentityT m) -> Bool) -> IdentityT m (ParserInput (IdentityT m)) # notSatisfy :: (ParserInput (IdentityT m) -> Bool) -> IdentityT m () # scan :: state -> (state -> ParserInput (IdentityT m) -> Maybe state) -> IdentityT m (ParserInput (IdentityT m)) # string :: ParserInput (IdentityT m) -> IdentityT m (ParserInput (IdentityT m)) # takeWhile :: (ParserInput (IdentityT m) -> Bool) -> IdentityT m (ParserInput (IdentityT m)) # takeWhile1 :: (ParserInput (IdentityT m) -> Bool) -> IdentityT m (ParserInput (IdentityT m)) # | |||||||||
| (MonadPlus m, InputParsing m) => InputParsing (ReaderT e m) | |||||||||
Defined in Text.Parser.Input Associated Types
Methods getInput :: ReaderT e m (ParserInput (ReaderT e m)) # getSourcePos :: ReaderT e m (ParserPosition (ReaderT e m)) # anyToken :: ReaderT e m (ParserInput (ReaderT e m)) # take :: Int -> ReaderT e m (ParserInput (ReaderT e m)) # satisfy :: (ParserInput (ReaderT e m) -> Bool) -> ReaderT e m (ParserInput (ReaderT e m)) # notSatisfy :: (ParserInput (ReaderT e m) -> Bool) -> ReaderT e m () # scan :: state -> (state -> ParserInput (ReaderT e m) -> Maybe state) -> ReaderT e m (ParserInput (ReaderT e m)) # string :: ParserInput (ReaderT e m) -> ReaderT e m (ParserInput (ReaderT e m)) # takeWhile :: (ParserInput (ReaderT e m) -> Bool) -> ReaderT e m (ParserInput (ReaderT e m)) # takeWhile1 :: (ParserInput (ReaderT e m) -> Bool) -> ReaderT e m (ParserInput (ReaderT e m)) # | |||||||||
| (MonadPlus m, InputParsing m) => InputParsing (StateT s m) | |||||||||
Defined in Text.Parser.Input Associated Types
Methods getInput :: StateT s m (ParserInput (StateT s m)) # getSourcePos :: StateT s m (ParserPosition (StateT s m)) # anyToken :: StateT s m (ParserInput (StateT s m)) # take :: Int -> StateT s m (ParserInput (StateT s m)) # satisfy :: (ParserInput (StateT s m) -> Bool) -> StateT s m (ParserInput (StateT s m)) # notSatisfy :: (ParserInput (StateT s m) -> Bool) -> StateT s m () # scan :: state -> (state -> ParserInput (StateT s m) -> Maybe state) -> StateT s m (ParserInput (StateT s m)) # string :: ParserInput (StateT s m) -> StateT s m (ParserInput (StateT s m)) # takeWhile :: (ParserInput (StateT s m) -> Bool) -> StateT s m (ParserInput (StateT s m)) # takeWhile1 :: (ParserInput (StateT s m) -> Bool) -> StateT s m (ParserInput (StateT s m)) # | |||||||||
| (MonadPlus m, InputParsing m) => InputParsing (StateT s m) | |||||||||
Defined in Text.Parser.Input Associated Types
Methods getInput :: StateT s m (ParserInput (StateT s m)) # getSourcePos :: StateT s m (ParserPosition (StateT s m)) # anyToken :: StateT s m (ParserInput (StateT s m)) # take :: Int -> StateT s m (ParserInput (StateT s m)) # satisfy :: (ParserInput (StateT s m) -> Bool) -> StateT s m (ParserInput (StateT s m)) # notSatisfy :: (ParserInput (StateT s m) -> Bool) -> StateT s m () # scan :: state -> (state -> ParserInput (StateT s m) -> Maybe state) -> StateT s m (ParserInput (StateT s m)) # string :: ParserInput (StateT s m) -> StateT s m (ParserInput (StateT s m)) # takeWhile :: (ParserInput (StateT s m) -> Bool) -> StateT s m (ParserInput (StateT s m)) # takeWhile1 :: (ParserInput (StateT s m) -> Bool) -> StateT s m (ParserInput (StateT s m)) # | |||||||||
| (MonadPlus m, InputParsing m, Monoid w) => InputParsing (WriterT w m) | |||||||||
Defined in Text.Parser.Input Associated Types
Methods getInput :: WriterT w m (ParserInput (WriterT w m)) # getSourcePos :: WriterT w m (ParserPosition (WriterT w m)) # anyToken :: WriterT w m (ParserInput (WriterT w m)) # take :: Int -> WriterT w m (ParserInput (WriterT w m)) # satisfy :: (ParserInput (WriterT w m) -> Bool) -> WriterT w m (ParserInput (WriterT w m)) # notSatisfy :: (ParserInput (WriterT w m) -> Bool) -> WriterT w m () # scan :: state -> (state -> ParserInput (WriterT w m) -> Maybe state) -> WriterT w m (ParserInput (WriterT w m)) # string :: ParserInput (WriterT w m) -> WriterT w m (ParserInput (WriterT w m)) # takeWhile :: (ParserInput (WriterT w m) -> Bool) -> WriterT w m (ParserInput (WriterT w m)) # takeWhile1 :: (ParserInput (WriterT w m) -> Bool) -> WriterT w m (ParserInput (WriterT w m)) # | |||||||||
| (MonadPlus m, InputParsing m, Monoid w) => InputParsing (WriterT w m) | |||||||||
Defined in Text.Parser.Input Associated Types
Methods getInput :: WriterT w m (ParserInput (WriterT w m)) # getSourcePos :: WriterT w m (ParserPosition (WriterT w m)) # anyToken :: WriterT w m (ParserInput (WriterT w m)) # take :: Int -> WriterT w m (ParserInput (WriterT w m)) # satisfy :: (ParserInput (WriterT w m) -> Bool) -> WriterT w m (ParserInput (WriterT w m)) # notSatisfy :: (ParserInput (WriterT w m) -> Bool) -> WriterT w m () # scan :: state -> (state -> ParserInput (WriterT w m) -> Maybe state) -> WriterT w m (ParserInput (WriterT w m)) # string :: ParserInput (WriterT w m) -> WriterT w m (ParserInput (WriterT w m)) # takeWhile :: (ParserInput (WriterT w m) -> Bool) -> WriterT w m (ParserInput (WriterT w m)) # takeWhile1 :: (ParserInput (WriterT w m) -> Bool) -> WriterT w m (ParserInput (WriterT w m)) # | |||||||||
| (Applicative m, LeftReductive s, FactorialMonoid s, Ord s) => InputParsing (ParserT m g s) Source # | |||||||||
Defined in Text.Grampa.ContextFree.SortedMemoizing.Transformer Associated Types
Methods getInput :: ParserT m g s (ParserInput (ParserT m g s)) # getSourcePos :: ParserT m g s (ParserPosition (ParserT m g s)) # anyToken :: ParserT m g s (ParserInput (ParserT m g s)) # take :: Int -> ParserT m g s (ParserInput (ParserT m g s)) # satisfy :: (ParserInput (ParserT m g s) -> Bool) -> ParserT m g s (ParserInput (ParserT m g s)) # notSatisfy :: (ParserInput (ParserT m g s) -> Bool) -> ParserT m g s () # scan :: state -> (state -> ParserInput (ParserT m g s) -> Maybe state) -> ParserT m g s (ParserInput (ParserT m g s)) # string :: ParserInput (ParserT m g s) -> ParserT m g s (ParserInput (ParserT m g s)) # takeWhile :: (ParserInput (ParserT m g s) -> Bool) -> ParserT m g s (ParserInput (ParserT m g s)) # takeWhile1 :: (ParserInput (ParserT m g s) -> Bool) -> ParserT m g s (ParserInput (ParserT m g s)) # | |||||||||
| (Apply g, LeftReductive s, FactorialMonoid s, InputParsing (p g s), ParserInput (p g s) ~ s) => InputParsing (Fixed p g s) Source # | |||||||||
Defined in Text.Grampa.Internal.LeftRecursive Associated Types
Methods getInput :: Fixed p g s (ParserInput (Fixed p g s)) # getSourcePos :: Fixed p g s (ParserPosition (Fixed p g s)) # anyToken :: Fixed p g s (ParserInput (Fixed p g s)) # take :: Int -> Fixed p g s (ParserInput (Fixed p g s)) # satisfy :: (ParserInput (Fixed p g s) -> Bool) -> Fixed p g s (ParserInput (Fixed p g s)) # notSatisfy :: (ParserInput (Fixed p g s) -> Bool) -> Fixed p g s () # scan :: state -> (state -> ParserInput (Fixed p g s) -> Maybe state) -> Fixed p g s (ParserInput (Fixed p g s)) # string :: ParserInput (Fixed p g s) -> Fixed p g s (ParserInput (Fixed p g s)) # takeWhile :: (ParserInput (Fixed p g s) -> Bool) -> Fixed p g s (ParserInput (Fixed p g s)) # takeWhile1 :: (ParserInput (Fixed p g s) -> Bool) -> Fixed p g s (ParserInput (Fixed p g s)) # | |||||||||
| (FactorialMonoid s, LeftReductive s, Show s, Stream s m t, Show t) => InputParsing (ParsecT s u m) | |||||||||
Defined in Text.Parser.Input Associated Types
Methods getInput :: ParsecT s u m (ParserInput (ParsecT s u m)) # getSourcePos :: ParsecT s u m (ParserPosition (ParsecT s u m)) # anyToken :: ParsecT s u m (ParserInput (ParsecT s u m)) # take :: Int -> ParsecT s u m (ParserInput (ParsecT s u m)) # satisfy :: (ParserInput (ParsecT s u m) -> Bool) -> ParsecT s u m (ParserInput (ParsecT s u m)) # notSatisfy :: (ParserInput (ParsecT s u m) -> Bool) -> ParsecT s u m () # scan :: state -> (state -> ParserInput (ParsecT s u m) -> Maybe state) -> ParsecT s u m (ParserInput (ParsecT s u m)) # string :: ParserInput (ParsecT s u m) -> ParsecT s u m (ParserInput (ParsecT s u m)) # takeWhile :: (ParserInput (ParsecT s u m) -> Bool) -> ParsecT s u m (ParserInput (ParsecT s u m)) # takeWhile1 :: (ParserInput (ParsecT s u m) -> Bool) -> ParsecT s u m (ParserInput (ParsecT s u m)) # | |||||||||
| (MonadPlus m, InputParsing m, Monoid w) => InputParsing (RWST r w s m) | |||||||||
Defined in Text.Parser.Input Associated Types
Methods getInput :: RWST r w s m (ParserInput (RWST r w s m)) # getSourcePos :: RWST r w s m (ParserPosition (RWST r w s m)) # anyToken :: RWST r w s m (ParserInput (RWST r w s m)) # take :: Int -> RWST r w s m (ParserInput (RWST r w s m)) # satisfy :: (ParserInput (RWST r w s m) -> Bool) -> RWST r w s m (ParserInput (RWST r w s m)) # notSatisfy :: (ParserInput (RWST r w s m) -> Bool) -> RWST r w s m () # scan :: state -> (state -> ParserInput (RWST r w s m) -> Maybe state) -> RWST r w s m (ParserInput (RWST r w s m)) # string :: ParserInput (RWST r w s m) -> RWST r w s m (ParserInput (RWST r w s m)) # takeWhile :: (ParserInput (RWST r w s m) -> Bool) -> RWST r w s m (ParserInput (RWST r w s m)) # takeWhile1 :: (ParserInput (RWST r w s m) -> Bool) -> RWST r w s m (ParserInput (RWST r w s m)) # | |||||||||
| (MonadPlus m, InputParsing m, Monoid w) => InputParsing (RWST r w s m) | |||||||||
Defined in Text.Parser.Input Associated Types
Methods getInput :: RWST r w s m (ParserInput (RWST r w s m)) # getSourcePos :: RWST r w s m (ParserPosition (RWST r w s m)) # anyToken :: RWST r w s m (ParserInput (RWST r w s m)) # take :: Int -> RWST r w s m (ParserInput (RWST r w s m)) # satisfy :: (ParserInput (RWST r w s m) -> Bool) -> RWST r w s m (ParserInput (RWST r w s m)) # notSatisfy :: (ParserInput (RWST r w s m) -> Bool) -> RWST r w s m () # scan :: state -> (state -> ParserInput (RWST r w s m) -> Maybe state) -> RWST r w s m (ParserInput (RWST r w s m)) # string :: ParserInput (RWST r w s m) -> RWST r w s m (ParserInput (RWST r w s m)) # takeWhile :: (ParserInput (RWST r w s m) -> Bool) -> RWST r w s m (ParserInput (RWST r w s m)) # takeWhile1 :: (ParserInput (RWST r w s m) -> Bool) -> RWST r w s m (ParserInput (RWST r w s m)) # | |||||||||
class (CharParsing m, InputParsing m) => InputCharParsing (m :: Type -> Type) where #
Methods for parsing textual monoid inputs
Minimal complete definition
Methods
satisfyCharInput :: (Char -> Bool) -> m (ParserInput m) #
Specialization of satisfy on textual inputs, accepting an input character only if it satisfies the given
predicate, and returning the input atom that represents the character. Equivalent to fmap singleton
. Char.satisfy
notSatisfyChar :: (Char -> Bool) -> m () #
A parser that succeeds exactly when satisfy doesn't, equivalent to notFollowedBy . Char.satisfy
scanChars :: state -> (state -> Char -> Maybe state) -> m (ParserInput m) #
Stateful scanner like scan, but specialized for TextualMonoid inputs.
default scanChars :: (Monad m, TextualMonoid (ParserInput m)) => state -> (state -> Char -> Maybe state) -> m (ParserInput m) #
takeCharsWhile :: (Char -> Bool) -> m (ParserInput m) #
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 . Char.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.
default takeCharsWhile :: (Monad m, TextualMonoid (ParserInput m)) => (Char -> Bool) -> m (ParserInput m) #
takeCharsWhile1 :: (Char -> Bool) -> m (ParserInput m) #
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 . Char.satisfy.
default takeCharsWhile1 :: (Monad m, TextualMonoid (ParserInput m)) => (Char -> Bool) -> m (ParserInput m) #
Instances
| InputCharParsing Parser | |
Defined in Text.Parser.Input Methods satisfyCharInput :: (Char -> Bool) -> Parser (ParserInput Parser) # notSatisfyChar :: (Char -> Bool) -> Parser () # scanChars :: state -> (state -> Char -> Maybe state) -> Parser (ParserInput Parser) # takeCharsWhile :: (Char -> Bool) -> Parser (ParserInput Parser) # takeCharsWhile1 :: (Char -> Bool) -> Parser (ParserInput Parser) # | |
| InputCharParsing Parser | |
Defined in Text.Parser.Input Methods satisfyCharInput :: (Char -> Bool) -> Parser (ParserInput Parser) # notSatisfyChar :: (Char -> Bool) -> Parser () # scanChars :: state -> (state -> Char -> Maybe state) -> Parser (ParserInput Parser) # takeCharsWhile :: (Char -> Bool) -> Parser (ParserInput Parser) # takeCharsWhile1 :: (Char -> Bool) -> Parser (ParserInput Parser) # | |
| InputCharParsing ReadP | |
Defined in Text.Parser.Input Methods satisfyCharInput :: (Char -> Bool) -> ReadP (ParserInput ReadP) # notSatisfyChar :: (Char -> Bool) -> ReadP () # scanChars :: state -> (state -> Char -> Maybe state) -> ReadP (ParserInput ReadP) # takeCharsWhile :: (Char -> Bool) -> ReadP (ParserInput ReadP) # takeCharsWhile1 :: (Char -> Bool) -> ReadP (ParserInput ReadP) # | |
| (Ord s, Show s, TextualMonoid s) => InputCharParsing (Parser g s) Source # | |
Defined in Text.Grampa.ContextFree.Continued Methods satisfyCharInput :: (Char -> Bool) -> Parser g s (ParserInput (Parser g s)) # notSatisfyChar :: (Char -> Bool) -> Parser g s () # scanChars :: state -> (state -> Char -> Maybe state) -> Parser g s (ParserInput (Parser g s)) # takeCharsWhile :: (Char -> Bool) -> Parser g s (ParserInput (Parser g s)) # takeCharsWhile1 :: (Char -> Bool) -> Parser g s (ParserInput (Parser g s)) # | |
| (Ord s, Show s, TextualMonoid s) => InputCharParsing (Parser g s) Source # | |
Defined in Text.Grampa.ContextFree.Memoizing Methods satisfyCharInput :: (Char -> Bool) -> Parser g s (ParserInput (Parser g s)) # notSatisfyChar :: (Char -> Bool) -> Parser g s () # scanChars :: state -> (state -> Char -> Maybe state) -> Parser g s (ParserInput (Parser g s)) # takeCharsWhile :: (Char -> Bool) -> Parser g s (ParserInput (Parser g s)) # takeCharsWhile1 :: (Char -> Bool) -> Parser g s (ParserInput (Parser g s)) # | |
| (Ord s, TextualMonoid s) => InputCharParsing (Parser g s) Source # | |
Defined in Text.Grampa.ContextFree.Parallel Methods satisfyCharInput :: (Char -> Bool) -> Parser g s (ParserInput (Parser g s)) # notSatisfyChar :: (Char -> Bool) -> Parser g s () # scanChars :: state -> (state -> Char -> Maybe state) -> Parser g s (ParserInput (Parser g s)) # takeCharsWhile :: (Char -> Bool) -> Parser g s (ParserInput (Parser g s)) # takeCharsWhile1 :: (Char -> Bool) -> Parser g s (ParserInput (Parser g s)) # | |
| (Ord s, Show s, TextualMonoid s) => InputCharParsing (Parser g s) Source # | |
Defined in Text.Grampa.ContextFree.SortedMemoizing Methods satisfyCharInput :: (Char -> Bool) -> Parser g s (ParserInput (Parser g s)) # notSatisfyChar :: (Char -> Bool) -> Parser g s () # scanChars :: state -> (state -> Char -> Maybe state) -> Parser g s (ParserInput (Parser g s)) # takeCharsWhile :: (Char -> Bool) -> Parser g s (ParserInput (Parser g s)) # takeCharsWhile1 :: (Char -> Bool) -> Parser g s (ParserInput (Parser g s)) # | |
| (Show s, TextualMonoid s) => InputCharParsing (Parser g s) Source # | |
Defined in Text.Grampa.PEG.Backtrack Methods satisfyCharInput :: (Char -> Bool) -> Parser g s (ParserInput (Parser g s)) # notSatisfyChar :: (Char -> Bool) -> Parser g s () # scanChars :: state -> (state -> Char -> Maybe state) -> Parser g s (ParserInput (Parser g s)) # takeCharsWhile :: (Char -> Bool) -> Parser g s (ParserInput (Parser g s)) # takeCharsWhile1 :: (Char -> Bool) -> Parser g s (ParserInput (Parser g s)) # | |
| (Show s, TextualMonoid s) => InputCharParsing (Parser g s) Source # | |
Defined in Text.Grampa.PEG.Packrat Methods satisfyCharInput :: (Char -> Bool) -> Parser g s (ParserInput (Parser g s)) # notSatisfyChar :: (Char -> Bool) -> Parser g s () # scanChars :: state -> (state -> Char -> Maybe state) -> Parser g s (ParserInput (Parser g s)) # takeCharsWhile :: (Char -> Bool) -> Parser g s (ParserInput (Parser g s)) # takeCharsWhile1 :: (Char -> Bool) -> Parser g s (ParserInput (Parser g s)) # | |
| (MonadPlus m, InputCharParsing m) => InputCharParsing (IdentityT m) | |
Defined in Text.Parser.Input Methods satisfyCharInput :: (Char -> Bool) -> IdentityT m (ParserInput (IdentityT m)) # notSatisfyChar :: (Char -> Bool) -> IdentityT m () # scanChars :: state -> (state -> Char -> Maybe state) -> IdentityT m (ParserInput (IdentityT m)) # takeCharsWhile :: (Char -> Bool) -> IdentityT m (ParserInput (IdentityT m)) # takeCharsWhile1 :: (Char -> Bool) -> IdentityT m (ParserInput (IdentityT m)) # | |
| (MonadPlus m, InputCharParsing m) => InputCharParsing (ReaderT e m) | |
Defined in Text.Parser.Input Methods satisfyCharInput :: (Char -> Bool) -> ReaderT e m (ParserInput (ReaderT e m)) # notSatisfyChar :: (Char -> Bool) -> ReaderT e m () # scanChars :: state -> (state -> Char -> Maybe state) -> ReaderT e m (ParserInput (ReaderT e m)) # takeCharsWhile :: (Char -> Bool) -> ReaderT e m (ParserInput (ReaderT e m)) # takeCharsWhile1 :: (Char -> Bool) -> ReaderT e m (ParserInput (ReaderT e m)) # | |
| (MonadPlus m, InputCharParsing m) => InputCharParsing (StateT s m) | |
Defined in Text.Parser.Input Methods satisfyCharInput :: (Char -> Bool) -> StateT s m (ParserInput (StateT s m)) # notSatisfyChar :: (Char -> Bool) -> StateT s m () # scanChars :: state -> (state -> Char -> Maybe state) -> StateT s m (ParserInput (StateT s m)) # takeCharsWhile :: (Char -> Bool) -> StateT s m (ParserInput (StateT s m)) # takeCharsWhile1 :: (Char -> Bool) -> StateT s m (ParserInput (StateT s m)) # | |
| (MonadPlus m, InputCharParsing m) => InputCharParsing (StateT s m) | |
Defined in Text.Parser.Input Methods satisfyCharInput :: (Char -> Bool) -> StateT s m (ParserInput (StateT s m)) # notSatisfyChar :: (Char -> Bool) -> StateT s m () # scanChars :: state -> (state -> Char -> Maybe state) -> StateT s m (ParserInput (StateT s m)) # takeCharsWhile :: (Char -> Bool) -> StateT s m (ParserInput (StateT s m)) # takeCharsWhile1 :: (Char -> Bool) -> StateT s m (ParserInput (StateT s m)) # | |
| (MonadPlus m, InputCharParsing m, Monoid w) => InputCharParsing (WriterT w m) | |
Defined in Text.Parser.Input Methods satisfyCharInput :: (Char -> Bool) -> WriterT w m (ParserInput (WriterT w m)) # notSatisfyChar :: (Char -> Bool) -> WriterT w m () # scanChars :: state -> (state -> Char -> Maybe state) -> WriterT w m (ParserInput (WriterT w m)) # takeCharsWhile :: (Char -> Bool) -> WriterT w m (ParserInput (WriterT w m)) # takeCharsWhile1 :: (Char -> Bool) -> WriterT w m (ParserInput (WriterT w m)) # | |
| (MonadPlus m, InputCharParsing m, Monoid w) => InputCharParsing (WriterT w m) | |
Defined in Text.Parser.Input Methods satisfyCharInput :: (Char -> Bool) -> WriterT w m (ParserInput (WriterT w m)) # notSatisfyChar :: (Char -> Bool) -> WriterT w m () # scanChars :: state -> (state -> Char -> Maybe state) -> WriterT w m (ParserInput (WriterT w m)) # takeCharsWhile :: (Char -> Bool) -> WriterT w m (ParserInput (WriterT w m)) # takeCharsWhile1 :: (Char -> Bool) -> WriterT w m (ParserInput (WriterT w m)) # | |
| (Applicative m, Ord s, Show s, TextualMonoid s) => InputCharParsing (ParserT m g s) Source # | |
Defined in Text.Grampa.ContextFree.SortedMemoizing.Transformer Methods satisfyCharInput :: (Char -> Bool) -> ParserT m g s (ParserInput (ParserT m g s)) # notSatisfyChar :: (Char -> Bool) -> ParserT m g s () # scanChars :: state -> (state -> Char -> Maybe state) -> ParserT m g s (ParserInput (ParserT m g s)) # takeCharsWhile :: (Char -> Bool) -> ParserT m g s (ParserInput (ParserT m g s)) # takeCharsWhile1 :: (Char -> Bool) -> ParserT m g s (ParserInput (ParserT m g s)) # | |
| (Apply g, Show s, TextualMonoid s, InputCharParsing (p g s), ParserInput (p g s) ~ s) => InputCharParsing (Fixed p g s) Source # | |
Defined in Text.Grampa.Internal.LeftRecursive Methods satisfyCharInput :: (Char -> Bool) -> Fixed p g s (ParserInput (Fixed p g s)) # notSatisfyChar :: (Char -> Bool) -> Fixed p g s () # scanChars :: state -> (state -> Char -> Maybe state) -> Fixed p g s (ParserInput (Fixed p g s)) # takeCharsWhile :: (Char -> Bool) -> Fixed p g s (ParserInput (Fixed p g s)) # takeCharsWhile1 :: (Char -> Bool) -> Fixed p g s (ParserInput (Fixed p g s)) # | |
| (TextualMonoid s, Show s, Stream s m Char) => InputCharParsing (ParsecT s u m) | |
Defined in Text.Parser.Input Methods satisfyCharInput :: (Char -> Bool) -> ParsecT s u m (ParserInput (ParsecT s u m)) # notSatisfyChar :: (Char -> Bool) -> ParsecT s u m () # scanChars :: state -> (state -> Char -> Maybe state) -> ParsecT s u m (ParserInput (ParsecT s u m)) # takeCharsWhile :: (Char -> Bool) -> ParsecT s u m (ParserInput (ParsecT s u m)) # takeCharsWhile1 :: (Char -> Bool) -> ParsecT s u m (ParserInput (ParsecT s u m)) # | |
| (MonadPlus m, InputCharParsing m, Monoid w) => InputCharParsing (RWST r w s m) | |
Defined in Text.Parser.Input Methods satisfyCharInput :: (Char -> Bool) -> RWST r w s m (ParserInput (RWST r w s m)) # notSatisfyChar :: (Char -> Bool) -> RWST r w s m () # scanChars :: state -> (state -> Char -> Maybe state) -> RWST r w s m (ParserInput (RWST r w s m)) # takeCharsWhile :: (Char -> Bool) -> RWST r w s m (ParserInput (RWST r w s m)) # takeCharsWhile1 :: (Char -> Bool) -> RWST r w s m (ParserInput (RWST r w s m)) # | |
| (MonadPlus m, InputCharParsing m, Monoid w) => InputCharParsing (RWST r w s m) | |
Defined in Text.Parser.Input Methods satisfyCharInput :: (Char -> Bool) -> RWST r w s m (ParserInput (RWST r w s m)) # notSatisfyChar :: (Char -> Bool) -> RWST r w s m () # scanChars :: state -> (state -> Char -> Maybe state) -> RWST r w s m (ParserInput (RWST r w s m)) # takeCharsWhile :: (Char -> Bool) -> RWST r w s m (ParserInput (RWST r w s m)) # takeCharsWhile1 :: (Char -> Bool) -> RWST r w s m (ParserInput (RWST r w s m)) # | |
class InputParsing m => ConsumedInputParsing (m :: Type -> Type) where #
Parsers that keep track of the consumed input.
Methods
match :: m a -> m (ParserInput m, a) #
Return both the result of a parse and the portion of the input that the argument parser consumed.
Instances
| ConsumedInputParsing Parser | |
Defined in Text.Parser.Input | |
| ConsumedInputParsing Parser | |
Defined in Text.Parser.Input | |
| ConsumedInputParsing ReadP | |
Defined in Text.Parser.Input | |
| ConsumedInputParsing (Lazy Get) | |
Defined in Text.Parser.Input | |
| ConsumedInputParsing (Strict Get) | |
Defined in Text.Parser.Input | |
| (LeftReductive s, FactorialMonoid s, Ord s) => ConsumedInputParsing (Parser g s) Source # | |
Defined in Text.Grampa.ContextFree.SortedMemoizing | |
| (Monad m, ConsumedInputParsing m) => ConsumedInputParsing (IdentityT m) | |
Defined in Text.Parser.Input | |
| (MonadPlus m, ConsumedInputParsing m) => ConsumedInputParsing (ReaderT e m) | |
Defined in Text.Parser.Input | |
| (MonadPlus m, ConsumedInputParsing m) => ConsumedInputParsing (StateT s m) | |
Defined in Text.Parser.Input | |
| (MonadPlus m, ConsumedInputParsing m) => ConsumedInputParsing (StateT s m) | |
Defined in Text.Parser.Input | |
| (MonadPlus m, ConsumedInputParsing m, Monoid w) => ConsumedInputParsing (WriterT w m) | |
Defined in Text.Parser.Input | |
| (MonadPlus m, ConsumedInputParsing m, Monoid w) => ConsumedInputParsing (WriterT w m) | |
Defined in Text.Parser.Input | |
| (Applicative m, LeftReductive s, FactorialMonoid s, Ord s) => ConsumedInputParsing (ParserT m g s) Source # | |
| (Apply g, LeftReductive s, FactorialMonoid s, ConsumedInputParsing (p g s), ParserInput (p g s) ~ s) => ConsumedInputParsing (Fixed p g s) Source # | |
Defined in Text.Grampa.Internal.LeftRecursive | |
| (MonadPlus m, ConsumedInputParsing m, Monoid w) => ConsumedInputParsing (RWST r w s m) | |
Defined in Text.Parser.Input | |
| (MonadPlus m, ConsumedInputParsing m, Monoid w) => ConsumedInputParsing (RWST r w s m) | |
Defined in Text.Parser.Input | |
class Ord p => Position p where #
A class for representing position values. The methods satisfy these laws:
move (distance pos1 pos2) pos1 == pos2 (pos1 < pos2) == (distance pos1 pos2 > 0)
Methods
Distance from the first position to the second
Move the position by the given distance.
offset :: FactorialMonoid s => s -> p -> Int #
Map the position into its offset from the beginning of the full input.
From the parsers library
class Parsing m => CharParsing (m :: Type -> Type) where #
Additional functionality needed to parse character streams.
Minimal complete definition
Nothing
Methods
notChar c parses any single character other than c. Returns the parsed
character.
This parser succeeds for any character. Returns the parsed character.
Instances
| CharParsing ReadP | |
| Chunk t => CharParsing (Parser t) | |
| CharParsing f => CharParsing (Lazy f) | |
| CharParsing f => CharParsing (Strict f) | |
| CharParsing m => CharParsing (Unhighlighted m) | |
Defined in Text.Parser.Token Methods satisfy :: (Char -> Bool) -> Unhighlighted m Char # char :: Char -> Unhighlighted m Char # notChar :: Char -> Unhighlighted m Char # anyChar :: Unhighlighted m Char # string :: String -> Unhighlighted m String # text :: Text -> Unhighlighted m Text # | |
| CharParsing m => CharParsing (Unlined m) | |
| CharParsing m => CharParsing (Unspaced m) | |
| (Ord s, Show s, TextualMonoid s) => CharParsing (Parser g s) Source # | |
| (Ord s, Show s, TextualMonoid s) => CharParsing (Parser g s) Source # | |
| (TextualMonoid s, Ord s) => CharParsing (Parser g s) Source # | |
| (Ord s, Show s, TextualMonoid s) => CharParsing (Parser g s) Source # | |
| (Show s, TextualMonoid s) => CharParsing (Parser g s) Source # | |
| (Show s, TextualMonoid s) => CharParsing (Parser g s) Source # | |
| (CharParsing m, MonadPlus m) => CharParsing (IdentityT m) | |
| (CharParsing m, MonadPlus m) => CharParsing (ReaderT e m) | |
| (CharParsing m, MonadPlus m) => CharParsing (StateT s m) | |
| (CharParsing m, MonadPlus m) => CharParsing (StateT s m) | |
| (CharParsing m, MonadPlus m, Monoid w) => CharParsing (WriterT w m) | |
| (CharParsing m, MonadPlus m, Monoid w) => CharParsing (WriterT w m) | |
| (Applicative m, Ord s, Show s, TextualMonoid s) => CharParsing (ParserT m g s) Source # | |
| (Apply g, CharParsing (p g s), InputCharParsing (Fixed p g s), TextualMonoid s, s ~ ParserInput (Fixed p g s), Show s) => CharParsing (Fixed p g s) Source # | |
| Stream s m Char => CharParsing (ParsecT s u m) | |
| (CharParsing m, MonadPlus m, Monoid w) => CharParsing (RWST r w s m) | |
| (CharParsing m, MonadPlus m, Monoid w) => CharParsing (RWST r w s m) | |
class Alternative m => Parsing (m :: Type -> Type) where #
Additional functionality needed to describe parsers independent of input type.
Minimal complete definition
Methods
(<?>) :: m a -> String -> m a infixr 0 #
Give a parser a name
A version of many that discards its input. Specialized because it can often be implemented more cheaply.
skipSome p applies the parser p one or more times, skipping
its result. (aka skipMany1 in parsec)
unexpected :: String -> m a #
Used to emit an error on an unexpected token
default unexpected :: forall (t :: (Type -> Type) -> Type -> Type) (n :: Type -> Type) a. (MonadTrans t, Monad n, Parsing n, m ~ t n) => String -> m a #
notFollowedBy :: Show a => m a -> m () #
notFollowedBy p only succeeds when parser p fails. This parser
does not consume any input. This parser can be used to implement the
'longest match' rule. For example, when recognizing keywords (for
example let), we want to make sure that a keyword is not followed
by a legal identifier character, in which case the keyword is
actually an identifier (for example lets). We can program this
behaviour as follows:
keywordLet = try $ string "let" <* notFollowedBy alphaNum
Instances
| Parsing ReadP | |
| Parsing Get | |
| Chunk t => Parsing (Parser t) | |
Defined in Text.Parser.Combinators | |
| Parsing f => Parsing (Lazy f) | |
| Parsing f => Parsing (Strict f) | |
Defined in Text.Parser.Wrapper | |
| Parsing m => Parsing (Unhighlighted m) | |
Defined in Text.Parser.Token Methods try :: Unhighlighted m a -> Unhighlighted m a # (<?>) :: Unhighlighted m a -> String -> Unhighlighted m a # skipMany :: Unhighlighted m a -> Unhighlighted m () # skipSome :: Unhighlighted m a -> Unhighlighted m () # unexpected :: String -> Unhighlighted m a # eof :: Unhighlighted m () # notFollowedBy :: Show a => Unhighlighted m a -> Unhighlighted m () # | |
| Parsing m => Parsing (Unlined m) | |
Defined in Text.Parser.Token | |
| Parsing m => Parsing (Unspaced m) | |
Defined in Text.Parser.Token | |
| (FactorialMonoid s, Ord s) => Parsing (Parser g s) Source # | |
Defined in Text.Grampa.ContextFree.Continued | |
| (MonoidNull s, Ord s) => Parsing (Parser g s) Source # | |
Defined in Text.Grampa.ContextFree.Memoizing | |
| (FactorialMonoid s, Ord s) => Parsing (Parser g s) Source # | |
Defined in Text.Grampa.ContextFree.Parallel | |
| (MonoidNull s, Ord s) => Parsing (Parser g s) Source # | |
Defined in Text.Grampa.ContextFree.SortedMemoizing | |
| FactorialMonoid s => Parsing (Parser g s) Source # | |
Defined in Text.Grampa.PEG.Backtrack | |
| FactorialMonoid s => Parsing (Parser g s) Source # | |
Defined in Text.Grampa.PEG.Packrat | |
| (Parsing m, Monad m) => Parsing (IdentityT m) | |
Defined in Text.Parser.Combinators | |
| (Parsing m, MonadPlus m) => Parsing (ReaderT e m) | |
Defined in Text.Parser.Combinators | |
| (Parsing m, MonadPlus m) => Parsing (StateT s m) | |
Defined in Text.Parser.Combinators | |
| (Parsing m, MonadPlus m) => Parsing (StateT s m) | |
Defined in Text.Parser.Combinators | |
| (Parsing m, MonadPlus m, Monoid w) => Parsing (WriterT w m) | |
Defined in Text.Parser.Combinators | |
| (Parsing m, MonadPlus m, Monoid w) => Parsing (WriterT w m) | |
Defined in Text.Parser.Combinators | |
| (Applicative m, MonoidNull s, Ord s) => Parsing (ParserT m g s) Source # | |
Defined in Text.Grampa.ContextFree.SortedMemoizing.Transformer Methods try :: ParserT m g s a -> ParserT m g s a # (<?>) :: ParserT m g s a -> String -> ParserT m g s a # skipMany :: ParserT m g s a -> ParserT m g s () # skipSome :: ParserT m g s a -> ParserT m g s () # unexpected :: String -> ParserT m g s a # notFollowedBy :: Show a => ParserT m g s a -> ParserT m g s () # | |
| (Apply g, Parsing (p g s), InputParsing (Fixed p g s)) => Parsing (Fixed p g s) Source # | |
Defined in Text.Grampa.Internal.LeftRecursive | |
| (Stream s m t, Show t) => Parsing (ParsecT s u m) | |
Defined in Text.Parser.Combinators Methods try :: ParsecT s u m a -> ParsecT s u m a # (<?>) :: ParsecT s u m a -> String -> ParsecT s u m a # skipMany :: ParsecT s u m a -> ParsecT s u m () # skipSome :: ParsecT s u m a -> ParsecT s u m () # unexpected :: String -> ParsecT s u m a # notFollowedBy :: Show a => ParsecT s u m a -> ParsecT s u m () # | |
| (Parsing m, MonadPlus m, Monoid w) => Parsing (RWST r w s m) | |
Defined in Text.Parser.Combinators | |
| (Parsing m, MonadPlus m, Monoid w) => Parsing (RWST r w s m) | |
Defined in Text.Parser.Combinators | |
module Text.Parser.LookAhead
class CharParsing m => TokenParsing (m :: Type -> Type) where #
Additional functionality that is needed to tokenize input while ignoring whitespace.
Minimal complete definition
Nothing
Methods
Usually, someSpace consists of one or more occurrences of a space.
Some parsers may choose to recognize line comments or block (multi line)
comments as white space as well.
Called when we enter a nested pair of symbols. Overloadable to enable disabling layout
The token parser |semi| parses the character ';' and skips any trailing white space. Returns the character ';'. Overloadable to permit automatic semicolon insertion or Haskell-style layout.
highlight :: Highlight -> m a -> m a #
Tag a region of parsed text with a bit of semantic information. Most parsers won't use this, but it is indispensible for highlighters.
token p first applies parser p and then the whiteSpace
parser, returning the value of p. Every lexical
token (token) is defined using token, this way every parse
starts at a point without white space. Parsers that use token are
called token parsers in this document.
The only point where the whiteSpace parser should be
called explicitly is the start of the main parser in order to skip
any leading white space.
Alternatively, one might define token as first parsing whiteSpace
and then parser p. By parsing whiteSpace first, the parser is able
to return before parsing additional whiteSpace, improving laziness.
mainParser = sum <$ whiteSpace <*> many (token digit) <* eof
Instances
| TokenParsing ReadP | |
| Chunk t => TokenParsing (Parser t) | |
| TokenParsing f => TokenParsing (Lazy f) | |
| TokenParsing f => TokenParsing (Strict f) | |
| TokenParsing m => TokenParsing (Unhighlighted m) | |
Defined in Text.Parser.Token Methods someSpace :: Unhighlighted m () # nesting :: Unhighlighted m a -> Unhighlighted m a # semi :: Unhighlighted m Char # highlight :: Highlight -> Unhighlighted m a -> Unhighlighted m a # token :: Unhighlighted m a -> Unhighlighted m a # | |
| TokenParsing m => TokenParsing (Unlined m) | |
| TokenParsing m => TokenParsing (Unspaced m) | |
| (TokenParsing m, MonadPlus m) => TokenParsing (IdentityT m) | |
| (TokenParsing m, MonadPlus m) => TokenParsing (ReaderT e m) | |
| (TokenParsing m, MonadPlus m) => TokenParsing (StateT s m) | |
| (TokenParsing m, MonadPlus m) => TokenParsing (StateT s m) | |
| (TokenParsing m, MonadPlus m, Monoid w) => TokenParsing (WriterT w m) | |
| (TokenParsing m, MonadPlus m, Monoid w) => TokenParsing (WriterT w m) | |
| Stream s m Char => TokenParsing (ParsecT s u m) | |
| (TokenParsing m, MonadPlus m, Monoid w) => TokenParsing (RWST r w s m) | |
| (TokenParsing m, MonadPlus m, Monoid w) => TokenParsing (RWST r w s m) | |
Other combinators
concatMany :: (Alternative p, Monoid a) => p a -> p a Source #
Zero or more argument occurrences like many, with concatenated monoidal results.
concatSome :: (Alternative p, Semigroup a) => p a -> p a Source #
One or more argument occurrences like some, with concatenated monoidal results.