sig
type 'a t = ('a -> unit) -> unit
type 'a sequence = 'a Sequence.t
type ('a, 'b) t2 = ('a -> 'b -> unit) -> unit
val from_iter : (('a -> unit) -> unit) -> 'a Sequence.t
val from_fun : (unit -> 'a option) -> 'a Sequence.t
val empty : 'a Sequence.t
val singleton : 'a -> 'a Sequence.t
val doubleton : 'a -> 'a -> 'a Sequence.t
val cons : 'a -> 'a Sequence.t -> 'a Sequence.t
val snoc : 'a Sequence.t -> 'a -> 'a Sequence.t
val return : 'a -> 'a Sequence.t
val pure : 'a -> 'a Sequence.t
val repeat : 'a -> 'a Sequence.t
val iterate : ('a -> 'a) -> 'a -> 'a Sequence.t
val forever : (unit -> 'b) -> 'b Sequence.t
val cycle : 'a Sequence.t -> 'a Sequence.t
val iter : ('a -> unit) -> 'a Sequence.t -> unit
val iteri : (int -> 'a -> unit) -> 'a Sequence.t -> unit
val fold : ('a -> 'b -> 'a) -> 'a -> 'b Sequence.t -> 'a
val foldi : ('a -> int -> 'b -> 'a) -> 'a -> 'b Sequence.t -> 'a
val map : ('a -> 'b) -> 'a Sequence.t -> 'b Sequence.t
val mapi : (int -> 'a -> 'b) -> 'a Sequence.t -> 'b Sequence.t
val map_by_2 : ('a -> 'a -> 'a) -> 'a Sequence.t -> 'a Sequence.t
val for_all : ('a -> bool) -> 'a Sequence.t -> bool
val exists : ('a -> bool) -> 'a Sequence.t -> bool
val mem : ?eq:('a -> 'a -> bool) -> 'a -> 'a Sequence.t -> bool
val find : ('a -> 'b option) -> 'a Sequence.t -> 'b option
val length : 'a Sequence.t -> int
val is_empty : 'a Sequence.t -> bool
val filter : ('a -> bool) -> 'a Sequence.t -> 'a Sequence.t
val append : 'a Sequence.t -> 'a Sequence.t -> 'a Sequence.t
val concat : 'a Sequence.t Sequence.t -> 'a Sequence.t
val flatten : 'a Sequence.t Sequence.t -> 'a Sequence.t
val flat_map : ('a -> 'b Sequence.t) -> 'a Sequence.t -> 'b Sequence.t
val flat_map_l : ('a -> 'b list) -> 'a Sequence.t -> 'b Sequence.t
val filter_map : ('a -> 'b option) -> 'a Sequence.t -> 'b Sequence.t
val intersperse : 'a -> 'a Sequence.t -> 'a Sequence.t
val persistent : 'a Sequence.t -> 'a Sequence.t
val persistent_lazy : 'a Sequence.t -> 'a Sequence.t
val sort : ?cmp:('a -> 'a -> int) -> 'a Sequence.t -> 'a Sequence.t
val sort_uniq : ?cmp:('a -> 'a -> int) -> 'a Sequence.t -> 'a Sequence.t
val group_succ_by :
?eq:('a -> 'a -> bool) -> 'a Sequence.t -> 'a list Sequence.t
val group_by :
?hash:('a -> int) ->
?eq:('a -> 'a -> bool) -> 'a Sequence.t -> 'a list Sequence.t
val uniq : ?eq:('a -> 'a -> bool) -> 'a Sequence.t -> 'a Sequence.t
val product : 'a Sequence.t -> 'b Sequence.t -> ('a * 'b) Sequence.t
val product2 : 'a Sequence.t -> 'b Sequence.t -> ('a, 'b) Sequence.t2
val join :
join_row:('a -> 'b -> 'c option) ->
'a Sequence.t -> 'b Sequence.t -> 'c Sequence.t
val unfoldr : ('b -> ('a * 'b) option) -> 'b -> 'a Sequence.t
val scan : ('b -> 'a -> 'b) -> 'b -> 'a Sequence.t -> 'b Sequence.t
val max : ?lt:('a -> 'a -> bool) -> 'a Sequence.t -> 'a option
val min : ?lt:('a -> 'a -> bool) -> 'a Sequence.t -> 'a option
val head : 'a Sequence.t -> 'a option
val head_exn : 'a Sequence.t -> 'a
val take : int -> 'a Sequence.t -> 'a Sequence.t
val take_while : ('a -> bool) -> 'a Sequence.t -> 'a Sequence.t
val fold_while :
('a -> 'b -> 'a * [ `Continue | `Stop ]) -> 'a -> 'b Sequence.t -> 'a
val drop : int -> 'a Sequence.t -> 'a Sequence.t
val drop_while : ('a -> bool) -> 'a Sequence.t -> 'a Sequence.t
val rev : 'a Sequence.t -> 'a Sequence.t
val empty2 : ('a, 'b) Sequence.t2
val is_empty2 : ('a, 'b) Sequence.t2 -> bool
val length2 : ('a, 'b) Sequence.t2 -> int
val zip : ('a, 'b) Sequence.t2 -> ('a * 'b) Sequence.t
val unzip : ('a * 'b) Sequence.t -> ('a, 'b) Sequence.t2
val zip_i : 'a Sequence.t -> (int, 'a) Sequence.t2
val fold2 : ('c -> 'a -> 'b -> 'c) -> 'c -> ('a, 'b) Sequence.t2 -> 'c
val iter2 : ('a -> 'b -> unit) -> ('a, 'b) Sequence.t2 -> unit
val map2 : ('a -> 'b -> 'c) -> ('a, 'b) Sequence.t2 -> 'c Sequence.t
val map2_2 :
('a -> 'b -> 'c) ->
('a -> 'b -> 'd) -> ('a, 'b) Sequence.t2 -> ('c, 'd) Sequence.t2
val to_list : 'a Sequence.t -> 'a list
val to_rev_list : 'a Sequence.t -> 'a list
val of_list : 'a list -> 'a Sequence.t
val on_list : ('a Sequence.t -> 'b Sequence.t) -> 'a list -> 'b list
val to_opt : 'a Sequence.t -> 'a option
val to_array : 'a Sequence.t -> 'a array
val of_array : 'a array -> 'a Sequence.t
val of_array_i : 'a array -> (int * 'a) Sequence.t
val of_array2 : 'a array -> (int, 'a) Sequence.t2
val array_slice : 'a array -> int -> int -> 'a Sequence.t
val of_opt : 'a option -> 'a Sequence.t
val of_stream : 'a Stream.t -> 'a Sequence.t
val to_stream : 'a Sequence.t -> 'a Stream.t
val to_stack : 'a Stack.t -> 'a Sequence.t -> unit
val of_stack : 'a Stack.t -> 'a Sequence.t
val to_queue : 'a Queue.t -> 'a Sequence.t -> unit
val of_queue : 'a Queue.t -> 'a Sequence.t
val hashtbl_add : ('a, 'b) Hashtbl.t -> ('a * 'b) Sequence.t -> unit
val hashtbl_replace : ('a, 'b) Hashtbl.t -> ('a * 'b) Sequence.t -> unit
val to_hashtbl : ('a * 'b) Sequence.t -> ('a, 'b) Hashtbl.t
val to_hashtbl2 : ('a, 'b) Sequence.t2 -> ('a, 'b) Hashtbl.t
val of_hashtbl : ('a, 'b) Hashtbl.t -> ('a * 'b) Sequence.t
val of_hashtbl2 : ('a, 'b) Hashtbl.t -> ('a, 'b) Sequence.t2
val hashtbl_keys : ('a, 'b) Hashtbl.t -> 'a Sequence.t
val hashtbl_values : ('a, 'b) Hashtbl.t -> 'b Sequence.t
val of_str : string -> char Sequence.t
val to_str : char Sequence.t -> string
val concat_str : string Sequence.t -> string
exception OneShotSequence
val of_in_channel : Pervasives.in_channel -> char Sequence.t
val to_buffer : char Sequence.t -> Buffer.t -> unit
val int_range : start:int -> stop:int -> int Sequence.t
val int_range_dec : start:int -> stop:int -> int Sequence.t
val int_range_by : step:int -> int -> int -> int Sequence.t
val bools : bool Sequence.t
val of_set :
(module Set.S with type elt = 'a and type t = 'b) -> 'b -> 'a Sequence.t
val to_set :
(module Set.S with type elt = 'a and type t = 'b) -> 'a Sequence.t -> 'b
type 'a gen = unit -> 'a option
type 'a klist = unit -> [ `Cons of 'a * 'a Sequence.klist | `Nil ]
val of_gen : 'a Sequence.gen -> 'a Sequence.t
val to_gen : 'a Sequence.t -> 'a Sequence.gen
val of_klist : 'a Sequence.klist -> 'a Sequence.t
val to_klist : 'a Sequence.t -> 'a Sequence.klist
module Set :
sig
module type S =
sig
type elt
type t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val min_elt : t -> elt
val max_elt : t -> elt
val choose : t -> elt
val split : elt -> t -> t * bool * t
val find : elt -> t -> elt
val of_seq : elt Sequence.sequence -> Sequence.t
val to_seq : Sequence.t -> elt Sequence.sequence
val to_list : Sequence.t -> elt list
val of_list : elt list -> Sequence.t
end
module Adapt :
functor (X : Set.S) ->
sig
type elt = X.elt
type t = X.t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val min_elt : t -> elt
val max_elt : t -> elt
val choose : t -> elt
val split : elt -> t -> t * bool * t
val find : elt -> t -> elt
val of_seq : elt sequence -> t
val to_seq : t -> elt sequence
val to_list : t -> elt list
val of_list : elt list -> t
end
module Make :
functor (X : Set.OrderedType) ->
sig
type elt = X.t
type t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : (elt -> unit) -> t -> unit
val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (elt -> bool) -> t -> bool
val exists : (elt -> bool) -> t -> bool
val filter : (elt -> bool) -> t -> t
val partition : (elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val min_elt : t -> elt
val max_elt : t -> elt
val choose : t -> elt
val split : elt -> t -> t * bool * t
val find : elt -> t -> elt
val of_seq : elt sequence -> t
val to_seq : t -> elt sequence
val to_list : t -> elt list
val of_list : elt list -> t
end
end
module Map :
sig
module type S =
sig
type key
type +'a t
val empty : 'a t
val is_empty : 'a t -> bool
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val singleton : key -> 'a -> 'a t
val remove : key -> 'a t -> 'a t
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val for_all : (key -> 'a -> bool) -> 'a t -> bool
val exists : (key -> 'a -> bool) -> 'a t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
val min_binding : 'a t -> key * 'a
val max_binding : 'a t -> key * 'a
val choose : 'a t -> key * 'a
val split : key -> 'a t -> 'a t * 'a option * 'a t
val find : key -> 'a t -> 'a
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val to_seq : 'a Sequence.t -> (key * 'a) Sequence.sequence
val of_seq : (key * 'a) Sequence.sequence -> 'a Sequence.t
val keys : 'a Sequence.t -> key Sequence.sequence
val values : 'a Sequence.t -> 'a Sequence.sequence
val to_list : 'a Sequence.t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a Sequence.t
end
module Adapt :
functor (M : Map.S) ->
sig
type key = M.key
type 'a t = 'a M.t
val empty : 'a t
val is_empty : 'a t -> bool
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val singleton : key -> 'a -> 'a t
val remove : key -> 'a t -> 'a t
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
val union :
(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val for_all : (key -> 'a -> bool) -> 'a t -> bool
val exists : (key -> 'a -> bool) -> 'a t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
val min_binding : 'a t -> key * 'a
val max_binding : 'a t -> key * 'a
val choose : 'a t -> key * 'a
val split : key -> 'a t -> 'a t * 'a option * 'a t
val find : key -> 'a t -> 'a
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val to_seq : 'a t -> (key * 'a) sequence
val of_seq : (key * 'a) sequence -> 'a t
val keys : 'a t -> key sequence
val values : 'a t -> 'a sequence
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
end
module Make :
functor (V : Map.OrderedType) ->
sig
type key = V.t
type +'a t
val empty : 'a t
val is_empty : 'a t -> bool
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val singleton : key -> 'a -> 'a t
val remove : key -> 'a t -> 'a t
val merge :
(key -> 'a option -> 'b option -> 'c option) ->
'a t -> 'b t -> 'c t
val union :
(key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val for_all : (key -> 'a -> bool) -> 'a t -> bool
val exists : (key -> 'a -> bool) -> 'a t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
val min_binding : 'a t -> key * 'a
val max_binding : 'a t -> key * 'a
val choose : 'a t -> key * 'a
val split : key -> 'a t -> 'a t * 'a option * 'a t
val find : key -> 'a t -> 'a
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val to_seq : 'a t -> (key * 'a) sequence
val of_seq : (key * 'a) sequence -> 'a t
val keys : 'a t -> key sequence
val values : 'a t -> 'a sequence
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
end
end
val random_int : int -> int Sequence.t
val random_bool : bool Sequence.t
val random_float : float -> float Sequence.t
val random_array : 'a array -> 'a Sequence.t
val random_list : 'a list -> 'a Sequence.t
val shuffle : 'a Sequence.t -> 'a Sequence.t
val shuffle_buffer : int -> 'a Sequence.t -> 'a Sequence.t
val sample : int -> 'a Sequence.t -> 'a array
module Infix :
sig
val ( -- ) : int -> int -> int Sequence.t
val ( --^ ) : int -> int -> int Sequence.t
val ( >>= ) : 'a Sequence.t -> ('a -> 'b Sequence.t) -> 'b Sequence.t
val ( >|= ) : 'a Sequence.t -> ('a -> 'b) -> 'b Sequence.t
val ( <*> ) : ('a -> 'b) Sequence.t -> 'a Sequence.t -> 'b Sequence.t
val ( <+> ) : 'a Sequence.t -> 'a Sequence.t -> 'a Sequence.t
end
val ( -- ) : int -> int -> int t
val ( --^ ) : int -> int -> int t
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >|= ) : 'a t -> ('a -> 'b) -> 'b t
val ( <*> ) : ('a -> 'b) t -> 'a t -> 'b t
val ( <+> ) : 'a t -> 'a t -> 'a t
val pp_seq :
?sep:string ->
(Format.formatter -> 'a -> unit) ->
Format.formatter -> 'a Sequence.t -> unit
val pp_buf :
?sep:string ->
(Buffer.t -> 'a -> unit) -> Buffer.t -> 'a Sequence.t -> unit
val to_string : ?sep:string -> ('a -> string) -> 'a Sequence.t -> string
module IO :
sig
val lines_of :
?mode:int ->
?flags:Pervasives.open_flag list -> string -> string Sequence.t
val chunks_of :
?mode:int ->
?flags:Pervasives.open_flag list ->
?size:int -> string -> string Sequence.t
val write_to :
?mode:int ->
?flags:Pervasives.open_flag list ->
string -> string Sequence.t -> unit
val write_bytes_to :
?mode:int ->
?flags:Pervasives.open_flag list ->
string -> Bytes.t Sequence.t -> unit
val write_lines :
?mode:int ->
?flags:Pervasives.open_flag list ->
string -> string Sequence.t -> unit
val write_bytes_lines :
?mode:int ->
?flags:Pervasives.open_flag list ->
string -> Bytes.t Sequence.t -> unit
end
end