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