Iter

#

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

module Iter