anchor.diff:  
   typedef ScopeRunnable();
   
  -@Injectable
  -abstract class Provider<T> {
  -  T get();
  -}
  -
  -void logCapabilities(Reflectable reflector) {
  +void logReflector(Reflectable reflector) {
     _logger.finest("******************************");
     _logger.fine(
         "Annotated classes of $reflector: ${reflector.annotatedClasses.length}");
  
positive.code:   static Map<Type, ProviderFunction> _SCOPED_PROVIDERS_CACHE;
  
    static Future load(Type moduleClazz,
        [Map<String, dynamic> parameters = const {}]) {
      _logger.finest("Load registry module");
  
      logCapabilities(Injectable);
  
      var module =
          (Module.reflectType(moduleClazz) as ClassMirror).newInstance("", []);
      if (module is! RegistryModule) {
        throw new ArgumentError("$moduleClazz is not a registry module");
      }
      _MODULE = module;
  
      _SCOPED_PROVIDERS_CACHE = {};
      return _MODULE.configure(parameters).then((_) {
        _injectProviders();
      });
    }
  
    static Future unload() {
      _logger.finest("Unload module");
  
      return _MODULE.unconfigure().then((_) {
        _MODULE = null;
        _SCOPED_PROVIDERS_CACHE = null;
      });
    }
  
    static Future openScope(Scope scope) {
      _logger.finest("Open scope $scope");
  
      if (scope == Scope.NONE) {
  
negative.code:   }
  
    static void _injectProviders() {
      for (var providerBinding in _MODULE._bindings.values) {
        _injectBindings(providerBinding.provider);
      }
    }
  
    static void _injectBindings(instance) {
  