Module Peg

module Peg: sig .. end

val debug : bool

type ('a, 'b) parzer_result = 

type ('a, 'b) parzer = 'b list -> bool -> ('a, 'b) parzer_result 

val print_intlist : 'a BatInnerIO.output -> int list -> unit

val print_int : 'a BatInnerIO.output -> int -> unit

val print_intopt : 'a BatInnerIO.output -> int Batteries.Option.t -> unit

val check_results : string ->
       ('a BatInnerIO.output -> 'b -> unit) ->
       (int list -> bool -> ('b, int) parzer_result) ->
       ('b, int) parzer_result list -> int list list -> bool

val return : 'a -> 'b list -> 'c -> ('a, 'b) parzer_result

val fail : 'a -> 'b -> ('c, 'd) parzer_result

val anything : 'a list -> bool -> ('a, 'a) parzer_result

val foreach_item : ('a -> bool -> ('b, 'a) parzer_result) ->
       'a list -> bool -> ('b, 'a) parzer_result

val start_match : 'a list * 'a list -> bool

val upto : 'a list -> 'a list -> bool -> ('a list, 'a) parzer_result

val cond : ('a -> bool) -> 'a list -> bool -> ('a, 'a) parzer_result

val item : 'a -> 'a list -> bool -> ('a, 'a) parzer_result

val regex : string -> string list -> bool -> (string list, string) parzer_result

val take : int -> 'a list -> bool -> ('a list, 'a) parzer_result

val all : unit -> 'a list -> bool -> ('a list, 'b) parzer_result

val map : ('a -> 'b -> ('c, 'd) parzer_result) ->
       ('c -> 'e) -> 'a -> 'b -> ('e, 'd) parzer_result

val map_filter : ('a -> 'b -> ('c, 'd) parzer_result) ->
       ('c -> 'e option) -> 'a -> 'b -> ('e, 'd) parzer_result

val some : ('a -> 'b -> ('c, 'd) parzer_result) ->
       'a -> 'b -> ('c option, 'd) parzer_result

val none : ('a -> 'b -> ('c, 'd) parzer_result) ->
       'a -> 'b -> ('e option, 'd) parzer_result

val seq : ('a list -> 'b -> ('c, 'a) parzer_result) list ->
       'a list -> 'b -> ('c list, 'a) parzer_result

val seqf : ('a list -> 'b -> ('c option, 'a) parzer_result) list ->
       'a list -> 'b -> ('c list, 'a) parzer_result

val either : ('a list -> 'b -> ('c, 'd) parzer_result) list ->
       'a list -> 'b -> ('c, 'd) parzer_result

val repeat : ?min:int ->
       ?max:int ->
       ('a list -> bool -> ('b, 'a) parzer_result) ->
       'a list -> bool -> ('b list, 'a) parzer_result

val many : ('a list -> bool -> ('b, 'a) parzer_result) ->
       'a list -> bool -> ('b list, 'a) parzer_result

val several : ('a list -> bool -> ('b, 'a) parzer_result) ->
       'a list -> bool -> ('b list, 'a) parzer_result

val optional : ('a list -> bool -> ('b, 'a) parzer_result) ->
       'a list -> bool -> ('b option, 'a) parzer_result

val repeat_until : ('a -> bool) ->
       ('b list -> bool -> ('a, 'b) parzer_result) ->
       'b list -> bool -> ('a list, 'b) parzer_result

val bind : ('a list -> 'b -> ('c, 'a) parzer_result) ->
       ('c -> 'a list -> 'b -> ('d, 'e) parzer_result) ->
       'a list -> 'b -> ('d, 'e) parzer_result

val pipe : 'a 'b 'c. ('a, 'b) parzer -> ('c, 'a) parzer -> ('c, 'b) parzer

val blank : unit -> char list -> bool -> (char, char) parzer_result

val alphabetic : unit -> char list -> bool -> (char, char) parzer_result

val numeric : unit -> char list -> bool -> (char, char) parzer_result

val alphanum : unit -> char list -> bool -> (char, char) parzer_result

val iitem : char -> char list -> bool -> (char, char) parzer_result

val char_seq : string -> char list -> bool -> (char list, char) parzer_result

val crlf : unit -> char list -> bool -> (char list, char) parzer_result