Remove verbose methods in Transition & Route.

SwiftState/Machine.swift

@@ -471,7 +471,7 @@ public class Machine<S: StateType, E: EventType>
 
     public func addChainHandler(chain: TransitionChain<S>, order: HandlerOrder = _defaultOrder, handler: Handler) -> ChainHandlerID<S, E>
     {
-        return self.addChainHandler(chain.toRouteChain(), order: order, handler: handler)
+        return self.addChainHandler(RouteChain(transitionChain: chain), order: order, handler: handler)
     }
 
     public func addChainHandler(chain: RouteChain<S, E>, order: HandlerOrder = _defaultOrder, handler: Handler) -> ChainHandlerID<S, E>
@@ -483,7 +483,7 @@ public class Machine<S: StateType, E: EventType>
 
     public func addChainErrorHandler(chain: TransitionChain<S>, order: HandlerOrder = _defaultOrder, handler: Handler) -> ChainHandlerID<S, E>
     {
-        return self.addChainErrorHandler(chain.toRouteChain(), order: order, handler: handler)
+        return self.addChainErrorHandler(RouteChain(transitionChain: chain), order: order, handler: handler)
     }
 
     public func addChainErrorHandler(chain: RouteChain<S, E>, order: HandlerOrder = _defaultOrder, handler: Handler) -> ChainHandlerID<S, E>

SwiftState/Route.swift

@@ -16,18 +16,6 @@ public struct Route<S: StateType, E: EventType>
         self.transition = transition
         self.condition = condition
     }
-
-    public func toTransition() -> Transition<S>
-    {
-        return self.transition
-    }
-
-    public func toRouteChain() -> RouteChain<S, E>
-    {
-        var routes: [Route<S, E>] = []
-        routes += [self]
-        return RouteChain(routes: routes)
-    }
 }
 
 //--------------------------------------------------

SwiftState/RouteChain.swift

@@ -8,51 +8,19 @@
 
 public struct RouteChain<S: StateType, E: EventType>
 {
-    internal var routes: [Route<S, E>]
+    public private(set) var routes: [Route<S, E>]
 
     public init(routes: [Route<S, E>])
     {
         self.routes = routes
     }
 
-    public init(transitionChain: TransitionChain<S>, condition: Machine<S, E>.Condition?)
+    public init(transitionChain: TransitionChain<S>, condition: Machine<S, E>.Condition? = nil)
     {
         var routes: [Route<S, E>] = []
         for transition in transitionChain.transitions {
             routes += [Route<S, E>(transition: transition, condition: condition)]
         }
-        self.routes = routes
-    }
-
-    public var numberOfRoutes: Int
-    {
-        return self.routes.count
-    }
-
-    mutating public func prepend(state: State<S>, condition: Machine<S, E>.Condition?)
-    {
-        let firstfromState = self.routes.first!.transition.fromState
-        let newRoute = Route<S, E>(transition: state => firstfromState, condition: condition)
-
-        self.routes.insert(newRoute, atIndex: 0)
-    }
-
-    mutating internal func append(state: State<S>, condition: Machine<S, E>.Condition?)
-    {
-        let lasttoState = self.routes.last!.transition.toState
-        let newRoute = Route<S, E>(transition: lasttoState => state, condition: condition)
-
-        self.routes += [newRoute]
-    }
-
-    public func toTransitionChain() -> TransitionChain<S>
-    {
-        let transitions = self.routes.map { route in route.transition }
-        return TransitionChain(transitions: transitions)
-    }
-
-    public func toRoutes() -> [Route<S, E>]
-    {
-        return self.routes
+        self.init(routes: routes)
     }
 }

SwiftState/Transition.swift

@@ -36,16 +36,6 @@ public struct Transition<S: StateType>: Hashable
     {
         return self.fromState.hashValue &+ self.toState.hashValue.byteSwapped
     }
-
-    public func toTransitionChain() -> TransitionChain<S>
-    {
-        return TransitionChain(transition: self)
-    }
-
-    public func toRoute<E: EventType>() -> Route<S, E>
-    {
-        return Route(transition: self, condition: nil)
-    }
 }
 
 // for Transition Equatable

SwiftState/TransitionChain.swift

@@ -8,25 +8,16 @@
 
 public struct TransitionChain<S: StateType>
 {
-    public var states: [State<S>]
+    public private(set) var states: [State<S>]
 
-    public init(transition: Transition<S>)
+    public init(states: [State<S>])
     {
-        self.init(transitions: [transition])
+        self.states = states
     }
 
-    public init(transitions: [Transition<S>])
+    public init(transition: Transition<S>)
     {
-        assert(transitions.count > 0, "TransitionChain must be initialized with at least 1 transition.")
-
-        var states: [State<S>] = []
-        for i in 0..<transitions.count {
-            if i == 0 {
-                states += [transitions[i].fromState]
-            }
-            states += [transitions[i].toState]
-        }
-        self.states = states
+        self.init(states: [transition.fromState, transition.toState])
     }
 
     public var transitions: [Transition<S>]
@@ -39,51 +30,6 @@ public struct TransitionChain<S: StateType>
 
         return transitions
     }
-
-    public var firstState: State<S>
-    {
-        return self.states.first!
-    }
-
-    public var lastState: State<S>
-    {
-        return self.states.last!
-    }
-
-    public var numberOfTransitions: Int
-    {
-        return self.states.count-1
-    }
-
-    mutating public func prepend(state: State<S>)
-    {
-        self.states.insert(state, atIndex: 0)
-    }
-
-    mutating public func prepend(state: S)
-    {
-        self.states.insert(.Some(state), atIndex: 0)
-    }
-
-    mutating public func append(state: State<S>)
-    {
-        self.states += [state]
-    }
-
-    mutating public func append(state: S)
-    {
-        self.states += [.Some(state)]
-    }
-
-    public func toRouteChain<E: EventType>() -> RouteChain<S, E>
-    {
-        return RouteChain(transitionChain: self, condition: nil)
-    }
-
-    public func toTransitions() -> [Transition<S>]
-    {
-        return self.transitions
-    }
 }
 
 //--------------------------------------------------
@@ -93,18 +39,17 @@ public struct TransitionChain<S: StateType>
 // e.g. (.State0 => .State1) => .State
 public func => <S: StateType>(left: Transition<S>, right: State<S>) -> TransitionChain<S>
 {
-    return left.toTransitionChain() => right
+    return TransitionChain(states: [left.fromState, left.toState]) => right
 }
 
 public func => <S: StateType>(left: Transition<S>, right: S) -> TransitionChain<S>
 {
     return left => .Some(right)
 }
 
-public func => <S: StateType>(var left: TransitionChain<S>, right: State<S>) -> TransitionChain<S>
+public func => <S: StateType>(left: TransitionChain<S>, right: State<S>) -> TransitionChain<S>
 {
-    left.append(right)
-    return left
+    return TransitionChain(states: left.states + [right])
 }
 
 public func => <S: StateType>(left: TransitionChain<S>, right: S) -> TransitionChain<S>
@@ -115,18 +60,17 @@ public func => <S: StateType>(left: TransitionChain<S>, right: S) -> TransitionC
 // e.g. .State0 => (.State1 => .State)
 public func => <S: StateType>(left: State<S>, right:Transition<S>) -> TransitionChain<S>
 {
-    return left => right.toTransitionChain()
+    return left => TransitionChain(states: [right.fromState, right.toState])
 }
 
 public func => <S: StateType>(left: S, right:Transition<S>) -> TransitionChain<S>
 {
     return .Some(left) => right
 }
 
-public func => <S: StateType>(left: State<S>, var right: TransitionChain<S>) -> TransitionChain<S>
+public func => <S: StateType>(left: State<S>, right: TransitionChain<S>) -> TransitionChain<S>
 {
-    right.prepend(left)
-    return right
+    return TransitionChain(states: [left] + right.states)
 }
 
 public func => <S: StateType>(left: S, right: TransitionChain<S>) -> TransitionChain<S>

SwiftStateTests/BasicTests.swift

@@ -66,7 +66,7 @@ class BasicTests: _TestCase
             }
         }
 
-        // tryState 0 => 1 => 2 => 1 => 0   
+        // tryState 0 => 1 => 2 => 1 => 0
 
         machine <- ".State1"
         XCTAssertTrue(machine.state == ".State1")

SwiftStateTests/MachineTests.swift

@@ -280,7 +280,7 @@ class MachineTests: _TestCase
     }
 
     //--------------------------------------------------
-    // MARK: - tryState a.k.a <-
+    // MARK: - tryState a.k.a `<-`
     //--------------------------------------------------
 
     // machine <- state

SwiftStateTests/RouteChainTests.swift

@@ -313,4 +313,5 @@ class MachineChainTests: _TestCase
         machine <- .State2
         XCTAssertEqual(errorCount, 0, "Chain error, but chainErrorHandler should NOT be performed.")
     }
+
 }

SwiftStateTests/TransitionChainTests.swift

@@ -16,68 +16,77 @@ class TransitionChainTests: _TestCase
         // 0 => 1 => 2
         var chain = MyState.State0 => .State1 => .State2
 
-        XCTAssertEqual(chain.numberOfTransitions, 2)
-        XCTAssertEqual(chain.firstState.value, MyState.State0)
-        XCTAssertEqual(chain.lastState.value, MyState.State2)
+        XCTAssertEqual(chain.states.count, 3)
+        XCTAssertTrue(chain.states[0] == .State0)
+        XCTAssertTrue(chain.states[1] == .State1)
+        XCTAssertTrue(chain.states[2] == .State2)
 
         // (1 => 2) => 3
         chain = MyState.State1 => .State2 => .State3
 
-        XCTAssertEqual(chain.numberOfTransitions, 2)
-        XCTAssertEqual(chain.firstState.value, MyState.State1)
-        XCTAssertEqual(chain.lastState.value, MyState.State3)
+        XCTAssertEqual(chain.states.count, 3)
+        XCTAssertTrue(chain.states[0] == .State1)
+        XCTAssertTrue(chain.states[1] == .State2)
+        XCTAssertTrue(chain.states[2] == .State3)
 
         // 2 => (3 => 0)
         chain = MyState.State2 => (.State3 => .State0)
 
-        XCTAssertEqual(chain.numberOfTransitions, 2)
-        XCTAssertEqual(chain.firstState.value, MyState.State2)
-        XCTAssertEqual(chain.lastState.value, MyState.State0)
+        XCTAssertEqual(chain.states.count, 3)
+        XCTAssertTrue(chain.states[0] == .State2)
+        XCTAssertTrue(chain.states[1] == .State3)
+        XCTAssertTrue(chain.states[2] == .State0)
     }
 
     func testAppend()
     {
         // 0 => 1
         let transition = MyState.State0 => .State1
-        var chain = transition.toTransitionChain()
+        var chain = TransitionChain(transition: transition)
 
-        XCTAssertEqual(chain.numberOfTransitions, 1)
-        XCTAssertEqual(chain.firstState.value, MyState.State0)
-        XCTAssertEqual(chain.lastState.value, MyState.State1)
+        XCTAssertEqual(chain.states.count, 2)
+        XCTAssertTrue(chain.states[0] == .State0)
+        XCTAssertTrue(chain.states[1] == .State1)
 
         // 0 => 1 => 2
-        chain = chain => .State2  // same as append
-        XCTAssertEqual(chain.numberOfTransitions, 2)
-        XCTAssertEqual(chain.firstState.value, MyState.State0)
-        XCTAssertEqual(chain.lastState.value, MyState.State2)
+        chain = chain => .State2
+        XCTAssertEqual(chain.states.count, 3)
+        XCTAssertTrue(chain.states[0] == .State0)
+        XCTAssertTrue(chain.states[1] == .State1)
+        XCTAssertTrue(chain.states[2] == .State2)
 
         // 0 => 1 => 2 => 3
-        chain.append(.State3)
-        XCTAssertEqual(chain.numberOfTransitions, 3)
-        XCTAssertEqual(chain.firstState.value, MyState.State0)
-        XCTAssertEqual(chain.lastState.value, MyState.State3)
+        chain = chain => .State3
+        XCTAssertEqual(chain.states.count, 4)
+        XCTAssertTrue(chain.states[0] == .State0)
+        XCTAssertTrue(chain.states[1] == .State1)
+        XCTAssertTrue(chain.states[2] == .State2)
+        XCTAssertTrue(chain.states[3] == .State3)
     }
 
     func testPrepend()
     {
         // 0 => 1
         let transition = MyState.State0 => .State1
-        var chain = transition.toTransitionChain()
+        var chain = TransitionChain(transition: transition)
 
-        XCTAssertEqual(chain.numberOfTransitions, 1)
-        XCTAssertEqual(chain.firstState.value, MyState.State0)
-        XCTAssertEqual(chain.lastState.value, MyState.State1)
+        XCTAssertEqual(chain.states.count, 2)
+        XCTAssertTrue(chain.states[0] == .State0)
+        XCTAssertTrue(chain.states[1] == .State1)
 
         // 2 => 0 => 1
         chain = .State2 => chain  // same as prepend
-        XCTAssertEqual(chain.numberOfTransitions, 2)
-        XCTAssertEqual(chain.firstState.value, MyState.State2)
-        XCTAssertEqual(chain.lastState.value, MyState.State1)
+        XCTAssertEqual(chain.states.count, 3)
+        XCTAssertTrue(chain.states[0] == .State2)
+        XCTAssertTrue(chain.states[1] == .State0)
+        XCTAssertTrue(chain.states[2] == .State1)
 
         // 3 => 2 => 0 => 1
-        chain.prepend(.State3)
-        XCTAssertEqual(chain.numberOfTransitions, 3)
-        XCTAssertEqual(chain.firstState.value, MyState.State3)
-        XCTAssertEqual(chain.lastState.value, MyState.State1)
+        chain = .State3 => chain
+        XCTAssertEqual(chain.states.count, 4)
+        XCTAssertTrue(chain.states[0] == .State3)
+        XCTAssertTrue(chain.states[1] == .State2)
+        XCTAssertTrue(chain.states[2] == .State0)
+        XCTAssertTrue(chain.states[3] == .State1)
     }
 }