anchor.diff:  
     void shuffle([Random random]) {
       _syncDelegate();
  -    (_delegate as List).shuffle(random);
  +    _delegate.shuffle(random);
     }
   
     void sort([int compare(V a, V b)]) {
       _syncDelegate();
  -    (_delegate as List).sort(compare);
  +    _delegate.sort(compare);
     }
   
     List<V> sublist(int start, [int end]) {
       _syncDelegate();
  -    return (_delegate as List).sublist(start, end);
  +    return _delegate.sublist(start, end);
     }
   }
   
  -class _WrappedSet<K, V> extends _WrappedIterable<K, V> implements Set<V> {
  +class _WrappedSet<K, V> extends _WrappedIterable<K, V, Set<V>> implements Set<V> {
     _WrappedSet(Map<K, Iterable<V>> map, K key, Iterable<V> delegate) :
         super(map, key, delegate);
   
     bool add(V value) {
       _syncDelegate();
       var wasEmpty = _delegate.isEmpty;
  -    bool wasAdded = (_delegate as Set).add(value);
  +    bool wasAdded = _delegate.add(value);
       if (wasEmpty) _addToMap();
       return wasAdded;
     }
  
positive.code:  * A multimap implementation that uses [Set]s to store the values associated
   * with each key.
   */
  class SetMultimap<K, V> extends _BaseMultimap<K, V> {
    SetMultimap() : super();
    Set<V> _create() => new Set<V>();
    Set<V> _wrap(Object key, Iterable<V> iterable) =>
        new _WrappedSet(_map, key, iterable);
    Set<V> operator [](Object key) => super[key];
  
negative.code:  * A [Map] that delegates its operations to an underlying multimap.
   */
  class _WrappedMap<K, V, C extends Iterable<V>> implements Map<K, C> {
    final _BaseMultimap<K, V, C> _multimap;
  
    _WrappedMap(this._multimap);
  
  