Up

Module Iter

Astract iterators.

Signature

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