// doesn't implement all methods yet
sclass ValueOnDemandMap<A, B> extends AbstractMap<A, B> {
  Set<A> keys; // keys may be changed if map is changed
  IF1<A, B> makeValue;
  
  *() {}
  *(Set<A> *keys, IF1<A, B> *makeValue) {} // doesn't clone keys
  
  public B get(O a) {
    ret !containsKey(a) ? null : makeValue.get((A) a);
  }
  
  public bool containsKey(O a) {
    ret keys.contains(a);
  }
  
  public Set<Map.Entry<A, B>> entrySet() {
    ret new EntrySet;
  }
  
  final class EntrySet extends AbstractSet<Map.Entry<A,B>> {
    public final int size() { ret keys.size(); }
    public final void clear() { keys.clear(); }
    public final Iterator<Map.Entry<A,B>> iterator() {
      return mapI(keys.iterator(), key -> new Map.Entry<A, B>() {
        public A getKey() { ret key; }
        public B getValue() { ret makeValue.get(key); }
      });
    }
    public final boolean contains(Object o) {
      if (o cast Map.Entry)
        ret keys.contains(o.getKey());
      false;
    }
    public final boolean remove(Object o) {
      if (o cast Map.Entry)
        ret keys.remove(o.getKey());
      false;
    }
    /*public final Spliterator<Map.Entry<A,B>> spliterator() {
        return new EntrySpliterator<>(HashMap.this, 0, -1, 0, 0);
    }
    public final void forEach(Consumer<? super Map.Entry<A,B>> action) {
        Node<A,B>[] tab;
        if (action == null)
            throw new NullPointerException();
        if (size > 0 && (tab = table) != null) {
            int mc = modCount;
            for (Node<A,B> e : tab) {
                for (; e != null; e = e.next)
                    action.accept(e);
            }
            if (modCount != mc)
                throw new ConcurrentModificationException();
        }
    }*/
  }

  public Set<A> keySet() { ret keys; }
  
  public int size() { ret keys.size(); }
}