functor
  (K : sig val is_summary : Key.t -> bool end) (Value : sig
                                                          val ty :
                                                            Value.t Type.t
                                                          val name : string
                                                          val descr :
                                                            Value.t Descr.t
                                                          val packed_descr :
                                                            Structural_descr.pack
                                                          val reprs :
                                                            Value.t list
                                                          val equal :
                                                            Value.t ->
                                                            Value.t -> bool
                                                          val compare :
                                                            Value.t ->
                                                            Value.t -> int
                                                          val hash :
                                                            Value.t -> int
                                                          val pretty_code :
                                                            Format.formatter ->
                                                            Value.t -> unit
                                                          val internal_pretty_code :
                                                            Type.precedence ->
                                                            Format.formatter ->
                                                            Value.t -> unit
                                                          val pretty :
                                                            Format.formatter ->
                                                            Value.t -> unit
                                                          val varname :
                                                            Value.t -> string
                                                          val mem_project :
                                                            (Project_skeleton.t ->
                                                             bool) ->
                                                            Value.t -> bool
                                                          val copy :
                                                            Value.t ->
                                                            Value.t
                                                          val join :
                                                            Value.t ->
                                                            Value.t ->
                                                            Value.t
                                                          val is_included :
                                                            Value.t ->
                                                            Value.t -> bool
                                                          val bottom :
                                                            Value.t
                                                          val top : Value.t
                                                          type widen_hint
                                                          val widen :
                                                            widen_hint ->
                                                            Value.t ->
                                                            Value.t ->
                                                            Value.t
                                                          val cardinal_zero_or_one :
                                                            Value.t -> bool
                                                          val narrow :
                                                            Value.t ->
                                                            Value.t ->
                                                            Value.t
                                                          val link :
                                                            Value.t ->
                                                            Value.t ->
                                                            Value.t
                                                          val meet :
                                                            Value.t ->
                                                            Value.t ->
                                                            Value.t
                                                          val intersects :
                                                            Value.t ->
                                                            Value.t -> bool
                                                          val diff :
                                                            Value.t ->
                                                            Value.t ->
                                                            Value.t
                                                          val diff_if_one :
                                                            Value.t ->
                                                            Value.t ->
                                                            Value.t
                                                          val fold_enum :
                                                            (Value.t ->
                                                             '-> 'a) ->
                                                            Value.t ->
                                                            '-> 'a
                                                          val cardinal_less_than :
                                                            Value.t ->
                                                            int -> int
                                                        end->
  sig
    val cardinal_zero_or_one : t -> bool
    val diff_if_one : t -> t -> t
    val fold_enum : (t -> '-> 'a) -> t -> '-> 'a
    val cardinal_less_than : t -> int -> int
    val find_lonely_key : t -> key * v
    val find_lonely_binding : t -> key * v
  end