Create IterableMixinWorkaround and move most of the Collections methods there.

sdk/lib/collection/collections.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;
 
 /**
- * The [Collections] class implements static methods useful when
- * writing a class that implements [Collection] and the [iterator]
- * method.
+ * This class provides default implementations for Iterables (including Lists).
+ *
+ * Once Dart receives Mixins it will be replaced with mixin classes.
  */
-class Collections {
+class IterableMixinWorkaround {
   static bool contains(Iterable iterable, var element) {
     for (final e in iterable) {
       if (element == e) return true;
     }
     return false;
   }
 
   static void forEach(Iterable iterable, void f(o)) {
     for (final e in iterable) {
       f(e);
@@ skipping 156 matching lines @@
     } else {
       buffer.add("${iterator.current}");
       while (iterator.moveNext()) {
         buffer.add(separator);
         buffer.add("${iterator.current}");
       }
     }
     return buffer.toString();
   }
 
-  static String joinList(List<Object> list, [String separator]) {
+  static String joinList(List list, [String separator]) {
     if (list.isEmpty) return "";
     if (list.length == 1) return "${list[0]}";
     StringBuffer buffer = new StringBuffer();
     if (separator == null || separator == "") {
       for (int i = 0; i < list.length; i++) {
         buffer.add("${list[i]}");
       }
     } else {
       buffer.add("${list[0]}");
       for (int i = 1; i < list.length; i++) {
         buffer.add(separator);
         buffer.add("${list[i]}");
       }
     }
     return buffer.toString();
   }
 
+  static Iterable where(Iterable iterable, bool f(var element)) {
+    return new WhereIterable(iterable, f);
+  }
+
+  static List mappedByList(List list, f(var element)) {
+    return new MappedList(list, f);
+  }
+
+  static List takeList(List list, int n) {
+    // The generic type is currently lost. It will be fixed with mixins.
+    return new ListView(list, 0, n);
+  }
+
+  static Iterable takeWhile(Iterable iterable, bool test(var value)) {
+    // The generic type is currently lost. It will be fixed with mixins.
+    return new TakeWhileIterable(iterable, test);
+  }
+
+  static List skipList(List list, int n) {
+    // The generic type is currently lost. It will be fixed with mixins.
+    return new ListView(list, n, null);
+  }
+
+  static Iterable skipWhile(Iterable iterable, bool test(var value)) {
+    // The generic type is currently lost. It will be fixed with mixins.
+    return new SkipWhileIterable(iterable, test);
+  }
+}
+
+/**
+ * The [Collections] class implements static methods useful when
+ * writing a class that implements [Collection] and the [iterator]
+ * method.
+ */
+class Collections {
+  /** Deprecated. Use the same method in [IterableMixinWorkaround] instead.*/
+  static bool contains(Iterable iterable, var element)
+      => IterableMixinWorkaround.contains(iterable, element);
+
+  /** Deprecated. Use the same method in [IterableMixinWorkaround] instead.*/
+  static void forEach(Iterable iterable, void f(o)) {
+    IterableMixinWorkaround.forEach(iterable, f);
+  }
+
+  /** Deprecated. Use the same method in [IterableMixinWorkaround] instead.*/
+  static bool any(Iterable iterable, bool f(o))
+      => IterableMixinWorkaround.any(iterable, f);
+
+  /** Deprecated. Use the same method in [IterableMixinWorkaround] instead.*/
+  static bool every(Iterable iterable, bool f(o))
+      => IterableMixinWorkaround.every(iterable, f);
+
+  /** Deprecated. Use the same method in [IterableMixinWorkaround] instead.*/
+  static dynamic reduce(Iterable iterable,
+                        dynamic initialValue,
+                        dynamic combine(dynamic previousValue, element))
+      => IterableMixinWorkaround.reduce(iterable, initialValue, combine);
+
+  /** Deprecated. Use the same method in [IterableMixinWorkaround] instead.*/
+  static bool isEmpty(Iterable iterable)
+      => IterableMixinWorkaround.isEmpty(iterable);
+
+  /** Deprecated. Use the same method in [IterableMixinWorkaround] instead.*/
+  static dynamic first(Iterable iterable)
+      => IterableMixinWorkaround.first(iterable);
+
+  /** Deprecated. Use the same method in [IterableMixinWorkaround] instead.*/
+  static dynamic last(Iterable iterable)
+      => IterableMixinWorkaround.last(iterable);
+
+  /** Deprecated. Use the same method in [IterableMixinWorkaround] instead.*/
+  static dynamic min(Iterable iterable, [int compare(var a, var b)])
+      => IterableMixinWorkaround.min(iterable, compare);
+
+  /** Deprecated. Use the same method in [IterableMixinWorkaround] instead.*/
+  static dynamic max(Iterable iterable, [int compare(var a, var b)])
+      => IterableMixinWorkaround.max(iterable, compare);
+
+  /** Deprecated. Use the same method in [IterableMixinWorkaround] instead.*/
+  static dynamic single(Iterable iterable)
+      => IterableMixinWorkaround.single(iterable);
+
+  /** Deprecated. Use the same method in [IterableMixinWorkaround] instead.*/
+  static dynamic firstMatching(Iterable iterable,
+                               bool test(dynamic value),
+                               dynamic orElse())
+      => IterableMixinWorkaround.firstMatching(iterable, test, orElse);
+
+  /** Deprecated. Use the same method in [IterableMixinWorkaround] instead.*/
+  static dynamic lastMatching(Iterable iterable,
+                              bool test(dynamic value),
+                              dynamic orElse())
+      => IterableMixinWorkaround.lastMatching(iterable, test, orElse);
+
+  /** Deprecated. Use the same method in [IterableMixinWorkaround] instead.*/
+  static dynamic lastMatchingInList(List list,
+                                    bool test(dynamic value),
+                                    dynamic orElse())
+      => IterableMixinWorkaround.lastMatchingInList(list, test, orElse);
+
+  /** Deprecated. Use the same method in [IterableMixinWorkaround] instead.*/
+  static dynamic singleMatching(Iterable iterable, bool test(dynamic value))
+      => IterableMixinWorkaround.singleMatching(iterable, test);
+
+  /** Deprecated. Use the same method in [IterableMixinWorkaround] instead.*/
+  static dynamic elementAt(Iterable iterable, int index)
+      => IterableMixinWorkaround.elementAt(iterable, index);
+
+  /** Deprecated. Use the same method in [IterableMixinWorkaround] instead.*/
+  static String join(Iterable iterable, [String separator])
+      => IterableMixinWorkaround.join(iterable, separator);
+
+  /** Deprecated. Use the same method in [IterableMixinWorkaround] instead.*/
+  static String joinList(List list, [String separator])
+      => IterableMixinWorkaround.joinList(list, separator);
+
+  /** Deprecated. Use the same method in [IterableMixinWorkaround] instead.*/
+  static Iterable where(Iterable iterable, bool f(var element))
+      => IterableMixinWorkaround.where(iterable, f);
+
+  /** Deprecated. Use the same method in [IterableMixinWorkaround] instead.*/
+  static List mappedByList(List list, f(var element))
+      => IterableMixinWorkaround.mappedByList(list, f);
+
+  /** Deprecated. Use the same method in [IterableMixinWorkaround] instead.*/
+  static List takeList(List list, int n)
+      => IterableMixinWorkaround.takeList(list, n);
+
+  /** Deprecated. Use the same method in [IterableMixinWorkaround] instead.*/
+  static Iterable takeWhile(Iterable iterable, bool test(var value))
+      => IterableMixinWorkaround.takeWhile(iterable, test);
+
+  /** Deprecated. Use the same method in [IterableMixinWorkaround] instead.*/
+  static List skipList(List list, int n)
+      => IterableMixinWorkaround.skipList(list, n);
+
+  /** Deprecated. Use the same method in [IterableMixinWorkaround] instead.*/
+  static Iterable skipWhile(Iterable iterable, bool test(var value))
+      => IterableMixinWorkaround.skipWhile(iterable, test);
+
   // TODO(jjb): visiting list should be an identityHashSet when it exists
 
   /**
    * Returns a string representing the specified collection. If the
    * collection is a [List], the returned string looks like this:
    * [:'[element0, element1, ... elementN]':]. The value returned by its
    * [toString] method is used to represent each element. If the specified
    * collection is not a list, the returned string looks like this:
    * [:{element0, element1, ... elementN}:]. In other words, the strings
    * returned for lists are surrounded by square brackets, while the strings
@@ skipping 80 matching lines @@
    * Returns true if the specified collection contains the specified object
    * reference.
    */
   static _containsRef(Collection c, Object ref) {
     for (var e in c) {
       if (identical(e, ref)) return true;
     }
     return false;
   }
 }