   /// - parameter value: the value to be transformed for a new `Deferred`
 
   public func apply<Other>(queue: DispatchQueue? = nil,
-                           transform: Deferred<(_ value: Success) throws -> Other>) -> Deferred<Other>
+                           transform: Deferred<(_ value: Success) -> Other, Never>) -> Deferred<Other, Failure>
   {
     func applyTransform(_ value: Success,
-                        _ transform: (Result<(Success) throws -> Other, Error>),
-                        _ resolver: Resolver<Other, Error>)
+                        _ transform: Result<(Success) -> Other, Never>,
+                        _ resolver: Resolver<Other, Failure>)
     {
       guard resolver.needsResolution else { return }
       resolver.beginExecution()
-      do {
-        let transform = try transform.get()
-        let transformed = try transform(value)
-        resolver.resolve(value: transformed)
-      }
-      catch {
-        resolver.resolve(error: error)
+      switch transform
+      {
+      case .success(let transform):
+        resolver.resolve(value: transform(value))
       }
     }
 

      self.notify(queue: queue) {
        result in
        guard resolver.needsResolution else { return }
        do {
          let value = try result.get()
          if let transform = transform.peek()
          {
            applyTransform(value, transform, resolver)

  /// - parameter value: the value to be transformed for a new `Deferred`

  public func apply<Other>(qos: DispatchQoS,
                           transform: Deferred<(_ value: Success) -> Other, Never>) -> Deferred<Other, Failure>
  {
    let queue = DispatchQueue(label: "deferred-apply", qos: qos)
    return apply(queue: queue, transform: transform)
  }
}

