// Maximally compact implementation of such a thing
// Use SortedArrayBasedMap instead if keys are sortable
sclass MinimalMap<A, B> extends CompactAbstractMap<A, B> {
  O[] entries;
  
  *() {}
  *(Map<A, B> map) {
    if (empty(map)) ret;
    entries = new O[l(map)*2];
    int i = 0;
    for (A a, B b : map) {
      entries[i++] = a;
      entries[i++] = b;
    }
  }
  
  public int size() { ret l(entries)/2; }
  public Set<Map.Entry<A, B>> entrySet() {
    ret toLinkedHashMap().entrySet();
  }
  
  int find(O o) {
    if (entries != null)
      for (int i = 0; i < entries.length; i += 2)
        if (eq(entries[i], o))
          ret i;
    ret -1;
  }
  
  public bool containsKey(O o) {
    ret find(o) >= 0;
  }
  
  @Override
  public B get(O o) {
    int i = find(o);
    ret i >= 0 ? (B) entries[i+1] : null;
  }
  
  LinkedHashMap<A, B> toLinkedHashMap() {
    new LinkedHashMap<A, B> map;
    if (entries != null)
      for (int i = 0; i < entries.length; i += 2)
        map.put((A) entries[i], (B) entries[i+1]);
    ret map;
  }
  
  @Override
  public B put(A key, B value) {
    int i = find(key);
    
    // existing key?
    if (i >= 0) {
      B oldValue = (B) entries[i+1];
      entries[i+1] = value;
      ret oldValue;
    }
    
    // new key
    int l = l(entries);
    entries = resizeObjectArray(entries, l+2);
    entries[l] = key;
    entries[l+1] = value;
    null;
  }
  
  @Override
  public B remove(O key) {
    int i = find(key);
    if (i < 0) null;
    B oldValue = (B) entries[i+1];
    int l = l(entries);
    entries = spliceObjectArray(entries, i, l+2, null);
    ret oldValue;
  }
}