Added new version of reduce.

sdk/lib/html/dart2js/html_dart2js.dart

Index: sdk/lib/html/dart2js/html_dart2js.dart
diff --git a/sdk/lib/html/dart2js/html_dart2js.dart b/sdk/lib/html/dart2js/html_dart2js.dart
index a29d6436a49a21a6c47211b133dee4e94d328d71..ee36989a91b3b3cfa39eb48a407bb2f21e994e69 100644
--- a/sdk/lib/html/dart2js/html_dart2js.dart
+++ b/sdk/lib/html/dart2js/html_dart2js.dart
@@ -6822,11 +6822,12 @@ class DomMimeTypeArray implements JavaScriptIndexingBehavior, List<DomMimeType>
     return new FixedSizeListIterator<DomMimeType>(this);
   }
 
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, DomMimeType)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+  DomMimeType reduce(DomMimeType combine(DomMimeType value, DomMimeType element)) {
+    return IterableMixinWorkaround.reduce(this, combine);
   }
 
-  dynamic fold(dynamic initialValue, dynamic combine(dynamic, DomMimeType)) {
+  dynamic fold(dynamic initialValue,
+               dynamic combine(dynamic previousValue, DomMimeType element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
@@ -6936,12 +6937,6 @@ class DomMimeTypeArray implements JavaScriptIndexingBehavior, List<DomMimeType>
     throw new StateError("More than one element");
   }
 
-  DomMimeType min([int compare(DomMimeType a, DomMimeType b)]) =>
-      IterableMixinWorkaround.min(this, compare);
-
-  DomMimeType max([int compare(DomMimeType a, DomMimeType b)]) =>
-      IterableMixinWorkaround.max(this, compare);
-
   void insert(int index, DomMimeType element) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
@@ -7097,11 +7092,12 @@ class DomPluginArray implements JavaScriptIndexingBehavior, List<DomPlugin> nati
     return new FixedSizeListIterator<DomPlugin>(this);
   }
 
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, DomPlugin)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+  DomPlugin reduce(DomPlugin combine(DomPlugin value, DomPlugin element)) {
+    return IterableMixinWorkaround.reduce(this, combine);
   }
 
-  dynamic fold(dynamic initialValue, dynamic combine(dynamic, DomPlugin)) {
+  dynamic fold(dynamic initialValue,
+               dynamic combine(dynamic previousValue, DomPlugin element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
@@ -7211,12 +7207,6 @@ class DomPluginArray implements JavaScriptIndexingBehavior, List<DomPlugin> nati
     throw new StateError("More than one element");
   }
 
-  DomPlugin min([int compare(DomPlugin a, DomPlugin b)]) =>
-      IterableMixinWorkaround.min(this, compare);
-
-  DomPlugin max([int compare(DomPlugin a, DomPlugin b)]) =>
-      IterableMixinWorkaround.max(this, compare);
-
   void insert(int index, DomPlugin element) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
@@ -7449,11 +7439,12 @@ class DomStringList implements JavaScriptIndexingBehavior, List<String> native "
     return new FixedSizeListIterator<String>(this);
   }
 
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, String)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+  String reduce(String combine(String value, String element)) {
+    return IterableMixinWorkaround.reduce(this, combine);
   }
 
-  dynamic fold(dynamic initialValue, dynamic combine(dynamic, String)) {
+  dynamic fold(dynamic initialValue,
+               dynamic combine(dynamic previousValue, String element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
@@ -7563,12 +7554,6 @@ class DomStringList implements JavaScriptIndexingBehavior, List<String> native "
     throw new StateError("More than one element");
   }
 
-  String min([int compare(String a, String b)]) =>
-      IterableMixinWorkaround.min(this, compare);
-
-  String max([int compare(String a, String b)]) =>
-      IterableMixinWorkaround.max(this, compare);
-
   void insert(int index, String element) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
@@ -7836,9 +7821,8 @@ class _ChildrenElementList extends ListBase<Element> {
     throw new UnsupportedError('TODO(jacobr): should we impl?');
   }
 
-  dynamic reduce(dynamic initialValue,
-      dynamic combine(dynamic previousValue, Element element)) {
-    return _childElements.reduce(initialValue, combine);
+  Element reduce(Element combine(Element value, Element element)) {
+    return _childElements.reduce(combine);
   }
 
   dynamic fold(dynamic initialValue,
@@ -7951,10 +7935,6 @@ class _ChildrenElementList extends ListBase<Element> {
     return first;
   }
 
-  Element min([int compare(Element a, Element b)]) {
-    return _childElements.min(compare);
-  }
-
   Element max([int compare(Element a, Element b)]) {
     return _childElements.max(compare);
   }
@@ -10210,11 +10190,12 @@ class FileList implements JavaScriptIndexingBehavior, List<File> native "*FileLi
     return new FixedSizeListIterator<File>(this);
   }
 
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, File)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+  File reduce(File combine(File value, File element)) {
+    return IterableMixinWorkaround.reduce(this, combine);
   }
 
-  dynamic fold(dynamic initialValue, dynamic combine(dynamic, File)) {
+  dynamic fold(dynamic initialValue,
+               dynamic combine(dynamic previousValue, File element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
@@ -10324,12 +10305,6 @@ class FileList implements JavaScriptIndexingBehavior, List<File> native "*FileLi
     throw new StateError("More than one element");
   }
 
-  File min([int compare(File a, File b)]) =>
-      IterableMixinWorkaround.min(this, compare);
-
-  File max([int compare(File a, File b)]) =>
-      IterableMixinWorkaround.max(this, compare);
-
   void insert(int index, File element) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
@@ -10707,11 +10682,12 @@ class Float32Array extends ArrayBufferView implements JavaScriptIndexingBehavior
     return new FixedSizeListIterator<num>(this);
   }
 
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, num)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+  num reduce(num combine(num value, num element)) {
+    return IterableMixinWorkaround.reduce(this, combine);
   }
 
-  dynamic fold(dynamic initialValue, dynamic combine(dynamic, num)) {
+  dynamic fold(dynamic initialValue,
+               dynamic combine(dynamic previousValue, num element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
@@ -10821,12 +10797,6 @@ class Float32Array extends ArrayBufferView implements JavaScriptIndexingBehavior
     throw new StateError("More than one element");
   }
 
-  num min([int compare(num a, num b)]) =>
-      IterableMixinWorkaround.min(this, compare);
-
-  num max([int compare(num a, num b)]) =>
-      IterableMixinWorkaround.max(this, compare);
-
   void insert(int index, num element) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
@@ -10946,11 +10916,12 @@ class Float64Array extends ArrayBufferView implements JavaScriptIndexingBehavior
     return new FixedSizeListIterator<num>(this);
   }
 
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, num)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+  num reduce(num combine(num value, num element)) {
+    return IterableMixinWorkaround.reduce(this, combine);
   }
 
-  dynamic fold(dynamic initialValue, dynamic combine(dynamic, num)) {
+  dynamic fold(dynamic initialValue,
+               dynamic combine(dynamic previousValue, num element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
@@ -11060,12 +11031,6 @@ class Float64Array extends ArrayBufferView implements JavaScriptIndexingBehavior
     throw new StateError("More than one element");
   }
 
-  num min([int compare(num a, num b)]) =>
-      IterableMixinWorkaround.min(this, compare);
-
-  num max([int compare(num a, num b)]) =>
-      IterableMixinWorkaround.max(this, compare);
-
   void insert(int index, num element) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
@@ -11605,11 +11570,12 @@ class HtmlAllCollection implements JavaScriptIndexingBehavior, List<Node> native
     return new FixedSizeListIterator<Node>(this);
   }
 
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, Node)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+  Node reduce(Node combine(Node value, Node element)) {
+    return IterableMixinWorkaround.reduce(this, combine);
   }
 
-  dynamic fold(dynamic initialValue, dynamic combine(dynamic, Node)) {
+  dynamic fold(dynamic initialValue,
+               dynamic combine(dynamic previousValue, Node element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
@@ -11719,12 +11685,6 @@ class HtmlAllCollection implements JavaScriptIndexingBehavior, List<Node> native
     throw new StateError("More than one element");
   }
 
-  Node min([int compare(Node a, Node b)]) =>
-      IterableMixinWorkaround.min(this, compare);
-
-  Node max([int compare(Node a, Node b)]) =>
-      IterableMixinWorkaround.max(this, compare);
-
   void insert(int index, Node element) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
@@ -11833,11 +11793,12 @@ class HtmlCollection implements JavaScriptIndexingBehavior, List<Node> native "*
     return new FixedSizeListIterator<Node>(this);
   }
 
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, Node)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+  Node reduce(Node combine(Node value, Node element)) {
+    return IterableMixinWorkaround.reduce(this, combine);
   }
 
-  dynamic fold(dynamic initialValue, dynamic combine(dynamic, Node)) {
+  dynamic fold(dynamic initialValue,
+               dynamic combine(dynamic previousValue, Node element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
@@ -11947,12 +11908,6 @@ class HtmlCollection implements JavaScriptIndexingBehavior, List<Node> native "*
     throw new StateError("More than one element");
   }
 
-  Node min([int compare(Node a, Node b)]) =>
-      IterableMixinWorkaround.min(this, compare);
-
-  Node max([int compare(Node a, Node b)]) =>
-      IterableMixinWorkaround.max(this, compare);
-
   void insert(int index, Node element) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
@@ -13880,11 +13835,12 @@ class Int16Array extends ArrayBufferView implements JavaScriptIndexingBehavior,
     return new FixedSizeListIterator<int>(this);
   }
 
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, int)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+  int reduce(int combine(int value, int element)) {
+    return IterableMixinWorkaround.reduce(this, combine);
   }
 
-  dynamic fold(dynamic initialValue, dynamic combine(dynamic, int)) {
+  dynamic fold(dynamic initialValue,
+               dynamic combine(dynamic previousValue, int element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
@@ -13994,12 +13950,6 @@ class Int16Array extends ArrayBufferView implements JavaScriptIndexingBehavior,
     throw new StateError("More than one element");
   }
 
-  int min([int compare(int a, int b)]) =>
-      IterableMixinWorkaround.min(this, compare);
-
-  int max([int compare(int a, int b)]) =>
-      IterableMixinWorkaround.max(this, compare);
-
   void insert(int index, int element) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
@@ -14119,11 +14069,12 @@ class Int32Array extends ArrayBufferView implements JavaScriptIndexingBehavior,
     return new FixedSizeListIterator<int>(this);
   }
 
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, int)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+  int reduce(int combine(int value, int element)) {
+    return IterableMixinWorkaround.reduce(this, combine);
   }
 
-  dynamic fold(dynamic initialValue, dynamic combine(dynamic, int)) {
+  dynamic fold(dynamic initialValue,
+               dynamic combine(dynamic previousValue, int element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
@@ -14233,12 +14184,6 @@ class Int32Array extends ArrayBufferView implements JavaScriptIndexingBehavior,
     throw new StateError("More than one element");
   }
 
-  int min([int compare(int a, int b)]) =>
-      IterableMixinWorkaround.min(this, compare);
-
-  int max([int compare(int a, int b)]) =>
-      IterableMixinWorkaround.max(this, compare);
-
   void insert(int index, int element) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
@@ -14358,11 +14303,12 @@ class Int8Array extends ArrayBufferView implements JavaScriptIndexingBehavior, L
     return new FixedSizeListIterator<int>(this);
   }
 
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, int)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+  int reduce(int combine(int value, int element)) {
+    return IterableMixinWorkaround.reduce(this, combine);
   }
 
-  dynamic fold(dynamic initialValue, dynamic combine(dynamic, int)) {
+  dynamic fold(dynamic initialValue,
+               dynamic combine(dynamic previousValue, int element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
@@ -14472,12 +14418,6 @@ class Int8Array extends ArrayBufferView implements JavaScriptIndexingBehavior, L
     throw new StateError("More than one element");
   }
 
-  int min([int compare(int a, int b)]) =>
-      IterableMixinWorkaround.min(this, compare);
-
-  int max([int compare(int a, int b)]) =>
-      IterableMixinWorkaround.max(this, compare);
-
   void insert(int index, int element) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
@@ -17392,11 +17332,12 @@ class NodeList implements JavaScriptIndexingBehavior, List<Node> native "*NodeLi
     return new FixedSizeListIterator<Node>(this);
   }
 
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, Node)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+  Node reduce(Node combine(Node value, Node element)) {
+    return IterableMixinWorkaround.reduce(this, combine);
   }
 
-  dynamic fold(dynamic initialValue, dynamic combine(dynamic, Node)) {
+  dynamic fold(dynamic initialValue,
+               dynamic combine(dynamic previousValue, Node element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
@@ -17506,12 +17447,6 @@ class NodeList implements JavaScriptIndexingBehavior, List<Node> native "*NodeLi
     throw new StateError("More than one element");
   }
 
-  Node min([int compare(Node a, Node b)]) =>
-      IterableMixinWorkaround.min(this, compare);
-
-  Node max([int compare(Node a, Node b)]) =>
-      IterableMixinWorkaround.max(this, compare);
-
   void insert(int index, Node element) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
@@ -19702,11 +19637,12 @@ class SourceBufferList extends EventTarget implements JavaScriptIndexingBehavior
     return new FixedSizeListIterator<SourceBuffer>(this);
   }
 
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, SourceBuffer)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+  SourceBuffer reduce(SourceBuffer combine(SourceBuffer value, SourceBuffer element)) {
+    return IterableMixinWorkaround.reduce(this, combine);
   }
 
-  dynamic fold(dynamic initialValue, dynamic combine(dynamic, SourceBuffer)) {
+  dynamic fold(dynamic initialValue,
+               dynamic combine(dynamic previousValue, SourceBuffer element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
@@ -19816,12 +19752,6 @@ class SourceBufferList extends EventTarget implements JavaScriptIndexingBehavior
     throw new StateError("More than one element");
   }
 
-  SourceBuffer min([int compare(SourceBuffer a, SourceBuffer b)]) =>
-      IterableMixinWorkaround.min(this, compare);
-
-  SourceBuffer max([int compare(SourceBuffer a, SourceBuffer b)]) =>
-      IterableMixinWorkaround.max(this, compare);
-
   void insert(int index, SourceBuffer element) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
@@ -20003,11 +19933,12 @@ class SpeechGrammarList implements JavaScriptIndexingBehavior, List<SpeechGramma
     return new FixedSizeListIterator<SpeechGrammar>(this);
   }
 
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, SpeechGrammar)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+  SpeechGrammar reduce(SpeechGrammar combine(SpeechGrammar value, SpeechGrammar element)) {
+    return IterableMixinWorkaround.reduce(this, combine);
   }
 
-  dynamic fold(dynamic initialValue, dynamic combine(dynamic, SpeechGrammar)) {
+  dynamic fold(dynamic initialValue,
+               dynamic combine(dynamic previousValue, SpeechGrammar element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
@@ -20117,12 +20048,6 @@ class SpeechGrammarList implements JavaScriptIndexingBehavior, List<SpeechGramma
     throw new StateError("More than one element");
   }
 
-  SpeechGrammar min([int compare(SpeechGrammar a, SpeechGrammar b)]) =>
-      IterableMixinWorkaround.min(this, compare);
-
-  SpeechGrammar max([int compare(SpeechGrammar a, SpeechGrammar b)]) =>
-      IterableMixinWorkaround.max(this, compare);
-
   void insert(int index, SpeechGrammar element) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
@@ -21467,11 +21392,12 @@ class TextTrackCueList implements List<TextTrackCue>, JavaScriptIndexingBehavior
     return new FixedSizeListIterator<TextTrackCue>(this);
   }
 
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, TextTrackCue)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+  TextTrackCue reduce(TextTrackCue combine(TextTrackCue value, TextTrackCue element)) {
+    return IterableMixinWorkaround.reduce(this, combine);
   }
 
-  dynamic fold(dynamic initialValue, dynamic combine(dynamic, TextTrackCue)) {
+  dynamic fold(dynamic initialValue,
+               dynamic combine(dynamic previousValue, TextTrackCue element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
@@ -21581,12 +21507,6 @@ class TextTrackCueList implements List<TextTrackCue>, JavaScriptIndexingBehavior
     throw new StateError("More than one element");
   }
 
-  TextTrackCue min([int compare(TextTrackCue a, TextTrackCue b)]) =>
-      IterableMixinWorkaround.min(this, compare);
-
-  TextTrackCue max([int compare(TextTrackCue a, TextTrackCue b)]) =>
-      IterableMixinWorkaround.max(this, compare);
-
   void insert(int index, TextTrackCue element) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
@@ -21693,11 +21613,12 @@ class TextTrackList extends EventTarget implements JavaScriptIndexingBehavior, L
     return new FixedSizeListIterator<TextTrack>(this);
   }
 
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, TextTrack)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+  TextTrack reduce(TextTrack combine(TextTrack value, TextTrack element)) {
+    return IterableMixinWorkaround.reduce(this, combine);
   }
 
-  dynamic fold(dynamic initialValue, dynamic combine(dynamic, TextTrack)) {
+  dynamic fold(dynamic initialValue,
+               dynamic combine(dynamic previousValue, TextTrack element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
@@ -21807,12 +21728,6 @@ class TextTrackList extends EventTarget implements JavaScriptIndexingBehavior, L
     throw new StateError("More than one element");
   }
 
-  TextTrack min([int compare(TextTrack a, TextTrack b)]) =>
-      IterableMixinWorkaround.min(this, compare);
-
-  TextTrack max([int compare(TextTrack a, TextTrack b)]) =>
-      IterableMixinWorkaround.max(this, compare);
-
   void insert(int index, TextTrack element) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
@@ -22145,11 +22060,12 @@ class TouchList implements JavaScriptIndexingBehavior, List<Touch> native "*Touc
     return new FixedSizeListIterator<Touch>(this);
   }
 
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, Touch)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+  Touch reduce(Touch combine(Touch value, Touch element)) {
+    return IterableMixinWorkaround.reduce(this, combine);
   }
 
-  dynamic fold(dynamic initialValue, dynamic combine(dynamic, Touch)) {
+  dynamic fold(dynamic initialValue,
+               dynamic combine(dynamic previousValue, Touch element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
@@ -22259,12 +22175,6 @@ class TouchList implements JavaScriptIndexingBehavior, List<Touch> native "*Touc
     throw new StateError("More than one element");
   }
 
-  Touch min([int compare(Touch a, Touch b)]) =>
-      IterableMixinWorkaround.min(this, compare);
-
-  Touch max([int compare(Touch a, Touch b)]) =>
-      IterableMixinWorkaround.max(this, compare);
-
   void insert(int index, Touch element) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
@@ -22634,11 +22544,12 @@ class Uint16Array extends ArrayBufferView implements JavaScriptIndexingBehavior,
     return new FixedSizeListIterator<int>(this);
   }
 
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, int)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+  int reduce(int combine(int value, int element)) {
+    return IterableMixinWorkaround.reduce(this, combine);
   }
 
-  dynamic fold(dynamic initialValue, dynamic combine(dynamic, int)) {
+  dynamic fold(dynamic initialValue,
+               dynamic combine(dynamic previousValue, int element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
@@ -22748,12 +22659,6 @@ class Uint16Array extends ArrayBufferView implements JavaScriptIndexingBehavior,
     throw new StateError("More than one element");
   }
 
-  int min([int compare(int a, int b)]) =>
-      IterableMixinWorkaround.min(this, compare);
-
-  int max([int compare(int a, int b)]) =>
-      IterableMixinWorkaround.max(this, compare);
-
   void insert(int index, int element) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
@@ -22873,11 +22778,12 @@ class Uint32Array extends ArrayBufferView implements JavaScriptIndexingBehavior,
     return new FixedSizeListIterator<int>(this);
   }
 
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, int)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+  int reduce(int combine(int value, int element)) {
+    return IterableMixinWorkaround.reduce(this, combine);
   }
 
-  dynamic fold(dynamic initialValue, dynamic combine(dynamic, int)) {
+  dynamic fold(dynamic initialValue,
+               dynamic combine(dynamic previousValue, int element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
@@ -22987,12 +22893,6 @@ class Uint32Array extends ArrayBufferView implements JavaScriptIndexingBehavior,
     throw new StateError("More than one element");
   }
 
-  int min([int compare(int a, int b)]) =>
-      IterableMixinWorkaround.min(this, compare);
-
-  int max([int compare(int a, int b)]) =>
-      IterableMixinWorkaround.max(this, compare);
-
   void insert(int index, int element) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
@@ -23112,11 +23012,12 @@ class Uint8Array extends ArrayBufferView implements JavaScriptIndexingBehavior,
     return new FixedSizeListIterator<int>(this);
   }
 
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, int)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+  int reduce(int combine(int value, int element)) {
+    return IterableMixinWorkaround.reduce(this, combine);
   }
 
-  dynamic fold(dynamic initialValue, dynamic combine(dynamic, int)) {
+  dynamic fold(dynamic initialValue,
+               dynamic combine(dynamic previousValue, int element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
@@ -23226,12 +23127,6 @@ class Uint8Array extends ArrayBufferView implements JavaScriptIndexingBehavior,
     throw new StateError("More than one element");
   }
 
-  int min([int compare(int a, int b)]) =>
-      IterableMixinWorkaround.min(this, compare);
-
-  int max([int compare(int a, int b)]) =>
-      IterableMixinWorkaround.max(this, compare);
-
   void insert(int index, int element) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
@@ -23348,11 +23243,12 @@ class Uint8ClampedArray extends Uint8Array implements JavaScriptIndexingBehavior
     return new FixedSizeListIterator<int>(this);
   }
 
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, int)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+  int reduce(int combine(int value, int element)) {
+    return IterableMixinWorkaround.reduce(this, combine);
   }
 
-  dynamic fold(dynamic initialValue, dynamic combine(dynamic, int)) {
+  dynamic fold(dynamic initialValue,
+               dynamic combine(dynamic previousValue, int element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
@@ -23462,12 +23358,6 @@ class Uint8ClampedArray extends Uint8Array implements JavaScriptIndexingBehavior
     throw new StateError("More than one element");
   }
 
-  int min([int compare(int a, int b)]) =>
-      IterableMixinWorkaround.min(this, compare);
-
-  int max([int compare(int a, int b)]) =>
-      IterableMixinWorkaround.max(this, compare);
-
   void insert(int index, int element) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
@@ -25635,11 +25525,12 @@ class _ClientRectList implements JavaScriptIndexingBehavior, List<Rect> native "
     return new FixedSizeListIterator<Rect>(this);
   }
 
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, Rect)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+  Rect reduce(Rect combine(Rect value, Rect element)) {
+    return IterableMixinWorkaround.reduce(this, combine);
   }
 
-  dynamic fold(dynamic initialValue, dynamic combine(dynamic, Rect)) {
+  dynamic fold(dynamic initialValue,
+               dynamic combine(dynamic previousValue, Rect element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
@@ -25749,12 +25640,6 @@ class _ClientRectList implements JavaScriptIndexingBehavior, List<Rect> native "
     throw new StateError("More than one element");
   }
 
-  Rect min([int compare(Rect a, Rect b)]) =>
-      IterableMixinWorkaround.min(this, compare);
-
-  Rect max([int compare(Rect a, Rect b)]) =>
-      IterableMixinWorkaround.max(this, compare);
-
   void insert(int index, Rect element) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
@@ -25862,11 +25747,12 @@ class _CssRuleList implements JavaScriptIndexingBehavior, List<CssRule> native "
     return new FixedSizeListIterator<CssRule>(this);
   }
 
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, CssRule)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+  CssRule reduce(CssRule combine(CssRule value, CssRule element)) {
+    return IterableMixinWorkaround.reduce(this, combine);
   }
 
-  dynamic fold(dynamic initialValue, dynamic combine(dynamic, CssRule)) {
+  dynamic fold(dynamic initialValue,
+               dynamic combine(dynamic previousValue, CssRule element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
@@ -25976,12 +25862,6 @@ class _CssRuleList implements JavaScriptIndexingBehavior, List<CssRule> native "
     throw new StateError("More than one element");
   }
 
-  CssRule min([int compare(CssRule a, CssRule b)]) =>
-      IterableMixinWorkaround.min(this, compare);
-
-  CssRule max([int compare(CssRule a, CssRule b)]) =>
-      IterableMixinWorkaround.max(this, compare);
-
   void insert(int index, CssRule element) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
@@ -26080,11 +25960,12 @@ class _CssValueList extends _CSSValue implements JavaScriptIndexingBehavior, Lis
     return new FixedSizeListIterator<_CSSValue>(this);
   }
 
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, _CSSValue)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+  _CSSValue reduce(_CSSValue combine(_CSSValue value, _CSSValue element)) {
+    return IterableMixinWorkaround.reduce(this, combine);
   }
 
-  dynamic fold(dynamic initialValue, dynamic combine(dynamic, _CSSValue)) {
+  dynamic fold(dynamic initialValue,
+               dynamic combine(dynamic previousValue, _CSSValue element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
@@ -26194,12 +26075,6 @@ class _CssValueList extends _CSSValue implements JavaScriptIndexingBehavior, Lis
     throw new StateError("More than one element");
   }
 
-  _CSSValue min([int compare(_CSSValue a, _CSSValue b)]) =>
-      IterableMixinWorkaround.min(this, compare);
-
-  _CSSValue max([int compare(_CSSValue a, _CSSValue b)]) =>
-      IterableMixinWorkaround.max(this, compare);
-
   void insert(int index, _CSSValue element) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
@@ -26366,11 +26241,12 @@ class _EntryArray implements JavaScriptIndexingBehavior, List<Entry> native "*En
     return new FixedSizeListIterator<Entry>(this);
   }
 
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, Entry)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+  Entry reduce(Entry combine(Entry value, Entry element)) {
+    return IterableMixinWorkaround.reduce(this, combine);
   }
 
-  dynamic fold(dynamic initialValue, dynamic combine(dynamic, Entry)) {
+  dynamic fold(dynamic initialValue,
+               dynamic combine(dynamic previousValue, Entry element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
@@ -26480,12 +26356,6 @@ class _EntryArray implements JavaScriptIndexingBehavior, List<Entry> native "*En
     throw new StateError("More than one element");
   }
 
-  Entry min([int compare(Entry a, Entry b)]) =>
-      IterableMixinWorkaround.min(this, compare);
-
-  Entry max([int compare(Entry a, Entry b)]) =>
-      IterableMixinWorkaround.max(this, compare);
-
   void insert(int index, Entry element) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
@@ -26584,11 +26454,12 @@ class _EntryArraySync implements JavaScriptIndexingBehavior, List<_EntrySync> na
     return new FixedSizeListIterator<_EntrySync>(this);
   }
 
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, _EntrySync)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+  _EntrySync reduce(_EntrySync combine(_EntrySync value, _EntrySync element)) {
+    return IterableMixinWorkaround.reduce(this, combine);
   }
 
-  dynamic fold(dynamic initialValue, dynamic combine(dynamic, _EntrySync)) {
+  dynamic fold(dynamic initialValue,
+               dynamic combine(dynamic previousValue, _EntrySync element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
@@ -26698,12 +26569,6 @@ class _EntryArraySync implements JavaScriptIndexingBehavior, List<_EntrySync> na
     throw new StateError("More than one element");
   }
 
-  _EntrySync min([int compare(_EntrySync a, _EntrySync b)]) =>
-      IterableMixinWorkaround.min(this, compare);
-
-  _EntrySync max([int compare(_EntrySync a, _EntrySync b)]) =>
-      IterableMixinWorkaround.max(this, compare);
-
   void insert(int index, _EntrySync element) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
@@ -26845,11 +26710,12 @@ class _GamepadList implements JavaScriptIndexingBehavior, List<Gamepad> native "
     return new FixedSizeListIterator<Gamepad>(this);
   }
 
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, Gamepad)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+  Gamepad reduce(Gamepad combine(Gamepad value, Gamepad element)) {
+    return IterableMixinWorkaround.reduce(this, combine);
   }
 
-  dynamic fold(dynamic initialValue, dynamic combine(dynamic, Gamepad)) {
+  dynamic fold(dynamic initialValue,
+               dynamic combine(dynamic previousValue, Gamepad element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
@@ -26959,12 +26825,6 @@ class _GamepadList implements JavaScriptIndexingBehavior, List<Gamepad> native "
     throw new StateError("More than one element");
   }
 
-  Gamepad min([int compare(Gamepad a, Gamepad b)]) =>
-      IterableMixinWorkaround.min(this, compare);
-
-  Gamepad max([int compare(Gamepad a, Gamepad b)]) =>
-      IterableMixinWorkaround.max(this, compare);
-
   void insert(int index, Gamepad element) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
@@ -27126,11 +26986,12 @@ class _NamedNodeMap implements JavaScriptIndexingBehavior, List<Node> native "*N
     return new FixedSizeListIterator<Node>(this);
   }
 
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, Node)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+  Node reduce(Node combine(Node value, Node element)) {
+    return IterableMixinWorkaround.reduce(this, combine);
   }
 
-  dynamic fold(dynamic initialValue, dynamic combine(dynamic, Node)) {
+  dynamic fold(dynamic initialValue,
+               dynamic combine(dynamic previousValue, Node element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
@@ -27240,12 +27101,6 @@ class _NamedNodeMap implements JavaScriptIndexingBehavior, List<Node> native "*N
     throw new StateError("More than one element");
   }
 
-  Node min([int compare(Node a, Node b)]) =>
-      IterableMixinWorkaround.min(this, compare);
-
-  Node max([int compare(Node a, Node b)]) =>
-      IterableMixinWorkaround.max(this, compare);
-
   void insert(int index, Node element) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
@@ -27415,11 +27270,12 @@ class _SpeechInputResultList implements JavaScriptIndexingBehavior, List<SpeechI
     return new FixedSizeListIterator<SpeechInputResult>(this);
   }
 
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, SpeechInputResult)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+  SpeechInputResult reduce(SpeechInputResult combine(SpeechInputResult value, SpeechInputResult element)) {
+    return IterableMixinWorkaround.reduce(this, combine);
   }
 
-  dynamic fold(dynamic initialValue, dynamic combine(dynamic, SpeechInputResult)) {
+  dynamic fold(dynamic initialValue,
+               dynamic combine(dynamic previousValue, SpeechInputResult element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
@@ -27529,12 +27385,6 @@ class _SpeechInputResultList implements JavaScriptIndexingBehavior, List<SpeechI
     throw new StateError("More than one element");
   }
 
-  SpeechInputResult min([int compare(SpeechInputResult a, SpeechInputResult b)]) =>
-      IterableMixinWorkaround.min(this, compare);
-
-  SpeechInputResult max([int compare(SpeechInputResult a, SpeechInputResult b)]) =>
-      IterableMixinWorkaround.max(this, compare);
-
   void insert(int index, SpeechInputResult element) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
@@ -27633,11 +27483,12 @@ class _SpeechRecognitionResultList implements JavaScriptIndexingBehavior, List<S
     return new FixedSizeListIterator<SpeechRecognitionResult>(this);
   }
 
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, SpeechRecognitionResult)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+  SpeechRecognitionResult reduce(SpeechRecognitionResult combine(SpeechRecognitionResult value, SpeechRecognitionResult element)) {
+    return IterableMixinWorkaround.reduce(this, combine);
   }
 
-  dynamic fold(dynamic initialValue, dynamic combine(dynamic, SpeechRecognitionResult)) {
+  dynamic fold(dynamic initialValue,
+               dynamic combine(dynamic previousValue, SpeechRecognitionResult element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
@@ -27747,12 +27598,6 @@ class _SpeechRecognitionResultList implements JavaScriptIndexingBehavior, List<S
     throw new StateError("More than one element");
   }
 
-  SpeechRecognitionResult min([int compare(SpeechRecognitionResult a, SpeechRecognitionResult b)]) =>
-      IterableMixinWorkaround.min(this, compare);
-
-  SpeechRecognitionResult max([int compare(SpeechRecognitionResult a, SpeechRecognitionResult b)]) =>
-      IterableMixinWorkaround.max(this, compare);
-
   void insert(int index, SpeechRecognitionResult element) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
@@ -27851,11 +27696,12 @@ class _StyleSheetList implements JavaScriptIndexingBehavior, List<StyleSheet> na
     return new FixedSizeListIterator<StyleSheet>(this);
   }
 
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, StyleSheet)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+  StyleSheet reduce(StyleSheet combine(StyleSheet value, StyleSheet element)) {
+    return IterableMixinWorkaround.reduce(this, combine);
   }
 
-  dynamic fold(dynamic initialValue, dynamic combine(dynamic, StyleSheet)) {
+  dynamic fold(dynamic initialValue,
+               dynamic combine(dynamic previousValue, StyleSheet element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
@@ -27965,12 +27811,6 @@ class _StyleSheetList implements JavaScriptIndexingBehavior, List<StyleSheet> na
     throw new StateError("More than one element");
   }
 
-  StyleSheet min([int compare(StyleSheet a, StyleSheet b)]) =>
-      IterableMixinWorkaround.min(this, compare);
-
-  StyleSheet max([int compare(StyleSheet a, StyleSheet b)]) =>
-      IterableMixinWorkaround.max(this, compare);
-
   void insert(int index, StyleSheet element) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
@@ -28581,9 +28421,8 @@ abstract class CssClassSet implements Set<String> {
 
   int get length => readClasses().length;
 
-  dynamic reduce(dynamic initialValue,
-      dynamic combine(dynamic previousValue, String element)) {
-    return readClasses().reduce(initialValue, combine);
+  String reduce(String combine(String value, String element)) {
+    return readClasses().reduce(combine);
   }
 
   dynamic fold(dynamic initialValue,
@@ -28693,10 +28532,6 @@ abstract class CssClassSet implements Set<String> {
   List<String> toList({ bool growable: true }) =>
       readClasses().toList(growable: growable);
   Set<String> toSet() => readClasses().toSet();
-  String min([int compare(String a, String b)]) =>
-      readClasses().min(compare);
-  String max([int compare(String a, String b)]) =>
-      readClasses().max(compare);
   Iterable<String> take(int n) => readClasses().take(n);
   Iterable<String> takeWhile(bool test(String value)) =>
       readClasses().takeWhile(test);
@@ -31063,8 +30898,8 @@ class _WrappedList<E> implements List<E> {
 
   void forEach(void f(E element)) { _list.forEach(f); }
 
-  dynamic reduce(initialValue, combine(previousValue, E element)) =>
-      _list.reduce(initialValue, combine);
+  E reduce(E combine(E value, E element)) =>
+      _list.reduce(combine);
 
   dynamic fold(initialValue, combine(previousValue, E element)) =>
       _list.fold(initialValue, combine);
@@ -31082,10 +30917,6 @@ class _WrappedList<E> implements List<E> {
 
   int get length => _list.length;
 
-  E min([int compare(E a, E b)]) => _list.min(compare);
-
-  E max([int compare(E a, E b)]) => _list.max(compare);
-
   bool get isEmpty => _list.isEmpty;
 
   Iterable<E> take(int n) => _list.take(n);