sclass CompressorSearch<A> {
  // public
  
  CompressionRegime<A> regime;
  byte[] inputData;
  new Best<Submission> best;
  
  *(CompressionRegime<A> *regime) {}
  *(CompressionRegime<A> *regime, byte[] *inputData) {}
  
  // can submit concurrently!
  Submission submit(A compression) { ret _submit(compression); }
  
  // private (although Submission is returned)
  
  class Submission {
    toString {
      ret linesLL(
        "Compressor " + (correct() ? "correct" : "incorrect"),
        "Compression factor " + score(),
        "Code:",
        decompressor(),
        "Code as bytes:",
        compressed()
      );
    }
    
    void setDecompressor(A decompressor) {
      this.decompressor_cache = decompressor;
    }
    
    byte[] inputData() { ret inputData; }
    
    simplyCached byte[] compressed() {
      ret decompressor_cache == null ?: regime.decompressorToBytes(decompressor_cache);
    }
    
    simplyCached A decompressor() {
      ret compressed_cache == null ?: regime.decompressorFromBytes(compressed_cache);
    }
    
    int compressedSize() { ret l(compressed()); }
    
    simplyCached double score() {
      ret doubleRatio(inputDataSize(), compressedSize());
    }
    
    bool decompressed;
    O decompressedValue;
    
    O decompressed() {
      if (!decompressed) {
        decompressedValue = regime.runDecompressor(decompressor());
        set decompressed;
      }
      ret decompressedValue;
    }
    
    simplyCached Bool correct() {
      ret byteArraysEqual(toByteArray(decompressed()), inputData());
    }
  }
  
  int inputDataSize() { ret l(inputData); }
  
  Submission _submit(A compression) {
    if (compression == null) null;
    new Submission s;
    s.setDecompressor(compression);
    if (s.score() > best.score())
      if (!s.correct())
        warn("Compressor didn't verify");
      else
        best.put(s, s.score());
    ret s;
  }
}