sclass JE_CompressEachElementIndividually<El> extends AbstractCompressor_AnyType<IJavaExpr, L<El>> {
  settable IF0<AbstractCompressor_AnyType<IJavaExpr<El>, El>> elementCompressionStrategy;
  new L<CompressionSearch_AnyType<IJavaExpr<El>, El>> searches;
  settable IF1<El, IJavaExpr> makeLiteral; // required
  new BitSet compressedElementsBitSet;
  // TODO: akas for variables
  
  selfType onCompressionFail(IF1<El, IJavaExpr> f) { makeLiteral = f; this; }
  
  settable bool debug;

  // internal
  
  new L<IJavaExpr> renderedElements;
  IJavaExpr renderedCode;
  new BitSet dirtyElements;
  
  int size() { ret l(inputData()); }
  int nNotLiteral() { ret countPred(searches, search -> search.has()); }
  
  scaffolded IJavaExpr getRenderedElement(int i) {
    if (contains(dirtyElements, i) || _get(renderedElements, i) == null) {
      remove(dirtyElements, i);
      //print("Rendering element " + (i+1) + "/" + size());
      var e = renderElement(i);
      listSet(renderedElements, i, e);
      //print("  => " + e);
    }
    ret renderedElements.get(i);
  }
    
  IJavaExpr renderElement(int i) {
    var search = _get(searches, i);
    IJavaExpr comp = search?!;
    if (comp != null) {
      synchronized(compressedElementsBitSet) { compressedElementsBitSet.set(i); }
      ret comp;
    }
    
    // no "good" compression found, return literal
    IJavaExpr java = makeLiteral.get(_get(inputData(), i));
    metaSet(java, gaveUp := this);
    ret java;
  }
  
  bool dirty() { ret nempty(dirtyElements) || l(renderedElements) < size(); }
  
  public void flush {
    if (!dirty()) ret;
    submit(code());
  }

  L<IJavaExpr> codeForElements() {
    ret countIteratorToList getRenderedElement(size());
  }
  
  // get current best compressed representation
  IJavaExpr code() {
    if (dirty() || renderedCode == null) {
      L<IJavaExpr> els = codeForElements();
      int iNull = indexOf(els, null);
      if (iNull >= 0)
        fail("Null element: " + iNull + "/" + l(els));
      renderedCode = javaExpr(
           functionCall_list ll(els),
        -> mapQuickEval_javaExpr(els));
    }
    ret renderedCode;
  }

  // start compressors  
  public void step0 {
    if (elementCompressionStrategy == null) ret;
    
    probabilisticForEach(scheduler(), 1.0, 0.5, indexAsSideValue(inputData()), ivf1WithToString("Compress element", data -> {
      int i = data.sideValue();
      var subSearch = new CompressionSearch_AnyType<IJavaExpr<El>, El>(assertNotNull(+childRegime()), data!, 1 /* TODO */);
      subSearch.onNewBest(-> set(dirtyElements, i));
      listSet(searches, i, subSearch);
      subSearch.addStrategy(elementCompressionStrategy!);
    }));
  }
  
  S stats() {
    ret renderVars(+nNotLiteral() + " of " + size());
  }
  
  // might as well work (reuse compression regime for children)
  swappable CompressionRegime_AnyType<IJavaExpr<El>> childRegime() {
    ret (CompressionRegime_AnyType) regime();
  }

  bool isElementCompressed(int i) {  
    synchronized(compressedElementsBitSet) {
      ret compressedElementsBitSet.get(i);
    }
  }
}