anchor.diff:    Option<V> get(K k) => _tree.get(_order, k);
   
     IMap<K, V> modify(K k, V f(V v), V dflt) => put(k, get(k).map(f)|dflt);
  +
  +  Option<IMap<K, V>> set(K k, V v) => _tree.set(_order, k, v).map((newTree) => new IMap(_order, newTree));
   
     IMap<K, V> remove(K k) => new IMap(_order, _tree.remove(_order, k));
   
  
positive.code:   int get height;
    int get balance;
    Option<Tuple3<_IMapAVLNode<K, V>, K, V>> _removeMax();
  }
  
  class _NonEmptyIMapAVLNode<K, V> extends _IMapAVLNode<K, V> {
  
negative.code:     }
      return none;
    }
  
    @override _IMapAVLNode<K, dynamic> map(f(V v)) {
      final _IMapAVLNode<K, dynamic> newLeft = _left.map(f);
      final newV = f(_v);
      final _IMapAVLNode<K, dynamic> newRight = _right.map(f);
      return new _NonEmptyIMapAVLNode(_k, newV, newLeft, newRight);
    }
  
    @override Option<_IMapAVLNode<K, V>> set(Order<K> order, K k, V v) {
      var current = this;
      while(current is _NonEmptyIMapAVLNode) {
        final Ordering o = order.order(k, current._k);
        if (o == Ordering.EQ) {
          return some(new _NonEmptyIMapAVLNode(current._k, v, current._left, current._right));
        } else if (o == Ordering.LT) {
          current = current._left;
        } else {
          current = current._right;
        }
      }
      return none;
    }
  }
  
  class _EmptyIMapAVLNode<K, V> extends _IMapAVLNode<K, V> {
    _EmptyIMapAVLNode();
  
    @override foldLeft(z, f(previous, K k, V v)) => z;
  
  