Update project to Xcode 9 suggested settings, fix warnings

adamyanalunas · adamyanalunas · commit 7a5da5b9b5da · 2017-09-27T15:09:24.000-07:00
diff --git a/Sources/EventType.swift b/Sources/EventType.swift
@@ -49,7 +49,7 @@ extension Event: RawRepresentable
     }
 }
 
-public func == <E: EventType>(lhs: Event<E>, rhs: Event<E>) -> Bool
+public func == <E>(lhs: Event<E>, rhs: Event<E>) -> Bool
 {
     switch (lhs, rhs) {
         case let (.some(x1), .some(x2)) where x1 == x2:
@@ -61,7 +61,7 @@ public func == <E: EventType>(lhs: Event<E>, rhs: Event<E>) -> Bool
     }
 }
 
-public func == <E: EventType>(lhs: Event<E>, rhs: E) -> Bool
+public func == <E>(lhs: Event<E>, rhs: E) -> Bool
 {
     switch lhs {
     case .some(let x):
@@ -71,7 +71,7 @@ public func == <E: EventType>(lhs: Event<E>, rhs: E) -> Bool
     }
 }
 
-public func == <E: EventType>(lhs: E, rhs: Event<E>) -> Bool
+public func == <E>(lhs: E, rhs: Event<E>) -> Bool
 {
     switch rhs {
     case .some(let x):
diff --git a/Sources/Machine.swift b/Sources/Machine.swift
@@ -521,14 +521,14 @@ public class Machine<S: StateType, E: EventType>
 infix operator <-! : AdditionPrecedence
 
 @discardableResult
-public func <-! <S: StateType, E: EventType>(machine: Machine<S, E>, event: E) -> Machine<S, E>
+public func <-! <S, E>(machine: Machine<S, E>, event: E) -> Machine<S, E>
 {
     machine.tryEvent(event)
     return machine
 }
 
 @discardableResult
-public func <-! <S: StateType, E: EventType>(machine: Machine<S, E>, tuple: (E, Any?)) -> Machine<S, E>
+public func <-! <S, E>(machine: Machine<S, E>, tuple: (E, Any?)) -> Machine<S, E>
 {
     machine.tryEvent(tuple.0, userInfo: tuple.1)
     return machine
@@ -557,7 +557,7 @@ internal func _createUniqueString() -> String
     return uniqueString
 }
 
-internal func _validTransitions<S: StateType>(fromState: S, toState: S) -> [Transition<S>]
+internal func _validTransitions<S>(fromState: S, toState: S) -> [Transition<S>]
 {
     return [
         fromState => toState,
@@ -567,12 +567,12 @@ internal func _validTransitions<S: StateType>(fromState: S, toState: S) -> [Tran
     ]
 }
 
-internal func _canPassCondition<S: StateType, E: EventType>(_ condition: Machine<S, E>.Condition?, forEvent event: E?, fromState: S, toState: S, userInfo: Any?) -> Bool
+internal func _canPassCondition<S:StateType, E:EventType>(_ condition: Machine<S, E>.Condition?, forEvent event: E?, fromState: S, toState: S, userInfo: Any?) -> Bool
 {
     return condition?((event, fromState, toState, userInfo)) ?? true
 }
 
-internal func _insertHandlerIntoArray<S: StateType, E: EventType>(_ handlerInfos: inout [_HandlerInfo<S, E>], newHandlerInfo: _HandlerInfo<S, E>)
+internal func _insertHandlerIntoArray<S, E>(_ handlerInfos: inout [_HandlerInfo<S, E>], newHandlerInfo: _HandlerInfo<S, E>)
 {
     var index = handlerInfos.count
 
@@ -586,7 +586,7 @@ internal func _insertHandlerIntoArray<S: StateType, E: EventType>(_ handlerInfos
     handlerInfos.insert(newHandlerInfo, at: index)
 }
 
-internal func _removeHandlerFromArray<S: StateType, E: EventType>(_ handlerInfos: inout [_HandlerInfo<S, E>], removingHandlerID: _HandlerID<S, E>) -> Bool
+internal func _removeHandlerFromArray<S, E>(_ handlerInfos: inout [_HandlerInfo<S, E>], removingHandlerID: _HandlerID<S, E>) -> Bool
 {
     for i in 0..<handlerInfos.count {
         if handlerInfos[i].key == removingHandlerID.key {
diff --git a/Sources/Route.swift b/Sources/Route.swift
@@ -24,34 +24,34 @@ public struct Route<S: StateType, E: EventType>
 //--------------------------------------------------
 
 /// e.g. [.state0, .state1] => .state, allowing [0 => 2, 1 => 2]
-public func => <S: StateType, E: EventType>(leftStates: [S], right: State<S>) -> Route<S, E>
+public func => <S, E>(leftStates: [S], right: State<S>) -> Route<S, E>
 {
     // NOTE: don't reuse ".any => .any + condition" for efficiency
     return Route(transition: .any => right, condition: { context -> Bool in
         return leftStates.contains(context.fromState)
     })
 }
 
-public func => <S: StateType, E: EventType>(leftStates: [S], right: S) -> Route<S, E>
+public func => <S, E>(leftStates: [S], right: S) -> Route<S, E>
 {
     return leftStates => .some(right)
 }
 
 /// e.g. .state0 => [.state1, .state], allowing [0 => 1, 0 => 2]
-public func => <S: StateType, E: EventType>(left: State<S>, rightStates: [S]) -> Route<S, E>
+public func => <S, E>(left: State<S>, rightStates: [S]) -> Route<S, E>
 {
     return Route(transition: left => .any, condition: { context -> Bool in
         return rightStates.contains(context.toState)
     })
 }
 
-public func => <S: StateType, E: EventType>(left: S, rightStates: [S]) -> Route<S, E>
+public func => <S, E>(left: S, rightStates: [S]) -> Route<S, E>
 {
     return .some(left) => rightStates
 }
 
 /// e.g. [.state0, .state1] => [.state, .state3], allowing [0 => 2, 0 => 3, 1 => 2, 1 => 3]
-public func => <S: StateType, E: EventType>(leftStates: [S], rightStates: [S]) -> Route<S, E>
+public func => <S, E>(leftStates: [S], rightStates: [S]) -> Route<S, E>
 {
     return Route(transition: .any => .any, condition: { context -> Bool in
         return leftStates.contains(context.fromState) && rightStates.contains(context.toState)
diff --git a/Sources/StateMachine.swift b/Sources/StateMachine.swift
@@ -546,14 +546,14 @@ public final class StateMachine<S: StateType, E: EventType>: Machine<S, E>
 infix operator <- : AdditionPrecedence
 
 @discardableResult
-public func <- <S: StateType, E: EventType>(machine: StateMachine<S, E>, state: S) -> StateMachine<S, E>
+public func <- <S, E>(machine: StateMachine<S, E>, state: S) -> StateMachine<S, E>
 {
     machine.tryState(state)
     return machine
 }
 
 @discardableResult
-public func <- <S: StateType, E: EventType>(machine: StateMachine<S, E>, tuple: (S, Any?)) -> StateMachine<S, E>
+public func <- <S, E>(machine: StateMachine<S, E>, tuple: (S, Any?)) -> StateMachine<S, E>
 {
     machine.tryState(tuple.0, userInfo: tuple.1)
     return machine
diff --git a/Sources/StateType.swift b/Sources/StateType.swift
@@ -49,7 +49,7 @@ extension State: RawRepresentable
     }
 }
 
-public func == <S: StateType>(lhs: State<S>, rhs: State<S>) -> Bool
+public func == <S>(lhs: State<S>, rhs: State<S>) -> Bool
 {
     switch (lhs, rhs) {
     case let (.some(x1), .some(x2)) where x1 == x2:
@@ -61,7 +61,7 @@ public func == <S: StateType>(lhs: State<S>, rhs: State<S>) -> Bool
     }
 }
 
-public func == <S: StateType>(lhs: State<S>, rhs: S) -> Bool
+public func == <S>(lhs: State<S>, rhs: S) -> Bool
 {
     switch lhs {
     case .some(let x):
@@ -71,7 +71,7 @@ public func == <S: StateType>(lhs: State<S>, rhs: S) -> Bool
     }
 }
 
-public func == <S: StateType>(lhs: S, rhs: State<S>) -> Bool
+public func == <S>(lhs: S, rhs: State<S>) -> Bool
 {
     switch rhs {
     case .some(let x):
diff --git a/Sources/Transition.swift b/Sources/Transition.swift
@@ -43,7 +43,7 @@ public struct Transition<S: StateType>: Hashable
 }
 
 // for Transition Equatable
-public func == <S: StateType>(left: Transition<S>, right: Transition<S>) -> Bool
+public func == <S>(left: Transition<S>, right: Transition<S>) -> Bool
 {
     return left.fromState == right.fromState && left.toState == right.toState
 }
@@ -55,22 +55,22 @@ public func == <S: StateType>(left: Transition<S>, right: Transition<S>) -> Bool
 infix operator => : AdditionPrecedence
 
 /// e.g. .state0 => .state1
-public func => <S: StateType>(left: State<S>, right: State<S>) -> Transition<S>
+public func => <S>(left: State<S>, right: State<S>) -> Transition<S>
 {
     return Transition(fromState: left, toState: right)
 }
 
-public func => <S: StateType>(left: State<S>, right: S) -> Transition<S>
+public func => <S>(left: State<S>, right: S) -> Transition<S>
 {
     return left => .some(right)
 }
 
-public func => <S: StateType>(left: S, right: State<S>) -> Transition<S>
+public func => <S>(left: S, right: State<S>) -> Transition<S>
 {
     return .some(left) => right
 }
 
-public func => <S: StateType>(left: S, right: S) -> Transition<S>
+public func => <S>(left: S, right: S) -> Transition<S>
 {
     return .some(left) => .some(right)
 }
diff --git a/Sources/TransitionChain.swift b/Sources/TransitionChain.swift
@@ -38,43 +38,43 @@ public struct TransitionChain<S: StateType>
 //--------------------------------------------------
 
 // e.g. (.state0 => .state1) => .state
-public func => <S: StateType>(left: Transition<S>, right: State<S>) -> TransitionChain<S>
+public func => <S>(left: Transition<S>, right: State<S>) -> TransitionChain<S>
 {
     return TransitionChain(states: [left.fromState, left.toState]) => right
 }
 
-public func => <S: StateType>(left: Transition<S>, right: S) -> TransitionChain<S>
+public func => <S>(left: Transition<S>, right: S) -> TransitionChain<S>
 {
     return left => .some(right)
 }
 
-public func => <S: StateType>(left: TransitionChain<S>, right: State<S>) -> TransitionChain<S>
+public func => <S>(left: TransitionChain<S>, right: State<S>) -> TransitionChain<S>
 {
     return TransitionChain(states: left.states + [right])
 }
 
-public func => <S: StateType>(left: TransitionChain<S>, right: S) -> TransitionChain<S>
+public func => <S>(left: TransitionChain<S>, right: S) -> TransitionChain<S>
 {
     return left => .some(right)
 }
 
 // e.g. .state0 => (.state1 => .state)
-public func => <S: StateType>(left: State<S>, right: Transition<S>) -> TransitionChain<S>
+public func => <S>(left: State<S>, right: Transition<S>) -> TransitionChain<S>
 {
     return left => TransitionChain(states: [right.fromState, right.toState])
 }
 
-public func => <S: StateType>(left: S, right: Transition<S>) -> TransitionChain<S>
+public func => <S>(left: S, right: Transition<S>) -> TransitionChain<S>
 {
     return .some(left) => right
 }
 
-public func => <S: StateType>(left: State<S>, right: TransitionChain<S>) -> TransitionChain<S>
+public func => <S>(left: State<S>, right: TransitionChain<S>) -> TransitionChain<S>
 {
     return TransitionChain(states: [left] + right.states)
 }
 
-public func => <S: StateType>(left: S, right: TransitionChain<S>) -> TransitionChain<S>
+public func => <S>(left: S, right: TransitionChain<S>) -> TransitionChain<S>
 {
     return .some(left) => right
 }
diff --git a/SwiftState.xcodeproj/project.pbxproj b/SwiftState.xcodeproj/project.pbxproj
@@ -312,7 +312,7 @@
 			isa = PBXProject;
 			attributes = {
 				LastSwiftUpdateCheck = 0700;
-				LastUpgradeCheck = 0800;
+				LastUpgradeCheck = 0900;
 				ORGANIZATIONNAME = "Yasuhiro Inami";
 				TargetAttributes = {
 					1FA61FFF1996601000460108 = {
@@ -427,14 +427,20 @@
 				CLANG_CXX_LIBRARY = "libc++";
 				CLANG_ENABLE_MODULES = YES;
 				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
 				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
 				CLANG_WARN_CONSTANT_CONVERSION = YES;
 				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
 				CLANG_WARN_EMPTY_BODY = YES;
 				CLANG_WARN_ENUM_CONVERSION = YES;
 				CLANG_WARN_INFINITE_RECURSION = YES;
 				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
 				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
 				CLANG_WARN_SUSPICIOUS_MOVE = YES;
 				CLANG_WARN_UNREACHABLE_CODE = YES;
 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
@@ -475,14 +481,20 @@
 				CLANG_CXX_LIBRARY = "libc++";
 				CLANG_ENABLE_MODULES = YES;
 				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES;
 				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_COMMA = YES;
 				CLANG_WARN_CONSTANT_CONVERSION = YES;
 				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
 				CLANG_WARN_EMPTY_BODY = YES;
 				CLANG_WARN_ENUM_CONVERSION = YES;
 				CLANG_WARN_INFINITE_RECURSION = YES;
 				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES;
+				CLANG_WARN_OBJC_LITERAL_CONVERSION = YES;
 				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
+				CLANG_WARN_RANGE_LOOP_ANALYSIS = YES;
+				CLANG_WARN_STRICT_PROTOTYPES = YES;
 				CLANG_WARN_SUSPICIOUS_MOVE = YES;
 				CLANG_WARN_UNREACHABLE_CODE = YES;
 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
diff --git a/SwiftState.xcodeproj/xcshareddata/xcschemes/SwiftState.xcscheme b/SwiftState.xcodeproj/xcshareddata/xcschemes/SwiftState.xcscheme
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Scheme
-   LastUpgradeVersion = "0800"
+   LastUpgradeVersion = "0900"
    version = "1.3">
    <BuildAction
       parallelizeBuildables = "YES"
@@ -26,6 +26,7 @@
       buildConfiguration = "Debug"
       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      language = ""
       shouldUseLaunchSchemeArgsEnv = "YES"
       codeCoverageEnabled = "YES">
       <Testables>
@@ -56,6 +57,7 @@
       buildConfiguration = "Debug"
       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      language = ""
       launchStyle = "0"
       useCustomWorkingDirectory = "NO"
       ignoresPersistentStateOnLaunch = "NO"
diff --git a/Tests/BasicTests.swift b/Tests/BasicTests.swift
@@ -17,8 +17,8 @@ class BasicTests: _TestCase
         let machine = StateMachine<MyState, NoEvent>(state: .state0) { machine in
 
             machine.addRoute(.state0 => .state1)
-            machine.addRoute(.any => .state2) { context in print("Any => 2, msg=\(context.userInfo)") }
-            machine.addRoute(.state2 => .any) { context in print("2 => Any, msg=\(context.userInfo)") }
+            machine.addRoute(.any => .state2) { context in print("Any => 2, msg=\(String(describing: context.userInfo))") }
+            machine.addRoute(.state2 => .any) { context in print("2 => Any, msg=\(String(describing: context.userInfo))") }
 
             // add handler (`context = (event, fromState, toState, userInfo)`)
             machine.addHandler(.state0 => .state1) { context in
diff --git a/Tests/MiscTests.swift b/Tests/MiscTests.swift
@@ -17,8 +17,8 @@ class MiscTests: _TestCase
         let machine = StateMachine<String, NoEvent>(state: ".State0") { machine in
 
             machine.addRoute(".State0" => ".State1")
-            machine.addRoute(.any => ".State2") { context in print("Any => 2, msg=\(context.userInfo)") }
-            machine.addRoute(".State2" => .any) { context in print("2 => Any, msg=\(context.userInfo)") }
+            machine.addRoute(.any => ".State2") { context in print("Any => 2, msg=\(String(describing: context.userInfo))") }
+            machine.addRoute(".State2" => .any) { context in print("2 => Any, msg=\(String(describing: context.userInfo))") }
 
             // add handler (handlerContext = (event, transition, order, userInfo))
             machine.addHandler(".State0" => ".State1") { context in
@@ -54,8 +54,8 @@ class MiscTests: _TestCase
         let machine = StateMachine<StrState, StrEvent>(state: .str("0")) { machine in
 
             machine.addRoute(.str("0") => .str("1"))
-            machine.addRoute(.any => .str("2")) { context in print("Any => 2, msg=\(context.userInfo)") }
-            machine.addRoute(.str("2") => .any) { context in print("2 => Any, msg=\(context.userInfo)") }
+            machine.addRoute(.any => .str("2")) { context in print("Any => 2, msg=\(String(describing: context.userInfo))") }
+            machine.addRoute(.str("2") => .any) { context in print("2 => Any, msg=\(String(describing: context.userInfo))") }
 
             // add handler (handlerContext = (event, transition, order, userInfo))
             machine.addHandler(.str("0") => .str("1")) { context in
@@ -151,10 +151,10 @@ class MiscTests: _TestCase
                 print("[Entry 1] \(context.fromState) => \(context.toState)")
             }
             $0.addHandler(.any => .state2) { context in
-                print("[Entry 2] \(context.fromState) => \(context.toState), userInfo = \(context.userInfo)")
+                print("[Entry 2] \(context.fromState) => \(context.toState), userInfo = \(String(describing: context.userInfo))")
             }
             $0.addHandler(.any => .state2) { context in
-                print("[Entry 2b] \(context.fromState) => \(context.toState), userInfo = \(context.userInfo)")
+                print("[Entry 2b] \(context.fromState) => \(context.toState), userInfo = \(String(describing: context.userInfo))")
             }
 
             // add exit handlers
@@ -165,10 +165,10 @@ class MiscTests: _TestCase
                 print("[Exit 1] \(context.fromState) => \(context.toState)")
             }
             $0.addHandler(.state2 => .any) { context in
-                print("[Exit 2] \(context.fromState) => \(context.toState), userInfo = \(context.userInfo)")
+                print("[Exit 2] \(context.fromState) => \(context.toState), userInfo = \(String(describing: context.userInfo))")
             }
             $0.addHandler(.state2 => .any) { context in
-                print("[Exit 2b] \(context.fromState) => \(context.toState), userInfo = \(context.userInfo)")
+                print("[Exit 2b] \(context.fromState) => \(context.toState), userInfo = \(String(describing: context.userInfo))")
             }
         }
 

Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,7 @@ extension Event: RawRepresentable`
`49`	`49`	`}`
`50`	`50`	`}`
`51`	`51`
`52`		`-public func == <E: EventType>(lhs: Event<E>, rhs: Event<E>) -> Bool`
	`52`	`+public func == <E>(lhs: Event<E>, rhs: Event<E>) -> Bool`
`53`	`53`	`{`
`54`	`54`	`switch (lhs, rhs) {`
`55`	`55`	`case let (.some(x1), .some(x2)) where x1 == x2:`
`@@ -61,7 +61,7 @@ public func == <E: EventType>(lhs: Event<E>, rhs: Event<E>) -> Bool`
`61`	`61`	`}`
`62`	`62`	`}`
`63`	`63`
`64`		`-public func == <E: EventType>(lhs: Event<E>, rhs: E) -> Bool`
	`64`	`+public func == <E>(lhs: Event<E>, rhs: E) -> Bool`
`65`	`65`	`{`
`66`	`66`	`switch lhs {`
`67`	`67`	`case .some(let x):`
`@@ -71,7 +71,7 @@ public func == <E: EventType>(lhs: Event<E>, rhs: E) -> Bool`
`71`	`71`	`}`
`72`	`72`	`}`
`73`	`73`
`74`		`-public func == <E: EventType>(lhs: E, rhs: Event<E>) -> Bool`
	`74`	`+public func == <E>(lhs: E, rhs: Event<E>) -> Bool`
`75`	`75`	`{`
`76`	`76`	`switch rhs {`
`77`	`77`	`case .some(let x):`
Original file line number	Diff line number	Diff line change
`@@ -521,14 +521,14 @@ public class Machine<S: StateType, E: EventType>`
`521`	`521`	`infix operator <-! : AdditionPrecedence`
`522`	`522`
`523`	`523`	`@discardableResult`
`524`		`-public func <-! <S: StateType, E: EventType>(machine: Machine<S, E>, event: E) -> Machine<S, E>`
	`524`	`+public func <-! <S, E>(machine: Machine<S, E>, event: E) -> Machine<S, E>`
`525`	`525`	`{`
`526`	`526`	`machine.tryEvent(event)`
`527`	`527`	`return machine`
`528`	`528`	`}`
`529`	`529`
`530`	`530`	`@discardableResult`
`531`		`-public func <-! <S: StateType, E: EventType>(machine: Machine<S, E>, tuple: (E, Any?)) -> Machine<S, E>`
	`531`	`+public func <-! <S, E>(machine: Machine<S, E>, tuple: (E, Any?)) -> Machine<S, E>`
`532`	`532`	`{`
`533`	`533`	`machine.tryEvent(tuple.0, userInfo: tuple.1)`
`534`	`534`	`return machine`
`@@ -557,7 +557,7 @@ internal func _createUniqueString() -> String`
`557`	`557`	`return uniqueString`
`558`	`558`	`}`
`559`	`559`
`560`		`-internal func _validTransitions<S: StateType>(fromState: S, toState: S) -> [Transition<S>]`
	`560`	`+internal func _validTransitions<S>(fromState: S, toState: S) -> [Transition<S>]`
`561`	`561`	`{`
`562`	`562`	`return [`
`563`	`563`	`fromState => toState,`
`@@ -567,12 +567,12 @@ internal func _validTransitions<S: StateType>(fromState: S, toState: S) -> [Tran`
`567`	`567`	`]`
`568`	`568`	`}`
`569`	`569`
`570`		`-internal func _canPassCondition<S: StateType, E: EventType>(_ condition: Machine<S, E>.Condition?, forEvent event: E?, fromState: S, toState: S, userInfo: Any?) -> Bool`
	`570`	`+internal func _canPassCondition<S:StateType, E:EventType>(_ condition: Machine<S, E>.Condition?, forEvent event: E?, fromState: S, toState: S, userInfo: Any?) -> Bool`
`571`	`571`	`{`
`572`	`572`	`return condition?((event, fromState, toState, userInfo)) ?? true`
`573`	`573`	`}`
`574`	`574`
`575`		`-internal func _insertHandlerIntoArray<S: StateType, E: EventType>(_ handlerInfos: inout [_HandlerInfo<S, E>], newHandlerInfo: _HandlerInfo<S, E>)`
	`575`	`+internal func _insertHandlerIntoArray<S, E>(_ handlerInfos: inout [_HandlerInfo<S, E>], newHandlerInfo: _HandlerInfo<S, E>)`
`576`	`576`	`{`
`577`	`577`	`var index = handlerInfos.count`
`578`	`578`
`@@ -586,7 +586,7 @@ internal func _insertHandlerIntoArray<S: StateType, E: EventType>(_ handlerInfos`
`586`	`586`	`handlerInfos.insert(newHandlerInfo, at: index)`
`587`	`587`	`}`
`588`	`588`
`589`		`-internal func _removeHandlerFromArray<S: StateType, E: EventType>(_ handlerInfos: inout [_HandlerInfo<S, E>], removingHandlerID: _HandlerID<S, E>) -> Bool`
	`589`	`+internal func _removeHandlerFromArray<S, E>(_ handlerInfos: inout [_HandlerInfo<S, E>], removingHandlerID: _HandlerID<S, E>) -> Bool`
`590`	`590`	`{`
`591`	`591`	`for i in 0..<handlerInfos.count {`
`592`	`592`	`if handlerInfos[i].key == removingHandlerID.key {`
Original file line number	Diff line number	Diff line change
`@@ -24,34 +24,34 @@ public struct Route<S: StateType, E: EventType>`
`24`	`24`	`//--------------------------------------------------`
`25`	`25`
`26`	`26`	`/// e.g. [.state0, .state1] => .state, allowing [0 => 2, 1 => 2]`
`27`		`-public func => <S: StateType, E: EventType>(leftStates: [S], right: State<S>) -> Route<S, E>`
	`27`	`+public func => <S, E>(leftStates: [S], right: State<S>) -> Route<S, E>`
`28`	`28`	`{`
`29`	`29`	`// NOTE: don't reuse ".any => .any + condition" for efficiency`
`30`	`30`	`return Route(transition: .any => right, condition: { context -> Bool in`
`31`	`31`	`return leftStates.contains(context.fromState)`
`32`	`32`	`})`
`33`	`33`	`}`
`34`	`34`
`35`		`-public func => <S: StateType, E: EventType>(leftStates: [S], right: S) -> Route<S, E>`
	`35`	`+public func => <S, E>(leftStates: [S], right: S) -> Route<S, E>`
`36`	`36`	`{`
`37`	`37`	`return leftStates => .some(right)`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`/// e.g. .state0 => [.state1, .state], allowing [0 => 1, 0 => 2]`
`41`		`-public func => <S: StateType, E: EventType>(left: State<S>, rightStates: [S]) -> Route<S, E>`
	`41`	`+public func => <S, E>(left: State<S>, rightStates: [S]) -> Route<S, E>`
`42`	`42`	`{`
`43`	`43`	`return Route(transition: left => .any, condition: { context -> Bool in`
`44`	`44`	`return rightStates.contains(context.toState)`
`45`	`45`	`})`
`46`	`46`	`}`
`47`	`47`
`48`		`-public func => <S: StateType, E: EventType>(left: S, rightStates: [S]) -> Route<S, E>`
	`48`	`+public func => <S, E>(left: S, rightStates: [S]) -> Route<S, E>`
`49`	`49`	`{`
`50`	`50`	`return .some(left) => rightStates`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`/// e.g. [.state0, .state1] => [.state, .state3], allowing [0 => 2, 0 => 3, 1 => 2, 1 => 3]`
`54`		`-public func => <S: StateType, E: EventType>(leftStates: [S], rightStates: [S]) -> Route<S, E>`
	`54`	`+public func => <S, E>(leftStates: [S], rightStates: [S]) -> Route<S, E>`
`55`	`55`	`{`
`56`	`56`	`return Route(transition: .any => .any, condition: { context -> Bool in`
`57`	`57`	`return leftStates.contains(context.fromState) && rightStates.contains(context.toState)`
Original file line number	Diff line number	Diff line change
`@@ -546,14 +546,14 @@ public final class StateMachine<S: StateType, E: EventType>: Machine<S, E>`
`546`	`546`	`infix operator <- : AdditionPrecedence`
`547`	`547`
`548`	`548`	`@discardableResult`
`549`		`-public func <- <S: StateType, E: EventType>(machine: StateMachine<S, E>, state: S) -> StateMachine<S, E>`
	`549`	`+public func <- <S, E>(machine: StateMachine<S, E>, state: S) -> StateMachine<S, E>`
`550`	`550`	`{`
`551`	`551`	`machine.tryState(state)`
`552`	`552`	`return machine`
`553`	`553`	`}`
`554`	`554`
`555`	`555`	`@discardableResult`
`556`		`-public func <- <S: StateType, E: EventType>(machine: StateMachine<S, E>, tuple: (S, Any?)) -> StateMachine<S, E>`
	`556`	`+public func <- <S, E>(machine: StateMachine<S, E>, tuple: (S, Any?)) -> StateMachine<S, E>`
`557`	`557`	`{`
`558`	`558`	`machine.tryState(tuple.0, userInfo: tuple.1)`
`559`	`559`	`return machine`
Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,7 @@ extension State: RawRepresentable`
`49`	`49`	`}`
`50`	`50`	`}`
`51`	`51`
`52`		`-public func == <S: StateType>(lhs: State<S>, rhs: State<S>) -> Bool`
	`52`	`+public func == <S>(lhs: State<S>, rhs: State<S>) -> Bool`
`53`	`53`	`{`
`54`	`54`	`switch (lhs, rhs) {`
`55`	`55`	`case let (.some(x1), .some(x2)) where x1 == x2:`
`@@ -61,7 +61,7 @@ public func == <S: StateType>(lhs: State<S>, rhs: State<S>) -> Bool`
`61`	`61`	`}`
`62`	`62`	`}`
`63`	`63`
`64`		`-public func == <S: StateType>(lhs: State<S>, rhs: S) -> Bool`
	`64`	`+public func == <S>(lhs: State<S>, rhs: S) -> Bool`
`65`	`65`	`{`
`66`	`66`	`switch lhs {`
`67`	`67`	`case .some(let x):`
`@@ -71,7 +71,7 @@ public func == <S: StateType>(lhs: State<S>, rhs: S) -> Bool`
`71`	`71`	`}`
`72`	`72`	`}`
`73`	`73`
`74`		`-public func == <S: StateType>(lhs: S, rhs: State<S>) -> Bool`
	`74`	`+public func == <S>(lhs: S, rhs: State<S>) -> Bool`
`75`	`75`	`{`
`76`	`76`	`switch rhs {`
`77`	`77`	`case .some(let x):`
Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ public struct Transition<S: StateType>: Hashable`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`// for Transition Equatable`
`46`		`-public func == <S: StateType>(left: Transition<S>, right: Transition<S>) -> Bool`
	`46`	`+public func == <S>(left: Transition<S>, right: Transition<S>) -> Bool`
`47`	`47`	`{`
`48`	`48`	`return left.fromState == right.fromState && left.toState == right.toState`
`49`	`49`	`}`
`@@ -55,22 +55,22 @@ public func == <S: StateType>(left: Transition<S>, right: Transition<S>) -> Bool`
`55`	`55`	`infix operator => : AdditionPrecedence`
`56`	`56`
`57`	`57`	`/// e.g. .state0 => .state1`
`58`		`-public func => <S: StateType>(left: State<S>, right: State<S>) -> Transition<S>`
	`58`	`+public func => <S>(left: State<S>, right: State<S>) -> Transition<S>`
`59`	`59`	`{`
`60`	`60`	`return Transition(fromState: left, toState: right)`
`61`	`61`	`}`
`62`	`62`
`63`		`-public func => <S: StateType>(left: State<S>, right: S) -> Transition<S>`
	`63`	`+public func => <S>(left: State<S>, right: S) -> Transition<S>`
`64`	`64`	`{`
`65`	`65`	`return left => .some(right)`
`66`	`66`	`}`
`67`	`67`
`68`		`-public func => <S: StateType>(left: S, right: State<S>) -> Transition<S>`
	`68`	`+public func => <S>(left: S, right: State<S>) -> Transition<S>`
`69`	`69`	`{`
`70`	`70`	`return .some(left) => right`
`71`	`71`	`}`
`72`	`72`
`73`		`-public func => <S: StateType>(left: S, right: S) -> Transition<S>`
	`73`	`+public func => <S>(left: S, right: S) -> Transition<S>`
`74`	`74`	`{`
`75`	`75`	`return .some(left) => .some(right)`
`76`	`76`	`}`
Original file line number	Diff line number	Diff line change
`@@ -38,43 +38,43 @@ public struct TransitionChain<S: StateType>`
`38`	`38`	`//--------------------------------------------------`
`39`	`39`
`40`	`40`	`// e.g. (.state0 => .state1) => .state`
`41`		`-public func => <S: StateType>(left: Transition<S>, right: State<S>) -> TransitionChain<S>`
	`41`	`+public func => <S>(left: Transition<S>, right: State<S>) -> TransitionChain<S>`
`42`	`42`	`{`
`43`	`43`	`return TransitionChain(states: [left.fromState, left.toState]) => right`
`44`	`44`	`}`
`45`	`45`
`46`		`-public func => <S: StateType>(left: Transition<S>, right: S) -> TransitionChain<S>`
	`46`	`+public func => <S>(left: Transition<S>, right: S) -> TransitionChain<S>`
`47`	`47`	`{`
`48`	`48`	`return left => .some(right)`
`49`	`49`	`}`
`50`	`50`
`51`		`-public func => <S: StateType>(left: TransitionChain<S>, right: State<S>) -> TransitionChain<S>`
	`51`	`+public func => <S>(left: TransitionChain<S>, right: State<S>) -> TransitionChain<S>`
`52`	`52`	`{`
`53`	`53`	`return TransitionChain(states: left.states + [right])`
`54`	`54`	`}`
`55`	`55`
`56`		`-public func => <S: StateType>(left: TransitionChain<S>, right: S) -> TransitionChain<S>`
	`56`	`+public func => <S>(left: TransitionChain<S>, right: S) -> TransitionChain<S>`
`57`	`57`	`{`
`58`	`58`	`return left => .some(right)`
`59`	`59`	`}`
`60`	`60`
`61`	`61`	`// e.g. .state0 => (.state1 => .state)`
`62`		`-public func => <S: StateType>(left: State<S>, right: Transition<S>) -> TransitionChain<S>`
	`62`	`+public func => <S>(left: State<S>, right: Transition<S>) -> TransitionChain<S>`
`63`	`63`	`{`
`64`	`64`	`return left => TransitionChain(states: [right.fromState, right.toState])`
`65`	`65`	`}`
`66`	`66`
`67`		`-public func => <S: StateType>(left: S, right: Transition<S>) -> TransitionChain<S>`
	`67`	`+public func => <S>(left: S, right: Transition<S>) -> TransitionChain<S>`
`68`	`68`	`{`
`69`	`69`	`return .some(left) => right`
`70`	`70`	`}`
`71`	`71`
`72`		`-public func => <S: StateType>(left: State<S>, right: TransitionChain<S>) -> TransitionChain<S>`
	`72`	`+public func => <S>(left: State<S>, right: TransitionChain<S>) -> TransitionChain<S>`
`73`	`73`	`{`
`74`	`74`	`return TransitionChain(states: [left] + right.states)`
`75`	`75`	`}`
`76`	`76`
`77`		`-public func => <S: StateType>(left: S, right: TransitionChain<S>) -> TransitionChain<S>`
	`77`	`+public func => <S>(left: S, right: TransitionChain<S>) -> TransitionChain<S>`
`78`	`78`	`{`
`79`	`79`	`return .some(left) => right`
`80`	`80`	`}`