 extension Guise {
     
     /// All roads lead here
-    private static func filter<K: Keyed & Hashable>(type: String?, name: AnyHashable?, container: AnyHashable?, metathunk: Metathunk?) -> Set<K> {
+    private static func filter<K: Keyed & Hashable>(name: AnyHashable?, container: AnyHashable?, metathunk: Metathunk?) -> Set<K> {
         let keymap: (Dictionary<AnyKey, Dependency>.Element) -> Dictionary<K, Dependency>.Element? = {
+            /*
+             Filtering by type occurs when `K` is `Key<T>`. For instance, if `K` is `Key<String>` but `$0.key.type` is
+             `Swift.Int`, the initializer will fail because of the type incompatibility. This is why no explicit `type`
+             parameter for this method is needed.
+             
+             When *not* filtering by type, `K` should be `AnyKey`.
+             */
             guard let key = K($0.key) else { return nil }
-            if let type = type, type != key.type { return nil }
             if let name = name, name != key.name { return nil }
             if let container = container, container != key.container { return nil }
             return (key: key, value: $0.value)

    // MARK: Filter By Metadata
    
    public static func filter<M>(metafilter: @escaping Metafilter<M>) -> Set<AnyKey> {
        return filter(type: nil, name: nil, container: nil, metathunk: metathunk(metafilter))
    }
    
    public static func filter<M: Equatable>(metadata: M) -> Set<AnyKey> {

    // MARK: Filter By Type
    
    public static func filter<T>(type: T.Type) -> Set<Key<T>> {
        return filter(name: nil, container: nil, metathunk: nil)
    }
    
    public static func filter<T, M>(type: T.Type, metafilter: @escaping Metafilter<M>) -> Set<Key<T>> {
        return filter(name: nil, container: nil, metathunk: metathunk(metafilter))
    }
    
    public static func filter<T, M: Equatable>(type: T.Type, metadata: M) -> Set<Key<T>> {
