Make List.remove return boolean.

sdk/lib/collection/queue.dart

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart.collection;
 
 /**
  * A [Queue] is a collection that can be manipulated at both ends. One
  * can iterate over the elements of a queue through [forEach] or with
  * an [Iterator].
@@ skipping 32 matching lines @@
    * Adds [value] at the end of the queue.
    */
   void addLast(E value);
 
   /**
    * Adds [value] at the end of the queue.
    */
   void add(E value);
 
   /**
+   * Remove a single instance of [value] from the queue.
+   *
+   * Returns `true` if a value was removed, or `false` if the queue
+   * contained no element equal to [value].
+   */
+  bool remove(Object object);
+
+
+  /**
    * Adds all elements of [iterable] at the end of the queue. The
    * length of the queue is extended by the length of [iterable].
    */
   void addAll(Iterable<E> iterable);
 
   /**
    * Removes all elements in the queue. The size of the queue becomes zero.
    */
   void clear();
 }
@@ skipping 142 matching lines @@
     _elementCount--;
     return result;
   }
 
   E removeFirst() {
     E result = _sentinel._next.remove();
     _elementCount--;
     return result;
   }
 
-  void remove(Object o) {
+  bool remove(Object o) {
     DoubleLinkedQueueEntry<E> entry = firstEntry();
     while (!identical(entry, _sentinel)) {
       if (entry.element == o) {
         entry.remove();
         _elementCount--;
-        return;
+        return true;
       }
       entry = entry._next;
     }
+    return false;
   }
 
-  void retainAll(Iterable elements) {
-    _filterIterable(elements, true);
-  }
-
-  void removeAll(Iterable elements) {
-    _filterIterable(elements, false);
-  }
-
-  void _filterIterable(Iterable elements, bool retainMatching) {
-    Set elementSet;
-    if (elements is Set) {
-      elementSet = elements;
-    } else {
-      elementSet = elements.toSet();
-    }
-    _filter(elementSet.contains, retainMatching);
-  }
-
-  void _filter(bool test(E element), bool retainMatching) {
+  void _filter(bool test(E element), bool removeMatching) {
     DoubleLinkedQueueEntry<E> entry = firstEntry();
     while (!identical(entry, _sentinel)) {
       DoubleLinkedQueueEntry<E> next = entry._next;
-      if (test(entry.element) != retainMatching) {
+      if (identical(removeMatching, test(entry.element))) {
         entry.remove();
         _elementCount--;
       }
       entry = next;
     }
   }
 
   void removeWhere(bool test(E element)) {
+    _filter(test, true);
+  }
+
+  void retainWhere(bool test(E element)) {
     _filter(test, false);
   }
 
-  void retainWhere(bool test(E element)) {
-    _filter(test, true);
-  }
-
   E get first {
     return _sentinel._next.element;
   }
 
   E get last {
     return _sentinel._previous.element;
   }
 
   E get single {
     // Note that this also covers the case where the queue is empty.
@@ skipping 197 matching lines @@
           _table.setRange(0, preSpace, list, endSpace);
           _tail = preSpace;
         }
       }
       _modificationCount++;
     } else {
       for (E element in elements) _add(element);
     }
   }
 
-  void remove(Object object) {
+  bool remove(Object object) {
     for (int i = _head; i != _tail; i = (i + 1) & (_table.length - 1)) {
       E element = _table[i];
       if (element == object) {
         _remove(i);
-        return;
+        _modificationCount++;
+        return true;
       }
     }
-    _modificationCount++;
+    return false;
   }
 
   void _filterWhere(bool test(E element), bool removeMatching) {
     int index = _head;
     int modificationCount = _modificationCount;
     int i = _head;
     while (i != _tail) {
       E element = _table[i];
-      bool remove = (test(element) == removeMatching);
+      bool remove = identical(removeMatching, test(element));
       _checkModification(modificationCount);
       if (remove) {
         i = _remove(i);
         modificationCount = ++_modificationCount;
       } else {
         i = (i + 1) & (_table.length - 1);
       }
     }
   }
 
@@ skipping 198 matching lines @@
     _queue._checkModification(_modificationCount);
     if (_position == _end) {
       _current = null;
       return false;
     }
     _current = _queue._table[_position];
     _position = (_position + 1) & (_queue._table.length - 1);
     return true;
   }
 }