anchor.diff:  
   part of persistent;
   
  +/**
  + * A read-only map, binding keys of type [K] to values of type [V]. Null
  + * values are supported but null keys are not.
  + *
  + * There is no default implementation of [ReadMap], since it just
  + * specifies common interface of [PersistentMap] and [TransientMap].
  + * 
  + * In all the examples below `{k1: v1, k2: v2, ...}` is a shorthand for
  + * `new PersistentMap.fromMap({k1: v1, k2: v2, ...})`.
  + */
   abstract class ReadMap<K, V> implements Iterable<Pair<K, V>> {
   
     /**
  -   * Looks up the value possibly bound to [key] in `this`. Returns
  -   * [new Option.some(value)] if it exists, [new Option.none()] otherwise.
  +   * Returns the value bound to [key].
  +   * 
  +   * If [key] is not bound, [orElse] is called to obtain the
  +   * return value. Default [orElse] throws [RangeError].
      */
     V lookup(K key, {orElse()});
   
  
positive.code:    * `leftvalue` is the value bound to `key` in `this` and `rightvalue` is the
     * one bound to `key` in [other].
     *
     *     {'a': 1}.intersection({'b': 2}) == {}
     *     {'a': 1}.intersection({'a': 3, 'b': 2}) == {'a': 3}
     *     {'a': 1}.intersection({'a': 3, 'b': 2}, (x,y) => x + y) == {'a': 4}
     *
     * Note that [intersection] is commutative if and only if [combine] is
     * provided and if it is commutative.
     */
    ReadMap<K, V>
        intersection(ReadMap<K, V> other, [V combine(V left, V right)]);
  
negative.code: }
  
  /**
   * A persistent map, binding keys of type [K] to values of type [V]. Null
   * values are supported but null keys are not.
   *
   * Persistent data structure is an immutable structure, that provides effective
  