CCParse
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) result
val string_of_branch : parse_branch -> string
exception ParseError of parse_branch * unit -> string
parsing branch * message.
val state_of_string : string -> state
type 'a t = state -> ok:('a -> unit) -> err:(exn -> unit) -> unit
Takes 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 t
Always 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 t
fail 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 t
Expect the end of input, fails otherwise.
val nop : unit t
Succeed with ()
.
val char : char -> char t
char c
parses the character c
and nothing else.
val char_if : (char -> bool) -> char t
char_if f
parses a character c
if f c = true
.
val chars_if : (char -> bool) -> string t
chars_if f
parses a string of chars that satisfy f
.
val endline : char t
Parse '\n'.
val space : char t
Tab or space.
val white : char t
Tab or space or newline.
val skip_chars : (char -> bool) -> unit t
Skip 0 or more chars satisfying the predicate.
val skip_space : unit t
Skip ' ' and '\t'.
val skip_white : unit t
Skip ' ' 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 t
string 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 t
Reflect the current line number.
val get_cnum : int t
Reflect the current column number.
val get_pos : (int * int) t
Reflect 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 -> 'a
parse_file p file
parses file
with p
by opening the file and reading it whole.
val parse_file_exn : 'a t -> string -> 'a
module Infix : sig ... end
This is useful to parse OCaml-like values in a simple way.
module U : sig ... end