Generics und some: SwiftUI-Code lesen lernen

Das Problem: Dieselbe Funktion für jeden Typ

Stell dir eine Funktion vor, die das erste und das letzte Element eines Arrays vertauscht:

func swapEnds(_ array: [Int]) -> [Int] {
    guard array.count > 1 else { return array }
    var result = array
    result.swapAt(0, result.count - 1)
    return result
}

print(swapEnds([1, 2, 3]))   // [3, 2, 1]

Funktioniert, aber nur für [Int]. Für [String] müsstest du die Funktion noch einmal schreiben, mit exakt demselben Code. Für [Double] ein drittes Mal. Für deine eigene [Book] ein viertes Mal.

Dabei interessiert sich die Funktion überhaupt nicht dafür, was im Array steckt. Sie vertauscht nur Positionen. Was du brauchst, ist eine Möglichkeit zu sagen: „Diese Funktion funktioniert für Arrays mit irgendeinem Typ.“ Das sind Generics.

Generics: Platzhalter für Typen

func swapEnds<T>(_ array: [T]) -> [T] {
    guard array.count > 1 else { return array }
    var result = array
    result.swapAt(0, result.count - 1)
    return result
}

print(swapEnds([1, 2, 3]))            // [3, 2, 1]
print(swapEnds(["a", "b", "c"]))      // ["c", "b", "a"]

Neu ist nur das <T> nach dem Funktionsnamen. Es bedeutet: „T ist ein Platzhalter für einen Typ, der erst beim Aufruf feststeht.“

• Beim Aufruf mit [1, 2, 3] setzt Swift für T den Typ Int ein.
• Beim Aufruf mit ["a", "b", "c"] setzt Swift String ein.

Die Funktion ist dabei genauso typsicher wie vorher. Gibst du ein [Int] hinein, kommt garantiert ein [Int] heraus, nie ein [String].

Du benutzt Generics schon die ganze Zeit

Generics klingen neu, aber du verwendest sie seit Lektion 1.6:

Array ist ein generischer Typ. Apple hat ihn einmal geschrieben, mit einem Platzhalter Element für den Inhalt. Du setzt beim Benutzen den konkreten Typ ein. Dasselbe gilt für Dictionary, Set und Optional.

Alle Fähigkeiten, die du kennst, also append, count, first, map, filter, funktionieren deshalb mit jedem Inhaltstyp, auch mit deinen eigenen Structs.

Eigene generische Typen

Auch Structs können Platzhalter haben:

struct Box<Content> {
    let content: Content

    func describe() -> String {
        "Eine Box mit: \(content)"
    }
}

let numberBox = Box(content: 42)            // Box<Int>
let textBox = Box(content: "Hallo")         // Box<String>

print(numberBox.describe())   // Eine Box mit: 42

Swift leitet den Typ für Content wieder automatisch ab.

Einschränkungen: Platzhalter mit Bedingungen

Manchmal muss der Platzhalter etwas Bestimmtes können. Diese Funktion soll prüfen, ob ein Wert in einem Array vorkommt:

func appears<T>(_ value: T, in array: [T]) -> Bool {
    for item in array {
        if item == value {   // ❌
            return true
        }
    }
    return false
}

Swift weiß nicht, ob man T überhaupt vergleichen kann. Nicht jeder Typ unterstützt ==. Die Lösung: Du verlangst, dass T das Protokoll Equatable erfüllt (Lektion 1.15):

func appears<T: Equatable>(_ value: T, in array: [T]) -> Bool {
    for item in array {
        if item == value {
            return true
        }
    }
    return false
}

print(appears(3, in: [1, 2, 3]))         // true
print(appears("x", in: ["a", "b"]))      // false

<T: Equatable> heißt: „T darf jeder Typ sein, solange er Equatable erfüllt.“ Hier fügen sich Generics und Protokolle zusammen: Das Protokoll beschreibt, was ein Typ können muss, und der Generic sagt, dass jeder passende Typ willkommen ist.

some: Ein bestimmter, aber verborgener Typ

Jetzt kommen wir zum Wort, das in jeder SwiftUI-Datei steht:

var body: some View {
    Text("Hallo")
}

Was ist some View?

Erinnerst du dich: View ist ein Protokoll (Lektion 1.15). Jede View hat aber einen ganz konkreten Typ. Text("Hallo") ist vom Typ Text. Und das hier:

VStack {
    Text("Hallo")
    Image(systemName: "star")
}
.padding()

… hat einen Typ, der ungefähr so aussieht:

ModifiedContent<VStack<TupleView<(Text, Image)>>, _PaddingLayout>

Niemand will so etwas hinschreiben. Und schlimmer: Jedes Mal, wenn du einen Modifier hinzufügst oder entfernst, würde sich dieser Typ ändern.

some View löst das Problem. Es bedeutet:

„Hier kommt ein bestimmter Typ zurück, der View erfüllt. Welcher genau, rechnet der Compiler selbst aus. Ich muss ihn nicht hinschreiben.“

Der Compiler kennt den genauen Typ trotzdem und kann damit optimal arbeiten. Er wird nur vor dir verborgen. Man nennt das einen opaken Typ (englisch opaque type, undurchsichtiger Typ).

some als Parameter

Dasselbe some kennst du schon aus Lektion 1.15:

func introduce(_ animal: some Animal) { ... }

Das ist nur eine kürzere Schreibweise für einen Generic:

func introduce<T: Animal>(_ animal: T) { ... }

Beide bedeuten exakt dasselbe: „Irgendein bestimmter Typ, der Animal erfüllt.“

some oder any?

In Lektion 1.15 hast du auch any kennengelernt. Der Unterschied ist subtil, aber wichtig:

let pet: some Animal = Dog(name: "Bello")       // immer ein Dog
let pets: [any Animal] = [Dog(...), Cat(...)]   // gemischt

Warum ein body nur eine Art von View liefern darf

Aus some folgt eine Regel, über die viele Anfänger stolpern:

var body: some View {
    if isLoggedIn {
        Text("Willkommen")
    } else {
        Image(systemName: "lock")
    }
}

Das funktioniert in SwiftUI, obwohl einmal ein Text und einmal ein Image herauskommt. SwiftUI hat hier einen eingebauten Helfer, den View Builder, der beide Fälle in einen gemeinsamen Typ verpackt. In einer normalen Funktion ohne diesen Helfer ginge das nicht:

func makeLabel(isLoggedIn: Bool) -> some View {
    if isLoggedIn {
        return Text("Willkommen")
    } else {
        return Image(systemName: "lock")
    }
}

some View verspricht einen bestimmten Typ, aber hier gäbe es zwei. Die Lösung ist in SwiftUI einfach: das Attribut @ViewBuilder vor die Funktion schreiben, damit SwiftUI wie bei body hilft. Das lernst du in Lektion 2.21.

Die große Auflösung

Jetzt, am Ende von Stufe 1, kannst du jede Zeile dieser Datei erklären:

import SwiftUI

struct ContentView: View {
    let quotes = ["Jeder Profi war einmal Anfänger.", "Kleine Schritte sind auch Schritte."]

    @State private var currentQuote = "Tippe auf den Button!"

    var body: some View {
        VStack(spacing: 30) {
            Text(currentQuote)
                .font(.title)

            Button("Neuer Spruch") {
                currentQuote = quotes.randomElement() ?? ""
            }
        }
        .padding()
    }
}

Nur @State ist noch offen. Es kommt in Stufe 2.

Typische Fehler

Platzhalter ohne Einschränkung

Der Generic weiß nicht, was T kann. Ergänze die passende Einschränkung, z. B. <T: Equatable> oder <T: Comparable>.

Verschiedene Typen hinter some

Eine Funktion mit some muss immer denselben konkreten Typ zurückgeben. In SwiftUI hilft @ViewBuilder.

Protokoll mit associatedtype als Typ

import SwiftUI

let screens: [View] = [Text("A"), Image(systemName: "star")]

Protokolle mit associatedtype wie View darfst du nur mit some oder any als Typ verwenden. Bei einfachen Protokollen wie Animal akzeptiert Swift [Animal] zwar noch ohne any. Schreib es trotzdem dazu, denn so sieht jeder sofort, dass hier unterschiedliche Typen drinstecken können.

Typ kann nicht abgeleitet werden

let empty = Box(content: nil)

Aus nil allein kann Swift den Typ nicht erkennen. Gib ihn an: Box<String?>(content: nil).

FAQ

Übungen

func largest<T: Comparable>(in array: [T]) -> T? {
    guard var result = array.first else {
        return nil
    }
    for item in array where item > result {
        result = item
    }
    return result
}

print(largest(in: [3, 9, 2]) ?? 0)               // 9
print(largest(in: ["Kiwi", "Apfel"]) ?? "")      // Kiwi
print(largest(in: [Double]()) ?? -1)             // -1.0

struct Stack<Element> {
    private var items: [Element] = []

    var isEmpty: Bool {
        items.isEmpty
    }

    mutating func push(_ item: Element) {
        items.append(item)
    }

    mutating func pop() -> Element? {
        items.popLast()
    }
}

var numbers = Stack<Int>()
numbers.push(1)
numbers.push(2)
print(numbers.pop() ?? 0)   // 2

var words = Stack<String>()
words.push("Hallo")
print(words.pop() ?? "")    // Hallo
print(words.isEmpty)        // true

Zusammenfassung

• Generics sind Platzhalter für Typen: func swapEnds<T>(_ array: [T]) -> [T].
• Array, Dictionary, Set und Optional sind generische Typen: [Int] ist Array<Int>.
• Einschränkungen wie <T: Equatable> legen fest, was der Platzhalter können muss.
• some View heißt: ein bestimmter View-Typ, den der Compiler kennt, du aber nicht hinschreiben musst.
• some = ein fester, verborgener Typ. any = irgendein Typ, z. B. in gemischten Arrays.
• Eine Funktion mit some muss immer denselben Typ liefern. In SwiftUI hilft @ViewBuilder.
• Du kannst jetzt jede Zeile einer einfachen SwiftUI-View erklären.

Spickzettel

func first<T>(_ a: [T]) -> T? { a.first }
func contains<T: Equatable>(_ v: T, in a: [T]) -> Bool { ... }
struct Box<Content> { let content: Content }

[Int]          == Array<Int>
[String: Int]  == Dictionary<String, Int>
Int?           == Optional<Int>

var body: some View { ... }        // ein verborgener View-Typ
func show(_ a: some Animal)        // == func show<T: Animal>(_ a: T)
let all: [any Animal] = [...]      // gemischte Sammlung