anchor.diff:     * `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.
  +   *     var mapA = PersistentMap.fromMap({'a': 1});
  +   *     var mapB = PersistentMap.fromMap({'b': 2});
  +   *     var mapAB = PersistentMap.fromMap({'a': 3, 'b': 2});
  +   *     mapA.intersection(mapB) // returns {}
  +   *     mapA.intersection(mapAB) // returns {'a': 1}
  +   *     mapA.intersection(mapAB, (x,y) => x + y) // returns {'a': 4}
      */
     ReadMap<K, V>
         intersection(ReadMap<K, V> other, [V combine(V left, V right)]);
  
positive.code: }
  
  /**
   * An 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
  
negative.code:   lookupIn(List path, {orElse()});
  
    /**
     * Returns the value bound to [key].
     * 
     * Throws [RangeError] if [key] is not bound.
     */
    V operator [](K key);
  
  