Add MapMixin to dart:collection.

sdk/lib/collection/maps.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.
 
 part of dart.collection;
 
 /**
  * Base class for implementing a [Map].
  *
  * This class has a basic implementation of all but five of the members of
  * [Map].
  * A basic `Map` class can be implemented by extending this class and

[kevmoo, 2014/04/29 13:41:11]

While you're at it, add a blank line here, too.

[Lasse Reichstein Nielsen, 2014/04/29 13:52:27]

I wanted this to be part of the same paragraph as the previous line. The "all
but five members" cannot really stand by itself, it needs those members to be
mentioned, and preferably in the same paragraph.

  * implementing `keys`, `operator[]`, `operator[]=`, `remove` and `clear`.
  * The remaining operations are implemented in terms of these five.
  *
  * The `keys` iterable should have efficient [length] and [contains]
  * operations, and it should catch concurrent modifications of the keys
  * while iterating.
  *
  * A more efficient implementation is usually possible by overriding
  * some of the other members as well.
  */
-abstract class MapBase<K, V> implements Map<K, V> {
-  MapBase();  // Prevents use as mixin.
+abstract class MapBase<K, V> = Object with MapMixin<K, V>;
 
+
+/**
+ * Mixin implementing a [Map].
+ *
+ * This mixin has a basic implementation of all but five of the members of
+ * [Map].
+ * A basic `Map` class can be implemented by mixin in this class and

[kevmoo, 2014/04/29 13:41:11]

include a blank line after the first sentence.

+ * implementing `keys`, `operator[]`, `operator[]=`, `remove` and `clear`.
+ * The remaining operations are implemented in terms of these five.
+ *
+ * The `keys` iterable should have efficient [length] and [contains]
+ * operations, and it should catch concurrent modifications of the keys
+ * while iterating.
+ *
+ * A more efficient implementation is usually possible by overriding
+ * some of the other members as well.
+ */
+abstract class MapMixin<K, V> implements Map<K, V> {
   Iterable<K> get keys;
   V operator[](Object key);
   operator []=(K key, V value);
   V remove(Object key);
   // The `clear` operation should not be based on `remove`.
   // It should clear the map even if some keys are not equal to themselves.
   void clear();
 
   void forEach(void action(K key, V value)) {
     for (K key in keys) {
@@ skipping 295 matching lines @@
       map[keyIterator.current] = valueIterator.current;
       hasNextKey = keyIterator.moveNext();
       hasNextValue = valueIterator.moveNext();
     }
 
     if (hasNextKey || hasNextValue) {
       throw new ArgumentError("Iterables do not have same length.");
     }
   }
 }