Pattern Matching

Tupel-Matching mit Guard

fn main() {
    let x = (0, 1);
    match x {
        (_, y) if y == 0 => println!("A"),
        (0, _) => println!("B"),
        _ => println!("C")
    }
}

1. Kompiliert
2. Kompiliert nicht

Prüfen

Der erste Zweig matcht y = 1 , was bedeutet, dass y != 0 , daher schlägt das Muster fehl. Der zweite Zweig erfordert, dass x == 0 ist, was wahr ist, daher ist das Muster erfolgreich.

---

Gültige Array-Muster

Betrachten Sie das folgende Programm:

let a = [(0, 1)];
let ?? = a;

Welche der folgenden sind gültige Muster, die den Platzhalter ?? ersetzen könnten?

1. [..]

2. [(n, ..)]

3. _

4. (_, n)

Prüfen

Das Muster (_, n) ist nicht gültig, da a ein Array von Tupeln ist, nicht ein Tupel selbst.

---

Ambiguität bei Array-Mustern

fn main() {
    let x = Some(&[0, 1]);
    match x {
        Some(&[.., 1, ..]) => println!("A"),
        Some(&[0, 1]) | None => println!("B"),
        _ => println!("C")
    }
}

1. Kompiliert
2. Kompiliert nicht

Prüfen

Es ist nicht gültig, .. auf beiden Seiten eines Wertes zu verwenden, da es mehrdeutig ist, auf welches Array-Element Bezug genommen wird.

---

Struktur-Muster mit Bereich

Angenommen, wir haben einen Typ Point mit der folgenden Definition:

struct Point {
    x: i32,
    y: i32
}

Angesichts des folgenden Musters:

Point { x: x @ 0 ..= 5, y } if x + y != 0

Welche der folgenden Werte passen zu diesem Muster?

1. Point { x: 3, y: -3 }

2. Point { x: -1, y: 2 }

3. Point { x: 5, y: -4 }

4. Point { x: 0, y: 1 }

Prüfen

Dieses Muster spezifiziert, dass x zwischen 0 und 5 (einschließlich) liegen muss und dass x + y != 0 . Daher sind Point { x: 5, y: -4 } und Point { x: 0, y: 1 } gültig, während Point { x: -1, y: 2 } und Point { x: 3, y: -3 } es nicht sind.

---