anchor.diff:  
     core.bool containsKey(K key) => _wrapped.containsKey(key);
   
  +  Map<dynamic, V> mapKeys(f(K key)) => _wrapped.mapKeys(f);
  +
  +  Map<K, dynamic> mapValues(f(V value)) => _wrapped.mapValues(f);
  +
  +  void put(Tuple2<K, V> tuple) => _wrapped.put(tuple);
  +
  +  Map<K, V> defaulting(V defaultFn(K key)) =>
  +      new DefaultMap(defaultFn, map: this);
  +
     core.bool operator ==(other) {
       if (other is! DefaultMap) return false;
       return _wrapped == other._wrapped;
  
positive.code:     });
    }
  
    core.Map<K, V> toMap() {
      var result = new Map<K, V>();
      this.forEach((tuple) => result[tuple.v1] = tuple.v2);
  
negative.code:   /** Checks if the two maps have the same content */
    core.bool sameContent(Map<K, V> other);
  
    /** Maps the keys of this map with a mapping function. Returns a new map. */
    Map<dynamic, V> mapKeys(f(K key));
  
    /** Maps the values of this map with a mapping function. Returns a new map. */
    Map<K, dynamic> mapValues(f(V value));
  
    /** Inserts the tuple into this map. */
    void put(Tuple2<K, V> tuple);
  
    /** Retrieves the key or evaluates orElse, inserts and returns it */
    V getOrElseUpdate(K key, orElse);
  
    /** Gets the value associated with the key or evaluates orElse and
     * returns it */
    V getOrElse(K key, orElse);
  
    /** Returns this map with the specified default function. */
    Map<K, V> defaulting(V defaultFn(K key));
  }
  
  class WrappedMap<K, V> extends core.Object with IterableMixin<Tuple2<K, V>>
  