Remove removeProgress() & removeThen(), add Cancellable instead.

inamiy · inamiy · commit 8a22ed56e62a · 2015-05-10T00:34:30.000+09:00
diff --git a/SwiftTask.xcodeproj/project.pbxproj b/SwiftTask.xcodeproj/project.pbxproj
@@ -20,6 +20,8 @@
 		1FCF71141AD8CD2F007079C2 /* Async.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 1FCF71131AD8CD2F007079C2 /* Async.framework */; };
 		1FCF71161AD8CD38007079C2 /* Alamofire.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 1FCF71151AD8CD38007079C2 /* Alamofire.framework */; };
 		1FCF71181AD8CD3C007079C2 /* Async.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 1FCF71171AD8CD3C007079C2 /* Async.framework */; };
+		1FD7197B1AFE387C00BC38C4 /* Cancellable.swift in Sources */ = {isa = PBXBuildFile; fileRef = 1FD7197A1AFE387C00BC38C4 /* Cancellable.swift */; };
+		1FD7197C1AFE387C00BC38C4 /* Cancellable.swift in Sources */ = {isa = PBXBuildFile; fileRef = 1FD7197A1AFE387C00BC38C4 /* Cancellable.swift */; };
 		1FF52EB41A4C395A00B4BA28 /* _InterruptableTask.swift in Sources */ = {isa = PBXBuildFile; fileRef = 1FF52EB31A4C395A00B4BA28 /* _InterruptableTask.swift */; };
 		1FF52EB51A4C395A00B4BA28 /* _InterruptableTask.swift in Sources */ = {isa = PBXBuildFile; fileRef = 1FF52EB31A4C395A00B4BA28 /* _InterruptableTask.swift */; };
 		4822F0DC19D00B2300F5F572 /* _TestCase.swift in Sources */ = {isa = PBXBuildFile; fileRef = 1F46DEFC199EE2C200F97868 /* _TestCase.swift */; };
@@ -53,6 +55,7 @@
 		1FCF71131AD8CD2F007079C2 /* Async.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Async.framework; path = "../Carthage/Checkouts/Async/build/Debug-iphoneos/Async.framework"; sourceTree = "<group>"; };
 		1FCF71151AD8CD38007079C2 /* Alamofire.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Alamofire.framework; path = ../Carthage/Checkouts/Alamofire/build/Debug/Alamofire.framework; sourceTree = "<group>"; };
 		1FCF71171AD8CD3C007079C2 /* Async.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Async.framework; path = ../Carthage/Checkouts/Async/build/Debug/Async.framework; sourceTree = "<group>"; };
+		1FD7197A1AFE387C00BC38C4 /* Cancellable.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = Cancellable.swift; sourceTree = "<group>"; };
 		1FF52EB31A4C395A00B4BA28 /* _InterruptableTask.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = _InterruptableTask.swift; sourceTree = "<group>"; };
 		4822F0D019D00ABF00F5F572 /* SwiftTask-iOSTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = "SwiftTask-iOSTests.xctest"; sourceTree = BUILT_PRODUCTS_DIR; };
 		48511C5A19C17563002FE03C /* RetainCycleTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = RetainCycleTests.swift; sourceTree = "<group>"; };
@@ -124,6 +127,7 @@
 			children = (
 				1F46DED9199EDF1000F97868 /* SwiftTask.h */,
 				1F46DEFA199EDF8100F97868 /* SwiftTask.swift */,
+				1FD7197A1AFE387C00BC38C4 /* Cancellable.swift */,
 				48B58D7A1A6F255E0068E18C /* _StateMachine.swift */,
 				1F46DED7199EDF1000F97868 /* Supporting Files */,
 			);
@@ -339,6 +343,7 @@
 			buildActionMask = 2147483647;
 			files = (
 				1F46DEFB199EDF8100F97868 /* SwiftTask.swift in Sources */,
+				1FD7197B1AFE387C00BC38C4 /* Cancellable.swift in Sources */,
 				48B58D7B1A6F255E0068E18C /* _StateMachine.swift in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
@@ -378,6 +383,7 @@
 			buildActionMask = 2147483647;
 			files = (
 				48CD5A3C19AEEBDF0042B9F1 /* SwiftTask.swift in Sources */,
+				1FD7197C1AFE387C00BC38C4 /* Cancellable.swift in Sources */,
 				48B58D7C1A6F255E0068E18C /* _StateMachine.swift in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
diff --git a/SwiftTask/Cancellable.swift b/SwiftTask/Cancellable.swift
@@ -0,0 +1,45 @@
+//
+//  Cancellable.swift
+//  SwiftTask
+//
+//  Created by Yasuhiro Inami on 2015/05/09.
+//  Copyright (c) 2015年 Yasuhiro Inami. All rights reserved.
+//
+
+import Foundation
+
+public protocol Cancellable
+{
+    typealias Error
+    
+    func cancel(error: Error) -> Bool
+}
+
+public class Canceller: Cancellable
+{
+    private var cancelHandler: (Void -> Void)?
+    
+    public required init(cancelHandler: Void -> Void)
+    {
+        self.cancelHandler = cancelHandler
+    }
+    
+    public func cancel(error: Void) -> Bool
+    {
+        if let cancelHandler = self.cancelHandler {
+            self.cancelHandler = nil
+            cancelHandler()
+            return true
+        }
+        
+        return false
+    }
+}
+
+public class AutoCanceller: Canceller
+{
+    deinit
+    {
+        self.cancel()
+    }
+}
diff --git a/SwiftTask/SwiftTask.swift b/SwiftTask/SwiftTask.swift
@@ -57,7 +57,7 @@ public class TaskConfiguration
     }
 }
 
-public class Task<Progress, Value, Error>: Printable
+public class Task<Progress, Value, Error>: Cancellable, Printable
 {
     public typealias ProgressTuple = (oldProgress: Progress?, newProgress: Progress)
     public typealias ErrorInfo = (error: Error?, isCancelled: Bool)
@@ -213,7 +213,8 @@ public class Task<Progress, Value, Error>: Printable
     internal func setup(#weakified: Bool, paused: Bool, _initClosure: _InitClosure)
     {
 //        #if DEBUG
-//            println("[init] \(self.name)")
+//            let addr = String(format: "%p", unsafeAddressOf(self))
+//            NSLog("[init] \(self.name) \(addr)")
 //        #endif
         
         self._initClosure = _initClosure
@@ -287,7 +288,8 @@ public class Task<Progress, Value, Error>: Printable
     deinit
     {
 //        #if DEBUG
-//            println("[deinit] \(self.name)")
+//            let addr = String(format: "%p", unsafeAddressOf(self))
+//            NSLog("[deinit] \(self.name) \(addr)")
 //        #endif
         
         // cancel in case machine is still running
@@ -355,14 +357,19 @@ public class Task<Progress, Value, Error>: Printable
     ///
     public func progress(progressClosure: ProgressTuple -> Void) -> Task
     {
-        var token: HandlerToken? = nil
-        return self.progress(&token, progressClosure)
+        var dummyCanceller: Canceller? = nil
+        return self.progress(&dummyCanceller, progressClosure)
     }
     
-    public func progress(inout token: HandlerToken?, _ progressClosure: ProgressTuple -> Void) -> Task
+    public func progress<C: Canceller>(inout canceller: C?, _ progressClosure: ProgressTuple -> Void) -> Task
     {
+        var token: _HandlerToken? = nil
         self._machine.addProgressTupleHandler(&token, progressClosure)
         
+        canceller = C { [weak self] in
+            self?._machine.removeProgressTupleHandler(token)
+        }
+        
         return self
     }
     
@@ -373,13 +380,13 @@ public class Task<Progress, Value, Error>: Printable
     ///
     public func then<Value2>(thenClosure: (Value?, ErrorInfo?) -> Value2) -> Task<Progress, Value2, Error>
     {
-        var token: HandlerToken? = nil
-        return self.then(&token, thenClosure)
+        var dummyCanceller: Canceller? = nil
+        return self.then(&dummyCanceller, thenClosure)
     }
     
-    public func then<Value2>(inout token: HandlerToken?, _ thenClosure: (Value?, ErrorInfo?) -> Value2) -> Task<Progress, Value2, Error>
+    public func then<Value2, C: Canceller>(inout canceller: C?, _ thenClosure: (Value?, ErrorInfo?) -> Value2) -> Task<Progress, Value2, Error>
     {
-        return self.then(&token) { (value: Value?, errorInfo: ErrorInfo?) -> Task<Progress, Value2, Error> in
+        return self.then(&canceller) { (value: Value?, errorInfo: ErrorInfo?) -> Task<Progress, Value2, Error> in
             return Task<Progress, Value2, Error>(value: thenClosure(value, errorInfo))
         }
     }
@@ -391,13 +398,13 @@ public class Task<Progress, Value, Error>: Printable
     ///
     public func then<Progress2, Value2>(thenClosure: (Value?, ErrorInfo?) -> Task<Progress2, Value2, Error>) -> Task<Progress2, Value2, Error>
     {
-        var token: HandlerToken? = nil
-        return self.then(&token, thenClosure)
+        var dummyCanceller: Canceller? = nil
+        return self.then(&dummyCanceller, thenClosure)
     }
     
-    public func then<Progress2, Value2>(inout token: HandlerToken?, _ thenClosure: (Value?, ErrorInfo?) -> Task<Progress2, Value2, Error>) -> Task<Progress2, Value2, Error>
+    public func then<Progress2, Value2, C: Canceller>(inout canceller: C?, _ thenClosure: (Value?, ErrorInfo?) -> Task<Progress2, Value2, Error>) -> Task<Progress2, Value2, Error>
     {
-        return Task<Progress2, Value2, Error> { [unowned self] newMachine, progress, fulfill, _reject, configure in
+        return Task<Progress2, Value2, Error> { [unowned self, weak canceller] newMachine, progress, fulfill, _reject, configure in
             
             //
             // NOTE: 
@@ -408,7 +415,7 @@ public class Task<Progress, Value, Error>: Printable
             //
             let selfMachine = self._machine
             
-            self._then(&token) {
+            self._then(&canceller) {
                 let innerTask = thenClosure(selfMachine.value, selfMachine.errorInfo)
                 _bindInnerTask(innerTask, newMachine, progress, fulfill, _reject, configure)
             }
@@ -417,13 +424,18 @@ public class Task<Progress, Value, Error>: Printable
     }
 
     /// invokes `completionHandler` "now" or "in the future"
-    private func _then(inout token: HandlerToken?, _ completionHandler: Void -> Void)
+    private func _then<C: Canceller>(inout canceller: C?, _ completionHandler: Void -> Void)
     {
         switch self.state {
             case .Fulfilled, .Rejected, .Cancelled:
                 completionHandler()
             default:
+                var token: _HandlerToken? = nil
                 self._machine.addCompletionHandler(&token, completionHandler)
+            
+                canceller = C { [weak self] in
+                    self?._machine.removeCompletionHandler(token)
+                }
         }
     }
     
@@ -434,13 +446,13 @@ public class Task<Progress, Value, Error>: Printable
     ///
     public func success<Value2>(successClosure: Value -> Value2) -> Task<Progress, Value2, Error>
     {
-        var token: HandlerToken? = nil
-        return self.success(&token, successClosure)
+        var dummyCanceller: Canceller? = nil
+        return self.success(&dummyCanceller, successClosure)
     }
     
-    public func success<Value2>(inout token: HandlerToken?, _ successClosure: Value -> Value2) -> Task<Progress, Value2, Error>
+    public func success<Value2, C: Canceller>(inout canceller: C?, _ successClosure: Value -> Value2) -> Task<Progress, Value2, Error>
     {
-        return self.success(&token) { (value: Value) -> Task<Progress, Value2, Error> in
+        return self.success(&canceller) { (value: Value) -> Task<Progress, Value2, Error> in
             return Task<Progress, Value2, Error>(value: successClosure(value))
         }
     }
@@ -452,18 +464,18 @@ public class Task<Progress, Value, Error>: Printable
     ///
     public func success<Progress2, Value2>(successClosure: Value -> Task<Progress2, Value2, Error>) -> Task<Progress2, Value2, Error>
     {
-        var token: HandlerToken? = nil
-        return self.success(&token, successClosure)
+        var dummyCanceller: Canceller? = nil
+        return self.success(&dummyCanceller, successClosure)
     }
     
-    public func success<Progress2, Value2>(inout token: HandlerToken?, _ successClosure: Value -> Task<Progress2, Value2, Error>) -> Task<Progress2, Value2, Error>
+    public func success<Progress2, Value2, C: Canceller>(inout canceller: C?, _ successClosure: Value -> Task<Progress2, Value2, Error>) -> Task<Progress2, Value2, Error>
     {
         return Task<Progress2, Value2, Error> { [unowned self] newMachine, progress, fulfill, _reject, configure in
             
             let selfMachine = self._machine
             
             // NOTE: using `self._then()` + `selfMachine` instead of `self.then()` will reduce Task allocation
-            self._then(&token) {
+            self._then(&canceller) {
                 if let value = selfMachine.value {
                     let innerTask = successClosure(value)
                     _bindInnerTask(innerTask, newMachine, progress, fulfill, _reject, configure)
@@ -484,13 +496,13 @@ public class Task<Progress, Value, Error>: Printable
     ///
     public func failure(failureClosure: ErrorInfo -> Value) -> Task
     {
-        var token: HandlerToken? = nil
-        return self.failure(&token, failureClosure)
+        var dummyCanceller: Canceller? = nil
+        return self.failure(&dummyCanceller, failureClosure)
     }
     
-    public func failure(inout token: HandlerToken?, _ failureClosure: ErrorInfo -> Value) -> Task
+    public func failure<C: Canceller>(inout canceller: C?, _ failureClosure: ErrorInfo -> Value) -> Task
     {
-        return self.failure(&token) { (errorInfo: ErrorInfo) -> Task in
+        return self.failure(&canceller) { (errorInfo: ErrorInfo) -> Task in
             return Task(value: failureClosure(errorInfo))
         }
     }
@@ -503,17 +515,17 @@ public class Task<Progress, Value, Error>: Printable
     ///
     public func failure<Progress2>(failureClosure: ErrorInfo -> Task<Progress2, Value, Error>) -> Task<Progress2, Value, Error>
     {
-        var token: HandlerToken? = nil
-        return self.failure(&token, failureClosure)
+        var dummyCanceller: Canceller? = nil
+        return self.failure(&dummyCanceller, failureClosure)
     }
     
-    public func failure<Progress2>(inout token: HandlerToken?, _ failureClosure: ErrorInfo -> Task<Progress2, Value, Error>) -> Task<Progress2, Value, Error>
+    public func failure<Progress2, C: Canceller>(inout canceller: C?, _ failureClosure: ErrorInfo -> Task<Progress2, Value, Error>) -> Task<Progress2, Value, Error>
     {
         return Task<Progress2, Value, Error> { [unowned self] newMachine, progress, fulfill, _reject, configure in
             
             let selfMachine = self._machine
             
-            self._then(&token) {
+            self._then(&canceller) {
                 if let value = selfMachine.value {
                     fulfill(value)
                 }
@@ -536,27 +548,25 @@ public class Task<Progress, Value, Error>: Printable
         return self._machine.handleResume()
     }
     
-    public func cancel(error: Error? = nil) -> Bool
+    //
+    // NOTE: 
+    // To conform to `Cancellable`, this method is needed in replace of:
+    // - `public func cancel(error: Error? = nil) -> Bool`
+    // - `public func cancel(_ error: Error? = nil) -> Bool` (segfault in Swift 1.2)
+    //
+    public func cancel() -> Bool
     {
-        return self._cancel(error: error)
+        return self.cancel(nil)
     }
     
-    internal func _cancel(error: Error? = nil) -> Bool
+    public func cancel(error: Error?) -> Bool
     {
-        return self._machine.handleCancel(error: error)
-    }
-    
-    // MARK: Remove Handlers
-    
-    public func removeProgress(handlerToken: HandlerToken)
-    {
-        return self._machine.removeProgressTupleHandler(handlerToken)
+        return self._cancel(error: error)
     }
     
-    /// NOTE: `task.removeThen(token)` will force `let task2 = task.then(&token)` to deinit immediately and tries cancellation if it is still running.
-    public func removeThen(handlerToken: HandlerToken)
+    internal func _cancel(error: Error? = nil) -> Bool
     {
-        return self._machine.removeCompletionHandler(handlerToken)
+        return self._machine.handleCancel(error: error)
     }
     
 }
diff --git a/SwiftTask/_StateMachine.swift b/SwiftTask/_StateMachine.swift
@@ -41,28 +41,32 @@ internal class _StateMachine<Progress, Value, Error>
         self.state = paused ? .Paused : .Running
     }
     
-    internal func addProgressTupleHandler(inout token: HandlerToken?, _ progressTupleHandler: ProgressTupleHandler)
+    internal func addProgressTupleHandler(inout token: _HandlerToken?, _ progressTupleHandler: ProgressTupleHandler)
     {
         if self.state == .Running || self.state == .Paused {
             token = self.progressTupleHandlers.append(progressTupleHandler)
         }
     }
     
-    internal func removeProgressTupleHandler(handlerToken: HandlerToken)
+    internal func removeProgressTupleHandler(handlerToken: _HandlerToken?)
     {
-        self.progressTupleHandlers.remove(handlerToken)
+        if let handlerToken = handlerToken {
+            self.progressTupleHandlers.remove(handlerToken)
+        }
     }
     
-    internal func addCompletionHandler(inout token: HandlerToken?, _ completionHandler: Void -> Void)
+    internal func addCompletionHandler(inout token: _HandlerToken?, _ completionHandler: Void -> Void)
     {
         if self.state == .Running || self.state == .Paused {
             token = self.completionHandlers.append(completionHandler)
         }
     }
     
-    internal func removeCompletionHandler(handlerToken: HandlerToken)
+    internal func removeCompletionHandler(handlerToken: _HandlerToken?)
     {
-        self.completionHandlers.remove(handlerToken)
+        if let handlerToken = handlerToken {
+            self.completionHandlers.remove(handlerToken)
+        }
     }
     
     internal func handleProgress(progress: Progress)
@@ -201,7 +205,7 @@ internal class _StateMachine<Progress, Value, Error>
 // MARK: - Utility
 //--------------------------------------------------
 
-public struct HandlerToken
+internal struct _HandlerToken
 {
     internal let key: Int
 }
@@ -211,16 +215,16 @@ internal struct _Handlers<T>: SequenceType
     private var currentKey: Int = 0
     private var elements = [Int : T]()
     
-    internal mutating func append(value: T) -> HandlerToken
+    internal mutating func append(value: T) -> _HandlerToken
     {
         self.currentKey = self.currentKey &+ 1
         
         self.elements[self.currentKey] = value
         
-        return HandlerToken(key: self.currentKey)
+        return _HandlerToken(key: self.currentKey)
     }
     
-    internal mutating func remove(token: HandlerToken)
+    internal mutating func remove(token: _HandlerToken)
     {
         self.elements.removeValueForKey(token.key)
     }
diff --git a/SwiftTaskTests/RemoveHandlerTests.swift b/SwiftTaskTests/RemoveHandlerTests.swift
diff --git a/SwiftTaskTests/SwiftTaskTests.swift b/SwiftTaskTests/SwiftTaskTests.swift

Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ public class TaskConfiguration`
`57`	`57`	`}`
`58`	`58`	`}`
`59`	`59`
`60`		`-public class Task<Progress, Value, Error>: Printable`
	`60`	`+public class Task<Progress, Value, Error>: Cancellable, Printable`
`61`	`61`	`{`
`62`	`62`	`public typealias ProgressTuple = (oldProgress: Progress?, newProgress: Progress)`
`63`	`63`	`public typealias ErrorInfo = (error: Error?, isCancelled: Bool)`
`@@ -213,7 +213,8 @@ public class Task<Progress, Value, Error>: Printable`
`213`	`213`	`internal func setup(#weakified: Bool, paused: Bool, _initClosure: _InitClosure)`
`214`	`214`	`{`
`215`	`215`	`// #if DEBUG`
`216`		`-// println("[init] \(self.name)")`
	`216`	`+// let addr = String(format: "%p", unsafeAddressOf(self))`
	`217`	`+// NSLog("[init] \(self.name) \(addr)")`
`217`	`218`	`// #endif`
`218`	`219`
`219`	`220`	`self._initClosure = _initClosure`
`@@ -287,7 +288,8 @@ public class Task<Progress, Value, Error>: Printable`
`287`	`288`	`deinit`
`288`	`289`	`{`
`289`	`290`	`// #if DEBUG`
`290`		`-// println("[deinit] \(self.name)")`
	`291`	`+// let addr = String(format: "%p", unsafeAddressOf(self))`
	`292`	`+// NSLog("[deinit] \(self.name) \(addr)")`
`291`	`293`	`// #endif`
`292`	`294`
`293`	`295`	`// cancel in case machine is still running`
`@@ -355,14 +357,19 @@ public class Task<Progress, Value, Error>: Printable`
`355`	`357`	`///`
`356`	`358`	`public func progress(progressClosure: ProgressTuple -> Void) -> Task`
`357`	`359`	`{`
`358`		`- var token: HandlerToken? = nil`
`359`		`- return self.progress(&token, progressClosure)`
	`360`	`+ var dummyCanceller: Canceller? = nil`
	`361`	`+ return self.progress(&dummyCanceller, progressClosure)`
`360`	`362`	`}`
`361`	`363`
`362`		`- public func progress(inout token: HandlerToken?, _ progressClosure: ProgressTuple -> Void) -> Task`
	`364`	`+ public func progress<C: Canceller>(inout canceller: C?, _ progressClosure: ProgressTuple -> Void) -> Task`
`363`	`365`	`{`
	`366`	`+ var token: _HandlerToken? = nil`
`364`	`367`	`self._machine.addProgressTupleHandler(&token, progressClosure)`
`365`	`368`
	`369`	`+ canceller = C { [weak self] in`
	`370`	`+ self?._machine.removeProgressTupleHandler(token)`
	`371`	`+ }`
	`372`	`+`
`366`	`373`	`return self`
`367`	`374`	`}`
`368`	`375`
`@@ -373,13 +380,13 @@ public class Task<Progress, Value, Error>: Printable`
`373`	`380`	`///`
`374`	`381`	`public func then<Value2>(thenClosure: (Value?, ErrorInfo?) -> Value2) -> Task<Progress, Value2, Error>`
`375`	`382`	`{`
`376`		`- var token: HandlerToken? = nil`
`377`		`- return self.then(&token, thenClosure)`
	`383`	`+ var dummyCanceller: Canceller? = nil`
	`384`	`+ return self.then(&dummyCanceller, thenClosure)`
`378`	`385`	`}`
`379`	`386`
`380`		`- public func then<Value2>(inout token: HandlerToken?, _ thenClosure: (Value?, ErrorInfo?) -> Value2) -> Task<Progress, Value2, Error>`
	`387`	`+ public func then<Value2, C: Canceller>(inout canceller: C?, _ thenClosure: (Value?, ErrorInfo?) -> Value2) -> Task<Progress, Value2, Error>`
`381`	`388`	`{`
`382`		`- return self.then(&token) { (value: Value?, errorInfo: ErrorInfo?) -> Task<Progress, Value2, Error> in`
	`389`	`+ return self.then(&canceller) { (value: Value?, errorInfo: ErrorInfo?) -> Task<Progress, Value2, Error> in`
`383`	`390`	`return Task<Progress, Value2, Error>(value: thenClosure(value, errorInfo))`
`384`	`391`	`}`
`385`	`392`	`}`
`@@ -391,13 +398,13 @@ public class Task<Progress, Value, Error>: Printable`
`391`	`398`	`///`
`392`	`399`	`public func then<Progress2, Value2>(thenClosure: (Value?, ErrorInfo?) -> Task<Progress2, Value2, Error>) -> Task<Progress2, Value2, Error>`
`393`	`400`	`{`
`394`		`- var token: HandlerToken? = nil`
`395`		`- return self.then(&token, thenClosure)`
	`401`	`+ var dummyCanceller: Canceller? = nil`
	`402`	`+ return self.then(&dummyCanceller, thenClosure)`
`396`	`403`	`}`
`397`	`404`
`398`		`- public func then<Progress2, Value2>(inout token: HandlerToken?, _ thenClosure: (Value?, ErrorInfo?) -> Task<Progress2, Value2, Error>) -> Task<Progress2, Value2, Error>`
	`405`	`+ public func then<Progress2, Value2, C: Canceller>(inout canceller: C?, _ thenClosure: (Value?, ErrorInfo?) -> Task<Progress2, Value2, Error>) -> Task<Progress2, Value2, Error>`
`399`	`406`	`{`
`400`		`- return Task<Progress2, Value2, Error> { [unowned self] newMachine, progress, fulfill, _reject, configure in`
	`407`	`+ return Task<Progress2, Value2, Error> { [unowned self, weak canceller] newMachine, progress, fulfill, _reject, configure in`
`401`	`408`
`402`	`409`	`//`
`403`	`410`	`// NOTE:`
`@@ -408,7 +415,7 @@ public class Task<Progress, Value, Error>: Printable`
`408`	`415`	`//`
`409`	`416`	`let selfMachine = self._machine`
`410`	`417`
`411`		`- self._then(&token) {`
	`418`	`+ self._then(&canceller) {`
`412`	`419`	`let innerTask = thenClosure(selfMachine.value, selfMachine.errorInfo)`
`413`	`420`	`_bindInnerTask(innerTask, newMachine, progress, fulfill, _reject, configure)`
`414`	`421`	`}`
`@@ -417,13 +424,18 @@ public class Task<Progress, Value, Error>: Printable`
`417`	`424`	`}`
`418`	`425`
`419`	`426`	/// invokes `completionHandler` "now" or "in the future"
`420`		`- private func _then(inout token: HandlerToken?, _ completionHandler: Void -> Void)`
	`427`	`+ private func _then<C: Canceller>(inout canceller: C?, _ completionHandler: Void -> Void)`
`421`	`428`	`{`
`422`	`429`	`switch self.state {`
`423`	`430`	`case .Fulfilled, .Rejected, .Cancelled:`
`424`	`431`	`completionHandler()`
`425`	`432`	`default:`
	`433`	`+ var token: _HandlerToken? = nil`
`426`	`434`	`self._machine.addCompletionHandler(&token, completionHandler)`
	`435`	`+`
	`436`	`+ canceller = C { [weak self] in`
	`437`	`+ self?._machine.removeCompletionHandler(token)`
	`438`	`+ }`
`427`	`439`	`}`
`428`	`440`	`}`
`429`	`441`
`@@ -434,13 +446,13 @@ public class Task<Progress, Value, Error>: Printable`
`434`	`446`	`///`
`435`	`447`	`public func success<Value2>(successClosure: Value -> Value2) -> Task<Progress, Value2, Error>`
`436`	`448`	`{`
`437`		`- var token: HandlerToken? = nil`
`438`		`- return self.success(&token, successClosure)`
	`449`	`+ var dummyCanceller: Canceller? = nil`
	`450`	`+ return self.success(&dummyCanceller, successClosure)`
`439`	`451`	`}`
`440`	`452`
`441`		`- public func success<Value2>(inout token: HandlerToken?, _ successClosure: Value -> Value2) -> Task<Progress, Value2, Error>`
	`453`	`+ public func success<Value2, C: Canceller>(inout canceller: C?, _ successClosure: Value -> Value2) -> Task<Progress, Value2, Error>`
`442`	`454`	`{`
`443`		`- return self.success(&token) { (value: Value) -> Task<Progress, Value2, Error> in`
	`455`	`+ return self.success(&canceller) { (value: Value) -> Task<Progress, Value2, Error> in`
`444`	`456`	`return Task<Progress, Value2, Error>(value: successClosure(value))`
`445`	`457`	`}`
`446`	`458`	`}`
`@@ -452,18 +464,18 @@ public class Task<Progress, Value, Error>: Printable`
`452`	`464`	`///`
`453`	`465`	`public func success<Progress2, Value2>(successClosure: Value -> Task<Progress2, Value2, Error>) -> Task<Progress2, Value2, Error>`
`454`	`466`	`{`
`455`		`- var token: HandlerToken? = nil`
`456`		`- return self.success(&token, successClosure)`
	`467`	`+ var dummyCanceller: Canceller? = nil`
	`468`	`+ return self.success(&dummyCanceller, successClosure)`
`457`	`469`	`}`
`458`	`470`
`459`		`- public func success<Progress2, Value2>(inout token: HandlerToken?, _ successClosure: Value -> Task<Progress2, Value2, Error>) -> Task<Progress2, Value2, Error>`
	`471`	`+ public func success<Progress2, Value2, C: Canceller>(inout canceller: C?, _ successClosure: Value -> Task<Progress2, Value2, Error>) -> Task<Progress2, Value2, Error>`
`460`	`472`	`{`
`461`	`473`	`return Task<Progress2, Value2, Error> { [unowned self] newMachine, progress, fulfill, _reject, configure in`
`462`	`474`
`463`	`475`	`let selfMachine = self._machine`
`464`	`476`
`465`	`477`	// NOTE: using `self._then()` + `selfMachine` instead of `self.then()` will reduce Task allocation
`466`		`- self._then(&token) {`
	`478`	`+ self._then(&canceller) {`
`467`	`479`	`if let value = selfMachine.value {`
`468`	`480`	`let innerTask = successClosure(value)`
`469`	`481`	`_bindInnerTask(innerTask, newMachine, progress, fulfill, _reject, configure)`
`@@ -484,13 +496,13 @@ public class Task<Progress, Value, Error>: Printable`
`484`	`496`	`///`
`485`	`497`	`public func failure(failureClosure: ErrorInfo -> Value) -> Task`
`486`	`498`	`{`
`487`		`- var token: HandlerToken? = nil`
`488`		`- return self.failure(&token, failureClosure)`
	`499`	`+ var dummyCanceller: Canceller? = nil`
	`500`	`+ return self.failure(&dummyCanceller, failureClosure)`
`489`	`501`	`}`
`490`	`502`
`491`		`- public func failure(inout token: HandlerToken?, _ failureClosure: ErrorInfo -> Value) -> Task`
	`503`	`+ public func failure<C: Canceller>(inout canceller: C?, _ failureClosure: ErrorInfo -> Value) -> Task`
`492`	`504`	`{`
`493`		`- return self.failure(&token) { (errorInfo: ErrorInfo) -> Task in`
	`505`	`+ return self.failure(&canceller) { (errorInfo: ErrorInfo) -> Task in`
`494`	`506`	`return Task(value: failureClosure(errorInfo))`
`495`	`507`	`}`
`496`	`508`	`}`
`@@ -503,17 +515,17 @@ public class Task<Progress, Value, Error>: Printable`
`503`	`515`	`///`
`504`	`516`	`public func failure<Progress2>(failureClosure: ErrorInfo -> Task<Progress2, Value, Error>) -> Task<Progress2, Value, Error>`
`505`	`517`	`{`
`506`		`- var token: HandlerToken? = nil`
`507`		`- return self.failure(&token, failureClosure)`
	`518`	`+ var dummyCanceller: Canceller? = nil`
	`519`	`+ return self.failure(&dummyCanceller, failureClosure)`
`508`	`520`	`}`
`509`	`521`
`510`		`- public func failure<Progress2>(inout token: HandlerToken?, _ failureClosure: ErrorInfo -> Task<Progress2, Value, Error>) -> Task<Progress2, Value, Error>`
	`522`	`+ public func failure<Progress2, C: Canceller>(inout canceller: C?, _ failureClosure: ErrorInfo -> Task<Progress2, Value, Error>) -> Task<Progress2, Value, Error>`
`511`	`523`	`{`
`512`	`524`	`return Task<Progress2, Value, Error> { [unowned self] newMachine, progress, fulfill, _reject, configure in`
`513`	`525`
`514`	`526`	`let selfMachine = self._machine`
`515`	`527`
`516`		`- self._then(&token) {`
	`528`	`+ self._then(&canceller) {`
`517`	`529`	`if let value = selfMachine.value {`
`518`	`530`	`fulfill(value)`
`519`	`531`	`}`
`@@ -536,27 +548,25 @@ public class Task<Progress, Value, Error>: Printable`
`536`	`548`	`return self._machine.handleResume()`
`537`	`549`	`}`
`538`	`550`
`539`		`- public func cancel(error: Error? = nil) -> Bool`
	`551`	`+ //`
	`552`	`+ // NOTE:`
	`553`	+ // To conform to `Cancellable`, this method is needed in replace of:
	`554`	+ // - `public func cancel(error: Error? = nil) -> Bool`
	`555`	+ // - `public func cancel(_ error: Error? = nil) -> Bool` (segfault in Swift 1.2)
	`556`	`+ //`
	`557`	`+ public func cancel() -> Bool`
`540`	`558`	`{`
`541`		`- return self._cancel(error: error)`
	`559`	`+ return self.cancel(nil)`
`542`	`560`	`}`
`543`	`561`
`544`		`- internal func _cancel(error: Error? = nil) -> Bool`
	`562`	`+ public func cancel(error: Error?) -> Bool`
`545`	`563`	`{`
`546`		`- return self._machine.handleCancel(error: error)`
`547`		`- }`
`548`		`-`
`549`		`- // MARK: Remove Handlers`
`550`		`-`
`551`		`- public func removeProgress(handlerToken: HandlerToken)`
`552`		`- {`
`553`		`- return self._machine.removeProgressTupleHandler(handlerToken)`
	`564`	`+ return self._cancel(error: error)`
`554`	`565`	`}`
`555`	`566`
`556`		- /// NOTE: `task.removeThen(token)` will force `let task2 = task.then(&token)` to deinit immediately and tries cancellation if it is still running.
`557`		`- public func removeThen(handlerToken: HandlerToken)`
	`567`	`+ internal func _cancel(error: Error? = nil) -> Bool`
`558`	`568`	`{`
`559`		`- return self._machine.removeCompletionHandler(handlerToken)`
	`569`	`+ return self._machine.handleCancel(error: error)`
`560`	`570`	`}`
`561`	`571`
`562`	`572`	`}`
Original file line number	Diff line number	Diff line change
`@@ -41,28 +41,32 @@ internal class _StateMachine<Progress, Value, Error>`
`41`	`41`	`self.state = paused ? .Paused : .Running`
`42`	`42`	`}`
`43`	`43`
`44`		`- internal func addProgressTupleHandler(inout token: HandlerToken?, _ progressTupleHandler: ProgressTupleHandler)`
	`44`	`+ internal func addProgressTupleHandler(inout token: _HandlerToken?, _ progressTupleHandler: ProgressTupleHandler)`
`45`	`45`	`{`
`46`	`46`	`if self.state == .Running \|\| self.state == .Paused {`
`47`	`47`	`token = self.progressTupleHandlers.append(progressTupleHandler)`
`48`	`48`	`}`
`49`	`49`	`}`
`50`	`50`
`51`		`- internal func removeProgressTupleHandler(handlerToken: HandlerToken)`
	`51`	`+ internal func removeProgressTupleHandler(handlerToken: _HandlerToken?)`
`52`	`52`	`{`
`53`		`- self.progressTupleHandlers.remove(handlerToken)`
	`53`	`+ if let handlerToken = handlerToken {`
	`54`	`+ self.progressTupleHandlers.remove(handlerToken)`
	`55`	`+ }`
`54`	`56`	`}`
`55`	`57`
`56`		`- internal func addCompletionHandler(inout token: HandlerToken?, _ completionHandler: Void -> Void)`
	`58`	`+ internal func addCompletionHandler(inout token: _HandlerToken?, _ completionHandler: Void -> Void)`
`57`	`59`	`{`
`58`	`60`	`if self.state == .Running \|\| self.state == .Paused {`
`59`	`61`	`token = self.completionHandlers.append(completionHandler)`
`60`	`62`	`}`
`61`	`63`	`}`
`62`	`64`
`63`		`- internal func removeCompletionHandler(handlerToken: HandlerToken)`
	`65`	`+ internal func removeCompletionHandler(handlerToken: _HandlerToken?)`
`64`	`66`	`{`
`65`		`- self.completionHandlers.remove(handlerToken)`
	`67`	`+ if let handlerToken = handlerToken {`
	`68`	`+ self.completionHandlers.remove(handlerToken)`
	`69`	`+ }`
`66`	`70`	`}`
`67`	`71`
`68`	`72`	`internal func handleProgress(progress: Progress)`
`@@ -201,7 +205,7 @@ internal class _StateMachine<Progress, Value, Error>`
`201`	`205`	`// MARK: - Utility`
`202`	`206`	`//--------------------------------------------------`
`203`	`207`
`204`		`-public struct HandlerToken`
	`208`	`+internal struct _HandlerToken`
`205`	`209`	`{`
`206`	`210`	`internal let key: Int`
`207`	`211`	`}`
`@@ -211,16 +215,16 @@ internal struct _Handlers<T>: SequenceType`
`211`	`215`	`private var currentKey: Int = 0`
`212`	`216`	`private var elements = [Int : T]()`
`213`	`217`
`214`		`- internal mutating func append(value: T) -> HandlerToken`
	`218`	`+ internal mutating func append(value: T) -> _HandlerToken`
`215`	`219`	`{`
`216`	`220`	`self.currentKey = self.currentKey &+ 1`
`217`	`221`
`218`	`222`	`self.elements[self.currentKey] = value`
`219`	`223`
`220`		`- return HandlerToken(key: self.currentKey)`
	`224`	`+ return _HandlerToken(key: self.currentKey)`
`221`	`225`	`}`
`222`	`226`
`223`		`- internal mutating func remove(token: HandlerToken)`
	`227`	`+ internal mutating func remove(token: _HandlerToken)`
`224`	`228`	`{`
`225`	`229`	`self.elements.removeValueForKey(token.key)`
`226`	`230`	`}`