Enumeraciones con métodos

Parte de la sección Programación orientada a objetos del Journey de Swift de Coddy. Lección 15 de 57.

Un enum define un tipo con un conjunto fijo de casos. Los valores se escriben con un punto, y switch debe gestionar cada caso, por lo que añadir un caso más adelante muestra todos los lugares que necesitan actualizarse:

enum Direction {
    case north, east, south, west
}

let heading = Direction.east
switch heading {
case .north: print("up")
case .east: print("right")
case .south: print("down")
case .west: print("left")
}

Salida:

right

Los enums pueden tener métodos y propiedades calculadas. Dentro de ellos, self es el caso actual:

enum Direction {
    case north, east, south, west

    var turnedRight: Direction {
        switch self {
        case .north: return .east
        case .east: return .south
        case .south: return .west
        case .west: return .north
        }
    }
}

print(Direction.north.turnedRight)
print(Direction.west.turnedRight.turnedRight)

Salida:

east
east

Un valor sin procesar asocia un valor fijo de un tipo a cada caso. init(rawValue:) hace lo contrario y devuelve nil cuando ningún caso coincide:

enum Size: String {
    case small = "S", medium = "M", large = "L"
}

print(Size.medium.rawValue)
print(Size(rawValue: "L") == .large)
print(Size(rawValue: "XL") == nil)

Salida:

M
true
true

Los valores asociados permiten que cada caso lleve sus propios datos, lo que permite que un mismo tipo contenga valores con formas diferentes. switch vincula los datos con let:

enum Payment {
    case cash(amount: Int)
    case card(number: String, amount: Int)

    var amount: Int {
        switch self {
        case .cash(let amount): return amount
        case .card(_, let amount): return amount
        }
    }
}

let payments: [Payment] = [.cash(amount: 20), .card(number: "4242", amount: 55)]
print(payments.map { $0.amount })

Salida:

[20, 55]

Desafío

Fácil

Completa el enum Command con los casos forward, back, left y right, respaldados por los valores sin procesar F, B, L y R. Añade una propiedad calculada step que devuelva el cambio en la posición: forward 1, back -1, left y right 0. Después, completa run(_:), que convierte cada carácter en un comando con init(rawValue:) (omitiendo los caracteres desconocidos) y devuelve position 2, turns 1, skipped 1.

El código proporcionado lee una línea de letras de comandos e imprime el resultado de run(_:).

Tu código va en Command.swift y Functions.swift. main.swift contiene el código proporcionado de entrada/salida y no se puede editar.

Pruébalo tú mismo

// Código de entrada/salida suministrado: déjalo como está
var input: [String] = []
while let line = readLine() { input.append(line) }
print(run(input[0]))