| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Text.Grampa
Description
Collection of parsing algorithms with a common interface, operating on grammars represented as records with rank-2 field types.
Synopsis
- class MultiParsing m where
- type ResultFunctor m :: * -> *
- type GrammarConstraint m (g :: (* -> *) -> *) :: Constraint
- parseComplete :: (GrammarConstraint m g, FactorialMonoid s) => g (m g s) -> s -> g (ResultFunctor m)
- parsePrefix :: (GrammarConstraint m g, FactorialMonoid s) => g (m g s) -> s -> g (Compose (ResultFunctor m) ((,) s))
- offsetContext :: (Eq s, IsString s, FactorialMonoid s) => s -> Int -> Int -> s
- offsetLineAndColumn :: (Eq s, IsString s, FactorialMonoid s) => s -> Int -> ([s], Int)
- positionOffset :: FactorialMonoid s => s -> Position s -> Int
- failureDescription :: forall s. (Eq s, IsString s, FactorialMonoid s) => s -> ParseFailure -> Int -> s
- simply :: (Only r (p (Only r) s) -> s -> Only r f) -> p (Only r) s r -> s -> f r
- type Grammar (g :: (* -> *) -> *) p s = g (p g s)
- type GrammarBuilder (g :: (* -> *) -> *) (g' :: (* -> *) -> *) (p :: ((* -> *) -> *) -> * -> * -> *) (s :: *) = g (p g' s) -> g (p g' s)
- type ParseResults = Either ParseFailure
- data ParseFailure = ParseFailure Int [String]
- newtype Ambiguous a = Ambiguous (NonEmpty a)
- data Position s
- class MultiParsing m => GrammarParsing m where
- type GrammarFunctor m :: ((* -> *) -> *) -> * -> * -> *
- nonTerminal :: GrammarConstraint m g => (g (GrammarFunctor m g s) -> GrammarFunctor m g s a) -> m g s a
- selfReferring :: (GrammarConstraint m g, Distributive g) => g (m g s)
- fixGrammar :: forall g s. (GrammarConstraint m g, Distributive g) => (g (m g s) -> g (m g s)) -> g (m g s)
- recursive :: m g s a -> m g s a
- class MonoidParsing m where
- endOfInput :: FactorialMonoid s => m s ()
- getInput :: FactorialMonoid s => m s s
- getSourcePos :: FactorialMonoid s => m s (Position s)
- anyToken :: FactorialMonoid s => m s s
- satisfy :: FactorialMonoid s => (s -> Bool) -> m s s
- satisfyChar :: TextualMonoid s => (Char -> Bool) -> m s Char
- satisfyCharInput :: TextualMonoid s => (Char -> Bool) -> m s s
- notSatisfy :: FactorialMonoid s => (s -> Bool) -> m s ()
- notSatisfyChar :: TextualMonoid s => (Char -> Bool) -> m s ()
- scan :: FactorialMonoid t => s -> (s -> t -> Maybe s) -> m t t
- scanChars :: TextualMonoid t => s -> (s -> Char -> Maybe s) -> m t t
- string :: (FactorialMonoid s, LeftReductiveMonoid s, Show s) => s -> m s s
- takeWhile :: FactorialMonoid s => (s -> Bool) -> m s s
- takeWhile1 :: FactorialMonoid s => (s -> Bool) -> m s s
- takeCharsWhile :: TextualMonoid s => (Char -> Bool) -> m s s
- takeCharsWhile1 :: TextualMonoid s => (Char -> Bool) -> m s s
- concatMany :: Monoid a => m s a -> m s a
- class AmbiguousParsing m where
- class Lexical (g :: (* -> *) -> *) where
- type LexicalConstraint (m :: ((* -> *) -> *) -> * -> * -> *) g s :: Constraint
- lexicalWhiteSpace :: LexicalConstraint m g s => m g s ()
- someLexicalSpace :: LexicalConstraint m g s => m g s ()
- lexicalComment :: LexicalConstraint m g s => m g s ()
- lexicalSemicolon :: LexicalConstraint m g s => m g s Char
- lexicalToken :: LexicalConstraint m g s => m g s a -> m g s a
- identifierToken :: LexicalConstraint m g s => m g s s -> m g s s
- isIdentifierStartChar :: Char -> Bool
- isIdentifierFollowChar :: Char -> Bool
- identifier :: LexicalConstraint m g s => m g s s
- keyword :: LexicalConstraint m g s => s -> m g s ()
- 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 ()
- class Parsing m => LookAheadParsing (m :: Type -> Type) where
- lookAhead :: m a -> m a
Parsing methods
class MultiParsing m where Source #
Choose one of the instances of this class to parse with.
Associated Types
type ResultFunctor m :: * -> * Source #
Some parser types produce a single result, others a list of results.
type GrammarConstraint m (g :: (* -> *) -> *) :: Constraint Source #
Methods
parseComplete :: (GrammarConstraint m g, FactorialMonoid s) => g (m g s) -> s -> g (ResultFunctor m) Source #
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)) Source #
Given a rank-2 record of parsers and input, produce a record of prefix parses paired with the remaining input suffix.
Instances
offsetContext :: (Eq s, IsString s, FactorialMonoid s) => s -> Int -> Int -> s Source #
Given the parser input, an offset within it, and desired number of context lines, returns a description of the offset position in English.
offsetLineAndColumn :: (Eq s, IsString s, FactorialMonoid s) => s -> Int -> ([s], Int) Source #
Given the full input and an offset within it, returns all the input lines up to and including the offset in reverse order, as well as the zero-based column number of the offset
positionOffset :: FactorialMonoid s => s -> Position s -> Int Source #
Map the position into its offset from the beginning of the full input.
failureDescription :: forall s. (Eq s, IsString s, FactorialMonoid s) => s -> ParseFailure -> Int -> s Source #
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 Source #
Apply the given parse function to the given grammar-free parser and its input.
Types
type Grammar (g :: (* -> *) -> *) p s = g (p g s) Source #
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) Source #
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 Source #
data ParseFailure Source #
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 Source # | |
Defined in Text.Grampa.Class | |
| Show ParseFailure Source # | |
Defined in Text.Grampa.Class Methods showsPrec :: Int -> ParseFailure -> ShowS # show :: ParseFailure -> String # showList :: [ParseFailure] -> ShowS # | |
An Ambiguous parse result, produced by the ambiguous combinator, contains a NonEmpty list of
alternative results.
Instances
| Functor Ambiguous Source # | |
| Applicative Ambiguous Source # | |
| Foldable Ambiguous Source # | |
Defined in Text.Grampa.Class Methods fold :: Monoid m => Ambiguous m -> 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 # | |
| Traversable Ambiguous Source # | |
Defined in Text.Grampa.Class | |
| Show1 Ambiguous Source # | |
| Eq a => Eq (Ambiguous a) 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 :: (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) Source # | |
Defined in Text.Grampa.Class | |
| Show a => Show (Ambiguous a) Source # | |
| Semigroup a => Semigroup (Ambiguous a) Source # | |
| Monoid a => Monoid (Ambiguous a) Source # | |
Parser combinators and primitives
class MultiParsing m => GrammarParsing m where Source #
Parsers that belong to this class can memoize the parse results to avoid exponential performance complexity.
Minimal complete definition
Associated Types
type GrammarFunctor m :: ((* -> *) -> *) -> * -> * -> * Source #
Methods
nonTerminal :: GrammarConstraint m g => (g (GrammarFunctor m g s) -> GrammarFunctor m g s a) -> m g s a Source #
Used to reference a grammar production, only necessary from outside the grammar itself
selfReferring :: (GrammarConstraint m g, Distributive g) => g (m g s) Source #
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) Source #
Convert a self-referring grammar function to a grammar.
recursive :: m g s a -> m g s a Source #
Mark a parser that relies on primitive recursion to prevent an infinite loop in fixGrammar.
Instances
class MonoidParsing m where Source #
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 () Source #
A parser that fails on any input and succeeds at its end.
getInput :: FactorialMonoid s => m s s Source #
Always sucessful parser that returns the remaining input without consuming it.
getSourcePos :: FactorialMonoid s => m s (Position s) Source #
Retrieve the Position the parser has reached in the input source.
anyToken :: FactorialMonoid s => m s s Source #
A parser that accepts any single input atom.
satisfy :: FactorialMonoid s => (s -> Bool) -> m s s Source #
A parser that accepts an input atom only if it satisfies the given predicate.
satisfyChar :: TextualMonoid s => (Char -> Bool) -> m s Char Source #
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 Source #
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 () Source #
A parser that succeeds exactly when satisfy doesn't, equivalent to
notFollowedBy . satisfy
notSatisfyChar :: TextualMonoid s => (Char -> Bool) -> m s () Source #
A parser that succeeds exactly when satisfyChar doesn't, equivalent to
notFollowedBy . satisfyChar
scan :: FactorialMonoid t => s -> (s -> t -> Maybe s) -> m t t Source #
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 Source #
Stateful scanner like scanChars, but specialized for TextualMonoid inputs.
string :: (FactorialMonoid s, LeftReductiveMonoid s, Show s) => s -> m s s Source #
A parser that consumes and returns the given prefix of the input.
takeWhile :: FactorialMonoid s => (s -> Bool) -> m s s Source #
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 Source #
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 Source #
Specialization of MonoidParsing 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 Source #
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 Source #
Zero or more argument occurrences like many, with concatenated monoidal results.
concatMany :: (Monoid a, Alternative (m s)) => m s a -> m s a Source #
Zero or more argument occurrences like many, with concatenated monoidal results.
getSourcePos :: (FactorialMonoid s, Functor (m s)) => m s (Position s) Source #
Retrieve the Position the parser has reached in the input source.
Instances
class AmbiguousParsing m 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
| AmbiguousParsing (Parser g s) Source # | |
| AmbiguousParsing (Fixed Parser g s) Source # | |
class Lexical (g :: (* -> *) -> *) where Source #
If a grammar is Lexical, its parsers can instantiate the TokenParsing class.
Minimal complete definition
Nothing
Associated Types
type LexicalConstraint (m :: ((* -> *) -> *) -> * -> * -> *) g s :: Constraint Source #
Methods
lexicalWhiteSpace :: LexicalConstraint m g s => m g s () Source #
Always succeeds, consuming all white space and comments
someLexicalSpace :: LexicalConstraint m g s => m g s () Source #
Consumes all whitespace and comments, failing if there are none
lexicalComment :: LexicalConstraint m g s => m g s () Source #
Consumes a single comment, defaults to empty
lexicalSemicolon :: LexicalConstraint m g s => m g s 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 :: LexicalConstraint m g s => m g s a -> m g s a Source #
Applies the argument parser and consumes the trailing lexicalWhitespace
identifierToken :: LexicalConstraint m g s => m g s s -> m g s s 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 :: LexicalConstraint m g s => m g s s Source #
Parses a valid identifier and consumes the trailing lexicalWhitespace
keyword :: LexicalConstraint m g s => s -> m g s () Source #
Parses the argument word whole, not followed by any identifier character, and consumes the trailing
lexicalWhitespace
lexicalComment :: Alternative (m g s) => m g s () Source #
Consumes a single comment, defaults to empty
lexicalWhiteSpace :: (LexicalConstraint m g s, Parsing (m g s), MonoidParsing (m g), TextualMonoid s) => m g s () Source #
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 () Source #
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 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 :: (LexicalConstraint m g s, Parsing (m g s), MonoidParsing (m g), TextualMonoid s) => m g s a -> m g s a Source #
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 Source #
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 Source #
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 () Source #
Parses the argument word whole, not followed by any identifier character, and consumes the trailing
lexicalWhitespace
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
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
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
class Parsing m => LookAheadParsing (m :: Type -> Type) where #
Additional functionality needed to describe parsers independent of input type.