Modelado de máquinas de estados con enumeraciones

Las enumeraciones son ideales para modelar máquinas de estados finitos. Cada caso representa un estado; las transiciones son funciones que devuelven el siguiente estado. Este enfoque hace que los estados no válidos sean irrepresentables.

```swift enum TrafficLight { case red, yellow, green func next() -> TrafficLight { switch self { case .red: return .green case .green: return .yellow case .yellow: return .red } } } var light = TrafficLight.red light = light.next() // .green ```

```swift enum LoadState { case idle case loading(progress: Double) case loaded(T) case failed(Error) } var state: LoadState<[String]> = .idle state = .loading(progress: 0.5) state = .loaded(["alice","bob"]) ```

```swift func transition(_ state: LoadState, event: AppEvent) -> LoadState { switch (state, event) { case (.idle, .startFetch): return .loading(progress: 0) case (.loading, .progress(let p)): return .loading(progress: p) case (.loading, .success(let d)): return .loaded(d) case (.loading, .error(let e)): return .failed(e) default: return state } } ```

Ventajas: • switch exhaustivo: el compilador obliga a gestionar todos los estados • Las combinaciones no válidas son imposibles (por ejemplo, `loaded` sin datos) • El estado es un valor: resulta fácil de probar, copiar y registrar • La interfaz puede usar switch sobre el estado y representarlo en consecuencia

```swift func render(_ state: LoadState<[User]>) { switch state { case .idle: showEmptyView() case .loading(let p): showProgress(p) case .loaded(let users): showList(users) case .failed(let err): showError(err) } } ```

```swift enum PlayerState { case stopped case playing(track: String, position: TimeInterval) case paused(track: String, position: TimeInterval) } ``` Solo `playing` y `paused` contienen una pista; `stopped` no la contiene, lo que hace que el modelo se explique por sí mismo.

```swift extension PlayerState { mutating func play(track: String) { guard case .stopped = self else { return } self = .playing(track: track, position: 0) } mutating func pause() { if case .playing(let t, let p) = self { self = .paused(track: t, position: p) } } } ```

```swift func testLight() { var l = TrafficLight.red assert(l.next() == .green) assert(l.next().next() == .yellow) } ``` Las máquinas de estados con funciones de transición puras se pueden probar fácilmente mediante pruebas unitarias; no se necesitan mocks.

Las aplicaciones grandes suelen tener varias máquinas de estados funcionando conjuntamente: ```swift struct AppState { var auth: AuthState var data: LoadState<[Article]> var ui: UIState } ``` Compóngalas en una única estructura de estado raíz para arquitecturas de estilo Flux/Redux.

Conceptos clave: • Cada caso = un estado; las transiciones = funciones que devuelven el siguiente estado • Los valores asociados contienen datos específicos del estado • Un switch exhaustivo = gestión de estados exigida por el compilador • Las funciones de transición puras son fáciles de probar mediante pruebas unitarias • Combine varias máquinas de estados en una estructura de estado raíz ¡Curso completado! Siguiente: composición de protocolos.