     }
     
     /**
-     Unregisters the dependency with the given name and type, as determined by the `eval` block.
+     Unregisters the dependency with the given name and type, as determined by the `resolve` block.
      
      - parameter name: The optional name under which the dependency was registered.
-     - parameter eval: A block (not called) used to determine the type that was registered.
+     - parameter resolve: A block (not called) used to determine the type that was registered.
      
      - note: The block is never called. It is only used to determine the type used to
      originally register the block. The block can take a parameter just like the registration
      block, but it is ignored.
      */
-    public static func unregister<P, D>(name name: String? = nil, container: String? = nil, @noescape eval: P -> D) -> Bool {
+    public static func unregister<P, D>(name name: String? = nil, container: String? = nil, @noescape resolve: P -> D) -> Bool {
         return unregister(type: String(reflecting: D.self), name: name, container: container)
     }
     

    // MARK: Registration
    
    /**
     Registers the block `eval` with Guise.
     
     - parameter type: Usually the type of `D`, but can be any string.
     - parameter name: An optional name to disambiguate similar `type`s.
     - parameter container: A named container into which to place the dependency.
     - parameter lifecycle: The lifecyle of the registered dependency.
     - parameter eval: The block to register with Guise.
     
     - returns: The registration key, which can be used with `unregister`.
     
     - warning: It is strongly recommended that the generic parameter `D` is not an optional.
     */
    public static func register<P, D>(type type: String = String(reflecting: D.self), name: String? = nil, container: String? = nil, lifecycle: Lifecycle = .NotCached, eval: P -> D) -> Key {
        let key = Key(type: type, name: name, container: container)
        withWriteLock {
            dependencies[key] = Dependency(lifecycle: lifecycle, eval: eval)
        }
        return key
    }

    // MARK: Dependencies
    
    private class Dependency {
        private let resolve: Any -> Any
        private let lifecycle: Lifecycle
        private var instance: Any?
        
        init<P, D>(lifecycle: Lifecycle, resolve: P -> D) {
            self.lifecycle = lifecycle
            self.resolve = { param in resolve(param as! P) }
        }
        
        func resolve<D>(parameter: Any, lifecycle: Lifecycle) -> D {
            var result: D
            if lifecycle != .NotCached && self.lifecycle == .Cached {
                if instance == nil {
                    instance = resolve(parameter)
                }
                result = instance! as! D
            } else {
                result = resolve(parameter) as! D
            }
            return result
        }
