         self.future = future
         self.cancellation = cancellation ?? {}
     }
+    #endif
 
     /// Create a task that will never complete.
-    public init() {
+    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>

#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`.

    }

    /// 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)
    }
    #else
    internal let cancellation: (() -> Void)

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