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:     });
    }
  
    Map<K, V> defaulting(V defaultFn(K key)) =>
        new DefaultMap(defaultFn, map: this);
  
    core.String toString() =>
        "WrappedMap(${map((tuple) => "${tuple.v1}, ${tuple.v2}").join(", ")})";
  }
  
  class DefaultMap<K, V> extends core.Object with IterableMixin<Tuple2<K, V>>
      implements Map<K, V> {
    final Map<K, V> _wrapped;
    final _defaultFn;
  
    DefaultMap(V defaultFn(K key), {Map<K, V> map})
        : _defaultFn = defaultFn,
          _wrapped = null == map ? new WrappedMap<K, V>() : map;
  
    Option<V> get(K key) =>
        _wrapped.get(key).orElse(() => new Some(_defaultFn(key)));
  