anchor.diff:  }
   
   /**
  - * An [Iterator] that allows moving backwards as well as forwards.
  + * An Iterator that allows moving backwards as well as forwards.
    */
   abstract class BidirectionalIterator<E> implements Iterator<E> {
     /**
  
positive.code:    * This method returns a view of the mapped elements. As long as the
     * returned [Iterable] is not iterated over, the supplied function [test] will
     * not be invoked. Iterating will not cache results, and thus iterating
     * multiple times over the the returned [Iterable] will invoke the supplied
     * function [test] multiple times on the same element.
     */
    Iterable<E> where(bool test(E element));
  
    /**
     * Expand each element of this [Iterable] into zero or more elements.
     *
     * The resulting Iterable will run through the elements returned
     * by [f] for each element of this, in order.
     *
     * The returned [Iterable] is lazy, and will call [f] for each element
     * of this every time it's iterated.
     */
    Iterable expand(Iterable f(E element));
  
    /**
     * Check whether the collection contains an element equal to [element].
     */
    bool contains(Object element);
  
  
negative.code: part of dart.core;
  
  /**
   * An object that uses an [Iterator] to serve objects one at a time.
   *
   * You can iterate over all objects served by an Iterable object
   * using the for-in loop construct.
   * For example, you can iterate over all of the keys in a [Map],
   * because Map keys are iterable.
   *
   *     Map kidsBooks = {'Matilda': 'Roald Dahl',
   *                      'Green Eggs and Ham': 'Dr Seuss',
   *                      'Where the Wild Things Are': 'Maurice Sendak'};
   *     for (var book in kidsBooks.keys) {
   *       print('$book was written by ${kidsBooks[book]}');
   *     }
   *
   * The [List] class and the [Set] class implement this interface,
   * as do classes in the [dart:collection](#dart-collection) library.
   *
   * You can implement Iterable in your own class.
   * If you do, then an instance of your Iterable class
   * can be the right-hand side of a for-in construct.
   */
  abstract class Iterable<E> {
    const Iterable();
  
    /**
     * Creates an Iterable that generates its elements dynamically.
     *
     * The Iterators created by the Iterable count from
     * zero to [:count - 1:] while iterating, and call [generator]
     * with that index to create the next value.
     *
     * As an Iterable, [:new Iterable.generate(n, generator)):] is equivalent to
     * [:const [0, ..., n - 1].map(generator):]
     */
    factory Iterable.generate(int count, E generator(int index)) {
  