Update andThen progress expansion to not leap backward by too much

Author: zwaldowski

Sources/Task/TaskAndThen.swift

@@ -43,7 +43,7 @@ extension TaskProtocol {
     /// - see: FutureProtocol.andThen(upon:start:)
     public func andThen<NewTask: TaskProtocol>(upon executor: Executor, start startNextTask: @escaping(Success) throws -> NewTask) -> Task<NewTask.Success> {
         #if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
-        let chain = TaskChain(continuingWith: self)
+        let chain = TaskChain(andThenFrom: self)
         #else
         let cancellationToken = Deferred<Void>()
         #endif

Sources/Task/TaskChain.swift

@@ -19,9 +19,12 @@ struct TaskChain {
     /// The default work unit count for a single call to a `Task` initializer or
     /// chaining method.
     private static let singleUnit = Int64(1)
+    /// The work unit count applied when a chaining method may later determine
+    /// a higher or lower unit count.
+    private static let undeterminedUnit = Int64(8)
     /// The work unit count when a `Task` initializer or chaining method accepts
     /// an user-provided `Progress` instance.
-    private static let explicitChildUnitCount = Int64(100)
+    private static let explicitChildUnitCount = Int64(20)
 
     /// Marker class representing the start of a task chain.
     ///
@@ -90,8 +93,8 @@ struct TaskChain {
             self.root = root
             self.effectiveProgress = root
         } else {
-            // Create a "root" progress for the task and its follow-up steps.
-            // If the initial operation provides progress, give it a 100x slice.
+            // Create a "root" progress for the task and its follow-up steps. If
+            // the initial operation provides progress, give it a larger slice.
             let unitCount = customProgress == nil ? TaskChain.singleUnit : TaskChain.explicitChildUnitCount
             self.root = Root()
             self.root.totalUnitCount = unitCount
@@ -107,17 +110,17 @@ struct TaskChain {
 
     /// Locates or creates the root of a task chain, then increments its
     /// total units in preparation for a follow-up operation to be performed.
-    init<Wrapped: TaskProtocol>(continuingWith wrapped: Wrapped) {
+    private init<Wrapped: TaskProtocol>(continuingFrom wrapped: Wrapped, pendingUnitCount: Int64) {
         if let task = wrapped as? Task<Wrapped.Success>, let root = task.progress as? Root {
             // If `wrapped` is a Task created normally, reuse the progress root;
             // this `map` or `andThen` builds on that progress.
+            root.totalUnitCount += pendingUnitCount
             self.root = root
-            self.root.totalUnitCount += TaskChain.singleUnit
             self.effectiveProgress = root
         } else {
             // If `wrapped` is a `Future` or something else, start a new chain.
             self.root = Root()
-            self.root.totalUnitCount = TaskChain.singleUnit * 2
+            self.root.totalUnitCount = TaskChain.singleUnit + pendingUnitCount
             self.effectiveProgress = root
 
             root.monitorCompletion(of: wrapped, withPendingUnitCount: TaskChain.singleUnit)
@@ -126,9 +129,15 @@ struct TaskChain {
 
     // MARK: -
 
+    /// Locates or creates the root of a task chain, then increments its
+    /// total units in preparation for a follow-up operation to be performed.
+    init<Wrapped: TaskProtocol>(mapFrom wrapped: Wrapped) {
+        self.init(continuingFrom: wrapped, pendingUnitCount: TaskChain.singleUnit)
+    }
+
     /// The handler passed to `map` can use implicit progress reporting.
     /// During the handler, the first `Progress` object created using
-    /// `parent: .current()` will be given a 100x slice of the task chain on
+    /// `parent: .current()` will be given a larger slice of the task chain on
     /// macOS 10.11, iOS 9, and above.
     func beginMap() {
         root.expandsAddedChildren = true
@@ -143,22 +152,29 @@ struct TaskChain {
 
     // MARK: -
 
+    /// Locates or creates the root of a task chain, then increments its
+    /// total units in preparation for a follow-up operation to be performed.
+    init<Wrapped: TaskProtocol>(andThenFrom wrapped: Wrapped) {
+        self.init(continuingFrom: wrapped, pendingUnitCount: TaskChain.undeterminedUnit)
+    }
+
     /// The handler passed to `andThen` uses explicit progress reporting.
     /// After returning a from the handler, locate or create a representative
     /// progress and attach it to the root. If this next step provides custom
-    /// progress, give it a 100x slice.
+    /// progress, give it a larger slice.
     func beginAndThen() {
         Root.activeStack.append(root)
     }
 
     /// See `beginAndThen`.
     func commitAndThen<Wrapped: TaskProtocol>(with wrapped: Wrapped) {
-        if let task = wrapped as? Task<Wrapped.Success> {
-            let pendingUnitCount = task.progress.wasGeneratedByTask ? TaskChain.singleUnit : TaskChain.explicitChildUnitCount
-            root.totalUnitCount += pendingUnitCount - TaskChain.singleUnit
-            root.monitorChild(task.progress, withPendingUnitCount: pendingUnitCount)
+        let wrappedProgress = (wrapped as? Task<Wrapped.Success>)?.progress
+        let pendingUnitCount = wrappedProgress?.wasGeneratedByTask == false ? TaskChain.explicitChildUnitCount : TaskChain.singleUnit
+        root.totalUnitCount += pendingUnitCount - TaskChain.undeterminedUnit
+        if let wrappedProgress = wrappedProgress {
+            root.monitorChild(wrappedProgress, withPendingUnitCount: pendingUnitCount)
         } else {
-            root.monitorCompletion(of: wrapped, uponCancel: wrapped.cancel, withPendingUnitCount: TaskChain.singleUnit)
+            root.monitorCompletion(of: wrapped, uponCancel: wrapped.cancel, withPendingUnitCount: pendingUnitCount)
         }
         Root.activeStack.removeLast()
     }
@@ -168,6 +184,7 @@ struct TaskChain {
     func flushAndThen() {
         root.becomeCurrent(withPendingUnitCount: TaskChain.singleUnit)
         root.resignCurrent()
+        root.totalUnitCount += TaskChain.singleUnit - TaskChain.undeterminedUnit
         Root.activeStack.removeLast()
     }
 }

Sources/Task/TaskFallback.swift

@@ -42,7 +42,7 @@ extension TaskProtocol {
     /// - see: FutureProtocol.andThen(upon:start:)
     public func fallback<NewTask: TaskProtocol>(upon executor: Executor, to restartTask: @escaping(Failure) throws -> NewTask) -> Task<Success> where NewTask.Success == Success {
         #if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
-        let chain = TaskChain(continuingWith: self)
+        let chain = TaskChain(andThenFrom: self)
         #else
         let cancellationToken = Deferred<Void>()
         #endif

Sources/Task/TaskMap.swift

@@ -39,7 +39,7 @@ extension TaskProtocol {
     /// - see: FutureProtocol.map(upon:transform:)
     public func map<NewSuccess>(upon executor: Executor, transform: @escaping(Success) throws -> NewSuccess) -> Task<NewSuccess> {
         #if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
-        let chain = TaskChain(continuingWith: self)
+        let chain = TaskChain(mapFrom: self)
         #endif
 
         let future: Future = map(upon: executor) { (result) -> Task<NewSuccess>.Result in

Sources/Task/TaskRecovery.swift

@@ -40,7 +40,7 @@ extension TaskProtocol {
     /// - see: FutureProtocol.map(upon:transform:)
     public func recover(upon executor: Executor, substituting substitution: @escaping(Failure) throws -> Success) -> Task<Success> {
         #if os(macOS) || os(iOS) || os(tvOS) || os(watchOS)
-        let chain = TaskChain(continuingWith: self)
+        let chain = TaskChain(andThenFrom: self)
         #endif
 
         let future: Future = map(upon: executor) { (result) -> Task<Success>.Result in