Module Core_extended.Lazy_sequence

type +'a t
include Core.Container.S1 with type a t := a t
type 'a t
val mem : 'a t ‑> 'a ‑> equal:('a ‑> 'a ‑> bool) ‑> bool

Checks whether the provided element is there, using equal.

val length : 'a t ‑> int
val is_empty : 'a t ‑> bool
val iter : 'a t ‑> f:('a ‑> unit) ‑> unit
val fold : 'a t ‑> init:'accum ‑> f:('accum ‑> 'a ‑> 'accum) ‑> 'accum

fold t ~init ~f returns f (... f (f (f init e1) e2) e3 ...) en, where e1..en are the elements of t

val fold_result : 'a t ‑> init:'accum ‑> f:('accum ‑> 'a ‑> ('accum, 'e) Base.Result.t) ‑> ('accum, 'e) Base.Result.t

fold_result t ~init ~f is a short-circuiting version of fold that runs in the Result monad. If f returns an Error _, that value is returned without any additional invocations of f.

val fold_until : 'a t ‑> init:'accum ‑> f:('accum ‑> 'a ‑> ('accum, 'final) Base__.Container_intf.Continue_or_stop.t) ‑> finish:('accum ‑> 'final) ‑> 'final

fold_until t ~init ~f ~finish is a short-circuiting version of fold. If f returns Stop _ the computation ceases and results in that value. If f returns Continue _, the fold will proceed. If f never returns Stop _, the final result is computed by finish.

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

Returns true if and only if there exists an element for which the provided function evaluates to true. This is a short-circuiting operation.

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

Returns true if and only if the provided function evaluates to true for all elements. This is a short-circuiting operation.

val count : 'a t ‑> f:('a ‑> bool) ‑> int

Returns the number of elements for which the provided function evaluates to true.

val sum : (module Base.Commutative_group.S with type t = 'sum) ‑> 'a t ‑> f:('a ‑> 'sum) ‑> 'sum

Returns the sum of f i for all i in the container.

val find : 'a t ‑> f:('a ‑> bool) ‑> 'a option

Returns as an option the first element for which f evaluates to true.

val find_map : 'a t ‑> f:('a ‑> 'b option) ‑> 'b option

Returns the first evaluation of f that returns Some, and returns None if there is no such element.

val to_list : 'a t ‑> 'a list
val to_array : 'a t ‑> 'a array
val min_elt : 'a t ‑> compare:('a ‑> 'a ‑> int) ‑> 'a option

Returns a minimum (resp maximum) element from the collection using the provided compare function, or None if the collection is empty. In case of a tie, the first element encountered while traversing the collection is returned. The implementation uses fold so it has the same complexity as fold.

val max_elt : 'a t ‑> compare:('a ‑> 'a ‑> int) ‑> 'a option
val iteri : 'a t ‑> f:(int ‑> 'a ‑> unit) ‑> unit
val foldi : 'a t ‑> init:'state ‑> f:(int ‑> 'state ‑> 'a ‑> 'state) ‑> 'state
val map : 'a t ‑> f:('a ‑> 'b) ‑> 'b t
val mapi : 'a t ‑> f:(int ‑> 'a ‑> 'b) ‑> 'b t
val filter : 'a t ‑> f:('a ‑> bool) ‑> 'a t
val filter_map : 'a t ‑> f:('a ‑> 'b option) ‑> 'b t
val filter_mapi : 'a t ‑> f:(int ‑> 'a ‑> 'b option) ‑> 'b t
val folding_map : 'a t ‑> init:'state ‑> f:('state ‑> 'a ‑> 'state * 'b) ‑> 'b t
val fold_map : 'a t ‑> init:'state ‑> f:('state ‑> 'a ‑> 'state * 'b) ‑> 'b t
val folding_filter_map : 'a t ‑> init:'state ‑> f:('state ‑> 'a ‑> 'state * 'b option) ‑> 'b t
val filter_fold_map : 'a t ‑> init:'state ‑> f:('state ‑> 'a ‑> 'state * 'b option) ‑> 'b t
val concat : 'a t t ‑> 'a t
val concat_seq_list : 'a t list ‑> 'a t
val concat_list_seq : 'a list t ‑> 'a t
val concat_map : 'a t ‑> f:('a ‑> 'b list) ‑> 'b t
val hd : 'a t ‑> 'a option
val last : 'a t ‑> 'a option
val nth : 'a t ‑> int ‑> 'a option
val tl : 'a t ‑> 'a t
val take : 'a t ‑> int ‑> 'a t
val drop : 'a t ‑> int ‑> 'a t
val append : 'a t ‑> 'a t ‑> 'a t
val sub : 'a t ‑> pos:int ‑> len:int ‑> 'a t
val filter_map_partial : 'a t ‑> f:('a ‑> [ `Continue of 'b option | `Stop ]) ‑> 'b t
val zip_full : 'a t ‑> 'b t ‑> ('a option * 'b option) t
val length_if_at_most : max:int ‑> _ t ‑> int option
val length_bounded_by : ?⁠min:int ‑> ?⁠max:int ‑> _ t ‑> bool
val of_list : 'a list ‑> 'a t
val of_array : 'a array ‑> 'a t
val init : (int ‑> 'a option) ‑> 'a t
val read_lines : string ‑> string t
val force : 'a t ‑> 'a t
module Iterator : sig ... end
val empty : _ t
val (==>) : 'a ‑> (unit ‑> 'a t) ‑> 'a t
val (==>>) : 'a list ‑> (unit ‑> 'a t) ‑> 'a t
val initialize : (unit ‑> 'a t) ‑> 'a t
val protect : finally:(unit ‑> unit) ‑> (unit ‑> 'a t) ‑> 'a t