Recommit changing List.skip/take/revert returns Iterable and remove mappedBy.

sdk/lib/_collection_dev/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._collection.dev;
 
-
 /**
  * An [Iterable] for classes that have efficient [length] and [elementAt].
  *
  * All other methods are implemented in terms of [length] and [elementAt],
  * including [iterator].
  */
 abstract class ListIterable<E> extends Iterable<E> {
   int get length;
   E elementAt(int i);
 
-  Iterator<E> get iterator => new ListIterableIterator<E>(this);
+  Iterator<E> get iterator => new ListIterator<E>(this);
 
   void forEach(void action(E element)) {
     int length = this.length;
     for (int i = 0; i < length; i++) {
       action(elementAt(i));
       if (length != this.length) {
         throw new ConcurrentModificationError(this);
       }
     }
   }
@@ skipping 57 matching lines @@
       if (length != this.length) {
         throw new ConcurrentModificationError(this);
       }
     }
     if (orElse != null) return orElse();
     throw new StateError("No matching element");
   }
 
   E lastMatching(bool test(E element), { E orElse() }) {
     int length = this.length;
-    for (int i = length - 1; i >= 0; i++) {
+    for (int i = length - 1; i >= 0; i--) {
       E element = elementAt(i);
       if (test(element)) return element;
       if (length != this.length) {
         throw new ConcurrentModificationError(this);
       }
     }
     if (orElse != null) return orElse();
     throw new StateError("No matching element");
   }
 
@@ skipping 82 matching lines @@
         if (length != this.length) {
           throw new ConcurrentModificationError(this);
         }
       }
       return buffer.toString();
     }
   }
 
   Iterable<E> where(bool test(E element)) => super.where(test);
 
-  Iterable map(f(E element)) => new MappedIterable(this, f);
-
-  Iterable mappedBy(f(E element)) => super.mappedBy(f);
+  Iterable map(f(E element)) => new MappedListIterable(this, f);
 
   reduce(var initialValue, combine(var previousValue, E element)) {
     var value = initialValue;
     int length = this.length;
     for (int i = 0; i < length; i++) {
-      value = reduce(value, elementAt(i));
+      value = combine(value, elementAt(i));
       if (length != this.length) {
         throw new ConcurrentModificationError(this);
       }
     }
     return value;
   }
 
   Iterable<E> skip(int count) => new SubListIterable(this, count, null);
 
   Iterable<E> skipWhile(bool test(E element)) => super.skipWhile(test);
@@ skipping 12 matching lines @@
 
   Set<E> toSet() {
     Set<E> result = new Set<E>();
     for (int i = 0; i < length; i++) {
       result.add(elementAt(i));
     }
     return result;
   }
 }
 
-abstract class SubListIterable<E> extends ListIterable<E> {
+class SubListIterable<E> extends ListIterable<E> {
   final Iterable<E> _iterable;
   final int _start;
   /** If null, represents the length of the iterable. */
   final int _endOrLength;
 
   SubListIterable(this._iterable, this._start, this._endOrLength);
 
   int get _endIndex {
     int length = _iterable.length;
     if (_endOrLength == null || _endOrLength > length) return length;
@@ skipping 26 matching lines @@
   Iterable<E> skip(int count) {
     if (count < 0) throw new ArgumentError(count);
     return new SubListIterable(_iterable, _start + count, _endOrLength);
   }
 
   Iterable<E> take(int count) {
     if (count < 0) throw new ArgumentError(count);
     if (_endOrLength == null) {
       return new SubListIterable(_iterable, _start, _start + count);
     } else {
-      newEnd = _start + count;
+      int newEnd = _start + count;
       if (_endOrLength < newEnd) return this;
       return new SubListIterable(_iterable, _start, newEnd);
     }
   }
 }
 
-class ListIterableIterator<E> implements Iterator<E> {
+/**
+ * An [Iterator] that iterates a list-like [Iterable].
+ *
+ * All iterations is done in terms of [Iterable.length] and
+ * [Iterable.elementAt]. These operations are fast for list-like
+ * iterables.
+ */
+class ListIterator<E> implements Iterator<E> {
   final Iterable<E> _iterable;
   final int _length;
   int _index;
   E _current;
-  ListIterableIterator(Iterable<E> iterable)
+
+  ListIterator(Iterable<E> iterable)
       : _iterable = iterable, _length = iterable.length, _index = 0;
 
   E get current => _current;
 
   bool moveNext() {
     if (_length != _iterable.length) {
       throw new ConcurrentModificationError(_iterable);
     }
     if (_index == _length) {
       _current = null;
@@ skipping 13 matching lines @@
   // checked mode. http://dartbug.com/7733
   final /* _Transformation<S, T> */ _f;
 
   MappedIterable(this._iterable, T this._f(S element));
 
   Iterator<T> get iterator => new MappedIterator<S, T>(_iterable.iterator, _f);
 
   // Length related functions are independent of the mapping.
   int get length => _iterable.length;
   bool get isEmpty => _iterable.isEmpty;
+
+  // Index based lookup can be done before transforming.
+  T get first => _f(_iterable.first);
+  T get last => _f(_iterable.last);
+  T get single => _f(_iterable.single);
+  T elementAt(int index) => _f(_iterable.elementAt(index));
 }
 
-
 class MappedIterator<S, T> extends Iterator<T> {
   T _current;
   final Iterator<S> _iterator;
   // TODO(ahe): Restore type when feature is implemented in dart2js
   // checked mode. http://dartbug.com/7733
   final /* _Transformation<S, T> */ _f;
 
   MappedIterator(this._iterator, T this._f(S element));
 
   bool moveNext() {
     if (_iterator.moveNext()) {
       _current = _f(_iterator.current);
       return true;
-    } else {
-      _current = null;
-      return false;
     }
+    _current = null;
+    return false;
   }
 
   T get current => _current;
 }
 
 /** Specialized alternative to [MappedIterable] for mapped [List]s. */
-class MappedListIterable<S, T> extends Iterable<T> {
-  final List<S> _list;
-  /**
-   * Start index of the part of the list to map.
-   *
-   * Allows mapping only a sub-list of an existing list.
-   *
-   * Used to implement lazy skip/take on a [MappedListIterable].
-   */
-  final int _start;
-
-  /**
-   * End index of the part of the list to map.
-   *
-   * If null, always use the length of the list.
-   */
-  final int _end;
-
+class MappedListIterable<S, T> extends ListIterable<T> {
+  final Iterable<S> _source;
   // TODO(ahe): Restore type when feature is implemented in dart2js
   // checked mode. http://dartbug.com/7733
   final /* _Transformation<S, T> */ _f;
 
-  MappedListIterable(this._list, T this._f(S element), this._start, this._end) {
-    if (_end != null && _end < _start) {
-      throw new ArgumentError("End ($_end) before start ($_start)");
-    }
-  }
+  MappedListIterable(this._source, T this._f(S value));
 
-  /** The start index, limited to the current length of the list. */
-  int get _startIndex {
-    if (_start <= _list.length) return _start;
-    return _list.length;
-  }
-
-  /** The end index, if given, limited to the current length of the list. */
-  int get _endIndex {
-    if (_end == null || _end > _list.length) return _list.length;
-    return _end;
-  }
-
-  Iterator<T> get iterator =>
-      new MappedListIterator<S, T>(_list, _f, _startIndex, _endIndex);
-
-  void forEach(void action(T element)) {
-    int length = _list.length;
-    for (int i = _startIndex, n = _endIndex; i < n; i++) {
-      action(_f(_list[i]));
-      if (_list.length != length) {
-        throw new ConcurrentModificationError(_list);
-      }
-    }
-  }
-
-  bool get isEmpty => _startIndex == _endIndex;
-
-  int get length => _endIndex - _startIndex;
-
-  T get first {
-    int start = _startIndex;
-    if (start == _endIndex) {
-      throw new StateError("No elements");
-    }
-    return _f(_list.elementAt(start));
-  }
-
-  T get last {
-    int end = _endIndex;
-    if (end == _startIndex) {
-      throw new StateError("No elements");
-    }
-    return _f(_list.elementAt(end - 1));
-  }
-
-  T get single {
-    int start = _startIndex;
-    int end = _endIndex;
-    if (start != end - 1) {
-      if (start == end) {
-        throw new StateError("No elements");
-      }
-      throw new StateError("Too many elements");
-    }
-    return _f(_list[start]);
-  }
-
-  T elementAt(int index) {
-    index += _startIndex;
-    if (index >= _endIndex) {
-      throw new StateError("No matching element");
-    }
-    return _f(_list.elementAt(index));
-  }
-
-  bool contains(T element) {
-    int length = _list.length;
-    for (int i = _startIndex, n = _endIndex; i < n; i++) {
-      if (_f(_list[i]) == element) {
-        return true;
-      }
-      if (_list.length != length) {
-        throw new ConcurrentModificationError(_list);
-      }
-    }
-    return false;
-  }
-
-  bool every(bool test(T element)) {
-    int length = _list.length;
-    for (int i = _startIndex, n = _endIndex; i < n; i++) {
-      if (!test(_f(_list[i]))) return false;
-      if (_list.length != length) {
-        throw new ConcurrentModificationError(_list);
-      }
-    }
-    return true;
-  }
-
-  bool any(bool test(T element)) {
-    int length = _list.length;
-    for (int i = _startIndex, n = _endIndex; i < n; i++) {
-      if (test(_f(_list[i]))) return true;
-      if (_list.length != length) {
-        throw new ConcurrentModificationError(_list);
-      }
-    }
-    return false;
-  }
-
-  T firstMatching(bool test(T element), { T orElse() }) {
-    int length = _list.length;
-    for (int i = _startIndex, n = _endIndex; i < n; i++) {
-      T value = _f(_list[i]);
-      if (test(value)) return value;
-      if (_list.length != length) {
-        throw new ConcurrentModificationError(_list);
-      }
-    }
-    if (orElse != null) return orElse();
-    throw new StateError("No matching element");
-  }
-
-  T lastMatching(bool test(T element), { T orElse() }) {
-    int length = _list.length;
-    for (int i = _endIndex - 1, start = _startIndex; i >= start; i++) {
-      T value = _f(_list[i]);
-      if (test(value)) return value;
-      if (_list.length != length) {
-        throw new ConcurrentModificationError(_list);
-      }
-    }
-    if (orElse != null) return orElse();
-    throw new StateError("No matching element");
-  }
-
-  T singleMatching(bool test(T element)) {
-    int length = _list.length;
-    T match;
-    bool matchFound = false;
-    for (int i = _startIndex, n = _endIndex; i < n; i++) {
-      T value = _f(_list[i]);
-      if (test(value)) {
-        if (matchFound) {
-          throw new StateError("More than one matching element");
-        }
-        matchFound = true;
-        match = value;
-      }
-      if (_list.length != length) {
-        throw new ConcurrentModificationError(_list);
-      }
-    }
-    if (matchFound) return match;
-    throw new StateError("No matching element");
-  }
-
-  T min([int compare(T a, T b)]) {
-    if (compare == null) {
-      var defaultCompare = Comparable.compare;
-      compare = defaultCompare;
-    }
-    int length = _list.length;
-    int start = _startIndex;
-    int end = _endIndex;
-    if (start == end) return null;
-    T value = _f(_list[start]);
-    if (_list.length != length) {
-      throw new ConcurrentModificationError(_list);
-    }
-    for (int i = start + 1; i < end; i++) {
-      T nextValue = _f(_list[i]);
-      if (compare(value, nextValue) > 0) {
-        value = nextValue;
-      }
-      if (_list.length != length) {
-        throw new ConcurrentModificationError(_list);
-      }
-    }
-    return value;
-  }
-
-  T max([int compare(T a, T b)]) {
-    if (compare == null) {
-      var defaultCompare = Comparable.compare;
-      compare = defaultCompare;
-    }
-    int length = _list.length;
-    int start = _startIndex;
-    int end = _endIndex;
-    if (start == end) return null;
-    T value = _f(_list[start]);
-    if (_list.length != length) {
-      throw new ConcurrentModificationError(_list);
-    }
-    for (int i = start + 1; i < end; i++) {
-      T nextValue = _f(_list[i]);
-      if (compare(value, nextValue) < 0) {
-        value = nextValue;
-      }
-      if (_list.length != length) {
-        throw new ConcurrentModificationError(_list);
-      }
-    }
-    return value;
-  }
-
-  String join([String separator]) {
-    int start = _startIndex;
-    int end = _endIndex;
-    if (start == end) return "";
-    StringBuffer buffer = new StringBuffer("${_f(_list[start])}");
-    if (_list.length != length) {
-      throw new ConcurrentModificationError(_list);
-    }
-    for (int i = start + 1; i < end; i++) {
-      if (separator != null && separator != "") {
-        buffer.add(separator);
-      }
-      buffer.add("${_f(_list[i])}");
-      if (_list.length != length) {
-        throw new ConcurrentModificationError(_list);
-      }
-    }
-    return buffer.toString();
-  }
-
-  Iterable<T> where(bool test(T element)) => super.where(test);
-
-  Iterable map(f(T element)) {
-    return new MappedListIterable(_list, (S v) => f(_f(v)), _start, _end);
-  }
-
-  Iterable mappedBy(f(T element)) => map(f);
-
-  reduce(var initialValue, combine(var previousValue, T element)) {
-    return _list.reduce(initialValue, (v, S e) => combine(v, _f(e)));
-  }
-
-  Iterable<T> skip(int count) {
-    int start = _startIndex + count;
-    if (_end != null && start >= _end) {
-      return new EmptyIterable<T>();
-    }
-    return new MappedListIterable(_list, _f, start, _end);
-  }
-
-  Iterable<T> skipWhile(bool test(T element)) => super.skipWhile(test);
-
-  Iterable<T> take(int count)  {
-    int newEnd = _start + count;
-    if (_end == null || newEnd < _end)  {
-      return new MappedListIterable(_list, _f, _start, newEnd);
-    }
-    // Equivalent to "this".
-    return new MappedListIterable(_list, _f, _start, _end);
-  }
-
-  Iterable<T> takeWhile(bool test(T element)) => super.takeWhile(test);
-
-  List<T> toList() {
-    List<T> result = new List<T>();
-    forEach(result.add);
-    return result;
-  }
-
-  Set<T> toSet() {
-    Set<T> result = new Set<T>();
-    forEach(result.add);
-    return result;
-  }
+  int get length => _source.length;
+  T elementAt(int index) => _f(_source.elementAt(index));
 }
 
-/**
- * Iterator for [MappedListIterable].
- *
- * A list iterator that iterates over (a sublist of) a list and
- * returns the values transformed by a function.
- *
- * As a list iterator, it throws if the length of the list has
- * changed during iteration.
- */
-class MappedListIterator<S, T> implements Iterator<T> {
-  List<S> _list;
-  // TODO(ahe): Restore type when feature is implemented in dart2js
-  // checked mode. http://dartbug.com/7733
-  final /* _Transformation<S, T> */ _f;
-  final int _endIndex;
-  final int _length;
-  int _index;
-  T _current;
-
-  MappedListIterator(List<S> list, this._f, int start, this._endIndex)
-      : _list = list, _length = list.length, _index = start;
-
-  T get current => _current;
-
-  bool moveNext() {
-    if (_list.length != _length) {
-      throw new ConcurrentModificationError(_list);
-    }
-    if (_index >= _endIndex) {
-      _current = null;
-      return false;
-    }
-    _current = _f(_list[_index]);
-    _index++;
-    return true;
-  }
-}
 
 typedef bool _ElementPredicate<E>(E element);
 
 class WhereIterable<E> extends Iterable<E> {
   final Iterable<E> _iterable;
   // TODO(ahe): Restore type when feature is implemented in dart2js
   // checked mode. http://dartbug.com/7733
   final /* _ElementPredicate */ _f;
 
   WhereIterable(this._iterable, bool this._f(E element));
@@ skipping 265 matching lines @@
   E min([int compare(E a, E b)]) => null;
 
   E max([int compare(E a, E b)]) => null;
 
   String join([String separator]) => "";
 
   Iterable<E> where(bool test(E element)) => this;
 
   Iterable map(f(E element)) => const EmptyIterable();
 
-  Iterable mappedBy(f(E element)) => const EmptyIterable();
-
   reduce(var initialValue, combine(var previousValue, E element)) {
     return initialValue;
   }
 
   Iterable<E> skip(int count) => this;
 
   Iterable<E> skipWhile(bool test(E element)) => this;
 
   Iterable<E> take(int count) => this;
 
   Iterable<E> takeWhile(bool test(E element)) => this;
 
   List toList() => <E>[];
 
   Set toSet() => new Set<E>();
 }
 
 /** The always empty iterator. */
 class EmptyIterator<E> implements Iterator<E> {
   const EmptyIterator();
   bool moveNext() => false;
   E get current => null;
 }
 
 /** An [Iterator] that can move in both directions. */
 abstract class BiDirectionalIterator<T> implements Iterator<T> {
   bool movePrevious();
 }