Added new version of reduce.

sdk/lib/collection/list.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.
 
 part of dart.collection;
 
 /**
  * Abstract implementation of a list.
  *
  * All operations are defined in terms of `length`, `operator[]`,
  * `operator[]=` and `length=`, which need to be implemented.
  */
 typedef ListBase<E> = Object with ListMixin<E>;
 
 /**
+ * Abstract implementation of a fixed-length list.

[floitsch, 2013/04/10 15:14:07]

I thought we agreed that these classes are not in dart.collection.

[Lasse Reichstein Nielsen, 2013/04/11 07:54:04]

Yes, yet another bad merge. Seems I was working on a stale version of this file.

+ *
+ * All operations are defined in terms of `length`, `operator[]` and
+ * `operator[]=`, which need to be implemented.
+ */
+typedef FixedLengthListBase<E> = ListBase<E> with FixedLengthListMixin<E>;
+
+/**
+ * Abstract implementation of an unmodifiable list.
+ *
+ * All operations are defined in terms of `length` and `operator[]`,
+ * which need to be implemented.
+ */
+typedef UnmodifiableListBase<E> = ListBase<E> with UnmodifiableListMixin<E>;
+
+/**
  * Base implementation of a [List] class.
  *
  * This class can be used as a mixin.
  *
  * This implements all read operations using only the `length` and
  * `operator[]` members. It implements write operations using those and
  * `length=` and `operator[]=`
  *
  * A fixed-length list should mix this class in, and the [FixedLengthListMixin]
  * as well, in that order, to overwrite the methods that modify the length.
@@ skipping 108 matching lines @@
         match = element;
       }
       if (length != this.length) {
         throw new ConcurrentModificationError(this);
       }
     }
     if (matchFound) return match;
     throw new StateError("No matching element");
   }
 
-  E min([int compare(E a, E b)]) {
-    if (length == 0) return null;
-    if (compare == null) {
-      var defaultCompare = Comparable.compare;
-      compare = defaultCompare;
-    }
-    E min = this[0];
+  String join([String separator]) {

[floitsch, 2013/04/10 15:14:07]

bad merge.

[Lasse Reichstein Nielsen, 2013/04/11 08:00:23]

Done.

     int length = this.length;
-    for (int i = 1; i < length; i++) {
-      E element = this[i];
-      if (compare(min, element) > 0) {
-        min = element;
-      }
-      if (length != this.length) {
-        throw new ConcurrentModificationError(this);
-      }
-    }
-    return min;
-  }
-
-  E max([int compare(E a, E b)]) {
-    if (length == 0) return null;
-    if (compare == null) {
-      var defaultCompare = Comparable.compare;
-      compare = defaultCompare;
-    }
-    E max = this[0];
-    int length = this.length;
-    for (int i = 1; i < length; i++) {
-      E element = this[i];
-      if (compare(max, element) < 0) {
-        max = element;
-      }
-      if (length != this.length) {
-        throw new ConcurrentModificationError(this);
-      }
-    }
-    return max;
-  }
-
-  String join([String separator = ""]) {
-    int length = this.length;
-    if (!separator.isEmpty) {
+    if (separator != null && !separator.isEmpty) {

[floitsch, 2013/04/10 15:14:07]

bad merge.

[Lasse Reichstein Nielsen, 2013/04/11 08:00:23]

Done.

       if (length == 0) return "";
       String first = "${this[0]}";
       if (length != this.length) {
         throw new ConcurrentModificationError(this);
       }
       StringBuffer buffer = new StringBuffer(first);
       for (int i = 1; i < length; i++) {
         buffer.write(separator);
-        buffer.write(this[i]);
+        buffer.write("${this[i]}");

[floitsch, 2013/04/10 15:14:07]

bad merge.

         if (length != this.length) {
           throw new ConcurrentModificationError(this);
         }
       }
       return buffer.toString();
     } else {
       StringBuffer buffer = new StringBuffer();
       for (int i = 0; i < length; i++) {
-        buffer.write(this[i]);
+        buffer.write("${this[i]}");

[floitsch, 2013/04/10 15:14:07]

bad merge.

         if (length != this.length) {
           throw new ConcurrentModificationError(this);
         }
       }
       return buffer.toString();
     }
   }
 
   Iterable<E> where(bool test(E element)) => new WhereIterable<E>(this, test);
 
   Iterable map(f(E element)) => new MappedListIterable(this, f);
 
-  reduce(var initialValue, combine(var previousValue, E element)) {
-    return fold(initialValue, combine);
+  E reduce(E combine(E previousValue, E element)) {
+    if (length == 0) throw new StateError("No elements");
+    E value = this[0];
+    for (int i = 1; i < length; i++) {
+      value = combine(value, this[i]);
+    }
+    return value;
   }
 
   fold(var initialValue, combine(var previousValue, E element)) {
     var value = initialValue;
     int length = this.length;
     for (int i = 0; i < length; i++) {
       value = combine(value, this[i]);
       if (length != this.length) {
         throw new ConcurrentModificationError(this);
       }
@@ skipping 56 matching lines @@
   }
 
   void removeAll(Iterable<Object> elements) {
     if (elements is! Set) {
       elements = elements.toSet();
     }
     _filter(this, elements.contains, false);
   }
 
 
-  void retainAll(Iterable<E> elements) {
+  void retainAll(Iterable<E> iterable) {
     if (elements is! Set) {
       elements = elements.toSet();
     }
     _filter(this, elements.contains, true);
   }
 
   void removeWhere(bool test(E element)) {
     _filter(this, test, false);
   }
 
@@ skipping 14 matching lines @@
       if (length != source.length) {
         throw new ConcurrentModificationError(source);
       }
     }
     if (retained.length != source.length) {
       source.setRange(0, retained.length, retained);
       source.length = retained.length;
     }
   }
 
-  void clear() { this.length = 0; }

[floitsch, 2013/04/10 15:14:07]

Didn't you just add them?
bad merge?

-
   // List interface.
 
-  E removeLast() {
-    if (length == 0) {
-      throw new StateError("No elements");
-    }
-    E result = this[length - 1];
-    length--;
-    return result;
-  }
-
   void sort([Comparator<E> compare]) {
     Sort.sort(this, compare);
   }
 
   Map<int, E> asMap() {
     return new ListMapView(this);
   }
 
   List<E> sublist(int start, [int end]) {
     if (end == null) end = length;
@@ skipping 91 matching lines @@
    * the search at index [startIndex] to 0.
    * Returns -1 if [element] is not found.
    */
   int lastIndexOf(E element, [int startIndex]) {
     if (startIndex == null) {
       startIndex = this.length - 1;
     } else {
       if (startIndex < 0) {
         return -1;
       }
-      if (startIndex >= this.length) {
-        startIndex = this.length - 1;
+      if (startIndex >= a.length) {

[floitsch, 2013/04/10 15:14:07]

I guess bad merge.

+        startIndex = a.length - 1;
       }
     }
     for (int i = startIndex; i >= 0; i--) {
       if (this[i] == element) {
         return i;
       }
     }
     return -1;
   }
 
-  Iterable<E> get reversed => new ReversedListIterable(this);
+  Iterable<E> get reversed => new _ReversedListIterable(this);

[floitsch, 2013/04/10 15:14:07]

bad merge.

 }
+
+/**
+ * Mixin that throws on the length changing operations of [List].
+ *
+ * Intended to mix-in on top of [ListMixin] for fixed-length lists.
+ */
+abstract class FixedLengthListMixin<E>  {

[floitsch, 2013/04/10 15:14:07]

This shouldn't be here either.

+  void set length(int newLength) {
+    throw new UnsupportedError(
+        "Cannot change the length of a fixed-length list");
+  }
+
+  void add(E value) {
+    throw new UnsupportedError(
+        "Cannot add to a fixed-length list");
+  }
+
+  void insert(int index, E value) {
+    throw new UnsupportedError(
+        "Cannot add to a fixed-length list");
+  }
+
+  void addAll(Iterable<E> iterable) {
+    throw new UnsupportedError(
+        "Cannot add to a fixed-length list");
+  }
+
+  void remove(E element) {
+    throw new UnsupportedError(
+        "Cannot remove from a fixed-length list");
+  }
+
+  void removeAll(Iterable elements) {
+    throw new UnsupportedError(
+        "Cannot remove from a fixed-length list");
+  }
+
+  void retainAll(Iterable elements) {
+    throw new UnsupportedError(
+        "Cannot remove from a fixed-length list");
+  }
+
+  void removeWhere(bool test(E element)) {
+    throw new UnsupportedError(
+        "Cannot remove from a fixed-length list");
+  }
+
+  void retainWhere(bool test(E element)) {
+    throw new UnsupportedError(
+        "Cannot remove from a fixed-length list");
+  }
+
+  void clear() {
+    throw new UnsupportedError(
+        "Cannot clear a fixed-length list");
+  }
+
+  E removeAt(int index) {
+    throw new UnsupportedError(
+        "Cannot remove from a fixed-length list");
+  }
+
+  E removeLast() {
+    throw new UnsupportedError(
+        "Cannot remove from a fixed-length list");
+  }
+
+  void removeRange(int start, int length) {
+    throw new UnsupportedError(
+        "Cannot remove from a fixed-length list");
+  }
+
+  void insertRange(int start, int length, [E initialValue]) {
+    throw new UnsupportedError(
+        "Cannot insert range in a fixed-length list");
+  }
+}
+
+/**
+ * Mixin for an unmodifiable [List] class.
+ *
+ * This overrides all mutating methods with methods that throw.
+ * This mixin is intended to be mixed in on top of [ListMixin] on
+ * unmodifiable lists.
+ */
+abstract class UnmodifiableListMixin<E> {

[floitsch, 2013/04/10 15:14:07]

ditto.

+
+  void operator []=(int index, E value) {
+    throw new UnsupportedError(
+        "Cannot modify an unmodifiable list");
+  }
+
+  void set length(int newLength) {
+    throw new UnsupportedError(
+        "Cannot change the length of an unmodifiable list");
+  }
+
+  void add(E value) {
+    throw new UnsupportedError(
+        "Cannot add to an unmodifiable list");
+  }
+
+  E insert(int index, E value) {
+    throw new UnsupportedError(
+        "Cannot add to an unmodifiable list");
+  }
+
+  void addAll(Iterable<E> iterable) {
+    throw new UnsupportedError(
+        "Cannot add to an unmodifiable list");
+  }
+
+  void remove(E element) {
+    throw new UnsupportedError(
+        "Cannot remove from an unmodifiable list");
+  }
+
+  void removeAll(Iterable elements) {
+    throw new UnsupportedError(
+        "Cannot remove from an unmodifiable list");
+  }
+
+  void retainAll(Iterable elements) {
+    throw new UnsupportedError(
+        "Cannot remove from an unmodifiable list");
+  }
+
+  void removeWhere(bool test(E element)) {
+    throw new UnsupportedError(
+        "Cannot remove from an unmodifiable list");
+  }
+
+  void retainWhere(bool test(E element)) {
+    throw new UnsupportedError(
+        "Cannot remove from an unmodifiable list");
+  }
+
+  void sort([Comparator<E> compare]) {
+    throw new UnsupportedError(
+        "Cannot modify an unmodifiable list");
+  }
+
+  void clear() {
+    throw new UnsupportedError(
+        "Cannot clear an unmodifiable list");
+  }
+
+  E removeAt(int index) {
+    throw new UnsupportedError(
+        "Cannot remove from an unmodifiable list");
+  }
+
+  E removeLast() {
+    throw new UnsupportedError(
+        "Cannot remove from an unmodifiable list");
+  }
+
+  void setRange(int start, int length, List<E> from, [int startFrom]) {
+    throw new UnsupportedError(
+        "Cannot modify an unmodifiable list");
+  }
+
+  void removeRange(int start, int length) {
+    throw new UnsupportedError(
+        "Cannot remove from an unmodifiable list");
+  }
+
+  void insertRange(int start, int length, [E initialValue]) {
+    throw new UnsupportedError(
+        "Cannot insert range in an unmodifiable list");
+  }
+}
+
+class _ReversedListIterable<E> extends ListIterable<E> {
+  Iterable<E> _source;
+  _ReversedListIterable(this._source);
+
+  int get length => _source.length;
+
+  E elementAt(int index) => _source.elementAt(_source.length - 1 - index);
+}