# Module type Core_set_intf.Creators_generic

    module type Creators_generic = sig .. end

    type ('a, 'cmp) t

    type ('a, 'cmp) set

    type ('a, 'cmp) tree

    type 'a elt

    type ('a, 'cmp, 'z) options

    type 'cmp cmp

    val empty : ('a, 'cmp, ('a, 'cmp) t)
           options

    val singleton : ('a, 'cmp,
            'a elt ->
            ('a, 'cmp) t)
           options

    val union_list : ('a, 'cmp,
            ('a, 'cmp) t list ->
            ('a, 'cmp) t)
           options

    val of_list : ('a, 'cmp,
            'a elt list ->
            ('a, 'cmp) t)
           options

    val of_array : ('a, 'cmp,
            'a elt array ->
            ('a, 'cmp) t)
           options

    val of_sorted_array : ('a, 'cmp,
            'a elt array ->
            ('a, 'cmp) t Or_error.t)
           options

    val of_sorted_array_unchecked : ('a, 'cmp,
            'a elt array ->
            ('a, 'cmp) t)
           options

    val stable_dedup_list : ('a, 'b,
            'a elt list ->
            'a elt list)
           options

    val map : ('b, 'cmp,
            ('a, 'c) set ->
            f:('a -> 'b elt) ->
            ('b, 'cmp) t)
           options

The types of `map` and `filter_map` are subtle. The input set, `('a, _) set`, reflects the fact that these functions take a set of *any* type, with any comparator, while the output set, `('b, 'cmp) t`, reflects that the output set has the particular `'cmp` of the creation function. The comparator can come in one of three ways, depending on which set module is used

- `Set.map` -- comparator comes as an argument
- `Set.Poly.map` -- comparator is polymorphic comparison
- `Foo.Set.map` -- comparator is `Foo.comparator`

    val filter_map : ('b, 'cmp,
            ('a, 'c) set ->
            f:('a -> 'b elt option) ->
            ('b, 'cmp) t)
           options

    val of_tree : ('a, 'cmp,
            ('a elt, 'cmp)
            tree ->
            ('a, 'cmp) t)
           options

    val of_map_keys : ('a elt, 'b,
            'cmp cmp)
           Map.t -> ('a, 'cmp) t

never requires a comparator because it can get one from the input `Map.t`