Added new version of reduce.

sdk/lib/svg/dartium/svg_dartium.dart

 library dart.dom.svg;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:html';
 import 'dart:html_common';
 import 'dart:nativewrappers';
 // DO NOT EDIT
 // Auto-generated dart:svg library.
 
@@ skipping 3273 matching lines @@
 
   Iterator<Length> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<Length>(this);
   }
 
   // SVG Collections expose numberOfItems rather than length.
   int get length => numberOfItems;
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, Length)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+  Length reduce(Length combine(Length value, Length element)) {
+    return IterableMixinWorkaround.reduce(this, combine);
   }
 
-  dynamic fold(dynamic initialValue, dynamic combine(dynamic, Length)) {
+  dynamic fold(dynamic initialValue,
+               dynamic combine(dynamic previousValue, Length element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
   bool contains(Length element) => IterableMixinWorkaround.contains(this, element);
 
   void forEach(void f(Length element)) => IterableMixinWorkaround.forEach(this, f);
 
   String join([String separator = ""]) =>
       IterableMixinWorkaround.joinList(this, separator);
 
@@ skipping 87 matching lines @@
     if (this.length > 0) return this[this.length - 1];
     throw new StateError("No elements");
   }
 
   Length get single {
     if (length == 1) return this[0];
     if (length == 0) throw new StateError("No elements");
     throw new StateError("More than one element");
   }
 
-  Length min([int compare(Length a, Length b)]) =>
-      IterableMixinWorkaround.min(this, compare);
-
-  Length max([int compare(Length a, Length b)]) =>
-      IterableMixinWorkaround.max(this, compare);
-
   void insert(int index, Length element) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   Length removeAt(int pos) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
 
   Length removeLast() {
     throw new UnsupportedError("Cannot remove from immutable List.");
@@ skipping 584 matching lines @@
 
   Iterator<Number> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<Number>(this);
   }
 
   // SVG Collections expose numberOfItems rather than length.
   int get length => numberOfItems;
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, Number)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+  Number reduce(Number combine(Number value, Number element)) {
+    return IterableMixinWorkaround.reduce(this, combine);
   }
 
-  dynamic fold(dynamic initialValue, dynamic combine(dynamic, Number)) {
+  dynamic fold(dynamic initialValue,
+               dynamic combine(dynamic previousValue, Number element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
   bool contains(Number element) => IterableMixinWorkaround.contains(this, element);
 
   void forEach(void f(Number element)) => IterableMixinWorkaround.forEach(this, f);
 
   String join([String separator = ""]) =>
       IterableMixinWorkaround.joinList(this, separator);
 
@@ skipping 87 matching lines @@
     if (this.length > 0) return this[this.length - 1];
     throw new StateError("No elements");
   }
 
   Number get single {
     if (length == 1) return this[0];
     if (length == 0) throw new StateError("No elements");
     throw new StateError("More than one element");
   }
 
-  Number min([int compare(Number a, Number b)]) =>
-      IterableMixinWorkaround.min(this, compare);
-
-  Number max([int compare(Number a, Number b)]) =>
-      IterableMixinWorkaround.max(this, compare);
-
   void insert(int index, Number element) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   Number removeAt(int pos) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
 
   Number removeLast() {
     throw new UnsupportedError("Cannot remove from immutable List.");
@@ skipping 1011 matching lines @@
 
   Iterator<PathSeg> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<PathSeg>(this);
   }
 
   // SVG Collections expose numberOfItems rather than length.
   int get length => numberOfItems;
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, PathSeg)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+  PathSeg reduce(PathSeg combine(PathSeg value, PathSeg element)) {
+    return IterableMixinWorkaround.reduce(this, combine);
   }
 
-  dynamic fold(dynamic initialValue, dynamic combine(dynamic, PathSeg)) {
+  dynamic fold(dynamic initialValue,
+               dynamic combine(dynamic previousValue, PathSeg element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
   bool contains(PathSeg element) => IterableMixinWorkaround.contains(this, element);
 
   void forEach(void f(PathSeg element)) => IterableMixinWorkaround.forEach(this, f);
 
   String join([String separator = ""]) =>
       IterableMixinWorkaround.joinList(this, separator);
 
@@ skipping 87 matching lines @@
     if (this.length > 0) return this[this.length - 1];
     throw new StateError("No elements");
   }
 
   PathSeg get single {
     if (length == 1) return this[0];
     if (length == 0) throw new StateError("No elements");
     throw new StateError("More than one element");
   }
 
-  PathSeg min([int compare(PathSeg a, PathSeg b)]) =>
-      IterableMixinWorkaround.min(this, compare);
-
-  PathSeg max([int compare(PathSeg a, PathSeg b)]) =>
-      IterableMixinWorkaround.max(this, compare);
-
   void insert(int index, PathSeg element) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   PathSeg removeAt(int pos) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
 
   PathSeg removeLast() {
     throw new UnsupportedError("Cannot remove from immutable List.");
@@ skipping 865 matching lines @@
 
   Iterator<String> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<String>(this);
   }
 
   // SVG Collections expose numberOfItems rather than length.
   int get length => numberOfItems;
-  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);
   }
 
   bool contains(String element) => IterableMixinWorkaround.contains(this, element);
 
   void forEach(void f(String element)) => IterableMixinWorkaround.forEach(this, f);
 
   String join([String separator = ""]) =>
       IterableMixinWorkaround.joinList(this, separator);
 
@@ skipping 87 matching lines @@
     if (this.length > 0) return this[this.length - 1];
     throw new StateError("No elements");
   }
 
   String get single {
     if (length == 1) return this[0];
     if (length == 0) throw new StateError("No elements");
     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.");
   }
 
   String removeAt(int pos) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
 
   String removeLast() {
     throw new UnsupportedError("Cannot remove from immutable List.");
@@ skipping 1130 matching lines @@
 
   Iterator<Transform> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<Transform>(this);
   }
 
   // SVG Collections expose numberOfItems rather than length.
   int get length => numberOfItems;
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, Transform)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+  Transform reduce(Transform combine(Transform value, Transform element)) {
+    return IterableMixinWorkaround.reduce(this, combine);
   }
 
-  dynamic fold(dynamic initialValue, dynamic combine(dynamic, Transform)) {
+  dynamic fold(dynamic initialValue,
+               dynamic combine(dynamic previousValue, Transform element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
   bool contains(Transform element) => IterableMixinWorkaround.contains(this, element);
 
   void forEach(void f(Transform element)) => IterableMixinWorkaround.forEach(this, f);
 
   String join([String separator = ""]) =>
       IterableMixinWorkaround.joinList(this, separator);
 
@@ skipping 87 matching lines @@
     if (this.length > 0) return this[this.length - 1];
     throw new StateError("No elements");
   }
 
   Transform get single {
     if (length == 1) return this[0];
     if (length == 0) throw new StateError("No elements");
     throw new StateError("More than one element");
   }
 
-  Transform min([int compare(Transform a, Transform b)]) =>
-      IterableMixinWorkaround.min(this, compare);
-
-  Transform max([int compare(Transform a, Transform b)]) =>
-      IterableMixinWorkaround.max(this, compare);
-
   void insert(int index, Transform element) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   Transform removeAt(int pos) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
 
   Transform removeLast() {
     throw new UnsupportedError("Cannot remove from immutable List.");
@@ skipping 454 matching lines @@
 
   // From Iterable<ElementInstance>:
 
   Iterator<ElementInstance> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<ElementInstance>(this);
   }
 
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, ElementInstance)) {
-    return IterableMixinWorkaround.reduce(this, initialValue, combine);
+  ElementInstance reduce(ElementInstance combine(ElementInstance value, ElementInstance element)) {
+    return IterableMixinWorkaround.reduce(this, combine);
   }
 
-  dynamic fold(dynamic initialValue, dynamic combine(dynamic, ElementInstance)) {
+  dynamic fold(dynamic initialValue,
+               dynamic combine(dynamic previousValue, ElementInstance element)) {
     return IterableMixinWorkaround.fold(this, initialValue, combine);
   }
 
   bool contains(ElementInstance element) => IterableMixinWorkaround.contains(this, element);
 
   void forEach(void f(ElementInstance element)) => IterableMixinWorkaround.forEach(this, f);
 
   String join([String separator = ""]) =>
       IterableMixinWorkaround.joinList(this, separator);
 
@@ skipping 89 matching lines @@
     if (this.length > 0) return this[this.length - 1];
     throw new StateError("No elements");
   }
 
   ElementInstance get single {
     if (length == 1) return this[0];
     if (length == 0) throw new StateError("No elements");
     throw new StateError("More than one element");
   }
 
-  ElementInstance min([int compare(ElementInstance a, ElementInstance b)]) =>
-      IterableMixinWorkaround.min(this, compare);
-
-  ElementInstance max([int compare(ElementInstance a, ElementInstance b)]) =>
-      IterableMixinWorkaround.max(this, compare);
-
   void insert(int index, ElementInstance element) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   ElementInstance removeAt(int pos) {
     throw new UnsupportedError("Cannot remove from immutable List.");
   }
 
   ElementInstance removeLast() {
     throw new UnsupportedError("Cannot remove from immutable List.");
@@ skipping 389 matching lines @@
 @DocsEditable
 @DomName('SVGVKernElement')
 abstract class _SVGVKernElement extends SvgElement {
   _SVGVKernElement.internal() : super.internal();
 
   @DomName('SVGVKernElement.SVGVKernElement')
   @DocsEditable
   factory _SVGVKernElement() => _SvgElementFactoryProvider.createSvgElement_tag("vkern");
 
 }