module BatStream:sig..end
Streams are a read-and-forget data structure, comparable to enumerations.
In Batteries Included, streams are deprecated in favor of enumerations,
defined in module BatEnum.
Note This module is provided essentially for backwards-compatibility.
If you feel like using Stream.t, please take a look at BatEnum
or LazyList.
This module is based on Zheng Li's SDFlow
This module replaces Stdlib's
Stream
module.
Author(s): Zheng Li (SDFlow), David Teller
type'at ='a Stream.t
include BatEnum.Enumerable
include BatInterfaces.Mappable
'a.exception Failure
exception Error of string
val from : (int -> 'a option) -> 'a tStream.from f returns a stream built from the function f.
To create a new stream element, the function f is called with
the current stream count. The user function f must return either
Some <value> for a value or None to specify the end of the
stream.val of_list : 'a list -> 'a tval of_string : string -> char tval of_bytes : Bytes.t -> char tval of_channel : Pervasives.in_channel -> char t
Warning: these functions create streams with fast access; it is illegal
to mix them with streams built with [< >]; would raise Failure
when accessing such mixed streams.
val of_fun : (unit -> 'a) -> 'a tStream.of_fun f returns a stream built from the function f.
To create a new stream element, the function f is called with
the current stream count. The user function f must return either
Some <value> for a value or None to specify the end of the
stream.val iter : ('a -> unit) -> 'a t -> unitStream.iter f s scans the whole stream s, applying function f
in turn to each stream element encountered.val foldl : ('a -> 'b -> 'a * bool option) -> 'a -> 'b t -> 'afoldl f init stream is a lazy fold_left. f accu elt should return
(new_accu, state) where new_accu is normal accumulation result, and
state is a flag representing whether the computation should continue
and whether the last operation is valid: None means continue, Some b
means stop where b = true means the last addition is still valid and b
= false means the last addition is invalid and should be revert.val foldr : ('a -> 'b lazy_t -> 'b) -> 'b -> 'a t -> 'bfoldr f init stream is a lazy fold_right. Unlike the normal fold_right,
the accumulation parameter of f elt accu is lazy, hence it can decide
not to force the evaluation of accu if the current element elt can
determin the result by itself.val fold : ('a -> 'a -> 'a * bool option) -> 'a t -> 'afold is foldl without initialization value, where the first
element of stream is taken as init. It raises End_of_stream exception
when the input stream is empty.val filter : ('a -> bool) -> 'a t -> 'a tfilter test stream picks all the elements satisfying test from stream
and return the results in the same order as a stream.val next : 'a t -> 'aStream.Failure if the stream is empty.val empty : 'a t -> unit() if the stream is empty, else raise Stream.Failure.val peek : 'a t -> 'a optionSome of "the first element" of the stream, or None if
the stream is empty.val junk : 'a t -> unitval count : 'a t -> intval npeek : int -> 'a t -> 'a listnpeek n returns the list of the n first elements of
the stream, or all its remaining elements if less than n
elements are available.val enum : 'a t -> 'a BatEnum.tval of_enum : 'a BatEnum.t -> 'a tval of_input : BatIO.input -> char tinput to a stream.val to_list : 'a t -> 'a listval to_string : char t -> stringval to_string_fmt : ('a -> string, unit, string) Pervasives.format -> 'a t -> stringval to_string_fun : ('a -> string) -> 'a t -> stringval on_output : 'a BatIO.output -> char t -> unitoutput to a stream.
All the functions in this part are lazy.
val map : ('a -> 'b) -> 'a t -> 'b tmap f stream applies f in turn to elements from stream and return the
results as a stream in the same order.val map2 : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c tmap2 f streama streamb applies f in turn to elements of corresponding
positions from streama and streamb. The results are constructed in the
same order as a stream. If one stream is short, excess elements of the longer
stream are ignored.val scanl : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a tscanl f init stream returns a stream of successive reduced
values from the left: scanl f init [< 'e0; 'e1; ... >] is
equivalent to
[< 'init; '(f init e0); '(f (f init e0) e1); ... >]val scan : ('a -> 'a -> 'a) -> 'a t -> 'a tscan is similar to scanl but without the init value:
scanl f init [< 'e0; 'e1; 'e2; ... >] is equivalent to
[< 'e0; '(f e0 e1); '(f (f e0 e1) e2); ... >]val concat : 'a t t -> 'a tval concat_map : ('a -> 'b t) -> 'a t -> 'b tBatStream.concat and BatStream.map.
concat_map f e is the same as concat (map f e).val take : int -> 'a t -> 'a ttake n stream returns the prefix of stream of length n, or stream
itself if n is greater than the length of streamval drop : int -> 'a t -> 'a tdrop n stream returns the suffix of stream after the first n elements,
or a empty stream if n is greater than the length of streamval take_while : ('a -> bool) -> 'a t -> 'a ttake_while test stream returns the longest (possibly empty) prefix of
stream of elements that satisfy test.val drop_while : ('a -> bool) -> 'a t -> 'a tdrop_while test stream returns the remaining suffix of take_while test
stream.
All the functions in this part are lazy.
val dup : 'a t -> 'a t * 'a tdup stream returns a pair of streams which are identical to stream. Note
that stream is a destructive data structure, the point of dup is to
return two streams can be used independently.
NOT IMPLEMENTED CORRECTLY - WILL RAISE Failure UNTIL CORRECT
IMPLEMENTATION FOUND
val comb : 'a t * 'b t -> ('a * 'b) tcomb transform a pair of stream into a stream of pairs of corresponding
elements. If one stream is short, excess elements of the longer stream are
ignored.val split : ('a * 'b) t -> 'a t * 'b tsplit is the opposite of combval merge : (bool -> 'a -> bool) -> 'a t * 'a t -> 'a tmerge test (streama, streamb) merge the elements from streama and
streamb into a single stream. The bool type here represents the id of the
two input streams where true is the first and false represents the
second. The test function is applied to each element of the output stream
together with the id of the input stream from which it was extracted, to
decide which stream should the next element come from. The first element is
always taken from streama. When a stream runs out of elements, the merge
process will continue to take elements from the other stream until both
streams reach their ends.val switch : ('a -> bool) -> 'a t -> 'a t * 'a tswitch test stream split stream into two streams, where the first stream have
all the elements satisfying test, the second stream is opposite. The
order of elements in the source stream is preserved.
All the functions in this part are lazy.
val cons : 'a -> 'a t -> 'a tcons x stream equals [<'x; stream>].val apnd : 'a t -> 'a t -> 'a tapnd fla flb equals [<fla;flb>].val is_empty : 'a t -> boolis_empty stream tests whether stream is empty. But note that it forces
the evaluation of the head element if any.val next : 'a t -> 'aStream.Failure if the stream is empty.module StreamLabels:sig..end