Module BatParserCo Source A simple parser combinator library.
This module permits the simple definition of highly modular, dynamic parsers with unlimited backtracking. It may be used to parse any form of enumeration, including regular text, latin-1 text, bits, etc.
This library is vastly more powerful than LexingStrParsingScanf
Module CharParser contains pre-defined parsers to deal specifically with latin-1 text. Module Genlex
Note This library is still very rough and needs much testing.
Source type 'a state = | Eof The end of the source has been reached.
| State of 'a The current state of the parser.
The actual set of states is defined by the user. States are typically used to convey information, such as position in the file (i.e. line number and character).
Source type 'a report = | Report of ('a state 'a report listThe final result of parsing
A source for parsing. Unless you are parsing from exotic sources, you will probably not need to use this module directly. Rather, use CharParser.source_of_string or CharParser.source_of_enum.
A parser for elements of type 'a, producing elements of type 'b, with user-defined states of type 'c.
Accept the end of an enumeration.
Source val either : ('a , 'b , 'c ) t -> ('a , 'b , 'c ) t Accept one of several parsers.
Source val (<|>) : ('a , 'b , 'c ) t -> ('a , 'b , 'c ) t -> ('a , 'b , 'c ) t Accept one of two parsers
Source val maybe : ('a , 'b , 'c ) t -> ('a , 'b option'c ) t Accept an optional argument.
Source val (~?) : ('a , 'b , 'c ) t -> ('a , 'b option'c ) t Source val bind : ('a , 'b , 'c ) t -> ('b -> ('a , 'd , 'c ) t -> ('a , 'd , 'c ) t Monadic-style combination:
bind p f results in a new parser which behaves as p then, in case of success, applies f to the result.
Source val (>>=) : ('a , 'b , 'c ) t -> ('b -> ('a , 'd , 'c ) t -> ('a , 'd , 'c ) t Source val (>>>) : ('a , _ , 'c ) t -> ('a , 'd , 'c ) t -> ('a , 'd , 'c ) t As bind, but ignoring the result
Source val cons : ('a , 'b , 'c ) t -> ('a , 'b list'c ) t -> ('a , 'b list'c ) t cons p q applies parser p then parser q and conses the results into a list.
Source val (>::) : ('a , 'b , 'c ) t -> ('a , 'b list'c ) t -> ('a , 'b list'c ) t Source val label : string -> ('a , 'b , 'c ) t -> ('a , 'b , 'c ) t Give a name to a parser, for debugging purposes.
Succeed and return the state of the parser
Accept any singleton value.
Source val return : 'b -> (_ , 'b , _ ) t A parser which always succeeds
Source val satisfy : ('a -> -> ('a , 'a , _ ) t satisfy p accepts one value p x such that p x = true
Source val filter : ('b -> -> ('a , 'b , 'c ) t -> ('a , 'b , 'c ) t filter f p is only accepts values x such that p accepts x and f (p x) is true
suspend s returns the state of the parser in a form that can be resumed by calling the returned function. evaluation will resume from parser s
run p s executes parser p on source s. In case of success, returns Ok v, where v is the return value of p. In case of failure, returns Error f, with f containing details on the parsing error.
Always fail, without consuming anything.
Source val lookahead : ('a , 'b , 'c ) t -> ('a , 'b option'c ) t lookahead p behaves as maybe p but without consuming anything
Source val exactly : 'a -> ('a , 'a , 'c ) t Accept exactly one singleton.
Source val one_of : 'a list-> ('a , 'a , 'c ) t Accept one of several values. Faster and more convenient than combining satisfy and either.
Source val none_of : 'a list-> ('a , 'a , 'c ) t Accept any value not in a list Faster and more convenient than combining satisfy and either.
Source val range : 'a -> 'a -> ('a , 'a , 'c ) t Accept any element from a given range.
Source val zero_plus : ?sep :('a , _ , 'c ) t -> ('a , 'b , 'c ) t -> ('a , 'b list'c ) t Accept a (possibly empty) list of expressions.
Source val ignore_zero_plus : ?sep :('a , _ , 'c ) t -> ('a , _ , 'c ) t -> ('a , unit, 'c ) t Ignore a (possibly empty) list of expressions. Optimized version of zero_plus, for use when the list of expressions is unimportant.
Source val (~*) : ('a , 'b , 'c ) t -> ('a , 'b list'c ) t As zero_plus without arguments.
Source val one_plus : ?sep :('a , _ , 'c ) t -> ('a , 'b , 'c ) t -> ('a , 'b list'c ) t Accept a (non-empty) list of expressions
Source val ignore_one_plus : ?sep :('a , _ , 'c ) t -> ('a , _ , 'c ) t -> ('a , unit, 'c ) t Ignore a (non-empty) list of expressions. Optimized version of one_plus, for use when the list of expressions is unimportant.
Source val (~+) : ('a , 'b , 'c ) t -> ('a , 'b list'c ) t Source val times : int -> ('a , 'b , 'c ) t -> ('a , 'b list'c ) t times n p accepts a list of n expressions accepted by p
Source val (^^) : ('a , 'b , 'c ) t -> int -> ('a , 'b list'c ) t p ^^ n is the same thing as times n p
Source val must : ('a , 'b , 'c ) t -> ('a , 'b , 'c ) t Source val should : ('a , 'b , 'c ) t -> ('a , 'b , 'c ) t Source val post_map : ('b -> 'c ) -> ('a , 'b , 'd ) t -> ('a , 'c , 'd ) t Pass the (successful) result of some parser through a map.
Source val scan : ('a , _ , 'c ) t -> ('a , 'a list'c ) t Use a parser to extract list of tokens, but return that list of tokens instead of whatever the original parser returned.
Source val sat : ('a -> -> ('a , unit, _ ) t satisfy p accepts one value p x such that p x = true
If set to true, debugging information will be printed to the standard error.