sclass Scorer<A> {
  double score, total;
  L<A> successes, errors; // set to non-null if you want them filled
  bool verboseFailures, verboseAll;
  
  void addZeroToOne aka add(double score) {
    ++total;
    this.score += clamp(score, 0, 1);
  }
  
  void addZeroToOneError(double error) {
    addZeroToOne(1-error);
  }
  
  void addError { add(false); }
  void addError(A info) { add(false, info); }
  void error(A info) { addError(info); }
  void addOK { add(true); }
  void addOK(A info) { add(true, info); }
  void ok() { addOK(); }
  void ok(A info) { addOK(info); }
  
  bool add(bool correct) {
    ++total;
    if (correct) ++score;
    ret correct;
  }
  
  bool add(bool correct, A info) {
    main add(correct ? successes : errors, info);
    if (verboseAll || verboseFailures && !correct)
      _print((correct ? "[GOOD] " : "[BAD] ") + info);
    ret add(correct);
  }
  
  // works if you use Scorer or Scorer<S>
  void eq(O a, O b) {
    if (_eq(a, b))
      add(true);
    else
      add(false, (A) (a + " != " + b));
  }
  
  void print() {
    main print(toString());
  }
  
  toString {
    ret formatDouble(ratioToPercent(score, total), 1) + "% correct (n=" + formatDouble(total, 1) + ")";
  }
  
  double get() {
    ret ratioToPercent(score, total);
  }
  
  double percentScore() { ret get(); }
  double score() { ret get(); }
  
  bool allCorrect() {
    ret score == total;
  }
  
  void add(Scorer scorer) {
    if (scorer == null) ret;
    total += scorer.total;
    score += scorer.score;
    addAll(successes, scorer.successes);
    addAll(errors, scorer.errors);
  }
  
  void collectErrors() {
    errors = new L;
  }
  
  void collectSuccesses() {
    successes = new L;
  }
}