```"A [[MutableSet]] implemented using a red/black tree.
Elements of the set are maintained in a sorted order, from
smallest to largest, as determined by the given
[[comparator function|compare]]."
see (`function naturalOrderTreeSet`)
by ("Gavin King")
shared class TreeSet<Element>
satisfies MutableSet<Element>
& SortedSet<Element>
& Ranged<Element,Element,TreeSet<Element>>
given Element satisfies Object {

"A comparator function used to sort the elements."
Comparison compare(Element x, Element y);

TreeMap<Element,Element> map;

"Create a new `TreeSet` with the given
[[comparator function|compare]] and [[elements]]."
shared new (
"A comparator function used to sort the elements."
Comparison compare(Element x, Element y),
"The initial elements of the set."
{Element*} elements = {}) {
this.compare = compare;
map = TreeMap {
compare = compare;
entries = elements.map((elem) => elem->elem);
};
}

"Create a new `TreeMap` with the same comparator
function and elements as the given [[treeSet]]."
shared new copy(TreeSet<Element> treeSet) {
compare = treeSet.compare;
map = treeSet.map.clone();
}

contains(Object element) => map.defines(element);

add(Element element) => !map.put(element, element) exists;

remove(Element element) => map.remove(element) exists;

clear() => map.clear();

iterator() => map.keys.iterator();

first => map.first?.key;
last => map.last?.key;

higherElements(Element element)
=> map.higherEntries(element)
.map(Entry.key);

lowerElements(Element element)
=> map.lowerEntries(element)
.map(Entry.key);

ascendingElements(Element from, Element to)
=> higherElements(from)
.takeWhile((element)
=> compare(element,to)!=larger);

descendingElements(Element from, Element to)
=> lowerElements(from)
.takeWhile((element)
=> compare(element,to)!=smaller);

measure(Element from, Integer length)
=> TreeSet(compare,
higherElements(from)
.take(length));

span(Element from, Element to)
=> let (reverse = compare(from,to)==larger)
TreeSet {
compare(Element x, Element y)
=> reverse then compare(y,x)
else compare(x,y);
elements = reverse then descendingElements(from,to)
else ascendingElements(from,to);
};

spanFrom(Element from)
=> TreeSet(compare, higherElements(from));

spanTo(Element to)
=> TreeSet(compare,
takeWhile((element)
=> compare(element,to)!=larger));

shared actual TreeSet<Element> clone() => copy(this);

shared actual HashSet<Element> complement<Other>
(Set<Other> set)
given Other satisfies Object {
value result = HashSet<Element>();
for (element in this) {
if (!(element in set)) {
}
}
return result;
}

shared actual HashSet<Element|Other> exclusiveUnion<Other>
(Set<Other> set)
given Other satisfies Object {
value result = HashSet<Element|Other>();
for (element in this) {
if (!(element in set)) {
}
}
for (element in set) {
if (!(element in this)) {
}
}
return result;
}

shared actual HashSet<Element&Other> intersection<Other>
(Set<Other> set)
given Other satisfies Object {
value result = HashSet<Element&Other>();
for (element in this) {
if (element in set, is Other element) {
}
}
return result;
}

shared actual HashSet<Element|Other> union<Other>
(Set<Other> set)
given Other satisfies Object {
value result = HashSet<Element|Other>();
return result;
}

equals(Object that)
=> (super of Set<Element>).equals(that);

hash => (super of Set<Element>).hash;

}

"Create a [[TreeSet]] with [[comparable|Comparable]] keys,
sorted by the natural ordering of the keys."
shared TreeSet<Element> naturalOrderTreeSet<Element>
({<Element>*} entries)
given Element satisfies Comparable<Element>
=> TreeSet((Element x, Element y) => x<=>y, entries);
```