Module type It_type.IT

module type IT = sig .. end

module It_IO: sig .. end

module Subarray: sig .. end

module S: sig .. 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

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 .. end

type 'a sl = 'a Sl.sl 

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) Pervasives.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 Pervasives.ref -> int -> 'a array

module SC: sig .. end

type uchar = int 

module UTF8: sig .. 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) Pervasives.format4 -> 'a

val gather_to_string : (char, string) iteratee

module Ops: sig .. 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 .. 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 .. 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 .. end

module Reading_num: 
functor (Num : NUM) -> sig .. end

module Base64: sig .. end

val base64_decode : (char, 'a) iteratee ->
       (char, (char, 'a) iteratee) iteratee

module Deque_stream: sig .. end

val fdbg : ('a, unit, string, unit) Pervasives.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 ('a, 'b) enumpart = 'a sl ->
       ('a, 'b) iteratee -> ('a, 'b) enumpart_ret 

type ('a, 'b) enumpart_ret = (('a, 'b) iteratee * 'a sl Lazy.t *
        'a opt_enumpart)
       It_IO.m 

val enumpart_readchars : buffer_size:int ->
       read_func:('a -> string -> int -> int -> int It_IO.m) ->
       'a -> (char, 'b) enumpart

type it_exact = [ `Done | `Eof of int * err_msg option ] 

val take_exact : int ->
       ('a, 'b) iteratee ->
       ('a, it_exact * ('a, 'b) iteratee) iteratee