anchor.diff:    Iterable<E> take(int n);
   
     /**
  -   * Returns an [Iterable] that stops once [test] is not satisfied anymore.
  -   *
  -   * The filtering happens lazily. Every new [Iterator] of the returned
  -   * [Iterable] will start iterating over the elements of `this`.
  +   * Returns an Iterable that stops once [test] is not satisfied anymore.
  +   *
  +   * The filtering happens lazily. Every new Iterator of the returned
  +   * Iterable starts iterating over the elements of `this`.
      *
      * When the iterator encounters an element `e` that does not satisfy [test],
  -   * it discards `e` and moves into the finished state. That is, it will not
  -   * ask or provide any more elements.
  +   * it discards `e` and moves into the finished state. That is, it does not
  +   * get or provide any more elements.
      */
     Iterable<E> takeWhile(bool test(E value));
   
     /**
  -   * Returns an [Iterable] that skips the first [n] elements.
  -   *
  -   * If `this` has fewer than [n] elements, then the resulting [Iterable] will
  -   * be empty.
  +   * Returns an Iterable that skips the first [n] elements.
  +   *
  +   * If `this` has fewer than [n] elements, then the resulting Iterable is 
  +   * empty.
      *
      * It is an error if [n] is negative.
      */
     Iterable<E> skip(int n);
   
     /**
  -   * Returns an [Iterable] that skips elements while [test] is satisfied.
  -   *
  -   * The filtering happens lazily. Every new [Iterator] of the returned
  -   * [Iterable] iterates over all elements of `this`.
  +   * Returns an Iterable that skips elements while [test] is satisfied.
  +   *
  +   * The filtering happens lazily. Every new Iterator of the returned
  +   * Iterable iterates over all elements of `this`.
      *
      * As long as the iterator's elements satisfy [test] they are
      * discarded. Once an element does not satisfy the [test] the iterator stops
      * testing and uses every later element unconditionally. That is, the elements
  -   * of the returned [Iterable] are the elements of `this` starting from the
  +   * of the returned Iterable are the elements of `this` starting from the
      * first element that does not satisfy [test].
      */
     Iterable<E> skipWhile(bool test(E value));
  
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:   }
  
    /**
     * Returns an Iterator that iterates over this Iterable object.
     */
    Iterator<E> get iterator;
  
  