Big merge from experimental to bleeding edge.

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;
 
 /**
  * A named function of one argument that just returns it. Useful for using
  * as a default value for a function parameter or other places where you want
  * to concisely provide a function that just returns its argument.
  */
 doNothing(x) => x;
 
 /** Concatenate two lists. Handle the case where one or both might be null. */
 // TODO(alanknight): Remove once issue 5342 is resolved.
-List append(List a, List b) {
+List append(Iterable a, Iterable b) {
   if (a == null) {
     return (b == null) ? [] : new List.from(b);
   }
   if (b == null) return new List.from(a);
   var result = new List.from(a);
   result.addAll(b);
   return result;
 }
 
 /**
- * Return a sorted version of [aCollection], using the default sort criterion.
- * Always returns a List, regardless of the type of [aCollection].
+ * Return a sorted version of [anIterable], using the default sort criterion.
+ * Always returns a List, regardless of the type of [anIterable].
  */
-List sorted(aCollection) {
-  var result = new List.from(aCollection);
+List sorted(anIterable) {
+  var result = new List.from(anIterable);
   result.sort();
   return result;
 }
 
 /** Helper function for PrimitiveRule to tell which objects it applies to. */
 bool isPrimitive(object) {
   return identical(object, null) || object is num || object is String ||
       identical(object, true) || identical(object, false);
 }
 
@@ skipping 51 matching lines @@
   MapLikeIterableForMap(collection) : super(collection);
 
   void forEach(Function f) { collection.forEach(f);}
   Map copyEmpty() => new Map();
 }
 
 class MapLikeIterableForList extends MapLikeIterable {
   MapLikeIterableForList(collection) : super(collection);
 
   void forEach(f) {
-    Iterator iterator = collection.iterator();
+    Iterator iterator = collection.iterator;
     for (var i = 0; i < collection.length; i++) {
-      f(i, iterator.next());
+      iterator.moveNext();
+      f(i, iterator.current);
     }
   }
 
   List copyEmpty() => new List(collection.length);
 }
 
 /**
  * An inverse of MapLikeIterable. Lets you iterate polymorphically between
  * List-like and Map-like things, but making them behave like Lists, instead
  * of behaving like Maps.
  * So values(["a", "b", "c"]).forEach((value) => ...);
  * will loop over the values "a", "b", "c", as if it were a List of values.
  * 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).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;
 
@@ skipping 10 matching lines @@
    */
   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 iterator() => collection.values.iterator();
+  Iterator get iterator => collection.values.iterator;
 }
 
 /**
  * This acts as a stand-in for some value that cannot be hashed. We can't
  * just use const Object() because the compiler will fold them together.
  */
 class _Sentinel {
   final _wrappedObject;
   const _Sentinel(this._wrappedObject);
 }
@@ skipping 64 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);
 }