     }
     
     public static func register<P, D, N: Hashable>(name: N, lifecycle: Lifecycle = .notCached, resolve: @escaping (P) -> D) -> Key {
-        return register(container: Container.default, name: name, lifecycle: lifecycle, resolve: resolve)
+        return register(name: name, container: Container.default, lifecycle: lifecycle, resolve: resolve)
     }
     
     public static func register<P, D, C: Hashable>(container: C, lifecycle: Lifecycle = .notCached, resolve: @escaping (P) -> D) -> Key {
-        return register(container: container, name: Container.default, lifecycle: lifecycle, resolve: resolve)
+        return register(name: Name.default, container: Container.default, lifecycle: lifecycle, resolve: resolve)
     }
     
     public static func register<P, D>(lifecycle: Lifecycle = .notCached, resolve: @escaping (P) -> D) -> Key {
-        return register(container: Container.default, name: Name.default, lifecycle: lifecycle, resolve: resolve)
-    }
-    
-    public static func register<D, C: Hashable, N: Hashable>(instance: D, container: C, name: N) -> Key {
-        return register(container: container, name: name, lifecycle: .cached) { instance }
+        return register(name: Name.default, container: Container.default, lifecycle: lifecycle, resolve: resolve)
+    }
+    
+    public static func register<D, N: Hashable, C: Hashable>(instance: D, name: N, container: C) -> Key {
+        return register(name: name, container: container, lifecycle: .cached) { instance }
     }
     
     public static func register<D, N: Hashable>(instance: D, name: N) -> Key {
-        return register(instance: instance, container: Container.default, name: name)
+        return register(instance: instance, name: name, container: Container.default)
     }
     
     public static func register<D>(instance: D) -> Key {
-        return register(instance: instance, container: Container.default, name: Name.default)
+        return register(instance: instance, name: Name.default, container: Container.default)
     }
     
     public static func unregister(key: Key) {
         let _ = withWriteLock { dependencies.removeValue(forKey: key) }
     }
     
-    public static func unregister<D, C: Hashable, N: Hashable>(type: D.Type, container: C, name: N) {
+    public static func unregister<D, N: Hashable, C: Hashable>(type: D.Type, name: N, container: C) {
         let key = Key(type: D.self, name: name, container: container)
         unregister(key: key)
     }

    
    private static var dependencies = [Key: Dependency]()
    
    public static func register<P, D, C: Hashable, N: Hashable>(container: C, name: N, lifecycle: Lifecycle = .notCached, resolve: @escaping (P) -> D) -> Key {
        let key = Key(type: D.self, name: name, container: container)
        withWriteLock {
            dependencies[key] = Dependency(lifecycle: lifecycle, resolve: resolve)

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