anchor.diff:  /// amortized constant time add operations.
   ///
   /// The structure is efficient for any queue or stack usage.
  +///
  +/// Example:
  +/// ```dart
  +/// final queue = ListQueue<int>();
  +/// ```
  +/// To add objects to a queue, use [add], [addAll], [addFirst] or[addLast].
  +/// ```
  +/// queue.add(5);
  +/// queue.addFirst(0);
  +/// queue.addLast(10);
  +/// queue.addAll([1, 2, 3]);
  +/// print(queue); // {0, 5, 10, 1, 2, 3}
  +/// ```
  +/// To check if the queue is empty, use [isEmpty] or [isNotEmpty].
  +/// To find the number of queue entries, use [length].
  +/// ```
  +/// final isEmpty = queue.isEmpty; // false
  +/// final queueSize = queue.length; // 6
  +/// ```
  +/// To get first or last item from queue, use [first] or [last].
  +/// ```
  +/// final first = queue.first; // 0
  +/// final last = queue.last; // 3
  +/// ```
  +/// To get item value using index, use [elementAt].
  +/// ```
  +/// final itemAt = queue.elementAt(2); // 10
  +/// ```
  +/// To convert queue to list, call [toList].
  +/// ```
  +/// final numbers = queue.toList();
  +/// print(numbers); // [0, 5, 10, 1, 2, 3]
  +/// ```
  +/// To remove item from queue, call [remove], [removeFirst] or [removeLast].
  +/// ```
  +/// queue.remove(10);
  +/// queue.removeFirst();
  +/// queue.removeLast();
  +/// print(queue); // {5, 1, 2}
  +/// ```
  +/// To remove multiple elements at the same time, use [removeWhere].
  +/// ```
  +/// queue.removeWhere((element) => element == 1);
  +/// print(queue); // {5, 2}
  +/// ```
  +/// To remove all elements in this queue that do not meet a condition,
  +/// use [retainWhere].
  +/// ```
  +/// queue.retainWhere((element) => element < 4);
  +/// print(queue); // {2}
  +/// ```
  +/// To remove all items and empty the set, use [clear].
  +/// ```
  +/// queue.clear();
  +/// print(queue.isEmpty); // true
  +/// print(queue); // {}
  +/// ```
   class ListQueue<E> extends ListIterable<E> implements Queue<E> {
     static const int _INITIAL_CAPACITY = 8;
     List<E?> _table;
  
positive.code:   /// Queue<SubType> subQueue =
    ///     ListQueue<SubType>.from(superQueue.whereType<SubType>());
    /// ```
    factory ListQueue.from(Iterable<dynamic> elements) {
      if (elements is List<dynamic>) {
        int length = elements.length;
  
negative.code:   /// [DoubleLinkedQueueEntry.previousEntry()].
    ///
    /// The [action] function can use methods on [DoubleLinkedQueueEntry] to
    /// 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
  