Documentation for the Code¶
A universal Python parser combinator library inspired by Parsec library of Haskell.
-
exception
parsec.
ParseError
(expected, text, index)¶ Type for parse error.
-
loc
()¶ Locate the error position in the source code text.
-
static
loc_info
(text, index)¶ Location of index in source code text.
-
-
class
parsec.
Parser
(fn)¶ A Parser is an object that wraps a function to do the parsing work. Arguments of the function should be a string to be parsed and the index on which to begin parsing.
The function should return either Value.success(next_index, value) if parsing successfully, or Value.failure(index, expected) on the failure.
-
bind
(fn)¶ This is the monadic binding operation. Returns a parser which, if parser is successful, passes the result to fn, and continues with the parser returned from fn.
-
choice
(other)¶ (|) This combinator implements choice. The parser p | q first applies p.
- If it succeeds, the value of p is returned.
- If p fails without consuming any input, parser q is tried.
NOTICE: without backtrack.
-
compose
(other)¶ (>>) Sequentially compose two actions, discarding any value produced by the first.
-
desc
(description)¶ Describe a parser, when it failed, print out the description text.
-
ends_with
(other)¶ (<) Ends with a specified parser, and at the end parser hasn’t consumed any input.
-
excepts
(other)¶ Fail though matched when the consecutive parser other success for the rest text.
-
joint
(*parsers)¶ (+) Joint two or more parsers into one. Return the aggregate of two results from this two parser.
-
mark
()¶ Mark the line and column information of the result of this parser.
-
parse
(text)¶ Parses a given string text.
-
parse_partial
(text)¶ Parse the longest possible prefix of a given string.
Return a tuple of the result value and the rest of the string.
If failed, raise a ParseError.
-
parse_strict
(text)¶ Parse the longest possible prefix of the entire given string.
If the parser worked successfully and NONE text was rested, return the result value, else raise a ParseError.
The difference between parse and parse_strict is that whether entire given text must be used.
-
parsecapp
(other)¶ Returns a parser that applies the produced value of this parser to the produced value of other.
-
parsecmap
(fn)¶ Returns a parser that transforms the produced value of parser with fn.
-
result
(res)¶ Return a value according to the parameter res when parse successfully.
-
skip
(other)¶ (<<) Ends with a specified parser, and at the end parser consumed the end flag.
-
try_choice
(other)¶ (^) Choice with backtrack. This combinator is used whenever arbitrary look ahead is needed. The parser p || q first applies p, if it success, the value of p is returned. If p fails, it pretends that it hasn’t consumed any input, and then parser q is tried.
-
-
class
parsec.
Value
¶ Represent the result of the Parser.
-
aggregate
(other=None)¶ collect the furthest failure from self and other.
-
static
combinate
(values)¶ Aggregate multiple values into tuple
-
static
failure
(index, expected)¶ Create failure value.
-
static
success
(index, actual)¶ Create success value.
-
-
parsec.
any
()¶ Parses a arbitrary character.
-
parsec.
bind
(p, fn)¶ Bind two parsers, implements the operator of (>=).
-
parsec.
choice
(pa, pb)¶ Choice one from two parsers, implements the operator of (|).
-
parsec.
compose
(pa, pb)¶ Compose two parsers, implements the operator of (>>), or (>).
-
parsec.
count
(p, n)¶ count p n parses n occurrences of p. If n is smaller or equal to zero, the parser equals to return []. Returns a list of n values returned by p.
-
parsec.
desc
(p, description)¶ Describe a parser, when it failed, print out the description text.
-
parsec.
digit
()¶ Parse a digit.
-
parsec.
endBy
(p, sep)¶ endBy(p, sep) parses zero or more occurrences of p, separated and ended by sep. Returns a list of values returned by p.
-
parsec.
endBy1
(p, sep)¶ endBy1(p, sep) parses one or more occurrences of `p, separated and ended by sep. Returns a list of values returned by p.
-
parsec.
ends_with
(pa, pb)¶ Ends with a specified parser, and at the end parser hasn’t consumed any input. Implements the operator of (<).
-
parsec.
eof
()¶ Parses EOF flag of a string.
-
parsec.
excepts
(pa, pb)¶ Fail pa though matched when the consecutive parser pb success for the rest text.
-
parsec.
exclude
(p: parsec.Parser, exclude: parsec.Parser)¶ Fails parser p if parser exclude matches
-
parsec.
fix
(fn)¶ Allow recursive parser using the Y combinator trick.
Note that this version still yields the stack overflow problem, and will be fixed in later version.
See also: https://github.com/sighingnow/parsec.py/issues/39.
-
parsec.
generate
(fn)¶ Parser generator. (combinator syntax).
-
parsec.
joint
(*parsers)¶ Joint two or more parsers, implements the operator of (+).
-
parsec.
letter
()¶ Parse a letter in alphabet.
-
parsec.
lookahead
(p: parsec.Parser)¶ Parses without consuming
-
parsec.
many
(p)¶ Repeat a parser 0 to infinity times. DO AS MUCH MATCH AS IT CAN. Return a list of values.
-
parsec.
many1
(p)¶ Repeat a parser 1 to infinity times. DO AS MUCH MATCH AS IT CAN. Return a list of values.
-
parsec.
mark
(p)¶ Mark the line and column information of the result of the parser p.
-
parsec.
none_of
(s)¶ Parses a char NOT from specified string.
-
parsec.
one_of
(s)¶ Parses a char from specified string.
-
parsec.
optional
(p, default_value=None)¶ `Make a parser as optional. If success, return the result, otherwise return default_value silently, without raising any exception. If default_value is not provided None is returned instead.
-
parsec.
parse
(p, text, index=0)¶ Parse a string and return the result or raise a ParseError.
-
parsec.
parsecapp
(p, other)¶ Returns a parser that applies the produced value of this parser to the produced value of other.
There should be an operator (<*>), but that is impossible in Python.
-
parsec.
parsecmap
(p, fn)¶ Returns a parser that transforms the produced value of parser with fn.
-
parsec.
regex
(exp, flags=0)¶ Parses according to a regular expression.
-
parsec.
result
(p, res)¶ Return a value according to the parameter res when parse successfully.
-
parsec.
sepBy
(p, sep)¶ sepBy(p, sep) parses zero or more occurrences of p, separated by sep. Returns a list of values returned by p.
-
parsec.
sepBy1
(p, sep)¶ sepBy1(p, sep) parses one or more occurrences of p, separated by sep. Returns a list of values returned by p.
-
parsec.
sepEndBy
(p, sep)¶ sepEndBy(p, sep) parses zero or more occurrences of p, separated and optionally ended by sep. Returns a list of values returned by p.
-
parsec.
sepEndBy1
(p, sep)¶ sepEndBy1(p, sep) parses one or more occurrences of p, separated and optionally ended by sep. Returns a list of values returned by p.
-
parsec.
separated
(p, sep, mint, maxt=None, end=None)¶ Repeat a parser p separated by s between mint and maxt times.
- When end is None, a trailing separator is optional.
- When end is True, a trailing separator is required.
- When end is False, a trailing separator will not be parsed.
MATCHES AS MUCH AS POSSIBLE.
Return list of values returned by p.
-
parsec.
skip
(pa, pb)¶ Ends with a specified parser, and at the end parser consumed the end flag. Implements the operator of (<<).
-
parsec.
space
()¶ Parses a whitespace character.
-
parsec.
spaces
()¶ Parses zero or more whitespace characters.
-
parsec.
string
(s)¶ Parses a string.
-
parsec.
times
(p, mint, maxt=None)¶ Repeat a parser between mint and maxt times. DO AS MUCH MATCH AS IT CAN. Return a list of values.
-
parsec.
try_choice
(pa, pb)¶ Choice one from two parsers with backtrack, implements the operator of (^).
-
parsec.
unit
(p: parsec.Parser)¶ Converts a parser into a single unit. Only consumes input if the parser succeeds