open CCParse;;
type tree = L of int | N of tree * tree;;
let mk_leaf x = L x
let mk_node x y = N(x,y)
let ptree = fix @@ fun self ->
skip_space *>
( (try_ (char '(') *> (pure mk_node <*> self <*> self) <* char ')')
<|>
(U.int >|= mk_leaf) )
;;
parse_string_exn ptree "(1 (2 3))" ;;
parse_string_exn ptree "((1 2) (3 (4 5)))" ;;open Containers.Parse;;
let p = U.list ~sep:"," U.word;;
parse_string_exn p "[abc , de, hello ,world ]";;This makes a list of 100_000 integers, prints it and parses it back.
let p = CCParse.(U.list ~sep:"," U.int);;
let l = CCList.(1 -- 100_000);;
let l_printed =
CCFormat.(to_string (within "[" "]" (list ~sep:(return ",@,") int))) l;;
let l' = CCParse.parse_string_exn p l_printed;;
assert (l=l');;type 'a or_error = ('a, string) resultval string_of_branch : parse_branch -> stringexception ParseError of parse_branch * unit -> stringparsing branch * message.
val state_of_string : string -> statetype 'a t = state -> ok:('a -> unit) -> err:(exn -> unit) -> unitTakes the input and two continuations:
ok to call with the result when it's doneerr to call when the parser met an errorval return : 'a -> 'a tAlways succeeds, without consuming its input.
Monadic bind. p >>= f results in a new parser which behaves as p then, in case of success, applies f to the result.
a <* b parses a into x, parses b and ignores its result, and returns x.
a *> b parses a, then parses b into x, and returns x. The results of a is ignored.
val fail : string -> 'a tfail msg fails with the given message. It can trigger a backtrack.
parsing s p behaves the same as p, with the information that we are parsing s, if p fails.
val eoi : unit tExpect the end of input, fails otherwise.
val nop : unit tSucceed with ().
val char : char -> char tchar c parses the character c and nothing else.
val char_if : (char -> bool) -> char tchar_if f parses a character c if f c = true.
val chars_if : (char -> bool) -> string tchars_if f parses a string of chars that satisfy f.
val endline : char tParse '\n'.
val space : char tTab or space.
val white : char tTab or space or newline.
val skip_chars : (char -> bool) -> unit tSkip 0 or more chars satisfying the predicate.
val skip_space : unit tSkip ' ' and '\t'.
val skip_white : unit tSkip ' ' and '\t' and '\n'.
a <?> msg behaves like a, but if a fails without consuming any input, it fails with msg instead. Useful as the last choice in a series of <|>: a <|> b <|> c <?> "expected a|b|c".
try_ p tries to parse like p, but backtracks if p fails. Useful in combination with <|>.
suspend f is the same as f (), but evaluates f () only when needed.
val string : string -> string tstring s parses exactly the string s, and nothing else.
Memoize the parser. memo p will behave like p, but when called in a state (read: position in input) it has already processed, memo p returns a result directly. The implementation uses an underlying hashtable. This can be costly in memory, but improve the run time a lot if there is a lot of backtracking involving p.
This function is not thread-safe.
val get_lnum : int tReflect the current line number.
val get_cnum : int tReflect the current column number.
val get_pos : (int * int) tReflect the current (line, column) numbers.
Those functions have a label ~p on the parser, since 0.14.
parse p st applies p on the input, and returns Ok x if p succeeds with x, or Error s otherwise.
val parse_string_exn : 'a t -> string -> 'aparse_file p file parses file with p by opening the file and reading it whole.
val parse_file_exn : 'a t -> string -> 'amodule Infix : sig ... endThis is useful to parse OCaml-like values in a simple way.
module U : sig ... end