anchor.diff:  /// An element that was added after another will occur later in the iteration.
   /// Adding an element that is already in the set
   /// does not change its position in the iteration order,
  -/// but removing an element and adding it again,
  +/// but removing an element and adding it again
   /// will make it the last element of an iteration.
   ///
   /// 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..
  +/// codes of objects are well distributed.
  +///
  +/// **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 = <String>{}; // LinkedHashSet
  +/// ```
  +/// To add data to a set, use [add] or [addAll].
  +/// ```
  +/// final uranusAdded = planets.add('Uranus'); // true
  +/// planets.addAll({'Venus', 'Mars', 'Earth', 'Jupiter'});
  +/// print(planets); // {Uranus, Venus, Mars, Earth, Jupiter}
  +/// ```
  +/// To check if the set is empty, use [isEmpty] or [isNotEmpty].
  +/// To find the number of elements in the set, use [length].
  +/// ```
  +/// print(planets.isEmpty); // false
  +/// print(planets.length); // 5
  +/// ```
  +/// To check whether the set has an element with a specific value,
  +/// use [contains].
  +/// ```
  +/// final marsExists = planets.contains('Mars'); // true
  +/// ```
  +/// The [forEach] method calls a function with each element of the set.
  +/// ```
  +/// planets.forEach(print);
  +/// // Uranus
  +/// // Venus
  +/// // Mars
  +/// // Earth
  +/// // Jupiter
  +/// ```
  +///
  +/// To make a copy of the set, use [toSet].
  +/// ```
  +/// final copySet = planets.toSet();
  +/// print(copySet); // {Uranus, Venus, Mars, Earth, Jupiter}
  +/// ```
  +/// To remove an element, use [remove].
  +/// ```
  +/// final removedValue = planets.remove('Mars'); // Mars
  +/// print(planets); // {Uranus, Venus, Earth, Jupiter}
  +/// ```
  +/// To remove multiple elements at the same time, use [removeWhere] or
  +/// [removeAll].
  +/// ```
  +/// planets.removeWhere((element) => element.startsWith('E'));
  +/// print(planets); // {Uranus, Venus, Jupiter}
  +/// ```
  +/// To removes all elements in this set that do not meet a condition,
  +/// use [retainWhere].
  +/// ```
  +/// planets.retainWhere((element) => element.contains('Jupiter'));
  +/// print(planets); // {Jupiter}
  +/// ```
  +/// To remove all elements and empty the set, use [clear].
  +/// ```
  +/// planets.clear();
  +/// print(planets.isEmpty); // true
  +/// print(planets); // {}
  +/// ```
  +/// **See also:**
  +/// * [Set] is the general interface of collection where each object can
  +/// occur only once.
  +/// * [HashSet] the order of the objects in the iteration is not guaranteed.
  +/// * [SplayTreeSet] iterates the objects in sorted order.
   abstract class LinkedHashSet<E> implements Set<E> {
     /// Create an insertion-ordered hash set using the provided
     /// [equals] and [hashCode].
  
positive.code: 
    /// Create a linked hash set from [elements].
    ///
    /// Creates a linked hash set as by `new LinkedHashSet<E>()` and adds each
    /// element of `elements` to this set in the order they are iterated.
    factory LinkedHashSet.of(Iterable<E> elements) =>
        LinkedHashSet<E>()..addAll(elements);
  
  
negative.code: 
    /// Create a linked hash set containing all [elements].
    ///
    /// Creates a linked hash set as by `LinkedHashSet<E>()` and adds each
    /// element of `elements` to this set in the order they are iterated.
    ///
    /// All the [elements] should be instances of [E].
  