Make 'where' lazy.

sdk/lib/html/dart2js/html_dart2js.dart

 library html;
 
 import 'dart:async';
 import 'dart:isolate';
 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.
 
@@ skipping 5320 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);
 
   Iterable mappedBy(f(DOMMimeType element)) => new MappedIterable(this, f);
 
-  Collection<DOMMimeType> where(bool f(DOMMimeType element)) =>
-     _Collections.where(this, <DOMMimeType>[], f);
+  Iterable<DOMMimeType> where(bool f(DOMMimeType element)) => new FilteredIterable<DOMMimeType>(this, 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;
 
   // From List<DOMMimeType>:
 
   void sort([Comparator<DOMMimeType> compare = Comparable.compare]) {
@@ skipping 117 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);
 
   Iterable mappedBy(f(DOMPlugin element)) => new MappedIterable(this, f);
 
-  Collection<DOMPlugin> where(bool f(DOMPlugin element)) =>
-     _Collections.where(this, <DOMPlugin>[], f);
+  Iterable<DOMPlugin> where(bool f(DOMPlugin element)) => new FilteredIterable<DOMPlugin>(this, 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;
 
   // From List<DOMPlugin>:
 
   void sort([Comparator<DOMPlugin> compare = Comparable.compare]) {
@@ skipping 1239 matching lines @@
   }
 
   bool contains(Element element) => _childElements.contains(element);
 
   void forEach(void f(Element element)) {
     for (Element element in _childElements) {
       f(element);
     }
   }
 
-  List<Element> where(bool f(Element element)) {
-    final output = [];
-    forEach((Element element) {
-      if (f(element)) {
-        output.add(element);
-      }
-    });
-    return new _FrozenElementList._wrap(output);
-  }
+  Iterable<Element> where(bool f(Element element))
+      => new FilteredIterable<Element>(this, f);
 
   bool every(bool f(Element element)) {
     for (Element element in this) {
       if (!f(element)) {
         return false;
       }
     };
     return true;
   }
 
@@ skipping 112 matching lines @@
   }
 
   void forEach(void f(Element element)) {
     for (Element el in this) {
       f(el);
     }
   }
 
   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;
-  }
+  Iterable<Element> where(bool f(Element element))
+      => new FilteredIterable<Element>(this, f);
 
   bool every(bool f(Element element)) {
     for(Element element in this) {
       if (!f(element)) {
         return false;
       }
     };
     return true;
   }
 
@@ skipping 1712 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);
 
   Iterable mappedBy(f(num element)) => new MappedIterable(this, f);
 
-  Collection<num> where(bool f(num element)) =>
-     _Collections.where(this, <num>[], f);
+  Iterable<num> where(bool f(num element)) => new FilteredIterable<num>(this, 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;
 
   // From List<num>:
 
   void sort([Comparator<num> compare = Comparable.compare]) {
@@ skipping 87 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);
 
   Iterable mappedBy(f(num element)) => new MappedIterable(this, f);
 
-  Collection<num> where(bool f(num element)) =>
-     _Collections.where(this, <num>[], f);
+  Iterable<num> where(bool f(num element)) => new FilteredIterable<num>(this, 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;
 
   // From List<num>:
 
   void sort([Comparator<num> compare = Comparable.compare]) {
@@ skipping 344 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);
 
   Iterable mappedBy(f(Node element)) => new MappedIterable(this, f);
 
-  Collection<Node> where(bool f(Node element)) =>
-     _Collections.where(this, <Node>[], f);
+  Iterable<Node> where(bool f(Node element)) => new FilteredIterable<Node>(this, 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;
 
   // From List<Node>:
 
   void sort([Comparator<Node> compare = Comparable.compare]) {
@@ skipping 81 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);
 
   Iterable mappedBy(f(Node element)) => new MappedIterable(this, f);
 
-  Collection<Node> where(bool f(Node element)) =>
-     _Collections.where(this, <Node>[], f);
+  Iterable<Node> where(bool f(Node element)) => new FilteredIterable<Node>(this, 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;
 
   // From List<Node>:
 
   void sort([Comparator<Node> compare = Comparable.compare]) {
@@ skipping 1546 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);
 
   Iterable mappedBy(f(int element)) => new MappedIterable(this, f);
 
-  Collection<int> where(bool f(int element)) =>
-     _Collections.where(this, <int>[], f);
+  Iterable<int> where(bool f(int element)) => new FilteredIterable<int>(this, 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;
 
   // From List<int>:
 
   void sort([Comparator<int> compare = Comparable.compare]) {
@@ skipping 87 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);
 
   Iterable mappedBy(f(int element)) => new MappedIterable(this, f);
 
-  Collection<int> where(bool f(int element)) =>
-     _Collections.where(this, <int>[], f);
+  Iterable<int> where(bool f(int element)) => new FilteredIterable<int>(this, 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;
 
   // From List<int>:
 
   void sort([Comparator<int> compare = Comparable.compare]) {
@@ skipping 87 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);
 
   Iterable mappedBy(f(int element)) => new MappedIterable(this, f);
 
-  Collection<int> where(bool f(int element)) =>
-     _Collections.where(this, <int>[], f);
+  Iterable<int> where(bool f(int element)) => new FilteredIterable<int>(this, 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;
 
   // From List<int>:
 
   void sort([Comparator<int> compare = Comparable.compare]) {
@@ skipping 2128 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);
 
   Iterable mappedBy(f(Node element)) => new MappedIterable(this, f);
 
-  Collection<Node> where(bool f(Node element)) =>
-     _Collections.where(this, <Node>[], f);
+  Iterable<Node> where(bool f(Node element)) => new FilteredIterable<Node>(this, 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;
 
   // From List<Node>:
 
   void sort([Comparator<Node> compare = Comparable.compare]) {
@@ skipping 213 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);
 
   Iterable mappedBy(f(Node element)) => new MappedIterable(this, f);
 
-  Collection<Node> where(bool f(Node element)) =>
-     new _NodeListWrapper(_Collections.where(this, <Node>[], f));
+  Iterable<Node> where(bool f(Node element)) =>
+     new FilteredIterable<Node>(this, 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;
 
   // From List<Node>:
 
   // TODO(jacobr): this could be implemented for child node lists.
@@ skipping 269 matching lines @@
   _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);
 
   Iterable mappedBy(f(E element)) => new MappedIterable(this, f);
 
-  List<E> where(bool f(E element)) => _list.where(f);
+  Iterable<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;
 
   E operator [](int index) => _list[index];
@@ skipping 36 matching lines @@
   E get first => _list[0];
 }
 
 /**
  * This class is used to insure the results of list operations are NodeLists
  * instead of lists.
  */
 class _NodeListWrapper extends _ListWrapper<Node> implements List {
   _NodeListWrapper(List list) : super(list);
 
-  List<Node> where(bool f(Node element)) =>
-    new _NodeListWrapper(_list.where(f));
+  Iterable<Node> where(bool f(Node element)) => new FilteredIterable(this, f);
 
   List<Node> getRange(int start, int rangeLength) =>
     new _NodeListWrapper(_list.getRange(start, rangeLength));
 }
 
 class NodeList implements JavaScriptIndexingBehavior, List<Node> native "*NodeList" {
   Node _parent;
 
   // -- start List<Node> mixins.
   // Node is the element type.
@@ skipping 38 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);
 
   Iterable mappedBy(f(Node element)) => new MappedIterable(this, f);
 
-  Collection<Node> where(bool f(Node element)) =>
-     new _NodeListWrapper(_Collections.where(this, <Node>[], f));
+  Iterable<Node> where(bool f(Node element)) => new FilteredIterable(this, 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;
 
   // From List<Node>:
 
   void sort([Comparator<Node> compare = Comparable.compare]) {
@@ skipping 1651 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);
 
   Iterable mappedBy(f(Map element)) => new MappedIterable(this, f);
 
-  Collection<Map> where(bool f(Map element)) =>
-     _Collections.where(this, <Map>[], f);
+  Iterable<Map> where(bool f(Map element)) => new FilteredIterable<Map>(this, 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;
 
   // From List<Map>:
 
   void sort([Comparator<Map> compare = Comparable.compare]) {
@@ skipping 303 matching lines @@
   /** @domName HTMLSelectElement.namedItem */
   Node namedItem(String name) native;
 
   /** @domName HTMLSelectElement.setCustomValidity */
   void setCustomValidity(String error) native;
 
 
   // Override default options, since IE returns SelectElement itself and it
   // does not operate as a List.
   List<OptionElement> get options {
-    return this.elements.where((e) => e is OptionElement);
+    return this.elements.where((e) => e is OptionElement).toList();
   }
 
   List<OptionElement> get selectedOptions {
     // IE does not change the selected flag for single-selection items.
     if (this.multiple) {
-      return this.options.where((o) => o.selected);
+      return this.options.where((o) => o.selected).toList();
     } else {
       return [this.options[this.selectedIndex]];
     }
   }
 }
 // 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.
 
 
@@ skipping 162 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);
 
   Iterable mappedBy(f(SourceBuffer element)) => new MappedIterable(this, f);
 
-  Collection<SourceBuffer> where(bool f(SourceBuffer element)) =>
-     _Collections.where(this, <SourceBuffer>[], f);
+  Iterable<SourceBuffer> where(bool f(SourceBuffer element)) => new FilteredIterable<SourceBuffer>(this, 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;
 
   // From List<SourceBuffer>:
 
   void sort([Comparator<SourceBuffer> compare = Comparable.compare]) {
@@ skipping 131 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);
 
   Iterable mappedBy(f(SpeechGrammar element)) => new MappedIterable(this, f);
 
-  Collection<SpeechGrammar> where(bool f(SpeechGrammar element)) =>
-     _Collections.where(this, <SpeechGrammar>[], f);
+  Iterable<SpeechGrammar> where(bool f(SpeechGrammar element)) => new FilteredIterable<SpeechGrammar>(this, 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;
 
   // From List<SpeechGrammar>:
 
   void sort([Comparator<SpeechGrammar> compare = Comparable.compare]) {
@@ skipping 997 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);
 
   Iterable mappedBy(f(TextTrackCue element)) => new MappedIterable(this, f);
 
-  Collection<TextTrackCue> where(bool f(TextTrackCue element)) =>
-     _Collections.where(this, <TextTrackCue>[], f);
+  Iterable<TextTrackCue> where(bool f(TextTrackCue element)) => new FilteredIterable<TextTrackCue>(this, 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;
 
   // From List<TextTrackCue>:
 
   void sort([Comparator<TextTrackCue> compare = Comparable.compare]) {
@@ skipping 84 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);
 
   Iterable mappedBy(f(TextTrack element)) => new MappedIterable(this, f);
 
-  Collection<TextTrack> where(bool f(TextTrack element)) =>
-     _Collections.where(this, <TextTrack>[], f);
+  Iterable<TextTrack> where(bool f(TextTrack element)) => new FilteredIterable<TextTrack>(this, 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;
 
   // From List<TextTrack>:
 
   void sort([Comparator<TextTrack> compare = Comparable.compare]) {
@@ skipping 202 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);
 
   Iterable mappedBy(f(Touch element)) => new MappedIterable(this, f);
 
-  Collection<Touch> where(bool f(Touch element)) =>
-     _Collections.where(this, <Touch>[], f);
+  Iterable<Touch> where(bool f(Touch element)) => new FilteredIterable<Touch>(this, 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;
 
   // From List<Touch>:
 
   void sort([Comparator<Touch> compare = Comparable.compare]) {
@@ skipping 252 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);
 
   Iterable mappedBy(f(int element)) => new MappedIterable(this, f);
 
-  Collection<int> where(bool f(int element)) =>
-     _Collections.where(this, <int>[], f);
+  Iterable<int> where(bool f(int element)) => new FilteredIterable<int>(this, 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;
 
   // From List<int>:
 
   void sort([Comparator<int> compare = Comparable.compare]) {
@@ skipping 87 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);
 
   Iterable mappedBy(f(int element)) => new MappedIterable(this, f);
 
-  Collection<int> where(bool f(int element)) =>
-     _Collections.where(this, <int>[], f);
+  Iterable<int> where(bool f(int element)) => new FilteredIterable<int>(this, 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;
 
   // From List<int>:
 
   void sort([Comparator<int> compare = Comparable.compare]) {
@@ skipping 87 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);
 
   Iterable mappedBy(f(int element)) => new MappedIterable(this, f);
 
-  Collection<int> where(bool f(int element)) =>
-     _Collections.where(this, <int>[], f);
+  Iterable<int> where(bool f(int element)) => new FilteredIterable<int>(this, 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;
 
   // From List<int>:
 
   void sort([Comparator<int> compare = Comparable.compare]) {
@@ skipping 2164 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);
 
   Iterable mappedBy(f(CSSRule element)) => new MappedIterable(this, f);
 
-  Collection<CSSRule> where(bool f(CSSRule element)) =>
-     _Collections.where(this, <CSSRule>[], f);
+  Iterable<CSSRule> where(bool f(CSSRule element)) => new FilteredIterable<CSSRule>(this, 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;
 
   // From List<CSSRule>:
 
   void sort([Comparator<CSSRule> compare = Comparable.compare]) {
@@ skipping 75 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);
 
   Iterable mappedBy(f(CSSValue element)) => new MappedIterable(this, f);
 
-  Collection<CSSValue> where(bool f(CSSValue element)) =>
-     _Collections.where(this, <CSSValue>[], f);
+  Iterable<CSSValue> where(bool f(CSSValue element)) => new FilteredIterable<CSSValue>(this, 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;
 
   // From List<CSSValue>:
 
   void sort([Comparator<CSSValue> compare = Comparable.compare]) {
@@ skipping 75 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);
 
   Iterable mappedBy(f(ClientRect element)) => new MappedIterable(this, f);
 
-  Collection<ClientRect> where(bool f(ClientRect element)) =>
-     _Collections.where(this, <ClientRect>[], f);
+  Iterable<ClientRect> where(bool f(ClientRect element)) => new FilteredIterable<ClientRect>(this, 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;
 
   // From List<ClientRect>:
 
   void sort([Comparator<ClientRect> compare = Comparable.compare]) {
@@ skipping 84 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);
 
   Iterable mappedBy(f(String element)) => new MappedIterable(this, f);
 
-  Collection<String> where(bool f(String element)) =>
-     _Collections.where(this, <String>[], f);
+  Iterable<String> where(bool f(String element)) => new FilteredIterable<String>(this, 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;
 
   // From List<String>:
 
   void sort([Comparator<String> compare = Comparable.compare]) {
@@ skipping 400 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);
 
   Iterable mappedBy(f(Entry element)) => new MappedIterable(this, f);
 
-  Collection<Entry> where(bool f(Entry element)) =>
-     _Collections.where(this, <Entry>[], f);
+  Iterable<Entry> where(bool f(Entry element)) => new FilteredIterable<Entry>(this, 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;
 
   // From List<Entry>:
 
   void sort([Comparator<Entry> compare = Comparable.compare]) {
@@ skipping 75 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);
 
   Iterable mappedBy(f(EntrySync element)) => new MappedIterable(this, f);
 
-  Collection<EntrySync> where(bool f(EntrySync element)) =>
-     _Collections.where(this, <EntrySync>[], f);
+  Iterable<EntrySync> where(bool f(EntrySync element)) => new FilteredIterable<EntrySync>(this, 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;
 
   // From List<EntrySync>:
 
   void sort([Comparator<EntrySync> compare = Comparable.compare]) {
@@ skipping 84 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);
 
   Iterable mappedBy(f(File element)) => new MappedIterable(this, f);
 
-  Collection<File> where(bool f(File element)) =>
-     _Collections.where(this, <File>[], f);
+  Iterable<File> where(bool f(File element)) => new FilteredIterable<File>(this, 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;
 
   // From List<File>:
 
   void sort([Comparator<File> compare = Comparable.compare]) {
@@ skipping 104 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);
 
   Iterable mappedBy(f(Gamepad element)) => new MappedIterable(this, f);
 
-  Collection<Gamepad> where(bool f(Gamepad element)) =>
-     _Collections.where(this, <Gamepad>[], f);
+  Iterable<Gamepad> where(bool f(Gamepad element)) => new FilteredIterable<Gamepad>(this, 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;
 
   // From List<Gamepad>:
 
   void sort([Comparator<Gamepad> compare = Comparable.compare]) {
@@ skipping 128 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);
 
   Iterable mappedBy(f(MediaStream element)) => new MappedIterable(this, f);
 
-  Collection<MediaStream> where(bool f(MediaStream element)) =>
-     _Collections.where(this, <MediaStream>[], f);
+  Iterable<MediaStream> where(bool f(MediaStream element)) => new FilteredIterable<MediaStream>(this, 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;
 
   // From List<MediaStream>:
 
   void sort([Comparator<MediaStream> compare = Comparable.compare]) {
@@ skipping 238 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);
 
   Iterable mappedBy(f(SpeechInputResult element)) => new MappedIterable(this, f);
 
-  Collection<SpeechInputResult> where(bool f(SpeechInputResult element)) =>
-     _Collections.where(this, <SpeechInputResult>[], f);
+  Iterable<SpeechInputResult> where(bool f(SpeechInputResult element)) => new FilteredIterable<SpeechInputResult>(this, 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;
 
   // From List<SpeechInputResult>:
 
   void sort([Comparator<SpeechInputResult> compare = Comparable.compare]) {
@@ skipping 84 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);
 
   Iterable mappedBy(f(SpeechRecognitionResult element)) => new MappedIterable(this, f);
 
-  Collection<SpeechRecognitionResult> where(bool f(SpeechRecognitionResult element)) =>
-     _Collections.where(this, <SpeechRecognitionResult>[], f);
+  Iterable<SpeechRecognitionResult> where(bool f(SpeechRecognitionResult element)) => new FilteredIterable<SpeechRecognitionResult>(this, 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;
 
   // From List<SpeechRecognitionResult>:
 
   void sort([Comparator<SpeechRecognitionResult> compare = Comparable.compare]) {
@@ skipping 75 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);
 
   Iterable mappedBy(f(StyleSheet element)) => new MappedIterable(this, f);
 
-  Collection<StyleSheet> where(bool f(StyleSheet element)) =>
-     _Collections.where(this, <StyleSheet>[], f);
+  Iterable<StyleSheet> where(bool f(StyleSheet element)) => new FilteredIterable<StyleSheet>(this, 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;
 
   // From List<StyleSheet>:
 
   void sort([Comparator<StyleSheet> compare = Comparable.compare]) {
@@ skipping 99 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);
 
   Iterable mappedBy(f(Animation element)) => new MappedIterable(this, f);
 
-  Collection<Animation> where(bool f(Animation element)) =>
-     _Collections.where(this, <Animation>[], f);
+  Iterable<Animation> where(bool f(Animation element)) => new FilteredIterable<Animation>(this, 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;
 
   // From List<Animation>:
 
   void sort([Comparator<Animation> compare = Comparable.compare]) {
@@ skipping 138 matching lines @@
   Iterator<String> iterator() => readClasses().iterator();
   // interface Iterable - END
 
   // interface Collection - BEGIN
   void forEach(void f(String element)) {
     readClasses().forEach(f);
   }
 
   Iterable mappedBy(f(String element)) => readClasses().mappedBy(f);
 
-  Collection<String> where(bool f(String element)) => readClasses().where(f);
+  Iterable<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;
   // interface Collection - END
 
@@ skipping 183 matching lines @@
 
   Element removeLast() {
     final result = this.last;
     if (result != null) {
       result.remove();
     }
     return result;
   }
 
   Iterable mappedBy(f(Element element)) => _filtered.mappedBy(f);
-  Collection<Element> where(bool f(Element element)) => _filtered.where(f);
+  Iterable<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]) =>
     _filtered.indexOf(element, start);
@@ skipping 813 matching lines @@
     }
     return false;
   }
 
   static void forEach(Iterable<Object> iterable, void f(Object o)) {
     for (final e in iterable) {
       f(e);
     }
   }
 
-  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)) {
     for (final e in iterable) {
       if (!f(e)) return false;
     }
     return true;
   }
 
-  static List where(Iterable<Object> source,
-                     List<Object> destination,
-                     bool f(o)) {
-    for (final e in source) {
-      if (f(e)) destination.add(e);
-    }
-    return destination;
-  }
-
   static bool isEmpty(Iterable<Object> iterable) {
     return !iterable.iterator.moveNext();
   }
 }
 // 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.
 
 
 class _HttpRequestUtils {
@@ skipping 1671 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;
   }
 }