Revert "Create IterableMixinWorkaround and move most of the Collections methods there."

sdk/lib/html/dartium/html_dartium.dart

Index: sdk/lib/html/dartium/html_dartium.dart
diff --git a/sdk/lib/html/dartium/html_dartium.dart b/sdk/lib/html/dartium/html_dartium.dart
index d1ccbd499407329b49250033292b6269ce6b2c2e..4d6e224f2277fa5c4216f45e39f2bc68730980c2 100644
--- a/sdk/lib/html/dartium/html_dartium.dart
+++ b/sdk/lib/html/dartium/html_dartium.dart
@@ -7741,50 +7741,50 @@ class DomMimeTypeArray extends NativeFieldWrapperClass1 implements List<DomMimeT
   }
 
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, DomMimeType)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+    return Collections.reduce(this, initialValue, combine);
   }
 
-  bool contains(DomMimeType element) => IterableMixinWorkaround.contains(this, element);
+  bool contains(DomMimeType element) => Collections.contains(this, element);
 
-  void forEach(void f(DomMimeType element)) => IterableMixinWorkaround.forEach(this, f);
+  void forEach(void f(DomMimeType element)) => Collections.forEach(this, f);
 
-  String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  List mappedBy(f(DomMimeType element)) => IterableMixinWorkaround.mappedByList(this, f);
+  List mappedBy(f(DomMimeType element)) => new MappedList<DomMimeType, dynamic>(this, f);
 
-  Iterable<DomMimeType> where(bool f(DomMimeType element)) => IterableMixinWorkaround.where(this, f);
+  Iterable<DomMimeType> where(bool f(DomMimeType element)) => new WhereIterable<DomMimeType>(this, f);
 
-  bool every(bool f(DomMimeType element)) => IterableMixinWorkaround.every(this, f);
+  bool every(bool f(DomMimeType element)) => Collections.every(this, f);
 
-  bool any(bool f(DomMimeType element)) => IterableMixinWorkaround.any(this, f);
+  bool any(bool f(DomMimeType element)) => Collections.any(this, f);
 
   List<DomMimeType> toList() => new List<DomMimeType>.from(this);
   Set<DomMimeType> toSet() => new Set<DomMimeType>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<DomMimeType> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  List<DomMimeType> take(int n) => new ListView<DomMimeType>(this, 0, n);
 
   Iterable<DomMimeType> takeWhile(bool test(DomMimeType value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new TakeWhileIterable<DomMimeType>(this, test);
   }
 
-  List<DomMimeType> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  List<DomMimeType> skip(int n) => new ListView<DomMimeType>(this, n, null);
 
   Iterable<DomMimeType> skipWhile(bool test(DomMimeType value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new SkipWhileIterable<DomMimeType>(this, test);
   }
 
   DomMimeType firstMatching(bool test(DomMimeType value), { DomMimeType orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+    return Collections.firstMatching(this, test, orElse);
   }
 
   DomMimeType lastMatching(bool test(DomMimeType value), {DomMimeType orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+    return Collections.lastMatchingInList(this, test, orElse);
   }
 
   DomMimeType singleMatching(bool test(DomMimeType value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+    return Collections.singleMatching(this, test);
   }
 
   DomMimeType elementAt(int index) {
@@ -7842,9 +7842,9 @@ class DomMimeTypeArray extends NativeFieldWrapperClass1 implements List<DomMimeT
     throw new StateError("More than one element");
   }
 
-  DomMimeType min([int compare(DomMimeType a, DomMimeType b)]) => IterableMixinWorkaround.min(this, compare);
+  DomMimeType min([int compare(DomMimeType a, DomMimeType b)]) => Collections.min(this, compare);
 
-  DomMimeType max([int compare(DomMimeType a, DomMimeType b)]) => IterableMixinWorkaround.max(this, compare);
+  DomMimeType max([int compare(DomMimeType a, DomMimeType b)]) => Collections.max(this, compare);
 
   DomMimeType removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
@@ -7972,50 +7972,50 @@ class DomPluginArray extends NativeFieldWrapperClass1 implements List<DomPlugin>
   }
 
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, DomPlugin)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+    return Collections.reduce(this, initialValue, combine);
   }
 
-  bool contains(DomPlugin element) => IterableMixinWorkaround.contains(this, element);
+  bool contains(DomPlugin element) => Collections.contains(this, element);
 
-  void forEach(void f(DomPlugin element)) => IterableMixinWorkaround.forEach(this, f);
+  void forEach(void f(DomPlugin element)) => Collections.forEach(this, f);
 
-  String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  List mappedBy(f(DomPlugin element)) => IterableMixinWorkaround.mappedByList(this, f);
+  List mappedBy(f(DomPlugin element)) => new MappedList<DomPlugin, dynamic>(this, f);
 
-  Iterable<DomPlugin> where(bool f(DomPlugin element)) => IterableMixinWorkaround.where(this, f);
+  Iterable<DomPlugin> where(bool f(DomPlugin element)) => new WhereIterable<DomPlugin>(this, f);
 
-  bool every(bool f(DomPlugin element)) => IterableMixinWorkaround.every(this, f);
+  bool every(bool f(DomPlugin element)) => Collections.every(this, f);
 
-  bool any(bool f(DomPlugin element)) => IterableMixinWorkaround.any(this, f);
+  bool any(bool f(DomPlugin element)) => Collections.any(this, f);
 
   List<DomPlugin> toList() => new List<DomPlugin>.from(this);
   Set<DomPlugin> toSet() => new Set<DomPlugin>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<DomPlugin> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  List<DomPlugin> take(int n) => new ListView<DomPlugin>(this, 0, n);
 
   Iterable<DomPlugin> takeWhile(bool test(DomPlugin value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new TakeWhileIterable<DomPlugin>(this, test);
   }
 
-  List<DomPlugin> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  List<DomPlugin> skip(int n) => new ListView<DomPlugin>(this, n, null);
 
   Iterable<DomPlugin> skipWhile(bool test(DomPlugin value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new SkipWhileIterable<DomPlugin>(this, test);
   }
 
   DomPlugin firstMatching(bool test(DomPlugin value), { DomPlugin orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+    return Collections.firstMatching(this, test, orElse);
   }
 
   DomPlugin lastMatching(bool test(DomPlugin value), {DomPlugin orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+    return Collections.lastMatchingInList(this, test, orElse);
   }
 
   DomPlugin singleMatching(bool test(DomPlugin value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+    return Collections.singleMatching(this, test);
   }
 
   DomPlugin elementAt(int index) {
@@ -8073,9 +8073,9 @@ class DomPluginArray extends NativeFieldWrapperClass1 implements List<DomPlugin>
     throw new StateError("More than one element");
   }
 
-  DomPlugin min([int compare(DomPlugin a, DomPlugin b)]) => IterableMixinWorkaround.min(this, compare);
+  DomPlugin min([int compare(DomPlugin a, DomPlugin b)]) => Collections.min(this, compare);
 
-  DomPlugin max([int compare(DomPlugin a, DomPlugin b)]) => IterableMixinWorkaround.max(this, compare);
+  DomPlugin max([int compare(DomPlugin a, DomPlugin b)]) => Collections.max(this, compare);
 
   DomPlugin removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
@@ -8287,50 +8287,50 @@ class DomStringList extends NativeFieldWrapperClass1 implements List<String> {
   }
 
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, String)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+    return Collections.reduce(this, initialValue, combine);
   }
 
   // contains() defined by IDL.
 
-  void forEach(void f(String element)) => IterableMixinWorkaround.forEach(this, f);
+  void forEach(void f(String element)) => Collections.forEach(this, f);
 
-  String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  List mappedBy(f(String element)) => IterableMixinWorkaround.mappedByList(this, f);
+  List mappedBy(f(String element)) => new MappedList<String, dynamic>(this, f);
 
-  Iterable<String> where(bool f(String element)) => IterableMixinWorkaround.where(this, f);
+  Iterable<String> where(bool f(String element)) => new WhereIterable<String>(this, f);
 
-  bool every(bool f(String element)) => IterableMixinWorkaround.every(this, f);
+  bool every(bool f(String element)) => Collections.every(this, f);
 
-  bool any(bool f(String element)) => IterableMixinWorkaround.any(this, f);
+  bool any(bool f(String element)) => Collections.any(this, f);
 
   List<String> toList() => new List<String>.from(this);
   Set<String> toSet() => new Set<String>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<String> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  List<String> take(int n) => new ListView<String>(this, 0, n);
 
   Iterable<String> takeWhile(bool test(String value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new TakeWhileIterable<String>(this, test);
   }
 
-  List<String> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  List<String> skip(int n) => new ListView<String>(this, n, null);
 
   Iterable<String> skipWhile(bool test(String value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new SkipWhileIterable<String>(this, test);
   }
 
   String firstMatching(bool test(String value), { String orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+    return Collections.firstMatching(this, test, orElse);
   }
 
   String lastMatching(bool test(String value), {String orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+    return Collections.lastMatchingInList(this, test, orElse);
   }
 
   String singleMatching(bool test(String value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+    return Collections.singleMatching(this, test);
   }
 
   String elementAt(int index) {
@@ -8388,9 +8388,9 @@ class DomStringList extends NativeFieldWrapperClass1 implements List<String> {
     throw new StateError("More than one element");
   }
 
-  String min([int compare(String a, String b)]) => IterableMixinWorkaround.min(this, compare);
+  String min([int compare(String a, String b)]) => Collections.min(this, compare);
 
-  String max([int compare(String a, String b)]) => IterableMixinWorkaround.max(this, compare);
+  String max([int compare(String a, String b)]) => Collections.max(this, compare);
 
   String removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
@@ -8542,47 +8542,46 @@ class _ChildrenElementList implements List {
   }
 
   String join([String separator]) {
-    return IterableMixinWorkaround.joinList(this, separator);
+    return Collections.joinList(this, separator);
   }
 
   List mappedBy(f(Element element)) {
-    return IterableMixinWorkaround.mappedByList(this, f);
+    return new MappedList<Element, dynamic>(this, f);
   }
 
-  Iterable<Element> where(bool f(Element element)) {
-    return IterableMixinWorkaround.where(this, f);
-  }
+  Iterable<Element> where(bool f(Element element))
+      => new WhereIterable(this, f);
 
   bool get isEmpty {
     return _element.$dom_firstElementChild == null;
   }
 
   List<Element> take(int n) {
-    return IterableMixinWorkaround.takeList(this, n);
+    return new ListView<Element>(this, 0, n);
   }
 
   Iterable<Element> takeWhile(bool test(Element value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new TakeWhileIterable<Element>(this, test);
   }
 
   List<Element> skip(int n) {
-    return IterableMixinWorkaround.skipList(this, n);
+    return new ListView<Element>(this, n, null);
   }
 
   Iterable<Element> skipWhile(bool test(Element value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new SkipWhileIterable<Element>(this, test);
   }
 
   Element firstMatching(bool test(Element value), {Element orElse()}) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+    return Collections.firstMatching(this, test, orElse);
   }
 
   Element lastMatching(bool test(Element value), {Element orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+    return Collections.lastMatchingInList(this, test, orElse);
   }
 
   Element singleMatching(bool test(Element value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+    return Collections.singleMatching(this, test);
   }
 
   Element elementAt(int index) {
@@ -8627,7 +8626,7 @@ class _ChildrenElementList implements List {
 
   dynamic reduce(dynamic initialValue,
       dynamic combine(dynamic previousValue, Element element)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+    return Collections.reduce(this, initialValue, combine);
   }
 
   void setRange(int start, int rangeLength, List from, [int startFrom = 0]) {
@@ -8695,11 +8694,11 @@ class _ChildrenElementList implements List {
   }
 
   Element min([int compare(Element a, Element b)]) {
-    return IterableMixinWorkaround.min(this, compare);
+    return Collections.min(this, compare);
   }
 
   Element max([int compare(Element a, Element b)]) {
-    return IterableMixinWorkaround.max(this, compare);
+    return Collections.max(this, compare);
   }
 }
 
@@ -8726,16 +8725,15 @@ class _FrozenElementList implements List {
   }
 
   String join([String separator]) {
-    return IterableMixinWorkaround.joinList(this, separator);
+    return Collections.joinList(this, separator);
   }
 
   List mappedBy(f(Element element)) {
-    return IterableMixinWorkaround.mappedByList(this, f);
+    return new MappedList<Element, dynamic>(this, f);
   }
 
-  Iterable<Element> where(bool f(Element element)) {
-    return IterableMixinWorkaround.where(this, f);
-  }
+  Iterable<Element> where(bool f(Element element))
+      => new WhereIterable(this, f);
 
   bool every(bool f(Element element)) {
     for(Element element in this) {
@@ -8759,31 +8757,31 @@ class _FrozenElementList implements List {
   Set<Element> toSet() => new Set<Element>.from(this);
 
   List<Element> take(int n) {
-    return IterableMixinWorkaround.takeList(this, n);
+    return new ListView<Element>(this, 0, n);
   }
 
   Iterable<Element> takeWhile(bool test(Element value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new TakeWhileIterable<Element>(this, test);
   }
 
   List<Element> skip(int n) {
-    return IterableMixinWorkaround.skipList(this, n);
+    return new ListView<Element>(this, n, null);
   }
 
   Iterable<Element> skipWhile(bool test(Element value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new SkipWhileIterable<Element>(this, test);
   }
 
   Element firstMatching(bool test(Element value), {Element orElse()}) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+    return Collections.firstMatching(this, test, orElse);
   }
 
   Element lastMatching(bool test(Element value), {Element orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+    return Collections.lastMatchingInList(this, test, orElse);
   }
 
   Element singleMatching(bool test(Element value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+    return Collections.singleMatching(this, test);
   }
 
   Element elementAt(int index) {
@@ -8824,7 +8822,7 @@ class _FrozenElementList implements List {
 
   dynamic reduce(dynamic initialValue,
       dynamic combine(dynamic previousValue, Element element)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+    return Collections.reduce(this, initialValue, combine);
   }
 
   void setRange(int start, int rangeLength, List from, [int startFrom = 0]) {
@@ -8867,11 +8865,11 @@ class _FrozenElementList implements List {
   Element get single => _nodeList.single;
 
   Element min([int compare(Element a, Element b)]) {
-    return IterableMixinWorkaround.min(this, compare);
+    return Collections.min(this, compare);
   }
 
   Element max([int compare(Element a, Element b)]) {
-    return IterableMixinWorkaround.max(this, compare);
+    return Collections.max(this, compare);
   }
 }
 
@@ -10880,50 +10878,50 @@ class FileList extends NativeFieldWrapperClass1 implements List<File> {
   }
 
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, File)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+    return Collections.reduce(this, initialValue, combine);
   }
 
-  bool contains(File element) => IterableMixinWorkaround.contains(this, element);
+  bool contains(File element) => Collections.contains(this, element);
 
-  void forEach(void f(File element)) => IterableMixinWorkaround.forEach(this, f);
+  void forEach(void f(File element)) => Collections.forEach(this, f);
 
-  String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  List mappedBy(f(File element)) => IterableMixinWorkaround.mappedByList(this, f);
+  List mappedBy(f(File element)) => new MappedList<File, dynamic>(this, f);
 
-  Iterable<File> where(bool f(File element)) => IterableMixinWorkaround.where(this, f);
+  Iterable<File> where(bool f(File element)) => new WhereIterable<File>(this, f);
 
-  bool every(bool f(File element)) => IterableMixinWorkaround.every(this, f);
+  bool every(bool f(File element)) => Collections.every(this, f);
 
-  bool any(bool f(File element)) => IterableMixinWorkaround.any(this, f);
+  bool any(bool f(File element)) => Collections.any(this, f);
 
   List<File> toList() => new List<File>.from(this);
   Set<File> toSet() => new Set<File>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<File> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  List<File> take(int n) => new ListView<File>(this, 0, n);
 
   Iterable<File> takeWhile(bool test(File value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new TakeWhileIterable<File>(this, test);
   }
 
-  List<File> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  List<File> skip(int n) => new ListView<File>(this, n, null);
 
   Iterable<File> skipWhile(bool test(File value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new SkipWhileIterable<File>(this, test);
   }
 
   File firstMatching(bool test(File value), { File orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+    return Collections.firstMatching(this, test, orElse);
   }
 
   File lastMatching(bool test(File value), {File orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+    return Collections.lastMatchingInList(this, test, orElse);
   }
 
   File singleMatching(bool test(File value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+    return Collections.singleMatching(this, test);
   }
 
   File elementAt(int index) {
@@ -10981,9 +10979,9 @@ class FileList extends NativeFieldWrapperClass1 implements List<File> {
     throw new StateError("More than one element");
   }
 
-  File min([int compare(File a, File b)]) => IterableMixinWorkaround.min(this, compare);
+  File min([int compare(File a, File b)]) => Collections.min(this, compare);
 
-  File max([int compare(File a, File b)]) => IterableMixinWorkaround.max(this, compare);
+  File max([int compare(File a, File b)]) => Collections.max(this, compare);
 
   File removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
@@ -11448,50 +11446,50 @@ class Float32Array extends ArrayBufferView implements List<num> {
   }
 
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, num)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+    return Collections.reduce(this, initialValue, combine);
   }
 
-  bool contains(num element) => IterableMixinWorkaround.contains(this, element);
+  bool contains(num element) => Collections.contains(this, element);
 
-  void forEach(void f(num element)) => IterableMixinWorkaround.forEach(this, f);
+  void forEach(void f(num element)) => Collections.forEach(this, f);
 
-  String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  List mappedBy(f(num element)) => IterableMixinWorkaround.mappedByList(this, f);
+  List mappedBy(f(num element)) => new MappedList<num, dynamic>(this, f);
 
-  Iterable<num> where(bool f(num element)) => IterableMixinWorkaround.where(this, f);
+  Iterable<num> where(bool f(num element)) => new WhereIterable<num>(this, f);
 
-  bool every(bool f(num element)) => IterableMixinWorkaround.every(this, f);
+  bool every(bool f(num element)) => Collections.every(this, f);
 
-  bool any(bool f(num element)) => IterableMixinWorkaround.any(this, f);
+  bool any(bool f(num element)) => Collections.any(this, f);
 
   List<num> toList() => new List<num>.from(this);
   Set<num> toSet() => new Set<num>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<num> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  List<num> take(int n) => new ListView<num>(this, 0, n);
 
   Iterable<num> takeWhile(bool test(num value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new TakeWhileIterable<num>(this, test);
   }
 
-  List<num> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  List<num> skip(int n) => new ListView<num>(this, n, null);
 
   Iterable<num> skipWhile(bool test(num value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new SkipWhileIterable<num>(this, test);
   }
 
   num firstMatching(bool test(num value), { num orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+    return Collections.firstMatching(this, test, orElse);
   }
 
   num lastMatching(bool test(num value), {num orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+    return Collections.lastMatchingInList(this, test, orElse);
   }
 
   num singleMatching(bool test(num value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+    return Collections.singleMatching(this, test);
   }
 
   num elementAt(int index) {
@@ -11549,9 +11547,9 @@ class Float32Array extends ArrayBufferView implements List<num> {
     throw new StateError("More than one element");
   }
 
-  num min([int compare(num a, num b)]) => IterableMixinWorkaround.min(this, compare);
+  num min([int compare(num a, num b)]) => Collections.min(this, compare);
 
-  num max([int compare(num a, num b)]) => IterableMixinWorkaround.max(this, compare);
+  num max([int compare(num a, num b)]) => Collections.max(this, compare);
 
   num removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
@@ -11645,50 +11643,50 @@ class Float64Array extends ArrayBufferView implements List<num> {
   }
 
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, num)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+    return Collections.reduce(this, initialValue, combine);
   }
 
-  bool contains(num element) => IterableMixinWorkaround.contains(this, element);
+  bool contains(num element) => Collections.contains(this, element);
 
-  void forEach(void f(num element)) => IterableMixinWorkaround.forEach(this, f);
+  void forEach(void f(num element)) => Collections.forEach(this, f);
 
-  String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  List mappedBy(f(num element)) => IterableMixinWorkaround.mappedByList(this, f);
+  List mappedBy(f(num element)) => new MappedList<num, dynamic>(this, f);
 
-  Iterable<num> where(bool f(num element)) => IterableMixinWorkaround.where(this, f);
+  Iterable<num> where(bool f(num element)) => new WhereIterable<num>(this, f);
 
-  bool every(bool f(num element)) => IterableMixinWorkaround.every(this, f);
+  bool every(bool f(num element)) => Collections.every(this, f);
 
-  bool any(bool f(num element)) => IterableMixinWorkaround.any(this, f);
+  bool any(bool f(num element)) => Collections.any(this, f);
 
   List<num> toList() => new List<num>.from(this);
   Set<num> toSet() => new Set<num>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<num> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  List<num> take(int n) => new ListView<num>(this, 0, n);
 
   Iterable<num> takeWhile(bool test(num value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new TakeWhileIterable<num>(this, test);
   }
 
-  List<num> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  List<num> skip(int n) => new ListView<num>(this, n, null);
 
   Iterable<num> skipWhile(bool test(num value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new SkipWhileIterable<num>(this, test);
   }
 
   num firstMatching(bool test(num value), { num orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+    return Collections.firstMatching(this, test, orElse);
   }
 
   num lastMatching(bool test(num value), {num orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+    return Collections.lastMatchingInList(this, test, orElse);
   }
 
   num singleMatching(bool test(num value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+    return Collections.singleMatching(this, test);
   }
 
   num elementAt(int index) {
@@ -11746,9 +11744,9 @@ class Float64Array extends ArrayBufferView implements List<num> {
     throw new StateError("More than one element");
   }
 
-  num min([int compare(num a, num b)]) => IterableMixinWorkaround.min(this, compare);
+  num min([int compare(num a, num b)]) => Collections.min(this, compare);
 
-  num max([int compare(num a, num b)]) => IterableMixinWorkaround.max(this, compare);
+  num max([int compare(num a, num b)]) => Collections.max(this, compare);
 
   num removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
@@ -12184,50 +12182,50 @@ class HtmlAllCollection extends NativeFieldWrapperClass1 implements List<Node> {
   }
 
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, Node)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+    return Collections.reduce(this, initialValue, combine);
   }
 
-  bool contains(Node element) => IterableMixinWorkaround.contains(this, element);
+  bool contains(Node element) => Collections.contains(this, element);
 
-  void forEach(void f(Node element)) => IterableMixinWorkaround.forEach(this, f);
+  void forEach(void f(Node element)) => Collections.forEach(this, f);
 
-  String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  List mappedBy(f(Node element)) => IterableMixinWorkaround.mappedByList(this, f);
+  List mappedBy(f(Node element)) => new MappedList<Node, dynamic>(this, f);
 
-  Iterable<Node> where(bool f(Node element)) => IterableMixinWorkaround.where(this, f);
+  Iterable<Node> where(bool f(Node element)) => new WhereIterable<Node>(this, f);
 
-  bool every(bool f(Node element)) => IterableMixinWorkaround.every(this, f);
+  bool every(bool f(Node element)) => Collections.every(this, f);
 
-  bool any(bool f(Node element)) => IterableMixinWorkaround.any(this, f);
+  bool any(bool f(Node element)) => Collections.any(this, f);
 
   List<Node> toList() => new List<Node>.from(this);
   Set<Node> toSet() => new Set<Node>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<Node> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  List<Node> take(int n) => new ListView<Node>(this, 0, n);
 
   Iterable<Node> takeWhile(bool test(Node value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new TakeWhileIterable<Node>(this, test);
   }
 
-  List<Node> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  List<Node> skip(int n) => new ListView<Node>(this, n, null);
 
   Iterable<Node> skipWhile(bool test(Node value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new SkipWhileIterable<Node>(this, test);
   }
 
   Node firstMatching(bool test(Node value), { Node orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+    return Collections.firstMatching(this, test, orElse);
   }
 
   Node lastMatching(bool test(Node value), {Node orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+    return Collections.lastMatchingInList(this, test, orElse);
   }
 
   Node singleMatching(bool test(Node value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+    return Collections.singleMatching(this, test);
   }
 
   Node elementAt(int index) {
@@ -12285,9 +12283,9 @@ class HtmlAllCollection extends NativeFieldWrapperClass1 implements List<Node> {
     throw new StateError("More than one element");
   }
 
-  Node min([int compare(Node a, Node b)]) => IterableMixinWorkaround.min(this, compare);
+  Node min([int compare(Node a, Node b)]) => Collections.min(this, compare);
 
-  Node max([int compare(Node a, Node b)]) => IterableMixinWorkaround.max(this, compare);
+  Node max([int compare(Node a, Node b)]) => Collections.max(this, compare);
 
   Node removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
@@ -12361,50 +12359,50 @@ class HtmlCollection extends NativeFieldWrapperClass1 implements List<Node> {
   }
 
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, Node)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+    return Collections.reduce(this, initialValue, combine);
   }
 
-  bool contains(Node element) => IterableMixinWorkaround.contains(this, element);
+  bool contains(Node element) => Collections.contains(this, element);
 
-  void forEach(void f(Node element)) => IterableMixinWorkaround.forEach(this, f);
+  void forEach(void f(Node element)) => Collections.forEach(this, f);
 
-  String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  List mappedBy(f(Node element)) => IterableMixinWorkaround.mappedByList(this, f);
+  List mappedBy(f(Node element)) => new MappedList<Node, dynamic>(this, f);
 
-  Iterable<Node> where(bool f(Node element)) => IterableMixinWorkaround.where(this, f);
+  Iterable<Node> where(bool f(Node element)) => new WhereIterable<Node>(this, f);
 
-  bool every(bool f(Node element)) => IterableMixinWorkaround.every(this, f);
+  bool every(bool f(Node element)) => Collections.every(this, f);
 
-  bool any(bool f(Node element)) => IterableMixinWorkaround.any(this, f);
+  bool any(bool f(Node element)) => Collections.any(this, f);
 
   List<Node> toList() => new List<Node>.from(this);
   Set<Node> toSet() => new Set<Node>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<Node> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  List<Node> take(int n) => new ListView<Node>(this, 0, n);
 
   Iterable<Node> takeWhile(bool test(Node value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new TakeWhileIterable<Node>(this, test);
   }
 
-  List<Node> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  List<Node> skip(int n) => new ListView<Node>(this, n, null);
 
   Iterable<Node> skipWhile(bool test(Node value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new SkipWhileIterable<Node>(this, test);
   }
 
   Node firstMatching(bool test(Node value), { Node orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+    return Collections.firstMatching(this, test, orElse);
   }
 
   Node lastMatching(bool test(Node value), {Node orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+    return Collections.lastMatchingInList(this, test, orElse);
   }
 
   Node singleMatching(bool test(Node value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+    return Collections.singleMatching(this, test);
   }
 
   Node elementAt(int index) {
@@ -12462,9 +12460,9 @@ class HtmlCollection extends NativeFieldWrapperClass1 implements List<Node> {
     throw new StateError("More than one element");
   }
 
-  Node min([int compare(Node a, Node b)]) => IterableMixinWorkaround.min(this, compare);
+  Node min([int compare(Node a, Node b)]) => Collections.min(this, compare);
 
-  Node max([int compare(Node a, Node b)]) => IterableMixinWorkaround.max(this, compare);
+  Node max([int compare(Node a, Node b)]) => Collections.max(this, compare);
 
   Node removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
@@ -14373,50 +14371,50 @@ class Int16Array extends ArrayBufferView implements List<int> {
   }
 
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, int)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+    return Collections.reduce(this, initialValue, combine);
   }
 
-  bool contains(int element) => IterableMixinWorkaround.contains(this, element);
+  bool contains(int element) => Collections.contains(this, element);
 
-  void forEach(void f(int element)) => IterableMixinWorkaround.forEach(this, f);
+  void forEach(void f(int element)) => Collections.forEach(this, f);
 
-  String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  List mappedBy(f(int element)) => IterableMixinWorkaround.mappedByList(this, f);
+  List mappedBy(f(int element)) => new MappedList<int, dynamic>(this, f);
 
-  Iterable<int> where(bool f(int element)) => IterableMixinWorkaround.where(this, f);
+  Iterable<int> where(bool f(int element)) => new WhereIterable<int>(this, f);
 
-  bool every(bool f(int element)) => IterableMixinWorkaround.every(this, f);
+  bool every(bool f(int element)) => Collections.every(this, f);
 
-  bool any(bool f(int element)) => IterableMixinWorkaround.any(this, f);
+  bool any(bool f(int element)) => Collections.any(this, f);
 
   List<int> toList() => new List<int>.from(this);
   Set<int> toSet() => new Set<int>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<int> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  List<int> take(int n) => new ListView<int>(this, 0, n);
 
   Iterable<int> takeWhile(bool test(int value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new TakeWhileIterable<int>(this, test);
   }
 
-  List<int> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  List<int> skip(int n) => new ListView<int>(this, n, null);
 
   Iterable<int> skipWhile(bool test(int value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new SkipWhileIterable<int>(this, test);
   }
 
   int firstMatching(bool test(int value), { int orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+    return Collections.firstMatching(this, test, orElse);
   }
 
   int lastMatching(bool test(int value), {int orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+    return Collections.lastMatchingInList(this, test, orElse);
   }
 
   int singleMatching(bool test(int value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+    return Collections.singleMatching(this, test);
   }
 
   int elementAt(int index) {
@@ -14474,9 +14472,9 @@ class Int16Array extends ArrayBufferView implements List<int> {
     throw new StateError("More than one element");
   }
 
-  int min([int compare(int a, int b)]) => IterableMixinWorkaround.min(this, compare);
+  int min([int compare(int a, int b)]) => Collections.min(this, compare);
 
-  int max([int compare(int a, int b)]) => IterableMixinWorkaround.max(this, compare);
+  int max([int compare(int a, int b)]) => Collections.max(this, compare);
 
   int removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
@@ -14570,50 +14568,50 @@ class Int32Array extends ArrayBufferView implements List<int> {
   }
 
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, int)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+    return Collections.reduce(this, initialValue, combine);
   }
 
-  bool contains(int element) => IterableMixinWorkaround.contains(this, element);
+  bool contains(int element) => Collections.contains(this, element);
 
-  void forEach(void f(int element)) => IterableMixinWorkaround.forEach(this, f);
+  void forEach(void f(int element)) => Collections.forEach(this, f);
 
-  String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  List mappedBy(f(int element)) => IterableMixinWorkaround.mappedByList(this, f);
+  List mappedBy(f(int element)) => new MappedList<int, dynamic>(this, f);
 
-  Iterable<int> where(bool f(int element)) => IterableMixinWorkaround.where(this, f);
+  Iterable<int> where(bool f(int element)) => new WhereIterable<int>(this, f);
 
-  bool every(bool f(int element)) => IterableMixinWorkaround.every(this, f);
+  bool every(bool f(int element)) => Collections.every(this, f);
 
-  bool any(bool f(int element)) => IterableMixinWorkaround.any(this, f);
+  bool any(bool f(int element)) => Collections.any(this, f);
 
   List<int> toList() => new List<int>.from(this);
   Set<int> toSet() => new Set<int>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<int> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  List<int> take(int n) => new ListView<int>(this, 0, n);
 
   Iterable<int> takeWhile(bool test(int value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new TakeWhileIterable<int>(this, test);
   }
 
-  List<int> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  List<int> skip(int n) => new ListView<int>(this, n, null);
 
   Iterable<int> skipWhile(bool test(int value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new SkipWhileIterable<int>(this, test);
   }
 
   int firstMatching(bool test(int value), { int orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+    return Collections.firstMatching(this, test, orElse);
   }
 
   int lastMatching(bool test(int value), {int orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+    return Collections.lastMatchingInList(this, test, orElse);
   }
 
   int singleMatching(bool test(int value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+    return Collections.singleMatching(this, test);
   }
 
   int elementAt(int index) {
@@ -14671,9 +14669,9 @@ class Int32Array extends ArrayBufferView implements List<int> {
     throw new StateError("More than one element");
   }
 
-  int min([int compare(int a, int b)]) => IterableMixinWorkaround.min(this, compare);
+  int min([int compare(int a, int b)]) => Collections.min(this, compare);
 
-  int max([int compare(int a, int b)]) => IterableMixinWorkaround.max(this, compare);
+  int max([int compare(int a, int b)]) => Collections.max(this, compare);
 
   int removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
@@ -14767,50 +14765,50 @@ class Int8Array extends ArrayBufferView implements List<int> {
   }
 
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, int)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+    return Collections.reduce(this, initialValue, combine);
   }
 
-  bool contains(int element) => IterableMixinWorkaround.contains(this, element);
+  bool contains(int element) => Collections.contains(this, element);
 
-  void forEach(void f(int element)) => IterableMixinWorkaround.forEach(this, f);
+  void forEach(void f(int element)) => Collections.forEach(this, f);
 
-  String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  List mappedBy(f(int element)) => IterableMixinWorkaround.mappedByList(this, f);
+  List mappedBy(f(int element)) => new MappedList<int, dynamic>(this, f);
 
-  Iterable<int> where(bool f(int element)) => IterableMixinWorkaround.where(this, f);
+  Iterable<int> where(bool f(int element)) => new WhereIterable<int>(this, f);
 
-  bool every(bool f(int element)) => IterableMixinWorkaround.every(this, f);
+  bool every(bool f(int element)) => Collections.every(this, f);
 
-  bool any(bool f(int element)) => IterableMixinWorkaround.any(this, f);
+  bool any(bool f(int element)) => Collections.any(this, f);
 
   List<int> toList() => new List<int>.from(this);
   Set<int> toSet() => new Set<int>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<int> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  List<int> take(int n) => new ListView<int>(this, 0, n);
 
   Iterable<int> takeWhile(bool test(int value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new TakeWhileIterable<int>(this, test);
   }
 
-  List<int> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  List<int> skip(int n) => new ListView<int>(this, n, null);
 
   Iterable<int> skipWhile(bool test(int value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new SkipWhileIterable<int>(this, test);
   }
 
   int firstMatching(bool test(int value), { int orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+    return Collections.firstMatching(this, test, orElse);
   }
 
   int lastMatching(bool test(int value), {int orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+    return Collections.lastMatchingInList(this, test, orElse);
   }
 
   int singleMatching(bool test(int value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+    return Collections.singleMatching(this, test);
   }
 
   int elementAt(int index) {
@@ -14868,9 +14866,9 @@ class Int8Array extends ArrayBufferView implements List<int> {
     throw new StateError("More than one element");
   }
 
-  int min([int compare(int a, int b)]) => IterableMixinWorkaround.min(this, compare);
+  int min([int compare(int a, int b)]) => Collections.min(this, compare);
 
-  int max([int compare(int a, int b)]) => IterableMixinWorkaround.max(this, compare);
+  int max([int compare(int a, int b)]) => Collections.max(this, compare);
 
   int removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
@@ -17186,50 +17184,50 @@ class NamedNodeMap extends NativeFieldWrapperClass1 implements List<Node> {
   }
 
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, Node)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+    return Collections.reduce(this, initialValue, combine);
   }
 
-  bool contains(Node element) => IterableMixinWorkaround.contains(this, element);
+  bool contains(Node element) => Collections.contains(this, element);
 
-  void forEach(void f(Node element)) => IterableMixinWorkaround.forEach(this, f);
+  void forEach(void f(Node element)) => Collections.forEach(this, f);
 
-  String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  List mappedBy(f(Node element)) => IterableMixinWorkaround.mappedByList(this, f);
+  List mappedBy(f(Node element)) => new MappedList<Node, dynamic>(this, f);
 
-  Iterable<Node> where(bool f(Node element)) => IterableMixinWorkaround.where(this, f);
+  Iterable<Node> where(bool f(Node element)) => new WhereIterable<Node>(this, f);
 
-  bool every(bool f(Node element)) => IterableMixinWorkaround.every(this, f);
+  bool every(bool f(Node element)) => Collections.every(this, f);
 
-  bool any(bool f(Node element)) => IterableMixinWorkaround.any(this, f);
+  bool any(bool f(Node element)) => Collections.any(this, f);
 
   List<Node> toList() => new List<Node>.from(this);
   Set<Node> toSet() => new Set<Node>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<Node> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  List<Node> take(int n) => new ListView<Node>(this, 0, n);
 
   Iterable<Node> takeWhile(bool test(Node value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new TakeWhileIterable<Node>(this, test);
   }
 
-  List<Node> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  List<Node> skip(int n) => new ListView<Node>(this, n, null);
 
   Iterable<Node> skipWhile(bool test(Node value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new SkipWhileIterable<Node>(this, test);
   }
 
   Node firstMatching(bool test(Node value), { Node orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+    return Collections.firstMatching(this, test, orElse);
   }
 
   Node lastMatching(bool test(Node value), {Node orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+    return Collections.lastMatchingInList(this, test, orElse);
   }
 
   Node singleMatching(bool test(Node value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+    return Collections.singleMatching(this, test);
   }
 
   Node elementAt(int index) {
@@ -17287,9 +17285,9 @@ class NamedNodeMap extends NativeFieldWrapperClass1 implements List<Node> {
     throw new StateError("More than one element");
   }
 
-  Node min([int compare(Node a, Node b)]) => IterableMixinWorkaround.min(this, compare);
+  Node min([int compare(Node a, Node b)]) => Collections.min(this, compare);
 
-  Node max([int compare(Node a, Node b)]) => IterableMixinWorkaround.max(this, compare);
+  Node max([int compare(Node a, Node b)]) => Collections.max(this, compare);
 
   Node removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
@@ -17507,11 +17505,11 @@ class _ChildNodeListLazy implements List {
   }
 
   Node min([int compare(Node a, Node b)]) {
-    return IterableMixinWorkaround.min(this, compare);
+    return Collections.min(this, compare);
   }
 
   Node max([int compare(Node a, Node b)]) {
-    return IterableMixinWorkaround.max(this, compare);
+    return Collections.max(this, compare);
   }
 
   void add(Node value) {
@@ -17557,30 +17555,28 @@ class _ChildNodeListLazy implements List {
 
   // TODO(jacobr): We can implement these methods much more efficiently by
   // looking up the nodeList only once instead of once per iteration.
-  bool contains(Node element) => IterableMixinWorkaround.contains(this, element);
+  bool contains(Node element) => Collections.contains(this, element);
 
-  void forEach(void f(Node element)) => IterableMixinWorkaround.forEach(this, f);
+  void forEach(void f(Node element)) => Collections.forEach(this, f);
 
   dynamic reduce(dynamic initialValue,
       dynamic combine(dynamic previousValue, Node element)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+    return Collections.reduce(this, initialValue, combine);
   }
 
   String join([String separator]) {
-    return IterableMixinWorkaround.joinList(this, separator);
+    return Collections.joinList(this, separator);
   }
 
-  List mappedBy(f(Node element)) {
-    return IterableMixinWorkaround.mappedByList(this, f);
-  }
+  List mappedBy(f(Node element)) =>
+      new MappedList<Node, dynamic>(this, f);
 
-  Iterable<Node> where(bool f(Node element)) {
-    return IterableMixinWorkaround.where(this, f);
-  }
+  Iterable<Node> where(bool f(Node element)) =>
+     new WhereIterable<Node>(this, f);
 
-  bool every(bool f(Node element)) => IterableMixinWorkaround.every(this, f);
+  bool every(bool f(Node element)) => Collections.every(this, f);
 
-  bool any(bool f(Node element)) => IterableMixinWorkaround.any(this, f);
+  bool any(bool f(Node element)) => Collections.any(this, f);
 
   List<Node> toList() => new List<Node>.from(this);
   Set<Node> toSet() => new Set<Node>.from(this);
@@ -17590,31 +17586,31 @@ class _ChildNodeListLazy implements List {
   // From List<Node>:
 
   List<Node> take(int n) {
-    return IterableMixinWorkaround.takeList(this, n);
+    return new ListView<Node>(this, 0, n);
   }
 
   Iterable<Node> takeWhile(bool test(Node value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new TakeWhileIterable<Node>(this, test);
   }
 
   List<Node> skip(int n) {
-    return IterableMixinWorkaround.skipList(this, n);
+    return new ListView<Node>(this, n, null);
   }
 
   Iterable<Node> skipWhile(bool test(Node value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new SkipWhileIterable<Node>(this, test);
   }
 
   Node firstMatching(bool test(Node value), {Node orElse()}) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+    return Collections.firstMatching(this, test, orElse);
   }
 
   Node lastMatching(bool test(Node value), {Node orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+    return Collections.lastMatchingInList(this, test, orElse);
   }
 
   Node singleMatching(bool test(Node value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+    return Collections.singleMatching(this, test);
   }
 
   Node elementAt(int index) {
@@ -17942,50 +17938,50 @@ class NodeList extends NativeFieldWrapperClass1 implements List<Node> {
   }
 
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, Node)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+    return Collections.reduce(this, initialValue, combine);
   }
 
-  bool contains(Node element) => IterableMixinWorkaround.contains(this, element);
+  bool contains(Node element) => Collections.contains(this, element);
 
-  void forEach(void f(Node element)) => IterableMixinWorkaround.forEach(this, f);
+  void forEach(void f(Node element)) => Collections.forEach(this, f);
 
-  String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  List mappedBy(f(Node element)) => IterableMixinWorkaround.mappedByList(this, f);
+  List mappedBy(f(Node element)) => new MappedList<Node, dynamic>(this, f);
 
-  Iterable<Node> where(bool f(Node element)) => IterableMixinWorkaround.where(this, f);
+  Iterable<Node> where(bool f(Node element)) => new WhereIterable<Node>(this, f);
 
-  bool every(bool f(Node element)) => IterableMixinWorkaround.every(this, f);
+  bool every(bool f(Node element)) => Collections.every(this, f);
 
-  bool any(bool f(Node element)) => IterableMixinWorkaround.any(this, f);
+  bool any(bool f(Node element)) => Collections.any(this, f);
 
   List<Node> toList() => new List<Node>.from(this);
   Set<Node> toSet() => new Set<Node>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<Node> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  List<Node> take(int n) => new ListView<Node>(this, 0, n);
 
   Iterable<Node> takeWhile(bool test(Node value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new TakeWhileIterable<Node>(this, test);
   }
 
-  List<Node> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  List<Node> skip(int n) => new ListView<Node>(this, n, null);
 
   Iterable<Node> skipWhile(bool test(Node value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new SkipWhileIterable<Node>(this, test);
   }
 
   Node firstMatching(bool test(Node value), { Node orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+    return Collections.firstMatching(this, test, orElse);
   }
 
   Node lastMatching(bool test(Node value), {Node orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+    return Collections.lastMatchingInList(this, test, orElse);
   }
 
   Node singleMatching(bool test(Node value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+    return Collections.singleMatching(this, test);
   }
 
   Node elementAt(int index) {
@@ -18043,9 +18039,9 @@ class NodeList extends NativeFieldWrapperClass1 implements List<Node> {
     throw new StateError("More than one element");
   }
 
-  Node min([int compare(Node a, Node b)]) => IterableMixinWorkaround.min(this, compare);
+  Node min([int compare(Node a, Node b)]) => Collections.min(this, compare);
 
-  Node max([int compare(Node a, Node b)]) => IterableMixinWorkaround.max(this, compare);
+  Node max([int compare(Node a, Node b)]) => Collections.max(this, compare);
 
   Node removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
@@ -20557,50 +20553,50 @@ class SourceBufferList extends EventTarget implements List<SourceBuffer> {
   }
 
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, SourceBuffer)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+    return Collections.reduce(this, initialValue, combine);
   }
 
-  bool contains(SourceBuffer element) => IterableMixinWorkaround.contains(this, element);
+  bool contains(SourceBuffer element) => Collections.contains(this, element);
 
-  void forEach(void f(SourceBuffer element)) => IterableMixinWorkaround.forEach(this, f);
+  void forEach(void f(SourceBuffer element)) => Collections.forEach(this, f);
 
-  String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  List mappedBy(f(SourceBuffer element)) => IterableMixinWorkaround.mappedByList(this, f);
+  List mappedBy(f(SourceBuffer element)) => new MappedList<SourceBuffer, dynamic>(this, f);
 
-  Iterable<SourceBuffer> where(bool f(SourceBuffer element)) => IterableMixinWorkaround.where(this, f);
+  Iterable<SourceBuffer> where(bool f(SourceBuffer element)) => new WhereIterable<SourceBuffer>(this, f);
 
-  bool every(bool f(SourceBuffer element)) => IterableMixinWorkaround.every(this, f);
+  bool every(bool f(SourceBuffer element)) => Collections.every(this, f);
 
-  bool any(bool f(SourceBuffer element)) => IterableMixinWorkaround.any(this, f);
+  bool any(bool f(SourceBuffer element)) => Collections.any(this, f);
 
   List<SourceBuffer> toList() => new List<SourceBuffer>.from(this);
   Set<SourceBuffer> toSet() => new Set<SourceBuffer>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<SourceBuffer> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  List<SourceBuffer> take(int n) => new ListView<SourceBuffer>(this, 0, n);
 
   Iterable<SourceBuffer> takeWhile(bool test(SourceBuffer value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new TakeWhileIterable<SourceBuffer>(this, test);
   }
 
-  List<SourceBuffer> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  List<SourceBuffer> skip(int n) => new ListView<SourceBuffer>(this, n, null);
 
   Iterable<SourceBuffer> skipWhile(bool test(SourceBuffer value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new SkipWhileIterable<SourceBuffer>(this, test);
   }
 
   SourceBuffer firstMatching(bool test(SourceBuffer value), { SourceBuffer orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+    return Collections.firstMatching(this, test, orElse);
   }
 
   SourceBuffer lastMatching(bool test(SourceBuffer value), {SourceBuffer orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+    return Collections.lastMatchingInList(this, test, orElse);
   }
 
   SourceBuffer singleMatching(bool test(SourceBuffer value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+    return Collections.singleMatching(this, test);
   }
 
   SourceBuffer elementAt(int index) {
@@ -20658,9 +20654,9 @@ class SourceBufferList extends EventTarget implements List<SourceBuffer> {
     throw new StateError("More than one element");
   }
 
-  SourceBuffer min([int compare(SourceBuffer a, SourceBuffer b)]) => IterableMixinWorkaround.min(this, compare);
+  SourceBuffer min([int compare(SourceBuffer a, SourceBuffer b)]) => Collections.min(this, compare);
 
-  SourceBuffer max([int compare(SourceBuffer a, SourceBuffer b)]) => IterableMixinWorkaround.max(this, compare);
+  SourceBuffer max([int compare(SourceBuffer a, SourceBuffer b)]) => Collections.max(this, compare);
 
   SourceBuffer removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
@@ -20831,50 +20827,50 @@ class SpeechGrammarList extends NativeFieldWrapperClass1 implements List<SpeechG
   }
 
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, SpeechGrammar)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+    return Collections.reduce(this, initialValue, combine);
   }
 
-  bool contains(SpeechGrammar element) => IterableMixinWorkaround.contains(this, element);
+  bool contains(SpeechGrammar element) => Collections.contains(this, element);
 
-  void forEach(void f(SpeechGrammar element)) => IterableMixinWorkaround.forEach(this, f);
+  void forEach(void f(SpeechGrammar element)) => Collections.forEach(this, f);
 
-  String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  List mappedBy(f(SpeechGrammar element)) => IterableMixinWorkaround.mappedByList(this, f);
+  List mappedBy(f(SpeechGrammar element)) => new MappedList<SpeechGrammar, dynamic>(this, f);
 
-  Iterable<SpeechGrammar> where(bool f(SpeechGrammar element)) => IterableMixinWorkaround.where(this, f);
+  Iterable<SpeechGrammar> where(bool f(SpeechGrammar element)) => new WhereIterable<SpeechGrammar>(this, f);
 
-  bool every(bool f(SpeechGrammar element)) => IterableMixinWorkaround.every(this, f);
+  bool every(bool f(SpeechGrammar element)) => Collections.every(this, f);
 
-  bool any(bool f(SpeechGrammar element)) => IterableMixinWorkaround.any(this, f);
+  bool any(bool f(SpeechGrammar element)) => Collections.any(this, f);
 
   List<SpeechGrammar> toList() => new List<SpeechGrammar>.from(this);
   Set<SpeechGrammar> toSet() => new Set<SpeechGrammar>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<SpeechGrammar> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  List<SpeechGrammar> take(int n) => new ListView<SpeechGrammar>(this, 0, n);
 
   Iterable<SpeechGrammar> takeWhile(bool test(SpeechGrammar value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new TakeWhileIterable<SpeechGrammar>(this, test);
   }
 
-  List<SpeechGrammar> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  List<SpeechGrammar> skip(int n) => new ListView<SpeechGrammar>(this, n, null);
 
   Iterable<SpeechGrammar> skipWhile(bool test(SpeechGrammar value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new SkipWhileIterable<SpeechGrammar>(this, test);
   }
 
   SpeechGrammar firstMatching(bool test(SpeechGrammar value), { SpeechGrammar orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+    return Collections.firstMatching(this, test, orElse);
   }
 
   SpeechGrammar lastMatching(bool test(SpeechGrammar value), {SpeechGrammar orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+    return Collections.lastMatchingInList(this, test, orElse);
   }
 
   SpeechGrammar singleMatching(bool test(SpeechGrammar value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+    return Collections.singleMatching(this, test);
   }
 
   SpeechGrammar elementAt(int index) {
@@ -20932,9 +20928,9 @@ class SpeechGrammarList extends NativeFieldWrapperClass1 implements List<SpeechG
     throw new StateError("More than one element");
   }
 
-  SpeechGrammar min([int compare(SpeechGrammar a, SpeechGrammar b)]) => IterableMixinWorkaround.min(this, compare);
+  SpeechGrammar min([int compare(SpeechGrammar a, SpeechGrammar b)]) => Collections.min(this, compare);
 
-  SpeechGrammar max([int compare(SpeechGrammar a, SpeechGrammar b)]) => IterableMixinWorkaround.max(this, compare);
+  SpeechGrammar max([int compare(SpeechGrammar a, SpeechGrammar b)]) => Collections.max(this, compare);
 
   SpeechGrammar removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
@@ -21434,50 +21430,50 @@ class SqlResultSetRowList extends NativeFieldWrapperClass1 implements List<Map>
   }
 
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, Map)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+    return Collections.reduce(this, initialValue, combine);
   }
 
-  bool contains(Map element) => IterableMixinWorkaround.contains(this, element);
+  bool contains(Map element) => Collections.contains(this, element);
 
-  void forEach(void f(Map element)) => IterableMixinWorkaround.forEach(this, f);
+  void forEach(void f(Map element)) => Collections.forEach(this, f);
 
-  String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  List mappedBy(f(Map element)) => IterableMixinWorkaround.mappedByList(this, f);
+  List mappedBy(f(Map element)) => new MappedList<Map, dynamic>(this, f);
 
-  Iterable<Map> where(bool f(Map element)) => IterableMixinWorkaround.where(this, f);
+  Iterable<Map> where(bool f(Map element)) => new WhereIterable<Map>(this, f);
 
-  bool every(bool f(Map element)) => IterableMixinWorkaround.every(this, f);
+  bool every(bool f(Map element)) => Collections.every(this, f);
 
-  bool any(bool f(Map element)) => IterableMixinWorkaround.any(this, f);
+  bool any(bool f(Map element)) => Collections.any(this, f);
 
   List<Map> toList() => new List<Map>.from(this);
   Set<Map> toSet() => new Set<Map>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<Map> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  List<Map> take(int n) => new ListView<Map>(this, 0, n);
 
   Iterable<Map> takeWhile(bool test(Map value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new TakeWhileIterable<Map>(this, test);
   }
 
-  List<Map> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  List<Map> skip(int n) => new ListView<Map>(this, n, null);
 
   Iterable<Map> skipWhile(bool test(Map value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new SkipWhileIterable<Map>(this, test);
   }
 
   Map firstMatching(bool test(Map value), { Map orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+    return Collections.firstMatching(this, test, orElse);
   }
 
   Map lastMatching(bool test(Map value), {Map orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+    return Collections.lastMatchingInList(this, test, orElse);
   }
 
   Map singleMatching(bool test(Map value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+    return Collections.singleMatching(this, test);
   }
 
   Map elementAt(int index) {
@@ -21535,9 +21531,9 @@ class SqlResultSetRowList extends NativeFieldWrapperClass1 implements List<Map>
     throw new StateError("More than one element");
   }
 
-  Map min([int compare(Map a, Map b)]) => IterableMixinWorkaround.min(this, compare);
+  Map min([int compare(Map a, Map b)]) => Collections.min(this, compare);
 
-  Map max([int compare(Map a, Map b)]) => IterableMixinWorkaround.max(this, compare);
+  Map max([int compare(Map a, Map b)]) => Collections.max(this, compare);
 
   Map removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
@@ -22681,50 +22677,50 @@ class TextTrackCueList extends NativeFieldWrapperClass1 implements List<TextTrac
   }
 
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, TextTrackCue)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+    return Collections.reduce(this, initialValue, combine);
   }
 
-  bool contains(TextTrackCue element) => IterableMixinWorkaround.contains(this, element);
+  bool contains(TextTrackCue element) => Collections.contains(this, element);
 
-  void forEach(void f(TextTrackCue element)) => IterableMixinWorkaround.forEach(this, f);
+  void forEach(void f(TextTrackCue element)) => Collections.forEach(this, f);
 
-  String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  List mappedBy(f(TextTrackCue element)) => IterableMixinWorkaround.mappedByList(this, f);
+  List mappedBy(f(TextTrackCue element)) => new MappedList<TextTrackCue, dynamic>(this, f);
 
-  Iterable<TextTrackCue> where(bool f(TextTrackCue element)) => IterableMixinWorkaround.where(this, f);
+  Iterable<TextTrackCue> where(bool f(TextTrackCue element)) => new WhereIterable<TextTrackCue>(this, f);
 
-  bool every(bool f(TextTrackCue element)) => IterableMixinWorkaround.every(this, f);
+  bool every(bool f(TextTrackCue element)) => Collections.every(this, f);
 
-  bool any(bool f(TextTrackCue element)) => IterableMixinWorkaround.any(this, f);
+  bool any(bool f(TextTrackCue element)) => Collections.any(this, f);
 
   List<TextTrackCue> toList() => new List<TextTrackCue>.from(this);
   Set<TextTrackCue> toSet() => new Set<TextTrackCue>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<TextTrackCue> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  List<TextTrackCue> take(int n) => new ListView<TextTrackCue>(this, 0, n);
 
   Iterable<TextTrackCue> takeWhile(bool test(TextTrackCue value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new TakeWhileIterable<TextTrackCue>(this, test);
   }
 
-  List<TextTrackCue> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  List<TextTrackCue> skip(int n) => new ListView<TextTrackCue>(this, n, null);
 
   Iterable<TextTrackCue> skipWhile(bool test(TextTrackCue value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new SkipWhileIterable<TextTrackCue>(this, test);
   }
 
   TextTrackCue firstMatching(bool test(TextTrackCue value), { TextTrackCue orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+    return Collections.firstMatching(this, test, orElse);
   }
 
   TextTrackCue lastMatching(bool test(TextTrackCue value), {TextTrackCue orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+    return Collections.lastMatchingInList(this, test, orElse);
   }
 
   TextTrackCue singleMatching(bool test(TextTrackCue value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+    return Collections.singleMatching(this, test);
   }
 
   TextTrackCue elementAt(int index) {
@@ -22782,9 +22778,9 @@ class TextTrackCueList extends NativeFieldWrapperClass1 implements List<TextTrac
     throw new StateError("More than one element");
   }
 
-  TextTrackCue min([int compare(TextTrackCue a, TextTrackCue b)]) => IterableMixinWorkaround.min(this, compare);
+  TextTrackCue min([int compare(TextTrackCue a, TextTrackCue b)]) => Collections.min(this, compare);
 
-  TextTrackCue max([int compare(TextTrackCue a, TextTrackCue b)]) => IterableMixinWorkaround.max(this, compare);
+  TextTrackCue max([int compare(TextTrackCue a, TextTrackCue b)]) => Collections.max(this, compare);
 
   TextTrackCue removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
@@ -22861,50 +22857,50 @@ class TextTrackList extends EventTarget implements List<TextTrack> {
   }
 
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, TextTrack)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+    return Collections.reduce(this, initialValue, combine);
   }
 
-  bool contains(TextTrack element) => IterableMixinWorkaround.contains(this, element);
+  bool contains(TextTrack element) => Collections.contains(this, element);
 
-  void forEach(void f(TextTrack element)) => IterableMixinWorkaround.forEach(this, f);
+  void forEach(void f(TextTrack element)) => Collections.forEach(this, f);
 
-  String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  List mappedBy(f(TextTrack element)) => IterableMixinWorkaround.mappedByList(this, f);
+  List mappedBy(f(TextTrack element)) => new MappedList<TextTrack, dynamic>(this, f);
 
-  Iterable<TextTrack> where(bool f(TextTrack element)) => IterableMixinWorkaround.where(this, f);
+  Iterable<TextTrack> where(bool f(TextTrack element)) => new WhereIterable<TextTrack>(this, f);
 
-  bool every(bool f(TextTrack element)) => IterableMixinWorkaround.every(this, f);
+  bool every(bool f(TextTrack element)) => Collections.every(this, f);
 
-  bool any(bool f(TextTrack element)) => IterableMixinWorkaround.any(this, f);
+  bool any(bool f(TextTrack element)) => Collections.any(this, f);
 
   List<TextTrack> toList() => new List<TextTrack>.from(this);
   Set<TextTrack> toSet() => new Set<TextTrack>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<TextTrack> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  List<TextTrack> take(int n) => new ListView<TextTrack>(this, 0, n);
 
   Iterable<TextTrack> takeWhile(bool test(TextTrack value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new TakeWhileIterable<TextTrack>(this, test);
   }
 
-  List<TextTrack> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  List<TextTrack> skip(int n) => new ListView<TextTrack>(this, n, null);
 
   Iterable<TextTrack> skipWhile(bool test(TextTrack value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new SkipWhileIterable<TextTrack>(this, test);
   }
 
   TextTrack firstMatching(bool test(TextTrack value), { TextTrack orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+    return Collections.firstMatching(this, test, orElse);
   }
 
   TextTrack lastMatching(bool test(TextTrack value), {TextTrack orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+    return Collections.lastMatchingInList(this, test, orElse);
   }
 
   TextTrack singleMatching(bool test(TextTrack value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+    return Collections.singleMatching(this, test);
   }
 
   TextTrack elementAt(int index) {
@@ -22962,9 +22958,9 @@ class TextTrackList extends EventTarget implements List<TextTrack> {
     throw new StateError("More than one element");
   }
 
-  TextTrack min([int compare(TextTrack a, TextTrack b)]) => IterableMixinWorkaround.min(this, compare);
+  TextTrack min([int compare(TextTrack a, TextTrack b)]) => Collections.min(this, compare);
 
-  TextTrack max([int compare(TextTrack a, TextTrack b)]) => IterableMixinWorkaround.max(this, compare);
+  TextTrack max([int compare(TextTrack a, TextTrack b)]) => Collections.max(this, compare);
 
   TextTrack removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
@@ -23208,50 +23204,50 @@ class TouchList extends NativeFieldWrapperClass1 implements List<Touch> {
   }
 
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, Touch)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+    return Collections.reduce(this, initialValue, combine);
   }
 
-  bool contains(Touch element) => IterableMixinWorkaround.contains(this, element);
+  bool contains(Touch element) => Collections.contains(this, element);
 
-  void forEach(void f(Touch element)) => IterableMixinWorkaround.forEach(this, f);
+  void forEach(void f(Touch element)) => Collections.forEach(this, f);
 
-  String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  List mappedBy(f(Touch element)) => IterableMixinWorkaround.mappedByList(this, f);
+  List mappedBy(f(Touch element)) => new MappedList<Touch, dynamic>(this, f);
 
-  Iterable<Touch> where(bool f(Touch element)) => IterableMixinWorkaround.where(this, f);
+  Iterable<Touch> where(bool f(Touch element)) => new WhereIterable<Touch>(this, f);
 
-  bool every(bool f(Touch element)) => IterableMixinWorkaround.every(this, f);
+  bool every(bool f(Touch element)) => Collections.every(this, f);
 
-  bool any(bool f(Touch element)) => IterableMixinWorkaround.any(this, f);
+  bool any(bool f(Touch element)) => Collections.any(this, f);
 
   List<Touch> toList() => new List<Touch>.from(this);
   Set<Touch> toSet() => new Set<Touch>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<Touch> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  List<Touch> take(int n) => new ListView<Touch>(this, 0, n);
 
   Iterable<Touch> takeWhile(bool test(Touch value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new TakeWhileIterable<Touch>(this, test);
   }
 
-  List<Touch> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  List<Touch> skip(int n) => new ListView<Touch>(this, n, null);
 
   Iterable<Touch> skipWhile(bool test(Touch value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new SkipWhileIterable<Touch>(this, test);
   }
 
   Touch firstMatching(bool test(Touch value), { Touch orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+    return Collections.firstMatching(this, test, orElse);
   }
 
   Touch lastMatching(bool test(Touch value), {Touch orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+    return Collections.lastMatchingInList(this, test, orElse);
   }
 
   Touch singleMatching(bool test(Touch value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+    return Collections.singleMatching(this, test);
   }
 
   Touch elementAt(int index) {
@@ -23309,9 +23305,9 @@ class TouchList extends NativeFieldWrapperClass1 implements List<Touch> {
     throw new StateError("More than one element");
   }
 
-  Touch min([int compare(Touch a, Touch b)]) => IterableMixinWorkaround.min(this, compare);
+  Touch min([int compare(Touch a, Touch b)]) => Collections.min(this, compare);
 
-  Touch max([int compare(Touch a, Touch b)]) => IterableMixinWorkaround.max(this, compare);
+  Touch max([int compare(Touch a, Touch b)]) => Collections.max(this, compare);
 
   Touch removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
@@ -23652,50 +23648,50 @@ class Uint16Array extends ArrayBufferView implements List<int> {
   }
 
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, int)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+    return Collections.reduce(this, initialValue, combine);
   }
 
-  bool contains(int element) => IterableMixinWorkaround.contains(this, element);
+  bool contains(int element) => Collections.contains(this, element);
 
-  void forEach(void f(int element)) => IterableMixinWorkaround.forEach(this, f);
+  void forEach(void f(int element)) => Collections.forEach(this, f);
 
-  String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  List mappedBy(f(int element)) => IterableMixinWorkaround.mappedByList(this, f);
+  List mappedBy(f(int element)) => new MappedList<int, dynamic>(this, f);
 
-  Iterable<int> where(bool f(int element)) => IterableMixinWorkaround.where(this, f);
+  Iterable<int> where(bool f(int element)) => new WhereIterable<int>(this, f);
 
-  bool every(bool f(int element)) => IterableMixinWorkaround.every(this, f);
+  bool every(bool f(int element)) => Collections.every(this, f);
 
-  bool any(bool f(int element)) => IterableMixinWorkaround.any(this, f);
+  bool any(bool f(int element)) => Collections.any(this, f);
 
   List<int> toList() => new List<int>.from(this);
   Set<int> toSet() => new Set<int>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<int> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  List<int> take(int n) => new ListView<int>(this, 0, n);
 
   Iterable<int> takeWhile(bool test(int value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new TakeWhileIterable<int>(this, test);
   }
 
-  List<int> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  List<int> skip(int n) => new ListView<int>(this, n, null);
 
   Iterable<int> skipWhile(bool test(int value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new SkipWhileIterable<int>(this, test);
   }
 
   int firstMatching(bool test(int value), { int orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+    return Collections.firstMatching(this, test, orElse);
   }
 
   int lastMatching(bool test(int value), {int orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+    return Collections.lastMatchingInList(this, test, orElse);
   }
 
   int singleMatching(bool test(int value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+    return Collections.singleMatching(this, test);
   }
 
   int elementAt(int index) {
@@ -23753,9 +23749,9 @@ class Uint16Array extends ArrayBufferView implements List<int> {
     throw new StateError("More than one element");
   }
 
-  int min([int compare(int a, int b)]) => IterableMixinWorkaround.min(this, compare);
+  int min([int compare(int a, int b)]) => Collections.min(this, compare);
 
-  int max([int compare(int a, int b)]) => IterableMixinWorkaround.max(this, compare);
+  int max([int compare(int a, int b)]) => Collections.max(this, compare);
 
   int removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
@@ -23849,50 +23845,50 @@ class Uint32Array extends ArrayBufferView implements List<int> {
   }
 
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, int)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+    return Collections.reduce(this, initialValue, combine);
   }
 
-  bool contains(int element) => IterableMixinWorkaround.contains(this, element);
+  bool contains(int element) => Collections.contains(this, element);
 
-  void forEach(void f(int element)) => IterableMixinWorkaround.forEach(this, f);
+  void forEach(void f(int element)) => Collections.forEach(this, f);
 
-  String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  List mappedBy(f(int element)) => IterableMixinWorkaround.mappedByList(this, f);
+  List mappedBy(f(int element)) => new MappedList<int, dynamic>(this, f);
 
-  Iterable<int> where(bool f(int element)) => IterableMixinWorkaround.where(this, f);
+  Iterable<int> where(bool f(int element)) => new WhereIterable<int>(this, f);
 
-  bool every(bool f(int element)) => IterableMixinWorkaround.every(this, f);
+  bool every(bool f(int element)) => Collections.every(this, f);
 
-  bool any(bool f(int element)) => IterableMixinWorkaround.any(this, f);
+  bool any(bool f(int element)) => Collections.any(this, f);
 
   List<int> toList() => new List<int>.from(this);
   Set<int> toSet() => new Set<int>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<int> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  List<int> take(int n) => new ListView<int>(this, 0, n);
 
   Iterable<int> takeWhile(bool test(int value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new TakeWhileIterable<int>(this, test);
   }
 
-  List<int> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  List<int> skip(int n) => new ListView<int>(this, n, null);
 
   Iterable<int> skipWhile(bool test(int value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new SkipWhileIterable<int>(this, test);
   }
 
   int firstMatching(bool test(int value), { int orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+    return Collections.firstMatching(this, test, orElse);
   }
 
   int lastMatching(bool test(int value), {int orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+    return Collections.lastMatchingInList(this, test, orElse);
   }
 
   int singleMatching(bool test(int value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+    return Collections.singleMatching(this, test);
   }
 
   int elementAt(int index) {
@@ -23950,9 +23946,9 @@ class Uint32Array extends ArrayBufferView implements List<int> {
     throw new StateError("More than one element");
   }
 
-  int min([int compare(int a, int b)]) => IterableMixinWorkaround.min(this, compare);
+  int min([int compare(int a, int b)]) => Collections.min(this, compare);
 
-  int max([int compare(int a, int b)]) => IterableMixinWorkaround.max(this, compare);
+  int max([int compare(int a, int b)]) => Collections.max(this, compare);
 
   int removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
@@ -24046,50 +24042,50 @@ class Uint8Array extends ArrayBufferView implements List<int> {
   }
 
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, int)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+    return Collections.reduce(this, initialValue, combine);
   }
 
-  bool contains(int element) => IterableMixinWorkaround.contains(this, element);
+  bool contains(int element) => Collections.contains(this, element);
 
-  void forEach(void f(int element)) => IterableMixinWorkaround.forEach(this, f);
+  void forEach(void f(int element)) => Collections.forEach(this, f);
 
-  String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  List mappedBy(f(int element)) => IterableMixinWorkaround.mappedByList(this, f);
+  List mappedBy(f(int element)) => new MappedList<int, dynamic>(this, f);
 
-  Iterable<int> where(bool f(int element)) => IterableMixinWorkaround.where(this, f);
+  Iterable<int> where(bool f(int element)) => new WhereIterable<int>(this, f);
 
-  bool every(bool f(int element)) => IterableMixinWorkaround.every(this, f);
+  bool every(bool f(int element)) => Collections.every(this, f);
 
-  bool any(bool f(int element)) => IterableMixinWorkaround.any(this, f);
+  bool any(bool f(int element)) => Collections.any(this, f);
 
   List<int> toList() => new List<int>.from(this);
   Set<int> toSet() => new Set<int>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<int> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  List<int> take(int n) => new ListView<int>(this, 0, n);
 
   Iterable<int> takeWhile(bool test(int value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new TakeWhileIterable<int>(this, test);
   }
 
-  List<int> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  List<int> skip(int n) => new ListView<int>(this, n, null);
 
   Iterable<int> skipWhile(bool test(int value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new SkipWhileIterable<int>(this, test);
   }
 
   int firstMatching(bool test(int value), { int orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+    return Collections.firstMatching(this, test, orElse);
   }
 
   int lastMatching(bool test(int value), {int orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+    return Collections.lastMatchingInList(this, test, orElse);
   }
 
   int singleMatching(bool test(int value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+    return Collections.singleMatching(this, test);
   }
 
   int elementAt(int index) {
@@ -24147,9 +24143,9 @@ class Uint8Array extends ArrayBufferView implements List<int> {
     throw new StateError("More than one element");
   }
 
-  int min([int compare(int a, int b)]) => IterableMixinWorkaround.min(this, compare);
+  int min([int compare(int a, int b)]) => Collections.min(this, compare);
 
-  int max([int compare(int a, int b)]) => IterableMixinWorkaround.max(this, compare);
+  int max([int compare(int a, int b)]) => Collections.max(this, compare);
 
   int removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
@@ -24241,50 +24237,50 @@ class Uint8ClampedArray extends Uint8Array implements List<int> {
   }
 
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, int)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+    return Collections.reduce(this, initialValue, combine);
   }
 
-  bool contains(int element) => IterableMixinWorkaround.contains(this, element);
+  bool contains(int element) => Collections.contains(this, element);
 
-  void forEach(void f(int element)) => IterableMixinWorkaround.forEach(this, f);
+  void forEach(void f(int element)) => Collections.forEach(this, f);
 
-  String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  List mappedBy(f(int element)) => IterableMixinWorkaround.mappedByList(this, f);
+  List mappedBy(f(int element)) => new MappedList<int, dynamic>(this, f);
 
-  Iterable<int> where(bool f(int element)) => IterableMixinWorkaround.where(this, f);
+  Iterable<int> where(bool f(int element)) => new WhereIterable<int>(this, f);
 
-  bool every(bool f(int element)) => IterableMixinWorkaround.every(this, f);
+  bool every(bool f(int element)) => Collections.every(this, f);
 
-  bool any(bool f(int element)) => IterableMixinWorkaround.any(this, f);
+  bool any(bool f(int element)) => Collections.any(this, f);
 
   List<int> toList() => new List<int>.from(this);
   Set<int> toSet() => new Set<int>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<int> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  List<int> take(int n) => new ListView<int>(this, 0, n);
 
   Iterable<int> takeWhile(bool test(int value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new TakeWhileIterable<int>(this, test);
   }
 
-  List<int> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  List<int> skip(int n) => new ListView<int>(this, n, null);
 
   Iterable<int> skipWhile(bool test(int value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new SkipWhileIterable<int>(this, test);
   }
 
   int firstMatching(bool test(int value), { int orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+    return Collections.firstMatching(this, test, orElse);
   }
 
   int lastMatching(bool test(int value), {int orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+    return Collections.lastMatchingInList(this, test, orElse);
   }
 
   int singleMatching(bool test(int value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+    return Collections.singleMatching(this, test);
   }
 
   int elementAt(int index) {
@@ -24342,9 +24338,9 @@ class Uint8ClampedArray extends Uint8Array implements List<int> {
     throw new StateError("More than one element");
   }
 
-  int min([int compare(int a, int b)]) => IterableMixinWorkaround.min(this, compare);
+  int min([int compare(int a, int b)]) => Collections.min(this, compare);
 
-  int max([int compare(int a, int b)]) => IterableMixinWorkaround.max(this, compare);
+  int max([int compare(int a, int b)]) => Collections.max(this, compare);
 
   int removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
@@ -27997,50 +27993,50 @@ class _ClientRectList extends NativeFieldWrapperClass1 implements List<ClientRec
   }
 
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, ClientRect)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+    return Collections.reduce(this, initialValue, combine);
   }
 
-  bool contains(ClientRect element) => IterableMixinWorkaround.contains(this, element);
+  bool contains(ClientRect element) => Collections.contains(this, element);
 
-  void forEach(void f(ClientRect element)) => IterableMixinWorkaround.forEach(this, f);
+  void forEach(void f(ClientRect element)) => Collections.forEach(this, f);
 
-  String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  List mappedBy(f(ClientRect element)) => IterableMixinWorkaround.mappedByList(this, f);
+  List mappedBy(f(ClientRect element)) => new MappedList<ClientRect, dynamic>(this, f);
 
-  Iterable<ClientRect> where(bool f(ClientRect element)) => IterableMixinWorkaround.where(this, f);
+  Iterable<ClientRect> where(bool f(ClientRect element)) => new WhereIterable<ClientRect>(this, f);
 
-  bool every(bool f(ClientRect element)) => IterableMixinWorkaround.every(this, f);
+  bool every(bool f(ClientRect element)) => Collections.every(this, f);
 
-  bool any(bool f(ClientRect element)) => IterableMixinWorkaround.any(this, f);
+  bool any(bool f(ClientRect element)) => Collections.any(this, f);
 
   List<ClientRect> toList() => new List<ClientRect>.from(this);
   Set<ClientRect> toSet() => new Set<ClientRect>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<ClientRect> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  List<ClientRect> take(int n) => new ListView<ClientRect>(this, 0, n);
 
   Iterable<ClientRect> takeWhile(bool test(ClientRect value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new TakeWhileIterable<ClientRect>(this, test);
   }
 
-  List<ClientRect> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  List<ClientRect> skip(int n) => new ListView<ClientRect>(this, n, null);
 
   Iterable<ClientRect> skipWhile(bool test(ClientRect value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new SkipWhileIterable<ClientRect>(this, test);
   }
 
   ClientRect firstMatching(bool test(ClientRect value), { ClientRect orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+    return Collections.firstMatching(this, test, orElse);
   }
 
   ClientRect lastMatching(bool test(ClientRect value), {ClientRect orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+    return Collections.lastMatchingInList(this, test, orElse);
   }
 
   ClientRect singleMatching(bool test(ClientRect value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+    return Collections.singleMatching(this, test);
   }
 
   ClientRect elementAt(int index) {
@@ -28098,9 +28094,9 @@ class _ClientRectList extends NativeFieldWrapperClass1 implements List<ClientRec
     throw new StateError("More than one element");
   }
 
-  ClientRect min([int compare(ClientRect a, ClientRect b)]) => IterableMixinWorkaround.min(this, compare);
+  ClientRect min([int compare(ClientRect a, ClientRect b)]) => Collections.min(this, compare);
 
-  ClientRect max([int compare(ClientRect a, ClientRect b)]) => IterableMixinWorkaround.max(this, compare);
+  ClientRect max([int compare(ClientRect a, ClientRect b)]) => Collections.max(this, compare);
 
   ClientRect removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
@@ -28166,50 +28162,50 @@ class _CssRuleList extends NativeFieldWrapperClass1 implements List<CssRule> {
   }
 
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, CssRule)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+    return Collections.reduce(this, initialValue, combine);
   }
 
-  bool contains(CssRule element) => IterableMixinWorkaround.contains(this, element);
+  bool contains(CssRule element) => Collections.contains(this, element);
 
-  void forEach(void f(CssRule element)) => IterableMixinWorkaround.forEach(this, f);
+  void forEach(void f(CssRule element)) => Collections.forEach(this, f);
 
-  String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  List mappedBy(f(CssRule element)) => IterableMixinWorkaround.mappedByList(this, f);
+  List mappedBy(f(CssRule element)) => new MappedList<CssRule, dynamic>(this, f);
 
-  Iterable<CssRule> where(bool f(CssRule element)) => IterableMixinWorkaround.where(this, f);
+  Iterable<CssRule> where(bool f(CssRule element)) => new WhereIterable<CssRule>(this, f);
 
-  bool every(bool f(CssRule element)) => IterableMixinWorkaround.every(this, f);
+  bool every(bool f(CssRule element)) => Collections.every(this, f);
 
-  bool any(bool f(CssRule element)) => IterableMixinWorkaround.any(this, f);
+  bool any(bool f(CssRule element)) => Collections.any(this, f);
 
   List<CssRule> toList() => new List<CssRule>.from(this);
   Set<CssRule> toSet() => new Set<CssRule>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<CssRule> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  List<CssRule> take(int n) => new ListView<CssRule>(this, 0, n);
 
   Iterable<CssRule> takeWhile(bool test(CssRule value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new TakeWhileIterable<CssRule>(this, test);
   }
 
-  List<CssRule> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  List<CssRule> skip(int n) => new ListView<CssRule>(this, n, null);
 
   Iterable<CssRule> skipWhile(bool test(CssRule value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new SkipWhileIterable<CssRule>(this, test);
   }
 
   CssRule firstMatching(bool test(CssRule value), { CssRule orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+    return Collections.firstMatching(this, test, orElse);
   }
 
   CssRule lastMatching(bool test(CssRule value), {CssRule orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+    return Collections.lastMatchingInList(this, test, orElse);
   }
 
   CssRule singleMatching(bool test(CssRule value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+    return Collections.singleMatching(this, test);
   }
 
   CssRule elementAt(int index) {
@@ -28267,9 +28263,9 @@ class _CssRuleList extends NativeFieldWrapperClass1 implements List<CssRule> {
     throw new StateError("More than one element");
   }
 
-  CssRule min([int compare(CssRule a, CssRule b)]) => IterableMixinWorkaround.min(this, compare);
+  CssRule min([int compare(CssRule a, CssRule b)]) => Collections.min(this, compare);
 
-  CssRule max([int compare(CssRule a, CssRule b)]) => IterableMixinWorkaround.max(this, compare);
+  CssRule max([int compare(CssRule a, CssRule b)]) => Collections.max(this, compare);
 
   CssRule removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
@@ -28335,50 +28331,50 @@ class _CssValueList extends CssValue implements List<CssValue> {
   }
 
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, CssValue)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+    return Collections.reduce(this, initialValue, combine);
   }
 
-  bool contains(CssValue element) => IterableMixinWorkaround.contains(this, element);
+  bool contains(CssValue element) => Collections.contains(this, element);
 
-  void forEach(void f(CssValue element)) => IterableMixinWorkaround.forEach(this, f);
+  void forEach(void f(CssValue element)) => Collections.forEach(this, f);
 
-  String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  List mappedBy(f(CssValue element)) => IterableMixinWorkaround.mappedByList(this, f);
+  List mappedBy(f(CssValue element)) => new MappedList<CssValue, dynamic>(this, f);
 
-  Iterable<CssValue> where(bool f(CssValue element)) => IterableMixinWorkaround.where(this, f);
+  Iterable<CssValue> where(bool f(CssValue element)) => new WhereIterable<CssValue>(this, f);
 
-  bool every(bool f(CssValue element)) => IterableMixinWorkaround.every(this, f);
+  bool every(bool f(CssValue element)) => Collections.every(this, f);
 
-  bool any(bool f(CssValue element)) => IterableMixinWorkaround.any(this, f);
+  bool any(bool f(CssValue element)) => Collections.any(this, f);
 
   List<CssValue> toList() => new List<CssValue>.from(this);
   Set<CssValue> toSet() => new Set<CssValue>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<CssValue> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  List<CssValue> take(int n) => new ListView<CssValue>(this, 0, n);
 
   Iterable<CssValue> takeWhile(bool test(CssValue value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new TakeWhileIterable<CssValue>(this, test);
   }
 
-  List<CssValue> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  List<CssValue> skip(int n) => new ListView<CssValue>(this, n, null);
 
   Iterable<CssValue> skipWhile(bool test(CssValue value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new SkipWhileIterable<CssValue>(this, test);
   }
 
   CssValue firstMatching(bool test(CssValue value), { CssValue orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+    return Collections.firstMatching(this, test, orElse);
   }
 
   CssValue lastMatching(bool test(CssValue value), {CssValue orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+    return Collections.lastMatchingInList(this, test, orElse);
   }
 
   CssValue singleMatching(bool test(CssValue value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+    return Collections.singleMatching(this, test);
   }
 
   CssValue elementAt(int index) {
@@ -28436,9 +28432,9 @@ class _CssValueList extends CssValue implements List<CssValue> {
     throw new StateError("More than one element");
   }
 
-  CssValue min([int compare(CssValue a, CssValue b)]) => IterableMixinWorkaround.min(this, compare);
+  CssValue min([int compare(CssValue a, CssValue b)]) => Collections.min(this, compare);
 
-  CssValue max([int compare(CssValue a, CssValue b)]) => IterableMixinWorkaround.max(this, compare);
+  CssValue max([int compare(CssValue a, CssValue b)]) => Collections.max(this, compare);
 
   CssValue removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
@@ -28654,50 +28650,50 @@ class _EntryArray extends NativeFieldWrapperClass1 implements List<Entry> {
   }
 
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, Entry)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+    return Collections.reduce(this, initialValue, combine);
   }
 
-  bool contains(Entry element) => IterableMixinWorkaround.contains(this, element);
+  bool contains(Entry element) => Collections.contains(this, element);
 
-  void forEach(void f(Entry element)) => IterableMixinWorkaround.forEach(this, f);
+  void forEach(void f(Entry element)) => Collections.forEach(this, f);
 
-  String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  List mappedBy(f(Entry element)) => IterableMixinWorkaround.mappedByList(this, f);
+  List mappedBy(f(Entry element)) => new MappedList<Entry, dynamic>(this, f);
 
-  Iterable<Entry> where(bool f(Entry element)) => IterableMixinWorkaround.where(this, f);
+  Iterable<Entry> where(bool f(Entry element)) => new WhereIterable<Entry>(this, f);
 
-  bool every(bool f(Entry element)) => IterableMixinWorkaround.every(this, f);
+  bool every(bool f(Entry element)) => Collections.every(this, f);
 
-  bool any(bool f(Entry element)) => IterableMixinWorkaround.any(this, f);
+  bool any(bool f(Entry element)) => Collections.any(this, f);
 
   List<Entry> toList() => new List<Entry>.from(this);
   Set<Entry> toSet() => new Set<Entry>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<Entry> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  List<Entry> take(int n) => new ListView<Entry>(this, 0, n);
 
   Iterable<Entry> takeWhile(bool test(Entry value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new TakeWhileIterable<Entry>(this, test);
   }
 
-  List<Entry> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  List<Entry> skip(int n) => new ListView<Entry>(this, n, null);
 
   Iterable<Entry> skipWhile(bool test(Entry value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new SkipWhileIterable<Entry>(this, test);
   }
 
   Entry firstMatching(bool test(Entry value), { Entry orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+    return Collections.firstMatching(this, test, orElse);
   }
 
   Entry lastMatching(bool test(Entry value), {Entry orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+    return Collections.lastMatchingInList(this, test, orElse);
   }
 
   Entry singleMatching(bool test(Entry value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+    return Collections.singleMatching(this, test);
   }
 
   Entry elementAt(int index) {
@@ -28755,9 +28751,9 @@ class _EntryArray extends NativeFieldWrapperClass1 implements List<Entry> {
     throw new StateError("More than one element");
   }
 
-  Entry min([int compare(Entry a, Entry b)]) => IterableMixinWorkaround.min(this, compare);
+  Entry min([int compare(Entry a, Entry b)]) => Collections.min(this, compare);
 
-  Entry max([int compare(Entry a, Entry b)]) => IterableMixinWorkaround.max(this, compare);
+  Entry max([int compare(Entry a, Entry b)]) => Collections.max(this, compare);
 
   Entry removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
@@ -28823,50 +28819,50 @@ class _EntryArraySync extends NativeFieldWrapperClass1 implements List<EntrySync
   }
 
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, EntrySync)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+    return Collections.reduce(this, initialValue, combine);
   }
 
-  bool contains(EntrySync element) => IterableMixinWorkaround.contains(this, element);
+  bool contains(EntrySync element) => Collections.contains(this, element);
 
-  void forEach(void f(EntrySync element)) => IterableMixinWorkaround.forEach(this, f);
+  void forEach(void f(EntrySync element)) => Collections.forEach(this, f);
 
-  String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  List mappedBy(f(EntrySync element)) => IterableMixinWorkaround.mappedByList(this, f);
+  List mappedBy(f(EntrySync element)) => new MappedList<EntrySync, dynamic>(this, f);
 
-  Iterable<EntrySync> where(bool f(EntrySync element)) => IterableMixinWorkaround.where(this, f);
+  Iterable<EntrySync> where(bool f(EntrySync element)) => new WhereIterable<EntrySync>(this, f);
 
-  bool every(bool f(EntrySync element)) => IterableMixinWorkaround.every(this, f);
+  bool every(bool f(EntrySync element)) => Collections.every(this, f);
 
-  bool any(bool f(EntrySync element)) => IterableMixinWorkaround.any(this, f);
+  bool any(bool f(EntrySync element)) => Collections.any(this, f);
 
   List<EntrySync> toList() => new List<EntrySync>.from(this);
   Set<EntrySync> toSet() => new Set<EntrySync>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<EntrySync> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  List<EntrySync> take(int n) => new ListView<EntrySync>(this, 0, n);
 
   Iterable<EntrySync> takeWhile(bool test(EntrySync value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new TakeWhileIterable<EntrySync>(this, test);
   }
 
-  List<EntrySync> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  List<EntrySync> skip(int n) => new ListView<EntrySync>(this, n, null);
 
   Iterable<EntrySync> skipWhile(bool test(EntrySync value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new SkipWhileIterable<EntrySync>(this, test);
   }
 
   EntrySync firstMatching(bool test(EntrySync value), { EntrySync orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+    return Collections.firstMatching(this, test, orElse);
   }
 
   EntrySync lastMatching(bool test(EntrySync value), {EntrySync orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+    return Collections.lastMatchingInList(this, test, orElse);
   }
 
   EntrySync singleMatching(bool test(EntrySync value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+    return Collections.singleMatching(this, test);
   }
 
   EntrySync elementAt(int index) {
@@ -28924,9 +28920,9 @@ class _EntryArraySync extends NativeFieldWrapperClass1 implements List<EntrySync
     throw new StateError("More than one element");
   }
 
-  EntrySync min([int compare(EntrySync a, EntrySync b)]) => IterableMixinWorkaround.min(this, compare);
+  EntrySync min([int compare(EntrySync a, EntrySync b)]) => Collections.min(this, compare);
 
-  EntrySync max([int compare(EntrySync a, EntrySync b)]) => IterableMixinWorkaround.max(this, compare);
+  EntrySync max([int compare(EntrySync a, EntrySync b)]) => Collections.max(this, compare);
 
   EntrySync removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
@@ -29133,50 +29129,50 @@ class _GamepadList extends NativeFieldWrapperClass1 implements List<Gamepad> {
   }
 
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, Gamepad)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+    return Collections.reduce(this, initialValue, combine);
   }
 
-  bool contains(Gamepad element) => IterableMixinWorkaround.contains(this, element);
+  bool contains(Gamepad element) => Collections.contains(this, element);
 
-  void forEach(void f(Gamepad element)) => IterableMixinWorkaround.forEach(this, f);
+  void forEach(void f(Gamepad element)) => Collections.forEach(this, f);
 
-  String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  List mappedBy(f(Gamepad element)) => IterableMixinWorkaround.mappedByList(this, f);
+  List mappedBy(f(Gamepad element)) => new MappedList<Gamepad, dynamic>(this, f);
 
-  Iterable<Gamepad> where(bool f(Gamepad element)) => IterableMixinWorkaround.where(this, f);
+  Iterable<Gamepad> where(bool f(Gamepad element)) => new WhereIterable<Gamepad>(this, f);
 
-  bool every(bool f(Gamepad element)) => IterableMixinWorkaround.every(this, f);
+  bool every(bool f(Gamepad element)) => Collections.every(this, f);
 
-  bool any(bool f(Gamepad element)) => IterableMixinWorkaround.any(this, f);
+  bool any(bool f(Gamepad element)) => Collections.any(this, f);
 
   List<Gamepad> toList() => new List<Gamepad>.from(this);
   Set<Gamepad> toSet() => new Set<Gamepad>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<Gamepad> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  List<Gamepad> take(int n) => new ListView<Gamepad>(this, 0, n);
 
   Iterable<Gamepad> takeWhile(bool test(Gamepad value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new TakeWhileIterable<Gamepad>(this, test);
   }
 
-  List<Gamepad> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  List<Gamepad> skip(int n) => new ListView<Gamepad>(this, n, null);
 
   Iterable<Gamepad> skipWhile(bool test(Gamepad value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new SkipWhileIterable<Gamepad>(this, test);
   }
 
   Gamepad firstMatching(bool test(Gamepad value), { Gamepad orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+    return Collections.firstMatching(this, test, orElse);
   }
 
   Gamepad lastMatching(bool test(Gamepad value), {Gamepad orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+    return Collections.lastMatchingInList(this, test, orElse);
   }
 
   Gamepad singleMatching(bool test(Gamepad value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+    return Collections.singleMatching(this, test);
   }
 
   Gamepad elementAt(int index) {
@@ -29234,9 +29230,9 @@ class _GamepadList extends NativeFieldWrapperClass1 implements List<Gamepad> {
     throw new StateError("More than one element");
   }
 
-  Gamepad min([int compare(Gamepad a, Gamepad b)]) => IterableMixinWorkaround.min(this, compare);
+  Gamepad min([int compare(Gamepad a, Gamepad b)]) => Collections.min(this, compare);
 
-  Gamepad max([int compare(Gamepad a, Gamepad b)]) => IterableMixinWorkaround.max(this, compare);
+  Gamepad max([int compare(Gamepad a, Gamepad b)]) => Collections.max(this, compare);
 
   Gamepad removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
@@ -29315,50 +29311,50 @@ class _MediaStreamList extends NativeFieldWrapperClass1 implements List<MediaStr
   }
 
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, MediaStream)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+    return Collections.reduce(this, initialValue, combine);
   }
 
-  bool contains(MediaStream element) => IterableMixinWorkaround.contains(this, element);
+  bool contains(MediaStream element) => Collections.contains(this, element);
 
-  void forEach(void f(MediaStream element)) => IterableMixinWorkaround.forEach(this, f);
+  void forEach(void f(MediaStream element)) => Collections.forEach(this, f);
 
-  String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  List mappedBy(f(MediaStream element)) => IterableMixinWorkaround.mappedByList(this, f);
+  List mappedBy(f(MediaStream element)) => new MappedList<MediaStream, dynamic>(this, f);
 
-  Iterable<MediaStream> where(bool f(MediaStream element)) => IterableMixinWorkaround.where(this, f);
+  Iterable<MediaStream> where(bool f(MediaStream element)) => new WhereIterable<MediaStream>(this, f);
 
-  bool every(bool f(MediaStream element)) => IterableMixinWorkaround.every(this, f);
+  bool every(bool f(MediaStream element)) => Collections.every(this, f);
 
-  bool any(bool f(MediaStream element)) => IterableMixinWorkaround.any(this, f);
+  bool any(bool f(MediaStream element)) => Collections.any(this, f);
 
   List<MediaStream> toList() => new List<MediaStream>.from(this);
   Set<MediaStream> toSet() => new Set<MediaStream>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<MediaStream> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  List<MediaStream> take(int n) => new ListView<MediaStream>(this, 0, n);
 
   Iterable<MediaStream> takeWhile(bool test(MediaStream value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new TakeWhileIterable<MediaStream>(this, test);
   }
 
-  List<MediaStream> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  List<MediaStream> skip(int n) => new ListView<MediaStream>(this, n, null);
 
   Iterable<MediaStream> skipWhile(bool test(MediaStream value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new SkipWhileIterable<MediaStream>(this, test);
   }
 
   MediaStream firstMatching(bool test(MediaStream value), { MediaStream orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+    return Collections.firstMatching(this, test, orElse);
   }
 
   MediaStream lastMatching(bool test(MediaStream value), {MediaStream orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+    return Collections.lastMatchingInList(this, test, orElse);
   }
 
   MediaStream singleMatching(bool test(MediaStream value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+    return Collections.singleMatching(this, test);
   }
 
   MediaStream elementAt(int index) {
@@ -29416,9 +29412,9 @@ class _MediaStreamList extends NativeFieldWrapperClass1 implements List<MediaStr
     throw new StateError("More than one element");
   }
 
-  MediaStream min([int compare(MediaStream a, MediaStream b)]) => IterableMixinWorkaround.min(this, compare);
+  MediaStream min([int compare(MediaStream a, MediaStream b)]) => Collections.min(this, compare);
 
-  MediaStream max([int compare(MediaStream a, MediaStream b)]) => IterableMixinWorkaround.max(this, compare);
+  MediaStream max([int compare(MediaStream a, MediaStream b)]) => Collections.max(this, compare);
 
   MediaStream removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
@@ -29484,50 +29480,50 @@ class _SpeechInputResultList extends NativeFieldWrapperClass1 implements List<Sp
   }
 
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, SpeechInputResult)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+    return Collections.reduce(this, initialValue, combine);
   }
 
-  bool contains(SpeechInputResult element) => IterableMixinWorkaround.contains(this, element);
+  bool contains(SpeechInputResult element) => Collections.contains(this, element);
 
-  void forEach(void f(SpeechInputResult element)) => IterableMixinWorkaround.forEach(this, f);
+  void forEach(void f(SpeechInputResult element)) => Collections.forEach(this, f);
 
-  String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  List mappedBy(f(SpeechInputResult element)) => IterableMixinWorkaround.mappedByList(this, f);
+  List mappedBy(f(SpeechInputResult element)) => new MappedList<SpeechInputResult, dynamic>(this, f);
 
-  Iterable<SpeechInputResult> where(bool f(SpeechInputResult element)) => IterableMixinWorkaround.where(this, f);
+  Iterable<SpeechInputResult> where(bool f(SpeechInputResult element)) => new WhereIterable<SpeechInputResult>(this, f);
 
-  bool every(bool f(SpeechInputResult element)) => IterableMixinWorkaround.every(this, f);
+  bool every(bool f(SpeechInputResult element)) => Collections.every(this, f);
 
-  bool any(bool f(SpeechInputResult element)) => IterableMixinWorkaround.any(this, f);
+  bool any(bool f(SpeechInputResult element)) => Collections.any(this, f);
 
   List<SpeechInputResult> toList() => new List<SpeechInputResult>.from(this);
   Set<SpeechInputResult> toSet() => new Set<SpeechInputResult>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<SpeechInputResult> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  List<SpeechInputResult> take(int n) => new ListView<SpeechInputResult>(this, 0, n);
 
   Iterable<SpeechInputResult> takeWhile(bool test(SpeechInputResult value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new TakeWhileIterable<SpeechInputResult>(this, test);
   }
 
-  List<SpeechInputResult> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  List<SpeechInputResult> skip(int n) => new ListView<SpeechInputResult>(this, n, null);
 
   Iterable<SpeechInputResult> skipWhile(bool test(SpeechInputResult value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new SkipWhileIterable<SpeechInputResult>(this, test);
   }
 
   SpeechInputResult firstMatching(bool test(SpeechInputResult value), { SpeechInputResult orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+    return Collections.firstMatching(this, test, orElse);
   }
 
   SpeechInputResult lastMatching(bool test(SpeechInputResult value), {SpeechInputResult orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+    return Collections.lastMatchingInList(this, test, orElse);
   }
 
   SpeechInputResult singleMatching(bool test(SpeechInputResult value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+    return Collections.singleMatching(this, test);
   }
 
   SpeechInputResult elementAt(int index) {
@@ -29585,9 +29581,9 @@ class _SpeechInputResultList extends NativeFieldWrapperClass1 implements List<Sp
     throw new StateError("More than one element");
   }
 
-  SpeechInputResult min([int compare(SpeechInputResult a, SpeechInputResult b)]) => IterableMixinWorkaround.min(this, compare);
+  SpeechInputResult min([int compare(SpeechInputResult a, SpeechInputResult b)]) => Collections.min(this, compare);
 
-  SpeechInputResult max([int compare(SpeechInputResult a, SpeechInputResult b)]) => IterableMixinWorkaround.max(this, compare);
+  SpeechInputResult max([int compare(SpeechInputResult a, SpeechInputResult b)]) => Collections.max(this, compare);
 
   SpeechInputResult removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
@@ -29653,50 +29649,50 @@ class _SpeechRecognitionResultList extends NativeFieldWrapperClass1 implements L
   }
 
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, SpeechRecognitionResult)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+    return Collections.reduce(this, initialValue, combine);
   }
 
-  bool contains(SpeechRecognitionResult element) => IterableMixinWorkaround.contains(this, element);
+  bool contains(SpeechRecognitionResult element) => Collections.contains(this, element);
 
-  void forEach(void f(SpeechRecognitionResult element)) => IterableMixinWorkaround.forEach(this, f);
+  void forEach(void f(SpeechRecognitionResult element)) => Collections.forEach(this, f);
 
-  String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  List mappedBy(f(SpeechRecognitionResult element)) => IterableMixinWorkaround.mappedByList(this, f);
+  List mappedBy(f(SpeechRecognitionResult element)) => new MappedList<SpeechRecognitionResult, dynamic>(this, f);
 
-  Iterable<SpeechRecognitionResult> where(bool f(SpeechRecognitionResult element)) => IterableMixinWorkaround.where(this, f);
+  Iterable<SpeechRecognitionResult> where(bool f(SpeechRecognitionResult element)) => new WhereIterable<SpeechRecognitionResult>(this, f);
 
-  bool every(bool f(SpeechRecognitionResult element)) => IterableMixinWorkaround.every(this, f);
+  bool every(bool f(SpeechRecognitionResult element)) => Collections.every(this, f);
 
-  bool any(bool f(SpeechRecognitionResult element)) => IterableMixinWorkaround.any(this, f);
+  bool any(bool f(SpeechRecognitionResult element)) => Collections.any(this, f);
 
   List<SpeechRecognitionResult> toList() => new List<SpeechRecognitionResult>.from(this);
   Set<SpeechRecognitionResult> toSet() => new Set<SpeechRecognitionResult>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<SpeechRecognitionResult> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  List<SpeechRecognitionResult> take(int n) => new ListView<SpeechRecognitionResult>(this, 0, n);
 
   Iterable<SpeechRecognitionResult> takeWhile(bool test(SpeechRecognitionResult value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new TakeWhileIterable<SpeechRecognitionResult>(this, test);
   }
 
-  List<SpeechRecognitionResult> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  List<SpeechRecognitionResult> skip(int n) => new ListView<SpeechRecognitionResult>(this, n, null);
 
   Iterable<SpeechRecognitionResult> skipWhile(bool test(SpeechRecognitionResult value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new SkipWhileIterable<SpeechRecognitionResult>(this, test);
   }
 
   SpeechRecognitionResult firstMatching(bool test(SpeechRecognitionResult value), { SpeechRecognitionResult orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+    return Collections.firstMatching(this, test, orElse);
   }
 
   SpeechRecognitionResult lastMatching(bool test(SpeechRecognitionResult value), {SpeechRecognitionResult orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+    return Collections.lastMatchingInList(this, test, orElse);
   }
 
   SpeechRecognitionResult singleMatching(bool test(SpeechRecognitionResult value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+    return Collections.singleMatching(this, test);
   }
 
   SpeechRecognitionResult elementAt(int index) {
@@ -29754,9 +29750,9 @@ class _SpeechRecognitionResultList extends NativeFieldWrapperClass1 implements L
     throw new StateError("More than one element");
   }
 
-  SpeechRecognitionResult min([int compare(SpeechRecognitionResult a, SpeechRecognitionResult b)]) => IterableMixinWorkaround.min(this, compare);
+  SpeechRecognitionResult min([int compare(SpeechRecognitionResult a, SpeechRecognitionResult b)]) => Collections.min(this, compare);
 
-  SpeechRecognitionResult max([int compare(SpeechRecognitionResult a, SpeechRecognitionResult b)]) => IterableMixinWorkaround.max(this, compare);
+  SpeechRecognitionResult max([int compare(SpeechRecognitionResult a, SpeechRecognitionResult b)]) => Collections.max(this, compare);
 
   SpeechRecognitionResult removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
@@ -29822,50 +29818,50 @@ class _StyleSheetList extends NativeFieldWrapperClass1 implements List<StyleShee
   }
 
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, StyleSheet)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+    return Collections.reduce(this, initialValue, combine);
   }
 
-  bool contains(StyleSheet element) => IterableMixinWorkaround.contains(this, element);
+  bool contains(StyleSheet element) => Collections.contains(this, element);
 
-  void forEach(void f(StyleSheet element)) => IterableMixinWorkaround.forEach(this, f);
+  void forEach(void f(StyleSheet element)) => Collections.forEach(this, f);
 
-  String join([String separator]) => IterableMixinWorkaround.joinList(this, separator);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  List mappedBy(f(StyleSheet element)) => IterableMixinWorkaround.mappedByList(this, f);
+  List mappedBy(f(StyleSheet element)) => new MappedList<StyleSheet, dynamic>(this, f);
 
-  Iterable<StyleSheet> where(bool f(StyleSheet element)) => IterableMixinWorkaround.where(this, f);
+  Iterable<StyleSheet> where(bool f(StyleSheet element)) => new WhereIterable<StyleSheet>(this, f);
 
-  bool every(bool f(StyleSheet element)) => IterableMixinWorkaround.every(this, f);
+  bool every(bool f(StyleSheet element)) => Collections.every(this, f);
 
-  bool any(bool f(StyleSheet element)) => IterableMixinWorkaround.any(this, f);
+  bool any(bool f(StyleSheet element)) => Collections.any(this, f);
 
   List<StyleSheet> toList() => new List<StyleSheet>.from(this);
   Set<StyleSheet> toSet() => new Set<StyleSheet>.from(this);
 
   bool get isEmpty => this.length == 0;
 
-  List<StyleSheet> take(int n) => IterableMixinWorkaround.takeList(this, n);
+  List<StyleSheet> take(int n) => new ListView<StyleSheet>(this, 0, n);
 
   Iterable<StyleSheet> takeWhile(bool test(StyleSheet value)) {
-    return IterableMixinWorkaround.takeWhile(this, test);
+    return new TakeWhileIterable<StyleSheet>(this, test);
   }
 
-  List<StyleSheet> skip(int n) => IterableMixinWorkaround.skipList(this, n);
+  List<StyleSheet> skip(int n) => new ListView<StyleSheet>(this, n, null);
 
   Iterable<StyleSheet> skipWhile(bool test(StyleSheet value)) {
-    return IterableMixinWorkaround.skipWhile(this, test);
+    return new SkipWhileIterable<StyleSheet>(this, test);
   }
 
   StyleSheet firstMatching(bool test(StyleSheet value), { StyleSheet orElse() }) {
-    return IterableMixinWorkaround.firstMatching(this, test, orElse);
+    return Collections.firstMatching(this, test, orElse);
   }
 
   StyleSheet lastMatching(bool test(StyleSheet value), {StyleSheet orElse()}) {
-    return IterableMixinWorkaround.lastMatchingInList(this, test, orElse);
+    return Collections.lastMatchingInList(this, test, orElse);
   }
 
   StyleSheet singleMatching(bool test(StyleSheet value)) {
-    return IterableMixinWorkaround.singleMatching(this, test);
+    return Collections.singleMatching(this, test);
   }
 
   StyleSheet elementAt(int index) {
@@ -29923,9 +29919,9 @@ class _StyleSheetList extends NativeFieldWrapperClass1 implements List<StyleShee
     throw new StateError("More than one element");
   }
 
-  StyleSheet min([int compare(StyleSheet a, StyleSheet b)]) => IterableMixinWorkaround.min(this, compare);
+  StyleSheet min([int compare(StyleSheet a, StyleSheet b)]) => Collections.min(this, compare);
 
-  StyleSheet max([int compare(StyleSheet a, StyleSheet b)]) => IterableMixinWorkaround.max(this, compare);
+  StyleSheet max([int compare(StyleSheet a, StyleSheet b)]) => Collections.max(this, compare);
 
   StyleSheet removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");