sig
  type +'a t
  type 'a sequence = 'Sequence.t
  val mem : ?equal:('-> '-> bool) -> 'a t -> '-> bool
  val length : 'a t -> int
  val is_empty : 'a t -> bool
  val iter : 'a t -> f:('-> unit) -> unit
  val fold : 'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
  val exists : 'a t -> f:('-> bool) -> bool
  val for_all : 'a t -> f:('-> bool) -> bool
  val count : 'a t -> f:('-> bool) -> int
  val sum :
    (module Commutative_group.S with type t = 'sum) ->
    'a t -> f:('-> 'sum) -> 'sum
  val find : 'a t -> f:('-> bool) -> 'a option
  val find_map : 'a t -> f:('-> 'b option) -> 'b option
  val to_array : 'a t -> 'a array
  val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
  val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
  val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
  module Monad_infix :
    sig
      val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
    end
  val bind : 'a t -> ('-> 'b t) -> 'b t
  val return : '-> 'a t
  val map : 'a t -> f:('-> 'b) -> 'b t
  val join : 'a t t -> 'a t
  val ignore_m : 'a t -> unit t
  val all : 'a t list -> 'a list t
  val all_ignore : unit t list -> unit t
  val empty : 'Sequence.t
  val next : 'Sequence.t -> ('a * 'Sequence.t) option
  module Step :
    sig
      type ('a, 's) t = Done | Skip of '| Yield of 'a * 's
      val sexp_of_t :
        ('-> Sexplib.Sexp.t) ->
        ('-> Sexplib.Sexp.t) -> ('a, 's) Sequence.Step.t -> Sexplib.Sexp.t
    end
  val unfold_step :
    init:'-> f:('-> ('a, 's) Sequence.Step.t) -> 'Sequence.t
  val unfold : init:'-> f:('-> ('a * 's) option) -> 'Sequence.t
  val unfold_with :
    'Sequence.t ->
    init:'-> f:('-> '-> ('b, 's) Sequence.Step.t) -> 'Sequence.t
  val unfold_with_and_finish :
    'Sequence.t ->
    init:'s_a ->
    running_step:('s_a -> '-> ('b, 's_a) Sequence.Step.t) ->
    inner_finished:('s_a -> 's_b) ->
    finishing_step:('s_b -> ('b, 's_b) Sequence.Step.t) -> 'Sequence.t
  val nth : 'Sequence.t -> int -> 'a option
  val nth_exn : 'Sequence.t -> int -> 'a
  val mapi : 'Sequence.t -> f:(int -> '-> 'b) -> 'Sequence.t
  val filteri : 'Sequence.t -> f:(int -> '-> bool) -> 'Sequence.t
  val filter : 'Sequence.t -> f:('-> bool) -> 'Sequence.t
  val merge :
    'Sequence.t -> 'Sequence.t -> cmp:('-> '-> int) -> 'Sequence.t
  val hd : 'Sequence.t -> 'a option
  val hd_exn : 'Sequence.t -> 'a
  val tl : 'Sequence.t -> 'Sequence.t option
  val tl_eagerly_exn : 'Sequence.t -> 'Sequence.t
  val findi : 'Sequence.t -> f:(int -> '-> bool) -> (int * 'a) option
  val find_exn : 'Sequence.t -> f:('-> bool) -> 'a
  val append : 'Sequence.t -> 'Sequence.t -> 'Sequence.t
  val concat : 'Sequence.t Sequence.t -> 'Sequence.t
  val concat_map : 'Sequence.t -> f:('-> 'Sequence.t) -> 'Sequence.t
  val concat_mapi :
    'Sequence.t -> f:(int -> '-> 'Sequence.t) -> 'Sequence.t
  val interleave : 'Sequence.t Sequence.t -> 'Sequence.t
  val zip : 'Sequence.t -> 'Sequence.t -> ('a * 'b) Sequence.t
  val zip_full :
    'Sequence.t ->
    'Sequence.t ->
    [ `Both of 'a * '| `Left of '| `Right of 'b ] Sequence.t
  val iteri : 'Sequence.t -> f:(int -> '-> unit) -> unit
  val foldi : 'Sequence.t -> f:(int -> '-> '-> 'b) -> init:'-> 'b
  val reduce_exn : 'Sequence.t -> f:('-> '-> 'a) -> 'a
  val reduce : 'Sequence.t -> f:('-> '-> 'a) -> 'a option
  val find_consecutive_duplicate :
    'Sequence.t -> equal:('-> '-> bool) -> ('a * 'a) option
  val remove_consecutive_duplicates :
    'Sequence.t -> equal:('-> '-> bool) -> 'Sequence.t
  val range :
    ?stride:int ->
    ?start:[ `exclusive | `inclusive ] ->
    ?stop:[ `exclusive | `inclusive ] -> int -> int -> int Sequence.t
  val init : int -> f:(int -> 'a) -> 'Sequence.t
  val filter_map : 'Sequence.t -> f:('-> 'b option) -> 'Sequence.t
  val filter_mapi :
    'Sequence.t -> f:(int -> '-> 'b option) -> 'Sequence.t
  val filter_opt : 'a option Sequence.t -> 'Sequence.t
  val sub : 'Sequence.t -> pos:int -> len:int -> 'Sequence.t
  val take : 'Sequence.t -> int -> 'Sequence.t
  val drop : 'Sequence.t -> int -> 'Sequence.t
  val drop_eagerly : 'Sequence.t -> int -> 'Sequence.t
  val take_while : 'Sequence.t -> f:('-> bool) -> 'Sequence.t
  val drop_while : 'Sequence.t -> f:('-> bool) -> 'Sequence.t
  val drop_while_option :
    'Sequence.t -> f:('-> bool) -> ('a * 'Sequence.t) option
  val split_n_eagerly : 'Sequence.t -> int -> 'Sequence.t * 'Sequence.t
  val shift_right : 'Sequence.t -> '-> 'Sequence.t
  val shift_right_with_list : 'Sequence.t -> 'a list -> 'Sequence.t
  val shift_left : 'Sequence.t -> int -> 'Sequence.t
  module Infix :
    sig val ( @ ) : 'Sequence.t -> 'Sequence.t -> 'Sequence.t end
  val cartesian_product :
    'Sequence.t -> 'Sequence.t -> ('a * 'b) Sequence.t
  val interleaved_cartesian_product :
    'Sequence.t -> 'Sequence.t -> ('a * 'b) Sequence.t
  val intersperse : 'Sequence.t -> sep:'-> 'Sequence.t
  val cycle_list_exn : 'a list -> 'Sequence.t
  val repeat : '-> 'Sequence.t
  val singleton : '-> 'Sequence.t
  val delayed_fold :
    'Sequence.t ->
    init:'-> f:('-> '-> k:('-> 'r) -> 'r) -> finish:('-> 'r) -> 'r
  val to_list : 'Sequence.t -> 'a list
  val to_list_rev : 'Sequence.t -> 'a list
  val of_list : 'a list -> 'Sequence.t
  val memoize : 'Sequence.t -> 'Sequence.t
  val force_eagerly : 'Sequence.t -> 'Sequence.t
  val bounded_length :
    'Sequence.t -> at_most:int -> [ `Greater | `Is of int ]
  val length_is_bounded_by : ?min:int -> ?max:int -> 'Sequence.t -> bool
  module Generator :
    sig
      type ('a, 'e) t
      val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
      module Monad_infix :
        sig
          val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
          val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
        end
      val bind : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
      val return : '-> ('a, 'b) t
      val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
      val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
      val ignore_m : ('a, 'e) t -> (unit, 'e) t
      val all : ('a, 'e) t list -> ('a list, 'e) t
      val all_ignore : (unit, 'e) t list -> (unit, 'e) t
      val yield : 'elt -> (unit, 'elt) Sequence.t
      val run : (unit, 'elt) Sequence.t -> 'elt Sequence.sequence
    end
  val sexp_of_t : ('-> Sexplib.Sexp.t) -> 'Sequence.t -> Sexplib.Sexp.t
  val compare : ('-> '-> int) -> 'Sequence.t -> 'Sequence.t -> int
end