     private struct CacheKey: Hashable {
         let request: Request
 
-        var hashValue: Int { return request._ref.urlString?.hashValue ?? 0 }
+        var hashValue: Int { return request._ref._urlString?.hashValue ?? 0 }
 
         static func ==(lhs: CacheKey, rhs: CacheKey) -> Bool {
             let lhs = lhs.request, rhs = rhs.request
-            return lhs._ref.urlString == rhs._ref.urlString
-                && lhs.processor == rhs.processor
+            return lhs._ref._urlString == rhs._ref._urlString
+                && lhs._ref.isEqualProcessor(to: rhs._ref)
         }
     }
 
     private struct LoadKey: Hashable {
         let request: Request
 
-        var hashValue: Int { return request._ref.urlString?.hashValue ?? 0 }
+        var hashValue: Int { return request._ref._urlString?.hashValue ?? 0 }
 
         static func ==(lhs: LoadKey, rhs: LoadKey) -> Bool {
             func isEqual(_ a: URLRequest, _ b: URLRequest) -> Bool {

    /// Initializes a request with the given URL.
    public init(url: URL) {
        _ref = Container(resource: Resource.url(url))
        _ref.urlString = url.absoluteString
    }

    /// Initializes a request with the given request.
    public init(urlRequest: URLRequest) {
        _ref = Container(resource: Resource.urlRequest(urlRequest))
        _ref.urlString = urlRequest.url?.absoluteString
    }

    #if !os(macOS)

        #if !os(macOS)
        private static let decompressor = AnyProcessor(Decompressor())
        #endif

        func isEqualProcessor(to ref: Container) -> Bool {
            return (_isUsingDefaultProcessor && ref._isUsingDefaultProcessor) || processor == ref.processor
        }
    }

    /// Resource representation (either URL or URLRequest).
