Merge pull request #53 from diejmon/swift/3.0

inamiy · web-flow · commit 57c63cf43dee · 2016-09-10T11:06:29.000+09:00
Adds @escaping where required for Swift 3.0 GM
diff --git a/Sources/Disposable.swift b/Sources/Disposable.swift
@@ -34,7 +34,7 @@ public final class ActionDisposable: Disposable {
     }
 
     /// Initializes the disposable to run the given action upon disposal.
-    public init(action: (() -> ())) {
+    public init(action: @escaping (() -> ())) {
         self.action = action
     }
 
diff --git a/Sources/Machine.swift b/Sources/Machine.swift
@@ -293,26 +293,26 @@ public class Machine<S: StateType, E: EventType>
     // MARK: addRoutes(event:) + conditional handler
 
     @discardableResult
-    public func addRoutes(event: E, transitions: [Transition<S>], condition: Condition? = nil, handler: Handler) -> Disposable
+    public func addRoutes(event: E, transitions: [Transition<S>], condition: Condition? = nil, handler: @escaping Handler) -> Disposable
     {
         return self.addRoutes(event: .some(event), transitions: transitions, condition: condition, handler: handler)
     }
 
     @discardableResult
-    public func addRoutes(event: Event<E>, transitions: [Transition<S>], condition: Condition? = nil, handler: Handler) -> Disposable
+    public func addRoutes(event: Event<E>, transitions: [Transition<S>], condition: Condition? = nil, handler: @escaping Handler) -> Disposable
     {
         let routes = transitions.map { Route(transition: $0, condition: condition) }
         return self.addRoutes(event: event, routes: routes, handler: handler)
     }
 
     @discardableResult
-    public func addRoutes(event: E, routes: [Route<S, E>], handler: Handler) -> Disposable
+    public func addRoutes(event: E, routes: [Route<S, E>], handler: @escaping Handler) -> Disposable
     {
         return self.addRoutes(event: .some(event), routes: routes, handler: handler)
     }
 
     @discardableResult
-    public func addRoutes(event: Event<E>, routes: [Route<S, E>], handler: Handler) -> Disposable
+    public func addRoutes(event: Event<E>, routes: [Route<S, E>], handler: @escaping Handler) -> Disposable
     {
         let routeDisposable = self.addRoutes(event: event, routes: routes)
         let handlerDisposable = self.addHandler(event: event, handler: handler)
@@ -367,7 +367,7 @@ public class Machine<S: StateType, E: EventType>
     // MARK: addRouteMapping
 
     @discardableResult
-    public func addRouteMapping(_ routeMapping: RouteMapping) -> Disposable
+    public func addRouteMapping(_ routeMapping: @escaping RouteMapping) -> Disposable
     {
         let key = _createUniqueString()
 
@@ -383,7 +383,7 @@ public class Machine<S: StateType, E: EventType>
     // MARK: addRouteMapping + conditional handler
 
     @discardableResult
-    public func addRouteMapping(_ routeMapping: RouteMapping, order: HandlerOrder = _defaultOrder, handler: Machine.Handler) -> Disposable
+    public func addRouteMapping(_ routeMapping: @escaping RouteMapping, order: HandlerOrder = _defaultOrder, handler: @escaping Machine.Handler) -> Disposable
     {
         let routeDisposable = self.addRouteMapping(routeMapping)
 
@@ -425,13 +425,13 @@ public class Machine<S: StateType, E: EventType>
     // MARK: addHandler(event:)
 
     @discardableResult
-    public func addHandler(event: E, order: HandlerOrder = _defaultOrder, handler: Machine.Handler) -> Disposable
+    public func addHandler(event: E, order: HandlerOrder = _defaultOrder, handler: @escaping Machine.Handler) -> Disposable
     {
         return self.addHandler(event: .some(event), order: order, handler: handler)
     }
 
     @discardableResult
-    public func addHandler(event: Event<E>, order: HandlerOrder = _defaultOrder, handler: Machine.Handler) -> Disposable
+    public func addHandler(event: Event<E>, order: HandlerOrder = _defaultOrder, handler: @escaping Machine.Handler) -> Disposable
     {
         return self._addHandler(event: event, order: order) { context in
             // skip if not event-based transition
@@ -446,7 +446,7 @@ public class Machine<S: StateType, E: EventType>
     }
 
     @discardableResult
-    private func _addHandler(event: Event<E>, order: HandlerOrder = _defaultOrder, handler: Handler) -> Disposable
+    private func _addHandler(event: Event<E>, order: HandlerOrder = _defaultOrder, handler: @escaping Handler) -> Disposable
     {
         if self._handlers[event] == nil {
             self._handlers[event] = []
@@ -470,7 +470,7 @@ public class Machine<S: StateType, E: EventType>
     // MARK: addErrorHandler
 
     @discardableResult
-    public func addErrorHandler(order: HandlerOrder = _defaultOrder, handler: Handler) -> Disposable
+    public func addErrorHandler(order: HandlerOrder = _defaultOrder, handler: @escaping Handler) -> Disposable
     {
         let key = _createUniqueString()
 
diff --git a/Sources/StateMachine.swift b/Sources/StateMachine.swift
@@ -215,14 +215,14 @@ public final class StateMachine<S: StateType, E: EventType>: Machine<S, E>
     // MARK: addRoute (no-event) + conditional handler
 
     @discardableResult
-    public func addRoute(_ transition: Transition<S>, condition: Condition? = nil, handler: Handler) -> Disposable
+    public func addRoute(_ transition: Transition<S>, condition: Condition? = nil, handler: @escaping Handler) -> Disposable
     {
         let route = Route(transition: transition, condition: condition)
         return self.addRoute(route, handler: handler)
     }
 
     @discardableResult
-    public func addRoute(_ route: Route<S, E>, handler: Handler) -> Disposable
+    public func addRoute(_ route: Route<S, E>, handler: @escaping Handler) -> Disposable
     {
         let transition = route.transition
         let condition = route.condition
@@ -278,7 +278,7 @@ public final class StateMachine<S: StateType, E: EventType>: Machine<S, E>
     /// Add `handler` that is called when `tryState()` succeeds for target `transition`.
     /// - Note: `handler` will not be invoked for `tryEvent()`.
     @discardableResult
-    public func addHandler(_ transition: Transition<S>, order: HandlerOrder = _defaultOrder, handler: Handler) -> Disposable
+    public func addHandler(_ transition: Transition<S>, order: HandlerOrder = _defaultOrder, handler: @escaping Handler) -> Disposable
     {
         if self._handlers[transition] == nil {
             self._handlers[transition] = []
@@ -322,7 +322,7 @@ public final class StateMachine<S: StateType, E: EventType>: Machine<S, E>
 
     /// Add `handler` that is called when either `tryEvent()` or `tryState()` succeeds for target `transition`.
     @discardableResult
-    public func addAnyHandler(_ transition: Transition<S>, order: HandlerOrder = _defaultOrder, handler: Handler) -> Disposable
+    public func addAnyHandler(_ transition: Transition<S>, order: HandlerOrder = _defaultOrder, handler: @escaping Handler) -> Disposable
     {
         let disposable1 = self.addHandler(transition, order: order, handler: handler)
         let disposable2 = self.addHandler(event: .any, order: order) { context in
@@ -351,14 +351,14 @@ public final class StateMachine<S: StateType, E: EventType>: Machine<S, E>
     // MARK: addRouteChain + conditional handler
 
     @discardableResult
-    public func addRouteChain(_ chain: TransitionChain<S>, condition: Condition? = nil, handler: Handler) -> Disposable
+    public func addRouteChain(_ chain: TransitionChain<S>, condition: Condition? = nil, handler: @escaping Handler) -> Disposable
     {
         let routeChain = RouteChain(transitionChain: chain, condition: condition)
         return self.addRouteChain(routeChain, handler: handler)
     }
 
     @discardableResult
-    public func addRouteChain(_ chain: RouteChain<S, E>, handler: Handler) -> Disposable
+    public func addRouteChain(_ chain: RouteChain<S, E>, handler: @escaping Handler) -> Disposable
     {
         let routeDisposables = chain.routes.map { self.addRoute($0) }
         let handlerDisposable = self.addChainHandler(chain, handler: handler)
@@ -372,33 +372,33 @@ public final class StateMachine<S: StateType, E: EventType>: Machine<S, E>
     // MARK: addChainHandler
 
     @discardableResult
-    public func addChainHandler(_ chain: TransitionChain<S>, order: HandlerOrder = _defaultOrder, handler: Handler) -> Disposable
+    public func addChainHandler(_ chain: TransitionChain<S>, order: HandlerOrder = _defaultOrder, handler: @escaping Handler) -> Disposable
     {
         return self.addChainHandler(RouteChain(transitionChain: chain), order: order, handler: handler)
     }
 
     @discardableResult
-    public func addChainHandler(_ chain: RouteChain<S, E>, order: HandlerOrder = _defaultOrder, handler: Handler) -> Disposable
+    public func addChainHandler(_ chain: RouteChain<S, E>, order: HandlerOrder = _defaultOrder, handler: @escaping Handler) -> Disposable
     {
         return self._addChainHandler(chain, order: order, handler: handler, isError: false)
     }
 
     // MARK: addChainErrorHandler
 
     @discardableResult
-    public func addChainErrorHandler(_ chain: TransitionChain<S>, order: HandlerOrder = _defaultOrder, handler: Handler) -> Disposable
+    public func addChainErrorHandler(_ chain: TransitionChain<S>, order: HandlerOrder = _defaultOrder, handler: @escaping Handler) -> Disposable
     {
         return self.addChainErrorHandler(RouteChain(transitionChain: chain), order: order, handler: handler)
     }
 
     @discardableResult
-    public func addChainErrorHandler(_ chain: RouteChain<S, E>, order: HandlerOrder = _defaultOrder, handler: Handler) -> Disposable
+    public func addChainErrorHandler(_ chain: RouteChain<S, E>, order: HandlerOrder = _defaultOrder, handler: @escaping Handler) -> Disposable
     {
         return self._addChainHandler(chain, order: order, handler: handler, isError: true)
     }
 
     @discardableResult
-    private func _addChainHandler(_ chain: RouteChain<S, E>, order: HandlerOrder = _defaultOrder, handler: Handler, isError: Bool) -> Disposable
+    private func _addChainHandler(_ chain: RouteChain<S, E>, order: HandlerOrder = _defaultOrder, handler: @escaping Handler, isError: Bool) -> Disposable
     {
         var handlerDisposables: [Disposable] = []
 
@@ -483,7 +483,7 @@ public final class StateMachine<S: StateType, E: EventType>: Machine<S, E>
     // MARK: addStateRouteMapping
 
     @discardableResult
-    public func addStateRouteMapping(_ routeMapping: StateRouteMapping) -> Disposable
+    public func addStateRouteMapping(_ routeMapping: @escaping StateRouteMapping) -> Disposable
     {
         let key = _createUniqueString()
 
@@ -499,7 +499,7 @@ public final class StateMachine<S: StateType, E: EventType>: Machine<S, E>
     // MARK: addStateRouteMapping + conditional handler
 
     @discardableResult
-    public func addStateRouteMapping(_ routeMapping: StateRouteMapping, handler: Handler) -> Disposable
+    public func addStateRouteMapping(_ routeMapping: @escaping StateRouteMapping, handler: @escaping Handler) -> Disposable
     {
         let routeDisposable = self.addStateRouteMapping(routeMapping)
 
diff --git a/Sources/_HandlerInfo.swift b/Sources/_HandlerInfo.swift
@@ -12,7 +12,7 @@ internal final class _HandlerInfo<S: StateType, E: EventType>
     internal let key: String
     internal let handler: Machine<S, E>.Handler
 
-    internal init(order: HandlerOrder, key: String, handler: Machine<S, E>.Handler)
+    internal init(order: HandlerOrder, key: String, handler: @escaping Machine<S, E>.Handler)
     {
         self.order = order
         self.key = key

Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ public final class ActionDisposable: Disposable {`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`/// Initializes the disposable to run the given action upon disposal.`
`37`		`- public init(action: (() -> ())) {`
	`37`	`+ public init(action: @escaping (() -> ())) {`
`38`	`38`	`self.action = action`
`39`	`39`	`}`
`40`	`40`
Original file line number	Diff line number	Diff line change
`@@ -293,26 +293,26 @@ public class Machine<S: StateType, E: EventType>`
`293`	`293`	`// MARK: addRoutes(event:) + conditional handler`
`294`	`294`
`295`	`295`	`@discardableResult`
`296`		`- public func addRoutes(event: E, transitions: [Transition<S>], condition: Condition? = nil, handler: Handler) -> Disposable`
	`296`	`+ public func addRoutes(event: E, transitions: [Transition<S>], condition: Condition? = nil, handler: @escaping Handler) -> Disposable`
`297`	`297`	`{`
`298`	`298`	`return self.addRoutes(event: .some(event), transitions: transitions, condition: condition, handler: handler)`
`299`	`299`	`}`
`300`	`300`
`301`	`301`	`@discardableResult`
`302`		`- public func addRoutes(event: Event<E>, transitions: [Transition<S>], condition: Condition? = nil, handler: Handler) -> Disposable`
	`302`	`+ public func addRoutes(event: Event<E>, transitions: [Transition<S>], condition: Condition? = nil, handler: @escaping Handler) -> Disposable`
`303`	`303`	`{`
`304`	`304`	`let routes = transitions.map { Route(transition: $0, condition: condition) }`
`305`	`305`	`return self.addRoutes(event: event, routes: routes, handler: handler)`
`306`	`306`	`}`
`307`	`307`
`308`	`308`	`@discardableResult`
`309`		`- public func addRoutes(event: E, routes: [Route<S, E>], handler: Handler) -> Disposable`
	`309`	`+ public func addRoutes(event: E, routes: [Route<S, E>], handler: @escaping Handler) -> Disposable`
`310`	`310`	`{`
`311`	`311`	`return self.addRoutes(event: .some(event), routes: routes, handler: handler)`
`312`	`312`	`}`
`313`	`313`
`314`	`314`	`@discardableResult`
`315`		`- public func addRoutes(event: Event<E>, routes: [Route<S, E>], handler: Handler) -> Disposable`
	`315`	`+ public func addRoutes(event: Event<E>, routes: [Route<S, E>], handler: @escaping Handler) -> Disposable`
`316`	`316`	`{`
`317`	`317`	`let routeDisposable = self.addRoutes(event: event, routes: routes)`
`318`	`318`	`let handlerDisposable = self.addHandler(event: event, handler: handler)`
`@@ -367,7 +367,7 @@ public class Machine<S: StateType, E: EventType>`
`367`	`367`	`// MARK: addRouteMapping`
`368`	`368`
`369`	`369`	`@discardableResult`
`370`		`- public func addRouteMapping(_ routeMapping: RouteMapping) -> Disposable`
	`370`	`+ public func addRouteMapping(_ routeMapping: @escaping RouteMapping) -> Disposable`
`371`	`371`	`{`
`372`	`372`	`let key = _createUniqueString()`
`373`	`373`
`@@ -383,7 +383,7 @@ public class Machine<S: StateType, E: EventType>`
`383`	`383`	`// MARK: addRouteMapping + conditional handler`
`384`	`384`
`385`	`385`	`@discardableResult`
`386`		`- public func addRouteMapping(_ routeMapping: RouteMapping, order: HandlerOrder = _defaultOrder, handler: Machine.Handler) -> Disposable`
	`386`	`+ public func addRouteMapping(_ routeMapping: @escaping RouteMapping, order: HandlerOrder = _defaultOrder, handler: @escaping Machine.Handler) -> Disposable`
`387`	`387`	`{`
`388`	`388`	`let routeDisposable = self.addRouteMapping(routeMapping)`
`389`	`389`
`@@ -425,13 +425,13 @@ public class Machine<S: StateType, E: EventType>`
`425`	`425`	`// MARK: addHandler(event:)`
`426`	`426`
`427`	`427`	`@discardableResult`
`428`		`- public func addHandler(event: E, order: HandlerOrder = _defaultOrder, handler: Machine.Handler) -> Disposable`
	`428`	`+ public func addHandler(event: E, order: HandlerOrder = _defaultOrder, handler: @escaping Machine.Handler) -> Disposable`
`429`	`429`	`{`
`430`	`430`	`return self.addHandler(event: .some(event), order: order, handler: handler)`
`431`	`431`	`}`
`432`	`432`
`433`	`433`	`@discardableResult`
`434`		`- public func addHandler(event: Event<E>, order: HandlerOrder = _defaultOrder, handler: Machine.Handler) -> Disposable`
	`434`	`+ public func addHandler(event: Event<E>, order: HandlerOrder = _defaultOrder, handler: @escaping Machine.Handler) -> Disposable`
`435`	`435`	`{`
`436`	`436`	`return self._addHandler(event: event, order: order) { context in`
`437`	`437`	`// skip if not event-based transition`
`@@ -446,7 +446,7 @@ public class Machine<S: StateType, E: EventType>`
`446`	`446`	`}`
`447`	`447`
`448`	`448`	`@discardableResult`
`449`		`- private func _addHandler(event: Event<E>, order: HandlerOrder = _defaultOrder, handler: Handler) -> Disposable`
	`449`	`+ private func _addHandler(event: Event<E>, order: HandlerOrder = _defaultOrder, handler: @escaping Handler) -> Disposable`
`450`	`450`	`{`
`451`	`451`	`if self._handlers[event] == nil {`
`452`	`452`	`self._handlers[event] = []`
`@@ -470,7 +470,7 @@ public class Machine<S: StateType, E: EventType>`
`470`	`470`	`// MARK: addErrorHandler`
`471`	`471`
`472`	`472`	`@discardableResult`
`473`		`- public func addErrorHandler(order: HandlerOrder = _defaultOrder, handler: Handler) -> Disposable`
	`473`	`+ public func addErrorHandler(order: HandlerOrder = _defaultOrder, handler: @escaping Handler) -> Disposable`
`474`	`474`	`{`
`475`	`475`	`let key = _createUniqueString()`
`476`	`476`
Original file line number	Diff line number	Diff line change
`@@ -215,14 +215,14 @@ public final class StateMachine<S: StateType, E: EventType>: Machine<S, E>`
`215`	`215`	`// MARK: addRoute (no-event) + conditional handler`
`216`	`216`
`217`	`217`	`@discardableResult`
`218`		`- public func addRoute(_ transition: Transition<S>, condition: Condition? = nil, handler: Handler) -> Disposable`
	`218`	`+ public func addRoute(_ transition: Transition<S>, condition: Condition? = nil, handler: @escaping Handler) -> Disposable`
`219`	`219`	`{`
`220`	`220`	`let route = Route(transition: transition, condition: condition)`
`221`	`221`	`return self.addRoute(route, handler: handler)`
`222`	`222`	`}`
`223`	`223`
`224`	`224`	`@discardableResult`
`225`		`- public func addRoute(_ route: Route<S, E>, handler: Handler) -> Disposable`
	`225`	`+ public func addRoute(_ route: Route<S, E>, handler: @escaping Handler) -> Disposable`
`226`	`226`	`{`
`227`	`227`	`let transition = route.transition`
`228`	`228`	`let condition = route.condition`
`@@ -278,7 +278,7 @@ public final class StateMachine<S: StateType, E: EventType>: Machine<S, E>`
`278`	`278`	/// Add `handler` that is called when `tryState()` succeeds for target `transition`.
`279`	`279`	/// - Note: `handler` will not be invoked for `tryEvent()`.
`280`	`280`	`@discardableResult`
`281`		`- public func addHandler(_ transition: Transition<S>, order: HandlerOrder = _defaultOrder, handler: Handler) -> Disposable`
	`281`	`+ public func addHandler(_ transition: Transition<S>, order: HandlerOrder = _defaultOrder, handler: @escaping Handler) -> Disposable`
`282`	`282`	`{`
`283`	`283`	`if self._handlers[transition] == nil {`
`284`	`284`	`self._handlers[transition] = []`
`@@ -322,7 +322,7 @@ public final class StateMachine<S: StateType, E: EventType>: Machine<S, E>`
`322`	`322`
`323`	`323`	/// Add `handler` that is called when either `tryEvent()` or `tryState()` succeeds for target `transition`.
`324`	`324`	`@discardableResult`
`325`		`- public func addAnyHandler(_ transition: Transition<S>, order: HandlerOrder = _defaultOrder, handler: Handler) -> Disposable`
	`325`	`+ public func addAnyHandler(_ transition: Transition<S>, order: HandlerOrder = _defaultOrder, handler: @escaping Handler) -> Disposable`
`326`	`326`	`{`
`327`	`327`	`let disposable1 = self.addHandler(transition, order: order, handler: handler)`
`328`	`328`	`let disposable2 = self.addHandler(event: .any, order: order) { context in`
`@@ -351,14 +351,14 @@ public final class StateMachine<S: StateType, E: EventType>: Machine<S, E>`
`351`	`351`	`// MARK: addRouteChain + conditional handler`
`352`	`352`
`353`	`353`	`@discardableResult`
`354`		`- public func addRouteChain(_ chain: TransitionChain<S>, condition: Condition? = nil, handler: Handler) -> Disposable`
	`354`	`+ public func addRouteChain(_ chain: TransitionChain<S>, condition: Condition? = nil, handler: @escaping Handler) -> Disposable`
`355`	`355`	`{`
`356`	`356`	`let routeChain = RouteChain(transitionChain: chain, condition: condition)`
`357`	`357`	`return self.addRouteChain(routeChain, handler: handler)`
`358`	`358`	`}`
`359`	`359`
`360`	`360`	`@discardableResult`
`361`		`- public func addRouteChain(_ chain: RouteChain<S, E>, handler: Handler) -> Disposable`
	`361`	`+ public func addRouteChain(_ chain: RouteChain<S, E>, handler: @escaping Handler) -> Disposable`
`362`	`362`	`{`
`363`	`363`	`let routeDisposables = chain.routes.map { self.addRoute($0) }`
`364`	`364`	`let handlerDisposable = self.addChainHandler(chain, handler: handler)`
`@@ -372,33 +372,33 @@ public final class StateMachine<S: StateType, E: EventType>: Machine<S, E>`
`372`	`372`	`// MARK: addChainHandler`
`373`	`373`
`374`	`374`	`@discardableResult`
`375`		`- public func addChainHandler(_ chain: TransitionChain<S>, order: HandlerOrder = _defaultOrder, handler: Handler) -> Disposable`
	`375`	`+ public func addChainHandler(_ chain: TransitionChain<S>, order: HandlerOrder = _defaultOrder, handler: @escaping Handler) -> Disposable`
`376`	`376`	`{`
`377`	`377`	`return self.addChainHandler(RouteChain(transitionChain: chain), order: order, handler: handler)`
`378`	`378`	`}`
`379`	`379`
`380`	`380`	`@discardableResult`
`381`		`- public func addChainHandler(_ chain: RouteChain<S, E>, order: HandlerOrder = _defaultOrder, handler: Handler) -> Disposable`
	`381`	`+ public func addChainHandler(_ chain: RouteChain<S, E>, order: HandlerOrder = _defaultOrder, handler: @escaping Handler) -> Disposable`
`382`	`382`	`{`
`383`	`383`	`return self._addChainHandler(chain, order: order, handler: handler, isError: false)`
`384`	`384`	`}`
`385`	`385`
`386`	`386`	`// MARK: addChainErrorHandler`
`387`	`387`
`388`	`388`	`@discardableResult`
`389`		`- public func addChainErrorHandler(_ chain: TransitionChain<S>, order: HandlerOrder = _defaultOrder, handler: Handler) -> Disposable`
	`389`	`+ public func addChainErrorHandler(_ chain: TransitionChain<S>, order: HandlerOrder = _defaultOrder, handler: @escaping Handler) -> Disposable`
`390`	`390`	`{`
`391`	`391`	`return self.addChainErrorHandler(RouteChain(transitionChain: chain), order: order, handler: handler)`
`392`	`392`	`}`
`393`	`393`
`394`	`394`	`@discardableResult`
`395`		`- public func addChainErrorHandler(_ chain: RouteChain<S, E>, order: HandlerOrder = _defaultOrder, handler: Handler) -> Disposable`
	`395`	`+ public func addChainErrorHandler(_ chain: RouteChain<S, E>, order: HandlerOrder = _defaultOrder, handler: @escaping Handler) -> Disposable`
`396`	`396`	`{`
`397`	`397`	`return self._addChainHandler(chain, order: order, handler: handler, isError: true)`
`398`	`398`	`}`
`399`	`399`
`400`	`400`	`@discardableResult`
`401`		`- private func _addChainHandler(_ chain: RouteChain<S, E>, order: HandlerOrder = _defaultOrder, handler: Handler, isError: Bool) -> Disposable`
	`401`	`+ private func _addChainHandler(_ chain: RouteChain<S, E>, order: HandlerOrder = _defaultOrder, handler: @escaping Handler, isError: Bool) -> Disposable`
`402`	`402`	`{`
`403`	`403`	`var handlerDisposables: [Disposable] = []`
`404`	`404`
`@@ -483,7 +483,7 @@ public final class StateMachine<S: StateType, E: EventType>: Machine<S, E>`
`483`	`483`	`// MARK: addStateRouteMapping`
`484`	`484`
`485`	`485`	`@discardableResult`
`486`		`- public func addStateRouteMapping(_ routeMapping: StateRouteMapping) -> Disposable`
	`486`	`+ public func addStateRouteMapping(_ routeMapping: @escaping StateRouteMapping) -> Disposable`
`487`	`487`	`{`
`488`	`488`	`let key = _createUniqueString()`
`489`	`489`
`@@ -499,7 +499,7 @@ public final class StateMachine<S: StateType, E: EventType>: Machine<S, E>`
`499`	`499`	`// MARK: addStateRouteMapping + conditional handler`
`500`	`500`
`501`	`501`	`@discardableResult`
`502`		`- public func addStateRouteMapping(_ routeMapping: StateRouteMapping, handler: Handler) -> Disposable`
	`502`	`+ public func addStateRouteMapping(_ routeMapping: @escaping StateRouteMapping, handler: @escaping Handler) -> Disposable`
`503`	`503`	`{`
`504`	`504`	`let routeDisposable = self.addStateRouteMapping(routeMapping)`
`505`	`505`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ internal final class _HandlerInfo<S: StateType, E: EventType>`
`12`	`12`	`internal let key: String`
`13`	`13`	`internal let handler: Machine<S, E>.Handler`
`14`	`14`
`15`		`- internal init(order: HandlerOrder, key: String, handler: Machine<S, E>.Handler)`
	`15`	`+ internal init(order: HandlerOrder, key: String, handler: @escaping Machine<S, E>.Handler)`
`16`	`16`	`{`
`17`	`17`	`self.order = order`
`18`	`18`	`self.key = key`