anchor.diff:      });
     }
   
  +  Map<dynamic, V> mapKeys(f(K key)) {
  +    var result = new WrappedMap<dynamic, V>();
  +    forEach((Tuple2<K, V> tuple) {
  +      var mappedKey = f(tuple.v1);
  +      result[mappedKey] = tuple.v2;
  +    });
  +    return result;
  +  }
  +
  +  Map<dynamic, V> mapValues(f(V value)) {
  +    var result = new WrappedMap<dynamic, V>();
  +    forEach((Tuple2<K, V> tuple) {
  +      var mappedValue = f(tuple.v2);
  +      result[tuple.v1] = mappedValue;
  +    });
  +    return result;
  +  }
  +
  +  void put(Tuple2<K, V> tuple) {
  +    _values[tuple.v1] = tuple;
  +  }
  +
     core.Map<K, V> toMap() {
       var result = new Map<K, V>();
       this.forEach((tuple) => result[tuple.v1] = tuple.v2);
  
positive.code:   /** Checks if the two maps have the same content */
    core.bool sameContent(Map<K, V> other);
  
    /** 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);
  }
  
  class WrappedMap<K, V> extends core.Object with IterableMixin<Tuple2<K, V>>
  
negative.code: 
    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;
  