sig
  type _ t
  module Builder :
    sig
      type 'a vector = 'Vector.t
      type _ t
      val empty : unit -> 'Vector.Builder.t
      val copy : 'Vector.Builder.t -> 'Vector.Builder.t
      val put : 'Vector.Builder.t -> '-> unit
      val clear : 'Vector.Builder.t -> unit
      val result : 'Vector.Builder.t -> 'Vector.Builder.vector
    end
  exception Out_of_bounds of { index : int; size : int; }
  val empty : 'Vector.t
  val cons : '-> 'Vector.t -> 'Vector.t
  val snoc : 'Vector.t -> '-> 'Vector.t
  val length : 'Vector.t -> int
  val init : int -> (int -> 'a) -> 'Vector.t
  val append : 'Vector.t -> 'Vector.t -> 'Vector.t
  val get : 'Vector.t -> int -> 'a
  val update : 'Vector.t -> int -> '-> 'Vector.t
  val split_at : 'Vector.t -> int -> 'Vector.t * 'Vector.t
  val take : 'Vector.t -> int -> 'Vector.t
  val drop : 'Vector.t -> int -> 'Vector.t
  val iter : ('-> unit) -> 'Vector.t -> unit
  val of_list : 'a list -> 'Vector.t
  val to_list : 'Vector.t -> 'a list
  val bind : ('-> 'b t) -> 'a t -> 'b t
  val pure : '-> 'a t
  val ap : ('-> 'b) t -> (unit -> 'a t) -> 'b t
  val map : ('-> 'b) -> 'a t -> 'b t
  val ( >|= ) : 'a t -> ('-> 'b) -> 'b t
  val replace : '-> 'b t -> 'a t
  val void : 'a t -> unit t
  val ap' : ('-> 'b) t -> 'a t -> 'b t
  val ( <*> ) : ('-> 'b) t -> 'a t -> 'b t
  val ( <~> ) : ('-> 'b) t -> (unit -> 'a t) -> 'b t
  val discard_left : 'a t -> (unit -> 'b t) -> 'b t
  val discard_right : 'a t -> (unit -> 'b t) -> 'a t
  val repeat : int -> 'a t -> 'a list t
  val repeat_ : int -> 'a t -> unit t
  val forever : 'a t -> 'b t
  val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
  val join : 'a t t -> 'a t
  val mcompose : ('-> 'c t) -> ('-> 'b t) -> '-> 'c t
  val foldl : ('-> '-> 'a) -> '-> 'b t -> 'a
  val foldr : ('-> (unit -> 'b) -> 'b) -> (unit -> 'b) -> 'a t -> 'b
  val foldr' : ('-> '-> 'b) -> '-> 'a t -> 'b
  val fold_map :
    (module Monoid.S with type t = 'm) -> ('-> 'm) -> 'a t -> 'm
  val any : ('-> bool) -> 'a t -> bool
  val all : ('-> bool) -> 'a t -> bool
  val find : ('-> bool) -> 'a t -> 'a option
  val align_with : (('a, 'b) These.t -> 'c) -> 'a t -> 'b t -> 'c t
  val align : 'a t -> 'b t -> ('a, 'b) These.t t
  val falign : ('-> '-> 'a) -> 'a t -> 'a t -> 'a t
  val pad_zip_with : ('a option -> 'b option -> 'c) -> 'a t -> 'b t -> 'c t
  val pad_zip : 'a t -> 'b t -> ('a option * 'b option) t
  module A :
    functor (A : Applicative.Basic->
      sig
        val traverse : ('-> 'A.t) -> 'a t -> 'b t A.t
        val traverse_ : ('-> 'A.t) -> 'a t -> unit A.t
        val sequence : 'A.t t -> 'a t A.t
        val sequence_ : 'A.t t -> unit A.t
      end
  module A2 :
    functor (A : Applicative.Basic2->
      sig
        val traverse : ('-> ('u, 'b) A.t) -> 'a t -> ('u, 'b t) A.t
        val traverse_ : ('-> ('u, 'b) A.t) -> 'a t -> ('u, unit) A.t
        val sequence : ('u, 'a) A.t t -> ('u, 'a t) A.t
        val sequence_ : ('u, 'a) A.t t -> ('u, unit) A.t
      end
  module A3 :
    functor (A : Applicative.Basic3->
      sig
        val traverse : ('-> ('u, 'v, 'b) A.t) -> 'a t -> ('u, 'v, 'b t) A.t
        val traverse_ :
          ('-> ('u, 'v, 'b) A.t) -> 'a t -> ('u, 'v, unit) A.t
        val sequence : ('a, 'b, 'c) A.t t -> ('a, 'b, 'c t) A.t
        val sequence_ : ('a, 'b, 'c) A.t t -> ('a, 'b, unit) A.t
      end
  module M :
    functor (M : Monad.Basic->
      sig
        val traverse : ('-> 'M.t) -> 'a t -> 'b t M.t
        val traverse_ : ('-> 'M.t) -> 'a t -> unit M.t
        val sequence : 'M.t t -> 'a t M.t
        val sequence_ : 'M.t t -> unit M.t
        val foldr_m : ('-> '-> 'M.t) -> '-> 'a t -> 'M.t
        val foldl_m : ('-> '-> 'M.t) -> '-> 'a t -> 'M.t
      end
  module M2 :
    functor (M : Monad.Basic2->
      sig
        val traverse : ('-> ('u, 'b) M.t) -> 'a t -> ('u, 'b t) M.t
        val traverse_ : ('-> ('u, 'b) M.t) -> 'a t -> ('u, unit) M.t
        val sequence : ('u, 'a) M.t t -> ('u, 'a t) M.t
        val sequence_ : ('u, 'a) M.t t -> ('u, unit) M.t
        val foldr_m :
          ('-> '-> ('u, 'b) M.t) -> '-> 'a t -> ('u, 'b) M.t
        val foldl_m :
          ('-> '-> ('u, 'b) M.t) -> '-> 'a t -> ('u, 'b) M.t
      end
  module M3 :
    functor (M : Monad.Basic3->
      sig
        val traverse : ('-> ('u, 'v, 'b) M.t) -> 'a t -> ('u, 'v, 'b t) M.t
        val traverse_ :
          ('-> ('u, 'v, 'b) M.t) -> 'a t -> ('u, 'v, unit) M.t
        val sequence : ('a, 'b, 'c) M.t t -> ('a, 'b, 'c t) M.t
        val sequence_ : ('a, 'b, 'c) M.t t -> ('a, 'b, unit) M.t
        val foldr_m :
          ('-> '-> ('u, 'v, 'b) M.t) -> '-> 'a t -> ('u, 'v, 'b) M.t
        val foldl_m :
          ('-> '-> ('u, 'v, 'b) M.t) -> '-> 'a t -> ('u, 'v, 'b) M.t
      end
end