anchor.diff:    /** 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>>
  
positive.code: 
    core.bool containsKey(K key) => _wrapped.containsKey(key);
  
    core.bool operator ==(other) {
      if (other is! DefaultMap) return false;
      return _wrapped == other._wrapped;
  
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)));
  