Automatic Swift 2.0 conversion

adamyanalunas · adamyanalunas · commit 2a17aed3c90c · 2015-06-11T10:57:34.000-07:00
diff --git a/SwiftState.xcodeproj/project.pbxproj b/SwiftState.xcodeproj/project.pbxproj
@@ -323,6 +323,7 @@
 		1FA61FF71996601000460108 /* Project object */ = {
 			isa = PBXProject;
 			attributes = {
+				LastSwiftUpdateCheck = 0700;
 				LastUpgradeCheck = 0600;
 				ORGANIZATIONNAME = "Yasuhiro Inami";
 				TargetAttributes = {
diff --git a/SwiftState/HierarchicalStateMachine.swift b/SwiftState/HierarchicalStateMachine.swift
@@ -24,7 +24,7 @@ public typealias HSM = HierarchicalStateMachine<String, String>
 //
 
 /// nestable StateMachine with StateType as String
-public class HierarchicalStateMachine<S: StateType, E: StateEventType>: StateMachine<S, E>, Printable
+public class HierarchicalStateMachine<S: StateType, E: StateEventType>: StateMachine<S, E>, CustomStringConvertible
 {
     private var _submachines = [String : HSM]()
     
@@ -61,7 +61,7 @@ public class HierarchicalStateMachine<S: StateType, E: StateEventType>: StateMac
     {
         assert(state is HSM.State, "HSM state must be String.")
         
-        let components = split(state as! HSM.State, maxSplit: 1) { $0 == "." }
+        let components = split((state as! HSM.State).characters, maxSplit: 1) { $0 == "." }.map { String($0) }
         
         switch components.count {
             case 2:
diff --git a/SwiftState/StateMachine.swift b/SwiftState/StateMachine.swift
@@ -268,7 +268,7 @@ public class StateMachine<S: StateType, E: StateEventType>
             }
         }
         
-        validHandlerInfos.sort { info1, info2 in
+        validHandlerInfos.sortInPlace { info1, info2 in
             return info1.order < info2.order
         }
         
@@ -504,7 +504,7 @@ public class StateMachine<S: StateType, E: StateEventType>
     {
         var index = handlerInfos.count
         
-        for i in Array(0..<handlerInfos.count).reverse() {
+        for i in Array(Array(0..<handlerInfos.count).reverse()) {
             if handlerInfos[i].order <= newHandlerInfo.order {
                 break
             }
@@ -601,7 +601,7 @@ public class StateMachine<S: StateType, E: StateEventType>
         return self.addErrorHandler(order: self.dynamicType._defaultOrder, handler: handler)
     }
     
-    public func addErrorHandler(#order: HandlerOrder, handler: Handler) -> HandlerID
+    public func addErrorHandler(order order: HandlerOrder, handler: Handler) -> HandlerID
     {
         let handlerKey = self.dynamicType._createUniqueString()
         
diff --git a/SwiftState/StateRoute.swift b/SwiftState/StateRoute.swift
@@ -49,22 +49,22 @@ public func => <S: StateType>(leftStates: [S], right: S) -> StateRoute<S>
 {
     // NOTE: don't reuse "nil => nil + condition" for efficiency
     return StateRoute(transition: nil => right, condition: { transition -> Bool in
-        return contains(leftStates, transition.fromState)
+        return leftStates.contains(transition.fromState)
     })
 }
 
 /// e.g. .State0 => [.State1, .State2], allowing [0 => 1, 0 => 2]
 public func => <S: StateType>(left: S, rightStates: [S]) -> StateRoute<S>
 {
     return StateRoute(transition: left => nil, condition: { transition -> Bool in
-        return contains(rightStates, transition.toState)
+        return rightStates.contains(transition.toState)
     })
 }
 
 /// e.g. [.State0, .State1] => [.State2, .State3], allowing [0 => 2, 0 => 3, 1 => 2, 1 => 3]
 public func => <S: StateType>(leftStates: [S], rightStates: [S]) -> StateRoute<S>
 {
     return StateRoute(transition: nil => nil, condition: { transition -> Bool in
-        return contains(leftStates, transition.fromState) && contains(rightStates, transition.toState)
+        return leftStates.contains(transition.fromState) && rightStates.contains(transition.toState)
     })
 }
diff --git a/SwiftState/StateTransition.swift b/SwiftState/StateTransition.swift
@@ -58,7 +58,7 @@ public func => <S: StateType>(left: S, right: S) -> StateTransition<S>
 // MARK: - Printable
 //--------------------------------------------------
 
-extension StateTransition: Printable
+extension StateTransition: CustomStringConvertible
 {
     public var description: String
     {
diff --git a/SwiftStateTests/BasicTests.swift b/SwiftStateTests/BasicTests.swift
@@ -16,17 +16,17 @@ class BasicTests: _TestCase
         let machine = StateMachine<MyState, MyEvent>(state: .State0) { machine in
             
             machine.addRoute(.State0 => .State1)
-            machine.addRoute(nil => .State2) { context in println("Any => 2, msg=\(context.userInfo!)") }
-            machine.addRoute(.State2 => nil) { context in println("2 => Any, msg=\(context.userInfo!)") }
+            machine.addRoute(nil => .State2) { context in print("Any => 2, msg=\(context.userInfo!)") }
+            machine.addRoute(.State2 => nil) { context in print("2 => Any, msg=\(context.userInfo!)") }
             
             // add handler (handlerContext = (event, transition, order, userInfo))
             machine.addHandler(.State0 => .State1) { context in
-                println("0 => 1")
+                print("0 => 1")
             }
             
             // add errorHandler
             machine.addErrorHandler { (event, transition, order, userInfo) in
-                println("[ERROR] \(transition.fromState) => \(transition.toState)")
+                print("[ERROR] \(transition.fromState) => \(transition.toState)")
             }
         }
         
@@ -36,7 +36,7 @@ class BasicTests: _TestCase
         machine <- (.State1, "Bye")
         machine <- .State0  // fail: no 1 => 0
         
-        println("machine.state = \(machine.state)")
+        print("machine.state = \(machine.state)")
     }
     
     func testExample()
@@ -45,19 +45,19 @@ class BasicTests: _TestCase
         
             // add 0 => 1
             $0.addRoute(.State0 => .State1) { context in
-                println("[Transition 0=>1] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue)")
+                print("[Transition 0=>1] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue)")
             }
             // add 0 => 1 once more
             $0.addRoute(.State0 => .State1) { context in
-                println("[Transition 0=>1b] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue)")
+                print("[Transition 0=>1b] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue)")
             }
             // add 2 => Any
             $0.addRoute(.State2 => nil) { context in
-                println("[Transition exit 2] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue) (Any)")
+                print("[Transition exit 2] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue) (Any)")
             }
             // add Any => 2
             $0.addRoute(nil => .State2) { context in
-                println("[Transition Entry 2] \(context.transition.fromState.rawValue) (Any) => \(context.transition.toState.rawValue)")
+                print("[Transition Entry 2] \(context.transition.fromState.rawValue) (Any) => \(context.transition.toState.rawValue)")
             }
             // add 1 => 0 (no handler)
             $0.addRoute(.State1 => .State0)
@@ -94,35 +94,35 @@ class BasicTests: _TestCase
             
             // error
             $0.addErrorHandler { context in
-                println("[ERROR 1] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue)")
+                print("[ERROR 1] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue)")
             }
             
             // entry
             $0.addEntryHandler(.State0) { context in
-                println("[Entry 0] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue)")   // NOTE: this should not be called
+                print("[Entry 0] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue)")   // NOTE: this should not be called
             }
             $0.addEntryHandler(.State1) { context in
-                println("[Entry 1] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue)")
+                print("[Entry 1] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue)")
             }
             $0.addEntryHandler(.State2) { context in
-                println("[Entry 2] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue), userInfo = \(context.userInfo)")
+                print("[Entry 2] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue), userInfo = \(context.userInfo)")
             }
             $0.addEntryHandler(.State2) { context in
-                println("[Entry 2b] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue), userInfo = \(context.userInfo)")
+                print("[Entry 2b] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue), userInfo = \(context.userInfo)")
             }
             
             // exit
             $0.addExitHandler(.State0) { context in
-                println("[Exit 0] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue)")
+                print("[Exit 0] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue)")
             }
             $0.addExitHandler(.State1) { context in
-                println("[Exit 1] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue)")
+                print("[Exit 1] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue)")
             }
             $0.addExitHandler(.State2) { context in
-                println("[Exit 2] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue), userInfo = \(context.userInfo)")
+                print("[Exit 2] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue), userInfo = \(context.userInfo)")
             }
             $0.addExitHandler(.State2) { context in
-                println("[Exit 2b] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue), userInfo = \(context.userInfo)")
+                print("[Exit 2b] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue), userInfo = \(context.userInfo)")
             }
         }
         
diff --git a/SwiftStateTests/HierarchicalStateMachineTests.swift b/SwiftStateTests/HierarchicalStateMachineTests.swift
@@ -51,12 +51,12 @@ class HierarchicalStateMachineTests: _TestCase
         mainMachine.addRoute("MainState0" => "Sub1.State1")
         
         // add logging handlers
-        sub1Machine.addHandler(nil => nil) { println("[Sub1] \($0.transition)") }
-        sub1Machine.addErrorHandler { println("[ERROR][Sub1] \($0.transition)") }
-        sub2Machine.addHandler(nil => nil) { println("[Sub2] \($0.transition)") }
-        sub2Machine.addErrorHandler { println("[ERROR][Sub2] \($0.transition)") }
-        mainMachine.addHandler(nil => nil) { println("[Main] \($0.transition)") }
-        mainMachine.addErrorHandler { println("[ERROR][Main] \($0.transition)") }
+        sub1Machine.addHandler(nil => nil) { print("[Sub1] \($0.transition)") }
+        sub1Machine.addErrorHandler { print("[ERROR][Sub1] \($0.transition)") }
+        sub2Machine.addHandler(nil => nil) { print("[Sub2] \($0.transition)") }
+        sub2Machine.addErrorHandler { print("[ERROR][Sub2] \($0.transition)") }
+        mainMachine.addHandler(nil => nil) { print("[Main] \($0.transition)") }
+        mainMachine.addErrorHandler { print("[ERROR][Main] \($0.transition)") }
         
         self.mainMachine = mainMachine
         self.sub1Machine = sub1Machine
@@ -166,7 +166,7 @@ class HierarchicalStateMachineTests: _TestCase
         
         // NOTE: this handler is added to mainMachine and doesn't make submachines dirty
         mainMachine.addHandler("Sub1.State1" => "Sub1.State2") { context in
-            println("[Main] 1-1 => 1-2 (specific)")
+            print("[Main] 1-1 => 1-2 (specific)")
             didPass = true
         }
         
diff --git a/SwiftStateTests/MyState.swift b/SwiftStateTests/MyState.swift
@@ -8,7 +8,7 @@
 
 import SwiftState
 
-enum MyState: Int, StateType, Printable
+enum MyState: Int, StateType, CustomStringConvertible
 {
     case State0, State1, State2, State3
     case AnyState   // IMPORTANT: create case=Any & use it in convertFromNilLiteral()
diff --git a/SwiftStateTests/_TestCase.swift b/SwiftStateTests/_TestCase.swift
@@ -14,12 +14,12 @@ class _TestCase: XCTestCase
     override func setUp()
     {
         super.setUp()
-        println("\n\n\n")
+        print("\n\n\n")
     }
     
     override func tearDown()
     {
-        println("\n\n\n")
+        print("\n\n\n")
         super.tearDown()
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ public typealias HSM = HierarchicalStateMachine<String, String>`
`24`	`24`	`//`
`25`	`25`
`26`	`26`	`/// nestable StateMachine with StateType as String`
`27`		`-public class HierarchicalStateMachine<S: StateType, E: StateEventType>: StateMachine<S, E>, Printable`
	`27`	`+public class HierarchicalStateMachine<S: StateType, E: StateEventType>: StateMachine<S, E>, CustomStringConvertible`
`28`	`28`	`{`
`29`	`29`	`private var _submachines = [String : HSM]()`
`30`	`30`
`@@ -61,7 +61,7 @@ public class HierarchicalStateMachine<S: StateType, E: StateEventType>: StateMac`
`61`	`61`	`{`
`62`	`62`	`assert(state is HSM.State, "HSM state must be String.")`
`63`	`63`
`64`		`- let components = split(state as! HSM.State, maxSplit: 1) { $0 == "." }`
	`64`	`+ let components = split((state as! HSM.State).characters, maxSplit: 1) { $0 == "." }.map { String($0) }`
`65`	`65`
`66`	`66`	`switch components.count {`
`67`	`67`	`case 2:`
Original file line number	Diff line number	Diff line change
`@@ -268,7 +268,7 @@ public class StateMachine<S: StateType, E: StateEventType>`
`268`	`268`	`}`
`269`	`269`	`}`
`270`	`270`
`271`		`- validHandlerInfos.sort { info1, info2 in`
	`271`	`+ validHandlerInfos.sortInPlace { info1, info2 in`
`272`	`272`	`return info1.order < info2.order`
`273`	`273`	`}`
`274`	`274`
`@@ -504,7 +504,7 @@ public class StateMachine<S: StateType, E: StateEventType>`
`504`	`504`	`{`
`505`	`505`	`var index = handlerInfos.count`
`506`	`506`
`507`		`- for i in Array(0..<handlerInfos.count).reverse() {`
	`507`	`+ for i in Array(Array(0..<handlerInfos.count).reverse()) {`
`508`	`508`	`if handlerInfos[i].order <= newHandlerInfo.order {`
`509`	`509`	`break`
`510`	`510`	`}`
`@@ -601,7 +601,7 @@ public class StateMachine<S: StateType, E: StateEventType>`
`601`	`601`	`return self.addErrorHandler(order: self.dynamicType._defaultOrder, handler: handler)`
`602`	`602`	`}`
`603`	`603`
`604`		`- public func addErrorHandler(#order: HandlerOrder, handler: Handler) -> HandlerID`
	`604`	`+ public func addErrorHandler(order order: HandlerOrder, handler: Handler) -> HandlerID`
`605`	`605`	`{`
`606`	`606`	`let handlerKey = self.dynamicType._createUniqueString()`
`607`	`607`
Original file line number	Diff line number	Diff line change
`@@ -49,22 +49,22 @@ public func => <S: StateType>(leftStates: [S], right: S) -> StateRoute<S>`
`49`	`49`	`{`
`50`	`50`	`// NOTE: don't reuse "nil => nil + condition" for efficiency`
`51`	`51`	`return StateRoute(transition: nil => right, condition: { transition -> Bool in`
`52`		`- return contains(leftStates, transition.fromState)`
	`52`	`+ return leftStates.contains(transition.fromState)`
`53`	`53`	`})`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`/// e.g. .State0 => [.State1, .State2], allowing [0 => 1, 0 => 2]`
`57`	`57`	`public func => <S: StateType>(left: S, rightStates: [S]) -> StateRoute<S>`
`58`	`58`	`{`
`59`	`59`	`return StateRoute(transition: left => nil, condition: { transition -> Bool in`
`60`		`- return contains(rightStates, transition.toState)`
	`60`	`+ return rightStates.contains(transition.toState)`
`61`	`61`	`})`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`/// e.g. [.State0, .State1] => [.State2, .State3], allowing [0 => 2, 0 => 3, 1 => 2, 1 => 3]`
`65`	`65`	`public func => <S: StateType>(leftStates: [S], rightStates: [S]) -> StateRoute<S>`
`66`	`66`	`{`
`67`	`67`	`return StateRoute(transition: nil => nil, condition: { transition -> Bool in`
`68`		`- return contains(leftStates, transition.fromState) && contains(rightStates, transition.toState)`
	`68`	`+ return leftStates.contains(transition.fromState) && rightStates.contains(transition.toState)`
`69`	`69`	`})`
`70`	`70`	`}`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ public func => <S: StateType>(left: S, right: S) -> StateTransition<S>`
`58`	`58`	`// MARK: - Printable`
`59`	`59`	`//--------------------------------------------------`
`60`	`60`
`61`		`-extension StateTransition: Printable`
	`61`	`+extension StateTransition: CustomStringConvertible`
`62`	`62`	`{`
`63`	`63`	`public var description: String`
`64`	`64`	`{`
Original file line number	Diff line number	Diff line change
`@@ -16,17 +16,17 @@ class BasicTests: _TestCase`
`16`	`16`	`let machine = StateMachine<MyState, MyEvent>(state: .State0) { machine in`
`17`	`17`
`18`	`18`	`machine.addRoute(.State0 => .State1)`
`19`		`- machine.addRoute(nil => .State2) { context in println("Any => 2, msg=\(context.userInfo!)") }`
`20`		`- machine.addRoute(.State2 => nil) { context in println("2 => Any, msg=\(context.userInfo!)") }`
	`19`	`+ machine.addRoute(nil => .State2) { context in print("Any => 2, msg=\(context.userInfo!)") }`
	`20`	`+ machine.addRoute(.State2 => nil) { context in print("2 => Any, msg=\(context.userInfo!)") }`
`21`	`21`
`22`	`22`	`// add handler (handlerContext = (event, transition, order, userInfo))`
`23`	`23`	`machine.addHandler(.State0 => .State1) { context in`
`24`		`- println("0 => 1")`
	`24`	`+ print("0 => 1")`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`// add errorHandler`
`28`	`28`	`machine.addErrorHandler { (event, transition, order, userInfo) in`
`29`		`- println("[ERROR] \(transition.fromState) => \(transition.toState)")`
	`29`	`+ print("[ERROR] \(transition.fromState) => \(transition.toState)")`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`
`@@ -36,7 +36,7 @@ class BasicTests: _TestCase`
`36`	`36`	`machine <- (.State1, "Bye")`
`37`	`37`	`machine <- .State0 // fail: no 1 => 0`
`38`	`38`
`39`		`- println("machine.state = \(machine.state)")`
	`39`	`+ print("machine.state = \(machine.state)")`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`func testExample()`
`@@ -45,19 +45,19 @@ class BasicTests: _TestCase`
`45`	`45`
`46`	`46`	`// add 0 => 1`
`47`	`47`	`$0.addRoute(.State0 => .State1) { context in`
`48`		`- println("[Transition 0=>1] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue)")`
	`48`	`+ print("[Transition 0=>1] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue)")`
`49`	`49`	`}`
`50`	`50`	`// add 0 => 1 once more`
`51`	`51`	`$0.addRoute(.State0 => .State1) { context in`
`52`		`- println("[Transition 0=>1b] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue)")`
	`52`	`+ print("[Transition 0=>1b] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue)")`
`53`	`53`	`}`
`54`	`54`	`// add 2 => Any`
`55`	`55`	`$0.addRoute(.State2 => nil) { context in`
`56`		`- println("[Transition exit 2] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue) (Any)")`
	`56`	`+ print("[Transition exit 2] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue) (Any)")`
`57`	`57`	`}`
`58`	`58`	`// add Any => 2`
`59`	`59`	`$0.addRoute(nil => .State2) { context in`
`60`		`- println("[Transition Entry 2] \(context.transition.fromState.rawValue) (Any) => \(context.transition.toState.rawValue)")`
	`60`	`+ print("[Transition Entry 2] \(context.transition.fromState.rawValue) (Any) => \(context.transition.toState.rawValue)")`
`61`	`61`	`}`
`62`	`62`	`// add 1 => 0 (no handler)`
`63`	`63`	`$0.addRoute(.State1 => .State0)`
`@@ -94,35 +94,35 @@ class BasicTests: _TestCase`
`94`	`94`
`95`	`95`	`// error`
`96`	`96`	`$0.addErrorHandler { context in`
`97`		`- println("[ERROR 1] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue)")`
	`97`	`+ print("[ERROR 1] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue)")`
`98`	`98`	`}`
`99`	`99`
`100`	`100`	`// entry`
`101`	`101`	`$0.addEntryHandler(.State0) { context in`
`102`		`- println("[Entry 0] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue)") // NOTE: this should not be called`
	`102`	`+ print("[Entry 0] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue)") // NOTE: this should not be called`
`103`	`103`	`}`
`104`	`104`	`$0.addEntryHandler(.State1) { context in`
`105`		`- println("[Entry 1] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue)")`
	`105`	`+ print("[Entry 1] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue)")`
`106`	`106`	`}`
`107`	`107`	`$0.addEntryHandler(.State2) { context in`
`108`		`- println("[Entry 2] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue), userInfo = \(context.userInfo)")`
	`108`	`+ print("[Entry 2] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue), userInfo = \(context.userInfo)")`
`109`	`109`	`}`
`110`	`110`	`$0.addEntryHandler(.State2) { context in`
`111`		`- println("[Entry 2b] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue), userInfo = \(context.userInfo)")`
	`111`	`+ print("[Entry 2b] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue), userInfo = \(context.userInfo)")`
`112`	`112`	`}`
`113`	`113`
`114`	`114`	`// exit`
`115`	`115`	`$0.addExitHandler(.State0) { context in`
`116`		`- println("[Exit 0] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue)")`
	`116`	`+ print("[Exit 0] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue)")`
`117`	`117`	`}`
`118`	`118`	`$0.addExitHandler(.State1) { context in`
`119`		`- println("[Exit 1] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue)")`
	`119`	`+ print("[Exit 1] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue)")`
`120`	`120`	`}`
`121`	`121`	`$0.addExitHandler(.State2) { context in`
`122`		`- println("[Exit 2] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue), userInfo = \(context.userInfo)")`
	`122`	`+ print("[Exit 2] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue), userInfo = \(context.userInfo)")`
`123`	`123`	`}`
`124`	`124`	`$0.addExitHandler(.State2) { context in`
`125`		`- println("[Exit 2b] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue), userInfo = \(context.userInfo)")`
	`125`	`+ print("[Exit 2b] \(context.transition.fromState.rawValue) => \(context.transition.toState.rawValue), userInfo = \(context.userInfo)")`
`126`	`126`	`}`
`127`	`127`	`}`
`128`	`128`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@`
`8`	`8`
`9`	`9`	`import SwiftState`
`10`	`10`
`11`		`-enum MyState: Int, StateType, Printable`
	`11`	`+enum MyState: Int, StateType, CustomStringConvertible`
`12`	`12`	`{`
`13`	`13`	`case State0, State1, State2, State3`
`14`	`14`	`case AnyState // IMPORTANT: create case=Any & use it in convertFromNilLiteral()`
Original file line number	Diff line number	Diff line change
`@@ -14,12 +14,12 @@ class _TestCase: XCTestCase`
`14`	`14`	`override func setUp()`
`15`	`15`	`{`
`16`	`16`	`super.setUp()`
`17`		`- println("\n\n\n")`
	`17`	`+ print("\n\n\n")`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`override func tearDown()`
`21`	`21`	`{`
`22`		`- println("\n\n\n")`
	`22`	`+ print("\n\n\n")`
`23`	`23`	`super.tearDown()`
`24`	`24`	`}`
`25`	`25`	`}`