// optimized for search - O(1) for searching for a certain element
// set is O(log m) with m = number of occurrences of element
final sclass CalculatedFieldIndexedList<A, B> extends RandomAccessAbstractList<A> {
  new Map<B, TreeSet<Elem<A>>> index; // elements by calculated field, sorted by index
  final new ArrayList<Elem<A>> list;
  IF1<A, B> f; // element to "key" (calculated field)

  final sclass Elem<A> extends HasIndex {
    A s; // actual element
    
    toString { ret "Elem " + quote(s) + "@" + idx; }
  }
  
  *(IF1<A, B> *f) {}
  *(IF1<A, B> *f, Map<B, TreeSet<Elem<A>>> *index) {} // use different type of index (e.g. ciMap)
  *(IF1<A, B> *f, Cl<A> l) { addAll(l); }
  
  public A get(int i) { ret list.get(i).s; }
  public int size() { ret list.size(); }
  
  public A set(int i, A s) {
    Elem<A> t = list.get(i);
    A old = t.s;
    if (eq(old, s)) ret old;
    removeFromIdx(t);
    t.s = s;
    addToIdx(t);
    ret old;
  }
  
  public bool add(A s) {
    ++modCount;
    new Elem<A> t;
    t.s = s;
    t.idx = size();
    list.add(t);
    addToIdx(t);
    true;
  }
  
  public void add(int i, A s) {
    ++modCount;
    new Elem<A> t;
    t.s = s;
    t.idx = i;
    list.add(i, t);
    reorder(i+1);
    addToIdx(t);
  }
  
  public bool addAll(int i, Collection<? extends A> l) {
    int n = l.size();
    if (n == 0) false;
    ++modCount;
    L<Elem<A>> l2 = emptyList(n);
    int j = i;
    for (A s : l) {
      new Elem<A> t;
      t.s = s;
      t.idx = j++;
      l2.add(t);
    }
    list.addAll(i, l2);
    reorder(i+n);
    for (Elem<A> t : l2)
      addToIdx(t);
    true;
  }
  
  public A remove(int i) {
    ++modCount;
    Elem<A> t = list.get(i);
    removeFromIdx(t);
    list.remove(i);
    reorder(i);
    ret t.s;
  }
  
  void reorder(int fromIdx) {
    int n = size();
    for (int i = fromIdx; i < n; i++)
      list.get(i).idx = i;
  }
  
  void removeFromIdx(Elem<A> t) {
    B key = calc(t);
    var idx = index.get(key);
    idx.remove(t);
    if (idx.isEmpty()) index.remove(key);
  }
  
  void addToIdx(Elem<A> t) {
    B key = calc(t);
    var idx = index.get(key);
    if (idx == null)
      index.put(key, idx = new TreeSet);
    idx.add(t);
  }
  
  public A getByKey(B key) {
    var l = index.get(key);
    ret l == null ?: first(l).s;
  }
  
  // doesn't return null
  public L<A> getAllByKey(B key) {
    var l = index.get(key);
    ret l == null ? emptyList() : map(l, x -> x.s);
  }
  
  public int indexOfKey(B key) {
    var l = index.get(key);
    ret l == null ? -1 : first(l).idx;
  }
  
  @Override
  public int lastIndexOf(O s) {
    TreeSet<Elem<A>> l = index.get(s);
    ret l == null ? -1 : last(l).idx;
  }
  
  @Override
  public bool contains(O s) {
    ret index.containsKey(s);
  }
  
  public void clear() {
    ++modCount;
    index.clear();
    list.clear();
  }
  
  protected void removeRange(int fromIndex, int toIndex) {
    if (fromIndex == toIndex) ret;
    ++modCount;
    
    for (int i = fromIndex; i < toIndex; i++)
      removeFromIdx(list.get(i));
      
    list.subList(fromIndex, toIndex).clear();
    reorder(fromIndex);
  }
  
  public int[] indicesOfKey(B o) {
    TreeSet<Elem<A>> idx = index.get(o);
    if (idx == null) ret emptyIntArray();
    int[] a = new int[idx.size()];
    int i = 0;
    for (Elem<A> t : idx) a[i++] = t.idx;
    ret a;
  }
  
  B calc(A a) { ret f.get(a); }
  B calc(Elem<A> a) { ret f.get(a.s); }
}