         self.result = result
     }
 
+    // MARK: Load (Publisher)
+
+    public func load(_ publisher: AnyPublisher<ImageResponse, ImagePipeline.Error>) {
+        _reset()
+
+        cancellable = publisher.sink(receiveCompletion: { [weak self] completion in
+            guard let self = self else { return }
+            self.isLoading = false
+            switch completion {
+            case .finished:
+                if let response = self.lastResponse {
+                    self.result = .success(response)
+                } // else was cancelled, do nothing
+            case .failure(let error):
+                self.result = .failure(error)
+            }
+        }, receiveValue: { [weak self] response in
+            guard let self = self else { return }
+            self.lastResponse = response
+            self.image = response.image
+        })
+
+        isLoading = true
+    }
+
+    // MARK: Cancel
+
     /// Marks the request as being cancelled. Continues to display a downloaded
     /// image.
     public func cancel() {
+        // pipeline-based
         task?.cancel() // Guarantees that no more callbacks are will be delivered
         task = nil
+
+        // publisher-based
+        cancellable = nil
+
+        // common
         isLoading = false
     }
 

        isLoading = false
        image = nil
        result = nil
        progress = Progress(completed: 0, total: 0)
        request = nil
    }

        let previousTask = self.task
        defer { previousTask?.cancel() }

        let request = request.asImageRequest()
        self.request = request

        // Try to display the regular image if it is available in memory cache
