Make EfficientLength public, as EfficientLengthIterable.

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;
 
 /**
  * A collection of values, or "elements", that can be accessed sequentially.
  *
  * The elements of the iterable are accessed by getting an [Iterator]
@@ skipping 329 matching lines @@
   Set<E> toSet() => new Set<E>.from(this);
 
   /**
    * Returns the number of elements in [this].
    *
    * Counting all elements may involve iterating through all elements and can
    * therefore be slow.
    * Some iterables have a more efficient way to find the number of elements.
    */
   int get length {
-    assert(this is! EfficientLength);
+    assert(this is! EfficientLengthIterable);
     int count = 0;
     Iterator it = iterator;
     while (it.moveNext()) {
       count++;
     }
     return count;
   }
 
   /**
    * Returns `true` if there are no elements in this collection.
@@ skipping 226 matching lines @@
    * The conversion may omit calling `toString` on some elements if they
    * are known to not occur in the output, and it may stop iterating after
    * a hundred elements.
    */
   String toString() => IterableBase.iterableToShortString(this, '(', ')');
 }
 
 typedef E _Generator<E>(int index);
 
 class _GeneratorIterable<E> extends Iterable<E>
-                            implements EfficientLength {
+                            implements EfficientLengthIterable<E> {
   final int _start;
   final int _end;
   final _Generator<E> _generator;
   _GeneratorIterable(this._end, E generator(int n))
       : _start = 0,
         _generator = (generator != null) ? generator : _id;
 
   _GeneratorIterable.slice(this._start, this._end, this._generator);
 
   Iterator<E> get iterator =>
@@ skipping 46 matching lines @@
  */
 abstract class BidirectionalIterator<E> implements Iterator<E> {
   /**
    * 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();
 }