anchor.diff:  
     /// Creates an insertion-ordered identity-based set.
     ///
  -  /// Effectively a shorthand for:
  +  /// Effectively shorthand for:
     /// ```dart
     /// LinkedHashSet<E>(equals: identical, hashCode: identityHashCode)
     /// ```
  
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: /// 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
  /// 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.
  ///
  /// **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].
  