# Module Iter

    module Iter: sig .. end

Astract iterators.

    type 'a t

    val next : 'a t -> 'a option

get the next element of the iterator

    val next_exn : 'a t -> 'a

    val progress : 'a t -> float option

get the position in the iterator either None or Some x in `0;1`

    val progress_string : float option -> string

convert the progress return value to a string: None->"", Some->" 33%"

    val i : 'a t -> f:('a -> unit) -> unit

iterate over the iterator: call f on each element

    val concat : 'a t list -> 'a t

concatenate a list of iterators

    val reduce : 'a t -> init:'i -> f:('i -> 'a -> 'i) -> 'i

fold over the iterator: call f on each element and return the accumulator

    val map : 'a t -> f:('a -> 'b) -> 'b t

transform the iterator

    val fold : 'a t -> init:'i -> f:('i -> 'a -> 'i) -> 'i

fold is the same as reduce

    val unfold : init:'i -> f:('i -> 'a * 'i) -> stop:'i -> 'a t

    val find : 'a t -> f:('a -> bool) -> 'a

find an element that satisfies the predicate

    val filter : 'a t -> f:('a -> bool) -> 'a t

iterate over elements that satisfy the predicate

    val for_all : 'a t -> f:('a -> bool) -> bool

evaluate a predicate over the entire iterator

    val exists : 'a t -> f:('a -> bool) -> bool

    val t : ?progress:(unit -> float option) -> (unit -> 'a option) -> 'a t

create an iterator from an iterating function

    val empty : 'a t

an iterator that halts immediately

    val of_opt : 'a option -> 'a t

create an iterator that may iterate over one value

    val of_list : 'a list -> 'a t

create an iterator that will go over list elements

    val to_list : 'a t -> f:('a -> 'b) -> 'b list

iterate a function and collect results to a list

    val to_list_opt : 'a t -> f:('a -> 'b option) -> 'b list

    val of_array : 'a array -> 'a t

create an iterator that will go over array elements

    val to_array : 'a t -> f:('a -> 'b) -> 'b array

iterate a function and collect results to a array

    val to_array_opt : 'a t -> f:('a -> 'b option) -> 'b array

    val channel_progress : ?total:int64 -> Pervasives.in_channel -> unit -> float option

create a progress function for an input channel

    val of_channel : ?total:int64 ->
           Pervasives.in_channel -> f:(Pervasives.in_channel -> 'a) -> 'a t

create an iterator that will read from file using f

    val channel : Pervasives.in_channel -> f:(Pervasives.in_channel -> unit) -> unit

call f on channel until End_of_file