Zustandsautomaten mit Enums modellieren

Enums eignen sich ideal zum Modellieren endlicher Zustandsautomaten. Jeder Case ist ein Zustand, und Übergänge sind Funktionen, die den nächsten Zustand zurückgeben. Dadurch können ungültige Zustände nicht dargestellt werden.

```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 } } ```

Vorteile: • Vollständiges `switch` — der Compiler erzwingt die Behandlung aller Zustände • Ungültige Kombinationen sind unmöglich (z. B. `loaded` ohne Daten) • Der Zustand ist ein Wert — leicht zu testen, zu kopieren und zu protokollieren • Die Benutzeroberfläche kann den Zustand prüfen und entsprechend rendern

```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) } ``` Nur `playing` und `paused` enthalten einen Track — `stopped` nicht. Dadurch dokumentiert sich das Modell selbst.

```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) } ``` Zustandsautomaten mit reinen Übergangsfunktionen lassen sich problemlos als Unit-Tests testen — ohne Mocks.

In großen Apps arbeiten oft mehrere Zustandsautomaten zusammen: ```swift struct AppState { var auth: AuthState var data: LoadState<[Article]> var ui: UIState } ``` Kombinieren Sie sie in einer einzigen Root-State-Struktur für Architekturen im Flux-/Redux-Stil.

Die wichtigsten Erkenntnisse: • Jeder Case = ein Zustand; Übergänge = Funktionen, die den nächsten Zustand zurückgeben • Assoziierte Werte enthalten zustandsspezifische Daten • Vollständiges `switch` = vom Compiler erzwungene Zustandsbehandlung • Reine Übergangsfunktionen lassen sich einfach als Unit-Tests testen • Mehrere Zustandsautomaten können in einer Root-State-Struktur kombiniert werden Kurs abgeschlossen! Als Nächstes: Protokollkomposition.