Make mappedBy 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.
  * The for-in construct takes an [Iterable] object at the right-hand
  * side, and calls its [iterator] method to get an [Iterator] on it.
  *
  * A user-defined class that implements the [Iterable] interface can
  * be used as the right-hand side of a for-in construct.
  */
 abstract class Iterable<E> {
   const Iterable();
 
   /**
    * Returns an [Iterator] that iterates over this [Iterable] object.
    */
   Iterator<E> get iterator;
 
   /**
-   * Returns a new collection with the elements [: f(e) :]
-   * for each element [:e:] of this collection.
+   * Returns a lazy [Iterable] where each element [:e:] of [this] is replaced
+   * by the result of [:f(e):].
    *
-   * Subclasses of [Collection] should implement the [mappedBy] method
-   * to return a collection of the same general type as themselves.
-   * E.g., [List.mappedBy] should return a [List].
+   * 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.
    */
-  Collection mappedBy(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 = [];
-    for (E element in this) result.add(f(element));
-    return result;
-  }
+  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.
@@ skipping 78 matching lines @@
       count++;
     }
     return count;
   }
 
   /**
    * Returns true if there is no element in this collection.
    */
   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);
+}
+
+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> {
+  final Iterable<E> _iterable;
+  final Function _f;
+
+  FilteredIterable(this._iterable, bool this._f(E element));
+
+  Iterator<E> get iterator => new FilteredIterator<E>(_iterable.iterator, _f);
+}
+
+class FilteredIterator<E> extends Iterator<E> {
+  E _current;
+  Iterator _iterator;
+  Function _f;
+
+  FilteredIterator(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;
+}