Make 'where' lazy.

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.
 
 /**
  * The [Iterable] interface allows to get an [Iterator] out of an
  * [Iterable] object.
  *
  * This interface is used by the for-in construct to iterate over an
  * [Iterable] object.
@@ skipping 17 matching lines @@
    *
    * This method returns a view of the mapped elements. As long as the
    * returned [Iterable] is not iterated over, the supplied function [f] will
    * not be invoked. The transformed elements will not be cached. Iterating
    * multiple times over the the returned [Iterable] will invoke the supplied
    * function [f] multiple times on the same element.
    */
   Iterable mappedBy(f(E element)) => new MappedIterable<E, dynamic>(this, f);
 
   /**
-   * Returns a collection with the elements of this collection
-   * that satisfy the predicate [f].
-   *
-   * The returned collection should be of the same type as the collection
-   * creating it.
-   *
-   * An element satisfies the predicate [f] if [:f(element):]
-   * returns true.
-   */
-  Collection<E> where(bool f(E element)) {
-    // TODO(floitsch): this is just a temporary function to provide a complete
-    // skeleton. It will be changed to become lazy soon.
-    List result = <E>[];
-    for (E element in this) if (f(element)) result.add(element);
-    return result;
-  }
+    * Returns a lazy [Iterable] with all elements that satisfy the
+    * predicate [f].
+    *
+    * This method returns a view of the mapped elements. As long as the
+    * returned [Iterable] is not iterated over, the supplied function [f] will
+    * not be invoked. Iterating will not cache results, and thus iterating
+    * multiple times over the the returned [Iterable] will invoke the supplied
+    * function [f] multiple times on the same element.
+    */
+  Iterable<E> where(bool f(E element)) => new WhereIterable<E>(this, f);
 
   /**
    * Check whether the collection contains an element equal to [element].
    */
   bool contains(E element) {
     for (E e in this) {
       if (e == element) return true;
     }
     return false;
   }
@@ skipping 68 matching lines @@
   bool get isEmpty => !iterator.moveNext();
 }
 
 class MappedIterable<S, T> extends Iterable<T> {
   final Iterable<S> _iterable;
   final Function _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;
 }
 
 class MappedIterator<S, T> extends Iterator<T> {
   T _current;
   Iterator<S> _iterator;
   Function _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;
     }
   }
 
   T get current => _current;
 }
 
-class FilteredIterable<E> extends Iterable<E> {
+class WhereIterable<E> extends Iterable<E> {
   final Iterable<E> _iterable;
   final Function _f;
 
-  FilteredIterable(this._iterable, bool this._f(E element));
+  WhereIterable(this._iterable, bool this._f(E element));
 
-  Iterator<E> get iterator => new FilteredIterator<E>(_iterable.iterator, _f);
+  Iterator<E> get iterator => new WhereIterator<E>(_iterable.iterator, _f);
 }
 
-class FilteredIterator<E> extends Iterator<E> {
+class WhereIterator<E> extends Iterator<E> {
   E _current;
   Iterator _iterator;
   Function _f;
 
-  FilteredIterator(this._iterator, bool this._f(E element));
+  WhereIterator(this._iterator, bool this._f(E element));
 
   bool moveNext() {
     while (_iterator.moveNext()) {
       if (_f(_iterator.current)) {
         _current = _iterator.current;
         return true;
       }
     }
     _current = null;
     return false;
   }
 
   E get current => _current;
 }