Added new version of reduce.

sdk/lib/core/iterable.dart

 // Copyright (c) 2011, 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.
 
 part of dart.core;
 
 /**
  * The [Iterable] interface allows to get an [Iterator] out of an
  * [Iterable] object.
  *
@@ skipping 75 matching lines @@
   }
 
   /**
    * Applies the function [f] to each element of this collection.
    */
   void forEach(void f(E element)) {
     for (E element in this) f(element);
   }
 
   /**
-   * Reduce a collection to a single value by iteratively combining each element
-   * of the collection with an existing value using the provided function.
-   * Use [initialValue] as the initial value, and the function [combine] to
-   * create a new value from the previous one and an element.
+   * Reduce a collection to a single value by iteratively combining elements
+   * of the collection using the provided function.
    *
    * Example of calculating the sum of an iterable:
    *
-   *   iterable.reduce((prev, element) => prev + element);
+   *     iterable.reduce((value, element) => value + element);
    *
-   * *UPCOMING API-CHANGE*: this method will soon be changed to not take
-   * an initial value: `iterable.reduce(min)`. Use [fold] instead.
    */
-  @deprecated
-  dynamic reduce(var initialValue,
-                 dynamic combine(var previousValue, E element)) {
-    return fold(initialValue, combine);
+  E reduce(E combine(E value, E element)) {
+    Iterator<E> iterator = this.iterator;
+    if (!iterator.moveNext()) {
+      throw new StateError("No elements");
+    }
+    E value = iterator.current;
+    while (iterator.moveNext()) {
+      value = combine(value, iterator.current);
+    }
+    return value;
   }
 
   /**
    * Reduce a collection to a single value by iteratively combining each element
    * of the collection with an existing value using the provided function.
    * Use [initialValue] as the initial value, and the function [combine] to
    * create a new value from the previous one and an element.
    *
    * Example of calculating the sum of an iterable:
    *
-   *   iterable.fold(0, (prev, element) => prev + element);
+   *     iterable.fold(0, (prev, element) => prev + element);
+   *
    */
   dynamic fold(var initialValue,
                dynamic combine(var previousValue, E element)) {
     var value = initialValue;
     for (E element in this) value = combine(value, element);
     return value;
   }
 
   /**
    * Returns true if every elements of this collection satisify the
@@ skipping 43 matching lines @@
   int get length {
     int count = 0;
     Iterator it = iterator;
     while (it.moveNext()) {
       count++;
     }
     return count;
   }
 
   /**
-   * Find the least element in the iterable.
-   *
-   * Returns null if the iterable is empty.
-   * Otherwise returns an element [:x:] of this [Iterable] so that
-   * [:x:] is not greater than [:y:] (that is, [:compare(x, y) <= 0:]) for all
-   * other elements [:y:] in the iterable.
-   *
-   * The [compare] function must be a proper [Comparator<T>]. If a function is
-   * not provided, [compare] defaults to [Comparable.compare].
-   *
-   * *Deprecated*. Use [reduce] with a binary min method if needed.
-   */
-  @deprecated
-  E min([int compare(E a, E b)]) {
-    if (compare == null) compare = Comparable.compare;
-    Iterator it = iterator;
-    if (!it.moveNext()) return null;
-    E min = it.current;
-    while (it.moveNext()) {
-      E current = it.current;
-      if (compare(min, current) > 0) min = current;
-    }
-    return min;
-  }
-
-  /**
-   * Find the largest element in the iterable.
-   *
-   * Returns null if the iterable is empty.
-   * Otherwise returns an element [:x:] of this [Iterable] so that
-   * [:x:] is not smaller than [:y:] (that is, [:compare(x, y) >= 0:]) for all
-   * other elements [:y:] in the iterable.
-   *
-   * The [compare] function must be a proper [Comparator<T>]. If a function is
-   * not provided, [compare] defaults to [Comparable.compare].
-   *
-   * *Deprecated*. Use [reduce] with a binary max method if needed.
-   */
-  @deprecated
-  E max([int compare(E a, E b)]) {
-    if (compare == null) compare = Comparable.compare;
-    Iterator it = iterator;
-    if (!it.moveNext()) return null;
-    E max = it.current;
-    while (it.moveNext()) {
-      E current = it.current;
-      if (compare(max, current) < 0) max = current;
-    }
-    return max;
-  }
-
-  /**
    * Returns true if there is no element in this collection.
    */
   bool get isEmpty => !iterator.moveNext();
 
   /**
    * Returns an [Iterable] with at most [n] elements.
    *
    * The returned [Iterable] may contain fewer than [n] elements, if [this]
    * contains fewer than [n] elements.
    */
@@ skipping 198 matching lines @@
  */
 abstract class BidirectionalIterator<T> extends Iterator<T> {
   /**
    * Move back to the previous element.
    *
    * Returns true and updates [current] if successful. Returns false
    * and sets [current] to null if there is no previous element.
    */
   bool movePrevious();
 }