Misc updates (mostly doc)

tool/input_sdk/lib/core/iterable.dart

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart.core;
 
 /**
  * A collection of values, or "elements", that can be accessed sequentially.
  *
  * The elements of the iterable are accessed by getting an [Iterator]
@@ skipping 128 matching lines @@
    */
   Iterator<E> get iterator;
 
   /**
    * Returns a new lazy [Iterable] with elements that are created by
    * calling `f` on each element of this `Iterable` in iteration order.
    *
    * This method returns a view of the mapped elements. As long as the
    * returned [Iterable] is not iterated over, the supplied function [f] will
    * not be invoked. The transformed elements will not be cached. Iterating
-   * multiple times over the the returned [Iterable] will invoke the supplied
+   * multiple times over the returned [Iterable] will invoke the supplied
    * function [f] multiple times on the same element.
    *
    * Methods on the returned iterable are allowed to omit calling `f`
    * on any element where the result isn't needed.
    * For example, [elementAt] may call `f` only once.
    */
   Iterable/*<T>*/ map/*<T>*/(/*=T*/ f(E e)) =>
       new MappedIterable<E, dynamic/*=T*/>(this, f);
 
   /**
    * Returns a new lazy [Iterable] with all elements that satisfy the
    * predicate [test].
    *
    * The matching elements have the same order in the returned iterable
    * as they have in [iterator].
    *
    * 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 returned [Iterable] will invoke the supplied
    * function [test] multiple times on the same element.
    */
-  Iterable<E> where(bool f(E element)) => new WhereIterable<E>(this, f);
+  Iterable<E> where(bool test(E element)) =>
+      new WhereIterable<E>(this, test);
 
   /**
    * Expands each element of this [Iterable] into zero or more elements.
    *
    * The resulting Iterable runs through the elements returned
    * by [f] for each element of this, in iteration order.
    *
    * The returned [Iterable] is lazy, and calls [f] for each element
    * of this every time it's iterated.
    */
@@ skipping 244 matching lines @@
   /**
    * Returns an Iterable that skips leading elements while [test] is satisfied.
    *
    * The filtering happens lazily. Every new Iterator of the returned
    * Iterable iterates over all elements of `this`.
    *
    * The returned iterable provides elements by iterating this iterable,
    * but skipping over all initial elements where `test(element)` returns
    * true. If all elements satisfy `test` the resulting iterable is empty,
    * otherwise it iterates the remaining elements in their original order,
-   * starting with the first element for which `test(element)` returns false,
+   * starting with the first element for which `test(element)` returns false.
    */
   Iterable<E> skipWhile(bool test(E value)) {
     return new SkipWhileIterable<E>(this, test);
   }
 
   /**
    * Returns the first element.
    *
    * Throws a [StateError] if `this` is empty.
    * Otherwise returns the first element in the iteration order,
@@ skipping 225 matching lines @@
  */
 abstract class BidirectionalIterator<E> implements Iterator<E> {
   /**
    * Move back to the previous element.
    *
    * Returns true and updates [current] if successful. Returns false
    * and sets [current] to null if there is no previous element.
    */
   bool movePrevious();
 }