Make mappedBy lazy.

sdk/lib/html/dart2js/html_dart2js.dart

 library html;
 
 import 'dart:async';
 import 'dart:isolate';
-import 'dart:json';
+import 'dart:json' as json;
 import 'dart:svg' as svg;
 // Copyright (c) 2012, 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.
 
 // DO NOT EDIT
 // Auto-generated dart:html library.
 
 
 
@@ skipping 5313 matching lines @@
   }
 
   void addAll(Collection<DOMMimeType> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   bool contains(DOMMimeType element) => _Collections.contains(this, element);
 
   void forEach(void f(DOMMimeType element)) => _Collections.forEach(this, f);
 
-  Collection mappedBy(f(DOMMimeType element)) => _Collections.mappedBy(this, [], f);
+  Iterable mappedBy(f(DOMMimeType element)) => new MappedIterable(this, f);
 
   Collection<DOMMimeType> where(bool f(DOMMimeType element)) =>
      _Collections.where(this, <DOMMimeType>[], f);
 
   bool every(bool f(DOMMimeType element)) => _Collections.every(this, f);
 
   bool some(bool f(DOMMimeType element)) => _Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
@@ skipping 118 matching lines @@
   }
 
   void addAll(Collection<DOMPlugin> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   bool contains(DOMPlugin element) => _Collections.contains(this, element);
 
   void forEach(void f(DOMPlugin element)) => _Collections.forEach(this, f);
 
-  Collection mappedBy(f(DOMPlugin element)) => _Collections.mappedBy(this, [], f);
+  Iterable mappedBy(f(DOMPlugin element)) => new MappedIterable(this, f);
 
   Collection<DOMPlugin> where(bool f(DOMPlugin element)) =>
      _Collections.where(this, <DOMPlugin>[], f);
 
   bool every(bool f(DOMPlugin element)) => _Collections.every(this, f);
 
   bool some(bool f(DOMPlugin element)) => _Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
@@ skipping 1270 matching lines @@
 
   bool some(bool f(Element element)) {
     for (Element element in this) {
       if (f(element)) {
         return true;
       }
     };
     return false;
   }
 
-  Collection mappedBy(f(Element element)) {
-    final out = [];
-    for (Element el in this) {
-      out.add(f(el));
-    }
-    return out;
-  }
+  Iterable mappedBy(f(Element element)) => new MappedIterable(this, f);
 
   bool get isEmpty {
     return _element.$dom_firstElementChild == null;
   }
 
   int get length {
     return _childElements.length;
   }
 
   Element operator [](int index) {
@@ skipping 90 matching lines @@
     }
     return false;
   }
 
   void forEach(void f(Element element)) {
     for (Element el in this) {
       f(el);
     }
   }
 
-  Collection mappedBy(f(Element element)) {
-    final out = [];
-    for (Element el in this) {
-      out.add(f(el));
-    }
-    return out;
-  }
+  Iterable mappedBy(f(Element element)) => new MappedIterable(this, f);
 
   List<Element> where(bool f(Element element)) {
     final out = [];
     for (Element el in this) {
       if (f(el)) out.add(el);
     }
     return out;
   }
 
   bool every(bool f(Element element)) {
@@ skipping 1718 matching lines @@
   }
 
   void addAll(Collection<num> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   bool contains(num element) => _Collections.contains(this, element);
 
   void forEach(void f(num element)) => _Collections.forEach(this, f);
 
-  Collection mappedBy(f(num element)) => _Collections.mappedBy(this, [], f);
+  Iterable mappedBy(f(num element)) => new MappedIterable(this, f);
 
   Collection<num> where(bool f(num element)) =>
      _Collections.where(this, <num>[], f);
 
   bool every(bool f(num element)) => _Collections.every(this, f);
 
   bool some(bool f(num element)) => _Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
@@ skipping 88 matching lines @@
   }
 
   void addAll(Collection<num> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   bool contains(num element) => _Collections.contains(this, element);
 
   void forEach(void f(num element)) => _Collections.forEach(this, f);
 
-  Collection mappedBy(f(num element)) => _Collections.mappedBy(this, [], f);
+  Iterable mappedBy(f(num element)) => new MappedIterable(this, f);
 
   Collection<num> where(bool f(num element)) =>
      _Collections.where(this, <num>[], f);
 
   bool every(bool f(num element)) => _Collections.every(this, f);
 
   bool some(bool f(num element)) => _Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
@@ skipping 345 matching lines @@
   }
 
   void addAll(Collection<Node> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   bool contains(Node element) => _Collections.contains(this, element);
 
   void forEach(void f(Node element)) => _Collections.forEach(this, f);
 
-  Collection mappedBy(f(Node element)) => _Collections.mappedBy(this, [], f);
+  Iterable mappedBy(f(Node element)) => new MappedIterable(this, f);
 
   Collection<Node> where(bool f(Node element)) =>
      _Collections.where(this, <Node>[], f);
 
   bool every(bool f(Node element)) => _Collections.every(this, f);
 
   bool some(bool f(Node element)) => _Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
@@ skipping 82 matching lines @@
   }
 
   void addAll(Collection<Node> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   bool contains(Node element) => _Collections.contains(this, element);
 
   void forEach(void f(Node element)) => _Collections.forEach(this, f);
 
-  Collection mappedBy(f(Node element)) => _Collections.mappedBy(this, [], f);
+  Iterable mappedBy(f(Node element)) => new MappedIterable(this, f);
 
   Collection<Node> where(bool f(Node element)) =>
      _Collections.where(this, <Node>[], f);
 
   bool every(bool f(Node element)) => _Collections.every(this, f);
 
   bool some(bool f(Node element)) => _Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
@@ skipping 1547 matching lines @@
   }
 
   void addAll(Collection<int> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   bool contains(int element) => _Collections.contains(this, element);
 
   void forEach(void f(int element)) => _Collections.forEach(this, f);
 
-  Collection mappedBy(f(int element)) => _Collections.mappedBy(this, [], f);
+  Iterable mappedBy(f(int element)) => new MappedIterable(this, f);
 
   Collection<int> where(bool f(int element)) =>
      _Collections.where(this, <int>[], f);
 
   bool every(bool f(int element)) => _Collections.every(this, f);
 
   bool some(bool f(int element)) => _Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
@@ skipping 88 matching lines @@
   }
 
   void addAll(Collection<int> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   bool contains(int element) => _Collections.contains(this, element);
 
   void forEach(void f(int element)) => _Collections.forEach(this, f);
 
-  Collection mappedBy(f(int element)) => _Collections.mappedBy(this, [], f);
+  Iterable mappedBy(f(int element)) => new MappedIterable(this, f);
 
   Collection<int> where(bool f(int element)) =>
      _Collections.where(this, <int>[], f);
 
   bool every(bool f(int element)) => _Collections.every(this, f);
 
   bool some(bool f(int element)) => _Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
@@ skipping 88 matching lines @@
   }
 
   void addAll(Collection<int> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   bool contains(int element) => _Collections.contains(this, element);
 
   void forEach(void f(int element)) => _Collections.forEach(this, f);
 
-  Collection mappedBy(f(int element)) => _Collections.mappedBy(this, [], f);
+  Iterable mappedBy(f(int element)) => new MappedIterable(this, f);
 
   Collection<int> where(bool f(int element)) =>
      _Collections.where(this, <int>[], f);
 
   bool every(bool f(int element)) => _Collections.every(this, f);
 
   bool some(bool f(int element)) => _Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
@@ skipping 2129 matching lines @@
   }
 
   void addAll(Collection<Node> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   bool contains(Node element) => _Collections.contains(this, element);
 
   void forEach(void f(Node element)) => _Collections.forEach(this, f);
 
-  Collection mappedBy(f(Node element)) => _Collections.mappedBy(this, [], f);
+  Iterable mappedBy(f(Node element)) => new MappedIterable(this, f);
 
   Collection<Node> where(bool f(Node element)) =>
      _Collections.where(this, <Node>[], f);
 
   bool every(bool f(Node element)) => _Collections.every(this, f);
 
   bool some(bool f(Node element)) => _Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
@@ skipping 214 matching lines @@
   }
 
   Iterator<Node> get iterator => _this.$dom_childNodes.iterator;
 
   // TODO(jacobr): We can implement these methods much more efficiently by
   // looking up the nodeList only once instead of once per iteration.
   bool contains(Node element) => _Collections.contains(this, element);
 
   void forEach(void f(Node element)) => _Collections.forEach(this, f);
 
-  Collection mappedBy(f(Node element)) => _Collections.mappedBy(this, [], f);
+  Iterable mappedBy(f(Node element)) => new MappedIterable(this, f);
 
   Collection<Node> where(bool f(Node element)) =>
      new _NodeListWrapper(_Collections.where(this, <Node>[], f));
 
   bool every(bool f(Node element)) => _Collections.every(this, f);
 
   bool some(bool f(Node element)) => _Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
@@ skipping 270 matching lines @@
   List _list;
 
   _ListWrapper(List this._list);
 
   Iterator<E> get iterator => _list.iterator;
 
   bool contains(E element) => _list.contains(element);
 
   void forEach(void f(E element)) => _list.forEach(f);
 
-  Collection mappedBy(f(E element)) => _list.mappedBy(f);
+  Iterable mappedBy(f(E element)) => new MappedIterable(this, f);
 
   List<E> where(bool f(E element)) => _list.where(f);
 
   bool every(bool f(E element)) => _list.every(f);
 
   bool some(bool f(E element)) => _list.some(f);
 
   bool get isEmpty => _list.isEmpty;
 
   int get length => _list.length;
@@ skipping 96 matching lines @@
   }
 
   void operator []=(int index, Node value) {
     _parent.$dom_replaceChild(value, this[index]);
   }
 
   bool contains(Node element) => _Collections.contains(this, element);
 
   void forEach(void f(Node element)) => _Collections.forEach(this, f);
 
-  Collection mappedBy(f(Node element)) => _Collections.mappedBy(this, [], f);
+  Iterable mappedBy(f(Node element)) => new MappedIterable(this, f);
 
   Collection<Node> where(bool f(Node element)) =>
      new _NodeListWrapper(_Collections.where(this, <Node>[], f));
 
   bool every(bool f(Node element)) => _Collections.every(this, f);
 
   bool some(bool f(Node element)) => _Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
@@ skipping 1652 matching lines @@
   }
 
   void addAll(Collection<Map> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   bool contains(Map element) => _Collections.contains(this, element);
 
   void forEach(void f(Map element)) => _Collections.forEach(this, f);
 
-  Collection mappedBy(f(Map element)) => _Collections.mappedBy(this, [], f);
+  Iterable mappedBy(f(Map element)) => new MappedIterable(this, f);
 
   Collection<Map> where(bool f(Map element)) =>
      _Collections.where(this, <Map>[], f);
 
   bool every(bool f(Map element)) => _Collections.every(this, f);
 
   bool some(bool f(Map element)) => _Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
@@ skipping 493 matching lines @@
   }
 
   void addAll(Collection<SourceBuffer> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   bool contains(SourceBuffer element) => _Collections.contains(this, element);
 
   void forEach(void f(SourceBuffer element)) => _Collections.forEach(this, f);
 
-  Collection mappedBy(f(SourceBuffer element)) => _Collections.mappedBy(this, [], f);
+  Iterable mappedBy(f(SourceBuffer element)) => new MappedIterable(this, f);
 
   Collection<SourceBuffer> where(bool f(SourceBuffer element)) =>
      _Collections.where(this, <SourceBuffer>[], f);
 
   bool every(bool f(SourceBuffer element)) => _Collections.every(this, f);
 
   bool some(bool f(SourceBuffer element)) => _Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
@@ skipping 132 matching lines @@
   }
 
   void addAll(Collection<SpeechGrammar> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   bool contains(SpeechGrammar element) => _Collections.contains(this, element);
 
   void forEach(void f(SpeechGrammar element)) => _Collections.forEach(this, f);
 
-  Collection mappedBy(f(SpeechGrammar element)) => _Collections.mappedBy(this, [], f);
+  Iterable mappedBy(f(SpeechGrammar element)) => new MappedIterable(this, f);
 
   Collection<SpeechGrammar> where(bool f(SpeechGrammar element)) =>
      _Collections.where(this, <SpeechGrammar>[], f);
 
   bool every(bool f(SpeechGrammar element)) => _Collections.every(this, f);
 
   bool some(bool f(SpeechGrammar element)) => _Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
@@ skipping 998 matching lines @@
   }
 
   void addAll(Collection<TextTrackCue> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   bool contains(TextTrackCue element) => _Collections.contains(this, element);
 
   void forEach(void f(TextTrackCue element)) => _Collections.forEach(this, f);
 
-  Collection mappedBy(f(TextTrackCue element)) => _Collections.mappedBy(this, [], f);
+  Iterable mappedBy(f(TextTrackCue element)) => new MappedIterable(this, f);
 
   Collection<TextTrackCue> where(bool f(TextTrackCue element)) =>
      _Collections.where(this, <TextTrackCue>[], f);
 
   bool every(bool f(TextTrackCue element)) => _Collections.every(this, f);
 
   bool some(bool f(TextTrackCue element)) => _Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
@@ skipping 85 matching lines @@
   }
 
   void addAll(Collection<TextTrack> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   bool contains(TextTrack element) => _Collections.contains(this, element);
 
   void forEach(void f(TextTrack element)) => _Collections.forEach(this, f);
 
-  Collection mappedBy(f(TextTrack element)) => _Collections.mappedBy(this, [], f);
+  Iterable mappedBy(f(TextTrack element)) => new MappedIterable(this, f);
 
   Collection<TextTrack> where(bool f(TextTrack element)) =>
      _Collections.where(this, <TextTrack>[], f);
 
   bool every(bool f(TextTrack element)) => _Collections.every(this, f);
 
   bool some(bool f(TextTrack element)) => _Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
@@ skipping 203 matching lines @@
   }
 
   void addAll(Collection<Touch> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   bool contains(Touch element) => _Collections.contains(this, element);
 
   void forEach(void f(Touch element)) => _Collections.forEach(this, f);
 
-  Collection mappedBy(f(Touch element)) => _Collections.mappedBy(this, [], f);
+  Iterable mappedBy(f(Touch element)) => new MappedIterable(this, f);
 
   Collection<Touch> where(bool f(Touch element)) =>
      _Collections.where(this, <Touch>[], f);
 
   bool every(bool f(Touch element)) => _Collections.every(this, f);
 
   bool some(bool f(Touch element)) => _Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
@@ skipping 253 matching lines @@
   }
 
   void addAll(Collection<int> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   bool contains(int element) => _Collections.contains(this, element);
 
   void forEach(void f(int element)) => _Collections.forEach(this, f);
 
-  Collection mappedBy(f(int element)) => _Collections.mappedBy(this, [], f);
+  Iterable mappedBy(f(int element)) => new MappedIterable(this, f);
 
   Collection<int> where(bool f(int element)) =>
      _Collections.where(this, <int>[], f);
 
   bool every(bool f(int element)) => _Collections.every(this, f);
 
   bool some(bool f(int element)) => _Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
@@ skipping 88 matching lines @@
   }
 
   void addAll(Collection<int> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   bool contains(int element) => _Collections.contains(this, element);
 
   void forEach(void f(int element)) => _Collections.forEach(this, f);
 
-  Collection mappedBy(f(int element)) => _Collections.mappedBy(this, [], f);
+  Iterable mappedBy(f(int element)) => new MappedIterable(this, f);
 
   Collection<int> where(bool f(int element)) =>
      _Collections.where(this, <int>[], f);
 
   bool every(bool f(int element)) => _Collections.every(this, f);
 
   bool some(bool f(int element)) => _Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
@@ skipping 88 matching lines @@
   }
 
   void addAll(Collection<int> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   bool contains(int element) => _Collections.contains(this, element);
 
   void forEach(void f(int element)) => _Collections.forEach(this, f);
 
-  Collection mappedBy(f(int element)) => _Collections.mappedBy(this, [], f);
+  Iterable mappedBy(f(int element)) => new MappedIterable(this, f);
 
   Collection<int> where(bool f(int element)) =>
      _Collections.where(this, <int>[], f);
 
   bool every(bool f(int element)) => _Collections.every(this, f);
 
   bool some(bool f(int element)) => _Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
@@ skipping 2165 matching lines @@
   }
 
   void addAll(Collection<CSSRule> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   bool contains(CSSRule element) => _Collections.contains(this, element);
 
   void forEach(void f(CSSRule element)) => _Collections.forEach(this, f);
 
-  Collection mappedBy(f(CSSRule element)) => _Collections.mappedBy(this, [], f);
+  Iterable mappedBy(f(CSSRule element)) => new MappedIterable(this, f);
 
   Collection<CSSRule> where(bool f(CSSRule element)) =>
      _Collections.where(this, <CSSRule>[], f);
 
   bool every(bool f(CSSRule element)) => _Collections.every(this, f);
 
   bool some(bool f(CSSRule element)) => _Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
@@ skipping 76 matching lines @@
   }
 
   void addAll(Collection<CSSValue> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   bool contains(CSSValue element) => _Collections.contains(this, element);
 
   void forEach(void f(CSSValue element)) => _Collections.forEach(this, f);
 
-  Collection mappedBy(f(CSSValue element)) => _Collections.mappedBy(this, [], f);
+  Iterable mappedBy(f(CSSValue element)) => new MappedIterable(this, f);
 
   Collection<CSSValue> where(bool f(CSSValue element)) =>
      _Collections.where(this, <CSSValue>[], f);
 
   bool every(bool f(CSSValue element)) => _Collections.every(this, f);
 
   bool some(bool f(CSSValue element)) => _Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
@@ skipping 76 matching lines @@
   }
 
   void addAll(Collection<ClientRect> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   bool contains(ClientRect element) => _Collections.contains(this, element);
 
   void forEach(void f(ClientRect element)) => _Collections.forEach(this, f);
 
-  Collection mappedBy(f(ClientRect element)) => _Collections.mappedBy(this, [], f);
+  Iterable mappedBy(f(ClientRect element)) => new MappedIterable(this, f);
 
   Collection<ClientRect> where(bool f(ClientRect element)) =>
      _Collections.where(this, <ClientRect>[], f);
 
   bool every(bool f(ClientRect element)) => _Collections.every(this, f);
 
   bool some(bool f(ClientRect element)) => _Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
@@ skipping 85 matching lines @@
   }
 
   void addAll(Collection<String> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   // contains() defined by IDL.
 
   void forEach(void f(String element)) => _Collections.forEach(this, f);
 
-  Collection mappedBy(f(String element)) => _Collections.mappedBy(this, [], f);
+  Iterable mappedBy(f(String element)) => new MappedIterable(this, f);
 
   Collection<String> where(bool f(String element)) =>
      _Collections.where(this, <String>[], f);
 
   bool every(bool f(String element)) => _Collections.every(this, f);
 
   bool some(bool f(String element)) => _Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
@@ skipping 401 matching lines @@
   }
 
   void addAll(Collection<Entry> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   bool contains(Entry element) => _Collections.contains(this, element);
 
   void forEach(void f(Entry element)) => _Collections.forEach(this, f);
 
-  Collection mappedBy(f(Entry element)) => _Collections.mappedBy(this, [], f);
+  Iterable mappedBy(f(Entry element)) => new MappedIterable(this, f);
 
   Collection<Entry> where(bool f(Entry element)) =>
      _Collections.where(this, <Entry>[], f);
 
   bool every(bool f(Entry element)) => _Collections.every(this, f);
 
   bool some(bool f(Entry element)) => _Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
@@ skipping 76 matching lines @@
   }
 
   void addAll(Collection<EntrySync> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   bool contains(EntrySync element) => _Collections.contains(this, element);
 
   void forEach(void f(EntrySync element)) => _Collections.forEach(this, f);
 
-  Collection mappedBy(f(EntrySync element)) => _Collections.mappedBy(this, [], f);
+  Iterable mappedBy(f(EntrySync element)) => new MappedIterable(this, f);
 
   Collection<EntrySync> where(bool f(EntrySync element)) =>
      _Collections.where(this, <EntrySync>[], f);
 
   bool every(bool f(EntrySync element)) => _Collections.every(this, f);
 
   bool some(bool f(EntrySync element)) => _Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
@@ skipping 85 matching lines @@
   }
 
   void addAll(Collection<File> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   bool contains(File element) => _Collections.contains(this, element);
 
   void forEach(void f(File element)) => _Collections.forEach(this, f);
 
-  Collection mappedBy(f(File element)) => _Collections.mappedBy(this, [], f);
+  Iterable mappedBy(f(File element)) => new MappedIterable(this, f);
 
   Collection<File> where(bool f(File element)) =>
      _Collections.where(this, <File>[], f);
 
   bool every(bool f(File element)) => _Collections.every(this, f);
 
   bool some(bool f(File element)) => _Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
@@ skipping 105 matching lines @@
   }
 
   void addAll(Collection<Gamepad> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   bool contains(Gamepad element) => _Collections.contains(this, element);
 
   void forEach(void f(Gamepad element)) => _Collections.forEach(this, f);
 
-  Collection mappedBy(f(Gamepad element)) => _Collections.mappedBy(this, [], f);
+  Iterable mappedBy(f(Gamepad element)) => new MappedIterable(this, f);
 
   Collection<Gamepad> where(bool f(Gamepad element)) =>
      _Collections.where(this, <Gamepad>[], f);
 
   bool every(bool f(Gamepad element)) => _Collections.every(this, f);
 
   bool some(bool f(Gamepad element)) => _Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
@@ skipping 129 matching lines @@
   }
 
   void addAll(Collection<MediaStream> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   bool contains(MediaStream element) => _Collections.contains(this, element);
 
   void forEach(void f(MediaStream element)) => _Collections.forEach(this, f);
 
-  Collection mappedBy(f(MediaStream element)) => _Collections.mappedBy(this, [], f);
+  Iterable mappedBy(f(MediaStream element)) => new MappedIterable(this, f);
 
   Collection<MediaStream> where(bool f(MediaStream element)) =>
      _Collections.where(this, <MediaStream>[], f);
 
   bool every(bool f(MediaStream element)) => _Collections.every(this, f);
 
   bool some(bool f(MediaStream element)) => _Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
@@ skipping 239 matching lines @@
   }
 
   void addAll(Collection<SpeechInputResult> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   bool contains(SpeechInputResult element) => _Collections.contains(this, element);
 
   void forEach(void f(SpeechInputResult element)) => _Collections.forEach(this, f);
 
-  Collection mappedBy(f(SpeechInputResult element)) => _Collections.mappedBy(this, [], f);
+  Iterable mappedBy(f(SpeechInputResult element)) => new MappedIterable(this, f);
 
   Collection<SpeechInputResult> where(bool f(SpeechInputResult element)) =>
      _Collections.where(this, <SpeechInputResult>[], f);
 
   bool every(bool f(SpeechInputResult element)) => _Collections.every(this, f);
 
   bool some(bool f(SpeechInputResult element)) => _Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
@@ skipping 85 matching lines @@
   }
 
   void addAll(Collection<SpeechRecognitionResult> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   bool contains(SpeechRecognitionResult element) => _Collections.contains(this, element);
 
   void forEach(void f(SpeechRecognitionResult element)) => _Collections.forEach(this, f);
 
-  Collection mappedBy(f(SpeechRecognitionResult element)) => _Collections.mappedBy(this, [], f);
+  Iterable mappedBy(f(SpeechRecognitionResult element)) => new MappedIterable(this, f);
 
   Collection<SpeechRecognitionResult> where(bool f(SpeechRecognitionResult element)) =>
      _Collections.where(this, <SpeechRecognitionResult>[], f);
 
   bool every(bool f(SpeechRecognitionResult element)) => _Collections.every(this, f);
 
   bool some(bool f(SpeechRecognitionResult element)) => _Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
@@ skipping 76 matching lines @@
   }
 
   void addAll(Collection<StyleSheet> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   bool contains(StyleSheet element) => _Collections.contains(this, element);
 
   void forEach(void f(StyleSheet element)) => _Collections.forEach(this, f);
 
-  Collection mappedBy(f(StyleSheet element)) => _Collections.mappedBy(this, [], f);
+  Iterable mappedBy(f(StyleSheet element)) => new MappedIterable(this, f);
 
   Collection<StyleSheet> where(bool f(StyleSheet element)) =>
      _Collections.where(this, <StyleSheet>[], f);
 
   bool every(bool f(StyleSheet element)) => _Collections.every(this, f);
 
   bool some(bool f(StyleSheet element)) => _Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
@@ skipping 100 matching lines @@
   }
 
   void addAll(Collection<Animation> collection) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   bool contains(Animation element) => _Collections.contains(this, element);
 
   void forEach(void f(Animation element)) => _Collections.forEach(this, f);
 
-  Collection mappedBy(f(Animation element)) => _Collections.mappedBy(this, [], f);
+  Iterable mappedBy(f(Animation element)) => new MappedIterable(this, f);
 
   Collection<Animation> where(bool f(Animation element)) =>
      _Collections.where(this, <Animation>[], f);
 
   bool every(bool f(Animation element)) => _Collections.every(this, f);
 
   bool some(bool f(Animation element)) => _Collections.some(this, f);
 
   bool get isEmpty => this.length == 0;
 
@@ skipping 139 matching lines @@
 
   // interface Iterable - BEGIN
   Iterator<String> iterator() => readClasses().iterator();
   // interface Iterable - END
 
   // interface Collection - BEGIN
   void forEach(void f(String element)) {
     readClasses().forEach(f);
   }
 
-  Collection mappedBy(f(String element)) => readClasses().mappedBy(f);
+  Iterable mappedBy(f(String element)) => readClasses().mappedBy(f);
 
   Collection<String> where(bool f(String element)) => readClasses().where(f);
 
   bool every(bool f(String element)) => readClasses().every(f);
 
   bool some(bool f(String element)) => readClasses().some(f);
 
   bool get isEmpty => readClasses().isEmpty;
 
   int get length =>readClasses().length;
@@ skipping 184 matching lines @@
   }
 
   Element removeLast() {
     final result = this.last;
     if (result != null) {
       result.remove();
     }
     return result;
   }
 
-  Collection mappedBy(f(Element element)) => _filtered.mappedBy(f);
+  Iterable mappedBy(f(Element element)) => _filtered.mappedBy(f);
   Collection<Element> where(bool f(Element element)) => _filtered.where(f);
   bool every(bool f(Element element)) => _filtered.every(f);
   bool some(bool f(Element element)) => _filtered.some(f);
   bool get isEmpty => _filtered.isEmpty;
   int get length => _filtered.length;
   Element operator [](int index) => _filtered[index];
   Iterator<Element> iterator() => _filtered.iterator();
   List<Element> getRange(int start, int rangeLength) =>
     _filtered.getRange(start, rangeLength);
   int indexOf(Element element, [int start = 0]) =>
@@ skipping 814 matching lines @@
     }
     return false;
   }
 
   static void forEach(Iterable<Object> iterable, void f(Object o)) {
     for (final e in iterable) {
       f(e);
     }
   }
 
-  static List mappedBy(Iterable<Object> source,
-                  List<Object> destination,
-                  f(o)) {
-    for (final e in source) {
-      destination.add(f(e));
-    }
-    return destination;
+  static Iterable mappedBy(Iterable<Object> source, f(o)) {
+    return new MappedIterable(source, f);
   }
 
   static bool some(Iterable<Object> iterable, bool f(Object o)) {
     for (final e in iterable) {
       if (f(e)) return true;
     }
     return false;
   }
 
   static bool every(Iterable<Object> iterable, bool f(Object o)) {
@@ skipping 1696 matching lines @@
     if (length < 0) throw new ArgumentError('length');
     if (start < 0) throw new RangeError.value(start);
     int end = start + length;
     if (end > a.length) throw new RangeError.value(end);
     for (int i = start; i < end; i++) {
       accumulator.add(a[i]);
     }
     return accumulator;
   }
 }