Add Set.union, Set.difference. Change Set methods to expect Set.

sdk/lib/collection/hash_set.dart

 // Copyright (c) 2013, 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;
 
 class HashSet<E> extends Collection<E> implements Set<E> {
   static const int _INITIAL_CAPACITY = 8;
   final _HashTable<E> _table;
 
@@ skipping 68 matching lines @@
 
   void retainMatching(bool test(E element)) {
     _filterMatching(test, false);
   }
 
   void clear() {
     _table._clear();
   }
 
   // Set.
-  bool isSubsetOf(Collection<E> collection) {
-    Set otherSet;
-    if (collection is Set) {
-      otherSet = collection;
-    } else {
-      otherSet = collection.toSet();
+  bool isSubsetOf(Set<E> other) {

[floitsch, 2013/03/12 16:25:00]

bool isSubsetOf(Set<E> other) => other.containsAll(this);

And if there is a reason not to do this, explain.

[Lasse Reichstein Nielsen, 2013/03/13 13:01:42]

The resason is the usual one: I don't want public, overridable methods to call
each other. I'll make a method in IterableMixinOverride (SetMixinOverride?) that
they can both use.

+    if (length > other.length) return false;
+    for (E element in this) {
+      if (!other.contains(element)) return false;
     }
-    return otherSet.containsAll(this);
+    return true;
   }
 
-  bool containsAll(Collection<E> collection) {
-    for (E element in collection) {
+  bool containsAll(Set<E> other) {
+    if (other.length > length) return false;
+    for (E element in other) {
       if (!this.contains(element)) return false;
     }
     return true;
   }
 
-  Set<E> intersection(Collection<E> other) {
+  Set<E> intersection(Set<E> other) {
+    Set<E> smaller;
+    Set<E> larger;
+    if (length < other.length) {
+      smaller = this;
+      larger = other;
+    } else {
+      smaller = other;
+      larger = this;
+    }
     Set<E> result = new HashSet<E>();
-    for (E element in other) {
-      if (this.contains(element)) {
+    for (E element in smaller) {
+      if (larger.contains(element)) {
         result.add(element);
       }
     }
+    return result;
+  }
+
+  Set<E> union(Set<E> other) {
+    Set<E> result = new HashSet<E>();
+    result.addAll(this);
+    result.addAll(other);
+    return result;
+  }
+
+  Set<E> difference(Set<E> other) {
+    Set<E> result = new HashSet<E>();
+    for (E element in this) {
+      if (!other.contains(element)) {
+        result.add(element);
+      }
+    }
     return result;
   }
 
   String toString() =>  Collections.collectionToString(this);
 }