Fix implementation of the Iterable interface for typed data lists.

runtime/lib/typed_data.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // patch classes for Int8List ..... Float64List and ByteData implementations.
 
 import "dart:_internal";
 import 'dart:math' show Random;
 
 patch class Int8List {
@@ skipping 257 matching lines @@
   }
 
   Iterable map(f(element)) {
     return IterableMixinWorkaround.mapList(this, f);
   }
 
   Iterable expand(Iterable f(element)) {
     return IterableMixinWorkaround.expand(this, f);
   }
 
-  // The following methods need to know the element type (int or double).
-  Iterable where(bool f(element)) {
-    return new IterableMixinWorkaround().where(this, f);
-  }
-
-  Iterable take(int n) {
-    return new IterableMixinWorkaround().takeList(this, n);
-  }
-
-  Iterable takeWhile(bool test(element)) {
-    return new IterableMixinWorkaround().takeWhile(this, test);
-  }
-
-  Iterable skip(int n) {
-    return new IterableMixinWorkaround().skipList(this, n);
-  }
-
-  Iterable skipWhile(bool test(element)) {
-    return new IterableMixinWorkaround().skipWhile(this, test);
-  }
-
-  Iterable<dynamic> get reversed {
-    return new IterableMixinWorkaround().reversedList(this);
-  }
-
-  Map<int, dynamic> asMap() {
-    return new IterableMixinWorkaround().asMapList(this);
-  }
-
-  Iterable getRange(int start, [int end]) {
-    return new IterableMixinWorkaround().getRangeList(this, start, end);
-  }
-  // End of methods returning incorrectly parameterized types.
-
   bool every(bool f(element)) {
     return IterableMixinWorkaround.every(this, f);
   }
 
   bool any(bool f(element)) {
     return IterableMixinWorkaround.any(this, f);
   }
 
   dynamic firstWhere(bool test(element), {orElse()}) {
     return IterableMixinWorkaround.firstWhere(this, test, orElse);
@@ skipping 206 matching lines @@
   // match the cids of 'this' and 'from'.
   // Uses toCid and fromCid to decide if clamping is necessary.
   // Element size of toCid and fromCid must match (test at caller).
   bool _setRange(int startInBytes, int lengthInBytes,
                  _TypedListBase from, int startFromInBytes,
                  int toCid, int fromCid)
       native "TypedData_setRange";
 }
 
 
+class _IntListMixin {
+  Iterable<int> where(bool f(int element)) => new WhereIterable<int>(this, f);
+
+  Iterable<int> take(int n) => new SubListIterable<int>(this, 0, n);
+
+  Iterable<int> takeWhile(bool test(int element)) =>
+    new TakeWhileIterable<int>(this, test);
+
+  Iterable<int> skip(int n) => new SubListIterable<int>(this, n, null);
+
+  Iterable<int> skipWhile(bool test(element)) =>
+    new SkipWhileIterable<int>(this, test);
+
+  Iterable<int> get reversed => new ReversedListIterable<int>(this);
+
+  Map<int, int> asMap() => new ListMapView<int>(this);
+
+  Iterable<int> getRange(int start, [int end]) {
+    RangeError.checkValidRange(start, end, this.length);
+    return new SubListIterable<int>(this, start, end);
+  }
+
+  Iterator<int> get iterator => new _TypedListIterator<int>(this);
+}
+
+
+class _DoubleListMixin {
+  Iterable<double> where(bool f(int element)) => new WhereIterable<double>(this, f);

[Lasse Reichstein Nielsen, 2014/12/02 12:02:54]

Long line (repeated below).

[Florian Schneider, 2014/12/02 12:17:26]

Done.

+
+  Iterable<double> take(int n) => new SubListIterable<double>(this, 0, n);
+
+  Iterable<double> takeWhile(bool test(int element)) =>
+    new TakeWhileIterable<double>(this, test);
+
+  Iterable<double> skip(int n) => new SubListIterable<double>(this, n, null);
+
+  Iterable<double> skipWhile(bool test(element)) =>
+    new SkipWhileIterable<double>(this, test);
+
+  Iterable<double> get reversed => new ReversedListIterable<double>(this);
+
+  Map<int, double> asMap() => new ListMapView<double>(this);
+
+  Iterable<double> getRange(int start, [int end]) {
+    RangeError.checkValidRange(start, end, this.length);
+    return new SubListIterable<double>(this, start, end);
+  }
+
+  Iterator<double> get iterator => new _TypedListIterator<double>(this);
+}
+
+
+class _Float32x4ListMixin {
+  Iterable<Float32x4> where(bool f(int element)) => new WhereIterable<Float32x4>(this, f);
+
+  Iterable<Float32x4> take(int n) => new SubListIterable<Float32x4>(this, 0, n);
+
+  Iterable<Float32x4> takeWhile(bool test(int element)) =>
+    new TakeWhileIterable<Float32x4>(this, test);
+
+  Iterable<Float32x4> skip(int n) => new SubListIterable<Float32x4>(this, n, null);

[Lasse Reichstein Nielsen, 2014/12/02 12:02:54]

Long line.

[Florian Schneider, 2014/12/02 12:17:26]

Done.

+
+  Iterable<Float32x4> skipWhile(bool test(element)) =>
+    new SkipWhileIterable<Float32x4>(this, test);
+
+  Iterable<Float32x4> get reversed => new ReversedListIterable<Float32x4>(this);
+
+  Map<int, Float32x4> asMap() => new ListMapView<Float32x4>(this);
+
+  Iterable<Float32x4> getRange(int start, [int end]) {
+    RangeError.checkValidRange(start, end, this.length);
+    return new SubListIterable<Float32x4>(this, start, end);
+  }
+
+  Iterator<Float32x4> get iterator => new _TypedListIterator<Float32x4>(this);
+}
+
+
+class _Int32x4ListMixin {
+  Iterable<Int32x4> where(bool f(int element)) => new WhereIterable<Int32x4>(this, f);
+
+  Iterable<Int32x4> take(int n) => new SubListIterable<Int32x4>(this, 0, n);
+
+  Iterable<Int32x4> takeWhile(bool test(int element)) =>
+    new TakeWhileIterable<Int32x4>(this, test);
+
+  Iterable<Int32x4> skip(int n) => new SubListIterable<Int32x4>(this, n, null);
+
+  Iterable<Int32x4> skipWhile(bool test(element)) =>
+    new SkipWhileIterable<Int32x4>(this, test);
+
+  Iterable<Int32x4> get reversed => new ReversedListIterable<Int32x4>(this);
+
+  Map<int, Int32x4> asMap() => new ListMapView<Int32x4>(this);
+
+  Iterable<Int32x4> getRange(int start, [int end]) {
+    RangeError.checkValidRange(start, end, this.length);
+    return new SubListIterable<Int32x4>(this, start, end);
+  }
+
+  Iterator<Int32x4> get iterator => new _TypedListIterator<Int32x4>(this);
+}
+
+
+class _Float64x2ListMixin {
+  Iterable<Float64x2> where(bool f(int element)) => new WhereIterable<Float64x2>(this, f);
+
+  Iterable<Float64x2> take(int n) => new SubListIterable<Float64x2>(this, 0, n);
+
+  Iterable<Float64x2> takeWhile(bool test(int element)) =>
+    new TakeWhileIterable<Float64x2>(this, test);
+
+  Iterable<Float64x2> skip(int n) => new SubListIterable<Float64x2>(this, n, null);
+
+  Iterable<Float64x2> skipWhile(bool test(element)) =>
+    new SkipWhileIterable<Float64x2>(this, test);
+
+  Iterable<Float64x2> get reversed => new ReversedListIterable<Float64x2>(this);
+
+  Map<int, Float64x2> asMap() => new ListMapView<Float64x2>(this);
+
+  Iterable<Float64x2> getRange(int start, [int end]) {
+    RangeError.checkValidRange(start, end, this.length);
+    return new SubListIterable<Float64x2>(this, start, end);
+  }
+
+  Iterator<Float64x2> get iterator => new _TypedListIterator<Float64x2>(this);
+}
+
+
 class _ByteBuffer implements ByteBuffer {
   final _TypedList _data;
 
   _ByteBuffer(this._data);
 
   factory _ByteBuffer._New(data) => new _ByteBuffer(data);
 
   // Forward calls to _data.
   int get lengthInBytes => _data.lengthInBytes;
   int get hashCode => _data.hashCode;
@@ skipping 175 matching lines @@
   Int32x4 _getInt32x4(int offsetInBytes) native "TypedData_GetInt32x4";
   void _setInt32x4(int offsetInBytes, Int32x4 value)
       native "TypedData_SetInt32x4";
 
   Float64x2 _getFloat64x2(int offsetInBytes) native "TypedData_GetFloat64x2";
   void _setFloat64x2(int offsetInBytes, Float64x2 value)
       native "TypedData_SetFloat64x2";
 }
 
 
-class _Int8Array extends _TypedList implements Int8List {
+class _Int8Array extends _TypedList with _IntListMixin implements Int8List {

[Lasse Reichstein Nielsen, 2014/12/02 12:02:54]

Would it work to do:
  extends _TypedList with ListBase<int> implements Int8List
?
Or will that override some functions you don't want overridden?

Maybe
  extends ListBase<int> with _TypedList implements Int8List
(and remove all methods in TypedList that uses IterableMixinWorkaround)

[Florian Schneider, 2014/12/02 12:17:26]

In principle it would work. The down-side would be that every instance of typed
list would now have the type argument stored since the super class _TypedList
with _ListMixin<int> would have type arguments

With this approach (duplicating parts of ListMixin) we can get away without
actually storing type arguments in each object - saving one word per object.

   // Factory constructors.
 
   factory _Int8Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getInt8(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _setInt8(index, _toInt8(value));
   }
 
-  Iterator<int> get iterator {
-    return new _TypedListIterator<int>(this);
-  }
-
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Int8List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   _Int8Array _createList(int length) {
     return _new(length);
   }
 
   static _Int8Array _new(int length) native "TypedData_Int8Array_new";
 }
 
 
-class _Uint8Array extends _TypedList implements Uint8List {
+class _Uint8Array extends _TypedList with _IntListMixin implements Uint8List {
   // Factory constructors.
 
   factory _Uint8Array(int length) {
     return _new(length);
   }
 
 
   // Methods implementing List interface.
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getUint8(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _setUint8(index, _toUint8(value));
   }
 
-  Iterator<int> get iterator {
-    return new _TypedListIterator<int>(this);
-  }
-
 
   // Methods implementing TypedData interface.
   int get elementSizeInBytes {
     return Uint8List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   _Uint8Array _createList(int length) {
     return _new(length);
   }
 
   static _Uint8Array _new(int length) native "TypedData_Uint8Array_new";
 }
 
 
-class _Uint8ClampedArray extends _TypedList implements Uint8ClampedList {
+class _Uint8ClampedArray extends _TypedList with _IntListMixin implements Uint8ClampedList {
   // Factory constructors.
 
   factory _Uint8ClampedArray(int length) {
     return _new(length);
   }
 
   // Methods implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getUint8(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _setUint8(index, _toClampedUint8(value));
   }
 
-  Iterator<int> get iterator {
-    return new _TypedListIterator<int>(this);
-  }
-
 
   // Methods implementing TypedData interface.
   int get elementSizeInBytes {
     return Uint8List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   _Uint8ClampedArray _createList(int length) {
     return _new(length);
   }
 
   static _Uint8ClampedArray _new(int length)
       native "TypedData_Uint8ClampedArray_new";
 }
 
 
-class _Int16Array extends _TypedList implements Int16List {
+class _Int16Array extends _TypedList with _IntListMixin implements Int16List {
   // Factory constructors.
 
   factory _Int16Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getIndexedInt16(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _setIndexedInt16(index, _toInt16(value));
   }
 
-  Iterator<int> get iterator {
-    return new _TypedListIterator<int>(this);
-  }
-
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Int16List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   _Int16Array _createList(int length) {
     return _new(length);
   }
 
   int _getIndexedInt16(int index) {
     return _getInt16(index * Int16List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedInt16(int index, int value) {
     _setInt16(index * Int16List.BYTES_PER_ELEMENT, value);
   }
 
   static _Int16Array _new(int length) native "TypedData_Int16Array_new";
 }
 
 
-class _Uint16Array extends _TypedList implements Uint16List {
+class _Uint16Array extends _TypedList with _IntListMixin implements Uint16List {
   // Factory constructors.
 
   factory _Uint16Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getIndexedUint16(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _setIndexedUint16(index, _toUint16(value));
   }
 
-  Iterator<int> get iterator {
-    return new _TypedListIterator<int>(this);
-  }
-
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Uint16List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   _Uint16Array _createList(int length) {
     return _new(length);
   }
 
   int _getIndexedUint16(int index) {
     return _getUint16(index * Uint16List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedUint16(int index, int value) {
     _setUint16(index * Uint16List.BYTES_PER_ELEMENT, value);
   }
 
   static _Uint16Array _new(int length) native "TypedData_Uint16Array_new";
 }
 
 
-class _Int32Array extends _TypedList implements Int32List {
+class _Int32Array extends _TypedList with _IntListMixin implements Int32List {
   // Factory constructors.
 
   factory _Int32Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getIndexedInt32(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _setIndexedInt32(index, _toInt32(value));
   }
 
-  Iterator<int> get iterator {
-    return new _TypedListIterator<int>(this);
-  }
-
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Int32List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   _Int32Array _createList(int length) {
     return _new(length);
   }
 
   int _getIndexedInt32(int index) {
     return _getInt32(index * Int32List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedInt32(int index, int value) {
     _setInt32(index * Int32List.BYTES_PER_ELEMENT, value);
   }
 
   static _Int32Array _new(int length) native "TypedData_Int32Array_new";
 }
 
 
-class _Uint32Array extends _TypedList implements Uint32List {
+class _Uint32Array extends _TypedList with _IntListMixin implements Uint32List {
   // Factory constructors.
 
   factory _Uint32Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getIndexedUint32(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _setIndexedUint32(index, _toUint32(value));
   }
 
-  Iterator<int> get iterator {
-    return new _TypedListIterator<int>(this);
-  }
-
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Uint32List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   _Uint32Array _createList(int length) {
     return _new(length);
   }
 
   int _getIndexedUint32(int index) {
     return _getUint32(index * Uint32List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedUint32(int index, int value) {
     _setInt32(index * Uint32List.BYTES_PER_ELEMENT, value);
   }
 
   static _Uint32Array _new(int length) native "TypedData_Uint32Array_new";
 }
 
 
-class _Int64Array extends _TypedList implements Int64List {
+class _Int64Array extends _TypedList with _IntListMixin implements Int64List {
   // Factory constructors.
 
   factory _Int64Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getIndexedInt64(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _setIndexedInt64(index, _toInt64(value));
   }
 
-  Iterator<int> get iterator {
-    return new _TypedListIterator<int>(this);
-  }
-
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Int64List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   _Int64Array _createList(int length) {
     return _new(length);
   }
 
   int _getIndexedInt64(int index) {
     return _getInt64(index * Int64List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedInt64(int index, int value) {
     _setInt64(index * Int64List.BYTES_PER_ELEMENT, value);
   }
 
   static _Int64Array _new(int length) native "TypedData_Int64Array_new";
 }
 
 
-class _Uint64Array extends _TypedList implements Uint64List {
+class _Uint64Array extends _TypedList with _IntListMixin implements Uint64List {
   // Factory constructors.
 
   factory _Uint64Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getIndexedUint64(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _setIndexedUint64(index, _toUint64(value));
   }
 
-  Iterator<int> get iterator {
-    return new _TypedListIterator<int>(this);
-  }
-
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Uint64List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   _Uint64Array _createList(int length) {
     return _new(length);
   }
 
   int _getIndexedUint64(int index) {
     return _getUint64(index * Uint64List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedUint64(int index, int value) {
     _setUint64(index * Uint64List.BYTES_PER_ELEMENT, value);
   }
 
   static _Uint64Array _new(int length) native "TypedData_Uint64Array_new";
 }
 
 
-class _Float32Array extends _TypedList implements Float32List {
+class _Float32Array extends _TypedList with _DoubleListMixin implements Float32List {
   // Factory constructors.
 
   factory _Float32Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   double operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getIndexedFloat32(index);
   }
 
   void operator[]=(int index, double value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _setIndexedFloat32(index, value);
   }
 
-  Iterator<double> get iterator {
-    return new _TypedListIterator<double>(this);
-  }
-
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Float32List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   _Float32Array _createList(int length) {
     return _new(length);
   }
 
   double _getIndexedFloat32(int index) {
     return _getFloat32(index * Float32List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedFloat32(int index, double value) {
     _setFloat32(index * Float32List.BYTES_PER_ELEMENT, value);
   }
 
   static _Float32Array _new(int length) native "TypedData_Float32Array_new";
 }
 
 
-class _Float64Array extends _TypedList implements Float64List {
+class _Float64Array extends _TypedList with _DoubleListMixin implements Float64List {
   // Factory constructors.
 
   factory _Float64Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   double operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getIndexedFloat64(index);
   }
 
   void operator[]=(int index, double value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _setIndexedFloat64(index, value);
   }
 
-  Iterator<double> get iterator {
-    return new _TypedListIterator<double>(this);
-  }
-
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Float64List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   _Float64Array _createList(int length) {
     return _new(length);
   }
 
   double _getIndexedFloat64(int index) {
     return _getFloat64(index * Float64List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedFloat64(int index, double value) {
     _setFloat64(index * Float64List.BYTES_PER_ELEMENT, value);
   }
 
   static _Float64Array _new(int length) native "TypedData_Float64Array_new";
 }
 
 
-class _Float32x4Array extends _TypedList implements Float32x4List {
+class _Float32x4Array extends _TypedList with _Float32x4ListMixin implements Float32x4List {
   // Factory constructors.
 
   factory _Float32x4Array(int length) {
     return _new(length);
   }
 
 
   Float32x4 operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getIndexedFloat32x4(index);
   }
 
   void operator[]=(int index, Float32x4 value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _setIndexedFloat32x4(index, value);
   }
 
-  Iterator<Float32x4> get iterator {
-    return new _TypedListIterator<Float32x4>(this);
-  }
-
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Float32x4List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   _Float32x4Array _createList(int length) {
     return _new(length);
   }
 
   Float32x4 _getIndexedFloat32x4(int index) {
     return _getFloat32x4(index * Float32x4List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedFloat32x4(int index, Float32x4 value) {
     _setFloat32x4(index * Float32x4List.BYTES_PER_ELEMENT, value);
   }
 
   static _Float32x4Array _new(int length) native "TypedData_Float32x4Array_new";
 }
 
 
-class _Int32x4Array extends _TypedList implements Int32x4List {
+class _Int32x4Array extends _TypedList with _Int32x4ListMixin implements Int32x4List {
   // Factory constructors.
 
   factory _Int32x4Array(int length) {
     return _new(length);
   }
 
 
   Int32x4 operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getIndexedInt32x4(index);
   }
 
   void operator[]=(int index, Int32x4 value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _setIndexedInt32x4(index, value);
   }
 
-  Iterator<Int32x4> get iterator {
-    return new _TypedListIterator<Int32x4>(this);
-  }
-
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Int32x4List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   _Int32x4Array _createList(int length) {
     return _new(length);
   }
 
   Int32x4 _getIndexedInt32x4(int index) {
     return _getInt32x4(index * Int32x4List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedInt32x4(int index, Int32x4 value) {
     _setInt32x4(index * Int32x4List.BYTES_PER_ELEMENT, value);
   }
 
   static _Int32x4Array _new(int length) native "TypedData_Int32x4Array_new";
 }
 
 
-class _Float64x2Array extends _TypedList implements Float64x2List {
+class _Float64x2Array extends _TypedList with _Float64x2ListMixin implements Float64x2List {
   // Factory constructors.
 
   factory _Float64x2Array(int length) {
     return _new(length);
   }
 
 
   Float64x2 operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getIndexedFloat64x2(index);
   }
 
   void operator[]=(int index, Float64x2 value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _setIndexedFloat64x2(index, value);
   }
 
-  Iterator<Float64x2> get iterator {
-    return new _TypedListIterator<Float64x2>(this);
-  }
-
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Float64x2List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   _Float64x2Array _createList(int length) {
     return _new(length);
   }
 
   Float64x2 _getIndexedFloat64x2(int index) {
     return _getFloat64x2(index * Float64x2List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedFloat64x2(int index, Float64x2 value) {
     _setFloat64x2(index * Float64x2List.BYTES_PER_ELEMENT, value);
   }
 
   static _Float64x2Array _new(int length) native "TypedData_Float64x2Array_new";
 }
 
 
-class _ExternalInt8Array extends _TypedList implements Int8List {
+class _ExternalInt8Array extends _TypedList with _IntListMixin implements Int8List {
   // Factory constructors.
 
   factory _ExternalInt8Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getInt8(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _setInt8(index, value);
   }
 
-  Iterator<int> get iterator {
-    return new _TypedListIterator<int>(this);
-  }
-
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Int8List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   Int8List _createList(int length) {
     return new Int8List(length);
   }
 
   static _ExternalInt8Array _new(int length) native
       "ExternalTypedData_Int8Array_new";
 }
 
 
-class _ExternalUint8Array extends _TypedList implements Uint8List {
+class _ExternalUint8Array extends _TypedList with _IntListMixin implements Uint8List {
   // Factory constructors.
 
   factory _ExternalUint8Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getUint8(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _setUint8(index, _toUint8(value));
   }
 
-  Iterator<int> get iterator {
-    return new _TypedListIterator<int>(this);
-  }
-
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Uint8List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   Uint8List _createList(int length) {
     return new Uint8List(length);
   }
 
   static _ExternalUint8Array _new(int length) native
       "ExternalTypedData_Uint8Array_new";
 }
 
 
-class _ExternalUint8ClampedArray extends _TypedList implements Uint8ClampedList {
+class _ExternalUint8ClampedArray extends _TypedList with _IntListMixin implements Uint8ClampedList {
   // Factory constructors.
 
   factory _ExternalUint8ClampedArray(int length) {
     return _new(length);
   }
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getUint8(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _setUint8(index, _toClampedUint8(value));
   }
 
-  Iterator<int> get iterator {
-    return new _TypedListIterator<int>(this);
-  }
-
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Uint8List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   Uint8ClampedList _createList(int length) {
     return new Uint8ClampedList(length);
   }
 
   static _ExternalUint8ClampedArray _new(int length) native
       "ExternalTypedData_Uint8ClampedArray_new";
 }
 
 
-class _ExternalInt16Array extends _TypedList implements Int16List {
+class _ExternalInt16Array extends _TypedList with _IntListMixin implements Int16List {
   // Factory constructors.
 
   factory _ExternalInt16Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getIndexedInt16(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _setIndexedInt16(index, _toInt16(value));
   }
 
-  Iterator<int> get iterator {
-    return new _TypedListIterator<int>(this);
-  }
-
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Int16List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   Int16List _createList(int length) {
     return new Int16List(length);
   }
 
   int _getIndexedInt16(int index) {
     return _getInt16(index * Int16List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedInt16(int index, int value) {
     _setInt16(index * Int16List.BYTES_PER_ELEMENT, value);
   }
 
   static _ExternalInt16Array _new(int length) native
       "ExternalTypedData_Int16Array_new";
 }
 
 
-class _ExternalUint16Array extends _TypedList implements Uint16List {
+class _ExternalUint16Array extends _TypedList with _IntListMixin implements Uint16List {
   // Factory constructors.
 
   factory _ExternalUint16Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getIndexedUint16(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _setIndexedUint16(index, _toUint16(value));
   }
 
-  Iterator<int> get iterator {
-    return new _TypedListIterator<int>(this);
-  }
-
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Uint16List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   Uint16List _createList(int length) {
     return new Uint16List(length);
   }
 
   int _getIndexedUint16(int index) {
     return _getUint16(index * Uint16List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedUint16(int index, int value) {
     _setUint16(index * Uint16List.BYTES_PER_ELEMENT, value);
   }
 
   static _ExternalUint16Array _new(int length) native
       "ExternalTypedData_Uint16Array_new";
 }
 
 
-class _ExternalInt32Array extends _TypedList implements Int32List {
+class _ExternalInt32Array extends _TypedList with _IntListMixin implements Int32List {
   // Factory constructors.
 
   factory _ExternalInt32Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getIndexedInt32(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _setIndexedInt32(index, _toInt32(value));
   }
 
-  Iterator<int> get iterator {
-    return new _TypedListIterator<int>(this);
-  }
-
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Int32List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   Int32List _createList(int length) {
     return new Int32List(length);
   }
 
   int _getIndexedInt32(int index) {
     return _getInt32(index * Int32List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedInt32(int index, int value) {
     _setInt32(index * Int32List.BYTES_PER_ELEMENT, value);
   }
 
   static _ExternalInt32Array _new(int length) native
       "ExternalTypedData_Int32Array_new";
 }
 
 
-class _ExternalUint32Array extends _TypedList implements Uint32List {
+class _ExternalUint32Array extends _TypedList with _IntListMixin implements Uint32List {
   // Factory constructors.
 
   factory _ExternalUint32Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getIndexedUint32(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _setIndexedUint32(index, _toUint32(value));
   }
 
-  Iterator<int> get iterator {
-    return new _TypedListIterator<int>(this);
-  }
-
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Uint32List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   Uint32List _createList(int length) {
     return new Uint32List(length);
   }
 
   int _getIndexedUint32(int index) {
     return _getUint32(index * Uint32List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedUint32(int index, int value) {
     _setInt32(index * Uint32List.BYTES_PER_ELEMENT, value);
   }
 
   static _ExternalUint32Array _new(int length) native
       "ExternalTypedData_Uint32Array_new";
 }
 
 
-class _ExternalInt64Array extends _TypedList implements Int64List {
+class _ExternalInt64Array extends _TypedList with _IntListMixin implements Int64List {
   // Factory constructors.
 
   factory _ExternalInt64Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getIndexedInt64(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _setIndexedInt64(index, _toInt64(value));
   }
 
-  Iterator<int> get iterator {
-    return new _TypedListIterator<int>(this);
-  }
-
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Int64List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   Int64List _createList(int length) {
     return new Int64List(length);
   }
 
   int _getIndexedInt64(int index) {
     return _getInt64(index * Int64List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedInt64(int index, int value) {
     _setInt64(index * Int64List.BYTES_PER_ELEMENT, value);
   }
 
   static _ExternalInt64Array _new(int length) native
       "ExternalTypedData_Int64Array_new";
 }
 
 
-class _ExternalUint64Array extends _TypedList implements Uint64List {
+class _ExternalUint64Array extends _TypedList with _IntListMixin implements Uint64List {
   // Factory constructors.
 
   factory _ExternalUint64Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getIndexedUint64(index);
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _setIndexedUint64(index, _toUint64(value));
   }
 
-  Iterator<int> get iterator {
-    return new _TypedListIterator<int>(this);
-  }
-
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Uint64List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   Uint64List _createList(int length) {
     return new Uint64List(length);
   }
 
   int _getIndexedUint64(int index) {
     return _getUint64(index * Uint64List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedUint64(int index, int value) {
     _setUint64(index * Uint64List.BYTES_PER_ELEMENT, value);
   }
 
   static _ExternalUint64Array _new(int length) native
       "ExternalTypedData_Uint64Array_new";
 }
 
 
-class _ExternalFloat32Array extends _TypedList implements Float32List {
+class _ExternalFloat32Array extends _TypedList with _DoubleListMixin implements Float32List {
   // Factory constructors.
 
   factory _ExternalFloat32Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   double operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getIndexedFloat32(index);
   }
 
   void operator[]=(int index, double value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _setIndexedFloat32(index, value);
   }
 
-  Iterator<double> get iterator {
-    return new _TypedListIterator<double>(this);
-  }
-
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Float32List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   Float32List _createList(int length) {
     return new Float32List(length);
   }
 
   double _getIndexedFloat32(int index) {
     return _getFloat32(index * Float32List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedFloat32(int index, double value) {
     _setFloat32(index * Float32List.BYTES_PER_ELEMENT, value);
   }
 
   static _ExternalFloat32Array _new(int length) native
       "ExternalTypedData_Float32Array_new";
 }
 
 
-class _ExternalFloat64Array extends _TypedList implements Float64List {
+class _ExternalFloat64Array extends _TypedList with _DoubleListMixin implements Float64List {
   // Factory constructors.
 
   factory _ExternalFloat64Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   double operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getIndexedFloat64(index);
   }
 
   void operator[]=(int index, double value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _setIndexedFloat64(index, value);
   }
 
-  Iterator<double> get iterator {
-    return new _TypedListIterator<double>(this);
-  }
-
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Float64List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   Float64List _createList(int length) {
     return new Float64List(length);
   }
 
   double _getIndexedFloat64(int index) {
     return _getFloat64(index * Float64List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedFloat64(int index, double value) {
     _setFloat64(index * Float64List.BYTES_PER_ELEMENT, value);
   }
 
   static _ExternalFloat64Array _new(int length) native
       "ExternalTypedData_Float64Array_new";
 }
 
 
-class _ExternalFloat32x4Array extends _TypedList implements Float32x4List {
+class _ExternalFloat32x4Array extends _TypedList with _Float32x4ListMixin implements Float32x4List {
   // Factory constructors.
 
   factory _ExternalFloat32x4Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   Float32x4 operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getIndexedFloat32x4(index);
   }
 
   void operator[]=(int index, Float32x4 value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _setIndexedFloat32x4(index, value);
   }
 
-  Iterator<Float32x4> get iterator {
-    return new _TypedListIterator<Float32x4>(this);
-  }
-
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Float32x4List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   Float32x4List _createList(int length) {
     return new Float32x4List(length);
   }
 
   Float32x4 _getIndexedFloat32x4(int index) {
     return _getFloat32x4(index * Float32x4List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedFloat32x4(int index, Float32x4 value) {
     _setFloat32x4(index * Float32x4List.BYTES_PER_ELEMENT, value);
   }
 
   static _ExternalFloat32x4Array _new(int length) native
       "ExternalTypedData_Float32x4Array_new";
 }
 
 
-class _ExternalInt32x4Array extends _TypedList implements Int32x4List {
+class _ExternalInt32x4Array extends _TypedList with _Int32x4ListMixin implements Int32x4List {
   // Factory constructors.
 
   factory _ExternalInt32x4Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   Int32x4 operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getIndexedInt32x4(index);
   }
 
   void operator[]=(int index, Int32x4 value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _setIndexedInt32x4(index, value);
   }
 
-  Iterator<Int32x4> get iterator {
-    return new _TypedListIterator<Int32x4>(this);
-  }
-
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Int32x4List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   Int32x4List _createList(int length) {
     return new Int32x4List(length);
   }
 
   Int32x4 _getIndexedInt32x4(int index) {
     return _getInt32x4(index * Int32x4List.BYTES_PER_ELEMENT);
   }
 
   void _setIndexedInt32x4(int index, Int32x4 value) {
     _setInt32x4(index * Int32x4List.BYTES_PER_ELEMENT, value);
   }
 
   static _ExternalInt32x4Array _new(int length) native
       "ExternalTypedData_Int32x4Array_new";
 }
 
 
-class _ExternalFloat64x2Array extends _TypedList implements Float64x2List {
+class _ExternalFloat64x2Array extends _TypedList with _Float64x2ListMixin implements Float64x2List {
   // Factory constructors.
 
   factory _ExternalFloat64x2Array(int length) {
     return _new(length);
   }
 
 
   // Method(s) implementing the List interface.
 
   Float64x2 operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getIndexedFloat64x2(index);
   }
 
   void operator[]=(int index, Float64x2 value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _setIndexedFloat64x2(index, value);
   }
 
-  Iterator<Float64x2> get iterator {
-    return new _TypedListIterator<Float64x2>(this);
-  }
-
 
   // Method(s) implementing the TypedData interface.
 
   int get elementSizeInBytes {
     return Float64x2List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
@@ skipping 279 matching lines @@
   ByteBuffer get buffer {
     return _typedData.buffer;
   }
 
   final TypedData _typedData;
   final int offsetInBytes;
   final int length;
 }
 
 
-class _Int8ArrayView extends _TypedListView implements Int8List {
+class _Int8ArrayView extends _TypedListView with _IntListMixin implements Int8List {
   // Constructor.
   _Int8ArrayView(ByteBuffer buffer, [int _offsetInBytes = 0, int _length])
     : super(buffer, _offsetInBytes,
             _defaultIfNull(_length,
                            ((buffer.lengthInBytes - _offsetInBytes) ~/
                             Int8List.BYTES_PER_ELEMENT))) {
     _rangeCheck(buffer.lengthInBytes,
                 _offsetInBytes,
                 length * Int8List.BYTES_PER_ELEMENT);
   }
@@ skipping 10 matching lines @@
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _typedData._setInt8(offsetInBytes + (index * Int8List.BYTES_PER_ELEMENT),
                         _toInt8(value));
   }
 
-  Iterator<int> get iterator {
-    return new _TypedListIterator<int>(this);
-  }
-
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Int8List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   Int8List _createList(int length) {
     return new Int8List(length);
   }
 }
 
 
-class _Uint8ArrayView extends _TypedListView implements Uint8List {
+class _Uint8ArrayView extends _TypedListView with _IntListMixin implements Uint8List {
   // Constructor.
   _Uint8ArrayView(ByteBuffer buffer, [int _offsetInBytes = 0, int _length])
     : super(buffer, _offsetInBytes,
             _defaultIfNull(_length,
                            ((buffer.lengthInBytes - _offsetInBytes) ~/
                             Uint8List.BYTES_PER_ELEMENT))) {
     _rangeCheck(buffer.lengthInBytes,
                 _offsetInBytes,
                 length * Uint8List.BYTES_PER_ELEMENT);
   }
@@ skipping 10 matching lines @@
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _typedData._setUint8(offsetInBytes + (index * Uint8List.BYTES_PER_ELEMENT),
                          _toUint8(value));
   }
 
-  Iterator<int> get iterator {
-    return new _TypedListIterator<int>(this);
-  }
-
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Uint8List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   Uint8List _createList(int length) {
     return new Uint8List(length);
   }
 }
 
 
-class _Uint8ClampedArrayView extends _TypedListView implements Uint8ClampedList {
+class _Uint8ClampedArrayView extends _TypedListView with _IntListMixin implements Uint8ClampedList {
   // Constructor.
   _Uint8ClampedArrayView(ByteBuffer buffer,
                          [int _offsetInBytes = 0, int _length])
     : super(buffer, _offsetInBytes,
             _defaultIfNull(_length,
                            ((buffer.lengthInBytes - _offsetInBytes) ~/
                             Uint8List.BYTES_PER_ELEMENT))) {
     _rangeCheck(buffer.lengthInBytes,
                 offsetInBytes,
                 length * Uint8List.BYTES_PER_ELEMENT);
@@ skipping 11 matching lines @@
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _typedData._setUint8(offsetInBytes + (index * Uint8List.BYTES_PER_ELEMENT),
                          _toClampedUint8(value));
   }
 
-  Iterator<int> get iterator {
-    return new _TypedListIterator<int>(this);
-  }
-
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Uint8List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   Uint8ClampedList _createList(int length) {
     return new Uint8ClampedList(length);
   }
 }
 
 
-class _Int16ArrayView extends _TypedListView implements Int16List {
+class _Int16ArrayView extends _TypedListView with _IntListMixin implements Int16List {
   // Constructor.
   _Int16ArrayView(ByteBuffer buffer, [int _offsetInBytes = 0, int _length])
     : super(buffer, _offsetInBytes,
             _defaultIfNull(_length,
                            ((buffer.lengthInBytes - _offsetInBytes) ~/
                             Int16List.BYTES_PER_ELEMENT))) {
     _rangeCheck(buffer.lengthInBytes,
                 offsetInBytes,
                 length * Int16List.BYTES_PER_ELEMENT);
     _offsetAlignmentCheck(_offsetInBytes, Int16List.BYTES_PER_ELEMENT);
@@ skipping 11 matching lines @@
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _typedData._setInt16(offsetInBytes + (index * Int16List.BYTES_PER_ELEMENT),
                          _toInt16(value));
   }
 
-  Iterator<int> get iterator {
-    return new _TypedListIterator<int>(this);
-  }
-
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Int16List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   Int16List _createList(int length) {
     return new Int16List(length);
   }
 }
 
 
-class _Uint16ArrayView extends _TypedListView implements Uint16List {
+class _Uint16ArrayView extends _TypedListView with _IntListMixin implements Uint16List {
   // Constructor.
   _Uint16ArrayView(ByteBuffer buffer, [int _offsetInBytes = 0, int _length])
     : super(buffer, _offsetInBytes,
             _defaultIfNull(_length,
                            ((buffer.lengthInBytes - _offsetInBytes) ~/
                             Uint16List.BYTES_PER_ELEMENT))) {
     _rangeCheck(buffer.lengthInBytes,
                 offsetInBytes,
                 length * Uint16List.BYTES_PER_ELEMENT);
     _offsetAlignmentCheck(_offsetInBytes, Uint16List.BYTES_PER_ELEMENT);
@@ skipping 11 matching lines @@
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _typedData._setUint16(offsetInBytes + (index * Uint16List.BYTES_PER_ELEMENT),
                           _toUint16(value));
   }
 
-  Iterator<int> get iterator {
-    return new _TypedListIterator<int>(this);
-  }
-
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Uint16List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   Uint16List _createList(int length) {
     return new Uint16List(length);
   }
 }
 
 
-class _Int32ArrayView extends _TypedListView implements Int32List {
+class _Int32ArrayView extends _TypedListView with _IntListMixin implements Int32List {
   // Constructor.
   _Int32ArrayView(ByteBuffer buffer, [int _offsetInBytes = 0, int _length])
     : super(buffer, _offsetInBytes,
             _defaultIfNull(_length,
                            ((buffer.lengthInBytes - _offsetInBytes) ~/
                             Int32List.BYTES_PER_ELEMENT))) {
     _rangeCheck(buffer.lengthInBytes,
                 offsetInBytes,
                 length * Int32List.BYTES_PER_ELEMENT);
     _offsetAlignmentCheck(_offsetInBytes, Int32List.BYTES_PER_ELEMENT);
@@ skipping 11 matching lines @@
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _typedData._setInt32(offsetInBytes + (index * Int32List.BYTES_PER_ELEMENT),
                          _toInt32(value));
   }
 
-  Iterator<int> get iterator {
-    return new _TypedListIterator<int>(this);
-  }
-
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Int32List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   Int32List _createList(int length) {
     return new Int32List(length);
   }
 }
 
 
-class _Uint32ArrayView extends _TypedListView implements Uint32List {
+class _Uint32ArrayView extends _TypedListView with _IntListMixin implements Uint32List {
   // Constructor.
   _Uint32ArrayView(ByteBuffer buffer, [int _offsetInBytes = 0, int _length])
     : super(buffer, _offsetInBytes,
             _defaultIfNull(_length,
                            ((buffer.lengthInBytes - _offsetInBytes) ~/
                             Uint32List.BYTES_PER_ELEMENT))) {
     _rangeCheck(buffer.lengthInBytes,
                 offsetInBytes,
                 length * Uint32List.BYTES_PER_ELEMENT);
     _offsetAlignmentCheck(_offsetInBytes, Uint32List.BYTES_PER_ELEMENT);
@@ skipping 11 matching lines @@
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _typedData._setUint32(offsetInBytes + (index * Uint32List.BYTES_PER_ELEMENT),
                           _toUint32(value));
   }
 
-  Iterator<int> get iterator {
-    return new _TypedListIterator<int>(this);
-  }
-
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Uint32List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   Uint32List _createList(int length) {
     return new Uint32List(length);
   }
 }
 
 
-class _Int64ArrayView extends _TypedListView implements Int64List {
+class _Int64ArrayView extends _TypedListView with _IntListMixin implements Int64List {
   // Constructor.
   _Int64ArrayView(ByteBuffer buffer, [int _offsetInBytes = 0, int _length])
     : super(buffer, _offsetInBytes,
             _defaultIfNull(_length,
                            ((buffer.lengthInBytes - _offsetInBytes) ~/
                             Int64List.BYTES_PER_ELEMENT))) {
     _rangeCheck(buffer.lengthInBytes,
                 offsetInBytes,
                 length * Int64List.BYTES_PER_ELEMENT);
     _offsetAlignmentCheck(_offsetInBytes, Int64List.BYTES_PER_ELEMENT);
@@ skipping 11 matching lines @@
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _typedData._setInt64(offsetInBytes + (index * Int64List.BYTES_PER_ELEMENT),
                          _toInt64(value));
   }
 
-  Iterator<int> get iterator {
-    return new _TypedListIterator<int>(this);
-  }
-
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Int64List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   Int64List _createList(int length) {
     return new Int64List(length);
   }
 }
 
 
-class _Uint64ArrayView extends _TypedListView implements Uint64List {
+class _Uint64ArrayView extends _TypedListView with _IntListMixin implements Uint64List {
   // Constructor.
   _Uint64ArrayView(ByteBuffer buffer, [int _offsetInBytes = 0, int _length])
     : super(buffer, _offsetInBytes,
             _defaultIfNull(_length,
                            ((buffer.lengthInBytes - _offsetInBytes) ~/
                             Uint64List.BYTES_PER_ELEMENT))) {
     _rangeCheck(buffer.lengthInBytes,
                 offsetInBytes,
                 length * Uint64List.BYTES_PER_ELEMENT);
     _offsetAlignmentCheck(_offsetInBytes, Uint64List.BYTES_PER_ELEMENT);
@@ skipping 11 matching lines @@
   }
 
   void operator[]=(int index, int value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _typedData._setUint64(offsetInBytes + (index * Uint64List.BYTES_PER_ELEMENT),
                           _toUint64(value));
   }
 
-  Iterator<int> get iterator {
-    return new _TypedListIterator<int>(this);
-  }
-
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Uint64List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   Uint64List _createList(int length) {
     return new Uint64List(length);
   }
 }
 
 
-class _Float32ArrayView extends _TypedListView implements Float32List {
+class _Float32ArrayView extends _TypedListView with _DoubleListMixin implements Float32List {
   // Constructor.
   _Float32ArrayView(ByteBuffer buffer, [int _offsetInBytes = 0, int _length])
     : super(buffer, _offsetInBytes,
             _defaultIfNull(_length,
                            ((buffer.lengthInBytes - _offsetInBytes) ~/
                             Float32List.BYTES_PER_ELEMENT))) {
     _rangeCheck(buffer.lengthInBytes,
                 offsetInBytes,
                 length * Float32List.BYTES_PER_ELEMENT);
     _offsetAlignmentCheck(_offsetInBytes, Float32List.BYTES_PER_ELEMENT);
@@ skipping 11 matching lines @@
   }
 
   void operator[]=(int index, double value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _typedData._setFloat32(offsetInBytes +
                            (index * Float32List.BYTES_PER_ELEMENT), value);
   }
 
-  Iterator<double> get iterator {
-    return new _TypedListIterator<double>(this);
-  }
-
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Float32List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   Float32List _createList(int length) {
     return new Float32List(length);
   }
 }
 
 
-class _Float64ArrayView extends _TypedListView implements Float64List {
+class _Float64ArrayView extends _TypedListView with _DoubleListMixin implements Float64List {
   // Constructor.
   _Float64ArrayView(ByteBuffer buffer, [int _offsetInBytes = 0, int _length])
     : super(buffer, _offsetInBytes,
             _defaultIfNull(_length,
                            ((buffer.lengthInBytes - _offsetInBytes) ~/
                             Float64List.BYTES_PER_ELEMENT))) {
     _rangeCheck(buffer.lengthInBytes,
                 offsetInBytes,
                 length * Float64List.BYTES_PER_ELEMENT);
     _offsetAlignmentCheck(_offsetInBytes, Float64List.BYTES_PER_ELEMENT);
@@ skipping 11 matching lines @@
   }
 
   void operator[]=(int index, double value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _typedData._setFloat64(offsetInBytes +
                           (index * Float64List.BYTES_PER_ELEMENT), value);
   }
 
-  Iterator<double> get iterator {
-    return new _TypedListIterator<double>(this);
-  }
-
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Float64List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   Float64List _createList(int length) {
     return new Float64List(length);
   }
 }
 
 
-class _Float32x4ArrayView extends _TypedListView implements Float32x4List {
+class _Float32x4ArrayView extends _TypedListView with _Float32x4ListMixin implements Float32x4List {
   // Constructor.
   _Float32x4ArrayView(ByteBuffer buffer, [int _offsetInBytes = 0, int _length])
     : super(buffer, _offsetInBytes,
             _defaultIfNull(_length,
                            ((buffer.lengthInBytes - _offsetInBytes) ~/
                             Float32x4List.BYTES_PER_ELEMENT))) {
     _rangeCheck(buffer.lengthInBytes,
                 offsetInBytes,
                 length * Float32x4List.BYTES_PER_ELEMENT);
     _offsetAlignmentCheck(_offsetInBytes, Float32x4List.BYTES_PER_ELEMENT);
@@ skipping 11 matching lines @@
   }
 
   void operator[]=(int index, Float32x4 value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _typedData._setFloat32x4(offsetInBytes +
                              (index * Float32x4List.BYTES_PER_ELEMENT), value);
   }
 
-  Iterator<Float32x4> get iterator {
-    return new _TypedListIterator<Float32x4>(this);
-  }
-
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Float32x4List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   Float32x4List _createList(int length) {
     return new Float32x4List(length);
   }
 }
 
 
-class _Int32x4ArrayView extends _TypedListView implements Int32x4List {
+class _Int32x4ArrayView extends _TypedListView with _Int32x4ListMixin implements Int32x4List {
   // Constructor.
   _Int32x4ArrayView(ByteBuffer buffer, [int _offsetInBytes = 0, int _length])
     : super(buffer, _offsetInBytes,
             _defaultIfNull(_length,
                            ((buffer.lengthInBytes - _offsetInBytes) ~/
                             Int32x4List.BYTES_PER_ELEMENT))) {
     _rangeCheck(buffer.lengthInBytes,
                 offsetInBytes,
                 length * Int32x4List.BYTES_PER_ELEMENT);
     _offsetAlignmentCheck(_offsetInBytes, Int32x4List.BYTES_PER_ELEMENT);
@@ skipping 11 matching lines @@
   }
 
   void operator[]=(int index, Int32x4 value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _typedData._setInt32x4(offsetInBytes +
                             (index * Int32x4List.BYTES_PER_ELEMENT), value);
   }
 
-  Iterator<Int32x4> get iterator {
-    return new _TypedListIterator<Int32x4>(this);
-  }
-
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Int32x4List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
   Int32x4List _createList(int length) {
     return new Int32x4List(length);
   }
 }
 
 
-class _Float64x2ArrayView extends _TypedListView implements Float64x2List {
+class _Float64x2ArrayView extends _TypedListView with _Float64x2ListMixin implements Float64x2List {
   // Constructor.
   _Float64x2ArrayView(ByteBuffer buffer, [int _offsetInBytes = 0, int _length])
     : super(buffer, _offsetInBytes,
             _defaultIfNull(_length,
                            ((buffer.lengthInBytes - _offsetInBytes) ~/
                             Float64x2List.BYTES_PER_ELEMENT))) {
     _rangeCheck(buffer.lengthInBytes,
                 offsetInBytes,
                 length * Float64x2List.BYTES_PER_ELEMENT);
     _offsetAlignmentCheck(_offsetInBytes, Float64x2List.BYTES_PER_ELEMENT);
@@ skipping 11 matching lines @@
   }
 
   void operator[]=(int index, Float64x2 value) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     _typedData._setFloat64x2(offsetInBytes +
                              (index * Float64x2List.BYTES_PER_ELEMENT), value);
   }
 
-  Iterator<Float64x2> get iterator {
-    return new _TypedListIterator<Float64x2>(this);
-  }
-
 
   // Method(s) implementing TypedData interface.
 
   int get elementSizeInBytes {
     return Float64x2List.BYTES_PER_ELEMENT;
   }
 
 
   // Internal utility methods.
 
@@ skipping 371 matching lines @@
     return value;
   }
   return object;
 }
 
 
 void _throwRangeError(int index, int length) {
   String message = "$index must be in the range [0..$length)";
   throw new RangeError(message);
 }