anchor.diff:  
     toReflection(TypeReflection targetReflection) {
       Converter converter = Converters.find(source, targetReflection);
  -    if(converter is ConverterBase) {
  +    if (converter is ConverterBase) {
         return converter.convertTo(object, targetReflection);
       }
       return converter.convert(object);
  
positive.code:       return type.fields.values
        .where((field) => !field.has(Transient))
        .map((field) => {
            field.name: _convert(field.value(object))
        })
        .reduce((Map m1, Map m2) {
          m2.addAll(m1);
  
negative.code: }
  
  class Converters {
    static Set<ConverterBase> converters = new Set();
  
    static ConverterBase register(Type source, Type target, Transformation conversion) {
      ConverterBase converter = new ConverterBase(new TypeReflection(source), new TypeReflection(target), conversion);
      converters.add(converter);
      return converter;
    }
  
    static ConverterBase add(ConverterBase converter) {
      converters.add(converter);
      return converter;
    }
  
    static ConverterBase find(TypeReflection source, TypeReflection target) {
      Map<int, ConverterBase> scored = {};
      converters.forEach((c) {
        int score = ((c.source == source) ? 2 :
            (c.source.sameOrSuper(source)) ? 1 : -2)
          + ((c.target == target) ? 2 :
            (c.target.sameOrSuper(target)) ? 1 : -2);
        if(score >= 2) scored[score] = c;
      });
      if(scored.containsKey(4)) return scored[4];
      if(scored.containsKey(3)) return scored[3];
      if(scored.containsKey(2)) return scored[2];
      throw new ConverterException('No converter found from ' + source.toString() + ' to ' + target.toString() + '.');
    }
  }
  
  