sig
  type 'a t = ('a -> unit) -> unit
  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 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 : ('b -> 'a -> 'b) -> 'b -> 'a Sequence.t -> 'b
  val foldi : ('b -> int -> 'a -> 'b) -> 'b -> 'a Sequence.t -> 'b
  val map : ('a -> 'b) -> 'a Sequence.t -> 'b Sequence.t
  val mapi : (int -> 'a -> 'b) -> 'a Sequence.t -> 'b Sequence.t
  val for_all : ('a -> bool) -> 'a Sequence.t -> bool
  val exists : ('a -> bool) -> 'a Sequence.t -> bool
  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 flatMap : ('a -> 'b Sequence.t) -> 'a Sequence.t -> 'b Sequence.t
  val intersperse : 'a -> 'a Sequence.t -> 'a Sequence.t
  val persistent : '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 : ?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 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 -> 'a
  val min : ?lt:('a -> 'a -> bool) -> 'a Sequence.t -> 'a -> 'a
  val take : int -> 'a Sequence.t -> 'a Sequence.t
  val drop : int -> '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 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_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 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 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
  module Set :
    sig
      module type S =
        sig
          type set
          type elt
          val empty : set
          val is_empty : set -> bool
          val mem : elt -> set -> bool
          val add : elt -> set -> set
          val singleton : elt -> set
          val remove : elt -> set -> set
          val union : set -> set -> set
          val inter : set -> set -> set
          val diff : set -> set -> set
          val compare : set -> set -> int
          val equal : set -> set -> bool
          val subset : set -> set -> bool
          val iter : (elt -> unit) -> set -> unit
          val fold : (elt -> 'a -> 'a) -> set -> 'a -> 'a
          val for_all : (elt -> bool) -> set -> bool
          val exists : (elt -> bool) -> set -> bool
          val filter : (elt -> bool) -> set -> set
          val partition : (elt -> bool) -> set -> set * set
          val cardinal : set -> int
          val elements : set -> elt list
          val min_elt : set -> elt
          val max_elt : set -> elt
          val choose : set -> elt
          val split : elt -> set -> set * bool * set
          val of_seq : elt Sequence.t -> Sequence.Set.S.set
          val to_seq : Sequence.Set.S.set -> elt Sequence.t
        end
      module Adapt :
        functor (X : Set.S) ->
          sig
            type set = X.t
            type elt = X.elt
            val empty : set
            val is_empty : set -> bool
            val mem : elt -> set -> bool
            val add : elt -> set -> set
            val singleton : elt -> set
            val remove : elt -> set -> set
            val union : set -> set -> set
            val inter : set -> set -> set
            val diff : set -> set -> set
            val compare : set -> set -> int
            val equal : set -> set -> bool
            val subset : set -> set -> bool
            val iter : (elt -> unit) -> set -> unit
            val fold : (elt -> 'a -> 'a) -> set -> 'a -> 'a
            val for_all : (elt -> bool) -> set -> bool
            val exists : (elt -> bool) -> set -> bool
            val filter : (elt -> bool) -> set -> set
            val partition : (elt -> bool) -> set -> set * set
            val cardinal : set -> int
            val elements : set -> elt list
            val min_elt : set -> elt
            val max_elt : set -> elt
            val choose : set -> elt
            val split : elt -> set -> set * bool * set
            val of_seq : elt t -> set
            val to_seq : set -> elt t
          end
      module Make :
        functor (X : Set.OrderedType) ->
          sig
            type set
            type elt = X.t
            val empty : set
            val is_empty : set -> bool
            val mem : elt -> set -> bool
            val add : elt -> set -> set
            val singleton : elt -> set
            val remove : elt -> set -> set
            val union : set -> set -> set
            val inter : set -> set -> set
            val diff : set -> set -> set
            val compare : set -> set -> int
            val equal : set -> set -> bool
            val subset : set -> set -> bool
            val iter : (elt -> unit) -> set -> unit
            val fold : (elt -> 'a -> 'a) -> set -> 'a -> 'a
            val for_all : (elt -> bool) -> set -> bool
            val exists : (elt -> bool) -> set -> bool
            val filter : (elt -> bool) -> set -> set
            val partition : (elt -> bool) -> set -> set * set
            val cardinal : set -> int
            val elements : set -> elt list
            val min_elt : set -> elt
            val max_elt : set -> elt
            val choose : set -> elt
            val split : elt -> set -> set * bool * set
            val of_seq : elt t -> set
            val to_seq : set -> elt t
          end
    end
  module Map :
    sig
      module type S =
        sig
          type +'a map
          type key
          val empty : 'a map
          val is_empty : 'a map -> bool
          val mem : key -> 'a map -> bool
          val add : key -> 'a -> 'a map -> 'a map
          val singleton : key -> 'a -> 'a map
          val remove : key -> 'a map -> 'a map
          val merge :
            (key -> 'a option -> 'b option -> 'c option) ->
            'a map -> 'b map -> 'c map
          val compare : ('a -> 'a -> int) -> 'a map -> 'a map -> int
          val equal : ('a -> 'a -> bool) -> 'a map -> 'a map -> bool
          val iter : (key -> 'a -> unit) -> 'a map -> unit
          val fold : (key -> 'a -> 'b -> 'b) -> 'a map -> 'b -> 'b
          val for_all : (key -> 'a -> bool) -> 'a map -> bool
          val exists : (key -> 'a -> bool) -> 'a map -> bool
          val filter : (key -> 'a -> bool) -> 'a map -> 'a map
          val partition : (key -> 'a -> bool) -> 'a map -> 'a map * 'a map
          val cardinal : 'a map -> int
          val bindings : 'a map -> (key * 'a) list
          val min_binding : 'a map -> key * 'a
          val max_binding : 'a map -> key * 'a
          val choose : 'a map -> key * 'a
          val split : key -> 'a map -> 'a map * 'a option * 'a map
          val find : key -> 'a map -> 'a
          val map : ('a -> 'b) -> 'a map -> 'b map
          val mapi : (key -> 'a -> 'b) -> 'a map -> 'b map
          val to_seq : 'a Sequence.Map.S.map -> (key * 'a) Sequence.t
          val of_seq : (key * 'a) Sequence.t -> 'a Sequence.Map.S.map
          val keys : 'a Sequence.Map.S.map -> key Sequence.t
          val values : 'a Sequence.Map.S.map -> 'a Sequence.t
        end
      module Adapt :
        functor (M : Map.S) ->
          sig
            type 'a map = 'a M.t
            type key = M.key
            val empty : 'a map
            val is_empty : 'a map -> bool
            val mem : key -> 'a map -> bool
            val add : key -> 'a -> 'a map -> 'a map
            val singleton : key -> 'a -> 'a map
            val remove : key -> 'a map -> 'a map
            val merge :
              (key -> 'a option -> 'b option -> 'c option) ->
              'a map -> 'b map -> 'c map
            val compare : ('a -> 'a -> int) -> 'a map -> 'a map -> int
            val equal : ('a -> 'a -> bool) -> 'a map -> 'a map -> bool
            val iter : (key -> 'a -> unit) -> 'a map -> unit
            val fold : (key -> 'a -> 'b -> 'b) -> 'a map -> 'b -> 'b
            val for_all : (key -> 'a -> bool) -> 'a map -> bool
            val exists : (key -> 'a -> bool) -> 'a map -> bool
            val filter : (key -> 'a -> bool) -> 'a map -> 'a map
            val partition : (key -> 'a -> bool) -> 'a map -> 'a map * 'a map
            val cardinal : 'a map -> int
            val bindings : 'a map -> (key * 'a) list
            val min_binding : 'a map -> key * 'a
            val max_binding : 'a map -> key * 'a
            val choose : 'a map -> key * 'a
            val split : key -> 'a map -> 'a map * 'a option * 'a map
            val find : key -> 'a map -> 'a
            val map : ('a -> 'b) -> 'a map -> 'b map
            val mapi : (key -> 'a -> 'b) -> 'a map -> 'b map
            val to_seq : 'a map -> (key * 'a) t
            val of_seq : (key * 'a) t -> 'a map
            val keys : 'a map -> key t
            val values : 'a map -> 'a t
          end
      module Make :
        functor (V : Map.OrderedType) ->
          sig
            type +'a map
            type key = V.t
            val empty : 'a map
            val is_empty : 'a map -> bool
            val mem : key -> 'a map -> bool
            val add : key -> 'a -> 'a map -> 'a map
            val singleton : key -> 'a -> 'a map
            val remove : key -> 'a map -> 'a map
            val merge :
              (key -> 'a option -> 'b option -> 'c option) ->
              'a map -> 'b map -> 'c map
            val compare : ('a -> 'a -> int) -> 'a map -> 'a map -> int
            val equal : ('a -> 'a -> bool) -> 'a map -> 'a map -> bool
            val iter : (key -> 'a -> unit) -> 'a map -> unit
            val fold : (key -> 'a -> 'b -> 'b) -> 'a map -> 'b -> 'b
            val for_all : (key -> 'a -> bool) -> 'a map -> bool
            val exists : (key -> 'a -> bool) -> 'a map -> bool
            val filter : (key -> 'a -> bool) -> 'a map -> 'a map
            val partition : (key -> 'a -> bool) -> 'a map -> 'a map * 'a map
            val cardinal : 'a map -> int
            val bindings : 'a map -> (key * 'a) list
            val min_binding : 'a map -> key * 'a
            val max_binding : 'a map -> key * 'a
            val choose : 'a map -> key * 'a
            val split : key -> 'a map -> 'a map * 'a option * 'a map
            val find : key -> 'a map -> 'a
            val map : ('a -> 'b) -> 'a map -> 'b map
            val mapi : (key -> 'a -> 'b) -> 'a map -> 'b map
            val to_seq : 'a map -> (key * 'a) t
            val of_seq : (key * 'a) t -> 'a map
            val keys : 'a map -> key t
            val values : 'a map -> '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
  module TypeClass :
    sig
      type ('a, 'b) sequenceable = {
        to_seq : 'b -> 'a Sequence.t;
        of_seq : 'a Sequence.t -> 'b;
      }
      type ('a, 'b) addable = { empty : 'b; add : 'b -> 'a -> 'b; }
      type 'a monoid = ('a, 'a) Sequence.TypeClass.addable
      type ('a, 'b) iterable = { iter : ('a -> unit) -> 'b -> unit; }
      val sequenceable : ('a, 'a Sequence.t) Sequence.TypeClass.sequenceable
      val iterable : ('a, 'a Sequence.t) Sequence.TypeClass.iterable
      val monoid : 'a Sequence.t Sequence.TypeClass.monoid
      val of_iterable :
        ('a, 'b) Sequence.TypeClass.iterable -> 'b -> 'a Sequence.t
      val to_addable :
        ('a, 'b) Sequence.TypeClass.addable -> 'a Sequence.t -> 'b
    end
  module Infix :
    sig
      val ( -- ) : int -> int -> int Sequence.t
      val ( |> ) : 'a -> ('a -> 'b) -> 'b
      val ( @@ ) : 'a Sequence.t -> 'a Sequence.t -> 'a Sequence.t
    end
  val pp_seq :
    ?sep:string ->
    (Format.formatter -> 'a -> unit) ->
    Format.formatter -> 'a Sequence.t -> unit
end