functor
  (Domain : Abstract_domain.External) (States : sig
                                                  type state = Domain.t
                                                  type t
                                                  val empty : t
                                                  val is_empty : t -> bool
                                                  val singleton : state -> t
                                                  val singleton' :
                                                    state Eval.or_bottom -> t
                                                  val uncheck_add :
                                                    state -> t -> t
                                                  val add : state -> t -> t
                                                  val add' :
                                                    state Eval.or_bottom ->
                                                    t -> t
                                                  val length : t -> int
                                                  val merge :
                                                    into:t -> t -> t * bool
                                                  val join :
                                                    ?into:state
                                                          Eval.or_bottom ->
                                                    t -> state Eval.or_bottom
                                                  val fold :
                                                    (state -> '-> 'a) ->
                                                    t -> '-> 'a
                                                  val iter :
                                                    (state -> unit) ->
                                                    t -> unit
                                                  val map :
                                                    (state -> state) ->
                                                    t -> t
                                                  val reorder : t -> t
                                                  val of_list :
                                                    state list -> t
                                                  val to_list :
                                                    t -> state list
                                                  val pretty :
                                                    Format.formatter ->
                                                    t -> unit
                                                end->
  sig
    type state = Domain.t
    type state_set = States.t
    type t
    val empty : unit -> t
    val fold : (state -> '-> 'a) -> t -> '-> 'a
    val merge_set_return_new : state_set -> t -> state_set
    val join : t -> state Eval.or_bottom
    val to_set : t -> state_set
    val to_list : t -> state list
    val pretty : Format.formatter -> t -> unit
  end