Fix some Iterable comments.

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;
 
 /**
  * The [Iterable] interface allows to get an [Iterator] out of an
  * [Iterable] object.
  *
@@ skipping 34 matching lines @@
    * 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
    * function [f] multiple times on the same element.
    */
   Iterable map(f(E element));
 
   /**
    * Returns a lazy [Iterable] with all elements that satisfy the
-   * predicate [f].
+   * predicate [test].
    *
    * This method returns a view of the mapped elements. As long as the
-   * returned [Iterable] is not iterated over, the supplied function [f] will
+   * 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 [f] multiple times on the same element.
+   * function [test] multiple times on the same element.
    */
-  Iterable<E> where(bool f(E 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.
    */
@@ skipping 31 matching lines @@
    * Example of calculating the sum of an iterable:
    *
    *     iterable.fold(0, (prev, element) => prev + element);
    *
    */
   dynamic fold(var initialValue,
                dynamic combine(var previousValue, E element));
 
   /**
    * Returns true if every elements of this collection satisify the
-   * predicate [f]. Returns `false` otherwise.
+   * predicate [test]. Returns `false` otherwise.
    */
-  bool every(bool f(E element));
+  bool every(bool test(E element));
 
   /**
    * Converts each element to a [String] and concatenates the strings.
    *
    * Converts each element to a [String] by calling [Object.toString] on it.
    * Then concatenates the strings, optionally separated by the [separator]
    * string.
    */
   String join([String separator = ""]) {
     StringBuffer buffer = new StringBuffer();
     buffer.writeAll(this, separator);
     return buffer.toString();
   }
 
   /**
    * Returns true if one element of this collection satisfies the
-   * predicate [f]. Returns false otherwise.
+   * predicate [test]. Returns false otherwise.
    */
-  bool any(bool f(E element));
+  bool any(bool test(E element));
 
   /**
    * Creates a [List] containing the elements of this [Iterable].
    *
    * The elements will be in iteration order. The list is fixed-length
    * if [growable] is false.
    */
   List<E> toList({ bool growable: true });
 
   /**
@@ skipping 72 matching lines @@
   E get last;
 
   /**
    * Returns the single element in `this`.
    *
    * If `this` is empty or has more than one element throws a [StateError].
    */
   E get single;
 
   /**
-   * Returns the first element that satisfies the given predicate [f].
+   * Returns the first element that satisfies the given predicate [test].
    *
    * If none matches, the result of invoking the [orElse] function is
    * returned. By default, when [orElse] is `null`, a [StateError] is
    * thrown.
    */
-  E firstWhere(bool test(E value), { E orElse() });
+  E firstWhere(bool test(E element), { E orElse() });
 
   /**
-   * Returns the last element that satisfies the given predicate [f].
+   * Returns the last element that satisfies the given predicate [test].
    *
    * If none matches, the result of invoking the [orElse] function is
    * returned. By default, when [orElse] is `null`, a [StateError] is
    * thrown.
    */
-  E lastWhere(bool test(E value), {E orElse()});
+  E lastWhere(bool test(E element), {E orElse()});
 
   /**
-   * Returns the single element that satisfies [f]. If no or more than one
+   * Returns the single element that satisfies [test]. If no or more than one
    * element match then a [StateError] is thrown.
    */
-  E singleWhere(bool test(E value));
+  E singleWhere(bool test(E element));
 
   /**
    * Returns the [index]th element.
    *
    * If `this` has fewer than [index] elements throws a [RangeError].
    *
    * Note: if `this` does not have a deterministic iteration order then the
    * function may simply return any element without any iteration if there are
    * at least [index] elements in `this`.
    */
@@ skipping 37 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();
 }