Reapply "Rename mappedBy to map."

pkg/serialization/lib/src/serialization_helpers.dart

 // Copyright (c) 2012, 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.
 
 /**
  * This contains extra functions and classes useful for implementing
  * serialiation. Some or all of these will be removed once the functionality is
  * available in the core library.
  */
 library serialization_helpers;
@@ skipping 59 matching lines @@
 
   /** Iterate over the collection, passing both key and value parameters. */
   void forEach(Function f);
 
   /**
    * Return a new collection whose keys are the same as [collection], but whose
    * values are the result of applying [f] to the key/value pairs. So, if
    * [collection] is a List, it will be the same as the map() method if the
    * [key] parameter wasn't passed.
    */
-  mappedBy(Function f) {
+  map(Function f) {
     var result = copyEmpty();
     forEach((key, value) {
        result[key] = f(key, value);
     });
     return result;
   }
 
   /**
    * Return an empty copy of our collection. Very limited, only knows enough
    * to return a Map or List as appropriate.
@@ skipping 33 matching lines @@
  * Only supports forEach() and map() operations because that was all I needed
  * for the moment.
  */
 values(x) {
   if (x is Iterable) return x;
   if (x is Map) return new ListLikeIterable(x);
   throw new ArgumentError("Invalid argument");
 }
 
 mapValues(x, f) {
-  if (x is Set) return x.mappedBy(f).toSet();
-  if (x is Iterable) return x.mappedBy(f).toList();
-  if (x is Map) return new ListLikeIterable(x).mappedBy(f);
+  if (x is Set) return x.map(f).toSet();
+  if (x is Iterable) return x.map(f).toList();
+  if (x is Map) return new ListLikeIterable(x).map(f);
   throw new ArgumentError("Invalid argument");
 }
 
 /**
  * A class for iterating over things as if they were Lists, which primarily
  * means that forEach passes one argument, and map() returns a new Map
  * with the same keys as [collection] and values which haev been transformed
  * by the argument to map().
  */
 class ListLikeIterable {
   ListLikeIterable(this.collection);
   final Map collection;
 
   /** Iterate over the collection, passing just the value parameters. */
   forEach(f) {
       collection.forEach((key, value) => f(value));
   }
 
   /**
    * Return a new collection whose keys are the same as [collection], but whose
    * values are the result of applying [f] to the key/value pairs. So, if
    * [collection] is a List, it will be the same as if map() had been called
    * directly on [collection].
    */
-  mappedBy(Function f) {
+  map(Function f) {
       var result = new Map();
       collection.forEach((key, value) => result[key] = f(value));
       return result;
   }
 
   /**
    * Return an iterator that behaves like a List iterator, taking one parameter.
    */
   Iterator get iterator => collection.values.iterator;
 }
@@ skipping 72 matching lines @@
 
   int get length => keys.length;
   void clear() {
     keys.clear();
     values.clear();
   }
   bool get isEmpty => keys.isEmpty;
 
   // Note that this is doing an equality comparison.
   bool containsValue(x) => values.contains(x);
-}
+}