anchor.diff:    /// Set<SubType> subSet =
     ///     SplayTreeSet<SubType>.from(superSet.whereType<SubType>());
     /// ```
  +  /// Example:
  +  /// ```dart
  +  /// final numbers = <num>[20, 30, 10];
  +  /// final setFrom = SplayTreeSet<int>.from(numbers);
  +  /// print(setFrom); // {10, 20, 30}
  +  /// ```
     factory SplayTreeSet.from(Iterable elements,
         [int Function(E key1, E key2)? compare,
         bool Function(dynamic potentialKey)? isValidKey]) {
  
positive.code:   /// The set works as if created by `new SplayTreeSet<E>(compare, isValidKey)`.
    ///
    /// All the [elements] should be valid as arguments to the [compare] function.
    factory SplayTreeSet.of(Iterable<E> elements,
            [int Function(E key1, E key2)? compare,
            bool Function(dynamic potentialKey)? isValidKey]) =>
  
negative.code: /// [Comparable], and are compared using their [Comparable.compareTo] method.
  /// Non-comparable objects (including `null`) will not work as an element
  /// in that case.
  ///
  /// **Note:**
  /// Do not modify a set (add or remove elements) while an operation
  /// is being performed on that set, for example in functions
  /// called during a [forEach] or [containsAll] call,
  /// or while iterating the set.
  ///
  /// Do not modify elements in a way which changes their equality (and thus their
  /// hash code) while they are in the set. Some specialized kinds of sets may be
  /// more permissive with regards to equality, in which case they should document
  /// their different behavior and restrictions.
  ///
  /// Example:
  /// ```dart
  /// final planets = SplayTreeSet<String>((a, b) => a.compareTo(b));
  /// ```
  /// To add data to a set, use [add] or [addAll].
  /// ```
  /// planets.add('Neptune');
  /// planets.addAll({'Venus', 'Mars', 'Earth', 'Jupiter'});
  /// print(planets); // {Earth, Jupiter, Mars, Neptune, Venus}
  /// ```
  /// To check if the set is empty, use [isEmpty] or [isNotEmpty].
  /// To find the number of elements in the set, use [length].
  /// ```
  /// final isEmpty = planets.isEmpty; // false
  /// final length = planets.length; // 5
  /// ```
  /// To check whether the set contains a specific element, use [contains].
  /// ```
  /// final marsExists = planets.contains('Mars'); // true
  /// ```
  /// To get element value using index, use [elementAt].
  /// ```
  /// final elementAt = planets.elementAt(1);
  /// print(elementAt); // Jupiter
  /// ```
  /// To make a copy of set, use [toSet].
  /// ```
  /// final copySet = planets.toSet(); // a `SplayTreeSet` with the same ordering.
  /// print(copySet); // {Earth, Jupiter, Mars, Neptune, Venus}
  /// ```
  /// To remove an element, use [remove].
  /// ```
  /// final removedValue = planets.remove('Mars'); // true
  /// print(planets); // {Earth, Jupiter, Neptune, Venus}
  /// ```
  /// To remove multiple elements at the same time, use [removeWhere].
  /// ```
  /// planets.removeWhere((element) => element.startsWith('J'));
  /// print(planets); // {Earth, Neptune, Venus}
  /// ```
  /// To removes all elements in this set that do not meet a condition,
  /// use [retainWhere].
  /// ```
  /// planets.retainWhere((element) => element.contains('Earth'));
  /// print(planets); // {Earth}
  /// ```
  /// To remove all elements and empty the set, use [clear].
  /// ```
  /// planets.clear();
  /// print(planets.isEmpty); // true
  /// print(planets); // {}
  /// ```
  /// **See also:**
  /// * [Set] is a base-class for collection of objects.
  /// * [HashSet] the order of the objects in the iterations is not guaranteed.
  /// * [LinkedHashSet] objects stored based on insertion order.
  class SplayTreeSet<E> extends _SplayTree<E, _SplayTreeSetNode<E>>
      with IterableMixin<E>, SetMixin<E> {
    _SplayTreeSetNode<E>? _root;
  