anchor.diff:    /// [DoubleLinkedQueueEntry.previousEntry()].
     ///
     /// The [action] function can use methods on [DoubleLinkedQueueEntry] to
  -  /// remove the entry or it can insert elements before or after then entry.
  +  /// remove the entry or it can insert elements before or after the entry.
     /// If the current entry is removed, iteration continues with the entry that
     /// was following the current entry when [action] was called. Any elements
     /// inserted after the current element before it is removed will not be
  
positive.code:   /// Any time the queue would produce an element that is not a [T],
    /// the element access will throw.
    ///
    /// Any time a [T] value is attempted stored into the adapted queue,
    /// the store will throw unless the value is also an instance of [S].
    ///
    /// If all accessed elements of [source] are actually instances of [T],
    /// and if all elements stored into the returned queue are actually instance
    /// of [S],
    /// then the returned queue can be used as a `Queue<T>`.
    ///
    /// Methods which accept `Object?` as argument, like [contains] and [remove],
    /// will pass the argument directly to the this queue's method
    /// without any checks.
    static Queue<T> castFrom<S, T>(Queue<S> source) => CastQueue<S, T>(source);
  
  
negative.code:   /// Queue<SubType> subQueue =
    ///     ListQueue<SubType>.from(superQueue.whereType<SubType>());
    /// ```
    /// Example:
    /// ```dart
    /// final numbers = <num>[10, 20, 30];
    /// final queue = ListQueue<int>.from(numbers);
    /// print(queue); // {10, 20, 30}
    /// ```
    factory ListQueue.from(Iterable<dynamic> elements) {
      if (elements is List<dynamic>) {
        int length = elements.length;
  