sig
  type 'a trivial = Trivial | NonTrivial of 'a
  type 'a tree =
      Empty
    | Leaf of 'a
    | Node of 'Equality_sig.tree * 'Equality_sig.tree
  module type S =
    sig
      type t
      val ty : t Type.t
      val name : string
      val descr : t Descr.t
      val packed_descr : Structural_descr.pack
      val reprs : t list
      val hash : t -> int
      val pretty_code : Format.formatter -> t -> unit
      val internal_pretty_code :
        Type.precedence -> Format.formatter -> t -> unit
      val pretty : Format.formatter -> t -> unit
      val varname : t -> string
      val mem_project : (Project_skeleton.t -> bool) -> t -> bool
      val copy : t -> t
      type elt
      val pair :
        Equality_sig.S.elt -> Equality_sig.S.elt -> t Equality_sig.trivial
      val mem : Equality_sig.S.elt -> t -> bool
      val add : Equality_sig.S.elt -> t -> t
      val remove : Equality_sig.S.elt -> t -> t Equality_sig.trivial
      val union : t -> t -> t
      val inter : t -> t -> t Equality_sig.trivial
      val intersects : t -> t -> bool
      val compare : t -> t -> int
      val equal : t -> t -> bool
      val subset : t -> t -> bool
      val iter : (Equality_sig.S.elt -> unit) -> t -> unit
      val fold : (Equality_sig.S.elt -> '-> 'a) -> t -> '-> 'a
      val for_all : (Equality_sig.S.elt -> bool) -> t -> bool
      val exists : (Equality_sig.S.elt -> bool) -> t -> bool
      val filter :
        (Equality_sig.S.elt -> bool) -> t -> t Equality_sig.trivial
      val cardinal : t -> int
      val choose : t -> Equality_sig.S.elt
    end
  module type Set =
    sig
      type element
      type equality
      type t
      val ty : t Type.t
      val name : string
      val descr : t Descr.t
      val packed_descr : Structural_descr.pack
      val reprs : t list
      val hash : t -> int
      val pretty_code : Format.formatter -> t -> unit
      val internal_pretty_code :
        Type.precedence -> Format.formatter -> t -> unit
      val pretty : Format.formatter -> t -> unit
      val varname : t -> string
      val mem_project : (Project_skeleton.t -> bool) -> t -> bool
      val copy : t -> t
      val empty : t
      val is_empty : t -> bool
      val add : Equality_sig.Set.equality -> t -> t
      val singleton : Equality_sig.Set.equality -> t
      val union : t -> t -> t
      val inter : t -> t -> t
      val compare : t -> t -> int
      val equal : t -> t -> bool
      val subset : t -> t -> bool
      val iter : (Equality_sig.Set.equality -> unit) -> t -> unit
      val fold : (Equality_sig.Set.equality -> '-> 'a) -> t -> '-> 'a
      val for_all : (Equality_sig.Set.equality -> bool) -> t -> bool
      val exists : (Equality_sig.Set.equality -> bool) -> t -> bool
      val elements : t -> Equality_sig.Set.equality list
      val choose : t -> Equality_sig.Set.equality
      val remove : Equality_sig.Set.element -> t -> t
      val unite :
        Equality_sig.Set.element -> Equality_sig.Set.element -> t -> t
      val find : Equality_sig.Set.element -> t -> Equality_sig.Set.equality
      val find_option :
        Equality_sig.Set.element -> t -> Equality_sig.Set.equality option
      val mem : Equality_sig.Set.equality -> t -> bool
      val contains : Equality_sig.Set.element -> t -> bool
      val deep_fold :
        (Equality_sig.Set.equality -> Equality_sig.Set.element -> '-> 'a) ->
        t -> '-> 'a
      val cardinal : t -> int
      val elements_only_left :
        t -> t -> Equality_sig.Set.element Equality_sig.tree
    end
  module type S_with_collections =
    sig
      type t
      val ty : t Type.t
      val name : string
      val descr : t Descr.t
      val packed_descr : Structural_descr.pack
      val reprs : t list
      val hash : t -> int
      val pretty_code : Format.formatter -> t -> unit
      val internal_pretty_code :
        Type.precedence -> Format.formatter -> t -> unit
      val pretty : Format.formatter -> t -> unit
      val varname : t -> string
      val mem_project : (Project_skeleton.t -> bool) -> t -> bool
      val copy : t -> t
      type elt
      val pair : elt -> elt -> t trivial
      val mem : elt -> t -> bool
      val add : elt -> t -> t
      val remove : elt -> t -> t trivial
      val union : t -> t -> t
      val inter : t -> t -> t trivial
      val intersects : t -> t -> bool
      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) -> t -> '-> 'a
      val for_all : (elt -> bool) -> t -> bool
      val exists : (elt -> bool) -> t -> bool
      val filter : (elt -> bool) -> t -> t trivial
      val cardinal : t -> int
      val choose : t -> elt
      module Set :
        sig
          type element = elt
          type equality = t
          type t
          val ty : t Type.t
          val name : string
          val descr : t Descr.t
          val packed_descr : Structural_descr.pack
          val reprs : t list
          val hash : t -> int
          val pretty_code : Format.formatter -> t -> unit
          val internal_pretty_code :
            Type.precedence -> Format.formatter -> t -> unit
          val pretty : Format.formatter -> t -> unit
          val varname : t -> string
          val mem_project : (Project_skeleton.t -> bool) -> t -> bool
          val copy : t -> t
          val empty : t
          val is_empty : t -> bool
          val add : equality -> t -> t
          val singleton : equality -> t
          val union : t -> t -> t
          val inter : t -> t -> t
          val compare : t -> t -> int
          val equal : t -> t -> bool
          val subset : t -> t -> bool
          val iter : (equality -> unit) -> t -> unit
          val fold : (equality -> '-> 'a) -> t -> '-> 'a
          val for_all : (equality -> bool) -> t -> bool
          val exists : (equality -> bool) -> t -> bool
          val elements : t -> equality list
          val choose : t -> equality
          val remove : element -> t -> t
          val unite : element -> element -> t -> t
          val find : element -> t -> equality
          val find_option : element -> t -> equality option
          val mem : equality -> t -> bool
          val contains : element -> t -> bool
          val deep_fold : (equality -> element -> '-> 'a) -> t -> '-> 'a
          val cardinal : t -> int
          val elements_only_left : t -> t -> element tree
        end
    end
end