petitparser library

This package exports the core library of PetitParser, a dynamic parser combinator framework.

Classes

AndParser<R>
The and-predicate, a parser that succeeds whenever its delegate does, but does not consume the input stream.
AnyCharacterParser
A parser that accepts any input element.
CastListParser<R, S>
A parser that casts a Result<List> to a Result<List<S>>.
CastParser<R, S>
A parser that casts a Result to a Result<R>.
CharacterPredicate
Abstract character predicate class.
ChoiceParser<R>
A parser that uses the first parser that succeeds.
Context
An immutable parse context.
ContinuationParser<R, S>
Continuation parser that when activated captures a continuation function and passes it together with the current context into the handler.
DelegateParser<T, R>
An abstract parser that delegates to a parser of type T and returns a result of type R.
DigitCharPredicate
EndOfInputParser
A parser that succeeds at the end of input.
EpsilonParser<R>
A parser that consumes nothing and succeeds.
ExpressionBuilder<T>
A builder that allows the simple definition of expression grammars with prefix, postfix, and left- and right-associative infix operators.
ExpressionGroup<T>
Models a group of operators of the same precedence.
Failure
An immutable failed parse result.
FailureParser
A parser that consumes nothing and fails.
FlattenParser<R>
A parser that discards the result of the delegate and answers the sub-string its delegate consumes.
GrammarDefinition<R>
Helper to conveniently define and build complex, recursive grammars using plain Dart code.
GrammarParser<T>
A (now pointless) helper to build a parser from a {@link GrammarDefinition}.
GreedyRepeatingParser<R>
A greedy repeating parser, commonly seen in regular expression implementations. It aggressively consumes as much input as possible and then backtracks to meet the 'limit' condition.
LabeledParser<R>
Interface of a parser that has a debug label.
LabelParser<R>
A parser that always defers to its delegate, but that also holds a label for debugging purposes.
LazyRepeatingParser<R>
A lazy repeating parser, commonly seen in regular expression implementations. It limits its consumption to meet the 'limit' condition as early as possible.
LetterCharPredicate
LimitedRepeatingParser<R>
An abstract parser that repeatedly parses between 'min' and 'max' instances of its delegate and that requires the input to be completed with a specified parser 'limit'. Subclasses provide repeating behavior as typically seen in regular expression implementations (non-blind).
ListParser<R, S>
Abstract parser that parses a list of things in some way.
LowercaseCharPredicate
MapParser<R, S>
A parser that performs a transformation with a given function on the successful parse result of the delegate.
NewlineParser
A parser that consumes newlines platform independently.
NotParser<R>
The not-predicate, a parser that succeeds whenever its delegate does not, but consumes no input.
OptionalParser<R>
A parser that optionally parsers its delegate, or answers null.
Parser<R>
Abstract base class of all parsers that produce a parse result of type R.
PatternParser
A parser that uses a Pattern matcher for parsing.
PermuteParser<R>
A parser that performs a transformation with a given function on the successful parse result of the delegate.
PickParser<R>
A parser that performs a transformation with a given function on the successful parse result of the delegate.
PositionParser
A parser that reports the current input position.
PossessiveRepeatingParser<R>
A greedy parser that repeatedly parses between 'min' and 'max' instances of its delegate.
PredicateParser
A parser for a literal satisfying a predicate.
RangeCharPredicate
RepeatingCharacterParser
An abstract parser that repeatedly parses between 'min' and 'max' instances of its delegate.
RepeatingParser<T, R>
An abstract parser that repeatedly parses between 'min' and 'max' instances of its delegate.
ResolvableParser<R>
Interface of a parser that can be resolved to another one.
Result<R>
An immutable parse result that is either a Success or a Failure.
SeparatedList<R, S>
A list of elements and its separators.
SeparatedRepeatingParser<R, S>
A parser that consumes the delegate between min and max times separated by the separator parser.
SequenceParser<R>
A parser that parses a sequence of parsers.
SequenceParser2<R1, R2>
A parser that consumes a sequence of 2 parsers and returns a Record with 2 positional parse results.
SequenceParser3<R1, R2, R3>
A parser that consumes a sequence of 3 parsers and returns a Record with 3 positional parse results.
SequenceParser4<R1, R2, R3, R4>
A parser that consumes a sequence of 4 parsers and returns a Record with 4 positional parse results.
SequenceParser5<R1, R2, R3, R4, R5>
A parser that consumes a sequence of 5 parsers and returns a Record with 5 positional parse results.
SequenceParser6<R1, R2, R3, R4, R5, R6>
A parser that consumes a sequence of 6 parsers and returns a Record with 6 positional parse results.
SequenceParser7<R1, R2, R3, R4, R5, R6, R7>
A parser that consumes a sequence of 7 parsers and returns a Record with 7 positional parse results.
SequenceParser8<R1, R2, R3, R4, R5, R6, R7, R8>
A parser that consumes a sequence of 8 parsers and returns a Record with 8 positional parse results.
SequenceParser9<R1, R2, R3, R4, R5, R6, R7, R8, R9>
A parser that consumes a sequence of 9 parsers and returns a Record with 9 positional parse results.
SettableParser<R>
A parser that is not defined, but that can be set at a later point in time.
SingleCharacterParser
Parser class for individual character classes.
SingleCharPredicate
SkipParser<R>
A parser that silently consumes input of another parser before and after its delegate.
Success<R>
An immutable successful parse result.
Token<R>
A token represents a parsed part of the input stream.
TokenParser<R>
A parser that creates a token of the result its delegate parses.
TrimmingParser<R>
A parser that silently consumes input of another parser around its delegate.
UppercaseCharPredicate
WhereParser<R>
WhitespaceCharPredicate
WordCharPredicate

Extensions

AcceptParser on Parser<R>
AndParserExtension on Parser<R>
CastListParserExtension on Parser<R>
CastParserExtension on Parser<R>
ChoiceIterableExtension on Iterable<Parser<R>>
ChoiceParserExtension on Parser
ContinuationParserExtension on Parser<R>
EndOfInputParserExtension on Parser<R>
FlattenParserExtension on Parser<R>
GreedyRepeatingParserExtension on Parser<R>
LabelParserExtension on Parser<R>
LazyRepeatingParserExtension on Parser<R>
MapParserExtension on Parser<R>
MatchesParserExtension on Parser<T>
NotParserExtension on Parser<R>
OptionalParserExtension on Parser<R>
PatternParserExtension on Parser<R>
PermuteParserExtension on Parser<List<R>>
PickParserExtension on Parser<List<R>>
PossessiveRepeatingParserExtension on Parser<R>
PredicateStringExtension on String
RecordOfParsersExtension2 on (Parser<R1>, Parser<R2>)
Extensions on a Record with 2 positional Parsers.
RecordOfParsersExtension3 on (Parser<R1>, Parser<R2>, Parser<R3>)
Extensions on a Record with 3 positional Parsers.
RecordOfParsersExtension4 on (Parser<R1>, Parser<R2>, Parser<R3>, Parser<R4>)
Extensions on a Record with 4 positional Parsers.
RecordOfParsersExtension5 on (Parser<R1>, Parser<R2>, Parser<R3>, Parser<R4>, Parser<R5>)
Extensions on a Record with 5 positional Parsers.
RecordOfParsersExtension6 on (Parser<R1>, Parser<R2>, Parser<R3>, Parser<R4>, Parser<R5>, Parser<R6>)
Extensions on a Record with 6 positional Parsers.
RecordOfParsersExtension7 on (Parser<R1>, Parser<R2>, Parser<R3>, Parser<R4>, Parser<R5>, Parser<R6>, Parser<R7>)
Extensions on a Record with 7 positional Parsers.
RecordOfParsersExtension8 on (Parser<R1>, Parser<R2>, Parser<R3>, Parser<R4>, Parser<R5>, Parser<R6>, Parser<R7>, Parser<R8>)
Extensions on a Record with 8 positional Parsers.
RecordOfParsersExtension9 on (Parser<R1>, Parser<R2>, Parser<R3>, Parser<R4>, Parser<R5>, Parser<R6>, Parser<R7>, Parser<R8>, Parser<R9>)
Extensions on a Record with 9 positional Parsers.
RecordOfValuesExtension2 on (T1, T2)
Extension on a Record with 2 positional values.
RecordOfValuesExtension3 on (T1, T2, T3)
Extension on a Record with 3 positional values.
RecordOfValuesExtension4 on (T1, T2, T3, T4)
Extension on a Record with 4 positional values.
RecordOfValuesExtension5 on (T1, T2, T3, T4, T5)
Extension on a Record with 5 positional values.
RecordOfValuesExtension6 on (T1, T2, T3, T4, T5, T6)
Extension on a Record with 6 positional values.
RecordOfValuesExtension7 on (T1, T2, T3, T4, T5, T6, T7)
Extension on a Record with 7 positional values.
RecordOfValuesExtension8 on (T1, T2, T3, T4, T5, T6, T7, T8)
Extension on a Record with 8 positional values.
RecordOfValuesExtension9 on (T1, T2, T3, T4, T5, T6, T7, T8, T9)
Extension on a Record with 9 positional values.
RecordParserExtension2 on Parser<(T1, T2)>
Extension on a Parser producing a Record of 2 positional values.
RecordParserExtension3 on Parser<(T1, T2, T3)>
Extension on a Parser producing a Record of 3 positional values.
RecordParserExtension4 on Parser<(T1, T2, T3, T4)>
Extension on a Parser producing a Record of 4 positional values.
RecordParserExtension5 on Parser<(T1, T2, T3, T4, T5)>
Extension on a Parser producing a Record of 5 positional values.
RecordParserExtension6 on Parser<(T1, T2, T3, T4, T5, T6)>
Extension on a Parser producing a Record of 6 positional values.
RecordParserExtension7 on Parser<(T1, T2, T3, T4, T5, T6, T7)>
Extension on a Parser producing a Record of 7 positional values.
RecordParserExtension8 on Parser<(T1, T2, T3, T4, T5, T6, T7, T8)>
Extension on a Parser producing a Record of 8 positional values.
RecordParserExtension9 on Parser<(T1, T2, T3, T4, T5, T6, T7, T8, T9)>
Extension on a Parser producing a Record of 9 positional values.
RepeatingCharacterParserExtension on Parser<String>
SeparatedByParserExtension on Parser<T>
SeparatedRepeatingParserExtension on Parser<R>
SequenceIterableExtension on Iterable<Parser<R>>
SequenceParserExtension on Parser
SettableParserExtension on Parser<R>
SkipParserExtension on Parser<R>
TokenParserExtension on Parser<R>
TrimmingParserExtension on Parser<R>
WhereParserExtension on Parser<R>

Constants

unbounded → const int
An int used to mark an unbounded maximum repetition.

Functions

any([String message = 'input expected']) Parser<String>
Returns a parser that accepts any input element.
anyOf(String chars, [String? message]) Parser<String>
Returns a parser that accepts any of the specified characters.
char(String char, [String? message]) Parser<String>
Returns a parser that accepts a specific character only.
charIgnoringCase(String char, [String? message]) Parser<String>
Returns a parser that accepts a case-insensitive specific character only.
createFactory_<R>({String? message, FailureFactory<R>? factory, Callback<R, String>? failureMessage, Callback<R, int>? failurePosition}) FailureFactory<R>
digit([String message = 'digit expected']) Parser<String>
Returns a parser that accepts any digit character. The accepted input is equivalent to the character-set 0-9.
endOfInput([String message = 'end of input expected']) Parser<void>
Returns a parser that succeeds at the end of input.
epsilon() Parser<void>
Returns a parser that consumes nothing and succeeds.
epsilonWith<R>(R result) Parser<R>
Returns a parser that consumes nothing and succeeds with result.
failure<R>([String message = 'unable to parse']) Parser<R>
Returns a parser that consumes nothing and fails.
letter([String message = 'letter expected']) Parser<String>
Returns a parser that accepts any letter character (lowercase or uppercase). The accepted input is equivalent to the character-set a-zA-Z.
lowercase([String message = 'lowercase letter expected']) Parser<String>
Returns a parser that accepts any lowercase character. The accepted input is equivalent to the character-set a-z.
newline([String message = 'newline expected']) Parser<String>
Returns a parser that detects newlines platform independently.
noneOf(String chars, [String? message]) Parser<String>
Returns a parser that accepts none of the specified characters.
pattern(String element, [String? message]) Parser<String>
Returns a parser that accepts a single character of a given character set provided as a string.
patternIgnoreCase(String element, [String? message]) Parser<String>
Returns a parser that accepts a single character of a given case-insensitive character set provided as a string.
position() Parser
Returns a parser that reports the current input position.
predicate(int length, Predicate<String> predicate, String message) Parser<String>
Returns a parser that reads input of the specified length, accepts it if the predicate matches, or fails with the given message.
range(String start, String stop, [String? message]) Parser<String>
Returns a parser that accepts any character in the range between start and stop.
ref<R>(Function function, [dynamic arg1 = undefined, dynamic arg2 = undefined, dynamic arg3 = undefined, dynamic arg4 = undefined, dynamic arg5 = undefined, dynamic arg6 = undefined, dynamic arg7 = undefined, dynamic arg8 = undefined, dynamic arg9 = undefined]) Parser<R>
Creates a Parser from a function reference, possibly with the given arguments arg1, arg2, arg3, ...
ref0<R>(Parser<R> function()) Parser<R>
Creates a Parser from a function without arguments.
ref1<R, A1>(Parser<R> function(A1), A1 arg1) Parser<R>
Reference to a production function parametrized with 1 argument.
ref2<R, A1, A2>(Parser<R> function(A1, A2), A1 arg1, A2 arg2) Parser<R>
Reference to a production function parametrized with 2 arguments.
ref3<R, A1, A2, A3>(Parser<R> function(A1, A2, A3), A1 arg1, A2 arg2, A3 arg3) Parser<R>
Reference to a production function parametrized with 3 arguments.
ref4<R, A1, A2, A3, A4>(Parser<R> function(A1, A2, A3, A4), A1 arg1, A2 arg2, A3 arg3, A4 arg4) Parser<R>
Reference to a production function parametrized with 4 arguments.
ref5<R, A1, A2, A3, A4, A5>(Parser<R> function(A1, A2, A3, A4, A5), A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5) Parser<R>
Reference to a production function parametrized with 5 arguments.
ref6<R, A1, A2, A3, A4, A5, A6>(Parser<R> function(A1, A2, A3, A4, A5, A6), A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5, A6 arg6) Parser<R>
Reference to a production function parametrized with 6 arguments.
ref7<R, A1, A2, A3, A4, A5, A6, A7>(Parser<R> function(A1, A2, A3, A4, A5, A6, A7), A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5, A6 arg6, A7 arg7) Parser<R>
Reference to a production function parametrized with 7 arguments.
ref8<R, A1, A2, A3, A4, A5, A6, A7, A8>(Parser<R> function(A1, A2, A3, A4, A5, A6, A7, A8), A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5, A6 arg6, A7 arg7, A8 arg8) Parser<R>
Reference to a production function parametrized with 8 arguments.
ref9<R, A1, A2, A3, A4, A5, A6, A7, A8, A9>(Parser<R> function(A1, A2, A3, A4, A5, A6, A7, A8, A9), A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5, A6 arg6, A7 arg7, A8 arg8, A9 arg9) Parser<R>
Reference to a production function parametrized with 9 arguments.
resolve<R>(Parser<R> parser) Parser<R>
Resolves all parser references reachable through parser. Returns an optimized parser graph that inlines all references directly.
selectFarthest(Failure first, Failure second) Failure
Reports the parser failure farthest down in the input string, preferring later failures over earlier ones.
selectFarthestJoined(Failure first, Failure second) Failure
Reports the parser failure farthest down in the input string, joining error messages at the same position.
selectFirst(Failure first, Failure second) Failure
Reports the first parse failure observed.
selectLast(Failure first, Failure second) Failure
Reports the last parse failure observed (default).
seq2<R1, R2>(Parser<R1> parser1, Parser<R2> parser2) Parser<(R1, R2)>
Creates a Parser that consumes the 2 parsers passed as argument in sequence and returns a Record with 2 positional parse results.
seq3<R1, R2, R3>(Parser<R1> parser1, Parser<R2> parser2, Parser<R3> parser3) Parser<(R1, R2, R3)>
Creates a Parser that consumes the 3 parsers passed as argument in sequence and returns a Record with 3 positional parse results.
seq4<R1, R2, R3, R4>(Parser<R1> parser1, Parser<R2> parser2, Parser<R3> parser3, Parser<R4> parser4) Parser<(R1, R2, R3, R4)>
Creates a Parser that consumes the 4 parsers passed as argument in sequence and returns a Record with 4 positional parse results.
seq5<R1, R2, R3, R4, R5>(Parser<R1> parser1, Parser<R2> parser2, Parser<R3> parser3, Parser<R4> parser4, Parser<R5> parser5) Parser<(R1, R2, R3, R4, R5)>
Creates a Parser that consumes the 5 parsers passed as argument in sequence and returns a Record with 5 positional parse results.
seq6<R1, R2, R3, R4, R5, R6>(Parser<R1> parser1, Parser<R2> parser2, Parser<R3> parser3, Parser<R4> parser4, Parser<R5> parser5, Parser<R6> parser6) Parser<(R1, R2, R3, R4, R5, R6)>
Creates a Parser that consumes the 6 parsers passed as argument in sequence and returns a Record with 6 positional parse results.
seq7<R1, R2, R3, R4, R5, R6, R7>(Parser<R1> parser1, Parser<R2> parser2, Parser<R3> parser3, Parser<R4> parser4, Parser<R5> parser5, Parser<R6> parser6, Parser<R7> parser7) Parser<(R1, R2, R3, R4, R5, R6, R7)>
Creates a Parser that consumes the 7 parsers passed as argument in sequence and returns a Record with 7 positional parse results.
seq8<R1, R2, R3, R4, R5, R6, R7, R8>(Parser<R1> parser1, Parser<R2> parser2, Parser<R3> parser3, Parser<R4> parser4, Parser<R5> parser5, Parser<R6> parser6, Parser<R7> parser7, Parser<R8> parser8) Parser<(R1, R2, R3, R4, R5, R6, R7, R8)>
Creates a Parser that consumes the 8 parsers passed as argument in sequence and returns a Record with 8 positional parse results.
seq9<R1, R2, R3, R4, R5, R6, R7, R8, R9>(Parser<R1> parser1, Parser<R2> parser2, Parser<R3> parser3, Parser<R4> parser4, Parser<R5> parser5, Parser<R6> parser6, Parser<R7> parser7, Parser<R8> parser8, Parser<R9> parser9) Parser<(R1, R2, R3, R4, R5, R6, R7, R8, R9)>
Creates a Parser that consumes the 9 parsers passed as argument in sequence and returns a Record with 9 positional parse results.
string(String element, [String? message]) Parser<String>
Returns a parser that accepts the string element.
stringIgnoreCase(String element, [String? message]) Parser<String>
Returns a parser that accepts the string element ignoring the case.
undefined<R>([String message = 'undefined parser']) SettableParser<R>
Returns a parser that is not defined, but that can be set at a later point in time.
uppercase([String message = 'uppercase letter expected']) Parser<String>
Returns a parser that accepts any uppercase character. The accepted input is equivalent to the character-set A-Z.
whitespace([String message = 'whitespace expected']) Parser<String>
Returns a parser that accepts any whitespace character.
word([String message = 'letter or digit expected']) Parser<String>
Returns a parser that accepts any word character (lowercase, uppercase, underscore, or digit). The accepted input is equivalent to the character-set a-zA-Z_0-9.

Typedefs

AnyParser = AnyCharacterParser
Alias for deprecated class name.
CharacterParser = SingleCharacterParser
Alias for deprecated class name.
ContinuationFunction<R> = Result<R> Function(Context context)
Continuation function of the ContinuationHandler.
ContinuationHandler<R, S> = Result<S> Function(ContinuationFunction<R> continuation, Context context)
Handler function for the ContinuationParser.
FailureFactory<R> = Result<R> Function(Context context, Success<R> success)
FailureJoiner = Failure Function(Failure first, Failure second)
Function definition that joins parse Failure instances.

Exceptions / Errors

ParserException
An exception raised in case of a parse error.