Remove Collection, Collections and clean up List/Set/Queue implementations of retain/remove.

sdk/lib/core/list.dart

 // 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.
 
 part of dart.core;
 
 /**
  * A [List] is an indexable collection with a length.
  *
  * A `List` implementation can choose not to support all methods
@@ skipping 16 matching lines @@
  *    fixedLengthList[0] = 87;
  *    var growableList = [1, 2];
  *    growableList.length = 0;
  *    growableList.add(499);
  *    growableList[0] = 87;
  *    var unmodifiableList = const [1, 2];
  *    unmodifiableList.length = 0;  // throws.
  *    unmodifiableList.add(499);  // throws
  *    unmodifiableList[0] = 87;  // throws.
  */
-abstract class List<E> implements Collection<E> {
+abstract class List<E> implements Iterable<E> {
   /**
    * Creates a list of the given [length].
    *
    * The list is a fixed-length list if [length] is provided, and an empty
    * growable list if [length] is omitted.
    */
   external factory List([int length]);
 
   /**
    * Creates a fixed-length list of the given [length] where each entry
    * contains [fill].
    */
   external factory List.filled(int length, E fill);
 
   /**
-   * *Deprecated*: Use `new List(count)` instead.
-   */
-  @deprecated
-  factory List.fixedLength(int count, { E fill }) {
-    List<E> result = new List(count);
-    if (fill != null) {
-      for (int i = 0; i < count; i++) result[i] = fill;
-    }
-    return result;
-  }
-
-  /**
    * Creates an list with the elements of [other]. The order in
    * the list will be the order provided by the iterator of [other].
    *
    * The returned list is growable if [growable] is true, otherwise it's
    * a fixed length list.
    */
   factory List.from(Iterable other, { bool growable: true }) {
     List<E> list = new List<E>();
     for (E e in other) {
       list.add(e);
@@ skipping 119 matching lines @@
    *
    * This increases the length of the list by one and shifts all later elements
    * towards the end of the list.
    *
    * It is an error if the [index] does not point inside the list or at the
    * position after the last element.
    */
   void insert(int index, E element);
 
   /**
+   * Removes [value] from the list. Returns true if [value] was
+   * in the list. Returns false otherwise. The method has no effect
+   * if [value] value was not in the list.
+   */
+  bool remove(Object value);
+
+  /**
    * Removes the element at position [index] from the list.
    *
    * This reduces the length of the list by one and moves all later elements
    * down by one position.
    * Returns the removed element.
    * Throws an [ArgumentError] if [index] is not an [int].
    * Throws an [RangeError] if the [index] does not point inside
    * the list.
    * Throws an [UnsupportedError], and doesn't remove the element,
    * if the length of the list cannot be changed.
    */
   E removeAt(int index);
 
   /**
    * Pops and returns the last element of the list.
    * Throws a [UnsupportedError] if the length of the
    * list cannot be changed.
    */
   E removeLast();
 
   /**
+   * Removes all elements of this list that satisfy [test].
+   *
+   * An elements [:e:] satisfies [test] if [:test(e):] is true.
+   */
+  void removeWhere(bool test(E element));
+
+  /**
+   * Removes all elements of this list that fail to satisfy [test].
+   *
+   * An elements [:e:] satisfies [test] if [:test(e):] is true.
+   */
+  void retainWhere(bool test(E element));
+
+  /**
    * Returns a new list containing the elements from [start] to [end].
    *
    * If [end] is omitted, the [length] of the list is used.
    *
    * It is an error if [start] or [end] are not list indices for this list,
    * or if [end] is before [start].
    */
   List<E> sublist(int start, [int end]);
 
   /**
@@ skipping 55 matching lines @@
   void insertRange(int start, int length, [E fill]);
 
   /**
    * Returns an unmodifiable [Map] view of `this`.
    *
    * It has the indices of this list as keys, and the corresponding elements
    * as values.
    */
   Map<int, E> asMap();
 }