Fix some bad documentation links.

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 57 matching lines @@
  * This can be implemented by running through the [iterator], but some classes
  * may have more efficient ways of finding the result
  * (like [last] or [length] on a [List], or [contains] on a [Set]).
  *
  * The methods that return another `Iterable` (like [map] and [where])
  * are all *lazy* - they will iterate the original (as necessary)
  * every time the returned iterable is iterated, and not before.
  *
  * Since an iterable may be iterated more than once, it's not recommended to
  * have detectable side-effects in the iterator.
- * For methods like [map] and [while], the returned iterable will execute the
+ * For methods like [map] and [where], the returned iterable will execute the
  * argument function on every iteration, so those functions should also not
  * have side effects.
  */
 abstract class Iterable<E> {
   const Iterable();
 
   /**
    * Creates an `Iterable` which generates its elements dynamically.
    *
    * The generated iterable has [count] elements,
@@ skipping 111 matching lines @@
    *
    * This operation will check each element in order for being equal to
    * [element], unless it has a more efficient way to find an element
    * equal to [element].
    *
    * The equality used to determine whether [element] is equal to an element of
    * the iterable defaults to the [Object.==] of the element.
    *
    * Some types of iterable may have a different equality used for its elements.
    * For example, a [Set] may have a custom equality
-   * (see [Set.identical]) that its `contains` uses.
+   * (see [Set.identity]) that its `contains` uses.
    * Likewise the `Iterable` returned by a [Map.keys] call
    * should use the same equality that the `Map` uses for keys.
    */
   bool contains(Object element) {
     for (E e in this) {
       if (e == element) return true;
     }
     return false;
   }
 
@@ skipping 424 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();
 }