Revert "Make EfficientLength extend Iterable."

sdk/lib/internal/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._internal;
 
 /**
  * Marker interface for [Iterable] subclasses that have an efficient
  * [length] implementation.
  */
-abstract class EfficientLengthIterable<T> extends Iterable<T> {
-  const EfficientLengthIterable();
+abstract class EfficientLength {
   /**
    * Returns the number of elements in the iterable.
    *
    * This is an efficient operation that doesn't require iterating through
    * the elements.
    */
   int get length;
 }
 
 /**
  * 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 EfficientLengthIterable<E> {
+abstract class ListIterable<E> extends Iterable<E>
+                               implements EfficientLength {
   int get length;
   E elementAt(int i);
 
   const ListIterable();
 
   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++) {
@@ skipping 308 matching lines @@
   }
 }
 
 typedef T _Transformation<S, T>(S value);
 
 class MappedIterable<S, T> extends Iterable<T> {
   final Iterable<S> _iterable;
   final _Transformation<S, T> _f;
 
   factory MappedIterable(Iterable<S> iterable, T function(S value)) {
-    if (iterable is EfficientLengthIterable) {
+    if (iterable is EfficientLength) {
       return new EfficientLengthMappedIterable<S, T>(iterable, function);
     }
     return new MappedIterable<S, T>._(iterable, function);
   }
 
   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 EfficientLengthMappedIterable<S, T> extends MappedIterable<S, T>
-    implements EfficientLengthIterable<T> {
+                                          implements EfficientLength {
   EfficientLengthMappedIterable(Iterable<S> iterable, T function(S value))
       : super._(iterable, function);
 }
 
 class MappedIterator<S, T> extends Iterator<T> {
   T _current;
   final Iterator<S> _iterator;
   final _Transformation<S, T> _f;
 
   MappedIterator(this._iterator, T this._f(S element));
 
   bool moveNext() {
     if (_iterator.moveNext()) {
       _current = _f(_iterator.current);
       return true;
     }
     _current = null;
     return false;
   }
 
   T get current => _current;
 }
 
 /**
  * Specialized alternative to [MappedIterable] for mapped [List]s.
  *
  * Expects efficient `length` and `elementAt` on the source iterable.
  */
 class MappedListIterable<S, T> extends ListIterable<T>
-                               implements EfficientLengthIterable<T> {
+                               implements EfficientLength {
   final Iterable<S> _source;
   final _Transformation<S, T> _f;
 
   MappedListIterable(this._source, T this._f(S value));
 
   int get length => _source.length;
   T elementAt(int index) => _f(_source.elementAt(index));
 }
 
 
 typedef bool _ElementPredicate<E>(E element);
 
 class WhereIterable<E> extends Iterable<E> {
   final Iterable<E> _iterable;
   final _ElementPredicate<E> _f;
 
   WhereIterable(this._iterable, bool this._f(E element));
 
   Iterator<E> get iterator => new WhereIterator<E>(_iterable.iterator, _f);
 
-  // Specialization of [Iterable.map] to non-EfficientLengthIterable.
+  // Specialization of [Iterable.map] to non-EfficientLength.
   Iterable/*<T>*/ map/*<T>*/(/*=T*/ f(E element)) =>
      new MappedIterable<E, dynamic/*=T*/>._(this, f);
 }
 
 class WhereIterator<E> extends Iterator<E> {
   final Iterator<E> _iterator;
   final _ElementPredicate _f;
 
   WhereIterator(this._iterator, bool this._f(E element));
 
@@ skipping 52 matching lines @@
 }
 
 class TakeIterable<E> extends Iterable<E> {
   final Iterable<E> _iterable;
   final int _takeCount;
 
   factory TakeIterable(Iterable<E> iterable, int takeCount) {
     if (takeCount is! int || takeCount < 0) {
       throw new ArgumentError(takeCount);
     }
-    if (iterable is EfficientLengthIterable) {
+    if (iterable is EfficientLength) {
       return new EfficientLengthTakeIterable<E>(iterable, takeCount);
     }
     return new TakeIterable<E>._(iterable, takeCount);
   }
 
   TakeIterable._(this._iterable, this._takeCount);
 
   Iterator<E> get iterator {
     return new TakeIterator<E>(_iterable.iterator, _takeCount);
   }
 }
 
 class EfficientLengthTakeIterable<E> extends TakeIterable<E>
-                                     implements EfficientLengthIterable<E> {
+                                     implements EfficientLength {
   EfficientLengthTakeIterable(Iterable<E> iterable, int takeCount)
       : super._(iterable, takeCount);
 
   int get length {
     int iterableLength = _iterable.length;
     if (iterableLength > _takeCount) return _takeCount;
     return iterableLength;
   }
 }
 
@@ skipping 52 matching lines @@
     if (_isFinished) return null;
     return _iterator.current;
   }
 }
 
 class SkipIterable<E> extends Iterable<E> {
   final Iterable<E> _iterable;
   final int _skipCount;
 
   factory SkipIterable(Iterable<E> iterable, int count) {
-    if (iterable is EfficientLengthIterable) {
+    if (iterable is EfficientLength) {
       return new EfficientLengthSkipIterable<E>(iterable, count);
     }
     return new SkipIterable<E>._(iterable, count);
   }
 
   SkipIterable._(this._iterable, this._skipCount) {
     if (_skipCount is! int) {
       throw new ArgumentError.value(_skipCount, "count is not an integer");
     }
     RangeError.checkNotNegative(_skipCount, "count");
   }
 
   Iterable<E> skip(int count) {
     if (_skipCount is! int) {
       throw new ArgumentError.value(_skipCount, "count is not an integer");
     }
     RangeError.checkNotNegative(_skipCount, "count");
     return new SkipIterable<E>._(_iterable, _skipCount + count);
   }
 
   Iterator<E> get iterator {
     return new SkipIterator<E>(_iterable.iterator, _skipCount);
   }
 }
 
 class EfficientLengthSkipIterable<E> extends SkipIterable<E>
-                                     implements EfficientLengthIterable<E> {
+                                     implements EfficientLength {
   EfficientLengthSkipIterable(Iterable<E> iterable, int skipCount)
       : super._(iterable, skipCount);
 
   int get length {
     int length = _iterable.length - _skipCount;
     if (length >= 0) return length;
     return 0;
   }
 }
 
@@ skipping 41 matching lines @@
     }
     return _iterator.moveNext();
   }
 
   E get current => _iterator.current;
 }
 
 /**
  * The always empty [Iterable].
  */
-class EmptyIterable<E> extends EfficientLengthIterable<E> {
+class EmptyIterable<E> extends Iterable<E> implements EfficientLength {
   const EmptyIterable();
 
   Iterator<E> get iterator => const EmptyIterator();
 
   void forEach(void action(E element)) {}
 
   bool get isEmpty => true;
 
   int get length => 0;
 
@@ skipping 72 matching lines @@
  * Creates errors throw by [Iterable] when the element count is wrong.
  */
 abstract class IterableElementError {
   /** Error thrown thrown by, e.g., [Iterable.first] when there is no result. */
   static StateError noElement() => new StateError("No element");
   /** Error thrown by, e.g., [Iterable.single] if there are too many results. */
   static StateError tooMany() => new StateError("Too many elements");
   /** Error thrown by, e.g., [List.setRange] if there are too few elements. */
   static StateError tooFew() => new StateError("Too few elements");
 }