sig
  type 'a t
  val print :
    ?first:(unit, Format.formatter, unit) Pervasives.format ->
    ?sep:(unit, Format.formatter, unit) Pervasives.format ->
    ?last:(unit, Format.formatter, unit) Pervasives.format ->
    (Format.formatter -> 'a -> unit) ->
    Format.formatter -> 'a SetList.t -> unit
  val empty : 'a SetList.t
  val is_empty : 'a SetList.t -> bool
  val mem : 'a -> 'a SetList.t -> bool
  val of_list : 'a list -> 'a SetList.t
  val to_list : 'a SetList.t -> 'a list
  val singleton : 'a -> 'a SetList.t
  val add : 'a -> 'a SetList.t -> 'a SetList.t
  val remove : 'a -> 'a SetList.t -> 'a SetList.t
  val union : 'a SetList.t -> 'a SetList.t -> 'a SetList.t
  val inter : 'a SetList.t -> 'a SetList.t -> 'a SetList.t
  val diff : 'a SetList.t -> 'a SetList.t -> 'a SetList.t
  val compare : 'a SetList.t -> 'a SetList.t -> int
  val equal : 'a SetList.t -> 'a SetList.t -> bool
  val subset : 'a SetList.t -> 'a SetList.t -> bool
  val iter : ('a -> unit) -> 'a SetList.t -> unit
  val fold : ('a -> 'b -> 'b) -> 'a SetList.t -> 'b -> 'b
  val fold_right : ('a -> 'b -> 'b) -> 'a SetList.t -> 'b -> 'b
  val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b SetList.t -> 'a
  val cardinal : 'a SetList.t -> int
  val elements : 'a SetList.t -> 'a list
  val min_elt : 'a SetList.t -> 'a
  val max_elt : 'a SetList.t -> 'a
  val choose : 'a SetList.t -> 'a
  val filter : ('a -> bool) -> 'a SetList.t -> 'a SetList.t
  val partition : ('a -> bool) -> 'a SetList.t -> 'a SetList.t * 'a SetList.t
  val exists : ('a -> bool) -> 'a SetList.t -> bool
  val for_all : ('a -> bool) -> 'a SetList.t -> bool
  module type S =
    sig
      type elt
      type t
      val print :
        ?first:(unit, Format.formatter, unit) Pervasives.format ->
        ?sep:(unit, Format.formatter, unit) Pervasives.format ->
        ?last:(unit, Format.formatter, unit) Pervasives.format ->
        (Format.formatter -> SetList.S.elt -> unit) ->
        Format.formatter -> SetList.S.t -> unit
      val empty : SetList.S.t
      val is_empty : SetList.S.t -> bool
      val mem : SetList.S.elt -> SetList.S.t -> bool
      val of_list : SetList.S.elt list -> SetList.S.t
      val to_list : SetList.S.t -> SetList.S.elt list
      val singleton : SetList.S.elt -> SetList.S.t
      val add : SetList.S.elt -> SetList.S.t -> SetList.S.t
      val remove : SetList.S.elt -> SetList.S.t -> SetList.S.t
      val union : SetList.S.t -> SetList.S.t -> SetList.S.t
      val inter : SetList.S.t -> SetList.S.t -> SetList.S.t
      val diff : SetList.S.t -> SetList.S.t -> SetList.S.t
      val compare : SetList.S.t -> SetList.S.t -> int
      val equal : SetList.S.t -> SetList.S.t -> bool
      val subset : SetList.S.t -> SetList.S.t -> bool
      val iter : (SetList.S.elt -> unit) -> SetList.S.t -> unit
      val fold : (SetList.S.elt -> 'a -> 'a) -> SetList.S.t -> 'a -> 'a
      val fold_right : (SetList.S.elt -> 'a -> 'a) -> SetList.S.t -> 'a -> 'a
      val fold_left : ('a -> SetList.S.elt -> 'a) -> 'a -> SetList.S.t -> 'a
      val cardinal : SetList.S.t -> int
      val elements : SetList.S.t -> SetList.S.elt list
      val min_elt : SetList.S.t -> SetList.S.elt
      val max_elt : SetList.S.t -> SetList.S.elt
      val choose : SetList.S.t -> SetList.S.elt
      val filter : (SetList.S.elt -> bool) -> SetList.S.t -> SetList.S.t
      val partition :
        (SetList.S.elt -> bool) -> SetList.S.t -> SetList.S.t * SetList.S.t
      val exists : (SetList.S.elt -> bool) -> SetList.S.t -> bool
      val for_all : (SetList.S.elt -> bool) -> SetList.S.t -> bool
    end
  module Make :
    functor (Ord : Set.OrderedType) ->
      sig
        type elt = Ord.t
        type t
        val print :
          ?first:(unit, Format.formatter, unit) format ->
          ?sep:(unit, Format.formatter, unit) format ->
          ?last:(unit, Format.formatter, unit) format ->
          (Format.formatter -> elt -> unit) -> Format.formatter -> t -> unit
        val empty : t
        val is_empty : t -> bool
        val mem : elt -> t -> bool
        val of_list : elt list -> t
        val to_list : t -> elt list
        val singleton : elt -> t
        val add : elt -> t -> t
        val remove : elt -> t -> t
        val union : t -> t -> t
        val inter : t -> t -> t
        val diff : t -> t -> t
        val compare : t -> t -> int
        val equal : t -> t -> bool
        val subset : t -> t -> bool
        val iter : (elt -> unit) -> t -> unit
        val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
        val fold_right : (elt -> 'a -> 'a) -> t -> 'a -> 'a
        val fold_left : ('a -> elt -> 'a) -> 'a -> t -> 'a
        val cardinal : t -> int
        val elements : t -> elt list
        val min_elt : t -> elt
        val max_elt : t -> elt
        val choose : t -> elt
        val filter : (elt -> bool) -> t -> t
        val partition : (elt -> bool) -> t -> t * t
        val exists : (elt -> bool) -> t -> bool
        val for_all : (elt -> bool) -> t -> bool
      end
end