Module MoreStream

module MoreStream: sig .. end

Utilities for streams.

This module provides the necessary functions for applying data structure comprehension to streams.

type 'a flow = 'a Stream.t

Lazy conversion from stream to lazy list.

val to_lazylist : 'a Stream.t -> 'a LList.t

val to_stream : 'a -> 'a

Convert a stream to itself.

This function does nothing. It is included for consistency.

val flatten : 'a flow flow -> 'a flow

Flatten a stream of streams into a stream

val to_array : 'a flow -> 'a array

Convert to an array

val range : int -> int -> int Stream.t

Compute a range of integers a .. b as a stream.

The range is never empty. If a <= b, the range contains a, a+1 ... b. Otherwise, it contains a, a-1, ..., b.

val map_filter : ('a -> 'b option) -> 'a Stream.t -> 'b Stream.t

Identical to Sdflow

exception End_of_flow

val of_fun : (unit -> 'a) -> 'a flow

val of_list : 'a list -> 'a flow

val of_string : string -> char flow

val of_channel : Pervasives.in_channel -> char flow

val to_fun : 'a flow -> unit -> 'a

val to_list : 'a flow -> 'a list

val to_string : char flow -> string

val to_channel : Pervasives.out_channel -> char flow -> unit

val seq : 'a -> ('a -> 'a) -> ('a -> bool) -> 'a flow

val enum : ?fin:int -> int -> int flow

val (--) : int -> int -> int flow

val repeat : ?times:int -> 'a -> 'a flow

val cycle : ?times:int -> 'a flow -> 'a flow

val peek : 'a flow -> 'a option

val next : 'a flow -> 'a

val iter : ('a -> unit) -> 'a flow -> unit

val foldl : ('a -> 'b -> 'a * bool option) -> 'a -> 'b flow -> 'a

val foldr : ('a -> 'b lazy_t -> 'b) -> 'b -> 'a flow -> 'b

val fold : ('a -> 'a -> 'a * bool option) -> 'a flow -> 'a

val cons : 'a -> 'a flow -> 'a flow

val apnd : 'a flow -> 'a flow -> 'a flow

val is_empty : 'a flow -> bool

val filter : ('a -> bool) -> 'a flow -> 'a flow

val concat : 'a flow flow -> 'a flow

val take : int -> 'a flow -> 'a flow

val drop : int -> 'a flow -> 'a flow

val take_while : ('a -> bool) -> 'a flow -> 'a flow

val drop_while : ('a -> bool) -> 'a flow -> 'a flow

val span : ('a -> bool) -> 'a flow -> 'a flow * 'a flow

val break : ('a -> bool) -> 'a flow -> 'a flow * 'a flow

val group : ('a -> bool) -> 'a flow -> 'a flow flow

val dup : 'a flow -> 'a flow * 'a flow

val comb : 'a flow * 'b flow -> ('a * 'b) flow

val split : ('a * 'b) flow -> 'a flow * 'b flow

val merge : (bool -> 'a -> bool) ->
       'a flow * 'a flow -> 'a flow

val switch : ('a -> bool) -> 'a flow -> 'a flow * 'a flow

val dupn : int -> 'a flow -> 'a flow array

val combn : 'a flow array -> 'a array flow

val splitn : int -> 'a array flow -> 'a flow array

val mergen : (int -> 'a -> int) -> 'a flow array -> 'a flow

val switchn : int -> ('a -> int) -> 'a flow -> 'a flow array

val map : ('a -> 'b) -> 'a flow -> 'b flow

val map2 : ('a -> 'b -> 'c) ->
       'a flow -> 'b flow -> 'c flow

val scanl : ('a -> 'b -> 'a) -> 'a -> 'b flow -> 'a flow

val scan : ('a -> 'a -> 'a) -> 'a flow -> 'a flow

val map_fold : ('a -> 'a -> 'a * bool option) -> 'a flow -> 'a flow

val feedl : 'a flow -> ('a flow -> 'a flow * 'b) -> 'b

val feedr : 'a flow -> ('a flow -> 'b * 'a flow) -> 'b

val circ : 'a flow ->
       ('a flow -> 'a flow) -> 'a flow

val (|||) : ('a flow -> 'b flow) ->
       ('b flow -> 'c flow) ->
       'a flow -> 'c flow

val while_do : ?size:int ->
       ('a -> bool) ->
       ('a flow -> 'a flow) ->
       'a flow -> 'a flow

val do_while : ?size:int ->
       ('a -> bool) ->
       ('a flow -> 'a flow) ->
       'a flow -> 'a flow

val farm : ?par:int ->
       ?size:(int -> int) ->
       ?path:('a -> int) ->
       (int -> 'a flow -> 'b flow) ->
       'a flow -> 'b flow

val (|>) : 'a -> ('a -> 'b) -> 'b

val (@.) : ('a -> 'b) -> 'a -> 'b

val (|-) : ('a -> 'b) -> ('b -> 'c) -> 'a -> 'c

val (-|) : ('a -> 'b) -> ('c -> 'a) -> 'c -> 'b

val (//) : ('a -> 'b) -> ('c -> 'd) -> 'a * 'c -> 'b * 'd

val curry : ('a * 'b -> 'c) -> 'a -> 'b -> 'c

val uncurry : ('a -> 'b -> 'c) -> 'a * 'b -> 'c

val id : 'a -> 'a