Update Set.difference to take a Set<Object>.

lib/src/wrappers.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.
 
 import "dart:collection";
 import "dart:math" as math;
 
 import "typed_wrappers.dart";
 import "unmodifiable_wrappers.dart";
 
@@ skipping 235 matching lines @@
   void addAll(Iterable<E> elements) {
     _setBase.addAll(elements);
   }
 
   void clear() {
     _setBase.clear();
   }
 
   bool containsAll(Iterable<Object> other) => _setBase.containsAll(other);
 
-  Set<E> difference(Set<E> other) => _setBase.difference(other);
+  Set<E> difference(Set<Object> other) => _setBase.difference(other);
 
   Set<E> intersection(Set<Object> other) => _setBase.intersection(other);
 
   E lookup(Object element) => _setBase.lookup(element);
 
   bool remove(Object value) => _setBase.remove(value);
 
   void removeAll(Iterable<Object> elements) {
     _setBase.removeAll(elements);
   }
@@ skipping 162 matching lines @@
 
   bool containsAll(Iterable<Object> other) => other.every(contains);
 
   /// Returns a new set with the the elements of [this] that are not in [other].
   ///
   /// That is, the returned set contains all the elements of this [Set] that are
   /// not elements of [other] according to `other.contains`.
   ///
   /// Note that the returned set will use the default equality operation, which
   /// may be different than the equality operation [this] uses.
-  Set<E> difference(Set<E> other) =>
+  Set<E> difference(Set<Object> other) =>
       where((element) => !other.contains(element)).toSet();
 
   /// Returns a new set which is the intersection between [this] and [other].
   ///
   /// That is, the returned set contains all the elements of this [Set] that are
   /// also elements of [other] according to `other.contains`.
   ///
   /// Note that the returned set will use the default equality operation, which
   /// may be different than the equality operation [this] uses.
   Set<E> intersection(Set<Object> other) => where(other.contains).toSet();
@@ skipping 80 matching lines @@
 
   bool containsAll(Iterable<Object> other) => other.every(contains);
 
   /// Returns a new set with the the elements of [this] that are not in [other].
   ///
   /// That is, the returned set contains all the elements of this [Set] that are
   /// not elements of [other] according to `other.contains`.
   ///
   /// Note that the returned set will use the default equality operation, which
   /// may be different than the equality operation [this] uses.
-  Set<V> difference(Set<V> other) =>
+  Set<V> difference(Set<Object> other) =>
       where((element) => !other.contains(element)).toSet();
 
   /// Returns a new set which is the intersection between [this] and [other].
   ///
   /// That is, the returned set contains all the elements of this [Set] that are
   /// also elements of [other] according to `other.contains`.
   ///
   /// Note that the returned set will use the default equality operation, which
   /// may be different than the equality operation [this] uses.
   Set<V> intersection(Set<Object> other) => where(other.contains).toSet();
@@ skipping 46 matching lines @@
 
   /// Returns a new set which contains all the elements of [this] and [other].
   ///
   /// That is, the returned set contains all the elements of this [Set] and all
   /// the elements of [other].
   ///
   /// Note that the returned set will use the default equality operation, which
   /// may be different than the equality operation [this] uses.
   Set<V> union(Set<V> other) => toSet()..addAll(other);
 }