Home Rhyylen
Contatto
 
 
 
Rust Language
Capitolo 31
Pattern matching

L'argomento di questo paragrafo (forse avrei dovuto presentarlo prima, lo so) ci propone una modalità di analisi, destrutturazione e controllo di una grande varietà di dati. Si tratta di uno strumento così duttile che è difficile trovarne una definizione univoca che rende completamente l'idea del suo potenziale d'uso. A livello pratico permette un confronto tra strutture dati e pattern, ricordando un po' l'istruzione switch di altri linguaggi o il case del Pascal ma in formato molto più potente. Inoltre costituisce un valida alternativa ad if-else nei casi più complessi. Insomma osservarne il funzionamento pratico è la cosa migliore.
Una definizione base che ci fa intuire linea generale il funzionamento è il seguente:

match valore {
Pattern1 => azione1,
Pattern2 => azione2,
...
_ => azione_default,
}

Una caratteristica importante del pattern matching è che il suo sviluppo deve essere esaustivo, ovvero non devono essere lasciati "casi irrisolti". Questo è il significato dell'ultimo branch dove quell'identificatore _ ha il senso di definire un'azione di default per tutti i casi non compresi in precedenza. Questo ricorda l'istruzione else finale nel costrutto if-else visto nel paragrafo precedente solo che in questo caso è obbligatorio comprendere tutti i casi possibili, laddove con if è possibile considerare solo alcuni casi.
Iniziamo con un esempio semplice:

  Esempio 31.1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
use std::io;
use std::io::prelude::*;
fn main(){
    print!( "Inserisci un numero: ");
    io::stdout().flush().ok().expect("");
    let mut input01 = String::new();
    io::stdin().read_line(&mut input01);
    let x01: i32 = input01.trim().parse()
   .ok()
    .expect("Voglio un numero!");
    match x01 {
        1 => println!("Numero 1"),
        2 => println!("Numero 2"),
        _ => println!("Altro numero")
    }
}
 
In questo semplice codice viene richiesto all'utente di inserire un  numero. A seconda che tale input sia 1, 2 o un altro numero avremo a video la stampa del relativo messaggio. Come vedete, alla riga 14 abbiamo messo il rastrello che gestisce tutti i casi in cui l'input non sia 1 o 2. Se evidenzaste come commento la riga 14 , escludendola quindi dalla compilazione, il compilatore si farebbe sentire in maniera come sempre molto chiara:

error[E0004]: non-exhaustive patterns: `i32::MIN..=0_i32` and `3_i32..=i32::MAX` not covered
--> r253.rs:11:7
|
11 | match x01 {
| ^^^ patterns `i32::MIN..=0_i32` and `3_i32..=i32::MAX` not covered
|
= note: the matched value is of type `i32`
help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern, a match arm with multiple or-patterns as shown, or multiple match arms
|
13 ~ 2 => println!("Numero 2"),
14 ~ i32::MIN..=0_i32 | 3_i32..=i32::MAX => todo!(),
|

La riga in grassetto vi dice chiaramente che non vi è una gestione esaustiva dei pattern di confronto esistente, dandovi anche ulteriori informazioni aggiuntive. Una precisazione ovvia ma importante è che solo un ramo può venire eseguito, non è possibile che ne vadano in esecuzione due o più. In altri linguaggi c'è modo, attraverso l'uso di label e istruzioni tipo goto, di saltare da un ramo all'altro di strutture come ad esempio gli switch in C#. In Rust, per quanto ne so, questo non è possibile con il  pattern matching e se anche lo fosse non lo farei mai. Pertanto non è neanche possibile il fall-through (non servono i break) e quando viene eseguito un ramo il controllo esce immediatamente dal match. Un'altra osservazione è che è possibile lasciare un ramo senza alcuna azione da compiere, ad esempio

1 => {},

non fa nulla ed è perfettamente legale.

Una prima domanda che potreste farvi è come gestire il caso in cui vi siano più istruzioni nei rami che andranno in esecuzione. Niente di nuovo, si usano le parentesi graffe, come al solito:

pattern => {
       istruzioni
       },

con la virgola dopo la parentesi graffa di chiusura, ad esempio potreste modificare la riga 12 come segue:

1 => {          
    println!("Numero 1");          
    println!("ovvero il primo numero");    
},

Un altro caso comune è quello in cui ogni ramo debba prendere in esame più di un valore, ad esempio un range o insieme anche non contiguo.
Vediamo qualche esempio, tralascio la parte di richiesta di input che appesantisce il codice, eventualmente potete sempre riprendere tale parte dal primo esempio:

  Esempio 31.2
1
2
3
4
5
6
7
8
fn main() {
    let x = 15; // Provate a cambiare questo valore per vedere diversi output
    match x {
        n if (1..=10).contains(&n) => println!("x è tra 1 e 10"),
        n if (2..=20).contains(&n) => println!("x è tra 2 e 20"),
        _ => println!("x non è compreso negli intervalli specificati")
    }
}

Come si vede alle righe 4 e 5 sono stati inseriti dei range (vedi capitolo) di valori e cambiando il valore alla riga 2 otterrete output diversi. Le righe 4 e 5 presentano invece due varibiabili, quelle 'n' che trovate all'inizio che in congiunzione con if costituiscono le cosiddette "guardie" del pattern. La variabile n cattura il valore di x e lo utilizza per verificare la condizione di appartenenza al range tramite il metodo contains proprio dei range. Un altro frammento di codice che illustra l'uso di una guardia è il seguente:

let x = 5;
match x {
  n if n > 0 => println!("{} è positivo", n),
  n => println!("{} non è positivo", n),
}

Questo punto è piuttosto interessante e direi che merita un altro esempio:
  Esempio 31.3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
fn main() {
    let points = [(0, 0), (5, 5), (10, -3)];
    for (x, y) in points.iter() {
        match (x, y) {
            (0, 0) => println!("Il punto è all'origine."),
            (x, y) if x > &0 && y > &0 => println!
            ("Il punto ({}, {}) è nel primo quadrante.", x, y),
            (x, y) if x < &0 && y > &0 => println!
            ("Il punto ({}, {}) è nel secondo quadrante.", x, y),
            (x, y) if x < &0 && y < &0 => println!
            ("Il punto ({}, {}) è nel terzo quadrante.", x, y),
            (x, y) if x > &0 && y < &0 => println!
            ("Il punto ({}, {}) è nel quarto quadrante.", x, y),
            (_, _) => println!("Il punto ({}, {}) è su un asse.", x, y),
        }
    }
}

Altro caso ancora è quello in cui il pattern è costituito da una serie di valori casuali:

  Esempio 31.4
1
2
3
4
5
6
7
8
9
10
fn main() {
    let x01 = 3; // Provate a cambiare questo valore per vedere diversi output
    match x01 {
        1 | 2 | 3 => {
                       println!("Hai inserito uno dei primi 3 numeri");
                       print!("Sei astuto...")
                     },
        _ => print!("Tutto il resto..."),
        }  
}

usando l'operatore | (or) risolviamo il problema.
Anche da un pattern matching Rust fa uscire il valore, siamo pur sempre di fronte ad una espressione in questo linguaggio, valore che possiamo attribuire ad esempio ad una variabile. Modifichiamo l'esempio precedente:

  Esempio 31.5
1
2
3
4
5
6
7
8
fn main() {
    let x01 = 3; // Prova a cambiare questo valore per vedere diversi output
    let s01 = match x01 {
        1 | 2 | 3 => "Hai inserito uno dei primi 3 numeri",
        _ => "Tutto il resto...",
        };
    println!("{}", s01)  
}

Alla riga 3 abbiamo provveduto ad assegnare alla variabile s01 il risultato del match.
A questo punto, stante la grande importanza e utilità di questo argomento, riprendiamo procedendo in maniera strutturale esaminando come lavorare con alcuni costrutti di uso comune, considerando che la materia dovrebbe essere abbastanza chiara. Iniziamo con una semplice operazione su un enumerativo:

  Esempio 31.6
1
2
3
4
5
6
7
8
9
10
11
12
13
enum Semaforo {
    Rosso,
    Verde,
    Giallo,
}
fn main() {
    let sf01 = Semaforo::Verde;
    match sf01 {
        Semaforo::Verde => println!("Puoi passare"),
        Semaforo::Rosso => println!("Fermati"),
        Semaforo::Giallo => println!("Occhio a dove sei"),
    }
}

Vediamo ora un semplice esempio che coinvolge una ennupla:

  Esempio 31.7
1
2
3
4
5
6
7
8
9
10
11
fn main() {
    let my_tuple = (10, 20, 30);
    // Ora uso il pattern matching per accedere direttamente agli elementi e manipolarli
    match my_tuple {
        (a, b, c) => {
            let sum = a + b + c;
            let product = a * b * c;
            println!("La somma degli elementi è {}, e il prodotto è {}.", sum, product);
        },
    }
}

E vediamone un ulteriore che coinvolge una struct:

  Esempio 31.8
1
2
3
4
5
6
7
8
9
10
11
struct Punto {
    x: i32,
    y: i32,
}
fn main() {
    let p01 = Punto{x: 0, y: 8};
    match p01 {
        Punto{x:0,y:8} => println!("colpito"),
        _ => println!("acqua"),
    }
}

E infine vediamome uno un po' più complesso che riassume un po' di cose.

  Esempio 31.9
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
enum Color {
    Red,
    Green,
    Blue,
    Rgb(u8, u8, u8), // Rappresenta un colore personalizzato con valori RGB
    Cmyk { cyan: u8, magenta: u8, yellow: u8, black: u8 }, // Rappresenta un colore in formato CMYK
}
fn describe_color(color: Color) {
    match color {
        Color::Red => println!("Il colore è Rosso"),
        Color::Green => println!("Il colore è Verde"),
        Color::Blue => println!("Il colore è Blu"),
        Color::Rgb(r, g, b) => {
            println!("Colore RGB con valori Red: {}, Green: {}, Blue: {}", r, g, b);
        },
        Color::Cmyk { cyan, magenta, yellow, black } => {
            println!("Colore CMYK: valori Cyan: {}, Magenta: {}, Yellow: {}, Black: {}", cyan, magenta, yellow, black);
        },
    }
}
fn main() {
    let red = Color::Red;
    describe_color(red);
    let custom_color = Color::Rgb(120, 65, 75);
    describe_color(custom_color);
    let cmyk_color = Color::Cmyk { cyan: 0, magenta: 255, yellow: 255, black: 0 };
    describe_color(cmyk_color);
}


Come si può vedere il matching aiuta a selezionare in maniera elegante le diverse scelte. In questo ultimo caso non serve il ramo "rastrello" in quanto tutte le eventualità previste dall'enumerativo sono contemplate nell'insieme dei vari branch. Nell'esempio vediamo ancora come lavorare con enumerativi e strutture. Tutti gli esempi presentati ritengo siano abbastanza semplici da capire, tranne l'ultimo la cui analisi lascio un po' tipo esercizio conclusione.
Concludiamo, a proposito dell'identficatore _ che esso non ha solo il ruolo di introdurre il rastrello finale che fa su tutto quello che resta, esso è utile anche per ignorare alcuni valori che non sono di interesse. Riprendo l'esempio che si trova anche sul sito ufficiale in quanto semplice ed esplicativo:
  Esempio 31.10
1
2
3
4
5
6
7
8
fn main() {
    let numeri = (2, 4, 8, 16, 32);
    match numeri {
        (primo, _, terzo, _, quinto) => {
            println!("3 numeri: {primo}, {terzo}, {quinto}")
        }
    }
}

Una variante di questa esclusione fa uso dell'operatore .. (due punti consecutivi, si vedono poco)

  Esempio 31.11
1
2
3
4
5
6
7
8
fn main() {
     let numeri = (2, 4, 8, 16, 32);
     match numeri {
        (primo, .., quinto) => {
        println!("estremi {primo}, {quinto}")
    }
  }
}


Come si vede il materiale è davvero ampio e ulteriori esempi li abbiamo visti e li vedremo ancora, ma questo perchè quando si parla di pattern matching si parla di un meccanismo davvero trasversale per il linguaggio.