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 284 matching lines @@
 
   String join([String separator = ""]) {
     return IterableMixinWorkaround.join(this, separator);
   }
 
   dynamic reduce(dynamic combine(value, element)) {
     return IterableMixinWorkaround.reduce(this, combine);
   }
 
   dynamic fold(dynamic initialValue,
-                 dynamic combine(dynamic initialValue, element)) {
+               dynamic combine(dynamic initialValue, element)) {

[Lasse Reichstein Nielsen, 2013/05/29 07:44:18]

Inconsistent use of dynamic: it should be on element too, or not on
initialValue.
Using "dynamic" to represent one type and "omitted" (or, e.g., "var") to
represent another is too clever.

Either use dynamic for generic return type, or not, but do it consistently.

[floitsch, 2013/05/29 14:51:12]

Changed to `num`. That works for ints and doubles.

     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
-  Iterable where(bool f(int element)) {
+  Iterable where(bool f(element)) {
     return IterableMixinWorkaround.where(this, f);
   }
 
-  Iterable expand(Iterable f(int element)) {
+  Iterable expand(Iterable f(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(value)) {

[Lasse Reichstein Nielsen, 2013/05/29 07:44:18]

value => element.
More below.

[floitsch, 2013/05/29 14:51:12]

Done.

     return IterableMixinWorkaround.takeWhile(this, test);
   }
 
   Iterable skip(int n) {
     return IterableMixinWorkaround.skipList(this, n);
   }
 
-  Iterable skipWhile(bool test(int value)) {
+  Iterable skipWhile(bool test(value)) {
     return IterableMixinWorkaround.skipWhile(this, test);
   }
 
   bool every(bool f(element)) {
     return IterableMixinWorkaround.every(this, f);
   }
 
   bool any(bool f(element)) {
     return IterableMixinWorkaround.any(this, f);
   }
 
-  int firstWhere(bool test(int value), {int orElse()}) {
+  firstWhere(bool test(value), {orElse()}) {
     return IterableMixinWorkaround.firstWhere(this, test, orElse);
   }
 
-  int lastWhere(bool test(int value), {int orElse()}) {
+  lastWhere(bool test(value), {orElse()}) {
     return IterableMixinWorkaround.lastWhereList(this, test, orElse);
   }
 
-  int singleWhere(bool test(int value)) {
+  singleWhere(bool test(value)) {
     return IterableMixinWorkaround.singleWhere(this, test);
   }
 
-  int elementAt(int index) {
+  elementAt(int index) {
     return this[index];
   }
 
   bool get isEmpty {
     return this.length == 0;
   }
 
 
   // Method(s) implementing the List interface.
 
@@ skipping 57 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 {
+  get first {
     if (length > 0) return this[0];
     throw new StateError("No elements");
   }
 
-  int get last {
+  get last {
     if (length > 0) return this[length - 1];
     throw new StateError("No elements");
   }
 
-  int get single {
+  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 2643 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);
 }