// Sc = type of scores (e.g. Double)
sclass TunableParameters<Sc extends Comparable<Sc>> {
  replace Scrd with GenericallyScored<MapSO, Sc>.
  
  settable IF1<MapSO, Sc> scoreFunction;
  gettable Scrd best;
  
  abstract class Parameter<A> {
    settable S name;
    settable A defaultValue;
    
    abstract A randomValue();
  }
  
  class IntRangeParameter extends Parameter<Int> {
    settable IntRange range;
    
    Int randomValue() { ret random(range); }
  }
  
  class DoubleRangeParameter extends Parameter<Double> {
    settable DoubleRange range;
    
    Double randomValue() { ret random(range); }
  }
  
  new LinkedHashMap<S, Parameter> parameters;
  
  selfType add(Parameter p) {
    parameters.put(p.name(), p);
    this;
  }
  
  MapSO randomInstance() {
    MapSO map = new LinkedHashMap;
    for (param : values(parameters))
      map.put(param.name(), param.randomValue());
    ret map;
  }
  
  Scrd tryARandomCombination() {
    MapSO instance = randomInstance();
    var scored = new GenericallyScored<>(instance, score(instance));
    saveInstance(scored);
    ret scored;
  }
  
  Sc score(MapSO instance) {
    ret scoreFunction.get(instance);
  }
  
  void saveInstance(Scrd scored) {
    if (scored == null) ret;
    if (best == null || cmp(scored.score(), best.score()) > 0)
      best = scored;
  }
}