     /**
      Resolve multiple registrations at the same time.
      
-     - returns: A dictionary mapping the keys to their resolved dependencies.
-    */
-    public static func resolve<T, K: Sequence>(keys: K, parameter: Any = (), cached: Bool? = nil) -> [Key: T] where K.Iterator.Element == Key {
-        let type = String(reflecting: T.self)
-        let dependencies: [Key: Dependency] = lock.read {
-            var dependencies = [Key: Dependency]()
+     - returns: A dictionary mapping each supplied `Key` to its resolved dependency of type `T`.
+     
+     - parameters:
+         - keys: The keys to resolve.
+         - parameter: A parameter to pass to the resolution block.
+         - cached: Whether to use the cached value or to call the resolution block again.
+     
+     Use the `filter` overloads to conveniently get a list of keys. For example,
+     
+     ```swift
+     // Get the keys for all plugins
+     let keys = Guise.filter(type: Plugin.self)
+     // Resolve the keys
+     let plugins: [Plugin] = Guise.resolve(keys: keys)
+     ```
+     
+     - note: Passing `nil` for the `cached` parameter causes Guise to use the value of `cached` recorded
+     when the dependency was registered. In most cases, this is what you want.
+     
+     - note: If a `Key` does not map to a dependency of type `T`, it will be skipped.
+    */
+    public static func resolve<T>(keys: Set<Key<T>>, parameter: Any = (), cached: Bool? = nil) -> Dictionary<Key<T>, T> {
+        let dependencies: Dictionary<Key<T>, Dependency> = lock.read {
+            var dependencies = Dictionary<Key<T>, Dependency>()
             for (key, dependency) in registrations {
-                if type != key.type { continue }
+                guard let key = Key<T>(key) else { continue }
                 if !keys.contains(key) { continue }
                 dependencies[key] = dependency
             }

    }
    
    /**
     Find the given key matching the metafilter query.
     
     This method will always return either an empty set or a set with one element.
    */
    public static func filter<M>(key: Key, metafilter: @escaping Metafilter<M>) -> Set<Key> {
        guard let dependency = lock.read({ registrations[key] }) else { return [] }
        return metathunk(metafilter)(dependency.metadata) ? [key] : []
    }
    
    /**
    */
    public static  func filter(key: Key) -> Set<Key> {
        return lock.read{ registrations[key] == nil ? [] : [key] }
    }
    
    /**

     when the dependency was registered. In most cases, this is what you want.
    */
    public static func resolve<T, N: Hashable, C: Hashable>(name: N, container: C, parameter: Any = (), cached: Bool? = nil) -> T? {
        return resolve(key: Key(name: name, container: container), parameter: parameter, cached: cached)
    }
    
    /**
