     /// schedule work on it.
     public convenience init<Task: FutureProtocol>(_ base: Task, cancellation: ((Void) -> Void)? = nil)
         where Task.Value: Either, Task.Value.Left == Error, Task.Value.Right == SuccessValue {
+        #if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
+        let progress = Progress.wrapped(base, cancellation: cancellation)
+        self.init(future: Future(task: base), progress: progress)
+        #else
         self.init(future: Future(task: base), cancellation: (base as? _Self)?.cancellation ?? cancellation)
+        #endif
     }
+
 }
-#endif
 
 extension Task: FutureProtocol {
     public typealias Value = Result

#endif

import Dispatch

/// A wrapper over any task.
///
/// Forwards operations to an arbitrary underlying future having the same result
/// type, optionally combined with some `cancellation`.
#if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
import class Foundation.Progress
import protocol Foundation.ProgressReporting

public final class Task<SuccessValue>: NSObject, ProgressReporting {
    public typealias Result = TaskResult<SuccessValue>

    fileprivate let future: Future<Result>
    public let progress: Progress

    /// Creates a task given a `future` and its `progress`.
    public init(future: Future<Result>, progress: Progress) {
        self.future = future
        self.progress = .taskRoot(for: progress)
    }

    /// Create a task that will never complete.
    public override init() {
        self.future = Future()
        self.progress = .indefinite()
    }

    /// Creates a task whose `upon(_:execute:)` methods use the result of `base`.
    public convenience init<Task: FutureProtocol>(_ base: Task, progress: Progress)
        where Task.Value: Either, Task.Value.Left == Error, Task.Value.Right == SuccessValue {
        self.init(future: Future(task: base), progress: progress)
    }

    /// Creates a task given a `future` and an optional `cancellation`.

        self.future = future
        self.cancellation = cancellation ?? {}
    }
    #endif

    /// Create a task that will never complete.
    public override init() {
        self.future = Future()
        #if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
        self.progress = .indefinite()
        #else
        self.cancellation = {}
        #endif
    }

    private typealias _Self = Task<SuccessValue>
