cfstream 1.1.1 · OCaml Package

type 'a t = 'a Stream.t

val to_stream : 'a t -> 'a Stream.t

val of_stream : 'a Stream.t -> 'a t

exception Failure

exception Error of string

exception Expected_streams_of_equal_length

exception Premature_end_of_input

val next : 'a t -> 'a option

val next_exn : 'a t -> 'a

val peek : 'a t -> 'a option

val npeek : 'a t -> int -> 'a list

val junk : 'a t -> unit

val count : 'a t -> int

val is_empty : 'a t -> bool

val from : (int -> 'a option) -> 'a t

val of_channel : Core.Std.in_channel -> char t

val strings_of_channel : ?buffer_size:int -> Core.Std.in_channel -> string t

val range : ?until:int -> int -> int t

val empty : unit -> 'a t

val init : int -> f:(int -> 'a) -> 'a t

val singleton : 'a -> 'a t

val unfold : 'a -> f:('a -> ('b * 'a) option) -> 'b t

val unfoldi : 'a -> f:(int -> 'a -> ('b * 'a) option) -> 'b t

val of_lazy : 'a t lazy_t -> 'a t

val iter : 'a t -> f:('a -> unit) -> unit

val iter2 : 'a t -> 'b t -> f:('a -> 'b -> unit) -> unit

val iter2_exn : 'a t -> 'b t -> f:('a -> 'b -> unit) -> unit

val fold : 'a t -> init:'b -> f:('b -> 'a -> 'b) -> 'b

val fold2 : 'a t -> 'b t -> init:'c -> f:('c -> 'a -> 'b -> 'c) -> 'c

val fold2_exn : 'a t -> 'b t -> init:'c -> f:('c -> 'a -> 'b -> 'c) -> 'c

val scanl : 'a t -> init:'b -> f:('b -> 'a -> 'b) -> 'b t

val scan : 'a t -> f:('a -> 'a -> 'a) -> 'a t

val iteri : 'a t -> f:(int -> 'a -> unit) -> unit

val iter2i_exn : 'a t -> 'b t -> f:(int -> int -> 'a -> 'b -> unit) -> unit

val iter2i : 'a t -> 'b t -> f:(int -> int -> 'a -> 'b -> unit) -> unit

val foldi : 'a t -> init:'b -> f:(int -> 'b -> 'a -> 'b) -> 'b

val fold2i_exn : 
  'a t ->
  'b t ->
  init:'c ->
  f:(int -> int -> 'c -> 'a -> 'b -> 'c) ->
  'c

val fold2i : 
  'a t ->
  'b t ->
  init:'c ->
  f:(int -> int -> 'c -> 'a -> 'b -> 'c) ->
  'c

val reduce : 'a t -> f:('a -> 'a -> 'a) -> 'a

val sum : int t -> int

val fsum : float t -> float

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

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

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

val find_exn : 'a t -> f:('a -> bool) -> 'a

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

val take : 'a t -> n:int -> 'a t

val take_while : 'a t -> f:('a -> bool) -> 'a t

val drop : 'a t -> n:int -> unit

val drop_while : 'a t -> f:('a -> bool) -> unit

val skip : 'a t -> n:int -> 'a t

val skip_while : 'a t -> f:('a -> bool) -> 'a t

val take_whilei : 'a t -> f:(int -> 'a -> bool) -> 'a t

val drop_whilei : 'a t -> f:(int -> 'a -> bool) -> unit

val skip_whilei : 'a t -> f:(int -> 'a -> bool) -> 'a t

val span : 'a t -> f:('a -> bool) -> 'a t * 'a t

val group : 'a t -> f:('a -> 'b) -> 'a t t

val group_by : 'a t -> eq:('a -> 'a -> bool) -> 'a t t

val chunk2 : 'a t -> ('a * 'a) t

val chunk3 : 'a t -> ('a * 'a * 'a) t

val chunk4 : 'a t -> ('a * 'a * 'a * 'a) t

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 append : 'a t -> 'a t -> 'a t

val concat : 'a t t -> 'a t

val concat_map : 'a t -> f:('a -> 'b t) -> 'b t

val combine : ('a t * 'b t) -> ('a * 'b) t

val uncombine : ('a * 'b) t -> 'a t * 'b t

val merge : 'a t -> 'a t -> cmp:('a -> 'a -> int) -> 'a t

val partition : 'a t -> f:('a -> bool) -> 'a t * 'a t

val uniq : 'a t -> 'a t

val of_list : 'a list -> 'a t

val to_list : 'a t -> 'a list

val of_array : 'a array -> 'a t

val to_array : 'a t -> 'a array

val of_hashtbl : ('a, 'b) Core.Std.Hashtbl.t -> ('a * 'b) t

val to_hashtbl : ('a * 'b) t -> ('a, 'b) Core.Std.Hashtbl.t

val of_map : ('a, 'b, 'c) Core.Std.Map.t -> ('a * 'b) t

val to_map : ('a * 'b) t -> ('a, 'b) Core.Std.Map.Poly.t

val of_set : ('a, 'b) Core.Std.Set.t -> 'a t

val to_set : 'a t -> 'a Core.Std.Set.Poly.t

val of_string : string -> char t

val result_to_exn : 
  ('output, 'error) Core.Std.Result.t t ->
  error_to_exn:('error -> exn) ->
  'output t

module Infix : sig ... end

package cfstream