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(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 [Queryable] with all elements that satisfy the

[Anders Johnsen, 2012/11/20 06:32:21]

Queryable?

[floitsch, 2012/11/28 13:49:38]

Done.

+    * predicate [f].
+    *
+    * This method returns a view of the mapped elements. As long as the
+    * returned [Queryable] 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 [Queryable] will invoke the supplied
+    * function [f] multiple times on the same element.
+    */
+  Iterable<E> where(bool f(E element)) => new FilteredIterable<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<E> extends Iterable<E> {
   final Iterable _iterable;
   final Function _f;
 
   MappedIterable(this._iterable, E this._f(element));
 
   Iterator<E> get iterator => new MappedIterator<E>(_iterable.iterator, _f);
+
+  // Length related functions are independent of the mapping.
+  int get length => _iterable.length;
+  bool get isEmpty => _iterable.isEmpty;
 }
 
 class MappedIterator<E> extends Iterator<E> {
   E _current;
   Iterator _iterator;
   Function _f;
 
   MappedIterator(this._iterator, E this._f(element));
 
   bool moveNext() {
@@ skipping 31 matching lines @@
         _current = _iterator.current;
         return true;
       }
     }
     _current = null;
     return false;
   }
 
   E get current => _current;
 }