Introduction

In Part 2, we were half way done with our SwiftUI implementation of the Horse Race game. Let’s finish it up in this last part. This is how the UI looked on the old BASIC computer.

1. Choosing Horse

We ended the previous part where we were showing the odds on horses. Next we show the prompt to the player to choose one of these horses.

extension FX790...
    private func promptChooseHorse(for player: Player) -> Int {
        while true {
            let choice: Int = INPUT("P \(player.id)->")
            if (0...4).contains(choice) {
                return choice
            }
        }
    }

The new state is –

enum GameState...
    case chooseHorse(Player)

The displayText is –

class HorseRaceViewModel...
   var displayText...
       case .chooseHorse(let p): 
          "P \(p.id)→ \(horses.map(\.oddsLabel).joined(separator: " "))"
       }
   }

And moving to this state is –

class HorseRaceViewModel...
    private func moveToNextState...
        case .displayOdds(let player):
            state = .chooseHorse(player)

This shows –

I did not make this an actual prompt with the blinking cursor, because we will just need the user to press a number from 0-5 and that will move to the next screen, without needing to press the RETURN key.

2. Capturing User Input

We need to capture the key press of 0-5 from the user. This is what we had from old game.

let choice = promptChooseHorse(for: player)
if choice == 0 { continue }  // 0 means pass
player.choose(horse: horses[choice - 1])

First we need to capture user input without the RETURN key press. For this we will modify the handleUserInput method.

class HorseRaceViewModel...
    private func handleUserInput(_ char: Character) {
        switch state {
        case .promptNumPlayers:
            userInput.append(char)
        case .chooseHorse:
            userInput.append(char)
            moveToNextState()
        default: return
        }
    }

In the previous promptNumPlayers state we were waiting for user to press the RETURN before processing their input. In chooseHorse state we do moveToNextState after one key press.

class HorseRaceViewModel...
    private func moveToNextState...
        case .chooseHorse(let player):
            if chooseHorse(player) {
                state = ... // next state
            }
        }
    }

    private func chooseHorse(_ player: Player) -> Bool {
       guard let choice = Int(readInput()) else { return false }
       guard choice >= 0 && choice <= horses.count else { return false }
       if choice == 0 { return true }  // 0 means pass
       player.choose(horse: horses[choice - 1])
       return true
    }

3. Placing Bet

After choosing a horse, the game immediately takes the user to place a bet.

extension FX790...
    private func promptBetMoney(for player: Player) -> Int {
        BEEP()
        PRINT()
        while true {
            let bet: Int = 
INPUT("PLAYER \(player.id) \(player.chosenHorse!.symbol) MONEY ")
            if bet >= 0 && bet <= player.money {
                return bet
            }
        }
    }

Let’s create the new prompt state.

enum GameState...
    case promptBetMoney(Player)
    
    var isPrompt: Bool {
        switch self {
        case .promptNumPlayers: return true
        case .promptBetMoney: return true
        default : return false
        }
    }
}

The displayText and moving to this state becomes –

class HorseRaceViewModel...
    var displayText...
        case .promptBetMoney(let p): 
           "PLAYER \(p.id) \(p.chosenHorse!.symbol) MONEY? \(userInput)"
        }
    }

    private func moveToNextState...
        case .chooseHorse(let player):
            if chooseHorse(player) {
                state = .promptBetMoney(player)
            }

This returns in below screen where it shows the chosen horse and user can input money.

To process the bet, we need to add a new betMoney method.

class HorseRaceViewModel...
    private func betMoney(_ player: Player) -> Bool {
        guard let betAmount = Int(readInput()) else { return false }
        return player.placeBet(betAmount)
    }

class Player...
    func placeBet(_ bet: Int) -> Bool {
        guard bet >= 0 && bet <= money else { return false }
        self.bet = bet
        self.money -= bet
        return true
    }

Now we can handle the moveToNextState.

class HorseRaceViewModel...
    private func moveToNextState...
        case .promptBetMoney(let player):
            if betMoney(player) {
                state = players.next(after: player)
                    .map { .displayPlayerHoldings($0) }
                    .orElse(...) // Go to race start
            }
        }

Notice that after a player has placed a bed, we need to move to the next player, and take them back to the displayPlayerHoldings. If no players remain, then we go to race start.

4. Display Race Start

All the bets have been placed. Lets start the race.

extension FX790...
    private func displayRaceStart() {
        PRINT()
        PRINT(" < START! >")
        for _ in 1...10 {
            BEEP()
        }
        PRINT()
    }

This is a simple display only screen.

enum GameState...
    case displayRaceStart

class HorseRaceViewModel...
    var displayText...
        case .displayRaceStart: " < START! >"

    private func moveToNextState...
        case .promptBetMoney(let player):
            if betMoney(player) {
                state = players.next(after: player)
                    .map { .displayPlayerHoldings($0) }
                    .orElse(.displayRaceStart) 
            }
        }

Just 3 lines of code change, and the display is done.

5. The Actual Race!

Finally we have come to the most exciting part of game, where the race will actually take place. I am hoping we will get to do some animation here. Here’s the old implementation -

extension FX790...
    private func race...
        repeat {
            for horse in horses {
                if horses.hasNoWinner {
                    clearHorsePosition(horse)
                    horse.move()
                }
                displayHorsePosition(horse)
            }
        } while horses.hasNoWinner

    private func clearHorsePosition(_ horse: Horse) {
        PRINT(csr: Int(horse.position), " ")
    }

    private func displayHorsePosition(_ horse: Horse) {
        PRINT(csr: horse.position, "\(horse.symbol)")
    }

This code is running a little race loop. It keeps repeating as long as no horse has reached the finish line. For each horse, it first checks again if the race still has no winner, and if so, it clears the horse’s old spot and moves it forward. It then shows the horse’s position on the track. Once a winner is found the loop ends.

Lets create a new state.

enum GameState {
    case race(Horse)

We have a Horse as an associated value, since I want to move one horse at a time. So the state race(Horse) will be for that particular horse movement.

Next, we need to display the horses position in this view.

class HorseRaceViewModel...
    var raceTrackString: String = ""
    var displayText...
        case .race: "\(raceTrackString)"

This creates a string raceTrackString, which will show each horses position. As the horses move, their positions will change, and we will redraw that string. The view is observing the HorseRaceViewModel, and every time this string raceTrackString updates, the view will be updated. That will give the illusion of them moving right in the string.

Now we implement the horse movement.

class HorseRaceViewModel...
    private func moveToNextState...
        case .displayRaceStart: 
            state = .race(horses[0])
        case .race(let horse):
            if horses.hasNoWinner {
                moveHorse(horse)
                state = .race(horses.next(after: horse))
            } else {
                state = ... // go to race end state
            }
        }

    private func moveHorse(_ horse: Horse) {
        guard horses.hasNoWinner else { return }
        horse.move()
        redrawRaceTrack()
    }
    
    private func redrawRaceTrack() {
        var track = 
            [String](repeating: " ", count: GameConfig.goalPosition + 1)
        horses.forEach { track[$0.position] = $0.symbol }
        raceTrackString = track.joined()
    }

On every RETURN key press, the moveHorse() method will be called for each horse in turn. And it will remain in the race state, until a winner is reached. I created a helper next(:Horse) method, that will loop around picking one horse at a time.

extension Array where Element == Horse...    
    func next(after horse: Horse) -> Horse {
        let index = firstIndex(where: { $0.id == horse.id })!
        let nextIndex = (index + 1) % count
        return self[nextIndex]
    }
}

This is how it looks –

6. Auto Horse Movement

We obviously don’t want to be pressing RETURN to move the horses. Lets implement a ticker that will move the horse automatically. I implemented that in the HorseRaceView.

 struct HorseRaceView...
    let timer = Timer.publish(every: 0.1, on: .main, in: .common).autoconnect()
    
    var body: some View...
        ...
        .onReceive(timer) { _ in
            viewModel.handleTick()
        }
        .animation(.easeInOut(duration: 0.1), 
                   value: viewModel.raceTrackString)
    
class HorseRaceViewModel...
    func handleTick() {
        switch state {
        case .race: moveToNextState()
        default: return
        }
    }

The handleTick() method is called every 0.1 seconds, and it moves the horse. I also added a little animation property to show smoother transition.

7. Display Goal

When the race ends, the UI displays “GOAL!”. This is the old code.

extension FX790...
    private func displayGoal() {
        PRINT(csr: 0, "GOAL!")
        for _ in 1...7 {
            BEEP()
            BEEP(1)
        }
        TIMER()
    }

Lets create a new state and move there when the race ends.

enum GameState...
    case displayGoal

class HorseRaceViewModel...
    var displayText...
        case .displayGoal: 
            "\(raceTrackString.replaceFirst(with: "GOAL!"))"

    private func moveToNextState...
        case .race(let horse):
            if horses.hasNoWinner {
                moveHorse(horse)
                state = .race(horses.next(after: horse))
            } else {
                state = .displayGoal
            }

I created a helper String extension replaceFirst.

extension String {
    func replaceFirst(with replacement: String) -> String {
        let cutIndex = index(startIndex, offsetBy: replacement.count)
        return replacement + self[cutIndex...]
    }
}

And now it displays –

8. Winners Collect Prize

Next we distribute prizes to all the winner. This is from old code.

extension FX790...
    private func race...
        for player in players {
            if player.madeAnyBet() {
                let M = player.collectPrize(if: horses.winningHorse!)
                displayPlayerPrize(player, prize: M)
            }
            displayPlayerHoldings(player)
        }

This code intermingles the collecting prize and displaying total money. I will break it up into 2 states –

enum GameState...
    case displayPrize(Player, Int)
    case displayTotal(Player)

class HorseRaceViewModel...
    var displayText...
        case .displayPrize(let p, let prize): 
             "Player \(p.id) → PRIZE $\(prize)"
        case .displayTotal(let p): "Player \(p.id) has $\(p.money)"

Next we loop though each player, collecting prizes, and displaying total.

class HorseRaceViewModel...
  private func moveToNextState...
        case .displayGoal:
            if let player = players.first() {
                state = player.madeAnyBet
                    ? .displayPrize(player, collectPrize(player))
                    : .displayTotal(player)
            }
        case .displayPrize(let player, _):
            state = .displayTotal(player)
        case .displayTotal(let player):
            if let nextPlayer = players.next(after: player) {
                state = next.madeAnyBet
                    ? .displayPrize(next, collectPrize(next))
                    : .displayTotal(next)
            } else { // next }

    private func collectPrize(_ player: Player) {
        player.collectPrize(if: horses.winningHorse!)
    }

This will display the following -

And the total is –

9. Replay

The next screen is prompt to ask player if they want to replay.

extension FX790...
    private func promptReplay() -> Bool {
        PRINT()
        BEEP()
        while true {
            let ans: String = INPUT("REPLAY (Y/N)?")
            if ans == "Y" { return true }
            if ans == "N" { return false }
        }
    } 

Lets create a prompt state.

enum GameState...
    case chooseReplay

class HorseRaceViewModel...
    var displayText...
        case .chooseReplay: "Replay (Y/N)?"

This is like when choosing a horse, there is no blinking cursor, and a single key press moves to next state.

class HorseRaceViewModel...
    private func handleUserInput...
        case .chooseHorse, .chooseReplay:
            userInput.append(char)
            moveToNextState()

    private func moveToNextState...
        case .displayTotal(let player):
            if let next = players.next(after: player) {
                state = next.madeAnyBet
                    ? .displayPrize(next, collectPrize(next))
                    : .displayTotal(next)
            } else {
                state = .chooseReplay
            }

Now we implement the processing of the replay –

class HorseRaceViewModel...
    private func moveToNextState...
        case .promptReplay:
            if let replay = replay() {
                if replay {
                    state = .displayRaceNumber  // New Race
                } 
            }

    private func replay() -> Bool? {
        let response = readInput().uppercased()
        if response == "Y" {
            raceNumber += 1
            return true
        }
        if response == "N" {
            return false
        }
        return nil
    }

This will show the replay prompt –

And if the user pressed “y” it will increment the race number and restart the race with new odds.

10. Game Over

There are two ways a game can be over. If all players have $0 remaining or user presses “n” on the replay prompt.

extension FX790...
    private func race...
        if players.remaining > 0, promptReplay() {
            race(num: R+1, horses: horses, players: players)
        } else {
            displayGameOver()
        }

    private func displayGameOver() {
        PRINT()
        PRINT("GAME OVER")
    }

So our final state is going to be –

enum GameState...
    case displayGameOver

class HorseRaceViewModel...
    var displayText...
        case .displayGameOver: "GAME OVER"

And moveToNextState() becomes –

class HorseRaceViewModel...
    private func moveToNextState
        case .displayTotal(let player):
            if let next = players.next(after: player) {
                state = next.madeAnyBet
                    ? .displayPrize(next, collectPrize(next))
                    : .displayTotal(next)
            } else {
                state = players.remaining 
                    ? .promptReplay 
                    : .displayGameOver
            }
        case .promptReplay:
            if let replay = replay() {
                state = replay ? .displayRaceNumber : .displayGameOver
            }
            clearUserInput()
        case .displayGameOver: break

And we are done. Here’s the final screen.

Conclusion

This is how far I will go with this game. Its fully done. Its looks and behave very much like the old BASIC program. I wanted to see how much things have changed with UI programming. The biggest change I would say is how we are doing MVVM pattern. Plus, game programming in this pattern leads to to Finite State Machine. The whole moveToNextState method is exactly like the old BASIC, except that its changing states at every step, rather than being procedural program.

Introduction

In Part 1, I converted an old BASIC game from Casio FX-790P into Swift programing language. By the end of that part, I had the beginnings of a MVVM app. The Horse and Player classes were the Models, the horseRaceGame() method was the ViewModel, and the 16 display and prompt messages were the Views. In this part, I am going to put it all together in a proper SwiftUI application.

Here is the original game description.

We are going to try to stick to this as much as possible. The goal is not to improve the game or the UI, but to see how far and different modern languages and UI frameworks have become since the 90s.

1. Start Game

Our very first view is the display of the game title. Here’s the code from part 1.

extension FX790...
    private func displayGameTitle() {
        PRINT("< Horse Race >")
        for _ in 1...5 {
            BEEP()
            BEEP(1)
        }
    }

To convert this to SwiftUI, we need to start with the @main App.

@main
struct HorseRaceApp: App {
    var body: some Scene {
        WindowGroup {
            HorseRaceView()
        }
    }
}

All our game display logic will go inside HorseRaceView. I wanted to create same view as original monospaced, single line, text display.

struct HorseRaceView: View {
    var body: some View {
        Text("< Horse Race >")
            .font(.system(size: 28, design: .monospaced))
            .frame(width: 400, alignment: .leading)
            .padding()
            .background(Color.white)
            .border(Color.gray, width: 1)
    }
}

The width of 400 will fit 23 characters, as our original game. Here’s what is rendered.

All our displays will happen inside this box. So I decided to take this box and make it a base view called TrackView, (as in a “horse track”)

struct TrackView<Content: View>: View {
    let fontSize: CGFloat = 28
    let content: () -> Content
    
    init(@ViewBuilder content: @escaping () -> Content) {
        self.content = content
    }
    
    var body: some View {
        content()
            .font(.system(size: fontSize, design: .monospaced))
            .frame(width: trackWidth(), alignment: .leading)
            .padding()
            .background(Color.white)
            .border(Color.gray, width: 1)
    }
}

And then our HorseRaceView can use this base view –

struct HorseRaceView: View {
    var body: some View {
        TrackView {
            Text("< Horse Race >")
        }
    }
}

Also notice that that I make the width of the track dynamic with a function trackWidth() –

struct TrackView...
    private func trackWidth() -> CGFloat {
        let font = NSFont.monospacedSystemFont(
                       ofSize: fontSize, 
                       weight: .regular)
        let charWidth = "X".size(withAttributes: [.font: font]).width
        return charWidth * CGFloat(GameConfig.goalPosition)
    }

"X".size(withAttributes:) calculates the width of a single character, which we multiply by the number of characters (GameConfig.goalPosition) to get the total track width in pixels. The frame(width:) now dynamically fits our 23-character track.

2. Display Horses

The next display is the horses description —

extension FX790...
    private func displayHorses(_ horses: [Horse]) {
        PRINT() // clear screen
        PRINT("HORSE")
        for horse in horses {
            PRINT(" \(horse.id)\(horse.symbol)")
        }
        TIMER()
        TIMER()
    }

We don’t need a whole new View type every time the text changes. SwiftUI encourages state-driven UIs, not manually swapping whole views. The view’s body automatically re-renders when its state changes. That’s the natural way to do timed or gesture changes. In our game, the new display message is just a different state of the same HorseRaceView. This is much easier to animate, control timing, or even loop messages later.

So we will keep everything inside the HorseRaceView and just drive it with @State. The state will be driven by a HorseRaceViewModel. In BASIC, the code was very procedural, which we cannot do in SwiftUI. So we will have to do some state management. We will need an enum to track the current state.

enum GameState {
    case displayTitle
    case describeHorses
} 

The current state will be maintained by the view model.

@Observable
class HorseRaceViewModel  {
    private var state: GameState = .displayGameTitle
    private var horses: [Horse] = Horse.all()

    var displayText: String {
        return switch state {
        case .displayTitle: "< Horse Race >"
        case .describeHorses: 
            "HORSES \(horses.map(\.label).joined(separator: " "))"
        }
    }
    
    func moveToNextState() {
        switch state {
        case .displayTitle: state = .displayHorses
        case .displayHorses: state = break
        }
    }
}

The horses are obtained from the static method all() in the Horse model, and the label is extension property.

extension Horse {
    var label: String { "\(id)\(symbol)" }

    static func all() -> [Horse] {
        [
            Horse(id: 1, symbol: "♠"),
            Horse(id: 2, symbol: "♥"),
            Horse(id: 3, symbol: "♦"),
            Horse(id: 4, symbol: "♣")
        ]
    }
}

And finally, our view is —

struct HorseRaceView: View {
    @State private var viewModel = HorseRaceViewModel()
    
    var body: some View {
        TrackView {
            Text(viewModel.displayText)
        }
        .onKeyPress(.return) {
            viewModel.moveToNextState()
            return .handled
        }
    }
}

On pressing RETURN, our state is moved to the next state.

We need to capture the key press, and for that the view must be in focus. So I made the entire TrackView focusable.

struct TrackView...
    @FocusState private var isFocused: Bool
    
    var body: some View {
        content()
            .font(.system(size: fontSize, design: .monospaced))
            .frame(width: trackWidth(), alignment: .leading)
            .padding()
            .background(Color.white)
            .border(Color.gray, width: 1)
            .focusable()
            .focused($isFocused)
            .focusEffectDisabled()
            .onAppear {
                isFocused = true
            }
    }

3. Number of Players

Next is the prompt to get the user input for number of players.

extension FX790...
  private func promptNumPlayers() -> Int {
    PRINT()
    BEEP()
    while true {
      let p: Int = INPUT("How many players ")
       if (GameConfig.minPlayers...GameConfig.maxPlayers).contains(p) {
         return p
       }
    }
  }

Let’s add a new state for this.

enum GameState {
    case displayTitle
    case displayHorses
    case promptNumPlayers
}

Our displayText and moveToNextState() needs a new case statement for the promptNumPlayers.

class HorseRaceViewModel...
    var displayText: String {
        return switch state {
        ...
        case .promptNumPlayers: "How many players?"
        }
    }

    private func moveToNextState() {
        switch state {
        case .displayTitle: state = .displayHorses
        case .displayHorses: state = .promptNumPlayers
        case .promptNumPlayers: break
    }

That’s it. Just couple lines of code, and now our prompt shows up.

4. Blinking Cursor

Next we need to figure out how do we capture user input. We could add a TextField after the question mark. But I want to make it as close as the single line console display. I want to show a blinking underscore to tell the user that an input is expected after the question mark, just like in a console. The simplest approach is to append a _ that blinks on and off. We can simulate a blinking cursor in SwiftUI 5 using a Timer with a simple toggle state.

struct BlinkingCursorText: View {
    @State private var showCursor = true
    let text: String
    let timer = Timer.publish(every: 0.5, on: .main, in: .common).autoconnect()
    
    init(_ content: String) {
        self.text = content
    }

    var body: some View {
        Text(text + (showCursor ? "_" : ""))
            .font(.system(size: 28, design: .monospaced))
            .onReceive(timer) { _ in
                showCursor.toggle()
            }
    }
}

We can use this for only those displayText which are prompts. I added a helper field in GameState enum, because I know there are 3 more prompts coming later.

struct HorseRaceView...
    var body...
        TrackView {
            if viewModel.state.isPrompt {
                BlinkingCursorText(viewModel.displayText)
            } else {
                Text(viewModel.displayText)
            }
        }

enum GameState...
    var isPrompt: Bool {
        switch self {
        case .promptNumPlayers: return true
        default : return false
        }
    }
}

The _ toggles every 0.5s, giving the classic blinking cursor effect. This works nicely with “console-style” layout without needing a real TextField.

5. Capturing User Input

Next, we need to capture key presses from the users. We already have a way to capture user input of RETURN key. Instead of just that one key, we need to open it up for any key, and then have a Switch statement for the key pressed. So I created a handleKeyPress(:KeyPress) method in the view model.

struct HorseRaceView...
    var body: some View {
        TrackView...
        .onKeyPress(action: viewModel.handleKeyPress)
    }

class HorseRaceViewModel...    
    func handleKeyPress(_ keyPress: KeyPress) -> KeyPress.Result {
        switch keyPress.key.character {
        case "\r": moveToNextState()
        case let char: handleUserInput(char)
        }
        return .handled
    }

The handleUserInput() method will need to store the input. I added a field userInput which will be used the track the input from the user.

class HorseRaceViewModel...
    private var userInput: String = ""

    var displayText...
        case .promptNumPlayers: "How many players? \(userInput)"
    
    private func handleUserInput(_ char: Character) {
        guard state.isPrompt else { return }
        userInput.append(char)
    }

Now we can see user input when I press ‘4’ and ‘5’.

But what if user made a mistake and delete the input. Like here I want to delete ‘5’. We need to handle backspace. That’s just another case in handleKeyPress.

class HorseRaceViewModel...
    func handleKeyPress(_ keyPress: KeyPress) -> KeyPress.Result {
        switch keyPress.key.character {
        case Keys.returnKey: moveToNextState()
        case Keys.backspace, Keys.delete: handleBackspace()
        case let char: handleUserInput(char)
        }
        return .handled
    }

    private func handleBackspace() {
        guard state.isPrompt else { return }
        guard !userInput.isEmpty else { return }
        userInput.removeLast()
    }

enum Keys {
    static let returnKey: Character = "\r"
    static let backspace: Character = "\u{8}"
    static let delete: Character = "\u{7F}"
}

Keys is as an enum with no cases, it’s an uninstantiable namespace. This prevents someone from ever making a Keys() instance, which is nice when we only want constants.

6. Instantiating Players

Now after the user is satisfied with their input, they will press RETURN, which will call moveToNextState(). We need to read the userInput, convert it to Int, do validations, and create Players.

class HorseRaceViewModel  {
    private var players: [Player] = []
    
    private func moveToNextState() {
        switch state {
        case .displayTitle: state = .displayHorses
        case .displayHorses: state = .promptNumPlayers
        case .promptNumPlayers:
            if addPlayers() {
                state = ... // Move to next state 
            } 
        }
    }

    private func readInput() -> String {
        let returnVal = userInput
        userInput = ""  // Clear the input after reading
        return returnVal
    }

    private func addPlayers() -> Bool {
        guard let numPlayers = Int(readInput()) else { return false }
        guard numPlayers >= GameConfig.minPlayers else { return false }
        guard numPlayers <= GameConfig.maxPlayers else { return false }
        players.removeAll()
        for p in 1...numPlayers {
            players.append(Player(id: p))
        }
        return true
    }

We are done with this step. We have laid some good groundwork for capturing and processing user input. This will help us in upcoming stages. I think they will go fast.

7. Initial Player Holdings

Next is displaying initial player holdings.

extension FX790...
    private func displayInitialHoldings() {
        PRINT("ALL PLAYERS HAVE $\(GameConfig.startingMoney)")
        TIMER()
    }

This requires just 4 lines of code change.

enum GameState...
    case displayInitialHoldings

class HorseRaceViewModel...
    var displayText...
        case .displayInitialHoldings: 
            "All players have $\(GameConfig.startingMoney)"

    private func moveToNextState...
        case .promptNumPlayers:
            if addPlayers() {
                state = .displayInitialHoldings
            }

This displays —

8. Race Number

Next we need to display the race number.

    private func displayRaceNumber(_ R: Int) {
        PRINT()
        print("<RACE \(R)>")
        TIMER()
    }

We add a new state and a new field to keep track of race numbers. This is the state we will come back to on replay.

enum GameState...
    case displayRaceNumber

class HorseRaceViewModel...
    private var raceNumber: Int = 1
    
    var displayText...
        case .displayRaceNumber: "<Race \(raceNumber)>"
                
    private func moveToNextState...
        case .displayInitialHoldings:
            state = .displayRaceNumber

This displays —

9. Individual Player holdings

Next, we reset horses and players for a new race, and showing each individual player’s remaining money before they choose their horse and bet money on it.

extension FX790...
    private func displayPlayerHoldings(_ player: Player) {
        PRINT()
        BEEP()
        PRINT("PLAYER \(player.id) HAS $\(player.money)")
        TIMER()
    }

So we introduce a new state.

enum GameState...
    case displayPlayerHoldings(Player)

We need the Player as the associative value to know which player to show the holdings for. Let’s implement this new state —

class HorseRaceViewModel...
    var displayText...
        case .displayPlayerHoldings(let p): 
             "Player \(p.id) has $\(p.money)"
        }
    }

    private func moveToNextState...
        case .displayRaceNumber:
            resetForNewRace()
            if let player = players.first() {
                state = .displayPlayerHoldings(player)
            }
        case .displayPlayerHoldings(let player):
            state = players.next(after: player)
                .map { .displayPlayerHoldings($0) }
                .orElse(...)     // move to next state


    private func resetForNewRace() {
        horses.forEach { $0.reset() }
        players.forEach { $0.reset() }
    }

I implemented a couple of helpers first() and next(after:) on the player collection. This way I can loop through each player. In the BASIC code it had skipped the players who had $0 money.

class Player...
    var isActive: Bool { self.money > 0 || self.madeAnyBet }

extension Array where Element == Player...
    func first() -> Player? {
        first(where: \.isActive)
    }
    
    func next(after player: Player) -> Player? {
        guard let curr = firstIndex(of: player) else { return nil }
        return self[(curr + 1)...].first(where: \.isActive)
    }
}

Now we can show each individual players holdings.

10. Horse Odds

Next we need to show the odds of winning per horse, so the player can choose their horse.

extension FX790...
    private func displayHorseOdds(_ horses: [Horse]) {
        PRINT()
        PRINT("RATE ")
        for horse in horses {
            PRINT(csr: (horse.id)*5, " \(horse.symbol) \(horse.odds)")
        }
        TIMER()
        BEEP()
    }

We add the new state.

enum GameState...
    case displayOdds(Player)

We need the Player since we are looping through the player context. And we will pass this player to the next state. Next we implement this new state.

class HorseRaceViewModel...
    var displayText...
        case .displayOdds: 
            "RATE \(horses.map(\.oddsLabel).joined(separator: " "))"
        }

extension Horse...
    var oddsLabel: String { "\(symbol) \(odds)" }

And finally the moving to this state –

class HorseRaceViewModel...
    private func moveToNextState...
        case .displayPlayerHoldings(let player):
            state = .displayOdds(player)
        case .displayOdds(let player):
            state = players.next(after: player)
                .map { .displayPlayerHoldings($0) }
                .orElse(...)     // move to next state

This will display the odds to the player –

End of Part 2

We have come have about half way in our SwiftUI implementation of this game. Lets pause here for a minute and see how the game is shaping up. We can see that this moveToNextState is turning out to be orchestrator of this whole game. The logic here is matching the original game. It is the core game flow driver.

class HorseRaceViewModel...
    private func moveToNextState() {
        switch state {
        case .displayTitle: state = .describeHorses
        case .describeHorses: state = .promptNumPlayers
        case .promptNumPlayers:
            if addPlayers() {
                state = .displayInitialHoldings
            }
        case .displayInitialHoldings:
            resetForNewRace()
            state = .displayRaceNumber
        case .displayRaceNumber:
            if let player = players.first() {
                state = .displayPlayerHoldings(player)
            }
        case .displayPlayerHoldings(let player):
            state = .displayOdds(player)
        case .displayOdds(let player):
            state = players.next(after: player)
                .map { .displayPlayerHoldings($0) }
                .orElse(.displayTitle)
        }
    }

Games have different architecture traditions than MVVM. A very common one is Finite State Machine (FSM). This is exactly what this method doing now. Each game state (e.g. displayTitle, describeHorses, promptNumPlayers, etc.) has logic for transitions which is often implemented with enums and switch statements (like we have), or as a State pattern, which is the OO version of FSM, where each state has its own object/class with enter(), update(), exit() methods. Small/indie games often use FSM (like we’re doing). Bigger games use OO State Pattern or Entity-Component-System (ECS). ECS is popular in larger games (Unity, Bevy, etc.), where logic is separated into components (data, like Health or Position) and systems (logic, like MovementSystem or RenderSystem). ECS is more complex but very scalable for simulation-heavy games.

We will continue the rest of the game development in Part 3. There we will also see if we should refactor moveToNextState to a FSM.

The Casio FX-790P was my first computer where I learned programming back in the 90s. It was a blend between a scientific calculator and a BASIC-programmable handheld computer. It featured a single line, 24-character LCD display, 83 keys, and 8KB of internal memory. It had scientific functions, the ability to calculate square roots, and it ran on a BASIC interpreter, allowing for the storage and execution of up to 10 programs!

This device came with pretty great owner’s manual, which had an extensive chapter on BASIC programing language. I wrote so many programs on this, mostly simple 10-50 lines long. The owner’s manual had two sample programs— Bubble Sort and a Horse Race Game. The game was by far the largest, most complex program I had ever seen. It was 102 lines long and took 1.3KB of memory.

That’s some unreadable code! I just typed this in blindly and hoped that I didn’t make any typos, without really understanding the logic. So for nostalgic reasons, I thought I would convert this program to Swift, and see how a modern programing language compares to this old BASIC code. Can it be done in less than 100 lines? I will start with a line-by-line mirroring of the original code. Then I will refactor to see if I can make it readable.

Step 1: Convert to Swift

Before I can convert this code, it has some commands that I would like to use as-is to preserve the original code. So I wrote a protocol for them. I don’t want to implement these methods, so protocol gives me a nice way to defer the implementation.

Now I convert the whole program, line by line, keeping even the variable names same.

This is 138 lines, not quite 102. However, the BASIC program had multiple statements on single line. I counted them and it too came out to be 138 lines!

Time to refactor.

Step 2: Arrays to Classes

Notice the following 2D arrays -

var A: [[Double]] = DIM(3, 4)
var X : [[Int]] = DIM(2, P) 

“A” represent Horses, and “X” represent Players. The rows are the properties, and the column represent the instance.

A[1][j] = Position of the horse j
A[2][j] = Random number of the horse j
A[3][j] = Odds on the horse j

X[1][j] = Bet amount for player j
X[2][j] = Money remaining for player j

This is very interesting. This shows that even before Object Oriented languages, there was a need for grouping of data under a single variable. But since there were no classes or structs in BASIC, people used 2D arrays. Today we can convert them to proper classes. Lets start with Horse.

class Horse {
    var position: Int = 0
    var randomizer: Double = 0.0
    var odds: Int = 0
}

When we use the Horse class, this becomes,

func horseRaceGame()...
    var horses: [Horse] = Array(repeating: Horse(), count: 4)
    ...
    for horse in horses {
        horse.position = 0
        horse.randomizer = Double.random(in: 0...1)
        horse.odds = 1 + Int(pow(10.0, 1.2 - horse.randomizer))
    }

I can create an initialize() method in Horse, and move this code in there.

class Horse...
    func initialize() {
        self.position = 0
        self.randomizer = Double.random(in: 0...1)
        self.odds = 1 + Int(pow(10.0, 1.2 - self.randomizer))
    }

func horseRaceGame()...
    horses.forEach { $0.initialize() }

Next I create the Player class.

class Player {
    var money: Int
    var bet: Int = 0
    var chosenHorse: String = ""
    
    init(startingMoney: Int = 20) {
        self.money = startingMoney
    }
    
    func initialize() {
        self.bet = 0
        self.chosenHorse = ""
    }
}

There was an array Y$[j] that was tracking the chosen horse for the player j. I don’t know why the original program didn’t make it as X[3][j], since its part of the player data. I moved it with Player. Now I can use this class in the code, replacing all X and Y variables.

func horseRaceGame()...
    var players = Array(repeating: Player(), count: P)
    ...
    // bet money
    for (j, player) in players.enumerated() {
        ...
        player.initialize()
        if player.money == 0 { continue }
        PRINT("PLAYER \(j) HAS $\(player.money)")
        ...
        player.chosenHorse = S$[A$-1] 
        repeat {
            ...
            player.bet = INPUT("PLAYER\(j) \(player.chosenHorse) MONEY")
        } while player.money < player.bet
        player.money = player.money - player.bet
    }   

Step 3: Horse Symbols

Next, I want to move the horse symbols within the Horse class.

let S$ = ["♠", "♥", "♦", "♣"]

This could be an enum, but for now let’s just make it a string field of the class.

class Horse {
    var position: Int = 0
    var randomizer: Double = 0.0
    var odds: Int = 0
    var symbol: String
    
    init(with symbol: String) {
        self.symbol = symbol
    }
}

The initialize() method is separate from init() because it will be called again and again on replays. But the symbol of the horse will remain the same. I plan to change its name later to something like “newRace()” or “reset()”.

The code changes to:

func horseRaceGame()...
    var horses: [Horse] = []
    for symbol in ["♠", "♥", "♦", "♣"] {
        horses.append(Horse(with: symbol))
    }

And the rest of the code where we were using S$[j], we just use horses[j].symbol. But even better, I can remove all index j references.

// Before
    for j in 1...4 {
        if Int(horses[j-1].position) == 23 {
            H = horses[j-1].odds
            A$ = horses[j-1].symbol
        }
    }

// After
    for horse in horses {
        if Int(horse.position) == 23 {
            H = horse.odds
            A$ = horse.symbol
        }
    }

This, I believe, is another strength of classes over arrays. It reduces the amount of times we have to use the indices, which results in reduced bugs due to off-by-one errors.

Step 4: Horse reference in Player

There are few things I want to move to the player class. First I want to change the chosenHorse in player from String to actual Horse instance.

class Player...
    var chosenHorse: Horse?

Its optional because there a state when a player hasn’t made a choice of a horse. Also a player can choose to sit out a race, in which case chosenHorse will be nil. Now, anywhere we have,

player.chosenHorse

We can replace with,

player.chosenHorse?.symbol

Step 5: Player helper methods

Next, I want to create some encapsulations around player data of money and bet, so that I can make them private to player. I want to apply the principle of Tell Don’t Ask, so that the horseRaceGame doesn’t need to read or assign the money or bet data.

class Player...
    private var money: Int
    private var bet: Int = 0

That gave me a total of 13 errors. So I am going to work on fixing each of them one by one, until I am left with ones that cannot be fixed.

First, is the “if player.money == 0” check that is done in two place. I created a isBroke() method.

class Player...
    func isBroke() -> Bool {
        self.money == 0
    }

We are down to 11 errors. Next is the betting loop.

betting loop...
    repeat {
        player.bet = INPUT("PLAYER \(j) ... MONEY ")
    } while player.money < player.bet
    player.money = player.money - player.bet

We can simplify this with:

class Player...
    func placeBet(_ bet: Int) -> Bool {
        guard bet <= money else { return false }
        self.bet = bet
        self.money -= bet
        return true
    }
}

betting loop...
    var bet: Int
    repeat {
        bet = INPUT("PLAYER \(j) ... MONEY ")
    } while !player.placeBet(bet)

This cleaned up 6 more issues! Plus I think this better since before the bet was assigned to player and then the check for “money > bet” was done. Now we only assign the bet and money after everything checks out.

Next is the winnings calculations loop.

winning calculation...
    var M = 0 // money won
    if player.bet > 0 { // if player made any bets
        if player.chosenHorse?.symbol == A$ {
            M = player.bet * H
        }
        PRINT("PLAYER \(j+1) ->PRIZE $\(M)")
    }
    player.money += M

This is another great spot to push responsibility into the Player class. Right now the outside code is “reaching in” to check bets, horses, and money — which makes it harder to change the logic later. We can simplify this as:

winning calculation...
    if player.madeAnyBet() {
        var M = player.collectPrize(if: winningHorse)
        PRINT("PLAYER \(j+1) ->PRIZE $\(M)")
    }

This requires couple methods in Player.

class Player...    
    func madeAnyBet() -> Bool {
        self.bet > 0
    }

    func collectPrize(if winningHorse: Horse) -> Int {
        guard
            let myhorse = self.chosenHorse,
            myhorse.equals(winningHorse)
        else {
            return 0
        }
        
        let prize = myhorse.calculatePrize(for: self.bet)
        self.money += prize
        return prize
    }
}

Here we are chaining the guard conditions with a comma. In Swift, commas inside a guard mean “all of these must hold”. Also notice that we created two methods on Horse class as well - equals and calculatePrize.

class Horse...
    func equals(_ other: Horse) -> Bool {
        self.symbol == other.symbol
    }
    
    func calculatePrize(for bet: Int) -> Int {
        self.odds * bet
    }
}

We no longer need H, since the odds of the winning horse is obtained by the players chosen horse, if its the winner. So we can further simplify this code:

winning calculation...
    var H = 0 // odds on winning horse
    var A$ = "" // winning horse
    for horse in horses {
        if Int(horse.position) == 23 {
            H = horse.odds
            A$ = horse.symbol
        }
    }

We can make this just one liner.

let winningHorse = horses.last { $0.position == 23 }!

Better, I can make this a computed property for horses. in the We can add an extension on Array constrained to Horse like this:

extension Array where Element == Horse {
    var winningHorse: Horse? {
        last { $0.position == 23 }
    }
}

winning calculation...
    if player.madeAnyBet() {
        var M = player.collectPrize(if: horses.winningHorse!)
        PRINT("PLAYER \(j+1) ->PRIZE $\(M)")
    }

Notice I am using ‘last’ since that is what the above for loop would have given. Now we are down to just 2 errors. Both for the exact print statements.

PRINT("PLAYER \(j+1) HAS $\(player.money)")

I am not ready to tackle print statements. So let me just create a remainingMoney() method on Player.

class Player...
    func remainingMoney() -> Int {
        self.money
    }

All errors gone! I can also quickly make chosenHorse as private as well.

class Player...
    private var chosenHorse: Horse?

This results in 2 errors. Both when a player chooses a horse:

choose horse...
    player.chosenHorse = horses[A$-1] 
    bet = INPUT("PLAYER\(j) \(player.chosenHorse?.symbol) MONEY")

I can create a choose() method in Player. And for the second, I can just use the local horses[A$-1].

class Player...
    func choose(horse: Horse) {
        self.chosenHorse = horse
    }

choose horse...
    player.choose(horse: horses[A$-1])
    bet = INPUT("PLAYER \(j) \(horses[A$-1].symbol) MONEY ")

Step 6: Horse helper methods

Lets do the same exercise with Horse. We will try to make each of its property as private, starting with randomizer.

class Horse {
    var position: Int = 0
    private var randomizer: Double = 0.0
    var odds: Int = 0
    var symbol: String

Only 1 error.

if Double.random(in: 0...1) * (0.9 + horse.randomizer / 10.0) > 0.7 {
    horse.position += 1
}

We can extract this to a move() method in Horse.

class Horse...
    func move() {
        if Double.random(in: 0...1) * (0.9 + randomizer / 10.0) > 0.7 {
            self.position += 1
        }
    }
}

Next we tackle this winning condition which is used in couple of places:

horse.position == 23

Which can be made a method.

class Horse...
    func reachedGoal() -> Bool {
        self.position == 23
    }
}

Next, there is this weird logic of moving horses -

main loop...
    var G = 0
    repeat {
        for horse in horses {
            // As soon as somebody wins we stop moving horses
            if G < 1 {
                PRINT(csr: Int(horse.position), " ")
                horse.move()
            }
            if horse.reachedGoal() {
                G += 1
            }
            PRINT(csr: horse.position, "\(horse.symbol)")
        }
    } while G < 2

Here, G is the winners count. This loop can be made much cleaner by getting rid of the manual G counter and instead asking the collection how many horses have finished. We don’t need to manually increment and check G, since we can calculate it each round. Secondly, in the original logic, as soon as one horse reaches the goal, the others stop moving. That means only one horse ever actually finishes, so G will never reach 2. The original BASIC trick was: Keep looping until the first horse finishes, then stop moving horses but still draw all horses once more, then exit after every horse has been drawn in that final round. However, the redraw was at the exact same position. The equivalent Swift can be written much more directly, like this:

var noWinner = true
repeat {
    for horse in horses {
        if noWinner {
            PRINT(csr: Int(horse.position), " ")
            horse.move()
        }
        if horse.reachedGoal() {
            noWinner = false
        }
        PRINT(csr: horse.position, "\(horse.symbol)")
    }
} while noWinner

Now it reads almost like English: while there is no winner → move horses, once a winner appears → stop moving, but still finish drawing. We can make noWinner derived from the horses array instead of mutating a flag variable. We add another property to the extension on Array for Horse like this:

extension Array where Element == Horse {
    var winningHorse: Horse? {
        last { $0.reachedGoal() }
    }
    
    var hasNoWinner: Bool {
        winningHorse == nil
    }
}

Then the loop looks even cleaner:

repeat {
    for horse in horses {
        if horses.hasNoWinner {
            PRINT(csr: Int(horse.position), " ")
            horse.move()
        }
        PRINT(csr: horse.position, "\(horse.symbol)")
    }
} while horses.hasNoWinner

Step 7: Fixing Replay

When converting the program to Swift I had intentionally made wrong implementation of the replay logic. In the BASIC code, it had a GOTO statement, which took the program, not to the very top, but to the middle after all the horses and players were created. This preserved the remaining money of the players, while re-setting everything else (horse position, odds, player bets, etc.). But in Swift, since its a one long method, and there is no GOTO in Swift, I just recalled the horseRaceGame() from the top. That will reset the race number back to 1 and player money back to $20.

replay...
    var F = 0 // Num players with 0 money
    if player.isBroke() { F += 1 }
    if F < P {
        repeat {
            var A$: String = INPUT("REPLAY (Y/N)?")
            if A$ == "Y" {
                R += 1
                horseRaceGame() // GOTO Initialize
            }
            if A$ == "N" { break }
        } while true
    }
    PRINT()
    PRINT("GAME OVER")

The way to fix this is to break the single method into two methods — the top part with horses and players initialization, and the race part with odds and bets. Later we will break into even smaller methods, but for now lets start with two.

func horseRaceGame() {
    var R = 1
    ...
    race(num: 1, horses: horses, players: players)
}

private func race(num R: Int, horses: [Horse], players: [Player]) {
    ...
    if F < players.count { 
        repeat {
            var A$: String = INPUT("REPLAY (Y/N)?")
            if A$ == "Y" {
                race(num: R+1, horses: horses, players: players) 
            }
            if A$ == "N" { break }
        } while true
    }
    PRINT()
    PRINT("GAME OVER")
}

We don’t need number of players, P, variable anymore. I also want to get rid of F, which is the number of players who have $0. That was to test the game-end scenario. I created a remaining property on Players array.

extension Array where Element == Player {
    var remaining: Int {
        count { !$0.isBroke() }
    }
}

I can also separate the prompt and the replay and keep the loop only responsible for validating input, separating input phase from action phase.

replay...
    var replay = false
    if players.remaining > 0 {
        repeat {
            let ans: String = INPUT("REPLAY (Y/N)?")
            if ans == "Y" { replay = true; break }
            if ans == "N" { break }
        } while true
    }

    if replay {
        race(num: R+1, horses: horses, players: players)
    } else {
        PRINT()
        PRINT("GAME OVER")
    }

I plan to move all prompts to their own helper methods later, so this code will further clean up. Last thing I want to do in this step is rename the initialize() methods on Player and Horse to reset(), which communicates better that we are resetting for a new race.

class Horse...
    func reset() {
        self.position = 0
        self.randomizer = Double.random(in: 0...1)
        self.odds = 1 + Int(pow(10.0, 1.2 - self.randomizer))
    }

class Player...
    func reset() {
        self.bet = 0
        self.chosenHorse = nil
    }

Step 8: Player and Horse IDs

One thing I noticed that in 4 loops we are still using indices.

func horseRaceGame...
    for (j, horse) in horses.enumerated() {
        PRINT(" \(j+1)\(horse.symbol)")
    }

func race... 
    for (j, player) in players.enumerated() {
        PRINT("PLAYER \(j+1) HAS $\(player.remainingMoney())")
        ...
        for (k, horse) in horses.enumerated() {
            PRINT(csr: (k+1)*5, " \(horse.symbol) \(horse.odds)")
        }
        ...
        var A$ = 0
        repeat {
            A$ = INPUT("P \(player.id)->")
        } while A$ < 0 || A$ > 4 
        ...
        var bet: Int
        repeat {
            bet = INPUT("PLAYER \(j+1) \(horses[A$-1].symbol) MONEY ")
        } while !player.placeBet(bet)
    }
    ...
    for (j, player) in players.enumerated() {
        if player.madeAnyBet() {
            PRINT("PLAYER \(j+1) ->PRIZE $\(M)")
        }
        PRINT("PLAYER \(j+1) HAS $\(player.remainingMoney())")
    }

I actually had bugs where I just put j, and not j+1. So these indices really do cause off-by-one errors. Let’s add an Id property to Horse and Player.

class Horse...
    private(set) var id: Int
    
    init(id: Int, symbol: String) {
        self.id = id
        self.symbol = symbol
    }

class Player...
    private(set) var id: Int
    
    init(id: Int, startingMoney: Int = 20) {
        self.id = id
        self.money = startingMoney
    }

And the construction is only place we need the index.

func horseRaceGame...
    var horses: [Horse] = []
    for (j, symbol) in ["♠", "♥", "♦", "♣"].enumerated() {
        horses.append(Horse(id: j+1, symbol: symbol))
    }

    var players: [Player] = []
    for p in 1...P {
        players.append(Player(id: p))
    }

Now we don’t need indices everywhere and the rest of the code is simplified with no off-by-one bugs.

PRINT(" \(horse.id)\(horse.symbol)")
PRINT("PLAYER \(player.id) HAS $\(player.money)")
PRINT(csr: (horse.id)*5, " \(horse.symbol) \(horse.odds)")
INPUT("P \(player.id)->")
INPUT("PLAYER \(player.id) \(horses[A$-1].symbol) MONEY ")
PRINT("PLAYER \(player.id) ->PRIZE $\(M)")
PRINT("PLAYER \(player.id) HAS $\(player.remainingMoney())")

Step 9: Magic numbers

We have a lot of magic numbers through out the game that we can collect in one place under a struct GameConfig.

struct GameConfig {
    static let minPlayers = 1
    static let maxPlayers = 5
    static let goalPosition = 23
    static let startingMoney = 20
}

Then there are numbers which are used in calculating odds on a horse and how fast they move. These numbers are buried assumptions in our game logic. Lets look at them separately. First the odds —

class Horse.reset()... 
    self.randomizer = Double.random(in: 0...1)
    self.odds = 1 + Int(pow(10.0, 1.2 - self.randomizer))

This is exponential decay formula which is often used in Sports betting models, where odds drop steeply as winning probability rises. The 10.0 is the odds base multiplier. It sets the overall curve steepness when computing odds. 1.2 is the odds exponent offset. It shifts the curve so that horses with higher/lower randomizer values don’t become too extreme.

Next we look at move —

class Horse.move()
    if Double.random(in: 0...1) * (0.9 + self.randomizer / 10.0) > 0.7 {
        self.position += 1
    }

This is essentially threshold sampling from a uniform distribution, a very common way to implement “chance of success.” It’s a typical ad-hoc tuning pattern we see in game code: multiplying a random number, then comparing to a constant. 0.9 is the base speed factor. It sets how fast horses move on average. 10.0 is used as a randomizer divisor. It reduces the effect of the randomizer. 0.7 is the movement threshold. It determines how “hard” it is for a horse to actually move forward on a tick. The 0.7 is acting like a difficulty threshold. The (0.9 + r/10) is a scaling factor that makes the threshold easier to beat as r gets larger.

With the current values, the Odds ranges from 2:1 (best horse) to 16:1 (worst horse). And the Move probability ranges from ~22% to ~30% per turn. So horses move forward about once every 3–5 turns, and their odds can swing quite a bit depending on the randomizer.

Putting it all together.

struct GameConfig {
    // Player settings
    static let maxPlayers = 5
    static let minPlayers = 1
    static let startingMoney = 20

    // Race settings
    static let goalPosition = 23

    // Odds calculation. Range 2-16
    static let oddsBase: Double = 10.0
    static let oddsWinningDampner: Double = 1.2

    // Horse movement. Move probability range 22% to 30%
    static let moveBaseSpeed: Double = 0.9
    static let moveDampner: Double = 10.0
    static let moveThreshold: Double = 0.7
}

Step 10: Prompt helpers

Next I want to move all user input prompts to their own methods. We have 4 places were we ask for user inputs.

func horseRaceGame...
    var P = 0
    repeat {
        P = INPUT("How many players ")
    } while P > 5 || P < 1

func race...
    var A$ = 0
    repeat {
        A$ = INPUT("P \(j)->")
    } while A$ < 0 || A$ > 4 // 0 means pass
    if A$ == 0 { continue }

    var bet: Int
    repeat {
        BEEP()
        PRINT()
        bet = INPUT("PLAYER \(j) \(horses[A$-1].symbol) MONEY ")
    } while !player.placeBet(bet)

    // Replay
    var replay = false
    if players.remaining > 0 {
        repeat {
            let ans: String = INPUT("REPLAY (Y/N)?")
            if ans == "Y" { replay = true; break }
            if ans == "N" { break }
        } while true
    }

Lets tackle them one at a time. First getting number of players.

extension FX790...
    private func promptNumPlayers() -> Int {
        while true {
            let p: Int = INPUT("How many players ")
            if (1...5).contains(p) {
                return p
            }
        }
    }

func horseRaceGame...
    for p in 1...promptNumPlayers() { ... }

Next, choose horse.

extension FX790...
    private func promptChooseHorse(for player: Player) -> Int {
        while true {
            let choice: Int = INPUT("P \(player.id)->")
            if (0...4).contains(choice) {
                return choice
            }
        }
    }

func race...
    let choice = promptChooseHorse(for: player)
    if choice == 0 { continue }  // 0 means pass
    player.choose(horse: horses[choice - 1])

Next, placing bet.

extension FX790...
    func promptBetMoney(for player: Player) -> Int {
        while true {
            let bet: Int = INPUT(
              "PLAYER \(player.id) \(player.chosenHorse!.symbol) MONEY "
            )
            if bet >= 0 && bet <= player.money {
                return bet
            }
        }
    }

func race...
    let bet = promptBetMoney(for: player)
    player.placeBet(bet)

Lastly, replay.

extension FX790...
    private func promptReplay() -> Bool {
        while true {
            let ans: String = INPUT("REPLAY (Y/N)?")
            if ans == "Y" { return true }
            if ans == "N" { return false }
        }
    }

func race...
    if players.remaining > 0, promptReplay() {
        race(num: R+1, horses: horses, players: players)
    }

Step 11: Prints, Beeps and Timers

This will be the final step in this refactoring session. The code is littered with PRINT and BEEP and TIMER statement. I want to extract them out as well. In total I extracted out 12 display messages. Along with 4 prompt messages, the total comes to 16.

If we think of modern UI based applications, for instance SwiftUI, then they follow a MVVM pattern. I want to head into that direction next, where Horse and Player will become Models, The current horseRaceGame() method will become ViewModel, and these 16 display and prompt messages will turn into Views. However, this post is already too long, so we will tackle the MVVM refactoring in the next part.

End of Part 1

We have come a long way. This is how the program looks at the end of part one. I think this is, at the very least, readable.

The Horse class —

The Player class —

My all time favorite programing book is Refactoring by Martin Fowler. When I first read it many many years ago, it was the very first chapter that hooked me. Before even introducing the various refactorings, Martin Fowler starts the book by giving a very powerful example of how applying just a few simple cleanups to a code can improve its structure. So, just to have some fun, I wanted to do it myself, but in my own favorite language - Swift. I want to see if the the Swift version is going to be different from Java, maybe even better when we apply idiomatic Swift.

I am going to go in a slightly different order of steps than the book. Additionally, I am going to apply a few of my own refactorings. In this process we are going to learn about this concept of ‘increasing vocabulary’ of a software.

The Starting Program

I converted the program from Java to Swift. There are three main classes - Movie, Rental and Customer.

Movie represents the class which contains its title and pricing code.

class Movie {
    static let REGULAR = 0
    static let NEW_RELEASE = 1
    static let CHILDRENS = 2

    private var title: String
    private var priceCode: Int

    init(title: String, priceCode: Int) {
        self.title = title
        self.priceCode = priceCode
    }

    func getPriceCode() -> Int {
        return priceCode
    }

    func setPriceCode(_ code: Int) {
        priceCode = code
    }

    func getTitle() -> String {
        return title
    }
}

Rental class represents the number of days a movie was rented.

class Rental {
    private var movie: Movie
    private var daysRented: Int

    init(movie: Movie, daysRented: Int) {
        self.movie = movie
        self.daysRented = daysRented
    }

    func getDaysRented() -> Int {
        return daysRented
    }

    func getMovie() -> Movie {
        return movie
    }
}

Customer has the array of all their rentals.

class Customer {
    private var name: String
    private var rentals: [Rental] = []

    init(name: String) {
        self.name = name
    }

    func addRental(_ rental: Rental) {
        rentals.append(rental)
    }
    
    func getName() -> String {
        return name
    }
}

There is a method in the Customer class called statement(), which calculates and prints the rental amount and frequent renter points.

func statement() -> String {
    var totalAmount: Double = 0
    var frequentRenterPoints = 0
    var result = "Rental Record for \(name)\n"

    for rental in rentals {
        var thisAmount: Double = 0

        // Determine amounts for each line
        switch rental.getMovie().getPriceCode() {
        case Movie.REGULAR:
            thisAmount += 2
            if rental.getDaysRented() > 2 {
                thisAmount += Double(rental.getDaysRented() - 2) * 1.5
            }
        case Movie.NEW_RELEASE:
            thisAmount += Double(rental.getDaysRented()) * 3
        case Movie.CHILDRENS:
            thisAmount += 1.5
            if rental.getDaysRented() > 3 {
                thisAmount += Double(rental.getDaysRented() - 3) * 1.5
            }
        default:
            break
        }

        // Add frequent renter points
        frequentRenterPoints += 1
        if rental.getMovie().getPriceCode() == Movie.NEW_RELEASE &&
            rental.getDaysRented() > 1 {
            frequentRenterPoints += 1
        }

        // Show figures for this rental
        result += "\t" + rental.getMovie().getTitle() + "\t" +
            String(format: "%.1f", thisAmount) + "\n"
        totalAmount += thisAmount
    }

    // Add footer lines
    result += "Amount owed is \(String(format: "%.1f", totalAmount))\n"
    result += "You earned " + String(frequentRenterPoints) +
        " frequent renter points"

    return result
}

Step 1: Convert to Struct

Even before I use the first refactoring from book, I know I can convert Movie and Rental to Struct, and clean up a lot of boilerplate code of constructors, getters and setters methods. I can also convert the var to let.

struct Movie {
    static let REGULAR = 0
    static let NEW_RELEASE = 1
    static let CHILDRENS = 2

    let title: String
    let priceCode: Int
}

struct Rental {
    let movie: Movie
    let daysRented: Int
}

class Customer {
    let name: String
    private var rentals: [Rental] = []

    init(name: String) {
        self.name = name
    }

    func addRental(_ rental: Rental) {
        rentals.append(rental)
    }
}

Already the code is cleaned up nicely for the basic objects. 35 lines of boilerplate code is removed. Less code, which does the exact same thing, is always better.

Step 2: Extract Method

The best place to start a refactoring exercise are long methods. They are the ripest places for evolving our thinking on how to better design our software. We take a long method and breaks it up into smaller helper methods. This technique is called Extract Method, and it is the most powerful refactoring technique. In this step we apply this technique to the statement() method.

func statement() -> String {
    var totalAmount: Double = 0
    var frequentRenterPoints = 0
    var result = "Rental Record for \(name)\n"

    for rental in rentals {
        var thisAmount: Double = 0

        // Determine amounts for each line
        switch rental.movie.priceCode {
        case Movie.REGULAR:
            thisAmount += 2
            if rental.daysRented > 2 {
                thisAmount += Double(rental.daysRented - 2) * 1.5
            }
        case Movie.NEW_RELEASE:
            thisAmount += Double(rental.daysRented) * 3
        case Movie.CHILDRENS:
            thisAmount += 1.5
            if rental.daysRented > 3 {
                thisAmount += Double(rental.daysRented - 3) * 1.5
            }
        default:
            break
        }

        // Add frequent renter points
        frequentRenterPoints += 1
        if rental.movie.priceCode == Movie.NEW_RELEASE &&
            rental.daysRented > 1 {
            frequentRenterPoints += 1
        }

        // Show figures for this rental
        result += "\t" + rental.movie.title + "\t" +
            String(format: "%.1f", thisAmount) + "\n"
        totalAmount += thisAmount
    }

    // Add footer lines
    result += "Amount owed is \(String(format: "%.1f", totalAmount))\n"
    result += "You earned " + String(frequentRenterPoints) +
        " frequent renter points"

    return result
}

We extract the highlight code above to a new method getCharge(for:).

func statement() -> String {
    var totalAmount: Double = 0
    var frequentRenterPoints = 0
    var result = "Rental Record for \(name)\n"

    for rental in rentals {
        var thisAmount = getCharge(for: rental)

        // Add frequent renter points
        frequentRenterPoints += 1
        if rental.movie.priceCode == Movie.NEW_RELEASE &&
            rental.daysRented > 1 {
            frequentRenterPoints += 1
        }

        // Show figures for this rental
        result += "\t" + rental.movie.title + "\t" +
            String(format: "%.1f", thisAmount) + "\n"
        totalAmount += thisAmount
    }

    // Add footer lines
    result += "Amount owed is \(String(format: "%.1f", totalAmount))\n"
    result += "You earned " + String(frequentRenterPoints) +
        " frequent renter points"

    return result
}
    
private func getCharge(for aRental: Rental) -> Double {
    var result: Double = 0
    switch aRental.movie.priceCode {
    case Movie.REGULAR:
        result += 2
        if aRental.daysRented > 2 {
            result += Double(aRental.daysRented - 2) * 1.5
        }
    case Movie.NEW_RELEASE:
        result += Double(aRental.daysRented) * 3
    case Movie.CHILDRENS:
        result += 1.5
        if aRental.daysRented > 3 {
            result += Double(aRental.daysRented - 3) * 1.5
        }
    default:
        break
    }
    return result
}

One thing I like about Swift is how it lets you choose argument labels which reads like a sentence. In the book, the method was called getChargeFor(Rental aRental). But in Swift, I made it getCharge(for aRental: Rental). Now I call it as:

double thisAmount = getChargeFor(rental) // Java
var thisAmount = getCharge(for: rental) // Swift

The use of argument labels can allow a function to be called in an expressive, sentence-like manner, while still providing a function body that’s readable and clear in intent.

Step 3: Second Extract Method

We can also extract a second method which calculates frequent renter points.

class Customer...
func statement() -> String {
    var totalAmount: Double = 0
    var frequentRenterPoints = 0
    var result = "Rental Record for \(name)\n"

    for rental in rentals {
        var thisAmount = getCharge(for: rental)
        frequentRenterPoints = getFrequentRenterPoints(for: rental)

        // Show figures for this rental
        result += "\t" + rental.movie.title + "\t" +
            String(format: "%.1f", thisAmount) + "\n"
        totalAmount += thisAmount
    }

    // Add footer lines
    result += "Amount owed is \(String(format: "%.1f", totalAmount))\n"
    result += "You earned " + String(frequentRenterPoints) +
        " frequent renter points"

    return result
}

func getFrequentRenterPoints(for aRental: Rental) -> Int {
    if aRental.movie.priceCode == Movie.NEW_RELEASE 
       && aRental.daysRented > 1 {
        return 2
    }
    return 1
}

New Vocabulary Words

As I wrote above, Extract Method is the most powerful of refactoring techniques. Extract Method gives new words to our design vocabulary. For instance, in the above example, we now have two new words - getCharge and getFrequentRenterPoints. These new words are what we are after. They are a way for the existing software to tell us how it wants to evolve. (Yes, software talks if you listen closely!). As we will see in the following steps, once we have these new words, ideas will emerge to design our software better. They are the raw material which will shape the next version of our software’s design. We need to collect, as much as possible, these raw material.

Step 4: Move Method

The question to ask about these new words is - which object should these words belong to? Look at the getCharge and getFrequentRenterPoints methods. These methods do not use any data from the Customer class. All the calculations in these methods are done on aRental. This is a pretty strong indication that these methods should move to Rental.

struct Rental {
    var movie: Movie
    var daysRented: Int
    
    func getCharge() -> Double {
        var result: Double = 0
        switch movie.priceCode {
        case Movie.REGULAR:
            result += 2
            if daysRented > 2 {
                result += Double(daysRented - 2) * 1.5
            }
        case Movie.NEW_RELEASE:
            result += Double(daysRented) * 3
        case Movie.CHILDRENS:
            result += 1.5
            if daysRented > 3 {
                result += Double(daysRented - 3) * 1.5
            }
        default:
            break
        }
        return result
    }

    func getFrequentRenterPoints() -> Int {
        if movie.priceCode == Movie.NEW_RELEASE && daysRented > 1 {
            return 2
        }
        return 1
    }
}

Then the statement() method becomes:

class Customer...
func statement() -> String {
    var totalAmount: Double = 0
    var frequentRenterPoints = 0
    var result = "Rental Record for \(name)\n"

    for rental in rentals {
        var thisAmount = rental.getCharge()
        frequentRenterPoints += rental.getFrequentRenterPoints()

        // Show figures for this rental
        result += "\t" + rental.movie.title + "\t" +
            String(format: "%.1f", thisAmount) + "\n"
        totalAmount += thisAmount
    }

    // Add footer lines
    result += "Amount owed is \(String(format: "%.1f", totalAmount))\n"
    result += "You earned " + String(frequentRenterPoints) +
        " frequent renter points"

    return result
}

This has improved the design, however we are not done. We will go about finding more new words.

Step 5: Replace Temp with Query Methods

We have 3 temporary variables: thisAmount, frequentRenterPoints, and totalAmount. Our next step is to remove these temporary variables with methods knows as Query Methods. The idea is same as Extract Method - we are going to get more new words. Our vocabulary will increase. And increased vocabulary leads to better design.

We apply Replace Temp with Query refactoring to remove thisAmount in the statement method.

func statement() -> String {
    var totalAmount: Double = 0
    var frequentRenterPoints = 0
    var result = "Rental Record for \(name)\n"

    for rental in rentals {
        var thisAmount = rental.getCharge()
        frequentRenterPoints += rental.getFrequentRenterPoints()

        // Show figures for this rental
        result += "\t" + rental.movie.title + "\t" +
            String(format: "%.1f", rental.getCharge()) + "\n"
        totalAmount += rental.getCharge()
    }

    // Add footer lines
    result += "Amount owed is \(String(format: "%.1f", totalAmount))\n"
    result += "You earned " + String(frequentRenterPoints) +
        " frequent renter points"

    return result
}

That was simple, but we didn’t get any new words. Next, we remove the totalAmount variable.

class Customer...
    func statement() -> String {
        var totalAmount: Double = 0
        var frequentRenterPoints = 0
        var result = "Rental Record for \(name)\n"

        for rental in rentals {
            frequentRenterPoints += rental.getFrequentRenterPoints()

            // Show figures for this rental
            result += "\t" + rental.movie.title + "\t" +
                String(format: "%.1f", rental.getCharge()) + "\n"
            totalAmount += rental.getCharge()
        }

        // Add footer lines
        result += "Amount owed is " +
            String(format: "%.1f", getTotalCharge()) + "\n"
        result += "You earned " + String(frequentRenterPoints) +
            " frequent renter points"

        return result
    }
    
    private func getTotalCharge() -> Double {
        rentals.reduce(0) { $0 + $1.getCharge() }
    }

We got one new word - getTotalCharge! The getTotalCharge() method uses closure-based reduce() in Swift and using shorthand argument names ($0, $1). This was 7 lines of code in Java using a for-loop, which is now a one liner.

Now we do the same for frequentRenterPoints.

class Customer...
    func statement() -> String {
        var frequentRenterPoints = 0
        var result = "Rental Record for \(name)\n"

        for rental in rentals {
            frequentRenterPoints += rental.getFrequentRenterPoints()
            // Show figures for this rental
            result += "\t" + rental.movie.title + "\t" +
                String(format: "%.1f", rental.getCharge()) + "\n"
        }

        // Add footer lines
        result += "Amount owed is " +
            String(format: "%.1f", getTotalCharge()) + "\n"
        result += "You earned " +
            String(getTotalFrequentRenterPoints()) +
            " frequent renter points"

        return result
    }

    private func getTotalCharge() -> Double {
        rentals.reduce(0) { $0 + $1.getCharge() }
    }
    
    private func getTotalFrequentRenterPoints() -> Int {
        rentals.reduce(0) { $0 + $1.getFrequentRenterPoints() }
    }

Step 6: Extension Methods

We have two new words - getTotalCharge and getTotalFrequentRenterPoints. We again ask the question which object should these words belong to? These methods operator on a list of Rental objects. So we can make it an extension method on Rental list, and move these to the Rental file.

class Customer...
    func statement() -> String {
        var result = "Rental Record for \(name)\n"

        for rental in rentals {
            // Show figures for this rental
            result += "\t" + rental.movie.title + "\t" +
                String(format: "%.1f", rental.getCharge()) + "\n"
        }

        // Add footer lines
        result += "Amount owed is " +
            String(format: "%.1f", rentals.getTotalCharge()) + "\n"
        result += "You earned " +
            String(rentals.getTotalFrequentRenterPoints()) +
            " frequent renter points"

        return result
    }

File Rental...
extension Sequence where Element == Rental {
    func getTotalCharge() -> Double {
        reduce(0) { $0 + $1.getCharge() }
    }

    func getTotalFrequentRenterPoints() -> Int {
        reduce(0) { $0 + $1.getFrequentRenterPoints() }
    }
}

I love Swift’s extension methods. These methods are available to any other part of the code that needs them. That helps a lot in coming up with cleaner code for the class.

For now we are done with Customer class and the statement method. The statement method is looking much better than its original state. Now it only calculates the result and leaves the rest of the calculations of totalCharge and totalFrequentRenterPoints to others. This follows the powerful design principle known as ‘Tell, Don’t Ask”.

Tell, Don't Ask principle says that instead of asking an object for its data and then making decisions based on that data, you should tell the object what to do directly. This encourages thinking in terms of actions and responsibilities rather than data and state, leading to better encapsulation and maintainable code.

Step 7: Move Method

Lets move our attention to the Renter class, and its two new methods getCharge and getFrequentRenterPoints. Are these methods in the right place?

The way to find out where a particular method should live, we should look at what data does it operator on. These methods use two pieces of data - the daysRented and movie type. One belongs to Rental and other to the Movie structs. Its 50/50. So where should these methods live?

We choose Movie. Why? The book explains it brilliantly.

It’s about “minimizing change”. Think about which of these two data - daysRental or movie type - is more likely to change, that will lead to lot of other code changing? It will be the movie type. When we add new movie types, the switch and the if statements will change. If these methods live in Rental, then adding a new movie type will lead to two class changing - Movie and Rental. But if these methods live in Movie, then only one class will need to change, the Movie itself. Nobody else will need to know. Better encapsulation leads to another design principle called the “Open-Closed Principle”.

According to open-closed principle, the code should be open to extension (adding new movie types) but closed for modification (a big ripple effect across all the classes).

Lets move getCharge and getFrequentRenterPoints methods from Rental struct to Movie struct.

struct Rental...
    func getCharge() -> Double {
        return movie.getCharge(for: daysRented)
    }
    
    func getFrequentRenterPoints() -> Int {
        return movie.getFrequentRenterPoints(for: daysRented)
    }

struct Movie...
    func getCharge(for daysRented: Int) -> Double {
        var result: Double = 0
        switch priceCode {
        case Movie.REGULAR:
            result += 2
            if daysRented > 2 {
                result += Double(daysRented - 2) * 1.5
            }
        case Movie.NEW_RELEASE:
            result += Double(daysRented) * 3
        case Movie.CHILDRENS:
            result += 1.5
            if daysRented > 3 {
                result += Double(daysRented - 3) * 1.5
            }
        default:
            break
        }
        return result
    }
    
    func getFrequentRenterPoints(for daysRented: Int) -> Int {
        if priceCode == Movie.NEW_RELEASE && daysRented > 1 {
            return 2
        }
        return 1
    }

This is the brilliant insight right here! This is the inflection point from where the remainder of the refactoring will happen. This is where we start reaping the benefits of our new vocabulary that will lead us to a better polymorphic solution.

Step 8: Inheritance, Composition or Enums?

We are going to move our attention to the Movie struct. Its got three types, and based on what type of the movie is, we calculate the charge and frequent renter points.

struct Movie {
    static let REGULAR = 0
    static let NEW_RELEASE = 1
    static let CHILDRENS = 2

    let title: String
    let priceCode: Int

    func getCharge(for daysRented: Int) -> Double {
        var result: Double = 0
        switch priceCode {
        case Movie.REGULAR:
            result += 2
            if daysRented > 2 {
                result += Double(daysRented - 2) * 1.5
            }
        case Movie.NEW_RELEASE:
            result += Double(daysRented) * 3
        case Movie.CHILDRENS:
            result += 1.5
            if daysRented > 3 {
                result += Double(daysRented - 3) * 1.5
            }
        default:
            break
        }
        return result
    }
    
    func getFrequentRenterPoints(for daysRented: Int) -> Int {
        if priceCode == Movie.NEW_RELEASE && daysRented > 1 {
            return 2
        }
        return 1
    }
}

There are 3 options to move forward. First, we can use inheritance, and create sub classes for Movie. But notice that switch statement and the if statement is operating on the priceCode. These are not movie types but priceCode types!

Next option is we can use composition, and create an interface or abstract class Price, which will have the 3 sub-type implementations - RegularPrice, NewReleasePrice and ChildrenPrice. The Movie struct will have reference to the Price type, which it can polymorphically use to get charge and frequent renter points.

The book uses this option 2. But I am doing to defer slightly from the book. We have a third option. Instead of making Price an abstract class with various types being subclasses, I am going to make it an Enum. This is more idiomatic way of doing Swift. Swift Enums are too powerful, and in almost all cases, removes the need to create interfaces or abstract classes.

enum PriceCode {
    case childrens, regular, newRelease
}

Now we can move getCharge() and getFrequentRenterPoints() to PriceCode.

struct Movie {
    static let REGULAR = 0
    static let NEW_RELEASE = 1
    static let CHILDRENS = 2

    let title: String
    let priceCode: PriceCode

    func getCharge(for daysRented: Int) -> Double {
        return priceCode.getCharge(for: daysRented)
    }
    
    func getFrequentRenterPoints(for daysRented: Int) -> Int {
        return priceCode.getFrequentRenterPoints(for: daysRented)
    }
}

enum Price...
    func getCharge(for daysRented: Int) -> Double {
        switch self {
        case .regular:
            var charge = 2.0
            if daysRented > 2 {
                charge += Double(daysRented - 2) * 1.5
            }
            return charge

        case .newRelease:
            return Double(daysRented) * 3

        case .childrens:
            var charge = 1.5
            if daysRented > 3 {
                charge += Double(daysRented - 3) * 1.5
            }
            return charge
        }
    }
    
    func getFrequentRenterPoints(for daysRented: Int) -> Int {
        switch self {
        case .newRelease: return daysRented > 1 ? 2 : 1
        default: return 1
        }
    }

In Java example, they had it as classes, so the static movie types were needed. But in Swift, we can just use the enums directly. There is no difference.

Enums over Polymorphism

We could have done a polymorphic approach in Swift using Protocols.

protocol Price {
    func getCharge(for daysRented: Int) -> Double
    func getFrequentRenterPoints(for daysRented: Int) -> Int
}

Then had 3 structs adopt this protocol.

struct RegularPrice: Price { ... } 
struct NewReleasePrice: Price { ... }
struct ChildrensPrice: Price { ... }

Movie will have reference to Price protocol.

struct Movie...
    let priceCode: any Price
}

Here the priceCode is of box type Price, which allows the polymorphic behavior. Setting aside the performance cost of box types due to dynamic dispatch, I don’t like the proliferation of these small small structs every time we add a new type of price code. Enums allows keeping all logic in one place in a switch statement. Yes, the switch statement will grow as we add new price types, but they will stay in one place in one file. Enums also have different associative values for its case values. That is like different subclasses with different constructor fields.

Therefore, I generally prefer enums over polymorphism.

Step 9: PriceCode on Movie or Rental?

The example in the book end with step 8 above. But I want go on and do a couple more things.

Should Movie have a price code or Rental? I think Rental should have the price code. A movie’s release date or genre can influence its price at time of its rental. Few months after its release, a NEW_RELEASE price code will turn into REGULAR price code. But the Movie object shouldn’t change. Furthermore, there is a big hint in the code - for Rental to get a charge or frequent renter points, it has to make two hops, through Movie and PriceCode. But Movie has no use of price, except to quickly go and delegate to PriceCode. It doesn’t even pass any of its own data to PriceCode, like Rental passes daysRented.

So lets move priceCode to Rental.

struct Rental {
    var movie: Movie
    var priceCode: PriceCode
    var daysRented: Int
    
    func getCharge() -> Double {
        return priceCode.getCharge(for: daysRented)
    }
    
    func getFrequentRenterPoints() -> Int {
        return priceCode.getFrequentRenterPoints(for: daysRented)
    }
}

Now PriceCode can be created at the time of Rental, without changing Movie.

// In 2010
var rental = Rental(movie: inception, priceCode: Price.newRelease)

// In 2025
var rental = Rental(movie: inception, priceCode: Price.regular)

Movie just remains with a title. More needless code is deleted.

struct Movie {
    let title: String
    let priceCode: PriceCode

    func getCharge(for daysRented: Int) -> Double {
        return priceCode.getCharge(for: daysRented)
    }
    
    func getFrequentRenterPoints(for daysRented: Int) -> Int {
        return priceCode.getFrequentRenterPoints(for: daysRented)
    }
}

We could also delete the whole Movie struct and move the title to Rental. However, I think we should leave it. Later, if needed, we can add genre and releaseDate to Movie struct, which will help Rental to assign a price code.

struct Movie {
    let title: String
    let genre: String
    let releaseDate: Date
}

Step 10: Naming

This is the final step. We are going to rename a few methods. It is so important to name things correctly.

Methods should communicate both what it’s doing and how it should be interpreted by the caller.

We have two methods getCharge and getFrequentRenterPoints that I am going to rename.

On PriceCode, the results of these methods involves computation based on input or internal state. The name should communicate cost or intentionality (e.g., not just fetching a stored value). We want to signal to caller: “this isn’t a stored property, it’s logic.” Therefore, I think a more appropriate names are calculateCharge() and calculateFrequentRenterPoints().

enum Price {
    case childrens, regular, newRelease
    
    func calculateCharge(for daysRented: Int) -> Double {
        ...calculations...
    }
    
    func calculateFrequentRenterPoints(for daysRented: Int) -> Int {
        ...calculations...
    }
}

However, on Rental, these methods are very simple. When it comes to query methods (methods that retrieve information and don’t cause side effects), the Swift API Design Guidelines is to avoid using “get” as a prefix.

“Omit needless words.” Methods and properties should read as grammatical English phrases. Avoid get, is, do, compute, etc., unless they’re necessary for clarity or disambiguation.

So we can name these methods simply as charge() and frequentRenterPoints(). Further, for simple side-effect-free queries, Swift encourages to use Computed Properties. Lets do this for getTotalCharge() and getTotalFrequentRenterPoints() extension methods as well.

struct Rental...
    var charge: Double {
        return priceCode.calculateCharge(for: daysRented)
    }
    
    var frequentRenterPoints: Int {
        return priceCode.calculateFrequentRenterPoints(for: daysRented)
    }


extension Sequence where Element == Rental {
    var totalCharge: Double {
        reduce(0) { $0 + $1.charge }
    }
    
    var totalFrequentRenterPoints: Int {
        reduce(0) { $0 + $1.frequentRenterPoints }
    }
}

And the statement() method becomes even cleaner.

class Customer...
    func statement() -> String {
        var result = "Rental Record for \(name)\n"

        for rental in rentals {
            result += "\t" + rental.movie.title + "\t" +
                String(format: "%.1f", rental.charge) + "\n"
        }

        // Add footer lines
        result += "Amount owed is " +
            String(format: "%.1f", rentals.totalCharge) + "\n"
        result += "You earned " +
            String(rentals.totalFrequentRenterPoints) +
            " frequent renter points"

        return result
    }

Thats it! We are done.

Conclusion

Lets summarize the insights we gained from this exercise.

When we first write our software, these new “vocabulary” words do not exist. In our example, in the beginning this software’s purpose was to print out a customer’s rental statement with charges based on “days rented”. Life was simple. Over time, new features are added, like in this case we must have added new movie types (“new releases” and “children”) and frequent renter points. But we kept shoving them into the statement method. So the vocabulary of this program remained stagnant. With refractoring, we discovered new words - charges and frequentRenterPoints. Those led to the creation of a new enum PriceCode. This significantly improved the design of our software. Now, if we add a new price code, it would just need modifying one Enum. In this simple example its hard to see the cost savings, but imagine a code base with thousands of line of code.

We also looked at few design principles - Tell, Don’t Ask, Open-Closed principle, Enums over Polymorphism, and Naming guidelines.

Lastly, I hope I was able to illustrate some of the lovely features of the Swift programming language - Structs, Enums, Argument labels, Extension Methods, Computed Properties, and String Interpolation.

Thanks for reading!

Introduction

Varargs were introduced in Java 5 and provide a short-hand for methods that support an arbitrary number of parameters of one type. This is signified by three dots (...).

public boolean match(TokenType... types) {
    for (TokenType type : types) {
      if (check(type)) {
        return true;
      }
    }
    return false;  
}

And are called as a comma separated list.

match(PLUS, MINUS)

Rust doesn't have a direct equivalent to Java's ... (varargs) syntax. But there are 4 ways we can achieve the same result.

1. Vectors (Don't use)

We can use vectors to pass the list of arguments.

fn match_token(types: Vec<TokenType>) -> bool {
    for &token_type in types {
        if check(token_type) {
            return true;
        }
    }
    false
}`

And then call it like -

match_token(vec![PLUS, MINUS])

2. Slices (Best)

We can use slices (&[T]) to pass an arbitrary number of arguments.

fn match_token(types: &[TokenType]) -> bool {
    for &token_type in types {
        if check(token_type) {
            return true;
        }
    }
    false
}

Usage is -

match_token(&[PLUS, MINUS])

Using &[T] is better than using Vec in most cases.

• Avoids heap allocation: vec![…] creates a new vector on the heap every time you call the function. Whereas, &[T] is a borrowed reference to a static array — no allocation involved.

• Better performance: &[T] just points to existing data, no copying or memory allocation. Vec! has to allocate, construct, and then drop the vector.

• More idiomatic for fixed/short lists: We're not modifying the list, just reading it — so a reference is semantically correct.

3. Macros (Less common)

Macros can give Java-style variadic syntax, but are usually overkill unless you need extreme flexibility.

macro_rules! match_token {
    (expr, $( $token_type:expr ),+ ) => {{
        let mut matched = false;
        $(
            if check($token_type) {
                matched = true;
                break;
            }
        )+
        matched
    }};
}

Usage is -

match_token!(PLUS, MINUS) 

Macros are powerful, but they come with tradeoffs like harder debugging and less type inference. Use macros if you want concise call sites or compile-time efficiency. Prefer slices (&[T]) if you want more readable, testable, and debuggable code.

4. Const Generics (Cleanest!)

This approach is very clean and performant but only works with fixed-length arrays - i.e. size known at compile time. This is fine if the list is hardcoded at the call sites.

pub fn match_token<const N: usize>(types: [TokenType; N]) -> bool {
    for token_type in types {
        if check(token_type) {
            return true;
        }
    }
    false
}

Here <const N: usize> lets Rust know the size of the array at compile time, and [TokenType; N] is the fixed-size array. The usage is -

match_token([PLUS, MINUS])  

I think this is the cleanest approach! We do not need to take a reference (&[TokenType]) — it's owned, but with zero allocation, and inline. This avoids runtime heap allocations and allows full compile-time optimization.

Conclusion

Use slices when the number of arguments is not known at compile time, and use const generics when the size of the array is known at compile time.

In Rust, some simple types are “implicitly copyable” and when you assign them or pass them as arguments, the receiver will get a copy, leaving the original value in place. Copy types are like “value” types in Java or JS language. Therefore Copy can be used to avoid borrow, lifetime annotation or smart pointer.

Native types implement Copy

// u8 implements Copy
let x: u8 = 123;
let y = x;  // copy happen implicitly
println!("x={}, y={}", x, y);  // x can still be used

// Vec<u8> implements Clone, but not Copy
let v: Vec<u8> = vec![1, 2, 3];
let w = v; // This would *move* the value, rendering v unusable.

Copy simply tells the compiler that this previous copy is still valid and can be reused. The compiler understands that it doesn't need to consider move. Reassignments or passing-by-values leave behind a bitwise copy of the object at its previous position. Values are safely duplicated via memcpy. This implies the value is somehow primitive or cheap to copy. It is guaranteed to have zero overhead.

Reassignment

#[derive(Debug, Clone, Copy)]
pub struct PointCloneAndCopy {
    pub x: f64,
}

#[derive(Debug, Clone)]
pub struct PointCloneOnly {
    pub x: f64,
}

fn test_copy_and_clone() {
    let p1 = PointCloneAndCopy { x: 0. };
    let p2 = p1; // Copied automatically
    println!("{:?} {:?}", p1, p2);
}

fn test_clone_only() {
    let p1 = PointCloneOnly { x: 0. };
    let p2 = p1; // This is a move instead
    println!("{:?} {:?}", p1, p2); // ERROR!
}

Every Copy type is also required to be Clone. Clone is a supertrait of Copy, so everything which is Copy must also implement Clone. If a type is Copy then its Clone implementation only needs to return *self.

Passing-by-value

Consider this enum TokenType which doesn’t implement Copy. When we pass it as an argument to a method, we do it as borrow using &.

// No Copy
#[derive(Clone, Debug)]
enum TokenType {
    Plus,
    Minus,
    // ...
}

fn check(&self, token_type: &TokenType) -> bool {
    // ...
}

// This is *borrow* i.e. pass-by-reference
self.check(&TokenType.Plus)

I was bothered by the added & everywhere. I understand that the borrow is idiomatic in Rust, but here it feels a bit verbose, especially for enum comparisons where we're not mutating or consuming the value — just checking it. So I made TokenType implement Copy.

#[derive(Copy, Clone, Debug)]
enum TokenType {
    Plus,
    Minus,
    // ...
}

// Now its clean pass-by-value
self.check(TokenType.PLUS)

Conclusion

Copy is meant to be implemented for "cheap" types, such as u8 or simple Enums, as in the example above. If you write a quite heavyweight type, for which you think a move is more efficient than a copy, make it not implement Copy. Note that in the u8 case, we cannot possibly be more efficient with a move, since under the hood it would probably at least entail a pointer copy - which is already as expensive as a u8 copy, so why bother.

Fiction

The Question

Imagine we got the following coding question in an interview.

There exists a staircase with N steps, and you can climb up either 1 or 2 steps at a time. Given N, write a function that returns the number of unique ways you can climb the staircase.

Step 1: Think of the underlying structure of the problem

The underlying structure of this problem can be thought of as a tree. Every step of the staircase is the node of the tree. And from every step, we can go either 1 step or 2 steps. Thinking of the problem as a tree, leads us to a solution idea using depth-first-search (DFS).

Step 2: Implement simple DFS using recursion

The number of ways we can climb to a step n is the sum of number of ways we can climb to (n-1) step and number ways we can climb to (n-2) step. We can use this to create the recursive method.

int countWays(int n) {
  return countWays(n-1) + countWays(n-2);
}

Step 3: Implement Recursion Base Case

Now we just need to think of the base case to stop the recursion. Say n = 2. The number of ways to get to step 2 are 2 (1, 1 and 2). Using the equation above, this becomes:

CountWays(1) + CountWays(0) = CountWays(0) + CountWays(-1) + CountWays(0)

This mean whenever we have n=0, we return 1 count, and whenever we have n=-1, we return 0.

int countWays(int n) {
  if (n<0) {
    return 0; 
  } else if (n == 0) {
    return 1;
  }

  return countWays(n-1) + countWays(n-2);
}

Step 4: Think of Runtime and Optimize

The runtime is exponential, O(2^N), since each call branches to 2 more calls. We can fix this with memoization.

int countWays(int n) {
  if (n<0) {
    return 0; 
  } else if (n == 0) {
    return 1;
  } 

  // memoization
  if (cache.containsKey(n)){
    return cache.get(n);
  }

  int ways = countWays(n-1) + countWays(n-2);

  cache.put(n, ways);
  return ways;
} 

Step 5: Think of edge cases

Integer will overflow soon. Using a Long or BigInteger will help.

long countWays(int n) {
  if (n<0) {
    return 0; 
  } else if (n == 0) {
    return 1;
  } 

  // memoization
  if (cache.containsKey(n)){
    return cache.get(n);
  }

  long ways = countWays(n-1) + countWays(n-2);

  cache.put(n, ways);
  return ways;
}

Enhancing the Question

We knew this was going to happen. The interviewer was going to extend the problem to make it more challenging.

What if, instead of being able to climb 1 or 2 steps at a time, you could climb any number from a set of positive integers X? For example, if X = {1, 3, 5}, you could climb 1, 3, or 5 steps at a time.

Step 6: Again think of the underlying problem

This becomes a backtracking problem. We try all steps from the given set, until we reach the end (n=0).

long countWays(int n, Set<int> x) {
  if (n<0) {
    return 0; 
  } else if (n == 0) {
    return 1;
  } 

  if (cache.containsKey(n)){
    return cache.get(n);
  }

  // backtracking
  long ways = 0; 
  for (int st in x) {
    ways += countWays(n - st);
  }

  cache.put(n, ways);
  return ways;
} 

Conclusion

Every (good) interview question has some underlying structure. These structures are handful in number. We don’t need to solve every leetcode problem to ace the interview. Just remember these handful of structures. We examined a few in this post - Trees, DFS, Recursion, Memoization, and Backtracking.

I am a software engineer based in Seattle, WA. This is my corner of the web where I write about my programming experience, reading and software tinkering (see my github). Visit the archives for all past articles.

Stay up-to-date

If you like what you reading here, consider subscribing to the newsletter. It’s free and you won’t have to worry about missing anything. Every new article goes directly to your inbox.

Subscribe now

Join the crew

Be part of a community of people who share your interests. To find out more about the company that provides the tech for this newsletter, visit Substack.com.

Introduction

Object references in many programming languages can point to the real object or not point to anything (i.e. they are Null). Swift, conversely, does not have null object references. The references must always point to a real object. To support the “can have absence of a value” feature, Swift has a different solution - the Optional type, which is an enum of two cases.

enum Optional<Wrapped> {
  case none
  case some(Wrapped)
}

Optional either holds no value or some value. The none enum case denotes the absence of a value and the some enum case denotes presence of value. The value is stored as Wrapped, which is the generic placeholder type for the actual user define type of the value. Now anytime we have a need to use null, we can use Optional.

Creating Optionals

Lets use an example from an imaginary cat experiment.

func openSchrodingersBox() -> Optional<Cat> {
  if poisonFlaskShattered {
    return .none
  } else {
    return .some(Cat(name: "Shady"))
  }
}

This function can return both a value and none. Swift gives three helpful syntax simplifiers: (a) the special constant “nil” having the value Optional.none, (b) the question mark (?) operator to define the optional type instead of typing the full name Optional<Cat>, and (c) no need to specify .some.

func openSchrodingersBox() -> Cat? {
  if poisonFlaskShattered {
    return nil
  } else {
    return Cat(name: "Shady")
  }
} 

This way all the implementation details of the Optional enum is completely hidden from the programmer, and they can just work with nil and ?.

Unwrapping Optionals

Optional instances in Swift must be “unwrapped” before their values can be used. Unwrapping means extracting out the stored value. There are 6 ways to unwrap optional values. The following use the example function above to get a cat which may or may not be alive.

let maybeAliveCat: Cat? = openSchrodingersBox() 

1. Optional Binding

The first way you can unwrap an optional is use if-let to find out whether an optional contains a value, and if so, unwrap that value as a new variable. This is called optional binding.

if let aliveCat = maybeAliveCat {
  aliveCat.meow() 
} 

In this example the scope of aliveCat is only within the body of the if statement.

2. Guard Statement

You can use guard-let-else statement to also check if optional contains a value. The guard statement has an else clause. The code inside the else clause is executed if the optional doesn’t have a value. If the optional has a value, it is available in the lines of code that follow the guard statement.

guard let aliveCat = maybeAliveCat else {
  return 
} 
aliveCat.meow() 

Using guard statement lets you early exit a method if value is not present. It improves the readability of the code compared to doing the same check with an if-let statement.

3. Nil-Coalescing Operator

The third way you can unwrap an optional is using the nil-coalescing operator (??). This lets you provide a default value if optional is nil.

let aliveCat = maybeAliveCat ?? defaultCat
aliveCat.meow() 

4. Optional Chaining

Next, you can also unwrap by placing a question mark (?) after the optional. This is called optional chaining.

maybeAliveCat?.meow() 

If the optional contains a value, the meow() call succeeds; if the optional is nil, the method meow() is never executed. Multiple queries can be chained together, and the entire chain fails gracefully if any link in the chain is nil.

5. Forced Unwrapping

So far we have looked at safe ways to unwrap optionals. These next 2 are unsafe, and should be used when you’re sure that an optional contains a value. First of these is to force unwrap an optional’s underlying value by adding an exclamation point (!) to the end of the optional’s name.

maybeAliveCat!.meow()

This is similar to optional chaining using ?. But the difference is that optional chaining fails gracefully when the optional is nil, whereas trying to use ! to access a nonexistent optional value, triggers a runtime error. Therefore, forced unwrapping is generally not recommended.

6. Implicit Unwrapping

Finally, sometimes it’s useful to remove the need to check and unwrap the optional’s value every time it’s accessed, because it can be safely assumed to have a value all of the time. These kinds of optionals are declared using exclamation mark instead of a question mark, and are called as implicitly unwrapped optionals.

let aliveCat: Cat! = maybeAliveCat
aliveCat.meow() 

This way optionals are unwrapped automatically and can be used like non-optional values, without the need to unwrap them each time they’re accessed. However, if an implicitly unwrapped optional is nil and you try to access its wrapped value, you’ll trigger a runtime error.

Conclusion

Tony Hoare invented the Null reference in 1965 as part of the ALGOL W language. He later called it as a “billion-dollar mistake”, saying

…it has led to innumerable errors, vulnerabilities, and system crashes, which have probably caused a billion dollars of pain and damage in the last forty years.

I cannot say if Swift optionals have saved a billion dollars, but I hope at least this article helped you in understanding how they work. Feel free to contact me if you have any questions or comments.