anchor.diff:    /// the elements' intrinsic [Object.==] and [Object.hashCode].
     ///
     /// If you supply one of [equals] and [hashCode],
  -  /// you should generally also to supply the other.
  +  /// you should generally also supply the other.
     ///
     /// Some [equals] or [hashCode] functions might not work for all objects.
     /// If [isValidKey] is supplied, it's used to check a potential element
  
positive.code: /// and hashCode implementations. This means that the equals operation
  /// must define a stable equivalence relation on the elements (reflexive,
  /// symmetric, transitive, and consistent over time), and that the hashCode
  /// must consistent with equality, so that the same for objects that are
  /// considered equal.
  ///
  /// Most simple operations on `HashSet` are done in (potentially amortized)
  /// constant time: [add], [contains], [remove], and [length], provided the hash
  /// codes of objects are well distributed.
  ///
  /// The iteration order of the set is not specified and depends on
  /// the hashcodes of the provided elements. However, the order is stable:
  /// multiple iterations over the same set produce the same order, as long as
  /// the set is not modified.
  abstract class HashSet<E> implements Set<E> {
    /// Create a hash set using the provided [equals] as equality.
    ///
  
negative.code: 
    /// Create a hash set containing all [elements].
    ///
    /// Creates a hash set as by `HashSet<E>()` and adds all given [elements]
    /// to the set. The elements are added in order. If [elements] contains
    /// two entries that are equal, but not identical, then the first one is
    /// the one in the resulting set.
    /// Example:
    /// ```dart
    /// final baseSet = <int>{1, 2, 3};
    /// final hashSetOf = HashSet<num>.of(baseSet);
    /// print(hashSetOf); // fx {3, 1, 2}
    /// ```
    factory HashSet.of(Iterable<E> elements) => HashSet<E>()..addAll(elements);
  
    /// Provides an iterator that iterates over the elements of this set.
    ///
    /// The order of iteration is unspecified,
    /// but is consistent between changes to the set.
    Iterator<E> get iterator;
  }
  