anchor.diff:  
     T construct({Map namedArgs: const {
     }, List args: const [], String constructor: ''}) {
  -    return mirror.newInstance(MirrorSystem.getSymbol(constructor), args, namedArgs).reflectee;
  +    return _mirror.newInstance(MirrorSystem.getSymbol(constructor), args, namedArgs).reflectee;
     }
   
     String toString() => name;
   
  -  bool operator ==(o) => o is TypeReflection && mirror.qualifiedName == o.mirror.qualifiedName;
  +  bool operator ==(o) => o is TypeReflection && _mirror.qualifiedName == o._mirror.qualifiedName;
   }
   
   class FieldReflection {
  -  Symbol symbol;
  -  VariableMirror variable;
  -  MethodMirror accessor;
  +  Symbol _symbol;
  +  VariableMirror _variable;
  +  MethodMirror _accessor;
   
  -  FieldReflection(this.symbol, this.variable, this.accessor);
  +  FieldReflection(this._symbol, this._variable, this._accessor);
   
  -  bool has(Type metadata) => variable.metadata
  +  bool has(Type metadata) => _variable.metadata
     .firstWhere((instance) => instance.type.reflectedType == metadata,
     orElse: () => null) != null;
   
  -  value(Object entity) => reflect(entity).getField(symbol).reflectee;
  +  value(Object entity) => reflect(entity).getField(_symbol).reflectee;
   
  -  set(Object entity, value) => reflect(entity).setField(symbol, value);
  +  set(Object entity, value) => reflect(entity).setField(_symbol, value);
   
  -  TypeReflection get type => new TypeReflection.fromMirror(accessor.returnType);
  +  TypeReflection get type => new TypeReflection.fromMirror(_accessor.returnType);
   
  -  get name => MirrorSystem.getName(symbol);
  +  String get name => MirrorSystem.getName(_symbol);
   
     String toString() => name;
   
  -  bool operator ==(o) => o is FieldReflection && variable.qualifiedName == o.variable.qualifiedName && symbol == o.symbol;
  +  bool operator ==(o) => o is FieldReflection && _variable.qualifiedName == o._variable.qualifiedName && _symbol == o._symbol;
   }
   
   class Maps {
  
positive.code:     if (other is Type) {
        return sameOrSuper(new TypeReflection(other));
      } else if (other is TypeReflection) {
        return this == other || other.mirror.isSubtypeOf(mirror);
      } else {
        return sameOrSuper(new TypeReflection.fromInstance(other));
      }
  
negative.code: part of reflective;
  
  class TypeReflection<T> {
    ClassMirror _mirror;
    List<TypeReflection> _arguments;
  
    TypeReflection(Type type, [List<Type> arguments]) {
      _mirror = reflectClass(type);
      if(arguments != null) {
        _arguments = new List.from(arguments.map((arg) => new TypeReflection(arg)));
      } else {
  