Big merge from experimental to bleeding edge.

sdk/lib/html/dartium/html_dartium.dart

 library html;
 
+import 'dart:async';
 import 'dart:collection';
 import 'dart:html_common';
 import 'dart:indexed_db';
 import 'dart:isolate';
-import 'dart:json';
+import 'dart:json' as json;
 import 'dart:nativewrappers';
 import 'dart:svg' as svg;
 import 'dart:web_audio' as web_audio;
 // 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 29 matching lines @@
 List<Element> queryAll(String selector) => document.queryAll(selector);
 
 int _getNewIsolateId() => _Utils._getNewIsolateId();
 
 bool _callPortInitialized = false;
 var _callPortLastResult = null;
 
 _callPortSync(num id, var message) {
   if (!_callPortInitialized) {
     window.on['js-result'].add((event) {
-      _callPortLastResult = JSON.parse(_getPortSyncEventData(event));
+      _callPortLastResult = json.parse(_getPortSyncEventData(event));
     }, false);
     _callPortInitialized = true;
   }
   assert(_callPortLastResult == null);
   _dispatchEvent('js-sync-message', {'id': id, 'message': message});
   var result = _callPortLastResult;
   _callPortLastResult = null;
   return result;
 }
 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
@@ skipping 6988 matching lines @@
    *     var items = document.queryAll('.itemClassName');
    *
    * For details about CSS selector syntax, see the
    * [CSS selector specification](http://www.w3.org/TR/css3-selectors/).
    */
   List<Element> queryAll(String selectors) {
     if (new RegExp("""^\\[name=["'][^'"]+['"]\\]\$""").hasMatch(selectors)) {
       final mutableMatches = $dom_getElementsByName(
           selectors.substring(7,selectors.length - 2));
       int len = mutableMatches.length;
-      final copyOfMatches = new List<Element>(len);
+      final copyOfMatches = new List<Element>.fixedLength(len);
       for (int i = 0; i < len; ++i) {
         copyOfMatches[i] = mutableMatches[i];
       }
       return new _FrozenElementList._wrap(copyOfMatches);
     } else if (new RegExp("^[*a-zA-Z0-9]+\$").hasMatch(selectors)) {
       final mutableMatches = $dom_getElementsByTagName(selectors);
       int len = mutableMatches.length;
-      final copyOfMatches = new List<Element>(len);
+      final copyOfMatches = new List<Element>.fixedLength(len);
       for (int i = 0; i < len; ++i) {
         copyOfMatches[i] = mutableMatches[i];
       }
       return new _FrozenElementList._wrap(copyOfMatches);
     } else {
       return new _FrozenElementList._wrap($dom_querySelectorAll(selectors));
     }
   }
 }
 
@@ skipping 506 matching lines @@
   DomMimeType operator[](int index) native "DOMMimeTypeArray_item_Callback";
 
   void operator[]=(int index, DomMimeType value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<DomMimeType> mixins.
   // DomMimeType is the element type.
 
   // From Iterable<DomMimeType>:
 
-  Iterator<DomMimeType> iterator() {
+  Iterator<DomMimeType> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<DomMimeType>(this);
   }
 
-  // From Collection<DomMimeType>:
-
-  void add(DomMimeType value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addLast(DomMimeType value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addAll(Collection<DomMimeType> collection) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, DomMimeType)) {
     return Collections.reduce(this, initialValue, combine);
   }
 
   bool contains(DomMimeType element) => Collections.contains(this, element);
 
   void forEach(void f(DomMimeType element)) => Collections.forEach(this, f);
 
-  Collection map(f(DomMimeType element)) => Collections.map(this, [], f);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  Collection<DomMimeType> filter(bool f(DomMimeType element)) =>
-     Collections.filter(this, <DomMimeType>[], f);
+  List mappedBy(f(DomMimeType element)) => new MappedList<DomMimeType, dynamic>(this, f);
+
+  Iterable<DomMimeType> where(bool f(DomMimeType element)) => new WhereIterable<DomMimeType>(this, f);
 
   bool every(bool f(DomMimeType element)) => Collections.every(this, f);
 
-  bool some(bool f(DomMimeType element)) => Collections.some(this, f);
+  bool any(bool f(DomMimeType element)) => Collections.any(this, f);
 
   bool get isEmpty => this.length == 0;
 
+  List<DomMimeType> take(int n) => new ListView<DomMimeType>(this, 0, n);
+
+  Iterable<DomMimeType> takeWhile(bool test(DomMimeType value)) {
+    return new TakeWhileIterable<DomMimeType>(this, test);
+  }
+
+  List<DomMimeType> skip(int n) => new ListView<DomMimeType>(this, n, null);
+
+  Iterable<DomMimeType> skipWhile(bool test(DomMimeType value)) {
+    return new SkipWhileIterable<DomMimeType>(this, test);
+  }
+
+  DomMimeType firstMatching(bool test(DomMimeType value), { DomMimeType orElse() }) {
+    return Collections.firstMatching(this, test, orElse);
+  }
+
+  DomMimeType lastMatching(bool test(DomMimeType value), {DomMimeType orElse()}) {
+    return Collections.lastMatchingInList(this, test, orElse);
+  }
+
+  DomMimeType singleMatching(bool test(DomMimeType value)) {
+    return Collections.singleMatching(this, test);
+  }
+
+  DomMimeType elementAt(int index) {
+    return this[index];
+  }
+
+  // From Collection<DomMimeType>:
+
+  void add(DomMimeType value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addLast(DomMimeType value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addAll(Iterable<DomMimeType> iterable) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   // From List<DomMimeType>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
   void sort([int compare(DomMimeType a, DomMimeType b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(DomMimeType element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(DomMimeType element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
 
-  DomMimeType get first => this[0];
+  DomMimeType get first {
+    if (this.length > 0) return this[0];
+    throw new StateError("No elements");
+  }
 
-  DomMimeType get last => this[length - 1];
+  DomMimeType get last {
+    if (this.length > 0) return this[this.length - 1];
+    throw new StateError("No elements");
+  }
+
+  DomMimeType get single {
+    if (length == 1) return this[0];
+    if (length == 0) throw new StateError("No elements");
+    throw new StateError("More than one element");
+  }
+
+  DomMimeType min([int compare(DomMimeType a, DomMimeType b)]) => _Collections.minInList(this, compare);
+
+  DomMimeType max([int compare(DomMimeType a, DomMimeType b)]) => _Collections.maxInList(this, compare);
 
   DomMimeType removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   DomMimeType removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<DomMimeType> from, [int startFrom]) {
@@ skipping 96 matching lines @@
   DomPlugin operator[](int index) native "DOMPluginArray_item_Callback";
 
   void operator[]=(int index, DomPlugin value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<DomPlugin> mixins.
   // DomPlugin is the element type.
 
   // From Iterable<DomPlugin>:
 
-  Iterator<DomPlugin> iterator() {
+  Iterator<DomPlugin> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<DomPlugin>(this);
   }
 
-  // From Collection<DomPlugin>:
-
-  void add(DomPlugin value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addLast(DomPlugin value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addAll(Collection<DomPlugin> collection) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, DomPlugin)) {
     return Collections.reduce(this, initialValue, combine);
   }
 
   bool contains(DomPlugin element) => Collections.contains(this, element);
 
   void forEach(void f(DomPlugin element)) => Collections.forEach(this, f);
 
-  Collection map(f(DomPlugin element)) => Collections.map(this, [], f);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  Collection<DomPlugin> filter(bool f(DomPlugin element)) =>
-     Collections.filter(this, <DomPlugin>[], f);
+  List mappedBy(f(DomPlugin element)) => new MappedList<DomPlugin, dynamic>(this, f);
+
+  Iterable<DomPlugin> where(bool f(DomPlugin element)) => new WhereIterable<DomPlugin>(this, f);
 
   bool every(bool f(DomPlugin element)) => Collections.every(this, f);
 
-  bool some(bool f(DomPlugin element)) => Collections.some(this, f);
+  bool any(bool f(DomPlugin element)) => Collections.any(this, f);
 
   bool get isEmpty => this.length == 0;
 
+  List<DomPlugin> take(int n) => new ListView<DomPlugin>(this, 0, n);
+
+  Iterable<DomPlugin> takeWhile(bool test(DomPlugin value)) {
+    return new TakeWhileIterable<DomPlugin>(this, test);
+  }
+
+  List<DomPlugin> skip(int n) => new ListView<DomPlugin>(this, n, null);
+
+  Iterable<DomPlugin> skipWhile(bool test(DomPlugin value)) {
+    return new SkipWhileIterable<DomPlugin>(this, test);
+  }
+
+  DomPlugin firstMatching(bool test(DomPlugin value), { DomPlugin orElse() }) {
+    return Collections.firstMatching(this, test, orElse);
+  }
+
+  DomPlugin lastMatching(bool test(DomPlugin value), {DomPlugin orElse()}) {
+    return Collections.lastMatchingInList(this, test, orElse);
+  }
+
+  DomPlugin singleMatching(bool test(DomPlugin value)) {
+    return Collections.singleMatching(this, test);
+  }
+
+  DomPlugin elementAt(int index) {
+    return this[index];
+  }
+
+  // From Collection<DomPlugin>:
+
+  void add(DomPlugin value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addLast(DomPlugin value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addAll(Iterable<DomPlugin> iterable) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   // From List<DomPlugin>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
   void sort([int compare(DomPlugin a, DomPlugin b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(DomPlugin element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(DomPlugin element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
 
-  DomPlugin get first => this[0];
+  DomPlugin get first {
+    if (this.length > 0) return this[0];
+    throw new StateError("No elements");
+  }
 
-  DomPlugin get last => this[length - 1];
+  DomPlugin get last {
+    if (this.length > 0) return this[this.length - 1];
+    throw new StateError("No elements");
+  }
+
+  DomPlugin get single {
+    if (length == 1) return this[0];
+    if (length == 0) throw new StateError("No elements");
+    throw new StateError("More than one element");
+  }
+
+  DomPlugin min([int compare(DomPlugin a, DomPlugin b)]) => _Collections.minInList(this, compare);
+
+  DomPlugin max([int compare(DomPlugin a, DomPlugin b)]) => _Collections.maxInList(this, compare);
 
   DomPlugin removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   DomPlugin removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<DomPlugin> from, [int startFrom]) {
@@ skipping 180 matching lines @@
   String operator[](int index) native "DOMStringList_item_Callback";
 
   void operator[]=(int index, String value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<String> mixins.
   // String is the element type.
 
   // From Iterable<String>:
 
-  Iterator<String> iterator() {
+  Iterator<String> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<String>(this);
   }
 
-  // From Collection<String>:
-
-  void add(String value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addLast(String value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addAll(Collection<String> collection) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, String)) {
     return Collections.reduce(this, initialValue, combine);
   }
 
   // contains() defined by IDL.
 
   void forEach(void f(String element)) => Collections.forEach(this, f);
 
-  Collection map(f(String element)) => Collections.map(this, [], f);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  Collection<String> filter(bool f(String element)) =>
-     Collections.filter(this, <String>[], f);
+  List mappedBy(f(String element)) => new MappedList<String, dynamic>(this, f);
+
+  Iterable<String> where(bool f(String element)) => new WhereIterable<String>(this, f);
 
   bool every(bool f(String element)) => Collections.every(this, f);
 
-  bool some(bool f(String element)) => Collections.some(this, f);
+  bool any(bool f(String element)) => Collections.any(this, f);
 
   bool get isEmpty => this.length == 0;
 
+  List<String> take(int n) => new ListView<String>(this, 0, n);
+
+  Iterable<String> takeWhile(bool test(String value)) {
+    return new TakeWhileIterable<String>(this, test);
+  }
+
+  List<String> skip(int n) => new ListView<String>(this, n, null);
+
+  Iterable<String> skipWhile(bool test(String value)) {
+    return new SkipWhileIterable<String>(this, test);
+  }
+
+  String firstMatching(bool test(String value), { String orElse() }) {
+    return Collections.firstMatching(this, test, orElse);
+  }
+
+  String lastMatching(bool test(String value), {String orElse()}) {
+    return Collections.lastMatchingInList(this, test, orElse);
+  }
+
+  String singleMatching(bool test(String value)) {
+    return Collections.singleMatching(this, test);
+  }
+
+  String elementAt(int index) {
+    return this[index];
+  }
+
+  // From Collection<String>:
+
+  void add(String value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addLast(String value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addAll(Iterable<String> iterable) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   // From List<String>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
   void sort([int compare(String a, String b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(String element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(String element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
 
-  String get first => this[0];
+  String get first {
+    if (this.length > 0) return this[0];
+    throw new StateError("No elements");
+  }
 
-  String get last => this[length - 1];
+  String get last {
+    if (this.length > 0) return this[this.length - 1];
+    throw new StateError("No elements");
+  }
+
+  String get single {
+    if (length == 1) return this[0];
+    if (length == 0) throw new StateError("No elements");
+    throw new StateError("More than one element");
+  }
+
+  String min([int compare(String a, String b)]) => _Collections.minInList(this, compare);
+
+  String max([int compare(String a, String b)]) => _Collections.maxInList(this, compare);
 
   String removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   String removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<String> from, [int startFrom]) {
@@ skipping 86 matching lines @@
 // functionality.
 class _ChildrenElementList implements List {
   // Raw Element.
   final Element _element;
   final HtmlCollection _childElements;
 
   _ChildrenElementList._wrap(Element element)
     : _childElements = element.$dom_children,
       _element = element;
 
-  List<Element> _toList() {
-    final output = new List(_childElements.length);
+  List<Element> toList() {
+    final output = new List<Element>.fixedLength(_childElements.length);
     for (int i = 0, len = _childElements.length; i < len; i++) {
       output[i] = _childElements[i];
     }
     return output;
   }
 
+  Set<Element> toSet() {
+    final output = new Set<Element>(_childElements.length);
+    for (int i = 0, len = _childElements.length; i < len; i++) {
+      output.add(_childElements[i]);
+    }
+    return output;
+  }
+
   bool contains(Element element) => _childElements.contains(element);
 
   void forEach(void f(Element element)) {
     for (Element element in _childElements) {
       f(element);
     }
   }
 
-  List<Element> filter(bool f(Element element)) {
-    final output = [];
-    forEach((Element element) {
-      if (f(element)) {
-        output.add(element);
-      }
-    });
-    return new _FrozenElementList._wrap(output);
-  }
-
   bool every(bool f(Element element)) {
     for (Element element in this) {
       if (!f(element)) {
         return false;
       }
-    };
+    }
     return true;
   }
 
-  bool some(bool f(Element element)) {
+  bool any(bool f(Element element)) {
     for (Element element in this) {
       if (f(element)) {
         return true;
       }
-    };
+    }
     return false;
   }
 
-  Collection map(f(Element element)) {
-    final out = [];
-    for (Element el in this) {
-      out.add(f(el));
-    }
-    return out;
+  String join([String separator]) {
+    return Collections.joinList(this, separator);
   }
 
+  List mappedBy(f(Element element)) {
+    return new MappedList<Element, dynamic>(this, f);
+  }
+
+  Iterable<Element> where(bool f(Element element))
+      => new WhereIterable<Element>(this, f);
+
   bool get isEmpty {
     return _element.$dom_firstElementChild == null;
   }
 
+  List<Element> take(int n) {
+    return new ListView<Element>(this, 0, n);
+  }
+
+  Iterable<Element> takeWhile(bool test(Element value)) {
+    return new TakeWhileIterable<Element>(this, test);
+  }
+
+  List<Element> skip(int n) {
+    return new ListView<Element>(this, n, null);
+  }
+
+  Iterable<Element> skipWhile(bool test(Element value)) {
+    return new SkipWhileIterable<Element>(this, test);
+  }
+
+  Element firstMatching(bool test(Element value), {Element orElse()}) {
+    return Collections.firstMatching(this, test, orElse);
+  }
+
+  Element lastMatching(bool test(Element value), {Element orElse()}) {
+    return Collections.lastMatchingInList(this, test, orElse);
+  }
+
+  Element singleMatching(bool test(Element value)) {
+    return Collections.singleMatching(this, test);
+  }
+
+  Element elementAt(int index) {
+    return this[index];
+  }
+
   int get length {
     return _childElements.length;
   }
 
   Element operator [](int index) {
     return _childElements[index];
   }
 
   void operator []=(int index, Element value) {
     _element.$dom_replaceChild(value, _childElements[index]);
   }
 
    void set length(int newLength) {
      // TODO(jacobr): remove children when length is reduced.
      throw new UnsupportedError('');
    }
 
   Element add(Element value) {
     _element.$dom_appendChild(value);
     return value;
   }
 
   Element addLast(Element value) => add(value);
 
-  Iterator<Element> iterator() => _toList().iterator();
+  Iterator<Element> get iterator => toList().iterator;
 
-  void addAll(Collection<Element> collection) {
-    for (Element element in collection) {
+  void addAll(Iterable<Element> iterable) {
+    for (Element element in iterable) {
       _element.$dom_appendChild(element);
     }
   }
 
   void sort([int compare(Element a, Element b)]) {
     throw new UnsupportedError('TODO(jacobr): should we impl?');
   }
 
   dynamic reduce(dynamic initialValue,
       dynamic combine(dynamic previousValue, Element element)) {
@@ skipping 40 matching lines @@
 
   Element removeLast() {
     final result = this.last;
     if (result != null) {
       _element.$dom_removeChild(result);
     }
     return result;
   }
 
   Element get first {
-    return _element.$dom_firstElementChild;
+    Element result = _element.$dom_firstElementChild;
+    if (result == null) throw new StateError("No elements");
+    return result;
   }
 
 
   Element get last {
-    return _element.$dom_lastElementChild;
+    Element result = _element.$dom_lastElementChild;
+    if (result == null) throw new StateError("No elements");
+    return result;
+  }
+
+  Element get single {
+    if (length > 1) throw new StateError("More than one element");
+    return first;
+  }
+
+  Element min([int compare(Element a, Element b)]) {
+    return _Collections.minInList(this, compare);
+  }
+
+  Element max([int compare(Element a, Element b)]) {
+    return _Collections.maxInList(this, compare);
   }
 }
 
 // TODO(jacobr): this is an inefficient implementation but it is hard to see
 // a better option given that we cannot quite force NodeList to be an
 // ElementList as there are valid cases where a NodeList JavaScript object
 // contains Node objects that are not Elements.
 class _FrozenElementList implements List {
   final List<Node> _nodeList;
 
   _FrozenElementList._wrap(this._nodeList);
 
   bool contains(Element element) {
     for (Element el in this) {
       if (el == element) return true;
     }
     return false;
   }
 
   void forEach(void f(Element element)) {
     for (Element el in this) {
       f(el);
     }
   }
 
-  Collection map(f(Element element)) {
-    final out = [];
-    for (Element el in this) {
-      out.add(f(el));
-    }
-    return out;
+  String join([String separator]) {
+    return Collections.joinList(this, separator);
   }
 
-  List<Element> filter(bool f(Element element)) {
-    final out = [];
-    for (Element el in this) {
-      if (f(el)) out.add(el);
-    }
-    return out;
+  List mappedBy(f(Element element)) {
+    return new MappedList<Element, dynamic>(this, f);
   }
 
+  Iterable<Element> where(bool f(Element element))
+      => new WhereIterable<Element>(this, f);
+
   bool every(bool f(Element element)) {
     for(Element element in this) {
       if (!f(element)) {
         return false;
       }
     };
     return true;
   }
 
-  bool some(bool f(Element element)) {
+  bool any(bool f(Element element)) {
     for(Element element in this) {
       if (f(element)) {
         return true;
       }
     };
     return false;
   }
 
+  List<Element> take(int n) {
+    return new ListView<Element>(this, 0, n);
+  }
+
+  Iterable<Element> takeWhile(bool test(T value)) {
+    return new TakeWhileIterable<Element>(this, test);
+  }
+
+  List<Element> skip(int n) {
+    return new ListView<Element>(this, n, null);
+  }
+
+  Iterable<Element> skipWhile(bool test(T value)) {
+    return new SkipWhileIterable<Element>(this, test);
+  }
+
+  Element firstMatching(bool test(Element value), {Element orElse()}) {
+    return Collections.firstMatching(this, test, orElse);
+  }
+
+  Element lastMatching(bool test(Element value), {Element orElse()}) {
+    return Collections.lastMatchingInList(this, test, orElse);
+  }
+
+  Element singleMatching(bool test(Element value)) {
+    return Collections.singleMatching(this, test);
+  }
+
+  Element elementAt(int index) {
+    return this[index];
+  }
+
   bool get isEmpty => _nodeList.isEmpty;
 
   int get length => _nodeList.length;
 
   Element operator [](int index) => _nodeList[index];
 
   void operator []=(int index, Element value) {
     throw new UnsupportedError('');
   }
 
   void set length(int newLength) {
     _nodeList.length = newLength;
   }
 
   void add(Element value) {
     throw new UnsupportedError('');
   }
 
   void addLast(Element value) {
     throw new UnsupportedError('');
   }
 
-  Iterator<Element> iterator() => new _FrozenElementListIterator(this);
+  Iterator<Element> get iterator => new _FrozenElementListIterator(this);
 
-  void addAll(Collection<Element> collection) {
+  void addAll(Iterable<Element> iterable) {
     throw new UnsupportedError('');
   }
 
   void sort([int compare(Element a, Element b)]) {
     throw new UnsupportedError('');
   }
 
   dynamic reduce(dynamic initialValue,
       dynamic combine(dynamic previousValue, Element element)) {
     return Collections.reduce(this, initialValue, combine);
@@ skipping 28 matching lines @@
     throw new UnsupportedError('');
   }
 
   Element removeLast() {
     throw new UnsupportedError('');
   }
 
   Element get first => _nodeList.first;
 
   Element get last => _nodeList.last;
+
+  Element get single => _nodeList.single;
+
+  Element min([int compare(Element a, Element b)]) {
+    return _Collections.minInList(this, compare);
+  }
+
+  Element max([int compare(Element a, Element b)]) {
+    return _Collections.maxInList(this, compare);
+  }
 }
 
 class _FrozenElementListIterator implements Iterator<Element> {
   final _FrozenElementList _list;
   int _index = 0;
 
   _FrozenElementListIterator(this._list);
 
   /**
-   * Gets the next element in the iteration. Throws a
-   * [StateError("No more elements")] if no element is left.
+   * Moves to the next element. Returns true if the iterator is positioned
+   * at an element. Returns false if it is positioned after the last element.
    */
-  Element next() {
-    if (!hasNext) {
-      throw new StateError("No more elements");
+  bool moveNext() {
+    int nextIndex = _index + 1;
+    if (nextIndex < _list.length) {
+      _current = _list[nextIndex];
+      _index = nextIndex;
+      return true;
     }
-
-    return _list[_index++];
+    _index = _list.length;
+    _current = null;
+    return false;
   }
 
   /**
-   * Returns whether the [Iterator] has elements left.
+   * Returns the element the [Iterator] is positioned at.
+   *
+   * Return [:null:] if the iterator is positioned before the first, or
+   * after the last element.
    */
-  bool get hasNext => _index < _list.length;
+  E get current => _current;
 }
 
 class _ElementCssClassSet extends CssClassSet {
 
   final Element _element;
 
   _ElementCssClassSet(this._element);
 
   Set<String> readClasses() {
     var s = new Set<String>();
     var classname = _element.$dom_className;
 
     for (String name in classname.split(' ')) {
       String trimmed = name.trim();
       if (!trimmed.isEmpty) {
         s.add(trimmed);
       }
     }
     return s;
   }
 
   void writeClasses(Set<String> s) {
     List list = new List.from(s);
-    _element.$dom_className = Strings.join(list, ' ');
+    _element.$dom_className = s.join(' ');
   }
 }
 
 /**
  * An abstract class, which all HTML elements extend.
  */
 abstract class Element extends Node implements ElementTraversal {
 
   /**
    * Creates an HTML element from a valid fragment of HTML.
@@ skipping 1646 matching lines @@
   File operator[](int index) native "FileList_item_Callback";
 
   void operator[]=(int index, File value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<File> mixins.
   // File is the element type.
 
   // From Iterable<File>:
 
-  Iterator<File> iterator() {
+  Iterator<File> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<File>(this);
   }
 
-  // From Collection<File>:
-
-  void add(File value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addLast(File value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addAll(Collection<File> collection) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, File)) {
     return Collections.reduce(this, initialValue, combine);
   }
 
   bool contains(File element) => Collections.contains(this, element);
 
   void forEach(void f(File element)) => Collections.forEach(this, f);
 
-  Collection map(f(File element)) => Collections.map(this, [], f);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  Collection<File> filter(bool f(File element)) =>
-     Collections.filter(this, <File>[], f);
+  List mappedBy(f(File element)) => new MappedList<File, dynamic>(this, f);
+
+  Iterable<File> where(bool f(File element)) => new WhereIterable<File>(this, f);
 
   bool every(bool f(File element)) => Collections.every(this, f);
 
-  bool some(bool f(File element)) => Collections.some(this, f);
+  bool any(bool f(File element)) => Collections.any(this, f);
 
   bool get isEmpty => this.length == 0;
 
+  List<File> take(int n) => new ListView<File>(this, 0, n);
+
+  Iterable<File> takeWhile(bool test(File value)) {
+    return new TakeWhileIterable<File>(this, test);
+  }
+
+  List<File> skip(int n) => new ListView<File>(this, n, null);
+
+  Iterable<File> skipWhile(bool test(File value)) {
+    return new SkipWhileIterable<File>(this, test);
+  }
+
+  File firstMatching(bool test(File value), { File orElse() }) {
+    return Collections.firstMatching(this, test, orElse);
+  }
+
+  File lastMatching(bool test(File value), {File orElse()}) {
+    return Collections.lastMatchingInList(this, test, orElse);
+  }
+
+  File singleMatching(bool test(File value)) {
+    return Collections.singleMatching(this, test);
+  }
+
+  File elementAt(int index) {
+    return this[index];
+  }
+
+  // From Collection<File>:
+
+  void add(File value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addLast(File value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addAll(Iterable<File> iterable) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   // From List<File>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
   void sort([int compare(File a, File b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(File element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(File element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
 
-  File get first => this[0];
+  File get first {
+    if (this.length > 0) return this[0];
+    throw new StateError("No elements");
+  }
 
-  File get last => this[length - 1];
+  File get last {
+    if (this.length > 0) return this[this.length - 1];
+    throw new StateError("No elements");
+  }
+
+  File get single {
+    if (length == 1) return this[0];
+    if (length == 0) throw new StateError("No elements");
+    throw new StateError("More than one element");
+  }
+
+  File min([int compare(File a, File b)]) => _Collections.minInList(this, compare);
+
+  File max([int compare(File a, File b)]) => _Collections.maxInList(this, compare);
 
   File removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   File removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<File> from, [int startFrom]) {
@@ skipping 376 matching lines @@
   num operator[](int index) native "Float32Array_numericIndexGetter_Callback";
 
 
   /** @domName Float32Array.numericIndexSetter */
   void operator[]=(int index, num value) native "Float32Array_numericIndexSetter_Callback";
   // -- start List<num> mixins.
   // num is the element type.
 
   // From Iterable<num>:
 
-  Iterator<num> iterator() {
+  Iterator<num> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<num>(this);
   }
 
-  // From Collection<num>:
-
-  void add(num value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addLast(num value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addAll(Collection<num> collection) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, num)) {
     return Collections.reduce(this, initialValue, combine);
   }
 
   bool contains(num element) => Collections.contains(this, element);
 
   void forEach(void f(num element)) => Collections.forEach(this, f);
 
-  Collection map(f(num element)) => Collections.map(this, [], f);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  Collection<num> filter(bool f(num element)) =>
-     Collections.filter(this, <num>[], f);
+  List mappedBy(f(num element)) => new MappedList<num, dynamic>(this, f);
+
+  Iterable<num> where(bool f(num element)) => new WhereIterable<num>(this, f);
 
   bool every(bool f(num element)) => Collections.every(this, f);
 
-  bool some(bool f(num element)) => Collections.some(this, f);
+  bool any(bool f(num element)) => Collections.any(this, f);
 
   bool get isEmpty => this.length == 0;
 
+  List<num> take(int n) => new ListView<num>(this, 0, n);
+
+  Iterable<num> takeWhile(bool test(num value)) {
+    return new TakeWhileIterable<num>(this, test);
+  }
+
+  List<num> skip(int n) => new ListView<num>(this, n, null);
+
+  Iterable<num> skipWhile(bool test(num value)) {
+    return new SkipWhileIterable<num>(this, test);
+  }
+
+  num firstMatching(bool test(num value), { num orElse() }) {
+    return Collections.firstMatching(this, test, orElse);
+  }
+
+  num lastMatching(bool test(num value), {num orElse()}) {
+    return Collections.lastMatchingInList(this, test, orElse);
+  }
+
+  num singleMatching(bool test(num value)) {
+    return Collections.singleMatching(this, test);
+  }
+
+  num elementAt(int index) {
+    return this[index];
+  }
+
+  // From Collection<num>:
+
+  void add(num value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addLast(num value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addAll(Iterable<num> iterable) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   // From List<num>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
   void sort([int compare(num a, num b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(num element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(num element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
 
-  num get first => this[0];
+  num get first {
+    if (this.length > 0) return this[0];
+    throw new StateError("No elements");
+  }
 
-  num get last => this[length - 1];
+  num get last {
+    if (this.length > 0) return this[this.length - 1];
+    throw new StateError("No elements");
+  }
+
+  num get single {
+    if (length == 1) return this[0];
+    if (length == 0) throw new StateError("No elements");
+    throw new StateError("More than one element");
+  }
+
+  num min([int compare(num a, num b)]) => _Collections.minInList(this, compare);
+
+  num max([int compare(num a, num b)]) => _Collections.maxInList(this, compare);
 
   num removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   num removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<num> from, [int startFrom]) {
@@ skipping 64 matching lines @@
   num operator[](int index) native "Float64Array_numericIndexGetter_Callback";
 
 
   /** @domName Float64Array.numericIndexSetter */
   void operator[]=(int index, num value) native "Float64Array_numericIndexSetter_Callback";
   // -- start List<num> mixins.
   // num is the element type.
 
   // From Iterable<num>:
 
-  Iterator<num> iterator() {
+  Iterator<num> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<num>(this);
   }
 
-  // From Collection<num>:
-
-  void add(num value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addLast(num value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addAll(Collection<num> collection) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, num)) {
     return Collections.reduce(this, initialValue, combine);
   }
 
   bool contains(num element) => Collections.contains(this, element);
 
   void forEach(void f(num element)) => Collections.forEach(this, f);
 
-  Collection map(f(num element)) => Collections.map(this, [], f);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  Collection<num> filter(bool f(num element)) =>
-     Collections.filter(this, <num>[], f);
+  List mappedBy(f(num element)) => new MappedList<num, dynamic>(this, f);
+
+  Iterable<num> where(bool f(num element)) => new WhereIterable<num>(this, f);
 
   bool every(bool f(num element)) => Collections.every(this, f);
 
-  bool some(bool f(num element)) => Collections.some(this, f);
+  bool any(bool f(num element)) => Collections.any(this, f);
 
   bool get isEmpty => this.length == 0;
 
+  List<num> take(int n) => new ListView<num>(this, 0, n);
+
+  Iterable<num> takeWhile(bool test(num value)) {
+    return new TakeWhileIterable<num>(this, test);
+  }
+
+  List<num> skip(int n) => new ListView<num>(this, n, null);
+
+  Iterable<num> skipWhile(bool test(num value)) {
+    return new SkipWhileIterable<num>(this, test);
+  }
+
+  num firstMatching(bool test(num value), { num orElse() }) {
+    return Collections.firstMatching(this, test, orElse);
+  }
+
+  num lastMatching(bool test(num value), {num orElse()}) {
+    return Collections.lastMatchingInList(this, test, orElse);
+  }
+
+  num singleMatching(bool test(num value)) {
+    return Collections.singleMatching(this, test);
+  }
+
+  num elementAt(int index) {
+    return this[index];
+  }
+
+  // From Collection<num>:
+
+  void add(num value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addLast(num value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addAll(Iterable<num> iterable) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   // From List<num>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
   void sort([int compare(num a, num b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(num element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(num element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
 
-  num get first => this[0];
+  num get first {
+    if (this.length > 0) return this[0];
+    throw new StateError("No elements");
+  }
 
-  num get last => this[length - 1];
+  num get last {
+    if (this.length > 0) return this[this.length - 1];
+    throw new StateError("No elements");
+  }
+
+  num get single {
+    if (length == 1) return this[0];
+    if (length == 0) throw new StateError("No elements");
+    throw new StateError("More than one element");
+  }
+
+  num min([int compare(num a, num b)]) => _Collections.minInList(this, compare);
+
+  num max([int compare(num a, num b)]) => _Collections.maxInList(this, compare);
 
   num removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   num removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<num> from, [int startFrom]) {
@@ skipping 604 matching lines @@
   Node operator[](int index) native "HTMLAllCollection_item_Callback";
 
   void operator[]=(int index, Node value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<Node> mixins.
   // Node is the element type.
 
   // From Iterable<Node>:
 
-  Iterator<Node> iterator() {
+  Iterator<Node> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<Node>(this);
   }
 
-  // From Collection<Node>:
-
-  void add(Node value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addLast(Node value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addAll(Collection<Node> collection) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, Node)) {
     return Collections.reduce(this, initialValue, combine);
   }
 
   bool contains(Node element) => Collections.contains(this, element);
 
   void forEach(void f(Node element)) => Collections.forEach(this, f);
 
-  Collection map(f(Node element)) => Collections.map(this, [], f);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  Collection<Node> filter(bool f(Node element)) =>
-     Collections.filter(this, <Node>[], f);
+  List mappedBy(f(Node element)) => new MappedList<Node, dynamic>(this, f);
+
+  Iterable<Node> where(bool f(Node element)) => new WhereIterable<Node>(this, f);
 
   bool every(bool f(Node element)) => Collections.every(this, f);
 
-  bool some(bool f(Node element)) => Collections.some(this, f);
+  bool any(bool f(Node element)) => Collections.any(this, f);
 
   bool get isEmpty => this.length == 0;
 
+  List<Node> take(int n) => new ListView<Node>(this, 0, n);
+
+  Iterable<Node> takeWhile(bool test(Node value)) {
+    return new TakeWhileIterable<Node>(this, test);
+  }
+
+  List<Node> skip(int n) => new ListView<Node>(this, n, null);
+
+  Iterable<Node> skipWhile(bool test(Node value)) {
+    return new SkipWhileIterable<Node>(this, test);
+  }
+
+  Node firstMatching(bool test(Node value), { Node orElse() }) {
+    return Collections.firstMatching(this, test, orElse);
+  }
+
+  Node lastMatching(bool test(Node value), {Node orElse()}) {
+    return Collections.lastMatchingInList(this, test, orElse);
+  }
+
+  Node singleMatching(bool test(Node value)) {
+    return Collections.singleMatching(this, test);
+  }
+
+  Node elementAt(int index) {
+    return this[index];
+  }
+
+  // From Collection<Node>:
+
+  void add(Node value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addLast(Node value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addAll(Iterable<Node> iterable) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   // From List<Node>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
   void sort([int compare(Node a, Node b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(Node element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(Node element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
 
-  Node get first => this[0];
+  Node get first {
+    if (this.length > 0) return this[0];
+    throw new StateError("No elements");
+  }
 
-  Node get last => this[length - 1];
+  Node get last {
+    if (this.length > 0) return this[this.length - 1];
+    throw new StateError("No elements");
+  }
+
+  Node get single {
+    if (length == 1) return this[0];
+    if (length == 0) throw new StateError("No elements");
+    throw new StateError("More than one element");
+  }
+
+  Node min([int compare(Node a, Node b)]) => _Collections.minInList(this, compare);
+
+  Node max([int compare(Node a, Node b)]) => _Collections.maxInList(this, compare);
 
   Node removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   Node removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<Node> from, [int startFrom]) {
@@ skipping 44 matching lines @@
   Node operator[](int index) native "HTMLCollection_item_Callback";
 
   void operator[]=(int index, Node value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<Node> mixins.
   // Node is the element type.
 
   // From Iterable<Node>:
 
-  Iterator<Node> iterator() {
+  Iterator<Node> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<Node>(this);
   }
 
-  // From Collection<Node>:
-
-  void add(Node value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addLast(Node value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addAll(Collection<Node> collection) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, Node)) {
     return Collections.reduce(this, initialValue, combine);
   }
 
   bool contains(Node element) => Collections.contains(this, element);
 
   void forEach(void f(Node element)) => Collections.forEach(this, f);
 
-  Collection map(f(Node element)) => Collections.map(this, [], f);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  Collection<Node> filter(bool f(Node element)) =>
-     Collections.filter(this, <Node>[], f);
+  List mappedBy(f(Node element)) => new MappedList<Node, dynamic>(this, f);
+
+  Iterable<Node> where(bool f(Node element)) => new WhereIterable<Node>(this, f);
 
   bool every(bool f(Node element)) => Collections.every(this, f);
 
-  bool some(bool f(Node element)) => Collections.some(this, f);
+  bool any(bool f(Node element)) => Collections.any(this, f);
 
   bool get isEmpty => this.length == 0;
 
+  List<Node> take(int n) => new ListView<Node>(this, 0, n);
+
+  Iterable<Node> takeWhile(bool test(Node value)) {
+    return new TakeWhileIterable<Node>(this, test);
+  }
+
+  List<Node> skip(int n) => new ListView<Node>(this, n, null);
+
+  Iterable<Node> skipWhile(bool test(Node value)) {
+    return new SkipWhileIterable<Node>(this, test);
+  }
+
+  Node firstMatching(bool test(Node value), { Node orElse() }) {
+    return Collections.firstMatching(this, test, orElse);
+  }
+
+  Node lastMatching(bool test(Node value), {Node orElse()}) {
+    return Collections.lastMatchingInList(this, test, orElse);
+  }
+
+  Node singleMatching(bool test(Node value)) {
+    return Collections.singleMatching(this, test);
+  }
+
+  Node elementAt(int index) {
+    return this[index];
+  }
+
+  // From Collection<Node>:
+
+  void add(Node value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addLast(Node value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addAll(Iterable<Node> iterable) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   // From List<Node>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
   void sort([int compare(Node a, Node b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(Node element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(Node element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
 
-  Node get first => this[0];
+  Node get first {
+    if (this.length > 0) return this[0];
+    throw new StateError("No elements");
+  }
 
-  Node get last => this[length - 1];
+  Node get last {
+    if (this.length > 0) return this[this.length - 1];
+    throw new StateError("No elements");
+  }
+
+  Node get single {
+    if (length == 1) return this[0];
+    if (length == 0) throw new StateError("No elements");
+    throw new StateError("More than one element");
+  }
+
+  Node min([int compare(Node a, Node b)]) => _Collections.minInList(this, compare);
+
+  Node max([int compare(Node a, Node b)]) => _Collections.maxInList(this, compare);
 
   Node removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   Node removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<Node> from, [int startFrom]) {
@@ skipping 1801 matching lines @@
   int operator[](int index) native "Int16Array_numericIndexGetter_Callback";
 
 
   /** @domName Int16Array.numericIndexSetter */
   void operator[]=(int index, int value) native "Int16Array_numericIndexSetter_Callback";
   // -- start List<int> mixins.
   // int is the element type.
 
   // From Iterable<int>:
 
-  Iterator<int> iterator() {
+  Iterator<int> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<int>(this);
   }
 
-  // From Collection<int>:
-
-  void add(int value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addLast(int value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addAll(Collection<int> collection) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, int)) {
     return Collections.reduce(this, initialValue, combine);
   }
 
   bool contains(int element) => Collections.contains(this, element);
 
   void forEach(void f(int element)) => Collections.forEach(this, f);
 
-  Collection map(f(int element)) => Collections.map(this, [], f);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  Collection<int> filter(bool f(int element)) =>
-     Collections.filter(this, <int>[], f);
+  List mappedBy(f(int element)) => new MappedList<int, dynamic>(this, f);
+
+  Iterable<int> where(bool f(int element)) => new WhereIterable<int>(this, f);
 
   bool every(bool f(int element)) => Collections.every(this, f);
 
-  bool some(bool f(int element)) => Collections.some(this, f);
+  bool any(bool f(int element)) => Collections.any(this, f);
 
   bool get isEmpty => this.length == 0;
 
+  List<int> take(int n) => new ListView<int>(this, 0, n);
+
+  Iterable<int> takeWhile(bool test(int value)) {
+    return new TakeWhileIterable<int>(this, test);
+  }
+
+  List<int> skip(int n) => new ListView<int>(this, n, null);
+
+  Iterable<int> skipWhile(bool test(int value)) {
+    return new SkipWhileIterable<int>(this, test);
+  }
+
+  int firstMatching(bool test(int value), { int orElse() }) {
+    return Collections.firstMatching(this, test, orElse);
+  }
+
+  int lastMatching(bool test(int value), {int orElse()}) {
+    return Collections.lastMatchingInList(this, test, orElse);
+  }
+
+  int singleMatching(bool test(int value)) {
+    return Collections.singleMatching(this, test);
+  }
+
+  int elementAt(int index) {
+    return this[index];
+  }
+
+  // From Collection<int>:
+
+  void add(int value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addLast(int value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addAll(Iterable<int> iterable) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   // From List<int>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
   void sort([int compare(int a, int b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(int element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(int element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
 
-  int get first => this[0];
+  int get first {
+    if (this.length > 0) return this[0];
+    throw new StateError("No elements");
+  }
 
-  int get last => this[length - 1];
+  int get last {
+    if (this.length > 0) return this[this.length - 1];
+    throw new StateError("No elements");
+  }
+
+  int get single {
+    if (length == 1) return this[0];
+    if (length == 0) throw new StateError("No elements");
+    throw new StateError("More than one element");
+  }
+
+  int min([int compare(int a, int b)]) => _Collections.minInList(this, compare);
+
+  int max([int compare(int a, int b)]) => _Collections.maxInList(this, compare);
 
   int removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   int removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<int> from, [int startFrom]) {
@@ skipping 64 matching lines @@
   int operator[](int index) native "Int32Array_numericIndexGetter_Callback";
 
 
   /** @domName Int32Array.numericIndexSetter */
   void operator[]=(int index, int value) native "Int32Array_numericIndexSetter_Callback";
   // -- start List<int> mixins.
   // int is the element type.
 
   // From Iterable<int>:
 
-  Iterator<int> iterator() {
+  Iterator<int> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<int>(this);
   }
 
-  // From Collection<int>:
-
-  void add(int value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addLast(int value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addAll(Collection<int> collection) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, int)) {
     return Collections.reduce(this, initialValue, combine);
   }
 
   bool contains(int element) => Collections.contains(this, element);
 
   void forEach(void f(int element)) => Collections.forEach(this, f);
 
-  Collection map(f(int element)) => Collections.map(this, [], f);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  Collection<int> filter(bool f(int element)) =>
-     Collections.filter(this, <int>[], f);
+  List mappedBy(f(int element)) => new MappedList<int, dynamic>(this, f);
+
+  Iterable<int> where(bool f(int element)) => new WhereIterable<int>(this, f);
 
   bool every(bool f(int element)) => Collections.every(this, f);
 
-  bool some(bool f(int element)) => Collections.some(this, f);
+  bool any(bool f(int element)) => Collections.any(this, f);
 
   bool get isEmpty => this.length == 0;
 
+  List<int> take(int n) => new ListView<int>(this, 0, n);
+
+  Iterable<int> takeWhile(bool test(int value)) {
+    return new TakeWhileIterable<int>(this, test);
+  }
+
+  List<int> skip(int n) => new ListView<int>(this, n, null);
+
+  Iterable<int> skipWhile(bool test(int value)) {
+    return new SkipWhileIterable<int>(this, test);
+  }
+
+  int firstMatching(bool test(int value), { int orElse() }) {
+    return Collections.firstMatching(this, test, orElse);
+  }
+
+  int lastMatching(bool test(int value), {int orElse()}) {
+    return Collections.lastMatchingInList(this, test, orElse);
+  }
+
+  int singleMatching(bool test(int value)) {
+    return Collections.singleMatching(this, test);
+  }
+
+  int elementAt(int index) {
+    return this[index];
+  }
+
+  // From Collection<int>:
+
+  void add(int value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addLast(int value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addAll(Iterable<int> iterable) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   // From List<int>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
   void sort([int compare(int a, int b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(int element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(int element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
 
-  int get first => this[0];
+  int get first {
+    if (this.length > 0) return this[0];
+    throw new StateError("No elements");
+  }
 
-  int get last => this[length - 1];
+  int get last {
+    if (this.length > 0) return this[this.length - 1];
+    throw new StateError("No elements");
+  }
+
+  int get single {
+    if (length == 1) return this[0];
+    if (length == 0) throw new StateError("No elements");
+    throw new StateError("More than one element");
+  }
+
+  int min([int compare(int a, int b)]) => _Collections.minInList(this, compare);
+
+  int max([int compare(int a, int b)]) => _Collections.maxInList(this, compare);
 
   int removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   int removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<int> from, [int startFrom]) {
@@ skipping 64 matching lines @@
   int operator[](int index) native "Int8Array_numericIndexGetter_Callback";
 
 
   /** @domName Int8Array.numericIndexSetter */
   void operator[]=(int index, int value) native "Int8Array_numericIndexSetter_Callback";
   // -- start List<int> mixins.
   // int is the element type.
 
   // From Iterable<int>:
 
-  Iterator<int> iterator() {
+  Iterator<int> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<int>(this);
   }
 
-  // From Collection<int>:
-
-  void add(int value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addLast(int value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addAll(Collection<int> collection) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, int)) {
     return Collections.reduce(this, initialValue, combine);
   }
 
   bool contains(int element) => Collections.contains(this, element);
 
   void forEach(void f(int element)) => Collections.forEach(this, f);
 
-  Collection map(f(int element)) => Collections.map(this, [], f);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  Collection<int> filter(bool f(int element)) =>
-     Collections.filter(this, <int>[], f);
+  List mappedBy(f(int element)) => new MappedList<int, dynamic>(this, f);
+
+  Iterable<int> where(bool f(int element)) => new WhereIterable<int>(this, f);
 
   bool every(bool f(int element)) => Collections.every(this, f);
 
-  bool some(bool f(int element)) => Collections.some(this, f);
+  bool any(bool f(int element)) => Collections.any(this, f);
 
   bool get isEmpty => this.length == 0;
 
+  List<int> take(int n) => new ListView<int>(this, 0, n);
+
+  Iterable<int> takeWhile(bool test(int value)) {
+    return new TakeWhileIterable<int>(this, test);
+  }
+
+  List<int> skip(int n) => new ListView<int>(this, n, null);
+
+  Iterable<int> skipWhile(bool test(int value)) {
+    return new SkipWhileIterable<int>(this, test);
+  }
+
+  int firstMatching(bool test(int value), { int orElse() }) {
+    return Collections.firstMatching(this, test, orElse);
+  }
+
+  int lastMatching(bool test(int value), {int orElse()}) {
+    return Collections.lastMatchingInList(this, test, orElse);
+  }
+
+  int singleMatching(bool test(int value)) {
+    return Collections.singleMatching(this, test);
+  }
+
+  int elementAt(int index) {
+    return this[index];
+  }
+
+  // From Collection<int>:
+
+  void add(int value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addLast(int value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addAll(Iterable<int> iterable) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   // From List<int>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
   void sort([int compare(int a, int b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(int element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(int element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
 
-  int get first => this[0];
+  int get first {
+    if (this.length > 0) return this[0];
+    throw new StateError("No elements");
+  }
 
-  int get last => this[length - 1];
+  int get last {
+    if (this.length > 0) return this[this.length - 1];
+    throw new StateError("No elements");
+  }
+
+  int get single {
+    if (length == 1) return this[0];
+    if (length == 0) throw new StateError("No elements");
+    throw new StateError("More than one element");
+  }
+
+  int min([int compare(int a, int b)]) => _Collections.minInList(this, compare);
+
+  int max([int compare(int a, int b)]) => _Collections.maxInList(this, compare);
 
   int removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   int removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<int> from, [int startFrom]) {
@@ skipping 2242 matching lines @@
   Node operator[](int index) native "NamedNodeMap_item_Callback";
 
   void operator[]=(int index, Node value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<Node> mixins.
   // Node is the element type.
 
   // From Iterable<Node>:
 
-  Iterator<Node> iterator() {
+  Iterator<Node> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<Node>(this);
   }
 
-  // From Collection<Node>:
-
-  void add(Node value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addLast(Node value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addAll(Collection<Node> collection) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, Node)) {
     return Collections.reduce(this, initialValue, combine);
   }
 
   bool contains(Node element) => Collections.contains(this, element);
 
   void forEach(void f(Node element)) => Collections.forEach(this, f);
 
-  Collection map(f(Node element)) => Collections.map(this, [], f);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  Collection<Node> filter(bool f(Node element)) =>
-     Collections.filter(this, <Node>[], f);
+  List mappedBy(f(Node element)) => new MappedList<Node, dynamic>(this, f);
+
+  Iterable<Node> where(bool f(Node element)) => new WhereIterable<Node>(this, f);
 
   bool every(bool f(Node element)) => Collections.every(this, f);
 
-  bool some(bool f(Node element)) => Collections.some(this, f);
+  bool any(bool f(Node element)) => Collections.any(this, f);
 
   bool get isEmpty => this.length == 0;
 
+  List<Node> take(int n) => new ListView<Node>(this, 0, n);
+
+  Iterable<Node> takeWhile(bool test(Node value)) {
+    return new TakeWhileIterable<Node>(this, test);
+  }
+
+  List<Node> skip(int n) => new ListView<Node>(this, n, null);
+
+  Iterable<Node> skipWhile(bool test(Node value)) {
+    return new SkipWhileIterable<Node>(this, test);
+  }
+
+  Node firstMatching(bool test(Node value), { Node orElse() }) {
+    return Collections.firstMatching(this, test, orElse);
+  }
+
+  Node lastMatching(bool test(Node value), {Node orElse()}) {
+    return Collections.lastMatchingInList(this, test, orElse);
+  }
+
+  Node singleMatching(bool test(Node value)) {
+    return Collections.singleMatching(this, test);
+  }
+
+  Node elementAt(int index) {
+    return this[index];
+  }
+
+  // From Collection<Node>:
+
+  void add(Node value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addLast(Node value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addAll(Iterable<Node> iterable) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   // From List<Node>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
   void sort([int compare(Node a, Node b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(Node element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(Node element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
 
-  Node get first => this[0];
+  Node get first {
+    if (this.length > 0) return this[0];
+    throw new StateError("No elements");
+  }
 
-  Node get last => this[length - 1];
+  Node get last {
+    if (this.length > 0) return this[this.length - 1];
+    throw new StateError("No elements");
+  }
+
+  Node get single {
+    if (length == 1) return this[0];
+    if (length == 0) throw new StateError("No elements");
+    throw new StateError("More than one element");
+  }
+
+  Node min([int compare(Node a, Node b)]) => _Collections.minInList(this, compare);
+
+  Node max([int compare(Node a, Node b)]) => _Collections.maxInList(this, compare);
 
   Node removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   Node removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<Node> from, [int startFrom]) {
@@ skipping 177 matching lines @@
  * Lazy implementation of the child nodes of an element that does not request
  * the actual child nodes of an element until strictly necessary greatly
  * improving performance for the typical cases where it is not required.
  */
 class _ChildNodeListLazy implements List {
   final Node _this;
 
   _ChildNodeListLazy(this._this);
 
 
-  Node get first => _this.$dom_firstChild;
-  Node get last => _this.$dom_lastChild;
+  Node get first {
+    Node result = _this.$dom_firstChild;
+    if (result == null) throw new StateError("No elements");
+    return result;
+  }
+  Node get last {
+    Node result = _this.$dom_lastChild;
+    if (result == null) throw new StateError("No elements");
+    return result;
+  }
+  Node get single {
+    int l = this.length;
+    if (l == 0) throw new StateError("No elements");
+    if (l > 1) throw new StateError("More than one element");
+    return _this.$dom_firstChild;
+  }
+
+  Node min([int compare(Node a, Node b)]) {
+    return _Collections.minInList(this, compare);
+  }
+
+  Node max([int compare(Node a, Node b)]) {
+    return _Collections.maxInList(this, compare);
+  }
 
   void add(Node value) {
     _this.$dom_appendChild(value);
   }
 
   void addLast(Node value) {
     _this.$dom_appendChild(value);
   }
 
 
-  void addAll(Collection<Node> collection) {
-    for (Node node in collection) {
+  void addAll(Iterable<Node> iterable) {
+    for (Node node in iterable) {
       _this.$dom_appendChild(node);
     }
   }
 
   Node removeLast() {
     final result = last;
     if (result != null) {
       _this.$dom_removeChild(result);
     }
     return result;
   }
 
   Node removeAt(int index) {
     var result = this[index];
     if (result != null) {
       _this.$dom_removeChild(result);
     }
     return result;
   }
 
   void clear() {
     _this.text = '';
   }
 
   void operator []=(int index, Node value) {
     _this.$dom_replaceChild(value, this[index]);
   }
 
-  Iterator<Node> iterator() => _this.$dom_childNodes.iterator();
+  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);
 
   dynamic reduce(dynamic initialValue,
       dynamic combine(dynamic previousValue, Node element)) {
     return Collections.reduce(this, initialValue, combine);
   }
 
-  Collection map(f(Node element)) => Collections.map(this, [], f);
+  String join([String separator]) {
+    return Collections.joinList(this, separator);
+  }
 
-  Collection<Node> filter(bool f(Node element)) =>
-     Collections.filter(this, <Node>[], f);
+  List mappedBy(f(Node element)) =>
+      new MappedList<Node, dynamic>(this, f);
+
+  Iterable<Node> where(bool f(Node element)) =>
+     new WhereIterable<Node>(this, f);
 
   bool every(bool f(Node element)) => Collections.every(this, f);
 
-  bool some(bool f(Node element)) => Collections.some(this, f);
+  bool any(bool f(Node element)) => Collections.any(this, f);
 
   bool get isEmpty => this.length == 0;
 
   // From List<Node>:
 
+  List<Node> take(int n) {
+    return new ListView<Node>(this, 0, n);
+  }
+
+  Iterable<Node> takeWhile(bool test(Node value)) {
+    return new TakeWhileIterable<Node>(this, test);
+  }
+
+  List<Node> skip(int n) {
+    return new ListView<Node>(this, n, null);
+  }
+
+  Iterable<Node> skipWhile(bool test(Node value)) {
+    return new SkipWhileIterable<Node>(this, test);
+  }
+
+  Node firstMatching(bool test(Node value), {Node orElse()}) {
+    return Collections.firstMatching(this, test, orElse);
+  }
+
+  Node lastMatching(bool test(Node value), {Node orElse()}) {
+    return Collections.lastMatchingInList(this, test, orElse);
+  }
+
+  Node singleMatching(bool test(Node value)) {
+    return Collections.singleMatching(this, test);
+  }
+
+  Node elementAt(int index) {
+    return this[index];
+  }
+
   // TODO(jacobr): this could be implemented for child node lists.
   // The exception we throw here is misleading.
   void sort([int compare(Node a, Node b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(Node element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(Node element, [int start = 0]) =>
@@ skipping 321 matching lines @@
   Node operator[](int index) native "NodeList_item_Callback";
 
   void operator[]=(int index, Node value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<Node> mixins.
   // Node is the element type.
 
   // From Iterable<Node>:
 
-  Iterator<Node> iterator() {
+  Iterator<Node> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<Node>(this);
   }
 
-  // From Collection<Node>:
-
-  void add(Node value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addLast(Node value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addAll(Collection<Node> collection) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, Node)) {
     return Collections.reduce(this, initialValue, combine);
   }
 
   bool contains(Node element) => Collections.contains(this, element);
 
   void forEach(void f(Node element)) => Collections.forEach(this, f);
 
-  Collection map(f(Node element)) => Collections.map(this, [], f);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  Collection<Node> filter(bool f(Node element)) =>
-     Collections.filter(this, <Node>[], f);
+  List mappedBy(f(Node element)) => new MappedList<Node, dynamic>(this, f);
+
+  Iterable<Node> where(bool f(Node element)) => new WhereIterable<Node>(this, f);
 
   bool every(bool f(Node element)) => Collections.every(this, f);
 
-  bool some(bool f(Node element)) => Collections.some(this, f);
+  bool any(bool f(Node element)) => Collections.any(this, f);
 
   bool get isEmpty => this.length == 0;
 
+  List<Node> take(int n) => new ListView<Node>(this, 0, n);
+
+  Iterable<Node> takeWhile(bool test(Node value)) {
+    return new TakeWhileIterable<Node>(this, test);
+  }
+
+  List<Node> skip(int n) => new ListView<Node>(this, n, null);
+
+  Iterable<Node> skipWhile(bool test(Node value)) {
+    return new SkipWhileIterable<Node>(this, test);
+  }
+
+  Node firstMatching(bool test(Node value), { Node orElse() }) {
+    return Collections.firstMatching(this, test, orElse);
+  }
+
+  Node lastMatching(bool test(Node value), {Node orElse()}) {
+    return Collections.lastMatchingInList(this, test, orElse);
+  }
+
+  Node singleMatching(bool test(Node value)) {
+    return Collections.singleMatching(this, test);
+  }
+
+  Node elementAt(int index) {
+    return this[index];
+  }
+
+  // From Collection<Node>:
+
+  void add(Node value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addLast(Node value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addAll(Iterable<Node> iterable) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   // From List<Node>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
   void sort([int compare(Node a, Node b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(Node element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(Node element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
 
-  Node get first => this[0];
+  Node get first {
+    if (this.length > 0) return this[0];
+    throw new StateError("No elements");
+  }
 
-  Node get last => this[length - 1];
+  Node get last {
+    if (this.length > 0) return this[this.length - 1];
+    throw new StateError("No elements");
+  }
+
+  Node get single {
+    if (length == 1) return this[0];
+    if (length == 0) throw new StateError("No elements");
+    throw new StateError("More than one element");
+  }
+
+  Node min([int compare(Node a, Node b)]) => _Collections.minInList(this, compare);
+
+  Node max([int compare(Node a, Node b)]) => _Collections.maxInList(this, compare);
 
   Node removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   Node removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<Node> from, [int startFrom]) {
@@ skipping 2131 matching lines @@
   Node namedItem(String name) native "HTMLSelectElement_namedItem_Callback";
 
 
   /** @domName HTMLSelectElement.setCustomValidity */
   void setCustomValidity(String error) native "HTMLSelectElement_setCustomValidity_Callback";
 
 
   // Override default options, since IE returns SelectElement itself and it
   // does not operate as a List.
   List<OptionElement> get options {
-    return this.children.filter((e) => e is OptionElement);
+    return this.children.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.filter((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.
 
 // WARNING: Do not edit - generated code.
@@ skipping 190 matching lines @@
   SourceBuffer operator[](int index) native "SourceBufferList_item_Callback";
 
   void operator[]=(int index, SourceBuffer value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<SourceBuffer> mixins.
   // SourceBuffer is the element type.
 
   // From Iterable<SourceBuffer>:
 
-  Iterator<SourceBuffer> iterator() {
+  Iterator<SourceBuffer> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<SourceBuffer>(this);
   }
 
-  // From Collection<SourceBuffer>:
-
-  void add(SourceBuffer value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addLast(SourceBuffer value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addAll(Collection<SourceBuffer> collection) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, SourceBuffer)) {
     return Collections.reduce(this, initialValue, combine);
   }
 
   bool contains(SourceBuffer element) => Collections.contains(this, element);
 
   void forEach(void f(SourceBuffer element)) => Collections.forEach(this, f);
 
-  Collection map(f(SourceBuffer element)) => Collections.map(this, [], f);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  Collection<SourceBuffer> filter(bool f(SourceBuffer element)) =>
-     Collections.filter(this, <SourceBuffer>[], f);
+  List mappedBy(f(SourceBuffer element)) => new MappedList<SourceBuffer, dynamic>(this, f);
+
+  Iterable<SourceBuffer> where(bool f(SourceBuffer element)) => new WhereIterable<SourceBuffer>(this, f);
 
   bool every(bool f(SourceBuffer element)) => Collections.every(this, f);
 
-  bool some(bool f(SourceBuffer element)) => Collections.some(this, f);
+  bool any(bool f(SourceBuffer element)) => Collections.any(this, f);
 
   bool get isEmpty => this.length == 0;
 
+  List<SourceBuffer> take(int n) => new ListView<SourceBuffer>(this, 0, n);
+
+  Iterable<SourceBuffer> takeWhile(bool test(SourceBuffer value)) {
+    return new TakeWhileIterable<SourceBuffer>(this, test);
+  }
+
+  List<SourceBuffer> skip(int n) => new ListView<SourceBuffer>(this, n, null);
+
+  Iterable<SourceBuffer> skipWhile(bool test(SourceBuffer value)) {
+    return new SkipWhileIterable<SourceBuffer>(this, test);
+  }
+
+  SourceBuffer firstMatching(bool test(SourceBuffer value), { SourceBuffer orElse() }) {
+    return Collections.firstMatching(this, test, orElse);
+  }
+
+  SourceBuffer lastMatching(bool test(SourceBuffer value), {SourceBuffer orElse()}) {
+    return Collections.lastMatchingInList(this, test, orElse);
+  }
+
+  SourceBuffer singleMatching(bool test(SourceBuffer value)) {
+    return Collections.singleMatching(this, test);
+  }
+
+  SourceBuffer elementAt(int index) {
+    return this[index];
+  }
+
+  // From Collection<SourceBuffer>:
+
+  void add(SourceBuffer value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addLast(SourceBuffer value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addAll(Iterable<SourceBuffer> iterable) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   // From List<SourceBuffer>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
   void sort([int compare(SourceBuffer a, SourceBuffer b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(SourceBuffer element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(SourceBuffer element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
 
-  SourceBuffer get first => this[0];
+  SourceBuffer get first {
+    if (this.length > 0) return this[0];
+    throw new StateError("No elements");
+  }
 
-  SourceBuffer get last => this[length - 1];
+  SourceBuffer get last {
+    if (this.length > 0) return this[this.length - 1];
+    throw new StateError("No elements");
+  }
+
+  SourceBuffer get single {
+    if (length == 1) return this[0];
+    if (length == 0) throw new StateError("No elements");
+    throw new StateError("More than one element");
+  }
+
+  SourceBuffer min([int compare(SourceBuffer a, SourceBuffer b)]) => _Collections.minInList(this, compare);
+
+  SourceBuffer max([int compare(SourceBuffer a, SourceBuffer b)]) => _Collections.maxInList(this, compare);
 
   SourceBuffer removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   SourceBuffer removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<SourceBuffer> from, [int startFrom]) {
@@ skipping 138 matching lines @@
   SpeechGrammar operator[](int index) native "SpeechGrammarList_item_Callback";
 
   void operator[]=(int index, SpeechGrammar value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<SpeechGrammar> mixins.
   // SpeechGrammar is the element type.
 
   // From Iterable<SpeechGrammar>:
 
-  Iterator<SpeechGrammar> iterator() {
+  Iterator<SpeechGrammar> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<SpeechGrammar>(this);
   }
 
+  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, SpeechGrammar)) {
+    return Collections.reduce(this, initialValue, combine);
+  }
+
+  bool contains(SpeechGrammar element) => Collections.contains(this, element);
+
+  void forEach(void f(SpeechGrammar element)) => Collections.forEach(this, f);
+
+  String join([String separator]) => Collections.joinList(this, separator);
+
+  List mappedBy(f(SpeechGrammar element)) => new MappedList<SpeechGrammar, dynamic>(this, f);
+
+  Iterable<SpeechGrammar> where(bool f(SpeechGrammar element)) => new WhereIterable<SpeechGrammar>(this, f);
+
+  bool every(bool f(SpeechGrammar element)) => Collections.every(this, f);
+
+  bool any(bool f(SpeechGrammar element)) => Collections.any(this, f);
+
+  bool get isEmpty => this.length == 0;
+
+  List<SpeechGrammar> take(int n) => new ListView<SpeechGrammar>(this, 0, n);
+
+  Iterable<SpeechGrammar> takeWhile(bool test(SpeechGrammar value)) {
+    return new TakeWhileIterable<SpeechGrammar>(this, test);
+  }
+
+  List<SpeechGrammar> skip(int n) => new ListView<SpeechGrammar>(this, n, null);
+
+  Iterable<SpeechGrammar> skipWhile(bool test(SpeechGrammar value)) {
+    return new SkipWhileIterable<SpeechGrammar>(this, test);
+  }
+
+  SpeechGrammar firstMatching(bool test(SpeechGrammar value), { SpeechGrammar orElse() }) {
+    return Collections.firstMatching(this, test, orElse);
+  }
+
+  SpeechGrammar lastMatching(bool test(SpeechGrammar value), {SpeechGrammar orElse()}) {
+    return Collections.lastMatchingInList(this, test, orElse);
+  }
+
+  SpeechGrammar singleMatching(bool test(SpeechGrammar value)) {
+    return Collections.singleMatching(this, test);
+  }
+
+  SpeechGrammar elementAt(int index) {
+    return this[index];
+  }
+
   // From Collection<SpeechGrammar>:
 
   void add(SpeechGrammar value) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   void addLast(SpeechGrammar value) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
-  void addAll(Collection<SpeechGrammar> collection) {
+  void addAll(Iterable<SpeechGrammar> iterable) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, SpeechGrammar)) {
-    return Collections.reduce(this, initialValue, combine);
-  }
-
-  bool contains(SpeechGrammar element) => Collections.contains(this, element);
-
-  void forEach(void f(SpeechGrammar element)) => Collections.forEach(this, f);
-
-  Collection map(f(SpeechGrammar element)) => Collections.map(this, [], f);
-
-  Collection<SpeechGrammar> filter(bool f(SpeechGrammar element)) =>
-     Collections.filter(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;
-
   // From List<SpeechGrammar>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
   void sort([int compare(SpeechGrammar a, SpeechGrammar b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(SpeechGrammar element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(SpeechGrammar element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
 
-  SpeechGrammar get first => this[0];
+  SpeechGrammar get first {
+    if (this.length > 0) return this[0];
+    throw new StateError("No elements");
+  }
 
-  SpeechGrammar get last => this[length - 1];
+  SpeechGrammar get last {
+    if (this.length > 0) return this[this.length - 1];
+    throw new StateError("No elements");
+  }
+
+  SpeechGrammar get single {
+    if (length == 1) return this[0];
+    if (length == 0) throw new StateError("No elements");
+    throw new StateError("More than one element");
+  }
+
+  SpeechGrammar min([int compare(SpeechGrammar a, SpeechGrammar b)]) => _Collections.minInList(this, compare);
+
+  SpeechGrammar max([int compare(SpeechGrammar a, SpeechGrammar b)]) => _Collections.maxInList(this, compare);
 
   SpeechGrammar removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   SpeechGrammar removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<SpeechGrammar> from, [int startFrom]) {
@@ skipping 415 matching lines @@
   Map operator[](int index) native "SQLResultSetRowList_item_Callback";
 
   void operator[]=(int index, Map value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<Map> mixins.
   // Map is the element type.
 
   // From Iterable<Map>:
 
-  Iterator<Map> iterator() {
+  Iterator<Map> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<Map>(this);
   }
 
-  // From Collection<Map>:
-
-  void add(Map value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addLast(Map value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addAll(Collection<Map> collection) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, Map)) {
     return Collections.reduce(this, initialValue, combine);
   }
 
   bool contains(Map element) => Collections.contains(this, element);
 
   void forEach(void f(Map element)) => Collections.forEach(this, f);
 
-  Collection map(f(Map element)) => Collections.map(this, [], f);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  Collection<Map> filter(bool f(Map element)) =>
-     Collections.filter(this, <Map>[], f);
+  List mappedBy(f(Map element)) => new MappedList<Map, dynamic>(this, f);
+
+  Iterable<Map> where(bool f(Map element)) => new WhereIterable<Map>(this, f);
 
   bool every(bool f(Map element)) => Collections.every(this, f);
 
-  bool some(bool f(Map element)) => Collections.some(this, f);
+  bool any(bool f(Map element)) => Collections.any(this, f);
 
   bool get isEmpty => this.length == 0;
 
+  List<Map> take(int n) => new ListView<Map>(this, 0, n);
+
+  Iterable<Map> takeWhile(bool test(Map value)) {
+    return new TakeWhileIterable<Map>(this, test);
+  }
+
+  List<Map> skip(int n) => new ListView<Map>(this, n, null);
+
+  Iterable<Map> skipWhile(bool test(Map value)) {
+    return new SkipWhileIterable<Map>(this, test);
+  }
+
+  Map firstMatching(bool test(Map value), { Map orElse() }) {
+    return Collections.firstMatching(this, test, orElse);
+  }
+
+  Map lastMatching(bool test(Map value), {Map orElse()}) {
+    return Collections.lastMatchingInList(this, test, orElse);
+  }
+
+  Map singleMatching(bool test(Map value)) {
+    return Collections.singleMatching(this, test);
+  }
+
+  Map elementAt(int index) {
+    return this[index];
+  }
+
+  // From Collection<Map>:
+
+  void add(Map value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addLast(Map value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addAll(Iterable<Map> iterable) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   // From List<Map>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
   void sort([int compare(Map a, Map b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(Map element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(Map element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
 
-  Map get first => this[0];
+  Map get first {
+    if (this.length > 0) return this[0];
+    throw new StateError("No elements");
+  }
 
-  Map get last => this[length - 1];
+  Map get last {
+    if (this.length > 0) return this[this.length - 1];
+    throw new StateError("No elements");
+  }
+
+  Map get single {
+    if (length == 1) return this[0];
+    if (length == 0) throw new StateError("No elements");
+    throw new StateError("More than one element");
+  }
+
+  Map min([int compare(Map a, Map b)]) => _Collections.minInList(this, compare);
+
+  Map max([int compare(Map a, Map b)]) => _Collections.maxInList(this, compare);
 
   Map removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   Map removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<Map> from, [int startFrom]) {
@@ skipping 52 matching lines @@
 }
 // 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.
 
 
 /// @domName Storage
 class Storage extends NativeFieldWrapperClass1 implements Map<String, String>  {
 
   // TODO(nweiz): update this when maps support lazy iteration
-  bool containsValue(String value) => values.some((e) => e == value);
+  bool containsValue(String value) => values.any((e) => e == value);
 
   bool containsKey(String key) => $dom_getItem(key) != null;
 
   String operator [](String key) => $dom_getItem(key);
 
   void operator []=(String key, String value) { $dom_setItem(key, value); }
 
   String putIfAbsent(String key, String ifAbsent()) {
     if (!containsKey(key)) this[key] = ifAbsent();
     return this[key];
@@ skipping 1015 matching lines @@
   TextTrackCue operator[](int index) native "TextTrackCueList_item_Callback";
 
   void operator[]=(int index, TextTrackCue value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<TextTrackCue> mixins.
   // TextTrackCue is the element type.
 
   // From Iterable<TextTrackCue>:
 
-  Iterator<TextTrackCue> iterator() {
+  Iterator<TextTrackCue> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<TextTrackCue>(this);
   }
 
-  // From Collection<TextTrackCue>:
-
-  void add(TextTrackCue value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addLast(TextTrackCue value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addAll(Collection<TextTrackCue> collection) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, TextTrackCue)) {
     return Collections.reduce(this, initialValue, combine);
   }
 
   bool contains(TextTrackCue element) => Collections.contains(this, element);
 
   void forEach(void f(TextTrackCue element)) => Collections.forEach(this, f);
 
-  Collection map(f(TextTrackCue element)) => Collections.map(this, [], f);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  Collection<TextTrackCue> filter(bool f(TextTrackCue element)) =>
-     Collections.filter(this, <TextTrackCue>[], f);
+  List mappedBy(f(TextTrackCue element)) => new MappedList<TextTrackCue, dynamic>(this, f);
+
+  Iterable<TextTrackCue> where(bool f(TextTrackCue element)) => new WhereIterable<TextTrackCue>(this, f);
 
   bool every(bool f(TextTrackCue element)) => Collections.every(this, f);
 
-  bool some(bool f(TextTrackCue element)) => Collections.some(this, f);
+  bool any(bool f(TextTrackCue element)) => Collections.any(this, f);
 
   bool get isEmpty => this.length == 0;
 
+  List<TextTrackCue> take(int n) => new ListView<TextTrackCue>(this, 0, n);
+
+  Iterable<TextTrackCue> takeWhile(bool test(TextTrackCue value)) {
+    return new TakeWhileIterable<TextTrackCue>(this, test);
+  }
+
+  List<TextTrackCue> skip(int n) => new ListView<TextTrackCue>(this, n, null);
+
+  Iterable<TextTrackCue> skipWhile(bool test(TextTrackCue value)) {
+    return new SkipWhileIterable<TextTrackCue>(this, test);
+  }
+
+  TextTrackCue firstMatching(bool test(TextTrackCue value), { TextTrackCue orElse() }) {
+    return Collections.firstMatching(this, test, orElse);
+  }
+
+  TextTrackCue lastMatching(bool test(TextTrackCue value), {TextTrackCue orElse()}) {
+    return Collections.lastMatchingInList(this, test, orElse);
+  }
+
+  TextTrackCue singleMatching(bool test(TextTrackCue value)) {
+    return Collections.singleMatching(this, test);
+  }
+
+  TextTrackCue elementAt(int index) {
+    return this[index];
+  }
+
+  // From Collection<TextTrackCue>:
+
+  void add(TextTrackCue value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addLast(TextTrackCue value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addAll(Iterable<TextTrackCue> iterable) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   // From List<TextTrackCue>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
   void sort([int compare(TextTrackCue a, TextTrackCue b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(TextTrackCue element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(TextTrackCue element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
 
-  TextTrackCue get first => this[0];
+  TextTrackCue get first {
+    if (this.length > 0) return this[0];
+    throw new StateError("No elements");
+  }
 
-  TextTrackCue get last => this[length - 1];
+  TextTrackCue get last {
+    if (this.length > 0) return this[this.length - 1];
+    throw new StateError("No elements");
+  }
+
+  TextTrackCue get single {
+    if (length == 1) return this[0];
+    if (length == 0) throw new StateError("No elements");
+    throw new StateError("More than one element");
+  }
+
+  TextTrackCue min([int compare(TextTrackCue a, TextTrackCue b)]) => _Collections.minInList(this, compare);
+
+  TextTrackCue max([int compare(TextTrackCue a, TextTrackCue b)]) => _Collections.maxInList(this, compare);
 
   TextTrackCue removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   TextTrackCue removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<TextTrackCue> from, [int startFrom]) {
@@ skipping 44 matching lines @@
   TextTrack operator[](int index) native "TextTrackList_item_Callback";
 
   void operator[]=(int index, TextTrack value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<TextTrack> mixins.
   // TextTrack is the element type.
 
   // From Iterable<TextTrack>:
 
-  Iterator<TextTrack> iterator() {
+  Iterator<TextTrack> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<TextTrack>(this);
   }
 
-  // From Collection<TextTrack>:
-
-  void add(TextTrack value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addLast(TextTrack value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addAll(Collection<TextTrack> collection) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, TextTrack)) {
     return Collections.reduce(this, initialValue, combine);
   }
 
   bool contains(TextTrack element) => Collections.contains(this, element);
 
   void forEach(void f(TextTrack element)) => Collections.forEach(this, f);
 
-  Collection map(f(TextTrack element)) => Collections.map(this, [], f);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  Collection<TextTrack> filter(bool f(TextTrack element)) =>
-     Collections.filter(this, <TextTrack>[], f);
+  List mappedBy(f(TextTrack element)) => new MappedList<TextTrack, dynamic>(this, f);
+
+  Iterable<TextTrack> where(bool f(TextTrack element)) => new WhereIterable<TextTrack>(this, f);
 
   bool every(bool f(TextTrack element)) => Collections.every(this, f);
 
-  bool some(bool f(TextTrack element)) => Collections.some(this, f);
+  bool any(bool f(TextTrack element)) => Collections.any(this, f);
 
   bool get isEmpty => this.length == 0;
 
+  List<TextTrack> take(int n) => new ListView<TextTrack>(this, 0, n);
+
+  Iterable<TextTrack> takeWhile(bool test(TextTrack value)) {
+    return new TakeWhileIterable<TextTrack>(this, test);
+  }
+
+  List<TextTrack> skip(int n) => new ListView<TextTrack>(this, n, null);
+
+  Iterable<TextTrack> skipWhile(bool test(TextTrack value)) {
+    return new SkipWhileIterable<TextTrack>(this, test);
+  }
+
+  TextTrack firstMatching(bool test(TextTrack value), { TextTrack orElse() }) {
+    return Collections.firstMatching(this, test, orElse);
+  }
+
+  TextTrack lastMatching(bool test(TextTrack value), {TextTrack orElse()}) {
+    return Collections.lastMatchingInList(this, test, orElse);
+  }
+
+  TextTrack singleMatching(bool test(TextTrack value)) {
+    return Collections.singleMatching(this, test);
+  }
+
+  TextTrack elementAt(int index) {
+    return this[index];
+  }
+
+  // From Collection<TextTrack>:
+
+  void add(TextTrack value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addLast(TextTrack value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addAll(Iterable<TextTrack> iterable) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   // From List<TextTrack>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
   void sort([int compare(TextTrack a, TextTrack b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(TextTrack element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(TextTrack element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
 
-  TextTrack get first => this[0];
+  TextTrack get first {
+    if (this.length > 0) return this[0];
+    throw new StateError("No elements");
+  }
 
-  TextTrack get last => this[length - 1];
+  TextTrack get last {
+    if (this.length > 0) return this[this.length - 1];
+    throw new StateError("No elements");
+  }
+
+  TextTrack get single {
+    if (length == 1) return this[0];
+    if (length == 0) throw new StateError("No elements");
+    throw new StateError("More than one element");
+  }
+
+  TextTrack min([int compare(TextTrack a, TextTrack b)]) => _Collections.minInList(this, compare);
+
+  TextTrack max([int compare(TextTrack a, TextTrack b)]) => _Collections.maxInList(this, compare);
 
   TextTrack removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   TextTrack removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<TextTrack> from, [int startFrom]) {
@@ skipping 208 matching lines @@
   Touch operator[](int index) native "TouchList_item_Callback";
 
   void operator[]=(int index, Touch value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<Touch> mixins.
   // Touch is the element type.
 
   // From Iterable<Touch>:
 
-  Iterator<Touch> iterator() {
+  Iterator<Touch> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<Touch>(this);
   }
 
-  // From Collection<Touch>:
-
-  void add(Touch value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addLast(Touch value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addAll(Collection<Touch> collection) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, Touch)) {
     return Collections.reduce(this, initialValue, combine);
   }
 
   bool contains(Touch element) => Collections.contains(this, element);
 
   void forEach(void f(Touch element)) => Collections.forEach(this, f);
 
-  Collection map(f(Touch element)) => Collections.map(this, [], f);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  Collection<Touch> filter(bool f(Touch element)) =>
-     Collections.filter(this, <Touch>[], f);
+  List mappedBy(f(Touch element)) => new MappedList<Touch, dynamic>(this, f);
+
+  Iterable<Touch> where(bool f(Touch element)) => new WhereIterable<Touch>(this, f);
 
   bool every(bool f(Touch element)) => Collections.every(this, f);
 
-  bool some(bool f(Touch element)) => Collections.some(this, f);
+  bool any(bool f(Touch element)) => Collections.any(this, f);
 
   bool get isEmpty => this.length == 0;
 
+  List<Touch> take(int n) => new ListView<Touch>(this, 0, n);
+
+  Iterable<Touch> takeWhile(bool test(Touch value)) {
+    return new TakeWhileIterable<Touch>(this, test);
+  }
+
+  List<Touch> skip(int n) => new ListView<Touch>(this, n, null);
+
+  Iterable<Touch> skipWhile(bool test(Touch value)) {
+    return new SkipWhileIterable<Touch>(this, test);
+  }
+
+  Touch firstMatching(bool test(Touch value), { Touch orElse() }) {
+    return Collections.firstMatching(this, test, orElse);
+  }
+
+  Touch lastMatching(bool test(Touch value), {Touch orElse()}) {
+    return Collections.lastMatchingInList(this, test, orElse);
+  }
+
+  Touch singleMatching(bool test(Touch value)) {
+    return Collections.singleMatching(this, test);
+  }
+
+  Touch elementAt(int index) {
+    return this[index];
+  }
+
+  // From Collection<Touch>:
+
+  void add(Touch value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addLast(Touch value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addAll(Iterable<Touch> iterable) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   // From List<Touch>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
   void sort([int compare(Touch a, Touch b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(Touch element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(Touch element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
 
-  Touch get first => this[0];
+  Touch get first {
+    if (this.length > 0) return this[0];
+    throw new StateError("No elements");
+  }
 
-  Touch get last => this[length - 1];
+  Touch get last {
+    if (this.length > 0) return this[this.length - 1];
+    throw new StateError("No elements");
+  }
+
+  Touch get single {
+    if (length == 1) return this[0];
+    if (length == 0) throw new StateError("No elements");
+    throw new StateError("More than one element");
+  }
+
+  Touch min([int compare(Touch a, Touch b)]) => _Collections.minInList(this, compare);
+
+  Touch max([int compare(Touch a, Touch b)]) => _Collections.maxInList(this, compare);
 
   Touch removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   Touch removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<Touch> from, [int startFrom]) {
@@ skipping 307 matching lines @@
   int operator[](int index) native "Uint16Array_numericIndexGetter_Callback";
 
 
   /** @domName Uint16Array.numericIndexSetter */
   void operator[]=(int index, int value) native "Uint16Array_numericIndexSetter_Callback";
   // -- start List<int> mixins.
   // int is the element type.
 
   // From Iterable<int>:
 
-  Iterator<int> iterator() {
+  Iterator<int> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<int>(this);
   }
 
-  // From Collection<int>:
-
-  void add(int value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addLast(int value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addAll(Collection<int> collection) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, int)) {
     return Collections.reduce(this, initialValue, combine);
   }
 
   bool contains(int element) => Collections.contains(this, element);
 
   void forEach(void f(int element)) => Collections.forEach(this, f);
 
-  Collection map(f(int element)) => Collections.map(this, [], f);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  Collection<int> filter(bool f(int element)) =>
-     Collections.filter(this, <int>[], f);
+  List mappedBy(f(int element)) => new MappedList<int, dynamic>(this, f);
+
+  Iterable<int> where(bool f(int element)) => new WhereIterable<int>(this, f);
 
   bool every(bool f(int element)) => Collections.every(this, f);
 
-  bool some(bool f(int element)) => Collections.some(this, f);
+  bool any(bool f(int element)) => Collections.any(this, f);
 
   bool get isEmpty => this.length == 0;
 
+  List<int> take(int n) => new ListView<int>(this, 0, n);
+
+  Iterable<int> takeWhile(bool test(int value)) {
+    return new TakeWhileIterable<int>(this, test);
+  }
+
+  List<int> skip(int n) => new ListView<int>(this, n, null);
+
+  Iterable<int> skipWhile(bool test(int value)) {
+    return new SkipWhileIterable<int>(this, test);
+  }
+
+  int firstMatching(bool test(int value), { int orElse() }) {
+    return Collections.firstMatching(this, test, orElse);
+  }
+
+  int lastMatching(bool test(int value), {int orElse()}) {
+    return Collections.lastMatchingInList(this, test, orElse);
+  }
+
+  int singleMatching(bool test(int value)) {
+    return Collections.singleMatching(this, test);
+  }
+
+  int elementAt(int index) {
+    return this[index];
+  }
+
+  // From Collection<int>:
+
+  void add(int value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addLast(int value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addAll(Iterable<int> iterable) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   // From List<int>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
   void sort([int compare(int a, int b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(int element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(int element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
 
-  int get first => this[0];
+  int get first {
+    if (this.length > 0) return this[0];
+    throw new StateError("No elements");
+  }
 
-  int get last => this[length - 1];
+  int get last {
+    if (this.length > 0) return this[this.length - 1];
+    throw new StateError("No elements");
+  }
+
+  int get single {
+    if (length == 1) return this[0];
+    if (length == 0) throw new StateError("No elements");
+    throw new StateError("More than one element");
+  }
+
+  int min([int compare(int a, int b)]) => _Collections.minInList(this, compare);
+
+  int max([int compare(int a, int b)]) => _Collections.maxInList(this, compare);
 
   int removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   int removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<int> from, [int startFrom]) {
@@ skipping 64 matching lines @@
   int operator[](int index) native "Uint32Array_numericIndexGetter_Callback";
 
 
   /** @domName Uint32Array.numericIndexSetter */
   void operator[]=(int index, int value) native "Uint32Array_numericIndexSetter_Callback";
   // -- start List<int> mixins.
   // int is the element type.
 
   // From Iterable<int>:
 
-  Iterator<int> iterator() {
+  Iterator<int> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<int>(this);
   }
 
-  // From Collection<int>:
-
-  void add(int value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addLast(int value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addAll(Collection<int> collection) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, int)) {
     return Collections.reduce(this, initialValue, combine);
   }
 
   bool contains(int element) => Collections.contains(this, element);
 
   void forEach(void f(int element)) => Collections.forEach(this, f);
 
-  Collection map(f(int element)) => Collections.map(this, [], f);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  Collection<int> filter(bool f(int element)) =>
-     Collections.filter(this, <int>[], f);
+  List mappedBy(f(int element)) => new MappedList<int, dynamic>(this, f);
+
+  Iterable<int> where(bool f(int element)) => new WhereIterable<int>(this, f);
 
   bool every(bool f(int element)) => Collections.every(this, f);
 
-  bool some(bool f(int element)) => Collections.some(this, f);
+  bool any(bool f(int element)) => Collections.any(this, f);
 
   bool get isEmpty => this.length == 0;
 
+  List<int> take(int n) => new ListView<int>(this, 0, n);
+
+  Iterable<int> takeWhile(bool test(int value)) {
+    return new TakeWhileIterable<int>(this, test);
+  }
+
+  List<int> skip(int n) => new ListView<int>(this, n, null);
+
+  Iterable<int> skipWhile(bool test(int value)) {
+    return new SkipWhileIterable<int>(this, test);
+  }
+
+  int firstMatching(bool test(int value), { int orElse() }) {
+    return Collections.firstMatching(this, test, orElse);
+  }
+
+  int lastMatching(bool test(int value), {int orElse()}) {
+    return Collections.lastMatchingInList(this, test, orElse);
+  }
+
+  int singleMatching(bool test(int value)) {
+    return Collections.singleMatching(this, test);
+  }
+
+  int elementAt(int index) {
+    return this[index];
+  }
+
+  // From Collection<int>:
+
+  void add(int value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addLast(int value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addAll(Iterable<int> iterable) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   // From List<int>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
   void sort([int compare(int a, int b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(int element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(int element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
 
-  int get first => this[0];
+  int get first {
+    if (this.length > 0) return this[0];
+    throw new StateError("No elements");
+  }
 
-  int get last => this[length - 1];
+  int get last {
+    if (this.length > 0) return this[this.length - 1];
+    throw new StateError("No elements");
+  }
+
+  int get single {
+    if (length == 1) return this[0];
+    if (length == 0) throw new StateError("No elements");
+    throw new StateError("More than one element");
+  }
+
+  int min([int compare(int a, int b)]) => _Collections.minInList(this, compare);
+
+  int max([int compare(int a, int b)]) => _Collections.maxInList(this, compare);
 
   int removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   int removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<int> from, [int startFrom]) {
@@ skipping 64 matching lines @@
   int operator[](int index) native "Uint8Array_numericIndexGetter_Callback";
 
 
   /** @domName Uint8Array.numericIndexSetter */
   void operator[]=(int index, int value) native "Uint8Array_numericIndexSetter_Callback";
   // -- start List<int> mixins.
   // int is the element type.
 
   // From Iterable<int>:
 
-  Iterator<int> iterator() {
+  Iterator<int> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<int>(this);
   }
 
+  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, int)) {
+    return Collections.reduce(this, initialValue, combine);
+  }
+
+  bool contains(int element) => Collections.contains(this, element);
+
+  void forEach(void f(int element)) => Collections.forEach(this, f);
+
+  String join([String separator]) => Collections.joinList(this, separator);
+
+  List mappedBy(f(int element)) => new MappedList<int, dynamic>(this, f);
+
+  Iterable<int> where(bool f(int element)) => new WhereIterable<int>(this, f);
+
+  bool every(bool f(int element)) => Collections.every(this, f);
+
+  bool any(bool f(int element)) => Collections.any(this, f);
+
+  bool get isEmpty => this.length == 0;
+
+  List<int> take(int n) => new ListView<int>(this, 0, n);
+
+  Iterable<int> takeWhile(bool test(int value)) {
+    return new TakeWhileIterable<int>(this, test);
+  }
+
+  List<int> skip(int n) => new ListView<int>(this, n, null);
+
+  Iterable<int> skipWhile(bool test(int value)) {
+    return new SkipWhileIterable<int>(this, test);
+  }
+
+  int firstMatching(bool test(int value), { int orElse() }) {
+    return Collections.firstMatching(this, test, orElse);
+  }
+
+  int lastMatching(bool test(int value), {int orElse()}) {
+    return Collections.lastMatchingInList(this, test, orElse);
+  }
+
+  int singleMatching(bool test(int value)) {
+    return Collections.singleMatching(this, test);
+  }
+
+  int elementAt(int index) {
+    return this[index];
+  }
+
   // From Collection<int>:
 
   void add(int value) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
   void addLast(int value) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
-  void addAll(Collection<int> collection) {
+  void addAll(Iterable<int> iterable) {
     throw new UnsupportedError("Cannot add to immutable List.");
   }
 
-  dynamic reduce(dynamic initialValue, dynamic combine(dynamic, int)) {
-    return Collections.reduce(this, initialValue, combine);
-  }
-
-  bool contains(int element) => Collections.contains(this, element);
-
-  void forEach(void f(int element)) => Collections.forEach(this, f);
-
-  Collection map(f(int element)) => Collections.map(this, [], f);
-
-  Collection<int> filter(bool f(int element)) =>
-     Collections.filter(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;
-
   // From List<int>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
   void sort([int compare(int a, int b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(int element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(int element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
 
-  int get first => this[0];
+  int get first {
+    if (this.length > 0) return this[0];
+    throw new StateError("No elements");
+  }
 
-  int get last => this[length - 1];
+  int get last {
+    if (this.length > 0) return this[this.length - 1];
+    throw new StateError("No elements");
+  }
+
+  int get single {
+    if (length == 1) return this[0];
+    if (length == 0) throw new StateError("No elements");
+    throw new StateError("More than one element");
+  }
+
+  int min([int compare(int a, int b)]) => _Collections.minInList(this, compare);
+
+  int max([int compare(int a, int b)]) => _Collections.maxInList(this, compare);
 
   int removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   int removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<int> from, [int startFrom]) {
@@ skipping 2181 matching lines @@
    */
   void requestLayoutFrame(TimeoutHandler callback) {
     _addMeasurementFrameCallback(callback);
   }
 
   /**
    * Lookup a port by its [name].  Return null if no port is
    * registered under [name].
    */
   lookupPort(String name) {
-    var port = JSON.parse(document.documentElement.attributes['dart-port:$name']);
+    var port = json.parse(document.documentElement.attributes['dart-port:$name']);
     return _deserialize(port);
   }
 
   /**
    * Register a [port] on this window under the given [name].  This
    * port may be retrieved by any isolate (or JavaScript script)
    * running in this window.
    */
   registerPort(String name, var port) {
     var serialized = _serialize(port);
-    document.documentElement.attributes['dart-port:$name'] = JSON.stringify(serialized);
+    document.documentElement.attributes['dart-port:$name'] = json.stringify(serialized);
   }
 
   Window.internal() : super.internal();
 
   /// @domName EventTarget.addEventListener, EventTarget.removeEventListener, EventTarget.dispatchEvent; @docsEditable true
   WindowEvents get on =>
     new WindowEvents(this);
 
   static const int PERSISTENT = 1;
 
@@ skipping 1076 matching lines @@
   ClientRect operator[](int index) native "ClientRectList_item_Callback";
 
   void operator[]=(int index, ClientRect value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<ClientRect> mixins.
   // ClientRect is the element type.
 
   // From Iterable<ClientRect>:
 
-  Iterator<ClientRect> iterator() {
+  Iterator<ClientRect> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<ClientRect>(this);
   }
 
-  // From Collection<ClientRect>:
-
-  void add(ClientRect value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addLast(ClientRect value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addAll(Collection<ClientRect> collection) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, ClientRect)) {
     return Collections.reduce(this, initialValue, combine);
   }
 
   bool contains(ClientRect element) => Collections.contains(this, element);
 
   void forEach(void f(ClientRect element)) => Collections.forEach(this, f);
 
-  Collection map(f(ClientRect element)) => Collections.map(this, [], f);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  Collection<ClientRect> filter(bool f(ClientRect element)) =>
-     Collections.filter(this, <ClientRect>[], f);
+  List mappedBy(f(ClientRect element)) => new MappedList<ClientRect, dynamic>(this, f);
+
+  Iterable<ClientRect> where(bool f(ClientRect element)) => new WhereIterable<ClientRect>(this, f);
 
   bool every(bool f(ClientRect element)) => Collections.every(this, f);
 
-  bool some(bool f(ClientRect element)) => Collections.some(this, f);
+  bool any(bool f(ClientRect element)) => Collections.any(this, f);
 
   bool get isEmpty => this.length == 0;
 
+  List<ClientRect> take(int n) => new ListView<ClientRect>(this, 0, n);
+
+  Iterable<ClientRect> takeWhile(bool test(ClientRect value)) {
+    return new TakeWhileIterable<ClientRect>(this, test);
+  }
+
+  List<ClientRect> skip(int n) => new ListView<ClientRect>(this, n, null);
+
+  Iterable<ClientRect> skipWhile(bool test(ClientRect value)) {
+    return new SkipWhileIterable<ClientRect>(this, test);
+  }
+
+  ClientRect firstMatching(bool test(ClientRect value), { ClientRect orElse() }) {
+    return Collections.firstMatching(this, test, orElse);
+  }
+
+  ClientRect lastMatching(bool test(ClientRect value), {ClientRect orElse()}) {
+    return Collections.lastMatchingInList(this, test, orElse);
+  }
+
+  ClientRect singleMatching(bool test(ClientRect value)) {
+    return Collections.singleMatching(this, test);
+  }
+
+  ClientRect elementAt(int index) {
+    return this[index];
+  }
+
+  // From Collection<ClientRect>:
+
+  void add(ClientRect value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addLast(ClientRect value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addAll(Iterable<ClientRect> iterable) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   // From List<ClientRect>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
   void sort([int compare(ClientRect a, ClientRect b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(ClientRect element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(ClientRect element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
 
-  ClientRect get first => this[0];
+  ClientRect get first {
+    if (this.length > 0) return this[0];
+    throw new StateError("No elements");
+  }
 
-  ClientRect get last => this[length - 1];
+  ClientRect get last {
+    if (this.length > 0) return this[this.length - 1];
+    throw new StateError("No elements");
+  }
+
+  ClientRect get single {
+    if (length == 1) return this[0];
+    if (length == 0) throw new StateError("No elements");
+    throw new StateError("More than one element");
+  }
+
+  ClientRect min([int compare(ClientRect a, ClientRect b)]) => _Collections.minInList(this, compare);
+
+  ClientRect max([int compare(ClientRect a, ClientRect b)]) => _Collections.maxInList(this, compare);
 
   ClientRect removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   ClientRect removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<ClientRect> from, [int startFrom]) {
@@ skipping 36 matching lines @@
   CssRule operator[](int index) native "CSSRuleList_item_Callback";
 
   void operator[]=(int index, CssRule value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<CssRule> mixins.
   // CssRule is the element type.
 
   // From Iterable<CssRule>:
 
-  Iterator<CssRule> iterator() {
+  Iterator<CssRule> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<CssRule>(this);
   }
 
-  // From Collection<CssRule>:
-
-  void add(CssRule value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addLast(CssRule value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addAll(Collection<CssRule> collection) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, CssRule)) {
     return Collections.reduce(this, initialValue, combine);
   }
 
   bool contains(CssRule element) => Collections.contains(this, element);
 
   void forEach(void f(CssRule element)) => Collections.forEach(this, f);
 
-  Collection map(f(CssRule element)) => Collections.map(this, [], f);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  Collection<CssRule> filter(bool f(CssRule element)) =>
-     Collections.filter(this, <CssRule>[], f);
+  List mappedBy(f(CssRule element)) => new MappedList<CssRule, dynamic>(this, f);
+
+  Iterable<CssRule> where(bool f(CssRule element)) => new WhereIterable<CssRule>(this, f);
 
   bool every(bool f(CssRule element)) => Collections.every(this, f);
 
-  bool some(bool f(CssRule element)) => Collections.some(this, f);
+  bool any(bool f(CssRule element)) => Collections.any(this, f);
 
   bool get isEmpty => this.length == 0;
 
+  List<CssRule> take(int n) => new ListView<CssRule>(this, 0, n);
+
+  Iterable<CssRule> takeWhile(bool test(CssRule value)) {
+    return new TakeWhileIterable<CssRule>(this, test);
+  }
+
+  List<CssRule> skip(int n) => new ListView<CssRule>(this, n, null);
+
+  Iterable<CssRule> skipWhile(bool test(CssRule value)) {
+    return new SkipWhileIterable<CssRule>(this, test);
+  }
+
+  CssRule firstMatching(bool test(CssRule value), { CssRule orElse() }) {
+    return Collections.firstMatching(this, test, orElse);
+  }
+
+  CssRule lastMatching(bool test(CssRule value), {CssRule orElse()}) {
+    return Collections.lastMatchingInList(this, test, orElse);
+  }
+
+  CssRule singleMatching(bool test(CssRule value)) {
+    return Collections.singleMatching(this, test);
+  }
+
+  CssRule elementAt(int index) {
+    return this[index];
+  }
+
+  // From Collection<CssRule>:
+
+  void add(CssRule value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addLast(CssRule value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addAll(Iterable<CssRule> iterable) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   // From List<CssRule>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
   void sort([int compare(CssRule a, CssRule b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(CssRule element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(CssRule element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
 
-  CssRule get first => this[0];
+  CssRule get first {
+    if (this.length > 0) return this[0];
+    throw new StateError("No elements");
+  }
 
-  CssRule get last => this[length - 1];
+  CssRule get last {
+    if (this.length > 0) return this[this.length - 1];
+    throw new StateError("No elements");
+  }
+
+  CssRule get single {
+    if (length == 1) return this[0];
+    if (length == 0) throw new StateError("No elements");
+    throw new StateError("More than one element");
+  }
+
+  CssRule min([int compare(CssRule a, CssRule b)]) => _Collections.minInList(this, compare);
+
+  CssRule max([int compare(CssRule a, CssRule b)]) => _Collections.maxInList(this, compare);
 
   CssRule removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   CssRule removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<CssRule> from, [int startFrom]) {
@@ skipping 36 matching lines @@
   CssValue operator[](int index) native "CSSValueList_item_Callback";
 
   void operator[]=(int index, CssValue value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<CssValue> mixins.
   // CssValue is the element type.
 
   // From Iterable<CssValue>:
 
-  Iterator<CssValue> iterator() {
+  Iterator<CssValue> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<CssValue>(this);
   }
 
-  // From Collection<CssValue>:
-
-  void add(CssValue value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addLast(CssValue value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addAll(Collection<CssValue> collection) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, CssValue)) {
     return Collections.reduce(this, initialValue, combine);
   }
 
   bool contains(CssValue element) => Collections.contains(this, element);
 
   void forEach(void f(CssValue element)) => Collections.forEach(this, f);
 
-  Collection map(f(CssValue element)) => Collections.map(this, [], f);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  Collection<CssValue> filter(bool f(CssValue element)) =>
-     Collections.filter(this, <CssValue>[], f);
+  List mappedBy(f(CssValue element)) => new MappedList<CssValue, dynamic>(this, f);
+
+  Iterable<CssValue> where(bool f(CssValue element)) => new WhereIterable<CssValue>(this, f);
 
   bool every(bool f(CssValue element)) => Collections.every(this, f);
 
-  bool some(bool f(CssValue element)) => Collections.some(this, f);
+  bool any(bool f(CssValue element)) => Collections.any(this, f);
 
   bool get isEmpty => this.length == 0;
 
+  List<CssValue> take(int n) => new ListView<CssValue>(this, 0, n);
+
+  Iterable<CssValue> takeWhile(bool test(CssValue value)) {
+    return new TakeWhileIterable<CssValue>(this, test);
+  }
+
+  List<CssValue> skip(int n) => new ListView<CssValue>(this, n, null);
+
+  Iterable<CssValue> skipWhile(bool test(CssValue value)) {
+    return new SkipWhileIterable<CssValue>(this, test);
+  }
+
+  CssValue firstMatching(bool test(CssValue value), { CssValue orElse() }) {
+    return Collections.firstMatching(this, test, orElse);
+  }
+
+  CssValue lastMatching(bool test(CssValue value), {CssValue orElse()}) {
+    return Collections.lastMatchingInList(this, test, orElse);
+  }
+
+  CssValue singleMatching(bool test(CssValue value)) {
+    return Collections.singleMatching(this, test);
+  }
+
+  CssValue elementAt(int index) {
+    return this[index];
+  }
+
+  // From Collection<CssValue>:
+
+  void add(CssValue value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addLast(CssValue value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addAll(Iterable<CssValue> iterable) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   // From List<CssValue>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
   void sort([int compare(CssValue a, CssValue b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(CssValue element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(CssValue element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
 
-  CssValue get first => this[0];
+  CssValue get first {
+    if (this.length > 0) return this[0];
+    throw new StateError("No elements");
+  }
 
-  CssValue get last => this[length - 1];
+  CssValue get last {
+    if (this.length > 0) return this[this.length - 1];
+    throw new StateError("No elements");
+  }
+
+  CssValue get single {
+    if (length == 1) return this[0];
+    if (length == 0) throw new StateError("No elements");
+    throw new StateError("More than one element");
+  }
+
+  CssValue min([int compare(CssValue a, CssValue b)]) => _Collections.minInList(this, compare);
+
+  CssValue max([int compare(CssValue a, CssValue b)]) => _Collections.maxInList(this, compare);
 
   CssValue removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   CssValue removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<CssValue> from, [int startFrom]) {
@@ skipping 172 matching lines @@
   Entry operator[](int index) native "EntryArray_item_Callback";
 
   void operator[]=(int index, Entry value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<Entry> mixins.
   // Entry is the element type.
 
   // From Iterable<Entry>:
 
-  Iterator<Entry> iterator() {
+  Iterator<Entry> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<Entry>(this);
   }
 
-  // From Collection<Entry>:
-
-  void add(Entry value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addLast(Entry value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addAll(Collection<Entry> collection) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, Entry)) {
     return Collections.reduce(this, initialValue, combine);
   }
 
   bool contains(Entry element) => Collections.contains(this, element);
 
   void forEach(void f(Entry element)) => Collections.forEach(this, f);
 
-  Collection map(f(Entry element)) => Collections.map(this, [], f);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  Collection<Entry> filter(bool f(Entry element)) =>
-     Collections.filter(this, <Entry>[], f);
+  List mappedBy(f(Entry element)) => new MappedList<Entry, dynamic>(this, f);
+
+  Iterable<Entry> where(bool f(Entry element)) => new WhereIterable<Entry>(this, f);
 
   bool every(bool f(Entry element)) => Collections.every(this, f);
 
-  bool some(bool f(Entry element)) => Collections.some(this, f);
+  bool any(bool f(Entry element)) => Collections.any(this, f);
 
   bool get isEmpty => this.length == 0;
 
+  List<Entry> take(int n) => new ListView<Entry>(this, 0, n);
+
+  Iterable<Entry> takeWhile(bool test(Entry value)) {
+    return new TakeWhileIterable<Entry>(this, test);
+  }
+
+  List<Entry> skip(int n) => new ListView<Entry>(this, n, null);
+
+  Iterable<Entry> skipWhile(bool test(Entry value)) {
+    return new SkipWhileIterable<Entry>(this, test);
+  }
+
+  Entry firstMatching(bool test(Entry value), { Entry orElse() }) {
+    return Collections.firstMatching(this, test, orElse);
+  }
+
+  Entry lastMatching(bool test(Entry value), {Entry orElse()}) {
+    return Collections.lastMatchingInList(this, test, orElse);
+  }
+
+  Entry singleMatching(bool test(Entry value)) {
+    return Collections.singleMatching(this, test);
+  }
+
+  Entry elementAt(int index) {
+    return this[index];
+  }
+
+  // From Collection<Entry>:
+
+  void add(Entry value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addLast(Entry value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addAll(Iterable<Entry> iterable) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   // From List<Entry>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
   void sort([int compare(Entry a, Entry b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(Entry element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(Entry element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
 
-  Entry get first => this[0];
+  Entry get first {
+    if (this.length > 0) return this[0];
+    throw new StateError("No elements");
+  }
 
-  Entry get last => this[length - 1];
+  Entry get last {
+    if (this.length > 0) return this[this.length - 1];
+    throw new StateError("No elements");
+  }
+
+  Entry get single {
+    if (length == 1) return this[0];
+    if (length == 0) throw new StateError("No elements");
+    throw new StateError("More than one element");
+  }
+
+  Entry min([int compare(Entry a, Entry b)]) => _Collections.minInList(this, compare);
+
+  Entry max([int compare(Entry a, Entry b)]) => _Collections.maxInList(this, compare);
 
   Entry removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   Entry removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<Entry> from, [int startFrom]) {
@@ skipping 36 matching lines @@
   EntrySync operator[](int index) native "EntryArraySync_item_Callback";
 
   void operator[]=(int index, EntrySync value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<EntrySync> mixins.
   // EntrySync is the element type.
 
   // From Iterable<EntrySync>:
 
-  Iterator<EntrySync> iterator() {
+  Iterator<EntrySync> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<EntrySync>(this);
   }
 
-  // From Collection<EntrySync>:
-
-  void add(EntrySync value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addLast(EntrySync value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addAll(Collection<EntrySync> collection) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, EntrySync)) {
     return Collections.reduce(this, initialValue, combine);
   }
 
   bool contains(EntrySync element) => Collections.contains(this, element);
 
   void forEach(void f(EntrySync element)) => Collections.forEach(this, f);
 
-  Collection map(f(EntrySync element)) => Collections.map(this, [], f);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  Collection<EntrySync> filter(bool f(EntrySync element)) =>
-     Collections.filter(this, <EntrySync>[], f);
+  List mappedBy(f(EntrySync element)) => new MappedList<EntrySync, dynamic>(this, f);
+
+  Iterable<EntrySync> where(bool f(EntrySync element)) => new WhereIterable<EntrySync>(this, f);
 
   bool every(bool f(EntrySync element)) => Collections.every(this, f);
 
-  bool some(bool f(EntrySync element)) => Collections.some(this, f);
+  bool any(bool f(EntrySync element)) => Collections.any(this, f);
 
   bool get isEmpty => this.length == 0;
 
+  List<EntrySync> take(int n) => new ListView<EntrySync>(this, 0, n);
+
+  Iterable<EntrySync> takeWhile(bool test(EntrySync value)) {
+    return new TakeWhileIterable<EntrySync>(this, test);
+  }
+
+  List<EntrySync> skip(int n) => new ListView<EntrySync>(this, n, null);
+
+  Iterable<EntrySync> skipWhile(bool test(EntrySync value)) {
+    return new SkipWhileIterable<EntrySync>(this, test);
+  }
+
+  EntrySync firstMatching(bool test(EntrySync value), { EntrySync orElse() }) {
+    return Collections.firstMatching(this, test, orElse);
+  }
+
+  EntrySync lastMatching(bool test(EntrySync value), {EntrySync orElse()}) {
+    return Collections.lastMatchingInList(this, test, orElse);
+  }
+
+  EntrySync singleMatching(bool test(EntrySync value)) {
+    return Collections.singleMatching(this, test);
+  }
+
+  EntrySync elementAt(int index) {
+    return this[index];
+  }
+
+  // From Collection<EntrySync>:
+
+  void add(EntrySync value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addLast(EntrySync value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addAll(Iterable<EntrySync> iterable) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   // From List<EntrySync>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
   void sort([int compare(EntrySync a, EntrySync b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(EntrySync element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(EntrySync element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
 
-  EntrySync get first => this[0];
+  EntrySync get first {
+    if (this.length > 0) return this[0];
+    throw new StateError("No elements");
+  }
 
-  EntrySync get last => this[length - 1];
+  EntrySync get last {
+    if (this.length > 0) return this[this.length - 1];
+    throw new StateError("No elements");
+  }
+
+  EntrySync get single {
+    if (length == 1) return this[0];
+    if (length == 0) throw new StateError("No elements");
+    throw new StateError("More than one element");
+  }
+
+  EntrySync min([int compare(EntrySync a, EntrySync b)]) => _Collections.minInList(this, compare);
+
+  EntrySync max([int compare(EntrySync a, EntrySync b)]) => _Collections.maxInList(this, compare);
 
   EntrySync removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   EntrySync removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<EntrySync> from, [int startFrom]) {
@@ skipping 36 matching lines @@
   Gamepad operator[](int index) native "GamepadList_item_Callback";
 
   void operator[]=(int index, Gamepad value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<Gamepad> mixins.
   // Gamepad is the element type.
 
   // From Iterable<Gamepad>:
 
-  Iterator<Gamepad> iterator() {
+  Iterator<Gamepad> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<Gamepad>(this);
   }
 
-  // From Collection<Gamepad>:
-
-  void add(Gamepad value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addLast(Gamepad value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addAll(Collection<Gamepad> collection) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, Gamepad)) {
     return Collections.reduce(this, initialValue, combine);
   }
 
   bool contains(Gamepad element) => Collections.contains(this, element);
 
   void forEach(void f(Gamepad element)) => Collections.forEach(this, f);
 
-  Collection map(f(Gamepad element)) => Collections.map(this, [], f);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  Collection<Gamepad> filter(bool f(Gamepad element)) =>
-     Collections.filter(this, <Gamepad>[], f);
+  List mappedBy(f(Gamepad element)) => new MappedList<Gamepad, dynamic>(this, f);
+
+  Iterable<Gamepad> where(bool f(Gamepad element)) => new WhereIterable<Gamepad>(this, f);
 
   bool every(bool f(Gamepad element)) => Collections.every(this, f);
 
-  bool some(bool f(Gamepad element)) => Collections.some(this, f);
+  bool any(bool f(Gamepad element)) => Collections.any(this, f);
 
   bool get isEmpty => this.length == 0;
 
+  List<Gamepad> take(int n) => new ListView<Gamepad>(this, 0, n);
+
+  Iterable<Gamepad> takeWhile(bool test(Gamepad value)) {
+    return new TakeWhileIterable<Gamepad>(this, test);
+  }
+
+  List<Gamepad> skip(int n) => new ListView<Gamepad>(this, n, null);
+
+  Iterable<Gamepad> skipWhile(bool test(Gamepad value)) {
+    return new SkipWhileIterable<Gamepad>(this, test);
+  }
+
+  Gamepad firstMatching(bool test(Gamepad value), { Gamepad orElse() }) {
+    return Collections.firstMatching(this, test, orElse);
+  }
+
+  Gamepad lastMatching(bool test(Gamepad value), {Gamepad orElse()}) {
+    return Collections.lastMatchingInList(this, test, orElse);
+  }
+
+  Gamepad singleMatching(bool test(Gamepad value)) {
+    return Collections.singleMatching(this, test);
+  }
+
+  Gamepad elementAt(int index) {
+    return this[index];
+  }
+
+  // From Collection<Gamepad>:
+
+  void add(Gamepad value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addLast(Gamepad value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addAll(Iterable<Gamepad> iterable) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   // From List<Gamepad>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
   void sort([int compare(Gamepad a, Gamepad b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(Gamepad element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(Gamepad element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
 
-  Gamepad get first => this[0];
+  Gamepad get first {
+    if (this.length > 0) return this[0];
+    throw new StateError("No elements");
+  }
 
-  Gamepad get last => this[length - 1];
+  Gamepad get last {
+    if (this.length > 0) return this[this.length - 1];
+    throw new StateError("No elements");
+  }
+
+  Gamepad get single {
+    if (length == 1) return this[0];
+    if (length == 0) throw new StateError("No elements");
+    throw new StateError("More than one element");
+  }
+
+  Gamepad min([int compare(Gamepad a, Gamepad b)]) => _Collections.minInList(this, compare);
+
+  Gamepad max([int compare(Gamepad a, Gamepad b)]) => _Collections.maxInList(this, compare);
 
   Gamepad removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   Gamepad removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<Gamepad> from, [int startFrom]) {
@@ skipping 36 matching lines @@
   MediaStream operator[](int index) native "MediaStreamList_item_Callback";
 
   void operator[]=(int index, MediaStream value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<MediaStream> mixins.
   // MediaStream is the element type.
 
   // From Iterable<MediaStream>:
 
-  Iterator<MediaStream> iterator() {
+  Iterator<MediaStream> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<MediaStream>(this);
   }
 
-  // From Collection<MediaStream>:
-
-  void add(MediaStream value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addLast(MediaStream value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addAll(Collection<MediaStream> collection) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, MediaStream)) {
     return Collections.reduce(this, initialValue, combine);
   }
 
   bool contains(MediaStream element) => Collections.contains(this, element);
 
   void forEach(void f(MediaStream element)) => Collections.forEach(this, f);
 
-  Collection map(f(MediaStream element)) => Collections.map(this, [], f);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  Collection<MediaStream> filter(bool f(MediaStream element)) =>
-     Collections.filter(this, <MediaStream>[], f);
+  List mappedBy(f(MediaStream element)) => new MappedList<MediaStream, dynamic>(this, f);
+
+  Iterable<MediaStream> where(bool f(MediaStream element)) => new WhereIterable<MediaStream>(this, f);
 
   bool every(bool f(MediaStream element)) => Collections.every(this, f);
 
-  bool some(bool f(MediaStream element)) => Collections.some(this, f);
+  bool any(bool f(MediaStream element)) => Collections.any(this, f);
 
   bool get isEmpty => this.length == 0;
 
+  List<MediaStream> take(int n) => new ListView<MediaStream>(this, 0, n);
+
+  Iterable<MediaStream> takeWhile(bool test(MediaStream value)) {
+    return new TakeWhileIterable<MediaStream>(this, test);
+  }
+
+  List<MediaStream> skip(int n) => new ListView<MediaStream>(this, n, null);
+
+  Iterable<MediaStream> skipWhile(bool test(MediaStream value)) {
+    return new SkipWhileIterable<MediaStream>(this, test);
+  }
+
+  MediaStream firstMatching(bool test(MediaStream value), { MediaStream orElse() }) {
+    return Collections.firstMatching(this, test, orElse);
+  }
+
+  MediaStream lastMatching(bool test(MediaStream value), {MediaStream orElse()}) {
+    return Collections.lastMatchingInList(this, test, orElse);
+  }
+
+  MediaStream singleMatching(bool test(MediaStream value)) {
+    return Collections.singleMatching(this, test);
+  }
+
+  MediaStream elementAt(int index) {
+    return this[index];
+  }
+
+  // From Collection<MediaStream>:
+
+  void add(MediaStream value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addLast(MediaStream value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addAll(Iterable<MediaStream> iterable) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   // From List<MediaStream>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
   void sort([int compare(MediaStream a, MediaStream b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(MediaStream element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(MediaStream element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
 
-  MediaStream get first => this[0];
+  MediaStream get first {
+    if (this.length > 0) return this[0];
+    throw new StateError("No elements");
+  }
 
-  MediaStream get last => this[length - 1];
+  MediaStream get last {
+    if (this.length > 0) return this[this.length - 1];
+    throw new StateError("No elements");
+  }
+
+  MediaStream get single {
+    if (length == 1) return this[0];
+    if (length == 0) throw new StateError("No elements");
+    throw new StateError("More than one element");
+  }
+
+  MediaStream min([int compare(MediaStream a, MediaStream b)]) => _Collections.minInList(this, compare);
+
+  MediaStream max([int compare(MediaStream a, MediaStream b)]) => _Collections.maxInList(this, compare);
 
   MediaStream removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   MediaStream removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<MediaStream> from, [int startFrom]) {
@@ skipping 36 matching lines @@
   SpeechInputResult operator[](int index) native "SpeechInputResultList_item_Callback";
 
   void operator[]=(int index, SpeechInputResult value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<SpeechInputResult> mixins.
   // SpeechInputResult is the element type.
 
   // From Iterable<SpeechInputResult>:
 
-  Iterator<SpeechInputResult> iterator() {
+  Iterator<SpeechInputResult> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<SpeechInputResult>(this);
   }
 
-  // From Collection<SpeechInputResult>:
-
-  void add(SpeechInputResult value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addLast(SpeechInputResult value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addAll(Collection<SpeechInputResult> collection) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, SpeechInputResult)) {
     return Collections.reduce(this, initialValue, combine);
   }
 
   bool contains(SpeechInputResult element) => Collections.contains(this, element);
 
   void forEach(void f(SpeechInputResult element)) => Collections.forEach(this, f);
 
-  Collection map(f(SpeechInputResult element)) => Collections.map(this, [], f);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  Collection<SpeechInputResult> filter(bool f(SpeechInputResult element)) =>
-     Collections.filter(this, <SpeechInputResult>[], f);
+  List mappedBy(f(SpeechInputResult element)) => new MappedList<SpeechInputResult, dynamic>(this, f);
+
+  Iterable<SpeechInputResult> where(bool f(SpeechInputResult element)) => new WhereIterable<SpeechInputResult>(this, f);
 
   bool every(bool f(SpeechInputResult element)) => Collections.every(this, f);
 
-  bool some(bool f(SpeechInputResult element)) => Collections.some(this, f);
+  bool any(bool f(SpeechInputResult element)) => Collections.any(this, f);
 
   bool get isEmpty => this.length == 0;
 
+  List<SpeechInputResult> take(int n) => new ListView<SpeechInputResult>(this, 0, n);
+
+  Iterable<SpeechInputResult> takeWhile(bool test(SpeechInputResult value)) {
+    return new TakeWhileIterable<SpeechInputResult>(this, test);
+  }
+
+  List<SpeechInputResult> skip(int n) => new ListView<SpeechInputResult>(this, n, null);
+
+  Iterable<SpeechInputResult> skipWhile(bool test(SpeechInputResult value)) {
+    return new SkipWhileIterable<SpeechInputResult>(this, test);
+  }
+
+  SpeechInputResult firstMatching(bool test(SpeechInputResult value), { SpeechInputResult orElse() }) {
+    return Collections.firstMatching(this, test, orElse);
+  }
+
+  SpeechInputResult lastMatching(bool test(SpeechInputResult value), {SpeechInputResult orElse()}) {
+    return Collections.lastMatchingInList(this, test, orElse);
+  }
+
+  SpeechInputResult singleMatching(bool test(SpeechInputResult value)) {
+    return Collections.singleMatching(this, test);
+  }
+
+  SpeechInputResult elementAt(int index) {
+    return this[index];
+  }
+
+  // From Collection<SpeechInputResult>:
+
+  void add(SpeechInputResult value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addLast(SpeechInputResult value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addAll(Iterable<SpeechInputResult> iterable) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   // From List<SpeechInputResult>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
   void sort([int compare(SpeechInputResult a, SpeechInputResult b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(SpeechInputResult element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(SpeechInputResult element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
 
-  SpeechInputResult get first => this[0];
+  SpeechInputResult get first {
+    if (this.length > 0) return this[0];
+    throw new StateError("No elements");
+  }
 
-  SpeechInputResult get last => this[length - 1];
+  SpeechInputResult get last {
+    if (this.length > 0) return this[this.length - 1];
+    throw new StateError("No elements");
+  }
+
+  SpeechInputResult get single {
+    if (length == 1) return this[0];
+    if (length == 0) throw new StateError("No elements");
+    throw new StateError("More than one element");
+  }
+
+  SpeechInputResult min([int compare(SpeechInputResult a, SpeechInputResult b)]) => _Collections.minInList(this, compare);
+
+  SpeechInputResult max([int compare(SpeechInputResult a, SpeechInputResult b)]) => _Collections.maxInList(this, compare);
 
   SpeechInputResult removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   SpeechInputResult removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<SpeechInputResult> from, [int startFrom]) {
@@ skipping 36 matching lines @@
   SpeechRecognitionResult operator[](int index) native "SpeechRecognitionResultList_item_Callback";
 
   void operator[]=(int index, SpeechRecognitionResult value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<SpeechRecognitionResult> mixins.
   // SpeechRecognitionResult is the element type.
 
   // From Iterable<SpeechRecognitionResult>:
 
-  Iterator<SpeechRecognitionResult> iterator() {
+  Iterator<SpeechRecognitionResult> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<SpeechRecognitionResult>(this);
   }
 
-  // From Collection<SpeechRecognitionResult>:
-
-  void add(SpeechRecognitionResult value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addLast(SpeechRecognitionResult value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addAll(Collection<SpeechRecognitionResult> collection) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, SpeechRecognitionResult)) {
     return Collections.reduce(this, initialValue, combine);
   }
 
   bool contains(SpeechRecognitionResult element) => Collections.contains(this, element);
 
   void forEach(void f(SpeechRecognitionResult element)) => Collections.forEach(this, f);
 
-  Collection map(f(SpeechRecognitionResult element)) => Collections.map(this, [], f);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  Collection<SpeechRecognitionResult> filter(bool f(SpeechRecognitionResult element)) =>
-     Collections.filter(this, <SpeechRecognitionResult>[], f);
+  List mappedBy(f(SpeechRecognitionResult element)) => new MappedList<SpeechRecognitionResult, dynamic>(this, f);
+
+  Iterable<SpeechRecognitionResult> where(bool f(SpeechRecognitionResult element)) => new WhereIterable<SpeechRecognitionResult>(this, f);
 
   bool every(bool f(SpeechRecognitionResult element)) => Collections.every(this, f);
 
-  bool some(bool f(SpeechRecognitionResult element)) => Collections.some(this, f);
+  bool any(bool f(SpeechRecognitionResult element)) => Collections.any(this, f);
 
   bool get isEmpty => this.length == 0;
 
+  List<SpeechRecognitionResult> take(int n) => new ListView<SpeechRecognitionResult>(this, 0, n);
+
+  Iterable<SpeechRecognitionResult> takeWhile(bool test(SpeechRecognitionResult value)) {
+    return new TakeWhileIterable<SpeechRecognitionResult>(this, test);
+  }
+
+  List<SpeechRecognitionResult> skip(int n) => new ListView<SpeechRecognitionResult>(this, n, null);
+
+  Iterable<SpeechRecognitionResult> skipWhile(bool test(SpeechRecognitionResult value)) {
+    return new SkipWhileIterable<SpeechRecognitionResult>(this, test);
+  }
+
+  SpeechRecognitionResult firstMatching(bool test(SpeechRecognitionResult value), { SpeechRecognitionResult orElse() }) {
+    return Collections.firstMatching(this, test, orElse);
+  }
+
+  SpeechRecognitionResult lastMatching(bool test(SpeechRecognitionResult value), {SpeechRecognitionResult orElse()}) {
+    return Collections.lastMatchingInList(this, test, orElse);
+  }
+
+  SpeechRecognitionResult singleMatching(bool test(SpeechRecognitionResult value)) {
+    return Collections.singleMatching(this, test);
+  }
+
+  SpeechRecognitionResult elementAt(int index) {
+    return this[index];
+  }
+
+  // From Collection<SpeechRecognitionResult>:
+
+  void add(SpeechRecognitionResult value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addLast(SpeechRecognitionResult value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addAll(Iterable<SpeechRecognitionResult> iterable) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   // From List<SpeechRecognitionResult>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
   void sort([int compare(SpeechRecognitionResult a, SpeechRecognitionResult b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(SpeechRecognitionResult element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(SpeechRecognitionResult element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
 
-  SpeechRecognitionResult get first => this[0];
+  SpeechRecognitionResult get first {
+    if (this.length > 0) return this[0];
+    throw new StateError("No elements");
+  }
 
-  SpeechRecognitionResult get last => this[length - 1];
+  SpeechRecognitionResult get last {
+    if (this.length > 0) return this[this.length - 1];
+    throw new StateError("No elements");
+  }
+
+  SpeechRecognitionResult get single {
+    if (length == 1) return this[0];
+    if (length == 0) throw new StateError("No elements");
+    throw new StateError("More than one element");
+  }
+
+  SpeechRecognitionResult min([int compare(SpeechRecognitionResult a, SpeechRecognitionResult b)]) => _Collections.minInList(this, compare);
+
+  SpeechRecognitionResult max([int compare(SpeechRecognitionResult a, SpeechRecognitionResult b)]) => _Collections.maxInList(this, compare);
 
   SpeechRecognitionResult removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   SpeechRecognitionResult removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<SpeechRecognitionResult> from, [int startFrom]) {
@@ skipping 36 matching lines @@
   StyleSheet operator[](int index) native "StyleSheetList_item_Callback";
 
   void operator[]=(int index, StyleSheet value) {
     throw new UnsupportedError("Cannot assign element of immutable List.");
   }
   // -- start List<StyleSheet> mixins.
   // StyleSheet is the element type.
 
   // From Iterable<StyleSheet>:
 
-  Iterator<StyleSheet> iterator() {
+  Iterator<StyleSheet> get iterator {
     // Note: NodeLists are not fixed size. And most probably length shouldn't
     // be cached in both iterator _and_ forEach method. For now caching it
     // for consistency.
     return new FixedSizeListIterator<StyleSheet>(this);
   }
 
-  // From Collection<StyleSheet>:
-
-  void add(StyleSheet value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addLast(StyleSheet value) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
-  void addAll(Collection<StyleSheet> collection) {
-    throw new UnsupportedError("Cannot add to immutable List.");
-  }
-
   dynamic reduce(dynamic initialValue, dynamic combine(dynamic, StyleSheet)) {
     return Collections.reduce(this, initialValue, combine);
   }
 
   bool contains(StyleSheet element) => Collections.contains(this, element);
 
   void forEach(void f(StyleSheet element)) => Collections.forEach(this, f);
 
-  Collection map(f(StyleSheet element)) => Collections.map(this, [], f);
+  String join([String separator]) => Collections.joinList(this, separator);
 
-  Collection<StyleSheet> filter(bool f(StyleSheet element)) =>
-     Collections.filter(this, <StyleSheet>[], f);
+  List mappedBy(f(StyleSheet element)) => new MappedList<StyleSheet, dynamic>(this, f);
+
+  Iterable<StyleSheet> where(bool f(StyleSheet element)) => new WhereIterable<StyleSheet>(this, f);
 
   bool every(bool f(StyleSheet element)) => Collections.every(this, f);
 
-  bool some(bool f(StyleSheet element)) => Collections.some(this, f);
+  bool any(bool f(StyleSheet element)) => Collections.any(this, f);
 
   bool get isEmpty => this.length == 0;
 
+  List<StyleSheet> take(int n) => new ListView<StyleSheet>(this, 0, n);
+
+  Iterable<StyleSheet> takeWhile(bool test(StyleSheet value)) {
+    return new TakeWhileIterable<StyleSheet>(this, test);
+  }
+
+  List<StyleSheet> skip(int n) => new ListView<StyleSheet>(this, n, null);
+
+  Iterable<StyleSheet> skipWhile(bool test(StyleSheet value)) {
+    return new SkipWhileIterable<StyleSheet>(this, test);
+  }
+
+  StyleSheet firstMatching(bool test(StyleSheet value), { StyleSheet orElse() }) {
+    return Collections.firstMatching(this, test, orElse);
+  }
+
+  StyleSheet lastMatching(bool test(StyleSheet value), {StyleSheet orElse()}) {
+    return Collections.lastMatchingInList(this, test, orElse);
+  }
+
+  StyleSheet singleMatching(bool test(StyleSheet value)) {
+    return Collections.singleMatching(this, test);
+  }
+
+  StyleSheet elementAt(int index) {
+    return this[index];
+  }
+
+  // From Collection<StyleSheet>:
+
+  void add(StyleSheet value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addLast(StyleSheet value) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
+  void addAll(Iterable<StyleSheet> iterable) {
+    throw new UnsupportedError("Cannot add to immutable List.");
+  }
+
   // From List<StyleSheet>:
   void set length(int value) {
     throw new UnsupportedError("Cannot resize immutable List.");
   }
 
   void clear() {
     throw new UnsupportedError("Cannot clear immutable List.");
   }
 
   void sort([int compare(StyleSheet a, StyleSheet b)]) {
     throw new UnsupportedError("Cannot sort immutable List.");
   }
 
   int indexOf(StyleSheet element, [int start = 0]) =>
       Lists.indexOf(this, element, start, this.length);
 
   int lastIndexOf(StyleSheet element, [int start]) {
     if (start == null) start = length - 1;
     return Lists.lastIndexOf(this, element, start);
   }
 
-  StyleSheet get first => this[0];
+  StyleSheet get first {
+    if (this.length > 0) return this[0];
+    throw new StateError("No elements");
+  }
 
-  StyleSheet get last => this[length - 1];
+  StyleSheet get last {
+    if (this.length > 0) return this[this.length - 1];
+    throw new StateError("No elements");
+  }
+
+  StyleSheet get single {
+    if (length == 1) return this[0];
+    if (length == 0) throw new StateError("No elements");
+    throw new StateError("More than one element");
+  }
+
+  StyleSheet min([int compare(StyleSheet a, StyleSheet b)]) => _Collections.minInList(this, compare);
+
+  StyleSheet max([int compare(StyleSheet a, StyleSheet b)]) => _Collections.maxInList(this, compare);
 
   StyleSheet removeAt(int pos) {
     throw new UnsupportedError("Cannot removeAt on immutable List.");
   }
 
   StyleSheet removeLast() {
     throw new UnsupportedError("Cannot removeLast on immutable List.");
   }
 
   void setRange(int start, int rangeLength, List<StyleSheet> from, [int startFrom]) {
@@ skipping 173 matching lines @@
  */
 class _DataAttributeMap implements Map<String, String> {
 
   final Map<String, String> $dom_attributes;
 
   _DataAttributeMap(this.$dom_attributes);
 
   // interface Map
 
   // TODO: Use lazy iterator when it is available on Map.
-  bool containsValue(String value) => values.some((v) => v == value);
+  bool containsValue(String value) => values.any((v) => v == value);
 
   bool containsKey(String key) => $dom_attributes.containsKey(_attr(key));
 
   String operator [](String key) => $dom_attributes[_attr(key)];
 
   void operator []=(String key, value) {
     $dom_attributes[_attr(key)] = '$value';
   }
 
   String putIfAbsent(String key, String ifAbsent()) =>
@@ skipping 202 matching lines @@
     return result;
   }
 
   /**
    * Returns [:true:] if classes cannot be added or removed from this
    * [:CssClassSet:].
    */
   bool get frozen => false;
 
   // interface Iterable - BEGIN
-  Iterator<String> iterator() => readClasses().iterator();
+  Iterator<String> get iterator => readClasses().iterator;
   // interface Iterable - END
 
   // interface Collection - BEGIN
   void forEach(void f(String element)) {
     readClasses().forEach(f);
   }
 
-  Collection map(f(String element)) => readClasses().map(f);
+  String join([String separator]) => readClasses().join(separator);
 
-  Collection<String> filter(bool f(String element)) => readClasses().filter(f);
+  Iterable mappedBy(f(String element)) => readClasses().mappedBy(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 any(bool f(String element)) => readClasses().any(f);
 
   bool get isEmpty => readClasses().isEmpty;
 
   int get length =>readClasses().length;
 
   dynamic reduce(dynamic initialValue,
       dynamic combine(dynamic previousValue, String element)) {
     return readClasses().reduce(initialValue, combine);
   }
   // interface Collection - END
 
   // interface Set - BEGIN
   bool contains(String value) => readClasses().contains(value);
 
   void add(String value) {
     // TODO - figure out if we need to do any validation here
     // or if the browser natively does enough
     _modify((s) => s.add(value));
   }
 
   bool remove(String value) {
     Set<String> s = readClasses();
     bool result = s.remove(value);
     writeClasses(s);
     return result;
   }
 
-  void addAll(Collection<String> collection) {
+  void addAll(Iterable<String> iterable) {
     // TODO - see comment above about validation
-    _modify((s) => s.addAll(collection));
+    _modify((s) => s.addAll(iterable));
   }
 
-  void removeAll(Collection<String> collection) {
-    _modify((s) => s.removeAll(collection));
+  void removeAll(Iterable<String> iterable) {
+    _modify((s) => s.removeAll(iterable));
   }
 
   bool isSubsetOf(Collection<String> collection) =>
     readClasses().isSubsetOf(collection);
 
   bool containsAll(Collection<String> collection) =>
     readClasses().containsAll(collection);
 
   Set<String> intersection(Collection<String> other) =>
     readClasses().intersection(other);
@@ skipping 182 matching lines @@
     if (_callbacks.length == 0) {
       // If we have no listeners, don't bother keeping track of keypresses.
       _target.on.keyDown.remove(_keyDown);
       _target.on.keyPress.remove(_keyPress);
       _target.on.keyUp.remove(_keyUp);
     }
   }
 
   /** Determine if caps lock is one of the currently depressed keys. */
   bool get _capsLockOn =>
-      _keyDownList.some((var element) => element.keyCode == KeyCode.CAPS_LOCK);
+      _keyDownList.any((var element) => element.keyCode == KeyCode.CAPS_LOCK);
 
   /**
    * Given the previously recorded keydown key codes, see if we can determine
    * the keycode of this keypress [event]. (Generally browsers only provide
    * charCode information for keypress events, but with a little
    * reverse-engineering, we can also determine the keyCode.) Returns
    * KeyCode.UNKNOWN if the keycode could not be determined.
    */
   int _determineKeyCodeForKeypress(KeyboardEvent event) {
     // Note: This function is a work in progress. We'll expand this function
@@ skipping 208 matching lines @@
     // pressed, given previous keydown information.
     e._shadowKeyCode = _determineKeyCodeForKeypress(e);
 
     // Correct the key value for certain browser-specific quirks.
     if (e._shadowKeyIdentifier != null &&
         _keyIdentifier.containsKey(e._shadowKeyIdentifier)) {
       // This is needed for Safari Windows because it currently doesn't give a
       // keyCode/which for non printable keys.
       e._shadowKeyCode = _keyIdentifier[e._shadowKeyIdentifier];
     }
-    e._shadowAltKey = _keyDownList.some((var element) => element.altKey);
+    e._shadowAltKey = _keyDownList.any((var element) => element.altKey);
     _dispatch(e);
   }
 
   /** Handle keyup events. */
   void processKeyUp(KeyboardEvent event) {
     var e = new KeyEvent(event);
     KeyboardEvent toRemove = null;
     for (var key in _keyDownList) {
       if (key.keyCode == e.keyCode) {
         toRemove = key;
       }
     }
     if (toRemove != null) {
-      _keyDownList = _keyDownList.filter((element) => element != toRemove);
+      _keyDownList =
+          _keyDownList.where((element) => element != toRemove).toList();
     } else if (_keyDownList.length > 0) {
       // This happens when we've reached some international keyboard case we
       // haven't accounted for or we haven't correctly eliminated all browser
       // inconsistencies. Filing bugs on when this is reached is welcome!
       _keyDownList.removeLast();
     }
     _dispatch(e);
   }
 }
 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
@@ skipping 1251 matching lines @@
     return _deserialize(result);
   }
 
   static _call(int isolateId, int portId, var message) {
     var target = 'dart-port-$isolateId-$portId';
     // TODO(vsm): Make this re-entrant.
     // TODO(vsm): Set this up set once, on the first call.
     var source = '$target-result';
     var result = null;
     var listener = (Event e) {
-      result = JSON.parse(_getPortSyncEventData(e));
+      result = json.parse(_getPortSyncEventData(e));
     };
     window.on[source].add(listener);
     _dispatchEvent(target, [source, message]);
     window.on[source].remove(listener);
     return result;
   }
 }
 
 // The receiver is in the same Dart isolate, compiled to JS.
 class _LocalSendPortSync implements SendPortSync {
@@ skipping 51 matching lines @@
   }
 
   static String _getListenerName(isolateId, portId) =>
       'dart-port-$isolateId-$portId';
   String get _listenerName => _getListenerName(_isolateId, _portId);
 
   void receive(callback(var message)) {
     _callback = callback;
     if (_listener == null) {
       _listener = (Event e) {
-        var data = JSON.parse(_getPortSyncEventData(e));
+        var data = json.parse(_getPortSyncEventData(e));
         var replyTo = data[0];
         var message = _deserialize(data[1]);
         var result = _callback(message);
         _dispatchEvent(replyTo, _serialize(result));
       };
       window.on[_listenerName].add(_listener);
     }
   }
 
   void close() {
@@ skipping 10 matching lines @@
       return _portMap[portId].toSendPort();
     } else {
       return new _RemoteSendPortSync(isolateId, portId);
     }
   }
 }
 
 get _isolateId => ReceivePortSync._isolateId;
 
 void _dispatchEvent(String receiver, var message) {
-  var event = new CustomEvent(receiver, false, false, JSON.stringify(message));
+  var event = new CustomEvent(receiver, false, false, json.stringify(message));
   window.$dom_dispatchEvent(event);
 }
 
 String _getPortSyncEventData(CustomEvent event) => event.detail;
 // 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.
 
 
 typedef Object ComputeValue();
@@ skipping 274 matching lines @@
     // TODO(floitsch): we are losing the generic type.
     return ['list', id, jsArray];
   }
 
   visitMap(Map map) {
     int copyId = _visited[map];
     if (copyId != null) return ['ref', copyId];
 
     int id = _nextFreeRefId++;
     _visited[map] = id;
-    var keys = _serializeList(map.keys);
-    var values = _serializeList(map.values);
+    var keys = _serializeList(map.keys.toList());
+    var values = _serializeList(map.values.toList());
     // TODO(floitsch): we are losing the generic type.
     return ['map', id, keys, values];
   }
 
   _serializeList(List list) {
     int len = list.length;
-    var result = new List(len);
+    var result = new List.fixedLength(len);
     for (int i = 0; i < len; i++) {
       result[i] = _dispatch(list[i]);
     }
     return result;
   }
 }
 
 /** Deserializes arrays created with [_Serializer]. */
 abstract class _Deserializer {
   Map<int, dynamic> _deserialized;
@@ skipping 85 matching lines @@
     target.$dom_removeEventListener(type, listener, useCapture);
   }
 
 }
 // 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.
 
 
 // Iterator for arrays with fixed size.
-class FixedSizeListIterator<T> extends _VariableSizeListIterator<T> {
+class FixedSizeListIterator<T> implements Iterator<T> {
+  final List<T> _array;
+  final int _length;  // Cache array length for faster access.
+  int _position;
+  T _current;
+  
   FixedSizeListIterator(List<T> array)
-      : super(array),
+      : _array = array,
+        _position = -1,
         _length = array.length;
 
-  bool get hasNext => _length > _pos;
+  bool moveNext() {
+    int nextPosition = _position + 1;
+    if (nextPosition < _length) {
+      _current = _array[nextPosition];
+      _position = nextPosition;
+      return true;
+    }
+    _current = null;
+    _position = _length;
+    return false;
+  }
 
-  final int _length;  // Cache array length for faster access.
+  T get current => _current;
 }
 
 // Iterator for arrays with variable size.
 class _VariableSizeListIterator<T> implements Iterator<T> {
+  final List<T> _array;
+  int _position;
+  T _current;
+
   _VariableSizeListIterator(List<T> array)
       : _array = array,
-        _pos = 0;
+        _position = -1;
 
-  bool get hasNext => _array.length > _pos;
-
-  T next() {
-    if (!hasNext) {
-      throw new StateError("No more elements");
+  bool moveNext() {
+    int nextPosition = _position + 1;
+    if (nextPosition < _array.length) {
+      _current = _array[nextPosition];
+      _position = nextPosition;
+      return true;
     }
-    return _array[_pos++];
+    _current = null;
+    _position = _array.length;
+    return false;
   }
 
-  final List<T> _array;
-  int _pos;
+  T get current => _current;
 }
 // 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.
 
 
 // This API is exploratory.
 spawnDomFunction(Function topLevelFunction) => _Utils.spawnDomFunctionImpl(topLevelFunction);
 
 // testRunner implementation.
@@ skipping 20 matching lines @@
 }
 // 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 _Utils {
   static List convertToList(List list) {
     // FIXME: [possible optimization]: do not copy the array if Dart_IsArray is fine w/ it.
     final length = list.length;
-    List result = new List(length);
+    List result = new List.fixedLength(length);
     result.setRange(0, length, list);
     return result;
   }
 
   static List convertMapToList(Map map) {
     List result = [];
     map.forEach((k, v) => result.addAll([k, v]));
     return result;
   }
 
@@ skipping 85 matching lines @@
   bool get isEmpty => Maps.isEmpty(this);
 }
 
 get _printClosure => (s) {
   try {
     window.console.log(s);
   } catch (_) {
     _Utils.print(s);
   }
 };