sig
  type 'a t = 'a list
  val _Cons : 'a -> 'a list -> 'a list
  val _Nil : 'a list
  val iter : ('a -> unit) -> 'a Clarity_list.t -> unit
  val append : 'a Clarity_list.t -> 'a Clarity_list.t -> 'a Clarity_list.t
  val length : 'a Clarity_list.t -> int
  val mapi : (int -> 'a -> 'b) -> 'a Clarity_list.t -> 'b Clarity_list.t
  val filter : ('a -> bool) -> 'a Clarity_list.t -> 'a Clarity_list.t
  val intersperse : 'a -> 'a list -> 'a list
  val rev : 'a Clarity_list.t -> 'a Clarity_list.t
  val rev_append :
    'a Clarity_list.t -> 'a Clarity_list.t -> 'a Clarity_list.t
  val rev_map : ('a -> 'b) -> 'a Clarity_list.t -> 'b Clarity_list.t
  val rev_mapi : (int -> 'a -> 'b) -> 'a Clarity_list.t -> 'b Clarity_list.t
  val sort : ?cmp:('a -> 'a -> int) -> 'a Clarity_list.t -> 'a Clarity_list.t
  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