Rename onComplete/onSuccess/onFailure to then/success/failure.

inamiy · inamiy · commit 79dfe36b5f96 · 2014-11-18T21:29:29.000+09:00
diff --git a/README.md b/README.md
@@ -5,13 +5,12 @@ SwiftTask
 
 ![SwiftTask](Screenshots/diagram.png)
 
-### Ver 2.0.0 Changelog
+### Ver 2.0.0 Changelog (2014/11/18)
 
-- `task.progress()` is renamed to `task.onProgress()`
-    - `progressClosure`'s closure type changed from `Progress -> Void` to `(oldProgress: Progress?, newProgress: Progress) -> Void`
-- `task.then(thenClosure)` is renamed to `task.onComplete()`
-- `task.then(fulfilledClosure)` is renamed to `task.onSuccess()`
-- `task.catch(catchClosure)` is renamed to `task.onFailure()`
+- `task.progress()`'s `progressClosure` type changed from `Progress -> Void` to `(oldProgress: Progress?, newProgress: Progress) -> Void`
+- `task.then(fulfilledClosure)` is renamed to `task.success()`
+- `task.catch(catchClosure)` is renamed to `task.failure()`
+- `task.then()` is no longer used for fulfilled-only handling (this will improve Swift type-inference)
 
 
 ## Example
diff --git a/SwiftTask/SwiftTask.swift b/SwiftTask/SwiftTask.swift
@@ -199,7 +199,7 @@ public class Task<Progress, Value, Error>
         }
         
         // TODO: how to nest these inside StateMachine's initClosure? (using `self` is not permitted)
-        // NOTE: use order > 100 (default) to let `progressClosure(self.progress, newValue)` be invoked first before updating old `self.progress`
+        // NOTE: use order > 100 (default) to let `progressClosure(self.progress, newProgress)` be invoked first before updating old `self.progress`
         self.machine.addEventHandler(.Progress, order: 110) { [weak self] context in
             if let progress = context.userInfo as? Progress {
                 if let self_ = self {
@@ -278,33 +278,32 @@ public class Task<Progress, Value, Error>
         self._cancel(error: nil)
     }
     
-    /// task.onProgress
-    public func onProgress(progressClosure: (oldValue: Progress?, newValue: Progress) -> Void) -> Task
+    public func progress(progressClosure: (oldProgress: Progress?, newProgress: Progress) -> Void) -> Task
     {
         self.machine.addEventHandler(.Progress) { [weak self] context in
             if let progress = context.userInfo as? Progress {
-                progressClosure(oldValue: self?.progress, newValue: progress)
+                progressClosure(oldProgress: self?.progress, newProgress: progress)
             }
         }
         
         return self
     }
     
-    /// onComplete (fulfilled & rejected) + closure returning value
-    public func onComplete<Value2>(completeClosure: (Value?, ErrorInfo?) -> Value2) -> Task<Progress, Value2, Error>
+    /// then (fulfilled & rejected) + closure returning value
+    public func then<Value2>(thenClosure: (Value?, ErrorInfo?) -> Value2) -> Task<Progress, Value2, Error>
     {
-        return self.onComplete { (value: Value?, errorInfo: ErrorInfo?) -> Task<Progress, Value2, Error> in
-            return Task<Progress, Value2, Error>(value: completeClosure(value, errorInfo))
+        return self.then { (value: Value?, errorInfo: ErrorInfo?) -> Task<Progress, Value2, Error> in
+            return Task<Progress, Value2, Error>(value: thenClosure(value, errorInfo))
         }
     }
     
-    /// onComplete (fulfilled & rejected) + closure returning task
-    public func onComplete<Progress2, Value2>(completeClosure: (Value?, ErrorInfo?) -> Task<Progress2, Value2, Error>) -> Task<Progress2, Value2, Error>
+    /// then (fulfilled & rejected) + closure returning task
+    public func then<Progress2, Value2>(thenClosure: (Value?, ErrorInfo?) -> Task<Progress2, Value2, Error>) -> Task<Progress2, Value2, Error>
     {
         let newTask = Task<Progress2, Value2, Error> { [weak self] (progress, fulfill, _reject: _RejectHandler, configure) in
             
             let bind = { (value: Value?, errorInfo: ErrorInfo?) -> Void in
-                let innerTask = completeClosure(value, errorInfo)
+                let innerTask = thenClosure(value, errorInfo)
                 
                 // NOTE: don't call `then` for innerTask, or recursive bindings may occur
                 // Bad example: https://github.com/inamiy/SwiftTask/blob/e6085465c147fb2211fb2255c48929fcc07acd6d/SwiftTask/SwiftTask.swift#L312-L316
@@ -356,23 +355,23 @@ public class Task<Progress, Value, Error>
         return newTask
     }
     
-    /// onSuccess + closure returning value
-    public func onSuccess<Value2>(fulfilledClosure: Value -> Value2) -> Task<Progress, Value2, Error>
+    /// success (fulfilled) + closure returning value
+    public func success<Value2>(fulfilledClosure: Value -> Value2) -> Task<Progress, Value2, Error>
     {
-        return self.onSuccess { (value: Value) -> Task<Progress, Value2, Error> in
+        return self.success { (value: Value) -> Task<Progress, Value2, Error> in
             return Task<Progress, Value2, Error>(value: fulfilledClosure(value))
         }
     }
     
-    /// onSuccess + closure returning task
-    public func onSuccess<Progress2, Value2>(fulfilledClosure: Value -> Task<Progress2, Value2, Error>) -> Task<Progress2, Value2, Error>
+    /// success (fulfilled) + closure returning task
+    public func success<Progress2, Value2>(fulfilledClosure: Value -> Task<Progress2, Value2, Error>) -> Task<Progress2, Value2, Error>
     {
         let newTask = Task<Progress2, Value2, Error> { [weak self] (progress, fulfill, _reject: _RejectHandler, configure) in
             
             let bind = { (value: Value) -> Void in
                 let innerTask = fulfilledClosure(value)
                 
-                innerTask.onComplete { (value: Value2?, errorInfo: ErrorInfo?) -> Void in
+                innerTask.then { (value: Value2?, errorInfo: ErrorInfo?) -> Void in
                     if let value = value {
                         fulfill(value)
                     }
@@ -411,23 +410,23 @@ public class Task<Progress, Value, Error>
         return newTask
     }
     
-    /// onFailure + closure returning value
-    public func onFailure(failureClosure: ErrorInfo -> Value) -> Task
+    /// failure (rejected) + closure returning value
+    public func failure(failureClosure: ErrorInfo -> Value) -> Task
     {
-        return self.onFailure { (errorInfo: ErrorInfo) -> Task in
+        return self.failure { (errorInfo: ErrorInfo) -> Task in
             return Task(value: failureClosure(errorInfo))
         }
     }
 
-    /// onFailure + closure returning task
-    public func onFailure(failureClosure: ErrorInfo -> Task) -> Task
+    /// failure (rejected) + closure returning task
+    public func failure(failureClosure: ErrorInfo -> Task) -> Task
     {
         let newTask = Task { [weak self] (progress, fulfill, _reject: _RejectHandler, configure) in
             
             let bind = { (errorInfo: ErrorInfo) -> Void in
                 let innerTask = failureClosure(errorInfo)
                 
-                innerTask.onComplete { (value: Value?, errorInfo: ErrorInfo?) -> Void in
+                innerTask.then { (value: Value?, errorInfo: ErrorInfo?) -> Void in
                     if let value = value {
                         fulfill(value)
                     }
@@ -498,7 +497,7 @@ extension Task
             let totalCount = tasks.count
             
             for task in tasks {
-                task.onSuccess { (value: Value) -> Void in
+                task.success { (value: Value) -> Void in
                     
                     synchronized(self) {
                         completedCount++
@@ -517,7 +516,7 @@ extension Task
                         }
                     }
                     
-                }.onFailure { (errorInfo: ErrorInfo) -> Void in
+                }.failure { (errorInfo: ErrorInfo) -> Void in
                     
                     synchronized(self) {
                         _reject(errorInfo)
@@ -545,7 +544,7 @@ extension Task
             let totalCount = tasks.count
             
             for task in tasks {
-                task.onSuccess { (value: Value) -> Void in
+                task.success { (value: Value) -> Void in
                     
                     synchronized(self) {
                         completedCount++
@@ -557,7 +556,7 @@ extension Task
                         }
                     }
                     
-                }.onFailure { (errorInfo: ErrorInfo) -> Void in
+                }.failure { (errorInfo: ErrorInfo) -> Void in
                     
                     synchronized(self) {
                         rejectedCount++
@@ -589,7 +588,7 @@ extension Task
             let totalCount = tasks.count
             
             for task in tasks {
-                task.onComplete { (value: Value?, errorInfo: ErrorInfo?) -> Void in
+                task.then { (value: Value?, errorInfo: ErrorInfo?) -> Void in
                     
                     synchronized(self) {
                         completedCount++
diff --git a/SwiftTaskTests/AlamofireTests.swift b/SwiftTaskTests/AlamofireTests.swift
@@ -39,7 +39,7 @@ class AlamofireTests: _TestCase
             
         }
         
-        task.onComplete { (value: String) -> Void in
+        task.then { (value: String) -> Void in
             XCTAssertEqual(value, "OK")
             
             expect.fulfill()
@@ -74,11 +74,11 @@ class AlamofireTests: _TestCase
             
         }
             
-        task.onComplete { (value: String?) -> Void in
+        task.then { (value: String?) -> Void in
             
             XCTFail("Should never reach here.")
             
-        }.onFailure { (error: NSError?, isCancelled: Bool) -> Void in
+        }.failure { (error: NSError?, isCancelled: Bool) -> Void in
             
 //            println(error)
             
@@ -123,14 +123,14 @@ class AlamofireTests: _TestCase
             
         }
         
-        // set onProgress & onComplete
-        task.onProgress { progress in
+        // set progress & then
+        task.progress { progress in
             
             println("bytesWritten = \(progress.bytesWritten)")
             println("totalBytesWritten = \(progress.totalBytesWritten)")
             println("totalBytesExpectedToWrite = \(progress.totalBytesExpectedToWrite)")
             
-        }.onComplete { (value: String) -> Void in
+        }.then { (value: String) -> Void in
             
             XCTAssertEqual(value, "OK")
             
@@ -173,7 +173,7 @@ class AlamofireTests: _TestCase
         }
         
         // set then
-        task.onComplete { (value: String) -> Void in
+        task.then { (value: String) -> Void in
             
             XCTAssertEqual(value, "OK")
             XCTAssertEqual(nsProgress.completedUnitCount, 50)
@@ -226,13 +226,13 @@ class AlamofireTests: _TestCase
                 }
             }
             
-        } // end of 1st task definition (NOTE: don't chain with `onComplete` or `onFailure` for 1st task cancellation)
+        } // end of 1st task definition (NOTE: don't chain with `then` or `failure` for 1st task cancellation)
             
-        task.onComplete { (value: String?) -> Void in
+        task.then { (value: String?) -> Void in
             
             XCTFail("Should never reach here because task is cancelled.")
             
-        }.onFailure { (error: NSError?, isCancelled: Bool) -> Void in
+        }.failure { (error: NSError?, isCancelled: Bool) -> Void in
             
 //            println(error)
             
diff --git a/SwiftTaskTests/BasicTests.swift b/SwiftTaskTests/BasicTests.swift
@@ -36,21 +36,21 @@ class BasicTests: _TestCase
             
         }
         
-        task.onProgress { oldValue, newValue in
+        task.progress { oldProgress, newProgress in
             
-            println("progress = \(newValue)")
+            println("progress = \(newProgress)")
             
-        }.onSuccess { value -> String in  // `task.onSuccess {...}` = JavaScript's `promise.then(onFulfilled)`
+        }.success { value -> String in  // `task.success {...}` = JavaScript's `promise.then(onFulfilled)`
             
             XCTAssertEqual(value, "OK")
             return "Now OK"
             
-        }.onFailure { error, isCancelled -> String in  // `task.onFailure {...}` = JavaScript's `promise.catch(onRejected)`
+        }.failure { error, isCancelled -> String in  // `task.failure {...}` = JavaScript's `promise.catch(onRejected)`
             
             XCTAssertEqual(error!, "ERROR")
             return "Now RECOVERED"
             
-        }.onComplete { (value: String?, errorInfo: Task.ErrorInfo?) -> Task in // `task.onComplete {...}` = JavaScript's `promise.then(onFulfilled, onRejected)`
+        }.then { value, errorInfo -> Task in // `task.then {...}` = JavaScript's `promise.then(onFulfilled, onRejected)`
             
             println("value = \(value)") // either "Now OK" or "Now RECOVERED"
             
@@ -59,7 +59,7 @@ class BasicTests: _TestCase
             
             return Task(error: "ABORT")
             
-        }.onComplete { (value: String?, errorInfo: Task.ErrorInfo?) -> Void in
+        }.then { value, errorInfo -> Void in
                 
             println("errorInfo = \(errorInfo)")
             
diff --git a/SwiftTaskTests/RetainCycleTests.swift b/SwiftTaskTests/RetainCycleTests.swift
@@ -78,7 +78,7 @@ class RetainCycleTests: _TestCase
         XCTAssertNotNil(self.task, "self.task (weak) should NOT be nil because of retain cycle: task <- dispatch_queue.")
         XCTAssertNotNil(self.player, "self.player (weak) should NOT nil because player is not retained by dispatch_queue.")
         
-        self.task!.onSuccess { value -> Void in
+        self.task!.success { value -> Void in
             
             XCTAssertEqual(value, "OK")
             expect.fulfill()
@@ -124,7 +124,7 @@ class RetainCycleTests: _TestCase
         XCTAssertNotNil(self.task, "self.task (weak) should NOT be nil because of retain cycle: task <- dispatch_queue.")
         XCTAssertNotNil(self.player, "self.player (weak) should NOT be nil because of retain cycle: player <- configure <- task.")
         
-        self.task!.onSuccess { value -> Void in
+        self.task!.success { value -> Void in
             
             XCTAssertEqual(value, "OK")
             expect.fulfill()
@@ -166,7 +166,7 @@ class RetainCycleTests: _TestCase
         XCTAssertNotNil(self.task, "self.task (weak) should not be nil because of retain cycle: task <- player <- dispatch_queue.")
         XCTAssertNotNil(self.player, "self.player (weak) should not be nil because of retain cycle: player <- configure <- task.")
         
-        self.task!.onSuccess { value -> Void in
+        self.task!.success { value -> Void in
             
             XCTAssertEqual(value, "OK")
             expect.fulfill()
@@ -210,7 +210,7 @@ class RetainCycleTests: _TestCase
         XCTAssertNotNil(self.task, "self.task (weak) should not be nil because of retain cycle: task <- player <- dispatch_queue.")
         XCTAssertNotNil(self.player, "self.player (weak) should not be nil because of retain cycle: player <- configure <- task.")
         
-        self.task!.onSuccess { value -> Void in
+        self.task!.success { value -> Void in
             
             XCTAssertEqual(value, "OK")
             expect.fulfill()
diff --git a/SwiftTaskTests/SwiftTaskTests.swift b/SwiftTaskTests/SwiftTaskTests.swift

Original file line number	Diff line number	Diff line change
`@@ -199,7 +199,7 @@ public class Task<Progress, Value, Error>`
`199`	`199`	`}`
`200`	`200`
`201`	`201`	// TODO: how to nest these inside StateMachine's initClosure? (using `self` is not permitted)
`202`		- // NOTE: use order > 100 (default) to let `progressClosure(self.progress, newValue)` be invoked first before updating old `self.progress`
	`202`	+ // NOTE: use order > 100 (default) to let `progressClosure(self.progress, newProgress)` be invoked first before updating old `self.progress`
`203`	`203`	`self.machine.addEventHandler(.Progress, order: 110) { [weak self] context in`
`204`	`204`	`if let progress = context.userInfo as? Progress {`
`205`	`205`	`if let self_ = self {`
`@@ -278,33 +278,32 @@ public class Task<Progress, Value, Error>`
`278`	`278`	`self._cancel(error: nil)`
`279`	`279`	`}`
`280`	`280`
`281`		`- /// task.onProgress`
`282`		`- public func onProgress(progressClosure: (oldValue: Progress?, newValue: Progress) -> Void) -> Task`
	`281`	`+ public func progress(progressClosure: (oldProgress: Progress?, newProgress: Progress) -> Void) -> Task`
`283`	`282`	`{`
`284`	`283`	`self.machine.addEventHandler(.Progress) { [weak self] context in`
`285`	`284`	`if let progress = context.userInfo as? Progress {`
`286`		`- progressClosure(oldValue: self?.progress, newValue: progress)`
	`285`	`+ progressClosure(oldProgress: self?.progress, newProgress: progress)`
`287`	`286`	`}`
`288`	`287`	`}`
`289`	`288`
`290`	`289`	`return self`
`291`	`290`	`}`
`292`	`291`
`293`		`- /// onComplete (fulfilled & rejected) + closure returning value`
`294`		`- public func onComplete<Value2>(completeClosure: (Value?, ErrorInfo?) -> Value2) -> Task<Progress, Value2, Error>`
	`292`	`+ /// then (fulfilled & rejected) + closure returning value`
	`293`	`+ public func then<Value2>(thenClosure: (Value?, ErrorInfo?) -> Value2) -> Task<Progress, Value2, Error>`
`295`	`294`	`{`
`296`		`- return self.onComplete { (value: Value?, errorInfo: ErrorInfo?) -> Task<Progress, Value2, Error> in`
`297`		`- return Task<Progress, Value2, Error>(value: completeClosure(value, errorInfo))`
	`295`	`+ return self.then { (value: Value?, errorInfo: ErrorInfo?) -> Task<Progress, Value2, Error> in`
	`296`	`+ return Task<Progress, Value2, Error>(value: thenClosure(value, errorInfo))`
`298`	`297`	`}`
`299`	`298`	`}`
`300`	`299`
`301`		`- /// onComplete (fulfilled & rejected) + closure returning task`
`302`		`- public func onComplete<Progress2, Value2>(completeClosure: (Value?, ErrorInfo?) -> Task<Progress2, Value2, Error>) -> Task<Progress2, Value2, Error>`
	`300`	`+ /// then (fulfilled & rejected) + closure returning task`
	`301`	`+ public func then<Progress2, Value2>(thenClosure: (Value?, ErrorInfo?) -> Task<Progress2, Value2, Error>) -> Task<Progress2, Value2, Error>`
`303`	`302`	`{`
`304`	`303`	`let newTask = Task<Progress2, Value2, Error> { [weak self] (progress, fulfill, _reject: _RejectHandler, configure) in`
`305`	`304`
`306`	`305`	`let bind = { (value: Value?, errorInfo: ErrorInfo?) -> Void in`
`307`		`- let innerTask = completeClosure(value, errorInfo)`
	`306`	`+ let innerTask = thenClosure(value, errorInfo)`
`308`	`307`
`309`	`308`	// NOTE: don't call `then` for innerTask, or recursive bindings may occur
`310`	`309`	`// Bad example: https://github.com/inamiy/SwiftTask/blob/e6085465c147fb2211fb2255c48929fcc07acd6d/SwiftTask/SwiftTask.swift#L312-L316`
`@@ -356,23 +355,23 @@ public class Task<Progress, Value, Error>`
`356`	`355`	`return newTask`
`357`	`356`	`}`
`358`	`357`
`359`		`- /// onSuccess + closure returning value`
`360`		`- public func onSuccess<Value2>(fulfilledClosure: Value -> Value2) -> Task<Progress, Value2, Error>`
	`358`	`+ /// success (fulfilled) + closure returning value`
	`359`	`+ public func success<Value2>(fulfilledClosure: Value -> Value2) -> Task<Progress, Value2, Error>`
`361`	`360`	`{`
`362`		`- return self.onSuccess { (value: Value) -> Task<Progress, Value2, Error> in`
	`361`	`+ return self.success { (value: Value) -> Task<Progress, Value2, Error> in`
`363`	`362`	`return Task<Progress, Value2, Error>(value: fulfilledClosure(value))`
`364`	`363`	`}`
`365`	`364`	`}`
`366`	`365`
`367`		`- /// onSuccess + closure returning task`
`368`		`- public func onSuccess<Progress2, Value2>(fulfilledClosure: Value -> Task<Progress2, Value2, Error>) -> Task<Progress2, Value2, Error>`
	`366`	`+ /// success (fulfilled) + closure returning task`
	`367`	`+ public func success<Progress2, Value2>(fulfilledClosure: Value -> Task<Progress2, Value2, Error>) -> Task<Progress2, Value2, Error>`
`369`	`368`	`{`
`370`	`369`	`let newTask = Task<Progress2, Value2, Error> { [weak self] (progress, fulfill, _reject: _RejectHandler, configure) in`
`371`	`370`
`372`	`371`	`let bind = { (value: Value) -> Void in`
`373`	`372`	`let innerTask = fulfilledClosure(value)`
`374`	`373`
`375`		`- innerTask.onComplete { (value: Value2?, errorInfo: ErrorInfo?) -> Void in`
	`374`	`+ innerTask.then { (value: Value2?, errorInfo: ErrorInfo?) -> Void in`
`376`	`375`	`if let value = value {`
`377`	`376`	`fulfill(value)`
`378`	`377`	`}`
`@@ -411,23 +410,23 @@ public class Task<Progress, Value, Error>`
`411`	`410`	`return newTask`
`412`	`411`	`}`
`413`	`412`
`414`		`- /// onFailure + closure returning value`
`415`		`- public func onFailure(failureClosure: ErrorInfo -> Value) -> Task`
	`413`	`+ /// failure (rejected) + closure returning value`
	`414`	`+ public func failure(failureClosure: ErrorInfo -> Value) -> Task`
`416`	`415`	`{`
`417`		`- return self.onFailure { (errorInfo: ErrorInfo) -> Task in`
	`416`	`+ return self.failure { (errorInfo: ErrorInfo) -> Task in`
`418`	`417`	`return Task(value: failureClosure(errorInfo))`
`419`	`418`	`}`
`420`	`419`	`}`
`421`	`420`
`422`		`- /// onFailure + closure returning task`
`423`		`- public func onFailure(failureClosure: ErrorInfo -> Task) -> Task`
	`421`	`+ /// failure (rejected) + closure returning task`
	`422`	`+ public func failure(failureClosure: ErrorInfo -> Task) -> Task`
`424`	`423`	`{`
`425`	`424`	`let newTask = Task { [weak self] (progress, fulfill, _reject: _RejectHandler, configure) in`
`426`	`425`
`427`	`426`	`let bind = { (errorInfo: ErrorInfo) -> Void in`
`428`	`427`	`let innerTask = failureClosure(errorInfo)`
`429`	`428`
`430`		`- innerTask.onComplete { (value: Value?, errorInfo: ErrorInfo?) -> Void in`
	`429`	`+ innerTask.then { (value: Value?, errorInfo: ErrorInfo?) -> Void in`
`431`	`430`	`if let value = value {`
`432`	`431`	`fulfill(value)`
`433`	`432`	`}`
`@@ -498,7 +497,7 @@ extension Task`
`498`	`497`	`let totalCount = tasks.count`
`499`	`498`
`500`	`499`	`for task in tasks {`
`501`		`- task.onSuccess { (value: Value) -> Void in`
	`500`	`+ task.success { (value: Value) -> Void in`
`502`	`501`
`503`	`502`	`synchronized(self) {`
`504`	`503`	`completedCount++`
`@@ -517,7 +516,7 @@ extension Task`
`517`	`516`	`}`
`518`	`517`	`}`
`519`	`518`
`520`		`- }.onFailure { (errorInfo: ErrorInfo) -> Void in`
	`519`	`+ }.failure { (errorInfo: ErrorInfo) -> Void in`
`521`	`520`
`522`	`521`	`synchronized(self) {`
`523`	`522`	`_reject(errorInfo)`
`@@ -545,7 +544,7 @@ extension Task`
`545`	`544`	`let totalCount = tasks.count`
`546`	`545`
`547`	`546`	`for task in tasks {`
`548`		`- task.onSuccess { (value: Value) -> Void in`
	`547`	`+ task.success { (value: Value) -> Void in`
`549`	`548`
`550`	`549`	`synchronized(self) {`
`551`	`550`	`completedCount++`
`@@ -557,7 +556,7 @@ extension Task`
`557`	`556`	`}`
`558`	`557`	`}`
`559`	`558`
`560`		`- }.onFailure { (errorInfo: ErrorInfo) -> Void in`
	`559`	`+ }.failure { (errorInfo: ErrorInfo) -> Void in`
`561`	`560`
`562`	`561`	`synchronized(self) {`
`563`	`562`	`rejectedCount++`
`@@ -589,7 +588,7 @@ extension Task`
`589`	`588`	`let totalCount = tasks.count`
`590`	`589`
`591`	`590`	`for task in tasks {`
`592`		`- task.onComplete { (value: Value?, errorInfo: ErrorInfo?) -> Void in`
	`591`	`+ task.then { (value: Value?, errorInfo: ErrorInfo?) -> Void in`
`593`	`592`
`594`	`593`	`synchronized(self) {`
`595`	`594`	`completedCount++`