         hashValue = hash(self.type, self.name, self.container)
     }
     
-    init<P, D, C: Hashable, N: Hashable>(container: C, name: N, resolve: (P) -> D) {
+    init<P, D, N: Hashable, C: Hashable>(name: N, container: C, resolve: (P) -> D) {
         self.init(type: D.self, name: name, container: container)
     }
     

        return (dependency.resolve(parameter, lifecycle: lifecycle) as D)
    }
    
    public static func resolve<D, C: Hashable, N: Hashable>(container: C, name: N, parameter: Any = (), lifecycle: Lifecycle = .cached) -> D? {
        let key = Key(type: D.self, name: name, container: container)
        return resolve(key: key, parameter: parameter, lifecycle: lifecycle)
    }
    
    public static func resolve<D, C: Hashable>(container: C, parameter: Any = (), lifecycle: Lifecycle = .cached) -> D? {
        return resolve(container: container, name: Name.default, parameter: parameter, lifecycle: lifecycle)
    }
    
    public static func resolve<D, N: Hashable>(name: N, parameter: Any = (), lifecycle: Lifecycle = .cached) -> D? {
        return resolve(container: Container.default, name: name, parameter: parameter, lifecycle: lifecycle)
    }
    
    public static func resolve<D>(parameter: Any = (), lifecycle: Lifecycle = .cached) -> D? {
        return resolve(container: Container.default, name: Name.default, parameter: parameter, lifecycle: lifecycle)
    }
    
    public let name: AnyHashable

        self.lifecycle = lifecycle
    }
    
    public func register<P, D, N: Hashable, C: Hashable>(name: N, container: C, lifecycle: Lifecycle? = nil, resolve: @escaping (P) -> D) -> Key {
        return Guise.register(name: name, container: container, lifecycle: lifecycle ?? self.lifecycle, resolve: resolve)
    }
    
    public func register<P, D, N: Hashable>(name: N, lifecycle: Lifecycle? = nil, resolve: @escaping (P) -> D) -> Key {
        return Guise.register(name: name, container: Container.default, lifecycle: lifecycle ?? self.lifecycle, resolve: resolve)
    }
    
    public func register<P, D, C: Hashable>(container: C, lifecycle: Lifecycle? = nil, resolve: @escaping (P) -> D) -> Key {
        return Guise.register(name: Name.default, container: container, lifecycle: lifecycle ?? self.lifecycle, resolve: resolve)
    }
    
    public func register<P, D>(lifecycle: Lifecycle? = nil, resolve: @escaping (P) -> D) -> Key {
        return Guise.register(name: Name.default, container: Container.default, lifecycle: lifecycle ?? self.lifecycle, resolve: resolve)
    }

    public func resolve<D>(key: Key, parameter: Any = (), lifecycle: Lifecycle = .cached) -> D? {
        return Guise.resolve(key: key, parameter: parameter, lifecycle: lifecycle)
    }
    
    public func resolve<D, N: Hashable, C: Hashable>(name: N, container: C, parameter: Any = (), lifecycle: Lifecycle = .cached) -> D? {
        let key = Key(type: D.self, name: name, container: container)
        return Guise.resolve(key: key, parameter: parameter, lifecycle: lifecycle)
    }
    
    public func resolve<D, C: Hashable>(container: C, parameter: Any = (), lifecycle: Lifecycle = .cached) -> D? {
        return Guise.resolve(name: Name.default, container: container, parameter: parameter, lifecycle: lifecycle)
    }
    
    public func resolve<D, N: Hashable>(name: N, parameter: Any = (), lifecycle: Lifecycle = .cached) -> D? {
        return Guise.resolve(name: name, container: Container.default, parameter: parameter, lifecycle: lifecycle)
    }
    
    public func resolve<D>(parameter: Any = (), lifecycle: Lifecycle = .cached) -> D? {
        return Guise.resolve(name: Name.default, container: Container.default, parameter: parameter, lifecycle: lifecycle)
    }

}
