Rename mappedBy to map.

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.
  *
  * This interface is used by the for-in construct to iterate over an
  * [Iterable] object.
  * The for-in construct takes an [Iterable] object at the right-hand
  * side, and calls its [iterator] method to get an [Iterator] on it.
  *
  * A user-defined class that implements the [Iterable] interface can
  * be used as the right-hand side of a for-in construct.
  */
 abstract class Iterable<E> {
   const Iterable();
 
   /**
    * Create an [Iterable] that generates its elements dynamically.
    *
    * The [Iterators] created by the [Iterable] will 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].mappedBy(generator):]
+   * [:const [0, ..., n - 1].map(generator):]
    */
   factory Iterable.generate(int count, E generator(int index)) {
     return new _GeneratorIterable<E>(count, generator);
   }
 
   /**
    * Returns an [Iterator] that iterates over this [Iterable] object.
    */
   Iterator<E> get iterator;
 
   /**
    * Returns a lazy [Iterable] where each element [:e:] of [this] is replaced
    * by the result of [:f(e):].
    *
    * 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 mappedBy(f(E element)) => new MappedIterable<E, dynamic>(this, f);
+  Iterable map(f(E element)) => new MappedIterable<E, dynamic>(this, f);
+
+  /**
+   * Deprecated alias for [map].
+   *
+   * @deprecated
+   */
+  Iterable mappedBy(f(E element)) => map(f);
 
   /**
     * Returns a lazy [Iterable] with all elements that satisfy the
     * predicate [f].
     *
     * 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. 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.
@@ skipping 344 matching lines @@
       _index++;
       return true;
     } else {
       _current = null;
       return false;
     }
   }
 
   E get current => _current;
 }