module App_parse: CCApp_parse
type ('a, 'b) result = [ `Error of 'b | `Ok of 'a ]
type 'a t
Parser that yields an error or a value of type 'a
Combinators
val return : 'a -> 'a t
Parser that succeeds with the given value
val pure : 'a -> 'a t
val junk : unit t
Skip next char
val fail : string -> 'a t
fail msg fails with the given error message
val failf : ('a, unit, string, 'b t) Pervasives.format4 -> 'a
val app : ('a -> 'b) t -> 'a t -> 'b t
Applicative
val map : ('a -> 'b) -> 'a t -> 'b t
Map the parsed value
val int : int t
Parse an integer
val float : float t
Parse a floating point number
val bool : bool t
Parse "true" or "false"
val char : char -> char t
char c parses c and c only
val any_of : string -> char t
Parse any of the chars present in the given string
val alpha_lower : char t
val alpha_upper : char t
val alpha : char t
val symbols : char t
Symbols, such as "!-=_"...
val num : char t
val alpha_num : char t
val word : string t
word parses any identifier not starting with an integer and
not containing any whitespace nor delimiter
TODO: specify
val quoted : string t
Quoted string, following OCaml conventions
val str_of_l : char list -> string
Helper to build strings from lists of chars
val spaces : unit t
Parse a sequence of '\t' and ' '
val spaces1 : unit t
val white : unit t
Parse a sequence of '\t', '\n' and ' '
val white1 : unit t
val eof : unit t
Matches the end of input, fails otherwise
val many : ?sep:unit t -> 'a t -> 'a list t
0 or more parsed elements of the given type.
sep : separator between elements of the list (for instance, space)
val many1 : ?sep:unit t -> 'a t -> 'a list t
val skip : 'a t -> unit t
Skip 0 or more instances of the given parser
val skip1 : 'a t -> unit t
val opt : 'a t -> 'a option t
opt x tries to parse x, and returns None otherwise
val filter : ('a -> bool) -> 'a t -> 'a t
filter f p parses the same as p, but fails if the returned value
does not satisfy f
val switch_c : ?default:'a t ->
(char * 'a t) list -> 'a t
switch_c l matches the next char and uses the corresponding parser.
Fails if the next char is not in the list, unless default is defined.
Raises Invalid_argument if some char occurs several times in l
default : parser to use if no char matches
val switch_s : (string * 'a t) list -> 'a t
switch_s l attempts to match matches any of the strings in l.
If one of those strings matches, the corresponding parser
is used from now on.
Raises Invalid_argument if some string is a prefix of another string,
or is empty, or if the list is empty
val choice : 'a t list -> 'a t
choice l chooses between the parsers, unambiguously
Raises Invalid_argument if the list is empty, or if some parsers
overlap, making the choice ambiguous
val fix : ('a t -> 'a t) -> 'a t
fix f makes a fixpoint
module Infix: sig .. end
include CCApp_parse.Infix
Signatures
Signatures
Parsing
type
|
line : int; |
|
col : int; |
|
msg : string; |
}
val string_of_error : error -> string
exception Error of error
module type S = sig .. end
Parse
module type INPUT = sig .. end
module Make (I : INPUT) : S with type source = I.t
Low-level interface
val print : Format.formatter -> 'a t -> unit
Print a parser structure, for debug purpose
type
module type READER = sig .. end
module MakeFromReader (R : READER) : S with type source = R.source
Defaults
module Str: S with type source = string
module Chan: S with type source = in_channel