Fix usage of many iterable functions on floating point typed 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.
 
 patch class Int8List {
   /* patch */ factory Int8List(int length) {
     return new _Int8Array(length);
   }
@@ skipping 264 matching lines @@
 }
 
 
 // Based class for _TypedList that provides common methods for implementing
 // the collection and list interfaces.
 
 abstract class _TypedListBase {
   // Method(s) implementing the Collection interface.
   bool contains(element) => IterableMixinWorkaround.contains(this, element);
 
-  void forEach(void f(element)) {
+  void forEach(void f(num element)) {

[Lasse Reichstein Nielsen, 2013/05/31 09:18:21]

'num' works for callbacks and return values, and we don't seem to use it for
elements to be inserted into the array, so this should be fine.

Ofcourse, it would be better if _TypedListBase was generic, and the type was T.
I assume that was avoided because the VM can't optimize generic types in
superclasses yet.

[floitsch, 2013/05/31 15:06:25]

Yes. I talked to the VM people. No for generic type. (also wouldn't compile
anymore).

     var len = this.length;
     for (var i = 0; i < len; i++) {
       f(this[i]);
     }
   }
 
-  Iterable map(f(int element)) {
+  Iterable map(f(num element)) {
     return IterableMixinWorkaround.mapList(this, f);
   }
 
   String join([String separator = ""]) {
     return IterableMixinWorkaround.join(this, separator);
   }
 
-  dynamic reduce(dynamic combine(value, element)) {
+  num reduce(dynamic combine(num value, num element)) {
     return IterableMixinWorkaround.reduce(this, combine);
   }
 
   dynamic fold(dynamic initialValue,
-                 dynamic combine(dynamic initialValue, element)) {
+               dynamic combine(dynamic initialValue, num element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
-  Iterable where(bool f(int element)) {
+  Iterable where(bool f(num element)) {
     return IterableMixinWorkaround.where(this, f);
   }
 
-  Iterable expand(Iterable f(int element)) {
+  Iterable expand(Iterable f(num element)) {
     return IterableMixinWorkaround.expand(this, f);
   }
 
   Iterable take(int n) {
     return IterableMixinWorkaround.takeList(this, n);
   }
 
-  Iterable takeWhile(bool test(int value)) {
+  Iterable takeWhile(bool test(num element)) {
     return IterableMixinWorkaround.takeWhile(this, test);
   }
 
   Iterable skip(int n) {
     return IterableMixinWorkaround.skipList(this, n);
   }
 
-  Iterable skipWhile(bool test(int value)) {
+  Iterable skipWhile(bool test(num element)) {
     return IterableMixinWorkaround.skipWhile(this, test);
   }
 
-  bool every(bool f(element)) {
+  bool every(bool f(num element)) {
     return IterableMixinWorkaround.every(this, f);
   }
 
-  bool any(bool f(element)) {
+  bool any(bool f(num element)) {
     return IterableMixinWorkaround.any(this, f);
   }
 
-  int firstWhere(bool test(int value), {int orElse()}) {
+  num firstWhere(bool test(num element), {orElse()}) {
     return IterableMixinWorkaround.firstWhere(this, test, orElse);
   }
 
-  int lastWhere(bool test(int value), {int orElse()}) {
+  num lastWhere(bool test(num element), {orElse()}) {
     return IterableMixinWorkaround.lastWhereList(this, test, orElse);
   }
 
-  int singleWhere(bool test(int value)) {
+  num singleWhere(bool test(num element)) {
     return IterableMixinWorkaround.singleWhere(this, test);
   }
 
-  int elementAt(int index) {
+  num elementAt(int index) {
     return this[index];
   }
 
   bool get isEmpty {
     return this.length == 0;
   }
 
   bool get isNotEmpty => !isEmpty;
 
   // Method(s) implementing the List interface.
@@ skipping 16 matching lines @@
   void insert(int index, value) {
     throw new UnsupportedError(
         "Cannot insert into a non-extendable array");
   }
 
   void insertAll(int index, Iterable values) {
     throw new UnsupportedError(
         "Cannot insert into a non-extendable array");
   }
 
-  void sort([int compare(var a, var b)]) {
+  void sort([int compare(num a, num b)]) {
     return IterableMixinWorkaround.sortList(this, compare);
   }
 
   int indexOf(element, [int start = 0]) {
     return IterableMixinWorkaround.indexOfList(this, element, start);
   }
 
   int lastIndexOf(element, [int start = null]) {
     return IterableMixinWorkaround.lastIndexOfList(this, element, start);
   }
@@ skipping 21 matching lines @@
   void removeAll(Iterable elements) {
     throw new UnsupportedError(
         "Cannot remove from a non-extendable array");
   }
 
   void retainAll(Iterable elements) {
     throw new UnsupportedError(
         "Cannot remove from a non-extendable array");
   }
 
-  void removeWhere(bool test(int element)) {
+  void removeWhere(bool test(element)) {
     throw new UnsupportedError(
         "Cannot remove from a non-extendable array");
   }
 
-  void retainWhere(bool test(int element)) {
+  void retainWhere(bool test(element)) {
     throw new UnsupportedError(
         "Cannot remove from a non-extendable array");
   }
 
-  int get first {
+  num get first {
     if (length > 0) return this[0];
     throw new StateError("No elements");
   }
 
-  int get last {
+  num get last {
     if (length > 0) return this[length - 1];
     throw new StateError("No elements");
   }
 
-  int get single {
+  num get single {
     if (length == 1) return this[0];
     if (length == 0) throw new StateError("No elements");
     throw new StateError("More than one element");
   }
 
   void removeRange(int start, int end) {
     throw new UnsupportedError(
         "Cannot remove from a non-extendable array");
   }
 
@@ skipping 27 matching lines @@
     if (!_setRange(start, end - start, iterable, skipCount)) {
       IterableMixinWorkaround.setRangeList(this, start,
                                            end, iterable, skipCount);
     }
   }
 
   void setAll(int index, Iterable iterable) {
     IterableMixinWorkaround.setAllList(this, index, iterable);
   }
 
-  void fillRange(int start, int end, [fillValue]) {
+  void fillRange(int start, int end, [num fillValue]) {
     IterableMixinWorkaround.fillRangeList(this, start, end, fillValue);
   }
 
 
   // Method(s) implementing Object interface.
 
   String toString() {
     return ToString.iterableToString(this);
   }
 
@@ skipping 2595 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);
 }