# Module Std.Lazy_sequence

    module Lazy_sequence: Lazy_sequence

    type +'a t

    include Container.S1

    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 fold_map : 'a t ->
           init:'state -> f:('state -> 'a -> 'state * 'b) -> '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 -> 'a t -> int option

    val length_bounded_by : ?min:int -> ?max:int -> 'a 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 : 'a 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