module type IT =
sig
module It_IO :
sig
type +'a m
val return : 'a -> 'a m
val bind : ('a -> 'b m) -> 'a m -> 'b m
val bind_rev : 'a m -> ('a -> 'b m) -> 'b m
val error : exn -> 'a m
val catch : (unit -> 'a m) -> (exn -> 'a m) -> 'a m
type output_channel
val stdout : output_channel
val write : output_channel -> string -> unit m
type input_channel
val open_in : string -> input_channel m
val close_in : input_channel -> unit m
val read_into : input_channel -> string -> int -> int -> int m
val runIO : 'a m -> [ | `Error of exn | `Ok of 'a ]
end
module Subarray :
sig
module C :
sig
type 'a t = private { arr : 'a array; ofs : int; len : int }
val empty : 'a t
val mk : arr: ('a array) -> ofs: int -> len: int -> 'a t
end
type 'a t =
('a C.t) = private { arr : 'a array; ofs : int; len : int }
val length : 'a t -> int
val get : 'a t -> int -> 'a
val empty : 'a C.t
val replace_with_substring :
char array -> string -> int -> int -> char C.t
val of_string : string -> char C.t
val of_array : 'a array -> 'a C.t
val of_array_sub : 'a array -> int -> int -> 'a C.t
val of_list : 'a list -> 'a C.t
val of_elem : 'a -> 'a C.t
type dir = Subarray.dir = | L | R
val fold : dir -> ('a -> 'b -> 'a) -> 'a -> 'b C.t -> 'a
val iter : ('a -> unit) -> 'a C.t -> unit
val to_list : 'a C.t -> 'a list
val to_string : char C.t -> string
val append_to_list_rev : 'a C.t -> 'a list -> 'a list
val get_first_item : 'a C.t -> 'a option
val destruct_first_item : 'a C.t -> ('a * ('a C.t)) option
val sub : 'a C.t -> ofs: int -> len: int -> 'a C.t
val split_at : int -> 'a C.t -> (('a C.t) * ('a C.t))
val drop : int -> 'a C.t -> 'a C.t
val break : ('a -> bool) -> 'a C.t -> (('a C.t) * ('a C.t))
val break_limit :
limit: int ->
('a -> bool) ->
'a C.t ->
[> | `Found of (('a C.t) * ('a C.t)) | `Hit_end | `Hit_limit]
val drop_while : ('a -> bool) -> 'a C.t -> 'a C.t
val is_empty : 'a C.t -> bool
val buffer_add : Buffer.t -> char C.t -> unit
val map : ('a -> 'b) -> 'a C.t -> 'b C.t
val copy : 'a C.t -> 'a C.t
val concat_splitted : 'a C.t -> 'a C.t -> 'a C.t
end
module S :
sig
module C :
sig
type 'a t =
('a Subarray.C.t) =
private { arr : 'a array; ofs : int; len : int }
val empty : 'a t
val mk : arr: ('a array) -> ofs: int -> len: int -> 'a t
end
type 'a t =
('a Subarray.C.t) =
private { arr : 'a array; ofs : int; len : int }
val length : 'a t -> int
val get : 'a t -> int -> 'a
val empty : 'a C.t
val replace_with_substring :
char array -> string -> int -> int -> char C.t
val of_string : string -> char C.t
val of_array : 'a array -> 'a C.t
val of_array_sub : 'a array -> int -> int -> 'a C.t
val of_list : 'a list -> 'a C.t
val of_elem : 'a -> 'a C.t
type dir = Subarray.dir = | L | R
val fold : dir -> ('a -> 'b -> 'a) -> 'a -> 'b C.t -> 'a
val iter : ('a -> unit) -> 'a C.t -> unit
val to_list : 'a C.t -> 'a list
val to_string : char C.t -> string
val append_to_list_rev : 'a C.t -> 'a list -> 'a list
val get_first_item : 'a C.t -> 'a option
val destruct_first_item : 'a C.t -> ('a * ('a C.t)) option
val sub : 'a C.t -> ofs: int -> len: int -> 'a C.t
val split_at : int -> 'a C.t -> (('a C.t) * ('a C.t))
val drop : int -> 'a C.t -> 'a C.t
val break : ('a -> bool) -> 'a C.t -> (('a C.t) * ('a C.t))
val break_limit :
limit: int ->
('a -> bool) ->
'a C.t ->
[> | `Found of (('a C.t) * ('a C.t)) | `Hit_end | `Hit_limit]
val drop_while : ('a -> bool) -> 'a C.t -> 'a C.t
val is_empty : 'a C.t -> bool
val buffer_add : Buffer.t -> char C.t -> unit
val map : ('a -> 'b) -> 'a C.t -> 'b C.t
val copy : 'a C.t -> 'a C.t
val concat_splitted : 'a C.t -> 'a C.t -> 'a C.t
end
type err_msg = exn
exception EIO of (exn * It_Types.place)
exception Iteratees_err_msg of err_msg
exception Divergent_iteratee of It_Types.place
val ierr_of_merr : err_msg -> err_msg
type 'a stream = | EOF of err_msg option | Chunk of 'a Subarray.t
val chunk_of : 'a -> 'a stream
val dbgstream : ?addon: string -> 'a stream -> string
val dbgstream_char : ?body: int -> char stream -> string
val ( >>% ) : 'a It_IO.m -> ('a -> 'b It_IO.m) -> 'b It_IO.m
val ( %<< ) : ('a -> 'b It_IO.m) -> 'a It_IO.m -> 'b It_IO.m
module Sl :
sig
type 'a sl
val empty : 'a sl
val destr_head : 'a sl -> (('a stream) * ('a sl)) option
val cons : 'a stream -> 'a sl -> 'a sl
val get_one_opt : 'a sl -> ('a stream) option
val one : 'a stream -> 'a sl
val dbgsl : 'a sl -> string
end
type 'a sl = 'a Sl.sl
type ('a, 'b) iteratee =
| IE_done of 'b
| IE_cont of err_msg option
* ('a stream -> ((('a, 'b) iteratee) * ('a sl)) It_IO.m)
val return : 'a -> ('b, 'a) iteratee
val bindI :
('a -> ('b, 'c) iteratee) -> ('b, 'a) iteratee -> ('b, 'c) iteratee
val ( =<< ) :
('a -> ('b, 'c) iteratee) -> ('b, 'a) iteratee -> ('b, 'c) iteratee
val ( >>= ) :
('a, 'b) iteratee -> ('b -> ('a, 'c) iteratee) -> ('a, 'c) iteratee
val lift : 'a It_IO.m -> ('b, 'a) iteratee
val throw_err : err_msg -> ('a, 'b) iteratee
val throw_err_cont :
err_msg -> 'a stream -> ((('a, 'b) iteratee) * ('a sl)) It_IO.m
val throw_recoverable_err :
err_msg ->
('a stream -> ((('a, 'b) iteratee) * ('a sl)) It_IO.m) ->
('a, 'b) iteratee
val set_eof : 'a stream -> err_msg
val empty_stream : 'a stream
val ie_doneM : 'a -> 'b stream -> ((('b, 'a) iteratee) * ('b sl)) It_IO.m
val ie_contM :
('a stream -> ((('a, 'b) iteratee) * ('a sl)) It_IO.m) ->
((('a, 'b) iteratee) * ('c Sl.sl)) It_IO.m
val ie_doneMsl : 'a -> 'b -> ((('c, 'a) iteratee) * 'b) It_IO.m
val ie_errorMsl :
err_msg -> 'a sl -> ((('a, 'b) iteratee) * ('a sl)) It_IO.m
val ie_cont :
('a stream -> ((('a, 'b) iteratee) * ('a sl)) It_IO.m) ->
('a, 'b) iteratee
val liftI : (('a, 'b) iteratee) It_IO.m -> ('a, 'b) iteratee
val merr_of_ierr : err_msg -> 'a It_IO.m
val joinI : ('a, ('b, 'c) iteratee) iteratee -> ('a, 'c) iteratee
val run : ('a, 'b) iteratee -> 'b It_IO.m
val stream2list : ('a, 'a list) iteratee
val get_stream_eof : ('a, (err_msg option) option) iteratee
val is_stream_finished : ('a, err_msg option) iteratee
val break_fold :
('a -> bool) -> ('b -> 'a -> 'b) -> 'b -> ('a, 'b) iteratee
val mapI : ('a -> 'b) -> ('c, 'a) iteratee -> ('c, 'b) iteratee
val break : ('a -> bool) -> ('a, 'a list) iteratee
val prepend :
(unit -> 'a) -> ('a -> ('b, 'c) iteratee) -> ('b, 'c) iteratee
val break_chars : (char -> bool) -> (char, string) iteratee
val drop_while : ('a -> bool) -> ('a, unit) iteratee
val peek : ('a, 'a option) iteratee
val head : ('a, 'a) iteratee
val pervasives_eq : 'a -> 'a -> bool
val heads : ?eq: ('a -> 'a -> bool) -> 'a list -> ('a, int) iteratee
val skip_till_eof : ('a, unit) iteratee
val drop_step :
int -> 'a stream -> ((('a, unit) iteratee) * ('a sl)) It_IO.m
val drop : int -> ('a, unit) iteratee
val io_iter : ('a -> unit It_IO.m) -> 'a list -> unit It_IO.m
val print_line : string -> unit It_IO.m
type ('a, 'b) enumerator =
('a, 'b) iteratee -> (('a, 'b) iteratee) It_IO.m
val enum_eof : ('a, 'b) enumerator
val enum_err : err_msg -> ('a, 'b) enumerator
val ( >>> ) :
('a, 'b) enumerator -> ('a, 'b) enumerator -> ('a, 'b) enumerator
val enum_pure_1chunk : 'a list -> ('a, 'b) enumerator
val enum_pure_nchunk : 'a list -> int -> ('a, 'b) enumerator
val enum_string : ?chunk_size: int -> string -> (char, 'a) enumerator
val mprintf : ('a, unit, string, unit It_IO.m) format4 -> 'a
val mres : 'a It_IO.m -> ('a It_Types.res) It_IO.m
val _munres : 'a It_Types.res -> 'a It_IO.m
val enum_readchars :
buffer_size: int ->
read_func: ('a -> string -> int -> int -> int It_IO.m) ->
'a -> (char, 'b) enumerator
val enum_fd : It_IO.input_channel -> (char, 'a) enumerator
val enum_file : string -> (char, 'a) enumerator
type ('a, 'b, 'c) enumeratee =
('b, 'c) iteratee -> ('a, ('b, 'c) iteratee) iteratee
val take_gen : [ | `Drop | `Fail ] -> int -> ('a, 'a, 'b) enumeratee
val take : int -> ('a, 'b) iteratee -> ('a, ('a, 'b) iteratee) iteratee
val take_or_fail :
int -> ('a, 'b) iteratee -> ('a, ('a, 'b) iteratee) iteratee
val map_stream : ('a -> 'b) -> ('a, 'b, 'c) enumeratee
val sequence_stream : ('a, 'b) iteratee -> ('a, 'b, 'c) enumeratee
val enum_words : (char, string, 'a) enumeratee
val array_ensure_size : default: 'a -> ('a array) ref -> int -> 'a array
module SC :
sig
type 'a t = 'a Subarray_cat.t
val make : ('a Subarray.t) list -> 'a t
val length : 'a t -> int
val get : 'a t -> int -> 'a
val sub_copy_out : ?ofs: int -> ?len: int -> 'a t -> 'a Subarray.t
val append : 'a t -> 'a Subarray.t -> 'a t
end
type uchar = int
module UTF8 : sig val utf8_of_char : (char, uchar, 'a) enumeratee
end
val break_copy :
cpred: (char -> bool) ->
outch: It_IO.output_channel -> (char, unit) iteratee
val break_limit :
pred: ('a -> bool) ->
limit: int ->
('a, ([ | `Found | `Hit_eof | `Hit_limit ] * ('a Subarray.t)))
iteratee
val limit : int -> ('a, 'a, 'b) enumeratee
val catchk :
(unit -> ('a, 'b) iteratee) ->
(err_msg ->
('a stream -> ((('a, 'b) iteratee) * ('a sl)) It_IO.m) ->
('a, 'b) iteratee)
-> ('a, 'b) iteratee
val catch :
(unit -> ('a, 'b) iteratee) ->
(err_msg -> ('a, 'b) iteratee) -> ('a, 'b) iteratee
val printf : ('a, unit, string, ('b, unit) iteratee) format4 -> 'a
val gather_to_string : (char, string) iteratee
module Ops :
sig
val ( %<< ) : ('a -> 'b It_IO.m) -> 'a It_IO.m -> 'b It_IO.m
val ( >>% ) : 'a It_IO.m -> ('a -> 'b It_IO.m) -> 'b It_IO.m
val ( =<< ) :
('a -> ('b, 'c) iteratee) -> ('b, 'a) iteratee -> ('b, 'c) iteratee
val ( >>= ) :
('a, 'b) iteratee -> ('b -> ('a, 'c) iteratee) -> ('a, 'c) iteratee
val ( >>> ) :
('a, 'b) enumerator -> ('a, 'b) enumerator -> ('a, 'b) enumerator
end
val feedI :
('a stream -> ((('a, 'b) iteratee) * ('a sl)) It_IO.m) ->
'a stream -> (('a, 'b) iteratee) It_IO.m
val feed_it : ('a, 'b) iteratee -> 'a stream -> ('a, 'b) iteratee
exception Itlist_empty
module Anyresult_lasterror :
sig
val itlist_step_firstresult_lasterror :
(('a, 'b) iteratee) list ->
'a stream ->
[
| `Cont of (('a, 'b) iteratee) list
| `First_result of ((('a, 'b) iteratee) * ('a sl))
| `Last_error of err_msg ] It_IO.m
val get_any_done :
(('a, 'b) iteratee) list -> (('c, 'b) iteratee) option
val itlist_anyresult_lasterror :
(('a, 'b) iteratee) list -> ('a, 'b) iteratee
end
val itlist_anyresult_lasterror :
(('a, 'b) iteratee) list -> ('a, 'b) iteratee
val junk : ('a, unit) iteratee
exception SInt_overflow
exception SInt_not_a_number of string
module Reading_ints :
sig
val read_uint : (char, int) iteratee
val read_uint_nz : (char, int) iteratee
val read_int : (char, int) iteratee
val read_int_nz : (char, int) iteratee
val read_uint32 : (char, int32) iteratee
val read_uint32_nz : (char, int32) iteratee
val read_int32 : (char, int32) iteratee
val read_int32_nz : (char, int32) iteratee
val read_uint64 : (char, int64) iteratee
val read_uint64_nz : (char, int64) iteratee
val read_int64 : (char, int64) iteratee
val read_int64_nz : (char, int64) iteratee
end
val read_uint : (char, int) iteratee
val read_uint_nz : (char, int) iteratee
val read_int : (char, int) iteratee
val read_int_nz : (char, int) iteratee
val read_uint32 : (char, int32) iteratee
val read_uint32_nz : (char, int32) iteratee
val read_int32 : (char, int32) iteratee
val read_int32_nz : (char, int32) iteratee
val read_uint64 : (char, int64) iteratee
val read_uint64_nz : (char, int64) iteratee
val read_int64 : (char, int64) iteratee
val read_int64_nz : (char, int64) iteratee
module type NUM =
sig
type num
val num_of_int : int -> num
val mult_num : num -> num -> num
val power_num : num -> num -> num
val num_of_string : string -> num
end
module Reading_num (Num : NUM) :
sig
val num_fix_unsigned : (char, Num.num) iteratee
val num_fix : (char, Num.num) iteratee
val num_of_string_fix : string -> Num.num It_IO.m
end
module Base64 :
sig
val base64_conv_table : string
exception Bad_encoding
val base64_decode_char : char -> int
val base64_decode_piece :
ibuf: (int array) -> arr_to: (char array) -> arr_ofs: int -> unit
val base64_decode :
s_from: (char S.t) ->
arr_to: (char array) ->
ibuf: (int array) -> ipos: (int ref) -> (int * bool * bool)
val base64_decode_last :
arr_to: (char array) ->
ibuf: (int array) -> ipos_val: int -> (int * bool)
val enee_cont :
('a, 'b) iteratee ->
(('a stream -> ((('a, 'b) iteratee) * ('a sl)) It_IO.m) ->
('c, ('a, 'b) iteratee) iteratee)
-> ('c, ('a, 'b) iteratee) iteratee
val enee_cont_io :
('a, 'b) iteratee ->
(('a stream -> ((('a, 'b) iteratee) * ('a sl)) It_IO.m) ->
((('c, ('a, 'b) iteratee) iteratee) * ('c sl)) It_IO.m)
-> ((('c, ('a, 'b) iteratee) iteratee) * ('c sl)) It_IO.m
val enee_base64_decode :
(char, 'a) iteratee -> (char, (char, 'a) iteratee) iteratee
val step :
int array ->
int ref ->
(char array) ref ->
(char stream -> (((char, 'a) iteratee) * (char sl)) It_IO.m)
->
char stream ->
(((char, (char, 'a) iteratee) iteratee) * (char sl))
It_IO.m
val finish :
obuf: ((char array) ref) ->
ibuf: (int array) ->
ipos: (int ref) ->
opt_err: (err_msg option) ->
(char stream -> (((char, 'a) iteratee) * (char sl)) It_IO.m)
->
(((char, (char, 'a) iteratee) iteratee) * (char sl))
It_IO.m
val pass_obuf :
written: int ->
arr_to: (char array) ->
(char stream -> (((char, 'a) iteratee) * (char sl)) It_IO.m) ->
((char, 'a) iteratee) It_IO.m
val ret :
opt_err: (err_msg option) ->
(char stream -> (((char, 'a) iteratee) * (char sl)) It_IO.m) ->
(((char, (char, 'a) iteratee) iteratee) * (char sl)) It_IO.m
end
val base64_decode :
(char, 'a) iteratee -> (char, (char, 'a) iteratee) iteratee
module Deque_stream :
sig
type 'a t
val empty : 'a t
val cons : int -> 'a stream -> 'a t -> 'a t
val cons_sl : 'a sl -> 'a t -> 'a t
val snoc : 'a t -> int -> 'a stream -> 'a t
val concat : 'a t -> 'a sl
val destr_head : 'a t -> ((int * ('a stream)) * ('a t)) option
val is_empty : 'a t -> bool
end
val fdbg : ('a, unit, string, unit) format4 -> 'a
val break_subsequence :
('a S.t -> int -> (((('a, 'b) iteratee) * ('a sl)) It_IO.m) option) ->
('a, 'c) iteratee ->
('a, (('b option) * (('a, 'c) iteratee))) iteratee
val it_ignore : ('a, unit) iteratee
val it_ignore_step :
'a stream -> ((('a, unit) iteratee) * ('a sl)) It_IO.m
val map_ready : ('a, 'b) iteratee -> ('c, 'b) iteratee
val eof_to_res :
('a, 'b) iteratee ->
err_msg option -> ('c, [ | `Error of err_msg | `Ok of 'b ]) iteratee
val probe_string :
string ->
char S.t ->
int -> ((((char, unit) iteratee) * (char sl)) It_IO.m) option
val it_last : int -> ('a, 'a list) iteratee
type ('el, 'a) enumpart =
'el sl -> ('el, 'a) iteratee -> ('el, 'a) enumpart_ret
and ('el, 'a) enumpart_ret =
((('el, 'a) iteratee) * (('el sl) Lazy.t) * ('el opt_enumpart)) It_IO.m
and 'el opt_enumpart =
| EP_None | EP_Some of 'el enumpart_poly
and 'el enumpart_poly =
{ enumpart_poly : 'a. ('el, 'a) enumpart
}
val enumpart_readchars :
buffer_size: int ->
read_func:
('ch -> string -> int -> int -> int It_IO.m) ->
'ch -> (char, 'a) enumpart
type it_exact = [ | `Done | `Eof of (int * (err_msg option)) ]
val take_exact :
int ->
('el, 'a) iteratee ->
('el, (it_exact * (('el, 'a) iteratee))) iteratee
end