         }
     }
     
+    /**
+     Find all keys for the given type, name, and container.
+    */
     public static func filter<T, N: Hashable, C: Hashable>(type: T.Type, name: N, container: C) -> [Key] {
         return filter(type: String(reflecting: type), name: name, container: container)
     }
     
+    /**
+     Find all keys for the given type and name, independent of container.
+    */
     public static func filter<T, N: Hashable>(type: T.Type, name: N) -> [Key] {
         return filter(type: String(reflecting: type), name: name, container: nil)
     }
     
+    /**
+     Find all keys for the given type and container, independent of name.
+    */
     public static func filter<T, C: Hashable>(type: T.Type, container: C) -> [Key] {
         return filter(type: String(reflecting: type), name: nil, container: container)
     }
     
+    /**
+     Find all keys for the given name and container, independent of type.
+    */
     public static func filter<N: Hashable, C: Hashable>(name: N, container: C) -> [Key] {
         return filter(type: nil, name: name, container: container)
     }
     
+    /**
+     Find all keys for the given name, independent of the given type and container.
+    */
     public static func filter<N: Hashable>(name: N) -> [Key] {
         return filter(type: nil, name: name, container: nil)
     }
     
+    /**
+     Find all keys for the given container, independent of given type and name.
+    */
     public static func filter<C: Hashable>(container: C) -> [Key] {
         return filter(type: nil, name: nil, container: container)
     }
 
+    /**
+     All keys.
+    */
     public static var keys: [Key] {
         return lock.read { Array(registrations.keys) }
     }
     
-    public static func unregister(key: Key) {
-        unregister(keys: [key])
-    }
-    
+    /**
+     Remove the dependencies registered under the given key(s).
+    */
+    public static func unregister(key: Key...) {
+        unregister(keys: key)
+    }
+    
+    /**
+     Remove the dependencies registered under the given keys.
+    */
     public static func unregister<K: Sequence>(keys: K) where K.Iterator.Element == Key {
-        lock.write {
-            registrations = registrations.filter{ keys.contains($0.key) }.dictionary { $0 }
-        }
-    }
-    
-    public static func unregister() {
-        unregister(keys: keys)
+        lock.write { registrations = registrations.filter{ !keys.contains($0.key) }.dictionary { $0 } }
+    }
+    
+    /**
+     Remove all dependencies.
+    */
+    public static func clear() {
+        lock.write { registrations = [:] }
     }
 }
 

    case `default`
}

private func hash<H: Hashable>(_ hashables: H...) -> Int {
    // djb2 hash algorithm: http://www.cse.yorku.ca/~oz/hash.html
    // &+ operator handles Int overflow

        return resolve(key: Key(type: T.self, name: Name.default, container: Name.default), parameter: parameter, cached: cached)
    }
    
    /**
     Helper method for filtering.
    */
    private static func filter(type: String?, name: AnyHashable?, container: AnyHashable?) -> [Key] {
        return lock.read {
            var keys = [Key]()
