Il Linguaggio di Programmazione Rust

di Steve Klabnik, Carol Nichols, and Chris Krycho, con contributi della Communiy Rust

Questa versione del testo presuppone l’utilizzo di Rust 1.85.0 (rilasciato il 2025-02-17) o successivo con edition = "2024" nel file Cargo.toml di tutti i progetti per configurarli in modo da utilizzare gli idiomi dell’edizione 2024 di Rust. Consulta la sezione “Installazione” del Capitolo 1 per installare o aggiornare Rust, e vedi l’Appendice E per informaszioni sulle varie edizioni.

Il libro originale in inglese in formato HTML si trova su https://doc.rust-lang.org/stable/book/ oppure offline su installazioni di Rust fatte tramite rustup; esegui rustup doc --book per visualizzarlo.

Sono disponibili alcune traduzioni fatte dalla community.

Questo testo, in inglese, è disponibile anche come libro cartaceo o ebook da No Starch Press.

🚨 Vuoi provare un’esperienza di apprendimento più interattiva? Prova una versione modificata del Libro (in inglese), con aggiunta di quiz, sottolineature, visualizzazioni e molto altro: https://rust-book.cs.brown.edu

Prefazione

Il linguaggio di programmazione Rust ha fatto molta strada in pochi anni, dalla sua creazione e incubazione da parte di una piccola e giovane comunità di appassionati, fino a diventare uno dei linguaggi di programmazione più amati e richiesti al mondo. Ripensando a tutto ciò, era inevitabile che la potenza e le promesse di Rust attirassero l’attenzione e trovassero spazio nella programmazione di sistemi. Quello che non era scontato era la crescita globale dell’interesse e dell’innovazione che ha permeato le comunità open source, catalizzando un’adozione su larga scala in vari settori.

Oggi è facile indicare le meravigliose caratteristiche che Rust offre per spiegare questa esplosione di interesse e adozione. Chi non vorrebbe sicurezza nella gestione della memoria, e prestazioni elevate, e un compilatore amichevole, e ottimi strumenti, insieme a tante altre fantastiche funzionalità? Il linguaggio Rust che vedi oggi combina anni di ricerca nella programmazione di sistemi con la saggezza pratica di una comunità vivace e appassionata. Questo linguaggio è stato progettato con uno scopo e realizzato con cura, offrendo agli sviluppatori uno strumento che rende più facile scrivere codice sicuro, veloce e affidabile.

Ma ciò che rende Rust davvero speciale sono le sue radici nel dare potere a te, l’utente, per raggiungere i tuoi obiettivi. Questo è un linguaggio che vuole che tu abbia successo, e il principio di empowerment attraversa il cuore della comunità che costruisce, mantiene e promuove questo linguaggio. Dall’edizione precedente di questo testo definitivo, Rust si è ulteriormente sviluppato in un linguaggio davvero globale e affidabile. Il Rust Project è ora robustamente supportato dalla Rust Foundation, che investe anche in iniziative chiave per garantire che Rust sia sicuro, stabile e sostenibile.

Questa edizione di The Rust Programming Language è un aggiornamento completo, che riflette l’evoluzione del linguaggio nel corso degli anni e fornisce nuove informazioni preziose. Ma non è solo una guida alla sintassi e alle librerie: è un invito a unirti a una comunità che valorizza qualità, prestazioni e design riflessivo. Che tu sia uno sviluppatore esperto che vuole esplorare Rust per la prima volta o un Rustacean esperto che cerca di affinare le proprie abilità, questa edizione offre qualcosa per tutti.

Il viaggio di Rust è stato caratterizzato da collaborazione, apprendimento e iterazione. La crescita del linguaggio e del suo ecosistema è un riflesso diretto della comunità vibrante e diversificata che lo sostiene. I contributi di migliaia di sviluppatori, dai progettisti del linguaggio ai collaboratori occasionali, sono ciò che rende Rust uno strumento così unico e potente. Prendendo in mano questo libro, non stai solo imparando un nuovo linguaggio di programmazione: stai entrando a far parte di un movimento per rendere il software migliore, più sicuro e più piacevole da usare.

Benvenuto nella comunità di Rust!

• Bec Rumbul, Direttore Esecutivo della Rust Foundation

Introduzione

Nota: questa edizione del libro in inglese è identica a The Rust Programming Language, disponibile in formato cartaceo ed ebook presso No Starch Press.

Benvenuti a Il Linguaggio di Programmazione Rust, un libro introduttivo su Rust. Il linguaggio di programmazione Rust vi aiuta a scrivere software più veloce e affidabile. L’ergonomia di alto livello e il controllo di basso livello sono spesso in contrasto nella progettazione dei linguaggi di programmazione; Rust sfida questo conflitto. Grazie al bilanciamento tra potenti capacità tecniche e un’ottima esperienza di sviluppo, Rust vi offre la possibilità di controllare i dettagli di basso livello (come l’utilizzo della memoria) senza tutte le difficoltà tradizionalmente associate a tale controllo.

A Chi È Rivolto Rust

Rust è ideale per molte persone per una serie di motivi. Diamo un’occhiata ad alcuni dei gruppi più importanti.

Team di Sviluppatori

Rust si sta dimostrando uno strumento produttivo per la collaborazione tra grandi team di sviluppatori con diversi livelli di conoscenza della programmazione di sistemi. Il codice di basso livello è soggetto a vari bug subdoli, che nella maggior parte degli altri linguaggi possono essere individuati solo attraverso test approfonditi e un’attenta revisione del codice da parte di sviluppatori esperti. In Rust, il compilatore svolge un ruolo di gatekeeper rifiutando di compilare il codice con questi bug subdoli, compresi i bug di concorrenza. Lavorando a fianco del compilatore, il team può dedicare il proprio tempo a concentrarsi sulla logica del programma piuttosto che a cercare i bug.

Rust porta anche strumenti di sviluppo contemporanei nel mondo della programmazione di sistemi:

• Cargo, il gestore di dipendenze e strumento di compilazione integrato, rende l’aggiunta, la compilazione e la gestione delle dipendenze semplice e coerente in tutto l’ecosistema Rust.
• Lo strumento di formattazione rustfmt garantisce uno stile di programmazione coerente tra gli sviluppatori.
• Il Server LSP del Linguaggio Rust potenzia l’integrazione dell’ambiente di sviluppo integrato (IDE) per il completamento del codice e i messaggi di errore in linea.

Utilizzando questi e altri strumenti dell’ecosistema Rust, gli sviluppatori possono essere produttivi mentre scrivono codice a livello di sistema.

Studenti

Rust è rivolto agli studenti e a coloro che sono interessati a conoscere i concetti di sistema. Utilizzando Rust, molte persone hanno imparato a conoscere argomenti come lo sviluppo di sistemi operativi. La comunità è molto accogliente e felice di rispondere alle domande degli studenti. Attraverso iniziative come questo libro, i team di Rust vogliono rendere i concetti di sistema più accessibili a un maggior numero di persone, soprattutto a chi è alle prime armi con la programmazione.

Aziende

Centinaia di aziende, grandi e piccole, utilizzano Rust in produzione per una serie di compiti, come strumenti a riga di comando, servizi web, strumenti DevOps, dispositivi embedded, analisi e transcodifica di audio e video, cripto-valute, bioinformatica, motori di ricerca, applicazioni per l’Internet delle cose, machine learning e persino parti importanti del browser web Firefox.

Sviluppatori Open Source

Rust è per le persone che vogliono costruire il linguaggio di programmazione Rust, la comunità, gli strumenti per gli sviluppatori e le librerie. Ci piacerebbe che tu contribuissi al linguaggio Rust.

Persone che Apprezzano la Velocità e la Stabilità

Rust è per le persone che desiderano velocità e stabilità in un linguaggio. Per velocità intendiamo sia la velocità con cui il codice Rust può essere eseguito, sia la velocità con cui Rust ti permette di scrivere programmi. I controlli del compilatore di Rust assicurano la stabilità quando si aggiungono funzionalità e riscrive il codice, in contrasto con la fragilità del codice legacy dei linguaggi senza questi controlli, che spesso gli sviluppatori hanno paura di modificare. Puntando ad astrazioni a costo zero, ovvero funzionalità di livello superiore che vengono compilate in codice di livello inferiore con la stessa velocità del codice scritto manualmente, Rust cerca di rendere il codice sia sicuro che veloce.

Il linguaggio Rust spera di supportare anche molti altri utenti; quelli citati qui sono solo alcuni dei maggiori interessati. Nel complesso, la più grande ambizione di Rust è quella di eliminare i compromessi che i programmatori hanno accettato per decenni, offrendo sicurezza e produttività, velocità e ergonomia. Prova Rust e vedi se le sue scelte funzionano per te.

Per Chi È Questo Libro

Questo libro presuppone che tu abbia scritto codice in un altro linguaggio di programmazione, ma non fa alcuna ipotesi su quale sia. Abbiamo cercato di rendere il materiale ampiamente accessibile a coloro che provengono da un’ampia varietà di background di programmazione. Non dedichiamo molto tempo a parlare di cosa sia la programmazione o di come pensarla. Se sei completamente nuovo alla programmazione, è meglio che tu legga un libro che fornisca un’introduzione specifica alla programmazione.

Come Utilizzare Questo Libro

In generale, questo libro presuppone che tu lo legga in sequenza, dall’inizio alla fine. I capitoli più avanzati si basano sui concetti dei capitoli precedenti, e i capitoli iniziali potrebbero non approfondire un determinato argomento, che invece viene sviluppato più approfonditamente in un capitolo successivo.

In questo libro troverai due tipi di capitoli: i capitoli concettuali e i capitoli di progetto. Nei capitoli concettuali, imparerai a conoscere un aspetto di Rust. Nei capitoli di progetto, costruiremo insieme dei piccoli programmi, applicando ciò che hai imparato finora. I capitoli 2, 12 e 21 sono capitoli di progetto; il resto sono capitoli concettuali.

Il Capitolo 1 spiega come installare Rust, come scrivere un programma “Hello, world!” e come utilizzare Cargo, il gestore di pacchetti e lo strumento di compilazione di Rust. Il Capitolo 2 è un’introduzione pratica alla scrittura di un programma in Rust, con la creazione di un gioco di indovinelli con i numeri. Qui trattiamo i concetti ad un livello più superficiale e i capitoli successivi forniranno ulteriori dettagli. Se vuoi sporcarti subito le mani, il Capitolo 2 è dove puoi iniziare. Se invece sei uno studente particolarmente meticoloso, che preferisce imparare ogni dettaglio prima di passare al successivo, potresti voler saltare il Capitolo 2 e passare direttamente al Capitolo 3 che tratta le caratteristiche di Rust simili a quelle di altri linguaggi di programmazione; dopo, potrai ritornare al Capitolo 2 se vorrai applicare in un progetto quanto appreso.

Nel Capitolo 4 imparerai a conoscere il sistema di proprietà (ownership d’ora in poi) di Rust. Il Capitolo 5 parla di strutture e metodi, mentre il Capitolo 6 tratta le enumerazioni, le espressioni match e il costrutto della struttura di controllo if let. Utilizzerai le strutture e le enumerazioni per creare type personalizzati in Rust.

Nel Capitolo 7 imparerai a conoscere il sistema dei moduli di Rust, le regole di visibilità per l’organizzazione del codice e la sua Application Programming Interface (API) pubblica. Il Capitolo 8 tratta alcune strutture di dati comuni che la libreria standard mette a disposizione, come vettori, stringhe e mappe hash. Il Capitolo 9 esplora la filosofia e le tecniche di gestione degli errori di Rust.

Il Capitolo 10 approfondisce i generici, i tratti e la longevità (traits e lifetime d’ora in poi), che ti danno la possibilità di definire codice applicabile a più tipologie di dato. Il Capitolo 11 è dedicato ai test, che anche con le garanzie di sicurezza di Rust sono necessari per garantire la correttezza della logica del tuo programma. Nel Capitolo 12, costruiremo la nostra implementazione di un sottoinsieme di funzionalità dello strumento da riga di comando grep, che cerca il testo all’interno dei file. Per questo, utilizzeremo molti dei concetti discussi nei capitoli precedenti.

Il Capitolo 13 esplora le chiusure e gli iteratori: caratteristiche di Rust che derivano dai linguaggi di programmazione funzionale. Nel Capitolo 14 esamineremo Cargo in modo più approfondito e parleremo delle migliori pratiche per condividere le tue librerie con altri. Il Capitolo 15 parla dei puntatori intelligenti che la libreria standard mette a disposizione e dei traits che ne consentono la funzionalità.

Nel Capitolo 16, esamineremo diversi modelli di programmazione concorrente e parleremo di come Rust ti aiuti a programmare con più sotto-processi (thread d’ora in poi) senza paura. Nel Capitolo 17, esploreremo la sintassi async e await di Rust, insieme a task, futures e stream, e il modello di concomitanza leggera che consentono.

Il Capitolo 18 analizza come gli idiomi di Rust si confrontano con i principi della programmazione orientata agli oggetti che potresti conoscere. Il Capitolo 19 è un riferimento ai pattern e al loro riconoscimento (pattern matching), che sono modi potenti di esprimere idee nei programmi Rust. Il Capitolo 20 contiene una varietà di argomenti di interesse, tra cui Rust non sicuro (unsafe Rust d’ora in poi), macro e altre informazioni su longevità, trait, tipologie (type), funzioni e chiusure.

Nel Capitolo 21, completeremo un progetto in cui implementeremo un server web multi-thread di basso livello!

Infine, alcune appendici contengono informazioni utili sul linguaggio in un formato meno strutturato. L’Appendice A tratta delle parole chiave di Rust, l’Appendice B degli operatori e dei simboli di Rust, l’Appendice C dei trait derivabili forniti dalla libreria standard, l’Appendice D di alcuni utili strumenti di sviluppo e l’Appendice E delle varie edizioni di Rust. Nell’Appendice F puoi trovare un elenco delle traduzioni del libro, mentre nell’Appendice G si parlerà di come viene realizzato Rust e di cosa sia la nightly Rust.

Non c’è un modo sbagliato di leggere questo libro: se vuoi andare avanti, fallo pure! Potresti dover tornare indietro ai capitoli precedenti se ti senti confuso, ma fai quello che va bene per te.

Una parte importante del processo di apprendimento di Rust consiste nell’imparare a leggere i messaggi di errore visualizzati dal compilatore: questi ti guideranno verso un codice funzionante. Per questo motivo, ti forniremo molti esempi che non si compilano insieme al messaggio di errore che il compilatore ti mostrerà in ogni situazione. Sappi che se inserisci ed esegui un esempio a caso, potrebbe non compilarsi! Assicurati di leggere il testo circostante per capire se l’esempio che stai cercando di eseguire è destinato a dare un errore. Nella maggior parte delle situazioni, ti guideremo alla correzione di questi errori che comportano la mancata compilazione. Ferris ti aiuterà anche a distinguere il codice che non è destinato a funzionare:

Ferris	Significato
	Questo codice non si compila!
	Questo codice genera panic!
	Questo codice non funziona come dovrebbe.

Nella maggior parte dei casi, ti guideremo alla versione corretta di qualsiasi codice che non si compila.

Codice Sorgente

I file sorgente da cui è stato generato questo libro si trovano su GitHub per la versione italiana.

La versione originale in inglese si trova anch’essa su GitHub.

Primi Passi

Iniziamo il tuo viaggio in Rust! C’è molto da imparare, ma ogni viaggio inizia da qualche parte. In questo capitolo parleremo di come:

• Installare Rust su Linux, macOS e Windows
• Scrivere un programma che stampi Hello, world!
• Utilizzare cargo, il gestore di pacchetti e il sistema di compilazione di Rust

Installazione

Il primo passo è quello di installare Rust. Scaricheremo Rust attraverso rustup, uno strumento a riga di comando per gestire le versioni di Rust e gli strumenti associati. Per il download è necessaria una connessione a internet.

Nota: Se per qualche motivo preferisci non utilizzare rustup, consulta la pagina Altri metodi di installazione di Rust per ulteriori opzioni.

I passaggi seguenti installano l’ultima versione stabile del compilatore Rust. Le garanzie di stabilità di Rust assicurano che tutti gli esempi del libro che vengono compilati continueranno a essere compilati anche con le versioni più recenti di Rust. L’output potrebbe differire leggermente da una versione all’altra perché Rust spesso migliora i messaggi di errore e gli avvertimenti. In altre parole, qualsiasi versione più recente e stabile di Rust che installerai utilizzando questi passaggi dovrebbe funzionare come previsto con il contenuto di questo libro.

Installare rustup su Linux o macOS

Se stai usando Linux o macOS, apri un terminale e inserisci il seguente comando:

$ curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh

Il comando scarica uno script e avvia l’installazione dello strumento rustup, che installa l’ultima versione stabile di Rust. Potrebbe esserti richiesta la tua password. Se l’installazione ha successo, apparirà la seguente riga:

Rust is installed now. Great!

Avrai anche bisogno di un linker, che è un programma che Rust utilizza per unire i suoi output compilati in un unico file. È probabile che tu ne abbia già uno. Se ottieni errori di linker, dovresti installare un compilatore C, che di solito include un linker. Un compilatore C è utile anche perché alcuni pacchetti comuni di Rust dipendono dal codice C e avranno bisogno di un compilatore C.

Su macOS, puoi ottenere un compilatore C eseguendo:

$ xcode-select --install

Gli utenti Linux dovrebbero generalmente installare GCC o Clang, in base alla documentazione della loro distribuzione. Ad esempio, se utilizzi Ubuntu, puoi installare il pacchetto build-essential.

Installare rustup su Windows

Su Windows, vai su https://www.rust-lang.org/tools/install e segui le istruzioni per installare Rust. A un certo punto dell’installazione, ti verrà richiesto di installare Visual Studio, che fornisce un linker e le librerie native necessarie per compilare i programmi. Se hai bisogno di aiuto per questo passaggio, consulta https://rust-lang.github.io/rustup/installation/windows-msvc.html.

Il resto di questo libro utilizza comandi che funzionano sia in cmd.exe che in PowerShell. Se ci sono differenze specifiche, ti spiegheremo quale utilizzare.

Risolvere i Problemi

Per verificare se Rust è stato installato correttamente, apri il terminale e inserisci questo comando:

$ rustc --version

Dovresti vedere il numero di versione, l’hash del commit e la data del commit dell’ultima versione stabile rilasciata, nel seguente formato:

rustc x.y.z (abcabcabc yyyy-mm-dd)

Se vedi queste informazioni, hai installato Rust con successo! Se non vedi queste informazioni, controlla che Rust sia nella tua variabile di sistema %PATH% come segue.

Su Windows con CMD, usa:

> echo %PATH%

In PowerShell, usa:

> echo $env:Path

In Linux e macOS, usa:

$ echo $PATH

Se sembra essere tutto in ordine ma Rust non funziona ancora, ci sono diversi posti in cui puoi trovare aiuto. Scopri come metterti in contatto con altri Rustaceani (Rustacean d’ora in poi) (uno stupido soprannome con cui ci chiamiamo) sulla pagina della comunità.

Aggiornare e Disinstallare

Una volta che Rust è stato installato tramite rustup, l’aggiornamento a una nuova versione è semplice. Dalla tua shell, esegui il seguente script di aggiornamento:

$ rustup update

Per disinstallare Rust e rustup, esegui il seguente script di disinstallazione dalla tua shell:

$ rustup self uninstall

Leggere la Documentazione in Locale

L’installazione di Rust include anche una copia locale della documentazione per poterla leggere offline. Esegui rustup doc per aprire la documentazione locale nel tuo browser.

Ogni qual volta hai un dubbio su un type o una funzione fornita dalla libreria standard e non sei sicuro di cosa faccia o di come usarla, usa la documentazione delle API per scoprirlo!

Usare Editor di Testo e IDE

Questo libro non fa alcuna ipotesi sugli strumenti che utilizzi per scrivere il codice Rust. Qualsiasi editor di testo è in grado di fare il suo lavoro! Tuttavia, molti editor di testo e IDE (ambienti di sviluppo integrati) hanno un supporto integrato per Rust. Puoi sempre trovare un elenco abbastanza aggiornato di molti editor e IDE nella pagina degli strumenti sul sito web di Rust.

Lavorare Offline con Questo Libro

In diversi esempi, utilizzeremo pacchetti Rust oltre alla libreria standard. Per lavorare a questi esempi, dovrai disporre di una connessione a internet o aver scaricato le dipendenze in anticipo. Per scaricare le dipendenze in anticipo, puoi eseguire i seguenti comandi. (Spiegheremo cos’è cargo e cosa fa ciascuno di questi comandi in dettaglio più avanti)

$ cargo new get-dependencies
$ cd get-dependencies
$ cargo add rand@0.8.5 trpl@0.2.0

In questo modo i download di questi pacchetti verranno memorizzati nella cache e non sarà necessario scaricarli in seguito. Una volta eseguito questo comando, non dovrai conservare la cartella get-dependencies. Se hai eseguito questo comando, puoi aggiungere il flag --offline quando userai il comando cargo nel resto del libro per utilizzare queste versioni memorizzate nella cache invece di scaricarle da internet in quel momento.

Hello, World!

Ora che hai installato Rust, è il momento di scrivere il tuo primo programma Rust. Quando si impara un nuovo linguaggio, è consuetudine scrivere un piccolo programma che stampi sullo schermo il testo Hello, world!

Nota: questo libro presuppone una certa familiarità di base con la riga di comando. Rust non ha particolari esigenze per quanto riguarda l’editing o gli strumenti o dove risiede il tuo codice, quindi se preferisci usare IDE invece della riga di comando, sentiti libero di usare il tuo IDE preferito. Molti IDE ora hanno un certo grado di supporto per Rust; controlla la documentazione dell’IDE per maggiori dettagli. Il team di Rust si è concentrato sull’integrazione ottima con gli IDE tramite rust-analyzer. Vedi Appendice D per maggiori dettagli.

Impostare una Directory dei Progetti

Inizierai creando una directory per memorizzare il tuo codice Rust. Per Rust non è importante dove si trovi il tuo codice, ma per gli esercizi e i progetti di questo libro ti consigliamo di creare una cartella progetti nella tua home directory e di tenere tutti i tuoi progetti lì.

Apri un terminale e inserisci i seguenti comandi per creare una cartella progetti e una cartella per il progetto “Hello, world!” all’interno della directory progetti.

Per Linux, macOS, e PowerShell su Windows, digita questo:

$ mkdir ~/progetti
$ cd ~/progetti
$ mkdir hello_world
$ cd hello_world

Per Windows con CMD, digita questo:

> mkdir "%USERPROFILE%\progetti"
> cd /d "%USERPROFILE%\progetti"
> mkdir hello_world
> cd hello_world

Programma Rust Basilare

Adesso crea un nuovo file sorgente e chiamalo main.rs. I file di Rust terminano sempre con l’estensione .rs. Se usi più di una parola nel nome del file, la convenzione è di usare un trattino basso per separarle. Ad esempio, usa hello_world.rs piuttosto che helloworld.rs.

Ora apri il file main.rs che hai appena creato e inserisci il codice del Listato 1-1.

fn main() {
    println!("Hello, world!");
}

Salva il file e torna alla finestra del terminale alla cartella ~/progetti/hello_world . Su Linux o macOS, inserisci i seguenti comandi per compilare ed eseguire il file:

$ rustc main.rs
$ ./main
Hello, world!

Su Windows, inserisci il comando .\main invece di ./main:

> rustc main.rs
> .\main
Hello, world!

Indipendentemente dal sistema operativo, la stringa Hello, world! dovrebbe essere stampata sul terminale. Se non vedi questo output, consulta la sezione “Risolvere i Problemi” nel capitolo Installazione per trovare aiuto.

Se Hello, world! è stato stampato, congratulazioni! Hai ufficialmente scritto un programma Rust. Questo ti rende un programmatore Rust, benvenuto!

Anatomia di un Programma Rust

Esaminiamo in dettaglio questo programma “Hello, world!”. Ecco il primo pezzo del puzzle:

fn main() {

}

Queste righe definiscono una funzione chiamata main. La funzione main è speciale: è sempre il primo codice che viene eseguito in ogni eseguibile Rust. Qui, la prima riga dichiara una funzione chiamata main che non ha parametri e non restituisce nulla. Se ci fossero dei parametri, andrebbero dentro le parentesi (()).

Il corpo della funzione è racchiuso da {}. Rust richiede parentesi graffe intorno a tutti i corpi delle funzioni. È buona norma posizionare la parentesi graffa di apertura sulla stessa riga della dichiarazione della funzione, aggiungendo uno spazio in mezzo.

Nota: se vuoi attenerti a uno stile standard in tutti i progetti Rust, puoi usare uno strumento di formattazione automatica chiamato rustfmt per formattare il tuo codice in un particolare stile (maggiori informazioni su rustfmt in Appendice D). Il team di Rust ha incluso questo strumento nella distribuzione standard di Rust, come rustc, quindi dovrebbe essere già installato sul tuo computer!

Il corpo della funzione main contiene il seguente codice:

#![allow(unused)]
fn main() {
println!("Hello, world!");
}

Questa riga fa tutto il lavoro di questo piccolo programma: stampa il testo sullo schermo. Ci sono tre dettagli importanti da notare.

Innanzitutto, println! chiama una macro di Rust. Se invece avesse chiamato una funzione, sarebbe stata inserita come println (senza il !). Le macro di Rust sono un modo per scrivere codice che genera codice per estendere la sintassi di Rust e ne parleremo in modo più dettagliato nel Capitolo 20. Per ora, ti basterà sapere che usare una ! significa che stai chiamando una macro invece di una normale funzione e che le macro non seguono sempre le stesse regole delle funzioni.

In secondo luogo, vedi la stringa "Hello, world!" che viene passata come argomento a println! e la stringa viene stampata sullo schermo.

In terzo luogo, terminiamo la riga con un punto e virgola (;), che indica che questa espressione è terminata e che la prossima è pronta per iniziare. La maggior parte delle righe di codice Rust terminano con un punto e virgola

Compilare ed Eseguire

Hai appena eseguito un programma appena creato, quindi esaminiamo ogni fase del processo.

Prima di eseguire un programma Rust, devi compilarlo con il compilatore Rust inserendo il comando rustc e passandogli il nome del tuo file sorgente, in questo modo:

$ rustc main.rs

Se hai un background in C o C++, noterai che è simile a gcc o clang. Dopo aver compilato con successo, Rust produce un eseguibile binario.

Su Linux, macOS e PowerShell su Windows, puoi vedere l’eseguibile usando il comando ls nella tua shell:

$ ls
main  main.rs

Su Linux e macOS, vedrai due file. Con PowerShell su Windows, vedrai gli stessi tre file che vedresti usando CMD. Con CMD su Windows, inserisci il seguente comando:

> dir /B %= the /B option says to only show the file names =%
main.exe
main.pdb
main.rs

Questo mostra il file del codice sorgente con estensione .rs, il file eseguibile (main.exe su Windows, solo main su tutte le altre piattaforme) e, se usi Windows, un file contenente informazioni di debug con estensione .pdb. Ora puoi eseguire il file main o main.exe, in questo modo:

$ ./main # or .\main su Windows

Se il tuo main.rs è il tuo programma “Hello, world!”, questa riga stampa Hello, world! sul tuo terminale.

Se hai più familiarità con un linguaggio dinamico, come Ruby, Python o JavaScript, potresti non essere abituato alla compilazione e all’esecuzione di un programma come fasi separate. Rust è un linguaggio compilato in anticipo, il che significa che puoi compilare un programma e dare l’eseguibile a qualcun altro, che potrà eseguirlo anche senza avere Rust installato. Se dai a qualcuno un file .rb, .py o .js, deve avere un’implementazione di Ruby, Python o JavaScript installata (rispettivamente). Ma in questi linguaggi, hai bisogno di un solo comando per compilare ed eseguire il tuo programma. Sono compromessi diversi per ogni linguaggio di programmazione.

La semplice compilazione con rustc va bene per i programmi semplici, ma quando il tuo progetto cresce, vorrai gestire tutte le opzioni e rendere facile la condivisione del tuo codice. A seguire, ti presenteremo lo strumento Cargo, che ti aiuterà a scrivere programmi Rust veri e propri.

Hello, Cargo!

Cargo è il sistema di compilazione e il gestore di pacchetti di Rust. La maggior parte dei Rustacean utilizza questo strumento per gestire i propri progetti Rust perché Cargo gestisce molte attività al posto tuo, come la compilazione del codice, il download delle librerie da cui dipende il tuo codice e la compilazione di tali librerie (chiamiamo le librerie di cui il tuo codice ha bisogno dipendenze)

I programmi Rust più semplici, come quello che abbiamo scritto finora, non hanno dipendenze. Se avessimo costruito il progetto “Hello, world!” con Cargo, questo avrebbe utilizzato solo la parte di Cargo che si occupa della costruzione del codice. Man mano che scriverai programmi Rust più complessi, aggiungerai delle dipendenze e se inizierai un progetto utilizzando Cargo, sarà molto più facile aggiungere dipendenze.

Poiché la stragrande maggioranza dei progetti Rust utilizza Cargo, il resto di questo libro presuppone che anche tu stia utilizzando Cargo. Cargo viene installato insieme a Rust se hai utilizzato l’installazione di cui si parla nella sezione “Installazione”. Se hai installato Rust in altro modo, controlla se Cargo è installato inserendo quanto segue nel tuo terminale:

$ cargo --version

Se viene visualizzato un numero di versione, allora è fatta! Se viene visualizzato un errore, come ad esempio comando non trovato, consulta la documentazione relativa al tuo metodo di installazione per determinare come installare Cargo separatamente.

Creare un Progetto con Cargo

Creiamo un nuovo progetto utilizzando Cargo e vediamo come si differenzia dal nostro progetto originale “Hello, world!“. Torna alla tua cartella progetti (o dove hai deciso di memorizzare il tuo codice). Poi, su qualsiasi sistema operativo, esegui il seguente comando:

$ cargo new hello_cargo
$ cd hello_cargo

Il primo comando crea una nuova cartella e un nuovo progetto chiamato hello_cargo. Abbiamo chiamato il nostro progetto hello_cargo e Cargo crea i suoi file in una cartella con lo stesso nome.

Vai nella cartella hello_cargo ed elenca i file. Vedrai che Cargo ha generato due file e una cartella per noi: un file Cargo.toml e una cartella src con un file main.rs al suo interno.

Ha anche inizializzato un nuovo repository Git insieme a un file .gitignore. I file Git non verranno generati se esegui cargo new all’interno di un repository Git esistente; puoi annullare questo comportamento utilizzando cargo new --vcs=git.

Nota: Git è un diffuso software di controllo di versione distribuito. Puoi modificare cargo new per utilizzare un altro sistema di controllo di versione o nessun sistema di controllo di versioni utilizzando il flag --vcs. Esegui cargo new --help per vedere le opzioni disponibili.

Apri Cargo.toml nell’editor di testo che preferisci. Dovrebbe assomigliare al codice del Listato 1-2.

[package]
name = "hello_cargo"
version = "0.1.0"
edition = "2024"

[dependencies]

Questo file è nel formato TOML (Tom’s Obvious, Minimal Language), che è il formato di configurazione di Cargo.

La prima riga, [package], è un’intestazione di sezione che indica che le dichiarazioni seguenti stanno configurando un pacchetto. Man mano che aggiungeremo altre informazioni a questo file, aggiungeremo altre sezioni.

Le tre righe successive definiscono le informazioni di configurazione di cui Cargo ha bisogno per compilare il tuo programma: il nome, la versione e l’edizione di Rust da utilizzare. Parleremo della chiave edition in Appendice E.

L’ultima riga, [dependencies], è l’inizio di una sezione in cui puoi elencare tutte le dipendenze del tuo progetto. In Rust, i pacchetti di codice sono chiamati crates (inteso come cassetta, contenitore…). Non avremo bisogno di altri crates per questo progetto, ma lo faremo nel primo progetto del Capitolo 2, quindi useremo questa sezione di dipendenze.

Ora apri src/main.rs e dai un’occhiata:

File: src/main.rs

fn main() {
    println!("Hello, world!");
}

Cargo ha generato per te un programma “Hello, world!”, proprio come quello che abbiamo scritto nel Listato 1-1! Finora, le differenze tra il nostro progetto e quello generato da Cargo sono che Cargo ha inserito il codice nella cartella src, e che c’è un file di configurazione Cargo.toml nella directory principale.

Cargo si aspetta che i tuoi file sorgente si trovino all’interno della cartella src. La directory principale del progetto è solo per i file README, le informazioni sulla licenza, i file di configurazione e tutto ciò che non riguarda il tuo codice. L’utilizzo di Cargo ti aiuta a organizzare i tuoi progetti: c’è un posto per ogni cosa e ogni cosa è al suo posto.

Se hai iniziato un progetto che non utilizza Cargo, come abbiamo fatto con il progetto “Hello, world!”, puoi convertirlo in un progetto che utilizza Cargo. Sposta il codice del progetto nella cartella src e crea un file Cargo.toml appropriato. Un modo semplice per ottenere il file Cargo.toml è eseguire cargo init, che lo creerà automaticamente.

Costruire e Eseguire un Progetto Cargo

Ora vediamo cosa cambia quando costruiamo ed eseguiamo il programma “Hello, world!” con Cargo! Dalla cartella hello_cargo, costruisci il tuo progetto inserendo il seguente comando:

$ cargo build
   Compiling hello_cargo v0.1.0 (file:///progetti/hello_cargo)
    Finished dev [unoptimized + debuginfo] target(s) in 2.85 secs

Questo comando crea un file eseguibile in target/debug/hello_cargo (o target\debug\hello_cargo.exe_ su Windows) anziché nella tua cartella corrente. Poiché la compilazione predefinita è una compilazione di debug, Cargo mette il binario in una cartella chiamata debug. Puoi eseguire l’eseguibile con questo comando:

$ ./target/debug/hello_cargo # o .\target\debug\hello_cargo.exe su Windows
Hello, world!

Se tutto è andato bene, Hello, world! dovrebbe essere stampato sul terminale. L’esecuzione di cargo build per la prima volta fa sì che Cargo crei anche un nuovo file nella directory principale: Cargo.lock. Questo file tiene traccia delle versioni esatte delle dipendenze nel tuo progetto. Questo progetto non ha dipendenze, quindi il file è un po’ scarno. Non dovrai mai modificare questo file manualmente; Cargo gestisce il suo contenuto per te.

Abbiamo appena costruito un progetto con cargo build e lo abbiamo eseguito con ./target/debug/hello_cargo, ma possiamo anche usare cargo run per compilare il codice e poi eseguire l’eseguibile risultante con un solo comando:

$ cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
     Running `target/debug/hello_cargo`
Hello, world!

Utilizzare cargo run è più comodo che doversi ricordare di eseguire cargo build e poi utilizzare l’intero percorso del binario, quindi la maggior parte degli sviluppatori utilizza cargo run.

Nota che questa volta non abbiamo visto l’output che indicava che Cargo stava compilando hello_cargo. Cargo ha capito che i file non erano cambiati, quindi non ha ricostruito ma ha semplicemente eseguito il binario. Se avessi modificato il codice sorgente, Cargo avrebbe ricostruito il progetto prima di eseguirlo e avresti visto questo output:

$ cargo run
   Compiling hello_cargo v0.1.0 (file:///progetti/hello_cargo)
    Finished dev [unoptimized + debuginfo] target(s) in 0.33 secs
     Running `target/debug/hello_cargo`
Hello, world!

Cargo offre anche un comando chiamato cargo check, che controlla rapidamente il tuo codice per assicurarsi che venga compilato ma che non produce un eseguibile:

$ cargo check
   Checking hello_cargo v0.1.0 (file:///progetti/hello_cargo)
    Finished dev [unoptimized + debuginfo] target(s) in 0.32 secs

E perché non dovresti volere un eseguibile? Spesso, cargo check è molto più veloce di cargo build perché salta il passaggio della produzione di un eseguibile. Se controlli continuamente il tuo lavoro mentre scrivi il codice, l’uso di cargo check accelererà il processo di sapere se il tuo progetto è privo di errori e compilabile! Per questo motivo, molti Rustacean eseguono cargo check periodicamente mentre scrivono il loro programma per assicurarsi che si compili. Poi eseguono cargo build quando sono pronti a creare l’eseguibile.

Ricapitoliamo quello che abbiamo imparato finora su Cargo:

• Possiamo creare un progetto utilizzando cargo new.
• Possiamo costruire un progetto utilizzando cargo build.
• Possiamo costruire ed eseguire un progetto in un unico passaggio utilizzando cargo run.
• Possiamo costruire un progetto senza produrre un binario per controllare gli errori utilizzando cargo check.
• Invece di salvare il risultato della compilazione nella stessa directory del nostro codice, Cargo lo salva nella directory target/debug.

Un ulteriore vantaggio dell’utilizzo di Cargo è che i comandi sono gli stessi indipendentemente dal sistema operativo su cui stai lavorando. Quindi, a questo punto, non forniremo più istruzioni specifiche per Linux e macOS rispetto a Windows.

Costruire per il Rilascio

Quando il tuo progetto è finalmente pronto per essere rilasciato, puoi usare cargo build --release per compilarlo con le ottimizzazioni. Questo comando creerà un eseguibile in target/release invece che in target/debug. Le ottimizzazioni rendono il tuo codice Rust più veloce, ma attivarle allunga i tempi di compilazione del tuo programma. Per questo motivo esistono due profili diversi: uno per lo sviluppo, quando vuoi ricostruire rapidamente e spesso, e un altro per la creazione del programma finale che darai a un utente e che non sarà ricostruito più volte e che funzionerà il più velocemente possibile. Se vuoi fare un benchmark del tempo di esecuzione del tuo codice, assicurati di eseguire cargo build --release e di fare il benchmark con l’eseguibile in target/release.

Sfruttare Le Convenzioni di Cargo

Con i progetti semplici, Cargo non offre molti vantaggi rispetto all’uso di rustc, ma si dimostrerà utile quando i tuoi programmi diventeranno più complessi. Quando i programmi diventano più file o hanno bisogno di una dipendenza, è molto più facile lasciare che Cargo coordini la compilazione.

Anche se il progetto hello_cargo è semplice, ora utilizza gran parte degli strumenti che userai nel resto della tua carriera in Rust. Infatti, per lavorare su qualsiasi progetto esistente, puoi usare i seguenti comandi per verificare il codice usando Git, passare alla directory del progetto e compilare:

$ git clone example.org/un_progetto_nuovo
$ cd un_progetto_nuovo
$ cargo build

Per maggiori informazioni su Cargo, consulta la documentazione.

Riepilogo

Sei già partito alla grande nel tuo viaggio assieme a Rust! In questo capitolo hai imparato a..:

• Installare l’ultima versione stabile di Rust usando rustup.
• Aggiornare a una versione più recente di Rust.
• Aprire la documentazione installata localmente.
• Scrivere ed eseguire un programma “Hello, world!” usando direttamente rustc.
• Creare ed eseguire un nuovo progetto usando le convenzioni di Cargo.

Questo è un ottimo momento per costruire un programma più sostanzioso per abituarsi a leggere e scrivere codice in Rust. Quindi, nel Capitolo 2, costruiremo un programma di gioco di indovinelli. Se invece preferisci iniziare imparando come funzionano in Rust alcuni concetti base della programmazione, consulta il Capitolo 3 e poi ritorna al Capitolo 2.

Programmare un Gioco di Indovinelli

Cominciamo a programmare in Rust lavorando insieme a un progetto pratico! Questo capitolo ti introduce ad alcuni concetti comuni di Rust mostrandoti come utilizzarli in un programma reale. Imparerai a conoscere let, match, metodi, funzioni associate, crates esterni e molto altro ancora! Nei capitoli successivi esploreremo queste idee in modo più dettagliato, mentre in questo capitolo ti limiterai a mettere in pratica le nozioni fondamentali.

Implementeremo un classico problema di programmazione per principianti: un gioco di indovinelli. Ecco come funziona: il programma genererà un numero intero casuale compreso tra 1 e 100. Poi chiederà al giocatore di inserire un’ipotesi. Dopo aver inserito un’ipotesi, il programma indicherà se l’ipotesi è troppo bassa o troppo alta. Se l’ipotesi è corretta, il gioco stamperà un messaggio di congratulazioni e terminerà.

Impostare un Nuovo Progetto

Per creare un nuovo progetto, vai nella cartella progetti che hai creato nel Capitolo 1 e crea un nuovo progetto con Cargo, in questo modo:

$ cargo new gioco_indovinello
$ cd gioco_indovinello

Il primo comando, cargo new, prende il nome del progetto (gioco_indovinello) come primo argomento. Il secondo comando entra nella directory del nuovo progetto.

Diamo un’occhiata al file Cargo.toml appena generato:

File: Cargo.toml

[package]
name = "gioco_indovinello"
version = "0.1.0"
edition = "2024"

[dependencies]

Come hai visto nel Capitolo 1, cargo new genera per te un programma “Hello, world!”. Guarda il file src/main.rs:

File: src/main.rs

fn main() {
    println!("Hello, world!");
}

Ora compiliamo questo programma “Hello, world!” ed eseguiamolo nello stesso passaggio utilizzando il comando cargo run:

$ cargo run
   Compiling gioco_indovinello v0.1.0 (file:///progetti/gioco_indovinello)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.33s
     Running `target/debug/gioco_indovinello`
Hello, world!

Il comando run è utile quando hai bisogno di iterare rapidamente su un progetto, come faremo in questo gioco, testando velocemente ogni modifica prima di passare alla successiva.

Riapri il file src/main.rs. In questo file scriverai tutto il codice.

Elaborare un’Ipotesi

La prima parte del programma del gioco di indovinelli richiederà l’input dell’utente, lo elaborerà e verificherà che l’input sia nella forma prevista. Per iniziare, permetteremo al giocatore di inserire un’ipotesi. Inserisci il codice del Listato 2-1 in src/main.rs.

use std::io;

fn main() {
    println!("Indovina il numero!");

    println!("Inserisci la tua ipotesi.");

    let mut ipotesi = String::new();

    io::stdin()
        .read_line(&mut ipotesi)
        .expect("Errore di lettura");

    println!("Hai ipotizzato: {ipotesi}");
}

Questo codice contiene molte informazioni, quindi analizziamolo riga per riga. Per ottenere l’input dell’utente e poi stampare il risultato come output, dobbiamo utilizzare il modulo di input/output io. Il modulo io proviene dalla libreria standard, nota come std:

use std::io;

fn main() {
    println!("Indovina il numero!");

    println!("Inserisci la tua ipotesi.");

    let mut ipotesi = String::new();

    io::stdin()
        .read_line(&mut ipotesi)
        .expect("Errore di lettura");

    println!("Hai ipotizzato: {ipotesi}");
}

Come impostazione predefinita, Rust ha un insieme di risorse definite nella libreria standard che vengono inserite in ogni programma. Questo insieme è chiamato preludio (prelude d’ora in poi) e puoi vedere tutto ciò che contiene nella documentazione della libreria standard.

Se una risorsa che vuoi utilizzare non è presente nel prelude, devi renderla disponibile esplicitamente con un’istruzione use. L’utilizzo del modulo std::io ti offre una serie di utili funzioni, tra cui la possibilità di ricevere input dall’utente.

Come hai visto nel Capitolo 1, la funzione main è il punto di ingresso del programma:

use std::io;

fn main() {
    println!("Indovina il numero!");

    println!("Inserisci la tua ipotesi.");

    let mut ipotesi = String::new();

    io::stdin()
        .read_line(&mut ipotesi)
        .expect("Errore di lettura");

    println!("Hai ipotizzato: {ipotesi}");
}

La sintassi fn dichiara una nuova funzione; le parentesi, (), indicano che non ci sono parametri; e la parentesi graffa, {, inizia il corpo della funzione.

Come hai imparato nel Capitolo 1, println! è una macro che stampa una stringa sullo schermo:

use std::io;

fn main() {
    println!("Indovina il numero!");

    println!("Inserisci la tua ipotesi.");

    let mut ipotesi = String::new();

    io::stdin()
        .read_line(&mut ipotesi)
        .expect("Errore di lettura");

    println!("Hai ipotizzato: {ipotesi}");
}

Questo codice stampa un messaggio che introduce il gioco e richiede un input da parte dell’utente.

Memorizzare i Valori con le Variabili

Successivamente, creeremo una variabile per memorizzare l’input dell’utente, in questo modo:

use std::io;

fn main() {
    println!("Indovina il numero!");

    println!("Inserisci la tua ipotesi.");

    let mut ipotesi = String::new();

    io::stdin()
        .read_line(&mut ipotesi)
        .expect("Errore di lettura");

    println!("Hai ipotizzato: {ipotesi}");
}

Ora il programma si fa interessante! In questa piccola riga succedono molte cose. Usiamo l’istruzione let per creare la variabile. Ecco un altro esempio:

let mele = 5;

Questa riga crea una nuova variabile di nome mele e la lega al valore 5. In Rust, le variabili sono immutabili (immutable) come impostazione predefinita, il che significa che una volta assegnato un valore alla variabile, il valore non cambierà. Parleremo di questo concetto in dettaglio nella sezione “Variabili e mutabilità” del Capitolo 3. Per rendere mutabile (mutable) una variabile, aggiungiamo mut prima del nome della variabile:

let mele = 5; // immutabile
let mut banane = 5; // mutabile

Nota: la sintassi // inizia un commento che continua fino alla fine della riga. Rust ignora tutto ciò che è contenuto nei commenti. Parleremo dei commenti in modo più dettagliato nel Capitolo 3.

Torniamo al nostro gioco di indovinelli. Ora sai che let mut ipotesi introdurrà una variabile mutabile di nome ipotesi. Il segno di uguale (=) indica a Rust che vogliamo legare qualcosa alla variabile in quel momento. A destra del segno di uguale c’è il valore a cui ipotesi è legata, che è il risultato della chiamata a String::new, una funzione che restituisce una nuova istanza di una String. String è un type di stringa fornito dalla libreria standard che è un pezzo di testo codificato UTF-8 modificabile in lunghezza.

La sintassi :: nella riga ::new indica che new è una funzione associata al type String. Una funzione associata è una funzione implementata su un type, in questo caso String. Questa funzione new crea una nuova stringa vuota. Troverai una funzione new in molti type perché è un nome comune per una funzione che crea un nuovo valore di qualche tipo.

In pratica, la linea let mut ipotesi = String::new(); ha creato una variabile mutable che è attualmente legata a una nuova istanza vuota di String. Wow!

Ricevere l’Input dell’Utente

Ricordiamo che abbiamo incluso le funzionalità di input/output della libreria standard con use std::io; nella prima riga del programma. Ora chiameremo la funzione stdin dal modulo io, che ci permetterà di gestire l’input dell’utente:

use std::io;

fn main() {
    println!("Indovina il numero!");

    println!("Inserisci la tua ipotesi.");

    let mut ipotesi = String::new();

    io::stdin()
        .read_line(&mut ipotesi)
        .expect("Errore di lettura");

    println!("Hai ipotizzato: {ipotesi}");
}

Se non avessimo importato il modulo io con use std::io; all’inizio del programma, potremmo comunque utilizzare la funzione scrivendo questa chiamata di funzione come std::io::stdin. La funzione stdin restituisce un’istanza di std::io::Stdin, che è un type che rappresenta un handle all’input standard del tuo terminale.

Successivamente, la riga .read_line(&mut ipotesi) chiama il metodo read_line sull’handle di input standard per ottenere un input dall’utente. Passiamo anche &mut ipotesi come argomento a read_line per dirgli in quale stringa memorizzare l’input dell’utente. Il compito di read_line è quello di prendere tutto ciò che l’utente digita nell’input standard e aggiungerlo a una stringa (senza sovrascriverne il contenuto), quindi passiamo tale stringa come argomento. L’argomento stringa deve essere mutable in modo che il metodo possa cambiare il contenuto della stringa.

Il simbolo & indica che questo argomento è un riferimento (reference d’ora in poi), il che ti dà la possibilità di permettere a più parti del codice di accedere a un dato senza doverlo copiare più volte in memoria. I reference sono una funzionalità complessa e uno dei principali vantaggi di Rust è la sicurezza e la facilità con cui è possibile utilizzarli. Non hai bisogno di conoscere molti di questi dettagli per finire questo programma. Per ora, tutto ciò che devi sapere è che, come le variabili, i reference sono immutabili come impostazione predefinita. Di conseguenza, devi scrivere &mut ipotesi piuttosto che solo &ipotesi per renderli mutable (il Capitolo 4 spiegherà i reference in modo più approfondito)

Gestire i Potenziali Errori con Result

Stiamo ancora lavorando su questa riga di codice. Ora stiamo discutendo di una terza riga di testo, ma notiamo che fa ancora parte di un’unica riga logica di codice. La prossima parte è questo metodo:

use std::io;

fn main() {
    println!("Indovina il numero!");

    println!("Inserisci la tua ipotesi.");

    let mut ipotesi = String::new();

    io::stdin()
        .read_line(&mut ipotesi)
        .expect("Errore di lettura");

    println!("Hai ipotizzato: {ipotesi}");
}

Avremmo potuto scrivere questo codice come:

io::stdin().read_line(&mut ipotesi).expect("Errore di lettura");

Tuttavia, una riga lunga può essere difficile da leggere, quindi è meglio dividerla. Spesso è consigliabile andare a capo e aggiungere degli spazi bianchi per aiutare a spezzare le righe lunghe quando chiami un metodo con la sintassi .nome_metodo(). Ora vediamo cosa fa questa riga.

Come accennato in precedenza, read_line inserisce qualsiasi cosa l’utente inserisca nella stringa che gli passiamo, ma restituisce anche un valore Result. Result è una enumerazione (enum per brevità), che è un type che può trovarsi in uno dei molteplici stati possibili. Chiamiamo ogni stato possibile una variante.

Il Capitolo 6 tratterà le enum in modo più dettagliato. Lo scopo di questi type Result è quello di fornire informazioni sulla gestione degli errori.

Le varianti di Result sono Ok e Err. La variante Ok indica che l’operazione è andata a buon fine e contiene il valore generato con successo. La variante Err indica che l’operazione non è andata a buon fine e contiene informazioni su come o perché l’operazione è fallita.

I valori del tipo Result, come i valori di qualsiasi type, hanno dei metodi definiti su di essi. Un’istanza di Result ha un metodo expect che puoi chiamare. Se questa istanza di Result è un valore Err, expect causerà l’arresto del programma e visualizzerà il messaggio che hai passato come argomento a expect. Se il metodo read_line restituisce un Err, è probabile che sia il risultato di un errore proveniente dal sistema operativo sottostante. Se questa istanza di Result è un valore Ok, expect prenderà il valore di ritorno che Ok sta tenendo e ti restituirà solo quel valore in modo che tu possa usarlo. In questo caso, quel valore è il numero di byte nell’input dell’utente.

Se non chiami expect, il programma verrà compilato, ma riceverai un avviso:

$ cargo build
   Compiling gioco_indovinello v0.1.0 (file:///pregetti/gioco_indovinello)
warning: unused `Result` that must be used
  --> src/main.rs:10:5
   |
10 |     io::stdin().read_line(&mut ipotesi);
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: this `Result` may be an `Err` variant, which should be handled
   = note: `#[warn(unused_must_use)]` on by default
help: use `let _ = ...` to ignore the resulting value
   |
10 |     let _ = io::stdin().read_line(&mut ipotesi);
   |     +++++++

warning: `gioco_indovinello` (bin "gioco_indovinello") generated 1 warning
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.29s

Rust avverte che non è stato utilizzato il valore Result restituito da read_line, indicando che il programma non ha gestito un possibile errore.

Il modo corretto per sopprimere l’avvertimento è quello di scrivere del codice che gestisca questi potenziali errori, ma nel nostro caso non è un grosso problema mandare in crash il programma quando si verifica un problema, quindi possiamo usare expect. Imparerai a recuperare dagli errori nel Capitolo 9.

Stampare i Valori con i Segnaposto in println!

A parte la parentesi graffa di chiusura, c’è un’ultima riga da discutere nel codice:

use std::io;

fn main() {
    println!("Indovina il numero!");

    println!("Inserisci la tua ipotesi.");

    let mut ipotesi = String::new();

    io::stdin()
        .read_line(&mut ipotesi)
        .expect("Errore di lettura");

    println!("Hai ipotizzato: {ipotesi}");
}

Questa riga stampa la stringa che ora contiene l’input dell’utente. La serie di parentesi graffe {} è un segnaposto: pensa a {} come a delle piccole chele di granchio che tengono fermo un valore. Quando stampi il valore di una variabile, il nome della variabile può essere inserito all’interno delle parentesi graffe. Quando devi stampare il risultato della valutazione di un’espressione, inserisci delle parentesi graffe vuote nella stringa di formato, quindi fai seguire alla stringa di formato un elenco separato da virgole di espressioni da stampare in ogni segnaposto vuoto, nello stesso ordine. Stampare una variabile e il risultato di un’espressione in un’unica chiamata a println! sarebbe così:

#![allow(unused)]
fn main() {
let x = 5;
let y = 10;

println!("x = {x} e y + 2 = {}", y + 2);
}

Questo codice produrrà x = 5 e y + 2 = 12.

Proviamo la Prima Parte

Proviamo la prima parte del gioco di indovinelli utilizzando cargo run:

$ cargo run
   Compiling gioco_indovinello v0.1.0 (file:///progetti/gioco_indovinello)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.40s
     Running `target/debug/gioco_indovinello`
Indovina il numero!
Inserisci la tua ipotesi.
6
Hai ipotizzato: 6

A questo punto, la prima parte del gioco è terminata: stiamo ricevendo input dalla tastiera e poi li stiamo stampando.

Generare un Numero Segreto

Ora dobbiamo generare un numero segreto che l’utente cercherà di indovinare. Il numero segreto dovrebbe essere diverso ogni volta, in modo da rendere il gioco divertente più di una volta. Utilizzeremo un numero casuale compreso tra 1 e 100, in modo che il gioco non sia troppo difficile. Rust non include ancora la funzionalità dei numeri casuali nella sua libreria standard, ma il team di Rust fornisce un crate rand con tale funzionalità.

Aumentare le Funzionalità con un Crate

Ricorda che un crate è una raccolta di file di codice sorgente in Rust. Il progetto che stiamo costruendo è un crate binario, cioè un eseguibile. Il crate rand è un crate libreria, che contiene codice destinato a essere utilizzato in altri programmi e non può essere eseguito da solo.

Prima di poter scrivere del codice che utilizzi rand, dobbiamo modificare il file Cargo.toml per includere il crate rand come dipendenza. Apri il file e aggiungi la seguente riga in fondo, sotto l’intestazione della sezione delle dipendenze [dependencies] che Cargo ha creato per te. Assicurati di specificare rand esattamente come abbiamo fatto qui, con questo numero di versione, altrimenti gli esempi di codice di questo tutorial potrebbero non funzionare:

File: Cargo.toml

[dependencies]
rand = "0.8.5"

Nel file Cargo.toml, tutto ciò che segue un’intestazione fa parte di quella sezione che continua fino all’inizio di un’altra sezione. In [dependencies], indichi a Cargo quali sono i crate esterni da cui dipende il tuo progetto e quali sono le versioni di tali crate richieste. In questo caso, specifichiamo il crate rand con lo specificatore di versione semantica 0.8.5. Cargo comprende il Versionamento Semantico (a volte chiamato SemVer per brevità), che è uno standard per la scrittura dei numeri di versione. Lo specificatore 0.8.5 è in realtà un’abbreviazione di ^0.8.5, che indica qualsiasi versione che sia almeno 0.8.5 ma inferiore a 0.9.0.

Cargo considera queste versioni con API pubbliche compatibili con la versione 0.8.5 e questa specifica ti garantisce di ottenere l’ultima release della patch che si compila ancora con il codice di questo capitolo. Qualsiasi versione 0.9.0 o superiore non garantisce di avere le stesse API utilizzate negli esempi seguenti.

Ora, senza modificare alcun codice, costruiamo il progetto, come mostrato nel Listato 2-2.

$ cargo build
  Updating crates.io index
   Locking 15 packages to latest Rust 1.85.0 compatible versions
    Adding rand v0.8.5 (available: v0.9.0)
 Compiling proc-macro2 v1.0.93
 Compiling unicode-ident v1.0.17
 Compiling libc v0.2.170
 Compiling cfg-if v1.0.0
 Compiling byteorder v1.5.0
 Compiling getrandom v0.2.15
 Compiling rand_core v0.6.4
 Compiling quote v1.0.38
 Compiling syn v2.0.98
 Compiling zerocopy-derive v0.7.35
 Compiling zerocopy v0.7.35
 Compiling ppv-lite86 v0.2.20
 Compiling rand_chacha v0.3.1
 Compiling rand v0.8.5
 Compiling gioco_indovinello v0.1.0 (file:///progetti/gioco_indovinello)
  Finished `dev` profile [unoptimized + debuginfo] target(s) in 2.48s

Potresti vedere numeri di versione diversi (ma saranno tutti compatibili con il codice, grazie a SemVer!) e righe diverse (a seconda del sistema operativo) e le righe potrebbero essere in un ordine diverso.

Quando includiamo una dipendenza esterna, Cargo recupera le ultime versioni di tutto ciò di cui la dipendenza ha bisogno dal registro, registry, che è una copia dei dati di Crates.io. Crates.io è il sito in cui le persone che fanno parte dell’ecosistema Rust pubblicano i loro progetti Rust open source che possono essere utilizzati da altri.

Dopo aver aggiornato il registro, Cargo controlla la sezione [dependencies] e scarica tutti i crate elencati che non sono già stati scaricati. In questo caso, anche se abbiamo elencato solo rand come dipendenza, Cargo ha preso anche altri crate da cui rand dipende per funzionare. Dopo aver scaricato i crate, Rust li compila e poi compila il progetto con le dipendenze disponibili.

Se esegui immediatamente cargo build di nuovo senza apportare alcuna modifica, non otterrai alcun risultato a parte la riga Finished. Cargo sa che ha già scaricato e compilato le dipendenze e che non hai modificato nulla nel tuo file Cargo.toml. Cargo sa anche che non hai modificato nulla del tuo codice, quindi non ricompila nemmeno quello. Non avendo nulla da fare, semplicemente termina l’esecuzione.

Se apri il file src/main.rs, apporti una modifica banale e poi salvi e ricostruisci, vedrai solo due righe di output:

$ cargo build
   Compiling gioco_indovinello v0.1.0 (file:///progetti/gioco_indovinello)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.13s

Queste righe mostrano che Cargo ricompila solo le modifiche, il file src/main.rs. Le dipendenze non sono cambiate, quindi Cargo sa di poter riutilizzare ciò che ha già scaricato e compilato in precedenza.

Garantire Build Riproducibili

Cargo ha un meccanismo che ti garantisce di ricostruire lo stesso artefatto ogni volta che tu o chiunque altro costruisce il tuo codice: Cargo utilizzerà solo le versioni delle dipendenze che hai specificato fino a quando non indicherai il contrario. Per esempio, supponiamo che la prossima settimana esca la versione 0.8.6 del crate rand, che contiene un’importante correzione di un bug, ma anche una regressione incompatibile con il tuo codice. Per gestire questo problema, Rust crea il file Cargo.lock la prima volta che esegui cargo build, che quindi ora si trova nella directory gioco_indovinello.

Quando costruisci un progetto per la prima volta, Cargo calcola tutte le versioni delle dipendenze che soddisfano i criteri e le scrive nel file Cargo.lock. Quando costruisci il tuo progetto in futuro, Cargo vedrà che il file Cargo.lock esiste e userà le versioni specificate in esso, invece di fare tutto il lavoro per trovare di nuovo le versioni. In altre parole, il tuo progetto rimarrà alla versione 0.8.5 fino a quando non effettuerai un aggiornamento esplicito, grazie al file Cargo.lock. Poiché il file Cargo.lock è importante per la creazione di build riproducibili, spesso viene inserito nel controllo sorgente insieme al resto del codice del progetto.

Aggiornare un Crate per Ottenere una Nuova Versione

Quando vuoi aggiornare un crate, Cargo mette a disposizione il comando update, che ignorerà il file Cargo.lock e troverà tutte le ultime versioni che corrispondono alle tue specifiche in Cargo.toml. Cargo scriverà quindi queste versioni nel file Cargo.lock. Altrimenti, di default, Cargo cercherà solo le versioni maggiori di 0.8.5 e minori di 0.9.0. Se il crate rand ha rilasciato nuove versioni sia per la versione 0.8 che per la 0.9, vedrai quanto segue se eseguirai cargo update:

$ cargo update
    Updating crates.io index
     Locking 1 package to latest Rust 1.85.0 compatible version
    Updating rand v0.8.5 -> v0.8.6 (available: v0.9.0)

Cargo ignora la versione 0.9.0. A questo punto, noterai anche un cambiamento nel tuo file Cargo.lock che indica che la versione del crate rand che stai utilizzando è la 0.8.6. Per utilizzare la versione 0.9.0 di rand o qualsiasi altra versione della serie 0.9.x, dovrai aggiornare il file Cargo.toml in questo modo:

[dependencies]
rand = "0.9.0"

La prossima volta che eseguirai cargo build, Cargo aggiornerà il registro dei crate disponibili e rivaluterà i requisiti di rand in base alla nuova versione che hai specificato.

C’è molto altro da dire su Cargo e sul suo ecosistema, di cui parleremo nel Capitolo 14, ma per ora questo è tutto ciò che devi sapere. Cargo rende molto facile il riutilizzo delle librerie, per cui i Rustacean sono in grado di scrivere progetti più piccoli che sono assemblati da una serie di pacchetti.

Generare un Numero Casuale

Iniziamo a usare rand per generare un numero da indovinare. Il passo successivo è aggiornare src/main.rs, come mostrato nel Listato 2-3.

use std::io;

use rand::Rng;

fn main() {
    println!("Indovina il numero!");

    let numero_segreto = rand::thread_rng().gen_range(1..=100);

    println!("Il numero segreto è: {numero_segreto}");

    println!("Inserisci la tua ipotesi.");

    let mut ipotesi = String::new();

    io::stdin()
        .read_line(&mut ipotesi)
        .expect("Errore di lettura");

    println!("Hai ipotizzato: {ipotesi}");
}

Per prima cosa aggiungiamo la riga use rand::Rng;. Il trait Rng definisce i metodi che i generatori di numeri casuali implementano e questo trait deve essere nell’ambito di utilizzo (in scope d’ora in poi), per poter utilizzare tali metodi. Il Capitolo 10 tratterà in dettaglio i trait.

Nella prima riga, chiamiamo la funzione rand::thread_rng che ci fornisce il particolare generatore di numeri casuali che utilizzeremo: un generatore locale che si appoggia al sistema operativo. Poi chiamiamo il metodo gen_range sul generatore di numeri casuali. Questo metodo è definito dal trait Rng che abbiamo portato in scope con l’istruzione use rand::Rng;. Il metodo gen_range prende un’espressione di intervallo come argomento e genera un numero casuale nell’intervallo. Il tipo di espressione di intervallo che stiamo usando qui ha la forma inizio..=fine ed è inclusivo dei limiti inferiore e superiore, quindi dobbiamo specificare 1..=100 per richiedere un numero compreso tra 1 e 100.

Nota: non sarai sempre a conoscenza di quali trait utilizzare e quali metodi e funzioni chiamare di un crate, quindi ogni crate ha una documentazione con le istruzioni per utilizzarlo. Un’altra caratteristica interessante di Cargo è che eseguendo il comando cargo doc --open, la documentazione fornita da tutte le tue dipendenze viene creata localmente e aperta nel browser. Se sei interessato ad altre funzionalità del crate rand, ad esempio, esegui cargo doc --open e clicca su rand nella barra laterale a sinistra.

La seconda nuova riga stampa il numero segreto. Questo è utile durante lo sviluppo del programma per poterlo testare, ma lo elimineremo dalla versione finale. Non è un grande gioco se il programma stampa la risposta non appena inizia!

Prova a eseguire il programma alcune volte:

$ cargo run
   Compiling gioco_indovinello v0.1.0 (file:///progetti/gioco_indovinello)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.02s
     Running `target/debug/gioco_indovinello`
Indovina il numero!
Il numero segreto è: 7
Inserisci la tua ipotesi.
4
Hai ipotizzato: 4

$ cargo run
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.02s
     Running `target/debug/gioco_indovinello`
Indovina il numero!
Il numero segreto è: 83
Inserisci la tua ipotesi.
5
Hai ipotizzato: 5

Dovresti ottenere diversi numeri casuali, tutti compresi tra 1 e 100. Ottimo lavoro!

Confrontare l’Ipotesi con il Numero Segreto

Ora che abbiamo l’input dell’utente e un numero casuale, possiamo confrontarli. Questo passo è mostrato nel Listato 2-4. Nota che questo codice non è compilabile per il momento, come spiegheremo.

use std::cmp::Ordering;
use std::io;

use rand::Rng;

fn main() {
    // --taglio--
    println!("Indovina il numero!");

    let numero_segreto = rand::thread_rng().gen_range(1..=100);

    println!("Il numero segreto è: {numero_segreto}");

    println!("Inserisci la tua ipotesi.");

    let mut ipotesi = String::new();

    io::stdin()
        .read_line(&mut ipotesi)
        .expect("Errore di lettura");

    println!("Hai ipotizzato: {ipotesi}");

    match ipotesi.cmp(&numero_segreto) {
        Ordering::Less => println!("Troppo piccolo!"),
        Ordering::Greater => println!("Troppo grande!"),
        Ordering::Equal => println!("Hai indovinato!"),
    }
}

Per prima cosa aggiungiamo un’altra istruzione use, che porta un type chiamato std::cmp::Ordering dalla libreria standard. Il type Ordering è un’altra enum e ha le varianti Less, Greater e Equal. Questi sono i tre risultati possibili quando si confrontano due valori.

Poi aggiungiamo cinque nuove righe in basso che utilizzano il type Ordering. Il metodo cmp confronta due valori e può essere richiamato su qualsiasi cosa possa essere confrontata. Come parametro prende un reference a qualsiasi cosa si voglia confrontare: in questo caso sta confrontando ipotesi con numero_segreto. Poi restituisce una variante dell’enum Ordering che abbiamo portato nello scope con l’istruzione use. Utilizziamo un’espressione match per decidere cosa fare successivamente in base a quale variante di Ordering è stata restituita dalla chiamata a cmp con i valori in ipotesi e numero_segreto.

Un’espressione match è composta da due rami. Da una parte un pattern su cui fare il confronto, dall’altra il codice da eseguire se il valore dato a match corrisponde al pattern. Rust prende il valore dato a match e lo confronta con il _ pattern_ dei vari rami, eseguendo poi il codice se corrispondono. I pattern e il costrutto match sono potenti caratteristiche di Rust: ti permettono di esprimere una varietà di situazioni in cui il tuo codice potrebbe imbattersi e ti assicurano di gestirle tutte. Queste caratteristiche saranno trattate in dettaglio nel Capitolo 6 e nel Capitolo 19, rispettivamente.

Facciamo un esempio con l’espressione match che utilizziamo qui. Supponiamo che l’utente abbia ipotizzato 50 e che il numero segreto generato in modo casuale questa volta sia 38.

Quando il codice confronta 50 con 38, il metodo cmp restituirà Ordering::Greater perché 50 è maggiore di 38. L’espressione match ottiene il valore Ordering::Greater e inizia a controllare il pattern di ciascun ramo. Esamina il pattern del primo ramo, Ordering::Less, e vede che il valore Ordering::Greater non corrisponde a Ordering::Less, quindi ignora il codice in quel ramo e passa al ramo successivo. Il modello del ramo successivo è Ordering::Greater, che corrisponde a Ordering::Greater! Il codice associato in quel ramo verrà eseguito e stamperà Troppo grande! sullo schermo. L’espressione match termina dopo la prima corrispondenza riuscita, quindi non esaminerà l’ultimo ramo in questo scenario.

Tuttavia, il codice del Listato 2-4 non viene compilato. Proviamo:

$ cargo build
   Compiling libc v0.2.86
   Compiling getrandom v0.2.2
   Compiling cfg-if v1.0.0
   Compiling ppv-lite86 v0.2.10
   Compiling rand_core v0.6.2
   Compiling rand_chacha v0.3.0
   Compiling rand v0.8.5
   Compiling gioco_indovinello v0.1.0 (file:///progetti/gioco_indovinello)
error[E0308]: mismatched types
  --> src/main.rs:23:21
   |
23 |     match guess.cmp(&numero_segreto) {
   |                 --- ^^^^^^^^^^^^^^ expected `&String`, found `&{integer}`
   |                 |
   |                 arguments to this method are incorrect
   |
   = note: expected reference `&String`
              found reference `&{integer}`
note: method defined here
  --> /rustc/4eb161250e340c8f48f66e2b929ef4a5bed7c181/library/core/src/cmp.rs:964:8

For more information about this error, try `rustc --explain E0308`.
error: could not compile `gioco_indovinello` (bin "gioco_indovinello") due to 1 previous error

Il messaggio di errore afferma che ci sono mismatched types (type non corrispondenti). Rust ha un sistema di type forte e statico. Tuttavia, ha anche l’inferenza del type. Quando abbiamo scritto let mut ipotesi = String::new(), Rust è stato in grado di dedurre che ipotesi doveva essere un String e non ci ha fatto scrivere il type. Il numero_segreto, d’altra parte, è un type numerico. Alcuni type numerici di Rust possono avere un valore compreso tra 1 e 100: i32, un numero a 32 bit; u32, un numero a 32 bit senza segno; i64, un numero a 64 bit; e altri ancora. Se non diversamente specificato, Rust imposta come predefinito un i32, che è il type di numero_segreto a meno che non si aggiungano informazioni sul type altrove che indurrebbero Rust a dedurre un type numerico differente. Il motivo dell’errore è che Rust non può confrontare una type stringa e un type numerico.

In definitiva, vogliamo convertire la String che il programma legge come input in un type numerico in modo da poterlo confrontare numericamente con il numero segreto. Lo facciamo aggiungendo questa riga al corpo della funzione main:

File: src/main.rs

use std::cmp::Ordering;
use std::io;

use rand::Rng;

fn main() {
    println!("Indovina il numero!");

    let numero_segreto = rand::thread_rng().gen_range(1..=100);

    println!("Il numero segreto è: {numero_segreto}");

    println!("Inserisci la tua ipotesi.");

    // --taglio--

    let mut ipotesi = String::new();

    io::stdin()
        .read_line(&mut ipotesi)
        .expect("Errore di lettura");

    let ipotesi: u32 = ipotesi.trim().parse().expect("Inserisci un numero!");

    println!("Hai ipotizzato: {ipotesi}");

    match ipotesi.cmp(&numero_segreto) {
        Ordering::Less => println!("Troppo piccolo!"),
        Ordering::Greater => println!("Troppo grande!"),
        Ordering::Equal => println!("Hai indovinato!"),
    }
}

La riga è:

let ipotesi: u32 = ipotesi.trim().parse().expect("Inserisci un numero!");

Creiamo una variabile di nome ipotesi. Ma aspetta, il programma non ha già una variabile di nome ipotesi? Sì, ma Rust ci permette di mettere in ombra, il valore precedente di ipotesi con uno nuovo. Lo Shadowing ci permette di riutilizzare il nome della variabile ipotesi invece di costringerci a creare due variabili uniche, come ipotesi_str e ipotesi, per esempio. Ne parleremo in modo più dettagliato nel Capitolo 3, ma per ora, sappi che questa funzione è spesso usata quando vuoi convertire un valore da un type ad un altro.

Leghiamo questa nuova variabile all’espressione ipotesi.trim().parse(). L’ipotesi nell’espressione si riferisce alla variabile ipotesi originale che contiene l’input come stringa. Il metodo trim su un’istanza di String elimina ogni spazio bianco ad inizio e fine, cosa da fare prima di convertire la stringa in u32, che può contenere solo dati numerici. L’utente deve premere invio per confermare l’input da terminale e questo aggiunge un carattere nuova_linea (newline d’ora in poi) alla stringa letta da read_line. Per esempio, se l’utente digita 5 e poi preme invio, ipotesi conterrà: 5\n. Il carattere \n rappresenta newline. (Su Windows, premere invio aggiunge anche il carattere di ritorno a capo oltre a newline, risultando in \r\n.) Il metodo trim elimina sia \n che \r\n, restituendo quindi solo 5.

Il metodo parse sulle stringhe converte una stringa in un altro type. In questo caso, lo usiamo per convertire una stringa in un numero. Dobbiamo indicare a Rust il tipo esatto di numero che vogliamo usando let ipotesi: u32. I due punti (:) dopo ipotesi dicono a Rust che annoteremo il tipo di variabile. Rust ha alcuni type numerici incorporati; u32 visto qui è un intero a 32 bit senza segno. È una buona scelta predefinita per un piccolo numero positivo. Imparerai a conoscere altri type numerici Capitolo 3.

Inoltre, l’annotazione u32 in questo programma di esempio e il confronto con numero_segreto significa che Rust dedurrà che anche numero_segreto dovrebbe essere un u32. Quindi ora il confronto sarà tra due valori con lo stesso type!

Il metodo parse funziona solo su caratteri che possono essere convertiti logicamente in numeri e quindi può facilmente causare errori. Se, ad esempio, la stringa contenesse A👍%, non ci sarebbe modo di convertirla in un numero. Poiché potrebbe fallire, il metodo parse restituisce un type Result, proprio come fa il metodo read_line (discusso in precedenza in “Gestire i Potenziali Errori con Result”). Tratteremo questo Result allo stesso modo utilizzando nuovamente il metodo expect. Se parse restituisce una variante Err perché non è riuscito a creare un numero dalla stringa, la chiamata expect causerà il crash del gioco e stamperà il messaggio che gli abbiamo fornito. Se parse riesce a convertire la stringa in un numero, restituirà la variante Ok di Result e expect restituirà il numero che vogliamo dal valore Ok.

Ora eseguiamo il programma:

$ cargo run
   Compiling gioco_indovinello v0.1.0 (file:///progetti/gioco_indovinello)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.26s
     Running `target/debug/gioco_indovinello`
Indovina il numero!
Il numero segreto è: 58
Inserisci la tua ipotesi.
  76
Hai ipotizzato: 76
Troppo grande!

Bene! Anche se sono stati aggiunti degli spazi prima del numero, il programma ha capito che l’utente aveva ipotizzato 76. Esegui il programma alcune volte per verificare il diverso comportamento con diversi tipi di input: ipotizzare il numero corretto, ipotizzare un numero troppo alto e ipotizzare un numero troppo basso.

Ora la maggior parte del gioco funziona, ma l’utente può fare una sola ipotesi. Cambiamo questa situazione aggiungendo un ciclo!

Consentire Più Ipotesi con la Ripetizione

La parola chiave loop (ripetizione) crea un ciclo infinito. Aggiungeremo un ciclo per dare agli utenti più possibilità di indovinare il numero:

File: src/main.rs

use std::cmp::Ordering;
use std::io;

use rand::Rng;

fn main() {
    println!("Indovina il numero!");

    let numero_segreto = rand::thread_rng().gen_range(1..=100);

    // --taglio--

    println!("Il numero segreto è: {numero_segreto}");

    loop {
        println!("Inserisci la tua ipotesi.");

        // --taglio--


        let mut ipotesi = String::new();

        io::stdin()
            .read_line(&mut ipotesi)
            .expect("Errore di lettura");

        let ipotesi: u32 = ipotesi.trim().parse().expect("Inserisci un numero!");

        println!("Hai ipotizzato: {ipotesi}");

        match ipotesi.cmp(&numero_segreto) {
            Ordering::Less => println!("Troppo piccolo!"),
            Ordering::Greater => println!("Troppo grande!"),
            Ordering::Equal => println!("Hai indovinato!"),
        }
    }
}

Come puoi vedere, abbiamo spostato tutto ciò che va dalla richiesta di indovinare in poi all’interno di un ciclo. Assicurati di aggiungere degli spazi ad inizio riga per indentare correttamente il codice all’interno del ciclo ed esegui di nuovo il programma. Il programma ora chiederà sempre un’altra ipotesi, il che introduce un nuovo problema: come fa l’utente a smettere di giocare?

L’utente può sempre interrompere il programma utilizzando la scorciatoia da tastiera ctrl-C. Ma c’è un altro modo per sfuggire a questo mostro insaziabile, come accennato nella discussione su parse in “Confrontare l’ipotesi con il numero segreto”: se l’utente inserisce una risposta non numerica, il programma si blocca. Possiamo approfittarne per consentire all’utente di uscire, come mostrato qui:

$ cargo run
   Compiling gioco_indovinello v0.1.0 (file:///progetti/gioco_indovinello)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.23s
     Running `target/debug/gioco_indovinello`
Indovina il numero!
Il numero segreto è: 59
Inserisci la tua ipotesi.
45
Hai ipotizzato: 45
Troppo piccolo!
Inserisci la tua ipotesi.
60
Hai ipotizzato: 60
Troppo grande!
Inserisci la tua ipotesi.
59
Hai ipotizzato: 59
Hai indovinato!
Inserisci la tua ipotesi.
esci

thread 'main' panicked at src/main.rs:28:47:
Inserisci un numero!: ParseIntError { kind: InvalidDigit }
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Digitando esci chiude il gioco, ma come noterai, anche l’inserimento di qualsiasi altro input che non sia un numero. Questo è a dir poco sub-ottimale: vogliamo che il gioco si fermi anche quando viene indovinato il numero corretto.

Uscire Dopo un’Ipotesi Corretta

Programmiamo il gioco in modo che esca quando l’utente vince, aggiungendo un’istruzione break (uscita):

File: src/main.rs

use std::cmp::Ordering;
use std::io;

use rand::Rng;

fn main() {
    println!("Indovina il numero!");

    let numero_segreto = rand::thread_rng().gen_range(1..=100);

    println!("Il numero segreto è: {numero_segreto}");

    loop {
        println!("Inserisci la tua ipotesi.");

        let mut ipotesi = String::new();

        io::stdin()
            .read_line(&mut ipotesi)
            .expect("Errore di lettura");

        let ipotesi: u32 = ipotesi.trim().parse().expect("Inserisci un numero!");

        println!("Hai ipotizzato: {ipotesi}");

        // --taglio--

        match ipotesi.cmp(&numero_segreto) {
            Ordering::Less => println!("Troppo piccolo!"),
            Ordering::Greater => println!("Troppo grande!"),
            Ordering::Equal => {
                println!("Hai indovinato!");
                break;
            }
        }
    }
}

L’aggiunta della riga break dopo Hai indovinato! fa sì che il programma esca dal ciclo quando l’utente indovina correttamente il numero segreto. Uscire dal ciclo significa anche uscire dal programma, perché il ciclo è l’ultima parte di main.

Gestire Gli Input Non Validi

Per perfezionare ulteriormente il comportamento del gioco, invece di mandare in crash il programma quando l’utente non inserisce un numero valido, facciamo in modo che il gioco ignori un valore non numerico in modo che l’utente possa continuare a indovinare. Possiamo farlo modificando la riga in cui ipotesi viene convertito da String in u32, come mostrato nel Listato 2-5.

use std::cmp::Ordering;
use std::io;

use rand::Rng;

fn main() {
    println!("Indovina il numero!");

    let numero_segreto = rand::thread_rng().gen_range(1..=100);

    println!("Il numero segreto è: {numero_segreto}");

    loop {
        println!("Inserisci la tua ipotesi.");

        let mut ipotesi = String::new();

        // --taglio--

        io::stdin()
            .read_line(&mut ipotesi)
            .expect("Errore di lettura");

        let ipotesi: u32 = match ipotesi.trim().parse() {
            Ok(num) => num,
            Err(_) => continue,
        };

        println!("Hai ipotizzato: {ipotesi}");

        // --taglio--

        match ipotesi.cmp(&numero_segreto) {
            Ordering::Less => println!("Troppo piccolo!"),
            Ordering::Greater => println!("Troppo grande!"),
            Ordering::Equal => {
                println!("Hai indovinato!");
                break;
            }
        }
    }
}

Passiamo da una chiamata expect a un’espressione match per passare dal crash su un errore alla gestione di quell’errore. Ricorda che parse restituisce un type Result e Result è un’enum che ha le varianti Ok e Err. Stiamo usando un’espressione match qui, come abbiamo fatto con il risultato Ordering del metodo cmp.

Se parse riesce a trasformare la stringa in un numero, restituirà un valore Ok che contiene il numero risultante. Questo valore Ok corrisponderà allo schema del primo ramo e l’espressione match restituirà il valore num che parse ha prodotto e messo all’interno del valore Ok. Quel numero finirà proprio dove vogliamo nella nuova variabile ipotesi che stiamo creando.

Se parse non riesce a trasformare la stringa in un numero, restituirà un valore Err che contiene ulteriori informazioni sull’errore. Il valore Err non corrisponde allo schema Ok(num) del primo ramo match, ma corrisponde allo schema Err(_) del secondo ramo. Il trattino basso, _, è un valore piglia-tutto; in questo esempio, stiamo dicendo che va bene qualsiasi valore di Err, indipendentemente dalle informazioni che contene. Quindi il programma eseguirà il codice del secondo ramo, continue, che dice al programma di passare alla successiva iterazione del loop e di chiedere un’altra ipotesi. Quindi, in effetti, il programma ignora tutti gli errori che parse potrebbe incontrare!

Ora tutto il programma dovrebbe funzionare come previsto. Proviamo:

$ cargo run
   Compiling gioco_indovinello v0.1.0 (file:///progetti/gioco_indovinello)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.13s
     Running `target/debug/gioco_indovinello`
Indovina il numero!
Il numero segreto è: 61
Inserisci la tua ipotesi.
10
Hai ipotizzato: 10
Troppo piccolo!
Inserisci la tua ipotesi.
99
Hai ipotizzato: 99
Troppo grande!
Inserisci la tua ipotesi.
foo
Inserisci la tua ipotesi.
61
Hai ipotizzato: 61
Hai vinto!

Perfetto! Con un’ultima piccola modifica, finiremo il gioco di indovinelli. Ricorda che il programma continua a stampare il numero segreto. Questo funziona bene per testare il funzionamento, ma rovina il gioco. Eliminiamo il println! che produce il numero segreto. Il Listato 2-6 mostra il codice finale.

use std::cmp::Ordering;
use std::io;

use rand::Rng;

fn main() {
    println!("Indovina il numero!");

    let numero_segreto = rand::thread_rng().gen_range(1..=100);

    loop {
        println!("Inserisci la tua ipotesi.");

        let mut ipotesi = String::new();

        io::stdin()
            .read_line(&mut ipotesi)
            .expect("Errore di lettura");

        let ipotesi: u32 = match ipotesi.trim().parse() {
            Ok(num) => num,
            Err(_) => continue,
        };

        println!("Hai ipotizzato: {ipotesi}");

        match ipotesi.cmp(&numero_segreto) {
            Ordering::Less => println!("Troppo piccolo!"),
            Ordering::Greater => println!("Troppo grande!"),
            Ordering::Equal => {
                println!("Hai indovinato!");
                break;
            }
        }
    }
}

A questo punto, hai costruito con successo il gioco dell’indovinello: complimenti!

Riepilogo

Questo progetto è stato un modo pratico per introdurti a molti nuovi concetti di Rust: let, match, le funzioni, l’uso di crate esterni e altro ancora. Nei prossimi capitoli imparerai a conoscere questi concetti in modo più dettagliato. Il Capitolo 3 tratta i concetti che la maggior parte dei linguaggi di programmazione possiede, come le variabili, i tipi di dati e le funzioni, e mostra come utilizzarli in Rust. Il Capitolo 4 esplora la ownership (controllo esclusivo), una caratteristica che rende Rust diverso dagli altri linguaggi. Il Capitolo 5 parla delle strutture e della sintassi dei metodi, mentre il Capitolo 6 spiega come funzionano le enum.

Concetti Comuni di Programmazione

Questo capitolo tratta i concetti che appaiono in quasi tutti i linguaggi di programmazione e come funzionano in Rust. Molti linguaggi di programmazione hanno molti punti in comune. Nessuno dei concetti presentati in questo capitolo è esclusivo di Rust, ma li discuteremo nel contesto di Rust e spiegheremo le convenzioni per l’utilizzo di questi concetti.

In particolare, imparerai a conoscere le variabili, i type di base, le funzioni, i commenti e le strutture di controllo. Questi fondamenti saranno presenti in ogni programma di Rust e impararli presto ti darà una base solida da cui partire.

Variabili e Mutabilità

Come accennato nella sezione “Memorizzare i valori con le Variabili”, come impostazione predefinita, le variabili sono immutabili. Questo è uno dei tanti stimoli che Rust ti dà per scrivere il tuo codice in modo da sfruttare la sicurezza e la facilità di concorrenza che Rust offre. Tuttavia, hai ancora la possibilità di rendere le tue variabili mutabili. Esploriamo come e perché Rust ti incoraggia a favorire l’immutabilità e perché a volte potresti voler rinunciare a questa cosa.

Quando una variabile è immutabile, una volta che un valore è legato a un nome, non è più possibile cambiarlo. Per vederlo con mano, genera un nuovo progetto chiamato variabili nella tua cartella progetti utilizzando cargo new variabili.

Ed ora, nella nuova cartella variabili, apri src/main.rs e sostituisci il suo codice con il seguente, che per il momento risulterà non compilabile:

File: src/main.rs

fn main() {
    let x = 5;
    println!("Il valore di x è: {x}");
    x = 6;
    println!("Il valore di x è: {x}");
}

Salva ed esegui il programma utilizzando cargo run. Dovresti ricevere un messaggio di errore relativo a un errore di immutabilità, come mostrato in questo output:

$ cargo run
   Compiling variabili v0.1.0 (file:///progetti/variabili)
error[E0384]: cannot assign twice to immutable variable `x`
 --> src/main.rs:4:5
  |
2 |     let x = 5;
  |         - first assignment to `x`
3 |     println!("Il valore di x è: {x}");
4 |     x = 6;
  |     ^^^^^ cannot assign twice to immutable variable
  |
help: consider making this binding mutable
  |
2 |     let mut x = 5;
  |         +++

For more information about this error, try `rustc --explain E0384`.
error: could not compile `variabili` (bin "variabili") due to 1 previous error

Questo esempio mostra come il compilatore ti aiuta a trovare gli errori nei tuoi programmi. Gli errori del compilatore possono essere frustranti, ma in realtà significano solo che il tuo programma non sta ancora facendo in modo sicuro ciò che vuoi; non significano che non sei un buon programmatore! Anche ai Rustacean più esperti appaiono errori del compilatore.

Hai ricevuto il messaggio di errore cannot assign twice to immutable variable perché hai cercato di assegnare un secondo valore alla variabile immutabile x.

È importante che ci vengano segnalati errori in tempo di compilazione quando si tenta di modificare un valore che è stato definito immutabile, perché proprio questa situazione può portare a dei bug. Se una parte del nostro codice opera sulla base del presupposto che un valore non cambierà mai e un’altra parte del codice modifica quel valore, è possibile che la prima parte del codice non faccia ciò per cui è stata progettata. La causa di questo tipo di bug può essere difficile da rintracciare a posteriori, soprattutto quando la seconda parte del codice modifica il valore solo qualche volta. Il compilatore di Rust garantisce che quando si afferma che un valore non cambierà, non cambierà davvero, quindi non dovrai tenerne traccia tu stesso. Il tuo codice sarà quindi più facile da analizzare.

Ma la mutabilità può essere molto utile e può rendere il codice più comodo da scrivere. Sebbene le variabili siano immutabili come impostazione predefinita, puoi renderle mutabili aggiungendo mut davanti al nome della variabile, come hai fatto nel Capitolo 2. L’aggiunta di mut rende anche palese quando si andrà a rileggere il codice in futuro che altre parti del codice cambieranno il valore di questa variabile.

Ad esempio, cambiamo src/main.rs con il seguente:

File: src/main.rs

fn main() {
    let mut x = 5;
    println!("Il valore di x è: {x}");
    x = 6;
    println!("Il valore di x è: {x}");
}

Quando eseguiamo il programma ora, otteniamo questo:

$ cargo run
   Compiling variabili v0.1.0 (file:///progetti/variabili)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.49s
     Running `target/debug/variabili`
Il valore di x è: 5
Il valore di x è: 6

Siamo autorizzati a cambiare il valore legato a x da 5 a 6 quando si usa mut. In definitiva, decidere se usare la mutabilità o meno dipende da te e da ciò che ritieni più utile in quella particolare situazione.

Dichiarare le Costanti

Come le variabili immutabili, le costanti sono valori legati a un nome che non possono essere modificati, ma ci sono alcune differenze tra le costanti e le variabili.

Innanzitutto, non puoi usare mut con le costanti. Le costanti non solo sono immutabili come impostazione predefinita, sono sempre immutabili. Dichiari le costanti usando la parola chiave const invece della parola chiave let e il type del valore deve essere annotato. Tratteremo i type e le annotazioni dei type nella prossima sezione, “Tipi di Dato”, quindi non preoccuparti dei dettagli in questo momento. Sappi solo che devi sempre annotare il type.

Le costanti possono essere dichiarate in qualsiasi scope, compreso quello globale, il che le rende utili per i valori che molte parti del codice devono conoscere.

L’ultima differenza è che le costanti possono essere impostate solo su un’espressione costante, non sul risultato di un valore che può essere calcolato solo in fase di esecuzione.

Ecco un esempio di dichiarazione di una costante:

#![allow(unused)]
fn main() {
const TRE_ORE_IN_SECONDI: u32 = 60 * 60 * 3;
}

Il nome della costante è TRE_ORE_IN_SECONDI e il suo valore è impostato come il risultato della moltiplicazione di 60 (il numero di secondi in un minuto) per 60 (il numero di minuti in un’ora) per 3 (il numero di ore che vogliamo contare in questo programma). La convenzione di Rust per la denominazione delle costanti prevede l’uso di maiuscole con trattini bassi tra le parole. Il compilatore è in grado di valutare il risultato di un’operazione in fase di compilazione, il che ci permette di scegliere di scrivere questo valore in un modo più facile da capire e da verificare, piuttosto che impostare questa costante al valore 10.800. Consulta la sezione Valutazione delle costanti (in inglese) per maggiori informazioni sulle operazioni che possono essere utilizzate quando si dichiarano le costanti.

Le costanti sono valide per tutto il tempo di esecuzione di un programma, all’interno dello scope in cui sono state dichiarate. Questa proprietà rende le costanti utili per dei valori nella tua applicazione che più parti del programma potrebbero avere bisogno di conoscere, come ad esempio il numero massimo di punti che un giocatore di un gioco può guadagnare o la velocità della luce.

Dichiarare come costanti i valori codificati usati nel tuo programma è utile per trasmettere il significato di quel valore a chi leggerà il codice in futuro. Inoltre, è utile per avere un solo punto del codice da modificare se il valore codificato deve essere aggiornato in futuro.

Shadowing

Come hai visto nel tutorial sul gioco dell’indovinello nel Capitolo 2, puoi dichiarare una nuova variabile con lo stesso nome di una variabile precedente. I Rustacean dicono che la prima variabile è messa in ombra, shadowing, dalla seconda, il che significa che la seconda variabile è quella che il compilatore vedrà quando userai il nome della variabile. In effetti, la seconda variabile mette in ombra la prima, portando a sé qualsiasi uso del nome della variabile fino a quando non sarà essa stessa messa in ombra o lo scope terminerà. Possiamo fare shadowing di una variabile usando lo stesso nome della variabile e ripetendo l’uso della parola chiave let come segue:

File: src/main.rs

fn main() {
    let x = 5;

    let x = x + 1;

    {
        let x = x * 2;
        println!("Il valore di x nello scope interno è: {x}");
    }

    println!("Il valore di x è: {x}");
}

Questo programma vincola innanzitutto x a un valore di 5. Poi crea una nuova variabile x ripetendo let x =, prendendo il valore originale e aggiungendo 1 in modo che il valore di x sia 6. Quindi, all’interno di uno scope interno creato con le parentesi graffe, la terza istruzione let mette in ombra x e crea una nuova variabile, moltiplicando il valore precedente per 2 per dare a x un valore di 12. Quando lo scope termina, finisce pure lo shadowing e x torna a essere 6. Quando si esegue questo programma, si ottiene il seguente risultato:

$ cargo run
   Compiling variabili v0.1.0 (file:///progetti/variabili)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.29s
     Running `target/debug/variabili`
Il valore di x nello scope interno è: 12
Il valore di x è: 6

Lo shadowing è diverso dall’indicare una variabile come mut perché otterremo un errore in fase di compilazione se cercassimo accidentalmente di riassegnare questa variabile senza usare la parola chiave let. Usando let, possiamo eseguire alcune trasformazioni su un valore ma far sì che la variabile sia immutabile dopo che le trasformazioni sono completate.

L’altra differenza tra mut e lo shadowing è che, poiché stiamo effettivamente creando una nuova variabile quando usiamo di nuovo la parola chiave let, possiamo cambiare il type del valore ma riutilizzare lo stesso nome. Ad esempio, supponiamo che il nostro programma chieda a un utente di scriverci quanti spazi vuole tra un testo e l’altro inserendo dei caratteri di spazio, e poi vogliamo memorizzare questo input come un numero:

fn main() {
    let spazi = "   ";
    let spazi = spazi.len();
}

La prima variabile spazi è di type stringa e la seconda variabile spazi è di type numerico. Lo shadowing ci evita quindi di dover inventare nomi diversi, come spazi_str e spazi_num; possiamo invece riutilizzare il nome più semplice spazi. Tuttavia, se proviamo a usare mut per fare questa cosa, come mostrato qui, otterremo un errore di compilazione:

fn main() {
    let mut spazi = "   ";
    spazi = spazi.len();
}

L’errore dice che non è consentito mutare il type di una variabile:

$ cargo run
   Compiling variabili v0.1.0 (file:///progetti/variabili)
error[E0308]: mismatched types
 --> src/main.rs:4:13
  |
3 |     let mut spazi = "   ";
  |                     ----- expected due to this value
4 |     spazi = spazi.len();
  |             ^^^^^^^^^^^ expected `&str`, found `usize`

For more information about this error, try `rustc --explain E0308`.
error: could not compile `variabili` (bin "variabili") due to 1 previous error

Ora che abbiamo visto il funzionamento delle variabili, passiamo in rassegna le varie tipologie di dato, type, che possono essere.

Tipi di Dato

Ogni valore in Rust è di un determinato type, il che dice a Rust che tipo di dati vengono specificati in modo che sappia come lavorare con quei dati. Esamineremo due sottoinsiemi di tipi di dati: scalare e composto. Tieni presente che Rust è un linguaggio tipizzato staticamente, il che significa che deve conoscere il type di tutte le variabili in fase di compilazione. Il compilatore di solito può dedurre quale type vogliamo utilizzare in base al valore e al modo in cui lo utilizziamo. Nei casi in cui sono possibili molteplici type, come quando abbiamo convertito uno String in un type numerico usando parse nella sezione “Confrontare l’ipotesi con il numero segreto” del Capitolo 2, dobbiamo aggiungere un’annotazione, specificando il type in questo modo:

fn main() {
    let ipotesi: u32 = "42".parse().expect("Non è un numero!");
}

Se non aggiungiamo l’annotazione del type : u32 mostrata nel codice precedente, Rust visualizzerà il seguente errore, il che significa che il compilatore ha bisogno di ulteriori informazioni per sapere quale type vogliamo utilizzare:

$ cargo build
   Compiling annotazione_senza_type v0.1.0 (file:///progetti/annotazione_senza_type)

error[E0284]: type annotations needed
 --> src/main.rs:3:9
  |
3 |     let ipotesi = "42".parse().expect("Non è un numero!");
  |         ^^^^^^^        ----- type must be known at this point
  |
  = note: cannot satisfy `<_ as FromStr>::Err == _`
help: consider giving `ipotesi` an explicit type
  |
3 |     let ipotesi: /* Type */ = "42".parse().expect("Non è un numero!");
  |                ++++++++++++

For more information about this error, try `rustc --explain E0284`.
error: could not compile `annotazione_senza_type` (bin "annotazione_senza_type") due to 1 previous error; 1 warning emitted

Potrai vedere annotazioni di type diverso per altri tipi di dati.

I Type Scalari

Un type scalare rappresenta un singolo valore. Rust ha quattro type scalari primari: numeri interi, numeri in virgola mobile, booleani e caratteri. Potresti riconoscerli da altri linguaggi di programmazione. Andiamo a vedere come funzionano in Rust.

Il Type Intero

Un intero, integer d’ora in poi, è un numero senza una componente frazionaria. Nel Capitolo 2 abbiamo utilizzato un tipo integer, il type u32. Questa dichiarazione del type indica che il valore a cui è associato deve essere un integer senza segno (i type integer con segno iniziano con i invece che con u) che occupa 32 bit di spazio. La Tabella 3-1 mostra i type integer incorporati in Rust. Possiamo usare una qualsiasi di queste varianti per dichiarare il type di un valore intero.

Tabella 3-1: Type Integer in Rust

Ogni variante può essere con segno o senza e ha una dimensione esplicita. Con segno e senza segno si riferisce alla possibilità che il numero sia negativo. In altre parole, se il numero deve avere un segno con sé (signed in inglese) o se sarà sempre e solo positivo e potrà quindi essere rappresentato senza segno (unsigned in inglese). È come scrivere numeri su carta: quando il segno conta, un numero viene indicato con il segno più o con il segno meno; tuttavia, quando è lecito ritenere che il numero sia positivo, viene visualizzato senza segno. I numeri con segno vengono memorizzati utilizzando la rappresentazione del complemento a due.

Ogni variante con segno può memorizzare numeri da -(2^{n - 1}) a 2ⁿ

• 1 - 1 inclusi, dove n è il numero di bit che la variante utilizza. Quindi, un i8 può memorizzare numeri da -(2⁷) a 2⁷ - 1, il che equivale a -128 a 127. Le varianti senza segno possono memorizzare numeri da 0 a 2ⁿ - 1, quindi un u8 può memorizzare numeri da 0 a 2 ⁸ - 1, il che equivale a 0 a 255.

Inoltre, i type isize e usize dipendono dall’architettura del computer su cui viene eseguito il programma: 64 bit se si tratta di un’architettura a 64 bit e 32 bit se si tratta di un’architettura a 32 bit.

Puoi scrivere i letterali integer in una qualsiasi delle forme mostrate nella Tabella 3-2. Nota che i letterali numerici che possono essere di più type numerici permettono, tramite un suffisso, di specificarne il type in questo modo 57u8. I letterali numerici possono anche usare _ come separatore visivo per rendere il numero più facile da leggere, come ad esempio 1_000, che avrà lo stesso valore che avrebbe se avessi specificato 1000.

Tabella 3-2: letterali Integer in Rust

Come si fa a sapere quale type numerico utilizzare? Se non sei sicuro, le impostazioni predefinite di Rust sono in genere un buon punto di partenza: il type integer di default è i32. La situazione principale in cui puoi usare isize o usize è quando indicizzi qualche tipo di collezione.

Il Type a Virgola Mobile

Rust ha anche due type primitivi per i numeri in virgola mobile, abbreviato float in inglese, che sono numeri con punti decimali. I type in virgola mobile di Rust sono f32 e f64, rispettivamente di 32 e 64 bit. Il tipo predefinito è f64 perché sulle CPU moderne ha più o meno la stessa velocità di f32 ma è in grado di garantire una maggiore precisione. Tutti i type in virgola mobile sono con segno.

Ecco un esempio che mostra i numeri in virgola mobile in azione:

File: src/main.rs

fn main() {
    let x = 2.0; // f64

    let y: f32 = 3.0; // f32
}

I numeri in virgola mobile sono rappresentati secondo lo standard IEEE-754.

Operazioni Numeriche

Rust supporta le operazioni matematiche di base che ti aspetteresti per tutte le tipologie di numero: addizione, sottrazione, moltiplicazione, divisione e resto. La divisione degli interi tronca verso lo zero al numero intero più vicino. Il codice seguente mostra come utilizzare ogni operazione numerica in una dichiarazione let:

File: src/main.rs

fn main() {
    // addizione
    let somma = 5 + 10;

    // sottrazione
    let differenza = 95.5 - 4.3;

    // multiplicazione
    let prodotto = 4 * 30;

    // divisione
    let quoziente = 56.7 / 32.2;
    let troncato = -5 / 3; // Restituisce -1

    // resto
    let resto = 43 % 5;
}

Ogni espressione in queste dichiarazioni utilizza un operatore matematico e valuta un singolo valore, che viene poi legato a una variabile. Appendice B contiene un elenco di tutti gli operatori che Rust mette a disposizione.

Il Type Booleano

Come nella maggior parte degli altri linguaggi di programmazione, un type booleano in Rust ha due valori possibili: vero o falso (true e false rispettivamente d’ora in poi). I booleani hanno la dimensione di un byte. Il type booleano in Rust viene specificato con bool. Ad esempio:

File: src/main.rs

fn main() {
    let t = true;

    let f: bool = false; // con specificazione del type
}

Il modo principale per utilizzare i valori booleani è attraverso i condizionali, come ad esempio un’espressione if. Tratteremo il funzionamento delle espressioni if in Rust nella sezione “Controllare il flusso”.

Il Type Carattere

Il type carattere (char d’ora in poi) di Rust è il tipo alfabetico più primitivo del linguaggio. Ecco alcuni esempi di dichiarazione di valori char:

File: src/main.rs

fn main() {
    let c = 'z';
    let z: char = 'ℤ'; // con specificazione del type
    let gattino_innamorato = '😻';
}

Nota che specifichiamo i letterali char con le singole virgolette, al contrario dei letterali stringa, che utilizzano le virgolette doppie. Il type char di Rust ha la dimensione di 4 byte e rappresenta un valore scalare Unicode, il che significa che può rappresentare molte altre cose oltre all’ASCII. Le lettere accentate, i caratteri cinesi, giapponesi e coreani, le emoji e gli spazi a larghezza zero sono tutti valori char validi in Rust. I valori scalari Unicode vanno da U+0000 a U+D7FF e da U+E000 a U+10FFFF inclusi. Tuttavia, un “carattere” non è un concetto vero e proprio in Unicode, quindi quello che tu potresti concettualmente pensare essere un “carattere” potrebbe non corrispondere a cosa sia effettivamente un char in Rust. Discuteremo questo argomento in dettaglio in “Memorizzare testo codificato UTF-8 con le stringhe” nel Capitolo 8.

I Type Composti

I type composti possono raggruppare più valori in un unico type. Rust ha due type composti primitivi: le tuple e gli array.

Il Type Tupla

Una tupla è un modo generale per raggruppare una serie di valori di tipo diverso in un unico type composto. Le tuple hanno una lunghezza fissa: una volta dichiarate, non possono crescere o diminuire di dimensione. Creiamo una tupla scrivendo un elenco di valori separati da virgole all’interno di parentesi tonde. Ogni posizione nella tupla ha un type e i type dei diversi valori nella tupla non devono essere necessariamente gli stessi. In questo esempio abbiamo aggiunto annotazioni del type opzionali:

File: src/main.rs

fn main() {
    let tup: (i32, f64, u8) = (500, 6.4, 1);
}

La variabile tup si lega all’intera tupla perché una tupla è considerata un singolo elemento composto. Per ottenere i singoli valori di una tupla, possiamo fare pattern matching per destrutturare il valore di una tupla, in questo modo:

File: src/main.rs

fn main() {
    let tup = (500, 6.4, 1);

    let (x, y, z) = tup;

    println!("Il valore di y è: {y}");
}

Questo programma crea prima una tupla e la associa alla variabile tup. Quindi utilizza un pattern con let per prendere tup e trasformarlo in tre variabili separate, x, y e z. Questa operazione è chiamata destrutturazione perché spezza la singola tupla in tre parti. Infine, il programma stampa il valore di y, che è 6,4.

Possiamo anche accedere direttamente a un elemento della tupla utilizzando un punto (.) seguito dall’indice del valore a cui vogliamo accedere. Ad esempio:

File: src/main.rs

fn main() {
    let x: (i32, f64, u8) = (500, 6.4, 1);

    let cinque_cento = x.0;

    let sei_virgola_quattro = x.1;

    let uno = x.2;
}

Questo programma crea la tupla x e poi accede a ogni elemento della tupla utilizzando i rispettivi indici. Come nella maggior parte dei linguaggi di programmazione, il primo indice di una tupla è 0.

La tupla senza valori ha un nome speciale, unit. Questo valore e il suo type corrispondente sono entrambi scritti () e rappresentano un valore vuoto o un type di ritorno vuoto. Le espressioni restituiscono implicitamente il valore unit se non restituiscono nessun altro valore.

Il Type Array

Un altro modo per avere una collezione di valori multipli è un array. A differenza di una tupla, ogni elemento di un array deve avere lo stesso type. A differenza degli array in altri linguaggi, gli array in Rust hanno una lunghezza fissa.

Scriviamo i valori di un array come un elenco separato da virgole all’interno di parentesi quadre:

File: src/main.rs

fn main() {
    let a = [1, 2, 3, 4, 5];
}

Gli array sono utili quando vuoi che i tuoi dati siano allocati sullo stack, come gli altri type che abbiamo visto finora, piuttosto che nell’heap (parleremo dello stack e dell’heap in modo più approfondito nel Capitolo 4) o quando vuoi assicurarti di avere sempre un numero fisso di elementi. Un array, però, non è flessibile come il type vettore (vector d’ora in poi). Un vector è un type simile, che consente la collezione di dati, fornito dalla libreria standard ma che è autorizzato a crescere o a ridursi di dimensione perché il suo contenuto risiede nell’heap. Se non sei sicuro se usare un array o un vector, è probabile che tu debba usare un vector. Il Capitolo 8 tratta i vector in modo più dettagliato.

Tuttavia, gli array sono più utili quando sai che il numero di elementi non dovrà cambiare. Ad esempio, se dovessi utilizzare i nomi dei mesi in un programma, probabilmente utilizzeresti un array piuttosto che un vector perché sai che conterrà sempre 12 elementi:

#![allow(unused)]
fn main() {
let mesi = ["Gennaio", "Febbraio", "Marzo", "Aprile", "Maggio", "Giugno",
            "Luglio", "Agosto", "Settembre", "Ottobre", "Novembre", "Dicembre"];
}

Il type array si scrive utilizzando le parentesi quadre con il type di ogni elemento, il punto e virgola e il numero di elementi dell’array, in questo modo:

#![allow(unused)]
fn main() {
let a: [i32; 5] = [1, 2, 3, 4, 5];
}

In questo caso, i32 è il type di ogni elemento. Dopo il punto e virgola, il numero 5 indica che l’array contiene cinque elementi.

Puoi anche inizializzare un array in modo che contenga lo stesso valore per ogni elemento specificando il valore iniziale, seguito da un punto e virgola, e poi la lunghezza dell’array tra parentesi quadre, come mostrato qui:

#![allow(unused)]
fn main() {
let a = [3; 5];
}

L’array chiamato a conterrà 5 elementi che saranno tutti impostati inizialmente al valore 3. Questo equivale a scrivere let a = [3, 3, 3, 3, 3]; ma in modo più conciso.

Accedere Agli Elementi dell’Array

Un array è un singolo blocco di memoria di dimensione fissa e nota che può essere allocato nello stack. Puoi accedere agli elementi di un array utilizzando l’indicizzazione, in questo modo:

File: src/main.rs

fn main() {
    let a = [1, 2, 3, 4, 5];

    let primo = a[0];
    let secondo = a[1];
}

In questo esempio, la variabile denominata primo otterrà il valore 1 perché è il valore all’indice [0] dell’array. La variabile denominata secondo otterrà il valore 2 dall’indice [1] dell’array.

Accedere Agli Elementi Non Validi dell’Array

Vediamo cosa succede se cerchi di accedere a un elemento di un array che si trova oltre la fine dell’array stesso. Supponiamo di eseguire questo codice, simile al gioco di indovinelli del Capitolo 2, per ottenere un indice dell’array dall’utente:

File: src/main.rs

use std::io;

fn main() {
    let a = [1, 2, 3, 4, 5];

    println!("Digita un indice dell'array.");

    let mut indice = String::new();

    io::stdin()
        .read_line(&mut indice)
        .expect("Errore di lettura");

    let indice: usize = indice
        .trim()
        .parse()
        .expect("L'indice inserito non è un numero");

    let elemento = a[indice];

    println!("Il valore dell'elemento all'indice {indice} è: {elemento}");
}

Se esegui questo codice utilizzando cargo run e inserisci 0, 1, 2, 3 o 4, il programma stamperà il valore corrispondente a quell’indice nell’array. Se invece inserisci un numero oltre la fine dell’array, come ad esempio 10, vedrai un risultato come questo:

thread 'main' panicked at src/main.rs:19:20:
index out of bounds: the len is 5 but the index is 10
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Il programma ha generato un errore durante l’esecuzione (at runtime in inglese) nel momento in cui ha utilizzato un valore non valido nell’operazione di indicizzazione. Il programma è uscito con un messaggio di errore e non ha eseguito l’istruzione finale println!. Quando si tenta di accedere a un elemento utilizzando l’indicizzazione, Rust controlla che l’indice specificato sia inferiore alla lunghezza dell’array. Se l’indice è maggiore o uguale alla lunghezza, Rust va in panic. Questo controllo deve avvenire durante l’esecuzione, soprattutto in questo caso, perché il compilatore non può sapere quale valore inserirà l’utente quando eseguirà il codice in seguito.

Questo è un esempio dei principi di sicurezza della memoria di Rust in azione. In molti linguaggi di basso livello, questo tipo di controllo non viene fatto e quando si fornisce un indice errato, si può accedere a una memoria non valida. Rust ti protegge da questo tipo di errore uscendo immediatamente invece di consentire l’accesso alla memoria e continuare. Il Capitolo 9 tratta di altri aspetti della gestione degli errori di Rust e di come puoi scrivere codice leggibile e sicuro che non va in panic né consente l’accesso non valido alla memoria.

Funzioni

Le funzioni sono molto diffuse nel codice di Rust. Hai già visto una delle funzioni più importanti del linguaggio: la funzione main, che è il punto di ingresso di molti programmi. Hai anche visto la parola chiave fn, che ti permette di dichiarare nuove funzioni.

Il codice Rust utilizza lo snake case come stile convenzionale per i nomi di funzioni e variabili, in cui tutte le lettere sono minuscole e i trattini bassi separano le parole. Ecco un programma che contiene un esempio di definizione di funzione:

File: src/main.rs

fn main() {
    println!("Hello, world!");

    altra_funzione();
}

fn altra_funzione() {
    println!("Un'altra funzione.");
}

In Rust definiamo una funzione inserendo fn seguito dal nome della funzione e da una serie di parentesi tonde. Le parentesi graffe indicano al compilatore dove inizia e finisce il corpo della funzione.

Possiamo chiamare qualsiasi funzione che abbiamo definito inserendo il suo nome seguito da una serie di parentesi tonde. Poiché altra_funzione è definita nel programma, può essere chiamata dall’interno della funzione main. Nota che abbiamo definito altra_funzione dopo la funzione main nel codice sorgente; avremmo potuto definirla anche prima. A Rust non interessa dove definisci le tue funzioni, ma solo che siano definite in una parte del codice che sia “visibile”, in scope, al chiamante.

Cominciamo un nuovo progetto binario chiamato funzioni per esplorare ulteriormente le funzioni. Inserisci l’esempio altra_funzione in src/main.rs ed eseguilo. Dovresti vedere il seguente output:

$ cargo run
   Compiling funzioni v0.1.0 (file:///progetti/funzioni)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.37s
     Running `target/debug/funzioni`
Hello, world!
Un'altra funzione.

Le righe vengono eseguite nell’ordine in cui appaiono nella funzione main. Prima viene stampato il messaggio “Hello, world!”, poi viene chiamata altra_funzione e viene stampato il suo messaggio.

Parametri

Possiamo definire le funzioni in modo che abbiano dei parametri, ovvero delle variabili speciali che fanno parte della firma di una funzione. Quando una funzione ha dei parametri, puoi fornirle dei valori concreti per questi parametri. Tecnicamente, i valori concreti sono chiamati argomenti, ma in una conversazione informale si tende a usare le parole parametro e argomento in modo intercambiabile, sia per le variabili nella definizione di una funzione che per i valori concreti passati quando si chiama una funzione.

In questa versione di altra_funzione aggiungiamo un parametro:

File: src/main.rs

fn main() {
    altra_funzione(5);
}

fn altra_funzione(x: i32) {
    println!("Il valore di x è: {x}");
}

Prova a eseguire questo programma; dovresti ottenere il seguente risultato:

$ cargo run
   Compiling funzioni v0.1.0 (file:///progetti/funzioni)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.36s
     Running `target/debug/funzioni`
Il valore di x è: 5

La dichiarazione di altra_funzione ha un parametro chiamato x. Il type di x è specificato come i32. Quando passiamo 5 ad altra_funzione, la macro println! mette 5 nel punto in cui si trovava la coppia di parentesi graffe contenente x nella stringa di formato.

Nelle firme delle funzioni è obbligatorio dichiarare il type di ogni parametro. Si tratta di una decisione deliberata nel design di Rust: richiedere le annotazioni sul type nelle definizioni delle funzioni significa che il compilatore non ha quasi mai bisogno che tu le usi in altre parti del codice per capire a quale type ti riferisci. In questo modo il compilatore potrà anche dare messaggi di errore più utili se sa quali type si aspetta la funzione.

Quando definisci più parametri, separa le dichiarazioni dei parametri con delle virgole, in questo modo:

File: src/main.rs

fn main() {
    stampa_unita_misura(5, 'h');
}

fn stampa_unita_misura(valore: i32, unita_misura: char) {
    println!("La misura è : {valore}{unita_misura}");
}

Questo esempio crea una funzione chiamata stampa_unita_misura con due parametri. Il primo parametro si chiama valore ed è un i32. Il secondo si chiama unita_misura ed è di type char. La funzione stampa quindi un testo contenente sia il valore che unita_misura.

Eseguiamo il codice. Sostituisci il codice attualmente presente nel file src/main.rs_ del tuo progetto funzioni con l’esempio precedente ed eseguilo con cargo run:

$ cargo run
   Compiling funzioni v0.1.0 (file:///progetti/funzioni)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.39s
     Running `target/debug/funzioni`
La misura è : 5h

Poiché abbiamo chiamato la funzione con 5 come valore per valore e 'h' come valore per unita_misura, l’output del programma contiene questi valori.

Dichiarazioni ed Espressioni

I corpi delle funzioni sono costituiti da una serie di dichiarazioni che possono eventualmente terminare con un’espressione. Finora le funzioni che abbiamo trattato non hanno incluso un’espressione finale, ma hai visto un’espressione come parte di una dichiarazione. Poiché Rust è un linguaggio basato sulle espressioni, questa è una distinzione importante da capire. Altri linguaggi non hanno le stesse distinzioni, quindi vediamo cosa sono le dichiarazioni e le espressioni e come le loro differenze influenzano il corpo delle funzioni.

• Le dichiarazioni sono istruzioni che eseguono un’azione e non restituiscono un valore.
• Le espressioni vengono valutate e restituiscono un valore risultante.

Vediamo alcuni esempi.

In realtà abbiamo già usato le dichiarazioni e le espressioni. Creare una variabile e assegnarle un valore con la parola chiave let è una dichiarazione. Nel Listato 3-1, let y = 6; è una dichiarazione.

fn main() {
    let y = 6;
}

Anche la definizione di una funzione è una dichiarazione; l’intero esempio precedente è, di per sé, una dichiarazione. (Come vedremo più avanti, però, chiamare una funzione non è una dichiarazione.)

Le dichiarazioni non restituiscono valori. Pertanto, non puoi assegnare una dichiarazione let a un’altra variabile, come cerca di fare il codice seguente; otterrai un errore:

File: src/main.rs

fn main() {
    let x = (let y = 6);
}

Quando esegui questo programma, l’errore che otterrai è simile a questo:

$ cargo run
   Compiling funzioni v0.1.0 (file:///progetti/funzioni)
error: expected expression, found `let` statement
 --> src/main.rs:2:14
  |
2 |     let x = (let y = 6);
  |              ^^^
  |
  = note: only supported directly in conditions of `if` and `while` expressions

warning: unnecessary parentheses around assigned value
 --> src/main.rs:2:13
  |
2 |     let x = (let y = 6);
  |             ^         ^
  |
  = note: `#[warn(unused_parens)]` on by default
help: remove these parentheses
  |
2 -     let x = (let y = 6);
2 +     let x = let y = 6;
  |

warning: `funzioni` (bin "funzioni") generated 1 warning
error: could not compile `funzioni` (bin "funzioni") due to 1 previous error; 1 warning emitted

La dichiarazione let y = 6 non restituisce un valore, quindi non c’è nulla a cui x possa legarsi. Questo è diverso da ciò che accade in altri linguaggi, come C e Ruby, dove l’assegnazione restituisce il valore dell’assegnazione. In questi linguaggi, puoi scrivere x = y = 6 e far sì che sia x che y abbiano il valore 6; questo non è il caso di Rust.

Le espressioni che valutate restituiscono un valore costituiscono la maggior parte del resto del codice che scriverai in Rust. Considera un’operazione matematica, come 5 + 6, che è un’espressione che restituisce il valore 11. Le espressioni possono far parte di dichiarazioni: nel Listato 3-1, il 6 nella dichiarazione let y = 6; è un’espressione che valuta il valore 6. Chiamare una funzione è un’espressione. Chiamare una macro è un’espressione. Pure definire tramite parentesi graffe un nuovo scope ad esempio:

File: src/main.rs

fn main() {
    let y = {
        let x = 3;
        x + 1
    };

    println!("Il valore di y è: {y}");
}

Questa espressione:

{
    let x = 3;
    x + 1
}

è un blocco che, in questo caso, valuta 4. Questo valore viene legato a y come parte dell’istruzione let. Nota che la riga x + 1 non ha un punto e virgola alla fine, il che è diverso dalla maggior parte delle righe che hai visto finora. Le espressioni non includono il punto e virgola finale. Se aggiungi un punto e virgola alla fine di un’espressione, la trasformi in una dichiarazione e quindi non restituirà un valore. Tienilo a mente mentre leggi il prossimo paragrafo sui valori di ritorno delle funzioni e le espressioni.

Funzioni con Valori di Ritorno

Le funzioni possono restituire dei valori al codice che le chiama. Non assegniamo un nome ai valori di ritorno, ma dobbiamo esplicitarne il type dopo una freccia (->). In Rust, il valore di ritorno della funzione è sinonimo del valore dell’espressione finale nel blocco del corpo della funzione. Puoi far ritornare un valore anche in anticipo alla funzione usando la parola chiave return e specificando un valore, ma la maggior parte delle funzioni restituisce l’ultima espressione in modo implicito. Ecco un esempio di funzione che restituisce un valore:

File: src/main.rs

fn cinque() -> i32 {
    5
}

fn main() {
    let x = cinque();

    println!("Il valore di x è: {x}");
}

Non ci sono chiamate di funzione, macro o dichiarazioni let nella funzione cinque, ma solo il numero 5 da solo. Si tratta di una funzione perfettamente valida in Rust. Nota che anche il type di ritorno della funzione è specificato come -> i32. Prova a eseguire questo codice; l’output dovrebbe essere simile a questo:

$ cargo run
   Compiling funzioni v0.1.0 (file:///progetti/funzioni)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.34s
     Running `target/debug/funzioni`
Il valore di x è: 5

Il 5 in cinque è il valore di ritorno della funzione, motivo per cui il type di ritorno è i32. Esaminiamo il tutto più in dettaglio. Ci sono due elementi importanti: innanzitutto, la riga let x = cinque(); mostra che stiamo utilizzando il valore di ritorno di una funzione per inizializzare una variabile. Poiché la funzione cinque restituisce un 5, questa riga è uguale alla seguente:

#![allow(unused)]
fn main() {
let x = 5;
}

In secondo luogo, la funzione cinque non ha parametri e definisce il type del valore di ritorno, ma il corpo della funzione è un solitario 5 senza punto e virgola perché è un’espressione il cui valore vogliamo restituire.

Vediamo un altro esempio:

File: src/main.rs

fn main() {
    let x = più_uno(5);

    println!("Il valore di x è: {x}");
}

fn più_uno(x: i32) -> i32 {
    x + 1
}

Eseguendo questo codice verrà stampato Il valore di x è: 6. Ma che succede se inseriamo un punto e virgola alla fine della riga contenente x + 1, trasformandola da espressione a dichiarazione?

File: src/main.rs

fn main() {
    let x = più_uno(5);

    println!("Il valore di x è: {x}");
}

fn più_uno(x: i32) -> i32 {
    x + 1;
}

La compilazione di questo codice produrrà un errore, come segue:

$ cargo run
   Compiling funzioni v0.1.0 (file:///progetti/funzioni)
error[E0308]: mismatched types
 --> src/main.rs:7:23
  |
7 | fn più_uno(x: i32) -> i32 {
  |    -------            ^^^ expected `i32`, found `()`
  |    |
  |    implicitly returns `()` as its body has no tail or `return` expression
8 |     x + 1;
  |          - help: remove this semicolon to return this value

For more information about this error, try `rustc --explain E0308`.
error: could not compile `funzioni` (bin "funzioni") due to 1 previous error

Il messaggio di errore principale, mismatched types (type incompatibili), rivela il problema principale di questo codice. La definizione della funzione più_uno dice che restituirà un i32, ma le dichiarazioni non risultano in un valore, restituendo un (), il type unit. Pertanto, non viene restituito nulla, il che contraddice la definizione della funzione e provoca un errore. In questo output, Rust fornisce un messaggio che può aiutare a correggere questo problema: suggerisce di rimuovere il punto e virgola, che risolverebbe l’errore.

Commenti

Tutti i programmatori si sforzano di rendere il loro codice facile da capire, ma a volte è necessario fornire ulteriori spiegazioni. In questi casi, i programmatori lasciano dei commenti nel loro codice sorgente che il compilatore ignorerà ma che chi legge il codice sorgente potrebbe trovare utili.

Ecco un semplice commento:

#![allow(unused)]
fn main() {
// hello, world
}

In Rust, lo stile idiomatico di commento inizia un commento con due barre oblique, slash in inglese, e il commento continua fino alla fine della riga. Per i commenti che si estendono oltre una singola riga, dovrai includere // su ogni riga, come in questo caso:

#![allow(unused)]
fn main() {
// Stiamo facendo qualcosa di complicato, tanto da aver bisogno di
// più righe di commento per farlo! Speriamo che questo commento possa
// spiegare cosa sta succedendo.
}

I commenti possono essere inseriti anche alla fine delle righe contenenti codice:

File: src/main.rs

fn main() {
    let numero_fortunato = 7; // Oggi mi sento fortunato
}

Ma più spesso li vedrai utilizzati in questo formato, con il commento su una riga separata sopra il codice che sta annotando:

File: src/main.rs

fn main() {
    // Oggi mi sento fortunato
    let numero_fortunato = 7;
}

Rust ha anche un altro tipo di commento, i commenti alla documentazione, di cui parleremo nella sezione “Pubblicazione di un Crate su Crates.io” del Capitolo 14.

Controllare il Flusso

La possibilità di eseguire del codice a seconda che una condizione sia vera e la possibilità di eseguire ripetutamente del codice finché una data condizione è vera sono elementi fondamentali della maggior parte dei linguaggi di programmazione. I costrutti più comuni che ti permettono di controllare il flusso di esecuzione del codice in Rust sono le espressioni if e i cicli.

L’Espressione if

Un’espressione if (se in italiano) ti permette di ramificare il tuo codice a seconda delle condizioni. Fornisci una condizione e poi dici: “Se questa condizione è soddisfatta, esegui questo blocco di codice. Se la condizione non è soddisfatta, non eseguire questo blocco di codice”.

Crea un nuovo progetto chiamato ramificazioni nella tua directory progetti per sperimentare con l’espressione if. Nel file src/main.rs, inserisci quanto segue:

File: src/main.rs

fn main() {
    let numero = 3;

    if numero < 5 {
        println!("condizione era vera");
    } else {
        println!("condizione era falsa");
    }
}

Tutte le espressioni if iniziano con la parola chiave if, seguita da una condizione. In questo caso, la condizione verifica se la variabile numero ha o meno un valore inferiore a 5. Il blocco di codice da eseguire se la condizione è true viene posizionato subito dopo la condizione, all’interno di parentesi graffe. I blocchi di codice associati alle condizioni nelle espressioni if possono esser viste come dei rami, proprio come i rami nelle espressioni match di cui abbiamo parlato nella sezione “Confrontare l’ipotesi con il numero segreto” del Capitolo 2.

Opzionalmente, possiamo anche includere un’espressione else (altrimenti in italiano), come abbiamo scelto di fare in questo caso, per dare al programma un blocco di codice alternativo da eseguire nel caso in cui la condizione sia valutata false. Se non fornisci un’espressione else e la condizione è false, il programma salterà il blocco if e passerà alla parte di codice successiva.

Prova a eseguire questo codice; dovresti vedere il seguente risultato:

$ cargo run
   Compiling ramificazioni v0.1.0 (file:///progetti/ramificazioni)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 1.06s
     Running `target/debug/ramificazioni`
condizione era vera

Proviamo a cambiare il valore di numero con un valore che renda la condizione false per vedere cosa succede:

fn main() {
    let numero = 7;

    if numero < 5 {
        println!("condizione era vera");
    } else {
        println!("condizione era falsa");
    }
}

Esegui nuovamente il programma e guarda l’output:

$ cargo run
   Compiling ramificazioni v0.1.0 (file:///progetti/ramificazioni)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.38s
     Running `target/debug/ramificazioni`
condizione era falsa

Vale anche la pena di notare che la condizione in questo codice deve essere un bool. Se la condizione non è un bool, otterremo un errore. Ad esempio, prova a eseguire il seguente codice:

File: src/main.rs

fn main() {
    let numero = 3;

    if numero {
        println!("numero era tre");
    }
}

Questa volta la condizione if valuta un valore di 3 e Rust lancia un errore:

$ cargo run
   Compiling ramificazioni v0.1.0 (file:///progetti/ramificazioni)
error[E0308]: mismatched types
 --> src/main.rs:4:8
  |
4 |     if numero {
  |        ^^^^^^ expected `bool`, found integer

For more information about this error, try `rustc --explain E0308`.
error: could not compile `ramificazioni` (bin "ramificazioni") due to 1 previous error

L’errore indica che Rust si aspettava un bool ma ha ottenuto un numero intero. A differenza di linguaggi come Ruby e JavaScript, Rust non cercherà automaticamente di convertire i type non booleani in booleani. Devi essere esplicito e fornire sempre ad if un’espressione booleana come condizione. Se vogliamo che il blocco di codice if venga eseguito solo quando un numero non è uguale a 0, ad esempio, possiamo modificare l’espressione if nel seguente modo:

File: src/main.rs

fn main() {
    let numero = 3;

    if numero != 0 {
        println!("numero era qualcosa di diverso da zero");
    }
}

L’esecuzione di questo codice stamperà numero era qualcosa di diverso da zero.

Gestire Condizioni Multiple con else if

Puoi utilizzare condizioni multiple combinando if e else in un’espressione else if. Ad esempio:

File: src/main.rs

fn main() {
    let numero = 6;

    if numero % 4 == 0 {
        println!("numero è divisibile per 4");
    } else if numero % 3 == 0 {
        println!("numero è divisibile per 3");
    } else if numero % 2 == 0 {
        println!("numero è divisibile per 2");
    } else {
        println!("numero non è divisibile per by 4, 3, o 2");
    }
}

Questo programma ha quattro possibili rami. Dopo averlo eseguito, dovresti vedere il seguente output:

$ cargo run
   Compiling ramificazioni v0.1.0 (file:///progetti/ramificazioni)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.36s
     Running `target/debug/ramificazioni`
numero è divisibile per 3

Quando questo programma viene eseguito, controlla ogni espressione if a turno ed esegue il primo corpo per il quale la condizione è valutata true. Nota che anche se 6 è divisibile per 2, non vediamo l’output numero è divisibile per 2, né vediamo il testo numero non è divisibile per 4, 3 o 2 del blocco else. Questo perché Rust esegue il blocco solo per la prima condizione true e una volta che ne trova una, le restanti non vengono controllate.

L’uso di troppe espressioni else if può rendere il codice un po’ confusionario e difficile da leggere, quindi se ne hai più di una, potresti valutare di riscrivere il codice. Il Capitolo 6 descrive un potente costrutto di ramificazione di Rust chiamato match per gestire casi del genere.

Utilizzare if in Una Dichiarazione let

Dato che if è un’espressione, possiamo usarla a destra di una dichiarazione let per assegnare il risultato a una variabile, come nel Listato 3-2.

fn main() {
    let condizione = true;
    let numero = if condizione { 5 } else { 6 };

    println!("Il valore di numero è: {numero}");
}

La variabile numero sarà legata a un valore basato sul risultato dell’espressione if. Esegui questo codice per vedere cosa succede:

$ cargo run
   Compiling ramificazioni v0.1.0 (file:///progetti/ramificazioni)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.40s
     Running `target/debug/ramificazioni`
Il valore di numero è: 5

Ricorda che i blocchi di codice valutano l’ultima espressione in essi contenuta e i numeri da soli sono anch’essi espressioni. In questo caso, il valore dell’intera espressione if dipende da quale blocco di codice viene eseguito. Ciò significa che i valori che possono essere i risultati di ogni ramo di if devono essere dello stesso tipo; nel Listato 3-2, i risultati sia del ramo if che del ramo else erano numeri interi i32. Se i type non sono corrispondenti, come nell’esempio seguente, otterremo un errore:

File: src/main.rs

fn main() {
    let condizione = true;

    let numero = if condizione { 5 } else { "sei" };

    println!("Il valore di numero è: {numero}");
}

Quando proviamo a compilare questo codice, otterremo un errore: i rami if e else hanno type incompatibili e Rust indica esattamente dove trovare il problema nel programma:

$ cargo run
   Compiling ramificazioni v0.1.0 (file:///progetti/ramificazioni)
error[E0308]: `if` and `else` have incompatible types
 --> src/main.rs:4:45
  |
4 |     let numero = if condizione { 5 } else { "sei" };
  |                                  -          ^^^^^ expected integer, found `&str`
  |                                  |
  |                                  expected because of this

For more information about this error, try `rustc --explain E0308`.
error: could not compile `ramificazioni` (bin "ramificazioni") due to 1 previous error

L’espressione nel blocco if ritorna un integer e l’espressione nel blocco else ritorna una stringa. Questo non funziona perché le variabili devono avere un type univoco e Rust ha bisogno di sapere definitivamente in fase di compilazione di che type è la variabile numero. Conoscere il type di numero permette al compilatore di verificare che il type sia valido ovunque si utilizzi numero. Rust non sarebbe in grado di farlo se il type di numero fosse determinato solo in fase di esecuzione; il compilatore sarebbe più complesso e darebbe meno garanzie sul codice se dovesse tenere traccia dei più disparati type possibili per ogni variabile.

Ripetizione con i Cicli

Spesso è utile eseguire un blocco di codice più di una volta. Per questo compito, Rust mette a disposizione diversi cicli (loop in inglese), che eseguono il codice all’interno del corpo del ciclo fino alla fine e poi ripartono immediatamente dall’inizio. Per sperimentare con i cicli, creiamo un nuovo progetto chiamato cicli.

Rust mette a disposizione tre tipologie di ciclo: loop, while e for. Proviamo ciascuno di essi.

Ripetere il Codice con loop

La parola chiave loop dice a Rust di eseguire un blocco di codice più e più volte per sempre o finché non gli dici esplicitamente di fermarsi.

A titolo di esempio, modifica il file src/main.rs nella tua cartella cicli in questo modo:

File: src/main.rs

fn main() {
    loop {
        println!("ancora!");
    }
}

Quando eseguiamo questo programma, vedremo ancora! stampato in continuazione fino a quando non interromperemo il programma manualmente. La maggior parte dei terminali supporta la scorciatoia da tastiera ctrl-C per interrompere un programma che è bloccato in un ciclo continuo. Provaci:

$ cargo run
   Compiling cicli v0.1.0 (file:///progetti/cicli)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.08s
     Running `target/debug/cicli`
ancora!
ancora!
ancora!
ancora!
^C!

Il simbolo ^C rappresenta quando hai premuto ctrl-C.

Potresti vedere o meno la parola ancora! stampata dopo la ^C, a seconda di dove si trovava il codice nel ciclo quando ha ricevuto il segnale di interruzione.

Fortunatamente, Rust offre anche un modo per uscire da un ciclo utilizzando del codice. Puoi inserire la parola chiave break all’interno del ciclo per indicare al programma quando interrompere l’esecuzione del ciclo. Ricorda che abbiamo fatto questo nel gioco di indovinelli nella sezione “Uscire dopo un’ipotesi corretta” del Capitolo 2 per uscire dal programma quando l’utente indovinava il numero segreto.

Nel gioco di indovinelli abbiamo usato anche continue, che in un ciclo indica al programma di saltare tutto il codice rimanente in questa iterazione del ciclo e di passare all’iterazione successiva.

Restituire Valori dai Cicli

Uno degli utilizzi di un loop è quello di riprovare un’operazione che sai che potrebbe fallire, come ad esempio controllare se un thread ha completato il suo lavoro. Potresti anche aver bisogno di passare il risultato di questa operazione al di fuori del ciclo al resto del tuo codice. Per farlo, puoi aggiungere il valore che vuoi che venga restituito dopo l’espressione break che utilizzi per interrompere il ciclo; quel valore verrà restituito al di fuori del ciclo in modo da poterlo utilizzare, come mostrato qui:

fn main() {
    let mut contatore = 0;

    let risultato = loop {
        contatore += 1;

        if contatore == 10 {
            break contatore * 2;
        }
    };

    println!("Il risultato è {risultato}");
}

Prima del ciclo, dichiariamo una variabile chiamata contatore e la inizializziamo a 0. Poi dichiariamo una variabile chiamata risultato per contenere il valore restituito dal ciclo. A ogni iterazione del ciclo, aggiungiamo 1 alla variabile contatore e poi controlliamo se contatore è uguale a 10. Quando lo è, usiamo la parola chiave break con il valore contatore * 2. Dopo il ciclo, usiamo un punto e virgola per terminare l’istruzione che assegna il valore a risultato. Infine, stampiamo il valore in risultato, che in questo caso è 20.

Puoi anche usare return all’interno di un ciclo. Mentre break esce solo dal ciclo corrente, return esce sempre dalla funzione corrente.

Distinguere con le Etichette di Loop

Se hai un ciclo annidato all’interno di un altro ciclo, break e continue si applicano al loop più interno in quel momento. Puoi specificare facoltativamente un’etichetta (loop label) su uno specifico ciclo per poi usare con break o continue quell’etichetta per specificare a quale ciclo applicare l’istruzione. Le loop label devono iniziare con una virgoletta singola. Ecco un esempio con due cicli annidati:

fn main() {
    let mut conteggio = 0;
    'aumenta_conteggio: loop {
        println!("conteggio = {conteggio}");
        let mut rimanente = 10;

        loop {
            println!("rimanente = {rimanente}");
            if rimanente == 9 {
                break;
            }
            if conteggio == 2 {
                break 'aumenta_conteggio;
            }
            rimanente -= 1;
        }

        conteggio += 1;
    }
    println!("Fine conteggio = {conteggio}");
}

Il ciclo esterno ha la label 'aumenta_conteggio e conta da 0 a 2. Il ciclo interno senza label conta da 10 a 9. Il primo break che non specifica una label esce solo dal ciclo interno. L’istruzione break 'aumenta_conteggio; esce dal ciclo esterno. Questo codice stamperà:

$ cargo run
   Compiling cicli v0.1.0 (file:///progetti/cicli)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.35s
     Running `target/debug/cicli`
conteggio = 0
rimanente = 10
rimanente = 9
conteggio = 1
rimanente = 10
rimanente = 9
conteggio = 2
rimanente = 10
Fine conteggio = 2

Semplificare Cicli Condizionali con while

Spesso un programma ha bisogno di valutare una condizione all’interno di un ciclo. Quando la condizione è true, il ciclo viene eseguito. Quando la condizione cessa di essere true, il programma chiama break, interrompendo il ciclo. È possibile implementare un comportamento del genere utilizzando una combinazione di loop, if, else e break; se vuoi, puoi provare a farlo in un programma. Tuttavia, questo schema è così comune che Rust ha un costrutto di linguaggio incorporato per questi casi, chiamato ciclo while (finché in italiano). Nel Listato 3-3, usiamo while per eseguire il ciclo del programma tre volte, contando alla rovescia ogni volta, e poi, dopo il ciclo, stampiamo un messaggio e usciamo.

fn main() {
    let mut numero = 3;

    while numero != 0 {
        println!("{numero}!");

        numero -= 1;
    }

    println!("PARTENZA!!!");
}

Questo costrutto elimina un sacco di annidamenti che sarebbero necessari se usassi loop, if, else e break, ed è di più semplice lettura. Finché una condizione risulta true, il codice viene eseguito; altrimenti, esce dal ciclo.

Eseguire un Ciclo su una Collezione con for

Puoi scegliere di utilizzare il costrutto while per eseguire un ciclo sugli elementi di una collezione, come un array. Ad esempio, il ciclo nel Listato 3-4 stampa ogni elemento dell’array a.

fn main() {
    let a = [10, 20, 30, 40, 50];
    let mut indice = 0;

    while indice < 5 {
        println!("il valore è: {}", a[indice]);

        indice += 1;
    }
}

In questo caso, il codice conteggia tutti gli elementi dell’array: inizia dall’indice 0 e poi esegue un ciclo fino a raggiungere l’ultimo indice dell’array (cioè quando indice < 5 non è più true). L’esecuzione di questo codice stamperà ogni elemento dell’array:

$ cargo run
   Compiling cicli v0.1.0 (file:///progetti/cicli)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.36s
     Running `target/debug/cicli`
il valore è: 10
il valore è: 20
il valore è: 30
il valore è: 40
il valore è: 50

Tutti e cinque i valori dell’array appaiono nel terminale, come previsto. Anche se indice raggiungerà un valore di 5 a un certo punto, il ciclo viene bloccato prima che si tenti di leggere un sesto elemento dell’array.

Tuttavia, questo approccio è incline all’errore; potremmo causare il panic del programma se il valore dell’indice o la condizione di test non sono corretti. Per esempio, se cambiassi la definizione dell’array a per avere quattro elementi, ma dimenticassi di aggiornare la condizione a while indice < 4, il codice andrebbe in panic. È anche lento, perché il compilatore aggiunge codice di esecuzione per eseguire il controllo condizionale per verificare se l’indice è entro i limiti dell’array a ogni iterazione del ciclo.

Come alternativa più concisa, puoi usare un ciclo for ed eseguire del codice per ogni elemento di una collezione. Un ciclo for assomiglia al codice del Listato 3-5.

fn main() {
    let a = [10, 20, 30, 40, 50];

    for elemento in a {
        println!("il valore è: {elemento}");
    }
}

Quando eseguiamo questo codice, vedremo lo stesso risultato del Listato 3-4. Ma, cosa più importante, abbiamo aumentato la sicurezza del codice ed eliminato la possibilità di bug che potrebbero derivare dall’andare oltre la fine dell’array o dal non accedere ad ogni elemento dell’array. Il codice macchina generato dai cicli for può essere anche più efficiente, perché l’indice non deve essere confrontato con la lunghezza dell’array a ogni iterazione.

Utilizzando il ciclo for, non dovrai ricordarti di modificare altro codice se cambierai il numero di valori nell’array, come invece faresti con il metodo while usato nel Listato 3-4.

La sicurezza e la concisione dei cicli for li rendono il costrutto di ciclo più usato in Rust. Anche nelle situazioni in cui vuoi eseguire un certo numero di volte il codice, come nell’esempio del conto alla rovescia che utilizzava un ciclo while nel Listato 3-3, la maggior parte dei Rustacean userebbe un ciclo for. Il modo per farlo sarebbe quello di usare un Range, fornito dalla libreria standard, che genera tutti i numeri in sequenza partendo da un numero e finendo prima di un altro numero.

Ecco come apparirebbe il conto alla rovescia utilizzando un ciclo for e un altro metodo di cui non abbiamo ancora parlato, rev, per invertire l’intervallo.

File: src/main.rs

fn main() {
    for numero in (1..4).rev() {
        println!("{numero}!");
    }
    println!("PARTENZA!!!");
}

Questo codice è un po’ più carino, vero?

Riepilogo

Ce l’hai fatta! Questo capitolo è stato molto impegnativo: hai imparato a conoscere le variabili, i type di dati scalari e composti, le funzioni, i commenti, le espressioni if e i cicli! Per esercitarti con i concetti discussi in questo capitolo, prova a costruire dei programmi per eseguire le seguenti operazioni:

• Convertire le temperature tra Fahrenheit e Celsius.
• Generare l’n-esimo numero di Fibonacci.
• Stampare il testo del canto natalizio “The Twelve Days of Christmas”, sfruttando la ripetizione della canzone.

Quando sarai pronto per andare avanti, parleremo di un concetto di Rust che non esiste in altri linguaggi di programmazione: la ownership.

Capire la Ownership

Il controllo esclusivo o proprietà (la ownership d’ora in poi) è la caratteristica più qualificante di Rust e ha profonde implicazioni per il resto del linguaggio. Permette a Rust di garantire la sicurezza dei dati in memoria senza bisogno di un garbage collector, quindi è importante capire come funziona la ownership. In questo capitolo parleremo della ownership e di diverse caratteristiche correlate: il prestito (borrowing d’ora in poi), le slice e il modo in cui Rust dispone i dati in memoria.

Cos’è la Ownership?

La ownership è un insieme di regole che disciplinano la gestione della memoria da parte di un programma Rust. Tutti i programmi devono gestire il modo in cui utilizzano la memoria del computer durante l’esecuzione. Alcuni linguaggi hanno una garbage collection che cerca regolarmente la memoria non più utilizzata durante l’esecuzione del programma; in altri linguaggi, il programmatore deve allocare e rilasciare esplicitamente la memoria. Rust utilizza un terzo approccio: la memoria viene gestita attraverso un sistema di controllo esclusivo con un insieme di regole che il compilatore controlla. Se una qualsiasi delle regole viene violata, il programma non viene compilato. Nessuna delle caratteristiche di ownership rallenterà il tuo programma mentre è in esecuzione.

Poiché la ownership è un concetto nuovo per molti programmatori, ci vuole un po’ di tempo per abituarsi. La buona notizia è che più si acquisisce esperienza con Rust e con le regole del sistema di ownership, più sarà facile sviluppare naturalmente codice sicuro ed efficiente. Non mollare!

Quando capirai la ownership, avrai una solida base per comprendere le caratteristiche che rendono Rust unico. In questo capitolo imparerai la ownership lavorando su alcuni esempi che si concentrano su una struttura di dati molto comune: le stringhe.

Regole di Ownership

Per prima cosa, diamo un’occhiata alle regole di ownership, tenendole a mente mentre lavoriamo agli esempi che le illustrano:

• Ogni valore in Rust ha un proprietario, owner.
• Ci può essere un solo owner alla volta.
• Quando l’owner esce dallo scope, il valore viene rilasciato.

Scope delle Variabili

Ora che abbiamo visto e imparato la sintassi di base di Rust, non includeremo tutto il codice fn main() { negli esempi, quindi se stai seguendo, assicurati di inserire manualmente i seguenti esempi all’interno di una funzione main. Di conseguenza, i nostri esempi saranno un po’ più concisi, permettendoci di concentrarci sui dettagli reali piuttosto che sul codice di base.

Come primo esempio di ownership, analizzeremo lo scope di alcune variabili. Lo scope è l’ambito all’interno di un programma nel quale un elemento è valido. Prendiamo la seguente variabile:

#![allow(unused)]
fn main() {
let s = "ciao";
}

La variabile s si riferisce a un letterale stringa, il cui valore è codificato nel testo del nostro programma. La variabile è valida dal momento in cui viene dichiarata fino alla fine dello scope corrente. Il Listato 4-1 mostra un programma con commenti che annotano i punti in cui la variabile s sarebbe valida (in scope).

fn main() {
    {                      // `s` non è valida qui, perché non ancora dichiarata
        let s = "hello";   // `s` è valida da questo punto in poi

        // fai cose con `s`
    }                      // questo scope è finito, e `s` non è più valida
}

In altre parole, ci sono due momenti importanti:

• Quando s entra nello scope, è valida;
• Rimane valida fino a quando non esce dallo scope.

A questo punto, la relazione tra scope e validità delle variabili è simile a quella di altri linguaggi di programmazione. Ora ci baseremo su questa comprensione introducendo il type String.

Il Type String

Per illustrare le regole di ownership, abbiamo bisogno di un tipo di dati più complesso di quelli trattati nel Capitolo 3. I type trattati in precedenza hanno dimensioni note, possono essere inseriti e estratti sullo stack quando il loro scope è terminato, possono essere rapidamente copiati per creare una nuova istanza indipendente se un’altra parte del codice deve utilizzare lo stesso valore in uno scope diverso. Ma vogliamo esaminare i dati archiviati nell’heap e capire come Rust sa quando ripulire la memoria che quei dati usavano quando non serve più, e il type String è un ottimo esempio da cui partire.

Ci concentreremo sulle parti di String che riguardano la ownership. Questi aspetti si applicano anche ad altri type di dati complessi, siano essi forniti dalla libreria standard o creati dall’utente. Parleremo di String oltre l’aspetto della ownership nel Capitolo 8.

Abbiamo già visto i letterali stringa, in cui un valore stringa è codificato nel nostro programma. I letterali stringa sono convenienti, ma non sono adatti a tutte le situazioni in cui potremmo voler utilizzare del testo. Uno dei motivi è che sono immutabili. Un altro è che non tutti i valori di stringa possono essere conosciuti quando scriviamo il nostro codice: ad esempio, cosa succederebbe se volessimo prendere l’input dell’utente e memorizzarlo? È per queste situazioni che Rust ha un il type String. Questo type gestisce i dati allocati nell’heap e come tale è in grado di memorizzare una quantità di testo a noi sconosciuta in fase di compilazione. Puoi creare un type String partendo da un letterale stringa utilizzando la funzione from, in questo modo:

#![allow(unused)]
fn main() {
let s = String::from("ciao");
}

L’operatore double colon (doppio - due punti) :: ci permette di integrare questa particolare funzione from nel type String piuttosto che usare un nome come string_from. Parleremo di questa sintassi nella sezione “Sintassi dei metodi” del Capitolo 5 e quando parleremo di come organizzare la nomenclatura nei moduli in “Percorsi per fare riferimento a un elemento nell’albero dei moduli” nel Capitolo 7.

Questo tipo di stringa può essere mutata:

fn main() {
    let mut s = String::from("hello");

    s.push_str(", world!"); // push_str() aggiunge un letterale a una String

    println!("{s}");        // verrà stampato `hello, world!`
}

Allora, qual è la differenza? Perché String può essere mutata ma i letterali no? La differenza sta nel modo in cui questi due type vengono gestiti in memoria.

Memoria e Allocazione

Nel caso di un letterale stringa, conosciamo il contenuto al momento della compilazione, quindi il testo è codificato direttamente nell’eseguibile finale. Per questo motivo i letterali stringa sono veloci ed efficienti. Ma queste proprietà derivano solo dall’immutabilità del letterale stringa. Sfortunatamente, non possiamo inserire una porzione di memoria indefinita nel binario per ogni pezzo di testo la cui dimensione è sconosciuta al momento della compilazione e la cui dimensione potrebbe cambiare durante l’esecuzione del programma.

Con il type String, per supportare una porzione di testo mutabile e espandibile, dobbiamo allocare una quantità di memoria nell’heap, sconosciuta in fase di compilazione, per contenere il contenuto. Questo significa che:

• La memoria deve essere richiesta all’allocatore di memoria in fase di esecuzione.
• Abbiamo bisogno di un modo per restituire questa memoria all’allocatore quando abbiamo finito con la nostra String.

La prima parte la facciamo noi: quando chiamiamo String::from, la sua implementazione richiede la memoria di cui ha bisogno. Questo è praticamente universale nei linguaggi di programmazione.

Tuttavia, la seconda parte è diversa. Nei linguaggi con un garbage collector (GC), il GC tiene traccia e ripulisce la memoria che non viene più utilizzata e non abbiamo bisogno di pensarci. Nella maggior parte dei linguaggi senza GC, è nostra responsabilità identificare quando la memoria non viene più utilizzata e chiamare il codice per de-allocarla esplicitamente, proprio come abbiamo fatto per richiederla. Farlo correttamente è stato storicamente un difficile problema di programmazione. Se ce lo dimentichiamo, sprecheremo memoria. Se lo facciamo troppo presto, avremo una variabile non valida. Se lo facciamo due volte, anche questo è un bug. Dobbiamo accoppiare esattamente un’allocazione con esattamente una de-allocazione (o rilascio, liberazione).

Rust prende una strada diversa: la memoria viene rilasciata automaticamente una volta che la variabile che la possiede esce dallo scope. Ecco una versione del nostro esempio sullo scope che utilizza una String invece di un letterale stringa:

fn main() {
    {
        let s = String::from("hello"); // `s` è valida da questo punto in poi

        // fai cose con `s`
    }   // questo scope è finito, e `s` non è più valida
}

C’è un punto naturale in cui possiamo rilasciare la memoria di cui la nostra String ha bisogno all’allocatore: quando s esce dallo scope. Quando una variabile esce dallo scope, Rust chiama per noi una funzione speciale. Questa funzione si chiama drop, ed è dove l’autore di String può inserire il codice per rilasciare la memoria. Rust chiama drop automaticamente alla parentesi graffa di chiusura.

Nota: in C++, questo schema di de-allocazione delle risorse alla fine del ciclo di vita di un elemento è talvolta chiamato Resource Acquisition Is Initialization (RAII). La funzione drop di Rust ti sarà familiare se hai usato gli schemi RAII.

Questo schema ha un profondo impatto sul modo in cui viene scritto il codice Rust. Può sembrare semplice in questo momento, ma il comportamento del codice può essere inaspettato in situazioni più complicate quando vogliamo che più variabili utilizzino i dati che abbiamo allocato nell’heap. Esploriamo ora alcune di queste situazioni.

Interazione tra Variabili e Dati con Move

In Rust, più variabili possono interagire con gli stessi dati in modi diversi. Il Listato 4-2 mostra un esempio che utilizza un integer.

fn main() {
    let x = 5;
    let y = x;
}

Probabilmente possiamo indovinare cosa sta facendo: “Associa il valore 5 a x; quindi crea una copia del valore in x e associala a y.” Ora abbiamo due variabili, x e y, ed entrambe uguali a 5. Questo è effettivamente ciò che sta accadendo. Poiché gli integer sono valori semplici con una dimensione fissa e nota, questi due valori 5 vengono immessi sullo stack.

Ora diamo un’occhiata alla versione con String:

fn main() {
    let s1 = String::from("hello");
    let s2 = s1;
}

Sembra molto simile, quindi potremmo pensare che il funzionamento sia lo stesso: cioè che la seconda riga faccia una copia del valore in s1 e lo assegni a s2. Ma non è esattamente quello che succede.

Nella Figura 4-1 diamo un’occhiata sotto le coperte per vedere com’è in realtà una String. Una String è composta da tre parti, mostrate a sinistra: un puntatore (ptr) alla memoria che contiene il contenuto della stringa, una lunghezza (len) e una capienza (capacity). Questo gruppo di dati è memorizzato sullo stack. A destra c’è la memoria nell’heap che contiene il contenuto.

Figura 4-1: La representazione in memoria di una String con valore "hello" assegnato a s1

La lunghezza è la quantità di memoria, in byte, utilizzata attualmente dal contenuto della String. La capienza è la quantità totale di memoria, in byte, che String ha ricevuto dall’allocatore. La differenza tra lunghezza e capacità è importante, ma non in questo contesto, quindi per ora va bene ignorare la capienza.

Quando assegniamo s1 a s2, i dati String vengono copiati, ovvero copiamo il puntatore, la lunghezza e la capienza presenti sullo stack. Non copiamo i dati nell’heap a cui fa riferimento il puntatore. In altre parole, la rappresentazione dei dati in memoria è simile alla Figura 4-2.

Figura 4-2: La rappresentazione in memoria della variabile s2 che contiene una copia del puntatore, lunghezza e capienza di s1

La rappresentazione non assomiglia alla Figura 4-3, che è l’aspetto che avrebbe la memoria se Rust copiasse anche i dati dell’heap. Se Rust facesse così, l’operazione s2 = s1 potrebbe diventare molto dispendiosa in termini prestazionali e di memoria qualora i dati nell’heap fossero di grandi dimensioni.

Figura 4-3: Un’altra possibilità di come potrebbe essere s2 = s1 se Rust copiasse anche i dati dell’heap

In precedenza, abbiamo detto che quando una variabile esce dallo scope, Rust chiama automaticamente la funzione drop e ripulisce la memoria nell’heap di quella variabile. Ma la Figura 4-2 mostra entrambi i puntatori di dati che puntano alla stessa posizione. Questo è un problema: quando s2 e s1 escono dallo scope, entrambe tenteranno di de-allocare la stessa memoria. Questo è noto come errore da doppia de-allocazione (double free error in inglese) ed è uno dei bug di sicurezza della memoria menzionati in precedenza. Rilasciare la memoria due volte può portare a corruzione di memoria, che può potenzialmente esporre il programma a vulnerabilità di sicurezza.

Per garantire la sicurezza della memoria, dopo la riga let s2 = s1;, Rust considera s1 come non più valido. Pertanto, Rust non ha bisogno di de-allocare nulla quando s1 esce dallo scope. Controlla cosa succede quando provi a usare s1 dopo che s2 è stato creato: non funzionerà:

fn main() {
    let s1 = String::from("hello");
    let s2 = s1;

    println!("{s1}, world!");
}

Otterrai un errore di questo tipo perché Rust ti impedisce di utilizzare il riferimento invalidato:

$ cargo run
   Compiling ownership v0.1.0 (file:///progetti/ownership)
error[E0382]: borrow of moved value: `s1`
 --> src/main.rs:6:16
  |
3 |     let s1 = String::from("hello");
  |         -- move occurs because `s1` has type `String`, which does not implement the `Copy` trait
4 |     let s2 = s1;
  |              -- value moved here
5 |
6 |     println!("{s1}, world!");
  |                ^^ value borrowed here after move
  |
  = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
help: consider cloning the value if the performance cost is acceptable
  |
4 |     let s2 = s1.clone();
  |                ++++++++

For more information about this error, try `rustc --explain E0382`.
error: could not compile `ownership` (bin "ownership") due to 1 previous error

Se hai sentito i termini copia superficiale e copia profonda mentre lavoravi con altri linguaggi, il concetto di copiare il puntatore, la lunghezza e la capacità senza copiare i dati probabilmente ti sembrerà simile a una copia superficiale. Ma poiché Rust invalida anche la prima variabile, invece di essere chiamata copia superficiale, questa operazione è nota come move (spostamento). In questo esempio, diremmo che s1 è stata spostata in s2. Quindi, ciò che accade in realtà è mostrato nella Figura 4-4.

Figura 4-4: La rappresentazione in memoria dopo che s1 è resa non valida

Questo risolve il nostro problema! Con la sola s2 valida, quando essa uscirà dallo scope, solo lei rilascerà la memoria e il gioco è fatto.

Inoltre, c’è una scelta progettuale implicita in questo: Rust non creerà mai automaticamente copie “profonde” dei tuoi dati. Pertanto, si può presupporre che qualsiasi copia automatica sia poco dispendiosa in termini prestazionali e di memoria.

Scope e Assegnazione

L’opposto di ciò è vero anche per la relazione tra scope, ownership e memoria rilasciata tramite la funzione drop. Quando assegni un valore completamente nuovo a una variabile esistente, Rust chiamerà drop e libererà immediatamente la memoria del valore originale. Considera questo codice, ad esempio:

fn main() {
    let mut s = String::from("hello");
    s = String::from("ciao");

    println!("{s}, world!");
}

Inizialmente dichiariamo una variabile s e la associamo a una String con il valore "hello". Poi creiamo immediatamente una nuova String con il valore "ciao" e la assegniamo a s. A questo punto, non c’è più nulla che faccia riferimento al valore originale nell’heap. La Figura 4-5 mostra i dati sullo stack e nell’heap al momento:

Figura 4-5: La rappresentazione in memoria dopo che il primo valore è completamente sostituito.

La stringa originale esce così immediatamente dallo scope. Rust eseguirà la funzione drop su di essa e la sua memoria verrà rilasciata immediatamente. Quando stamperemo il valore alla fine, sarà "ciao, world!".

Interazione tra Variabili e Dati con Clone

Se vogliamo effettivamente duplicare i dati nell’heap della String, e non solo i dati sullo stack, possiamo utilizzare un metodo comune chiamato clone. Parleremo della sintassi dei metodi nel Capitolo 5, ma dato che i metodi sono una caratteristica comune a molti linguaggi di programmazione, probabilmente li hai già visti.

Ecco un esempio del metodo clone in azione:

fn main() {
    let s1 = String::from("hello");
    let s2 = s1.clone();

    println!("s1 = {s1}, s2 = {s2}");
}

Questo funziona benissimo e produce esplicitamente il comportamento mostrato nella Figura 4-3, in cui i anche i dati dell’heap vengono duplicati.

Quando vedi una chiamata a clone, sai che viene eseguito del codice arbitrario e che questo potrebbe essere dispendioso. È un indicatore visivo del fatto che sta succedendo qualcosa di diverso.

Duplicare Dati Sullo Stack

C’è un’altra peculiarità di cui non abbiamo ancora parlato: questo codice che utilizza gli integer, in parte mostrato nel Listato 4-2, funziona ed è valido

fn main() {
    let x = 5;
    let y = x;

    println!("x = {x}, y = {y}");
}

Ma questo codice sembra contraddire ciò che abbiamo appena imparato: non abbiamo una chiamata a clone, ma x è ancora valido e non è stato spostato in y.

Il motivo è che i type come gli integer che hanno una dimensione nota in fase di compilazione vengono archiviati interamente sullo stack, quindi le copie dei valori effettivi sono veloci da creare. Ciò significa che non c’è motivo per cui vorremmo impedire che x sia valido dopo aver creato la variabile y. In altre parole, qui non c’è differenza tra copia profonda e superficiale, quindi chiamare clone non farebbe nulla di diverso dalla solita copia superficiale e possiamo tralasciarlo.

Rust ha un’annotazione speciale chiamata tratto Copy che possiamo appiccicare sui type memorizzati sullo stack, come lo sono gli integer (parleremo meglio dei tratti nel Capitolo 10). Se un type implementa il tratto Copy, le variabili che lo utilizzano non si spostano, ma vengono semplicemente copiate, rendendole ancora valide dopo l’assegnazione ad un’altra variabile.

Rust non ci permette di annotare un type con Copy se il type, o una qualsiasi delle sue parti, ha implementato il tratto Drop. Se il type ha bisogno che accada qualcosa di speciale quando il valore esce dallo scope e aggiungiamo l’annotazione Copy a quel type, otterremo un errore in fase di compilazione. Per sapere come aggiungere l’annotazione Copy al tuo type, consulta “Tratti derivabili” nell’Appendice C.

Quindi, quali type implementano il tratto Copy? Puoi controllare la documentazione del type in questione per esserne sicuro, ma come regola generale, qualsiasi gruppo di valori scalari semplici può implementare Copy e niente che richieda l’allocazione o che sia una qualche forma di risorsa può implementare Copy:

Ecco alcuni dei type che implementano Copy:

• Tutti i type integer, come u32.
• Il type booleano, bool, con i valori true e false.
• Tutti i type in virgola mobile, come f64.
• Il type carattere, char.
• Le tuple, se contengono solo type che implementano Copy. Ad esempio, (i32, i32) implementa Copy, ma (i32, String) no.

Ownership e Funzioni

I meccanismi che regolano il passaggio di un valore a una funzione sono simili a quelli dell’assegnazione di un valore a una variabile. Passando una variabile a una funzione, questa viene spostata o copiata, proprio come fa l’assegnazione. Il Listato 4-3 contiene un esempio con alcune annotazioni che mostrano dove le variabili entrano ed escono dallo scope.

fn main() {
    let s = String::from("hello"); // `s` entra nello scope

    prende_ownership(s);           // il valore di `s` viene spostato nella funzione...
                                   // ... e quindi qui smette di esser valido

    let x = 5;                     // `x` entra nello scope

    duplica(x);                    // Siccome i32 implementa il tratto Copy,
                                   // `x` NON viene spostato nella funzione,
                                   // quindi dopo può ancora essere usata.

}   // Qui, `x` esce dallo scope, ed anche `s`. Tuttavia, siccome il valore di `s`
    // era stato spostato, non succede nulla di particolare.

fn prende_ownership(una_stringa: String) { // `una_stringa` entra nello scope
    println!("{una_stringa}");
}   // Qui, `una_stringa` esce dallo scope e `drop` viene chiamato.
    // La memoria corrispondente viene rilasciata.

fn duplica(un_integer: i32) { // `un_integer` entra nello scope
    println!("{un_integer}");
}   // Qui, `un_integer` esce dallo scope. Non succede nulla di particolare.

Se provassimo a usare s dopo la chiamata a prende_ownership, Rust segnalerebbe un errore in fase di compilazione. Questi controlli statici ci proteggono dagli errori. Prova ad aggiungere del codice a main che usi s e x per sperimentare dove puoi usarli e dove le regole di ownership te lo impediscono.

Valori di Ritorno e Scope

I valori di ritorno possono anch’essi trasferire la ownership. Il Listato 4-4 mostra un esempio di funzione che restituisce un valore, con annotazioni simili a quelle del Listato 4-3.

fn main() {
    let s1 = cede_ownership();         // `cede_ownership` sposta il proprio
                                       // valore di ritorno in `s1`

    let s2 = String::from("hello");    // `s2` entra in scope

    let s3 = prende_e_restituisce(s2); // `s2` viene spostata in
                                       // `prende_e_restituisce`, che a sua
                                       // volta sposta il proprio valore
                                       // di ritorno in `s3`

} // Qui, `s3` esce dallo scope e viene cancellata con `drop`. `s2` era stata spostata
  // e quindi non succede nulla. `s1` viene cancellata con `drop` anch'essa.

fn cede_ownership() -> String {   // `cede_ownership` spostera il proprio valore di
                                  // ritorno alla funzione che l'ha chiamata

    let una_stringa = String::from("yours"); // `una_stringa` entra in scope

    una_stringa                     // `una_stringa` viene ritornata e spostata
                                    // alla funzione chiamante
}

// Questa funzione prende una String e ritorna una String.
fn prende_e_restituisce(altra_stringa: String) -> String {
                    // `altra_stringa` entra in scope

    altra_stringa   // `altra_stringa` viene ritornata
                    // e spostata alla funzione chiamante
}

La ownership di una variabile segue ogni volta lo stesso schema: assegnare un valore a un’altra variabile la sposta. Quando una variabile che include dati nell’heap esce dallo scope, il valore verrà cancellato da drop a meno che la ownership dei dati non sia stata spostata ad un’altra variabile.

Anche se funziona, prendere e cedere la ownership con ogni funzione è un po’ faticoso. Cosa succede se vogliamo consentire a una funzione di utilizzare un valore ma non di prenderne la ownership? È piuttosto fastidioso che tutto ciò che passiamo debba anche essere restituito se vogliamo usarlo di nuovo, oltre a tutte le varie elaborazioni sui dati che la funzione esegue e che magari è necessario ritornare pure quelle.

Rust ci permette di ritornare più valori utilizzando una tupla, come mostrato nel Listato 4-5

fn main() {
    let s1 = String::from("ciao");

    let (s2, lung) = calcola_lunghezza(s1);

    println!("La lunghezza di '{s2}' è {lung}.");
}

fn calcola_lunghezza(s: String) -> (String, usize) {
    let lunghezza = s.len(); // len() restituisce la lunghezza di una String

    (s, lunghezza)
}

Ma questa è una procedura inutilmente complessa e richiede molto lavoro per un concetto che dovrebbe essere comune. Fortunatamente per noi, Rust ha una funzionalità che consente di utilizzare un valore senza trasferirne la ownership, chiamata riferimento (reference in inglese).

Reference e Borrowing

Il problema con il codice nel Listato 4-5 è che dobbiamo restituire la String alla funzione chiamante in modo da poter ancora utilizzare la String dopo la chiamata a calcola_lunghezza, perché la String è stata spostata in calcola_lunghezza. Possiamo invece fornire un riferimento (reference) al valore String. Un reference è come un puntatore in quanto è un indirizzo che possiamo seguire per accedere ai dati archiviati a quell’indirizzo di memoria; la ownership di quei dati appartiene ad un’altra variabile. A differenza di un puntatore, è garantito che un reference punti a un valore valido di un certo type finché il reference è ancora valido.

Ecco come definiresti e utilizzeresti una funzione calcola_lunghezza che abbia un reference ad un oggetto come parametro invece di assumere la ownership del valore:

fn main() {
    let s1 = String::from("ciao");

    let lung = calcola_lunghezza(&s1);

    println!("La lunghezza di '{s1}' è {lung}.");
}

fn calcola_lunghezza(s: &String) -> usize {
    s.len()
}

Innanzitutto, nota che tutto il codice che dichiarava e ritornava la variabile tupla è sparito. In secondo luogo, nota che passiamo &s1 a calcola_lunghezza e, nella sua definizione del parametro, prendiamo &String anziché String. Il carattere & (E commerciale) rappresenta il reference e consente di fare riferimento a un valore senza prenderne la ownership.

La Figura 4-6 illustra questo concetto.

Figura 4-6: Schema di &String s che punta a String s1

Nota: l’opposto della referenziazione tramite l’uso di & è la de-referenziazione, che si realizza con l’operatore di de-referenziazione * (dereference operator). Vedremo alcuni usi dell’operatore di de-referenziazione nel Capitolo 8 e discuteremo i dettagli della de-referenziazione nel Capitolo 15.

Diamo un’occhiata più da vicino alla chiamata di funzione:

fn main() {
    let s1 = String::from("ciao");

    let lung = calcola_lunghezza(&s1);

    println!("La lunghezza di '{s1}' è {lung}.");
}

fn calcola_lunghezza(s: &String) -> usize {
    s.len()
}

La sintassi &s1 ci permette di creare un reference che punta al valore di s1 ma non lo possiede. Poiché il reference non lo possiede, il valore a cui punta non verrà rilasciato dalla memoria quando il reference smette di essere utilizzato. Allo stesso modo, la firma della funzione utilizza & per indicare che il type del parametro s è un reference. Aggiungiamo alcune annotazioni esplicative:

fn main() {
    let s1 = String::from("ciao");

    let lung = calcola_lunghezza(&s1);

    println!("La lunghezza di '{s1}' è {lung}.");
}

fn calcola_lunghezza(s: &String) -> usize { // `s` è un reference a una String
    s.len()
} // Qui, `s` esce dallo scope. Ma siccome `s` non ha ownership di quello
  // a cui fa riferimento, i valori di String non vengono cancellati

Lo scope in cui la variabile s è valida è lo stesso dello scope di qualsiasi parametro di funzione, ma il valore a cui punta il reference non viene eliminato quando s smette di essere utilizzato, perché s non ha la ownership. Quando le funzioni hanno reference come parametri anziché valori effettivi, non avremo bisogno di restituire i valori per restituire la ownership, perché la ownership non ci è mai stata trasferita.

L’azione di creare un reference viene chiamata borrowing (fare un prestito in italiano). Come nella vita reale, se una persona possiede qualcosa, puoi chiedergliela in prestito. Quando hai finito, devi restituirla. Non la possiedi.

Quindi, cosa succede se proviamo a modificare qualcosa che abbiamo in prestito? Prova il codice nel Listato 4-6. Avviso spoiler: non funziona!

fn main() {
    let s = String::from("hello");

    cambia(&s);
}

fn cambia(una_stringa: &String) {
    una_stringa.push_str(", world");
}

Ecco l’errore:

$ cargo run
   Compiling ownership v0.1.0 (file:///progetti/ownership)
error[E0596]: cannot borrow `*una_stringa` as mutable, as it is behind a `&` reference
 --> src/main.rs:8:5
  |
8 |     una_stringa.push_str(", world");
  |     ^^^^^^^^^^^ `una_stringa` is a `&` reference, so the data it refers to cannot be borrowed as mutable
  |
help: consider changing this to be a mutable reference
  |
7 | fn cambia(una_stringa: &mut String) {
  |                         +++

For more information about this error, try `rustc --explain E0596`.
error: could not compile `ownership` (bin "ownership") due to 1 previous error

Così come le variabili sono immutabili come impostazione predefinita, lo sono anche i reference. Non possiamo modificare qualcosa a cui abbiamo solo un riferimento.

Reference Mutabili

Possiamo correggere il codice del Listato 4-6 per permetterci di modificare un valore preso in prestito con alcune piccole modifiche che utilizzano, invece, un reference mutabile:

fn main() {
    let mut s = String::from("hello");

    cambia(&mut s);
}

fn cambia(una_stringa: &mut String) {
    una_stringa.push_str(", world");
}

Per prima cosa rendiamo s mutabile con mut. Poi creiamo un reference mutabile con &mut s dove chiamiamo la funzione cambia e aggiorniamo la firma della funzione in modo che accetti un reference mutabile con una_stringa: &mut String. In questo modo è molto chiaro che la funzione cambia muterà il valore che prende in prestito. I reference mutabili hanno una grande restrizione: se hai un reference mutabile a un valore, non puoi avere altri reference a quel valore. Questo codice che tenta di creare due reference mutabili a s fallirà:

fn main() {
    let mut s = String::from("hello");

    let r1 = &mut s;
    let r2 = &mut s;

    println!("{r1}, {r2}");
}

Ecco l’errore:

$ cargo run
   Compiling ownership v0.1.0 (file:///progetti/ownership)
error[E0499]: cannot borrow `s` as mutable more than once at a time
 --> src/main.rs:6:14
  |
5 |     let r1 = &mut s;
  |              ------ first mutable borrow occurs here
6 |     let r2 = &mut s;
  |              ^^^^^^ second mutable borrow occurs here
7 |
8 |     println!("{r1}, {r2}");
  |                -- first borrow later used here

For more information about this error, try `rustc --explain E0499`.
error: could not compile `ownership` (bin "ownership") due to 1 previous error

L’errore dice che questo codice non è valido perché non possiamo avere più di un reference mutabile alla volta ad s. Il primo reference mutabile è in r1 e deve durare fino a quando non viene utilizzato nel println!, ma tra la creazione di quel reference mutabile e il suo utilizzo, abbiamo cercato di creare un altro reference mutabile in r2 che prende in prestito gli stessi dati di r1.

La restrizione che impedisce più reference mutabili agli stessi dati contemporaneamente consente la mutazione ma in modo molto controllato. È qualcosa con cui chi comincia a programmare in Rust fatica perché la maggior parte dei linguaggi ti consente di mutare quando vuoi. Il vantaggio di avere questa restrizione è che Rust può prevenire conflitti di accesso ai dati, data race, in fase di compilazione. Una data race è simile a una condizione di competizione e si verifica quando si verificano questi tre comportamenti:

• Due o più puntatori accedono contemporaneamente agli stessi dati.
• Almeno uno dei puntatori viene utilizzato per scrivere nei dati.
• Non viene utilizzato alcun meccanismo per sincronizzare l’accesso ai dati

I data race causano comportamenti non programmati e possono essere difficili da diagnosticare e risolvere quando si cerca di individuarli durante l’esecuzione; Rust previene questo problema rifiutando di compilare codice contenente data race!

Come sempre, possiamo usare le parentesi graffe per creare uno scope nuovo, consentendo di avere più reference mutabili, ma non simultanee:

fn main() {
    let mut s = String::from("ciao");

    {
        let r1 = &mut s;
    }   // qui `r1` esce dallo scope, quindi possiamo creare
        // un nuovo reference senza problemi

    let r2 = &mut s;
}

Rust applica una regola simile per combinare reference mutabili e immutabili. Questo codice genera un errore:

fn main() {
    let mut s = String::from("ciao");

    let r1 = &s;      // nessun problema
    let r2 = &s;      // nessun problema
    let r3 = &mut s;  // GROSSO PROBLEMA

    println!("{r1}, {r2}, e {r3}");
}

Ecco l’errore:

$ cargo run
   Compiling ownership v0.1.0 (file:///progetti/ownership)
error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable
 --> src/main.rs:7:14
  |
5 |     let r1 = &s;      // nessun problema
  |              -- immutable borrow occurs here
6 |     let r2 = &s;      // nessun problema
7 |     let r3 = &mut s;  // GROSSO PROBLEMA
  |              ^^^^^^ mutable borrow occurs here
8 |
9 |     println!("{r1}, {r2}, e {r3}");
  |                -- immutable borrow later used here

For more information about this error, try `rustc --explain E0502`.
error: could not compile `ownership` (bin "ownership") due to 1 previous error

Wow! Non possiamo nemmeno avere un reference mutabile mentre ne abbiamo uno immutabile allo stesso valore.

Chi userà un reference immutabile non si aspetta certo che il valore cambi improvvisamente! Tuttavia, sono consentiti reference multipli immutabili perché nessuno che stia leggendo i dati ha la possibilità di influenzare la lettura dei dati da parte di altri.

Nota che lo scope di un reference inizia dal punto in cui viene introdotto e continua fino all’ultima volta che viene utilizzato. Ad esempio, questo codice verrà compilato perché l’ultimo utilizzo dei reference immutabili avviene nel println!, prima che venga introdotto il reference mutabile:

fn main() {
    let mut s = String::from("ciao");

    let r1 = &s; // nessun problema
    let r2 = &s; // nessun problema
    println!("{r1} and {r2}");
    // Le variabili `r1` e `r2` non verranno più usato dopo questo punto

    let r3 = &mut s; // nessun problema
    println!("{r3}");
}

Gli scope dei reference immutabili r1 e r2 terminano dopo il println! in cui sono stati utilizzati per l’ultima volta, ovvero prima che venga creato il reference mutabile r3. Questi scope non si sovrappongono, quindi questo codice è consentito: il compilatore capisce che il reference non verrà più utilizzato in nessun altro punto prima della fine dello scope.

Anche se a volte gli errori di borrowing possono essere frustranti, ricorda che è il compilatore di Rust a segnalare un potenziale bug in anticipo (in fase di compilazione e non in fase di esecuzione) e a mostrarti esattamente dove si trova il problema. In questo modo non dovrai cercare di capire perché i tuoi dati non sono quelli che pensavi fossero quando il programma è in esecuzione.

Reference Pendenti

Nei linguaggi con puntatori, è facile creare erroneamente un puntatore pendente, cioè un puntatore che fa riferimento a una posizione in memoria non più valido, perché quella memoria assegnata a quella variabile è stata liberata, ma non si è provveduto a cancellare anche il puntatore che per l’appunto rimane pendente puntando a qualcosa che non è più disponibile. In Rust, al contrario, il compilatore garantisce che i reference non diverranno mai pendenti: se si ha un reference ad alcuni dati, il compilatore ci impedirà di usare quel reference dopo che i dati sono usciti dallo scope.

Proviamo a creare un reference pendente per vedere come Rust li previene segnalando un errore in fase di compilazione:

fn main() {
    let reference_a_nulla = pendente();
}

fn pendente() -> &String {
    let s = String::from("ciao");

    &s
}

Ecco l’errore:

$ cargo run
   Compiling ownership v0.1.0 (file:///progetti/ownership)
error[E0106]: missing lifetime specifier
 --> src/main.rs:5:18
  |
5 | fn pendente() -> &String {
  |                  ^ expected named lifetime parameter
  |
  = help: this function's return type contains a borrowed value, but there is no value for it to be borrowed from
help: consider using the `'static` lifetime, but this is uncommon unless you're returning a borrowed value from a `const` or a `static`
  |
5 | fn pendente() -> &'static String {
  |                   +++++++
help: instead, you are more likely to want to return an owned value
  |
5 - fn pendente() -> &String {
5 + fn pendente() -> String {
  |
error[E0515]: cannot return reference to local variable `s`
 --> src/main.rs:8:5
  |
8 |     &s
  |     ^^ returns a reference to data owned by the current function

Some errors have detailed explanations: E0106, E0515.
For more information about an error, try `rustc --explain E0106`.
error: could not compile `ownership` (bin "ownership") due to 2 previous error

Questo messaggio di errore si riferisce a una funzionalità che non abbiamo ancora trattato: la longevità (lifetime d’ora in poi). Parleremo in dettaglio della lifetime nel Capitolo 10. Ma, se trascuriamo le parti relative alla lifetime, il messaggio contiene la chiave del motivo per cui questo codice è un problema:

this function's return type contains a borrowed value, but there is no value
for it to be borrowed from

(traduzione: il type di ritorno di questa funzione contiene un valore in
prestito, ma non c’è alcun valore da cui prenderlo in prestito)

Diamo un’occhiata più da vicino a cosa succede esattamente in ogni fase della nostra funzione pendente:

fn main() {
    let reference_a_nulla = pendente();
}

fn pendente() -> &String { // pendente ritorna un reference a String

    let s = String::from("ciao"); // `s` è una String nuova

    &s // ritorniamo un reference alla String `s`
} // Qui `s` esce dallo scope e viene cancellata, così come la memora assegnatale.
  // Pericolo!

Poiché s viene creato all’interno di pendente, quando il codice di pendente sarà terminato, s e la memoria ad essa assegnata verranno rilasciate. Ma abbiamo cercato di restituire un reference a questa memoria. Ciò significa che questo reference punterebbe a una String non valida. Questo non va bene! Rust non ci permette di farlo.

La soluzione è restituire direttamente la String:

fn main() {
    let stringa = non_pendente();
}

fn non_pendente() -> String {
    let s = String::from("ciao");

    s
}

Questo funziona senza problemi: la ownership viene spostata all’esterno e non viene rilasciato nulla.

Le Regole dei Reference

Ricapitoliamo quello che abbiamo detto sui reference:

• In un dato momento, puoi avere o un singolo reference mutabile o un numero qualsiasi di reference immutabili.
• I reference devono essere sempre validi.

Successivamente, analizzeremo un’altra tipologia di reference: le sezioni (slice in inglese).

Il Type Slice

Le slice (sezioni, fette, porzioni in italiano) ti permettono di fare riferimento (un reference) a una sequenza contigua di elementi in una collezione. Una slice è una tipologia di reference, quindi non ha ownership.

Ecco un piccolo problema di programmazione: scrivi una funzione che prenda una stringa di parole separate da spazi e restituisca la prima parola che trova in quella stringa. Se la funzione non trova uno spazio nella stringa, l’intera stringa deve essere considerata come una sola parola, quindi deve essere restituita l’intera stringa.

Nota: Ai fini dell’introduzione alle slice di stringhe, stiamo assumendo solo caratteri ASCII in questa sezione; una discussione più approfondita sulla gestione di UTF-8 si trova nella sezione “Memorizzare testo codificato UTF-8 con le stringhe” del Capitolo 8.

Lavoriamo su come scrivere la firma di questa funzione senza usare slice per ora, per comprendere il problema che le slice risolveranno:

fn prima_parola(s: &String) -> ?

La funzione prima_parola ha un parametro di tipo &String. Non abbiamo bisogno di ownership, quindi va bene. (In Rust idiomatico, le funzioni non prendono la ownership dei loro argomenti se non strettamente necessario, e i motivi per questo diventeranno chiari man mano che andremo avanti.) Ma cosa dovremmo ritornare? Non abbiamo davvero un modo per descrivere una parte di una stringa. Tuttavia, potremmo restituire l’indice della fine della parola, indicato da uno spazio. Proviamo a farlo, come mostrato nel Listato 4-7.

fn prima_parola(s: &String) -> usize {
    let bytes = s.as_bytes();

    for (i, &lettera) in bytes.iter().enumerate() {
        if lettera == b' ' {
            return i;
        }
    }

    s.len()
}

fn main() {}

Poiché dobbiamo esaminare la String elemento per elemento e controllare se un valore è uno spazio, convertiremo la nostra String in un array di byte usando il metodo as_bytes.

fn prima_parola(s: &String) -> usize {
    let bytes = s.as_bytes();

    for (i, &lettera) in bytes.iter().enumerate() {
        if lettera == b' ' {
            return i;
        }
    }

    s.len()
}

fn main() {}

Successivamente, creiamo un iteratore sull’array di byte usando il metodo iter:

fn prima_parola(s: &String) -> usize {
    let bytes = s.as_bytes();

    for (i, &lettera) in bytes.iter().enumerate() {
        if lettera == b' ' {
            return i;
        }
    }

    s.len()
}

fn main() {}

Discuteremo gli iteratori in modo più dettagliato nel Capitolo 13. Per ora, sappi che iter è un metodo che restituisce ogni elemento in una collezione e che enumerate prende il risultato di iter e restituisce ogni elemento come parte di una tupla. Il primo elemento della tupla restituita da enumerate è l’indice, e il secondo elemento è un riferimento all’elemento. Questo è un po’ più conveniente rispetto a calcolarci l’indice da soli.

Poiché il metodo enumerate restituisce una tupla, possiamo usare i pattern per destrutturare quella tupla. Discuteremo meglio i pattern nel Capitolo 6. Nel ciclo for, specifichiamo un pattern che ha i per l’indice nella tupla e &item per il singolo byte nella tupla. Poiché da .iter().enumerate() otteniamo un reference all’elemento, usiamo & nel pattern.

All’interno del ciclo for, cerchiamo il byte che rappresenta lo spazio usando la sintassi del letterale byte. Se troviamo uno spazio, restituiamo la posizione. Altrimenti, restituiamo la lunghezza della stringa usando s.len().

fn prima_parola(s: &String) -> usize {
    let bytes = s.as_bytes();

    for (i, &lettera) in bytes.iter().enumerate() {
        if lettera == b' ' {
            return i;
        }
    }

    s.len()
}

fn main() {}

Ora abbiamo un metodo per scoprire l’indice della fine della prima parola nella stringa, ma c’è un problema. Stiamo ritornando un usize da solo, che è un numero significativo solo se usato in contesto con &String. In altre parole, poiché è un valore separato dalla String, non c’è garanzia che rimarrà valido in futuro. Considera il programma nel Listing 4-8 che utilizza la funzione prima_parola dal Listing 4-7.

fn prima_parola(s: &String) -> usize {
    let bytes = s.as_bytes();

    for (i, &lettera) in bytes.iter().enumerate() {
        if lettera == b' ' {
            return i;
        }
    }

    s.len()
}

fn main() {
    let mut s = String::from("hello world");

    let parola = prima_parola(&s); // `parola` riceverà il valore 5

    s.clear(); // questo svuota la String, rendendola uguale a ""

    // `parola` mantiene ancora il valore di 5, ma `s` non contiene più quello a cui
    // quel 5 si riferisce, quindi `parola` è adesso considerabile come non valida!
}

Questo programma si compila senza errori e lo farebbe anche se usassimo parola dopo aver chiamato s.clear(). Poiché parola non è collegato allo stato di s, parola contiene ancora il valore 5. Potremmo usare quel valore 5 con la variabile s per cercare di estrarre la prima parola, ma questo sarebbe un bug perché il contenuto di s è cambiato da quando abbiamo salvato 5 in parola.

Doversi preoccupare dell’indice in parola che si disallinea con i dati in s è noioso e soggetto a errori! Gestire questi indici è ancora più fragile se scriviamo una funzione seconda_parola. La sua firma dovrebbe apparire così:

fn seconda_parola(s: &String) -> (usize, usize) {

Ora stiamo tracciando un indice di partenza e un indice di fine, e abbiamo ancora altri valori che sono stati calcolati da dati in un determinato stato, ma che non sono per nulla legati a quello stato in qualche modo. Abbiamo tre variabili non correlate e indipendenti che noi dobbiamo mantenere in sincronia.

Fortunatamente, Rust ha una soluzione a questo problema: le slice di stringhe.

Slice di Stringa

Una slice di stringa (string slice) è un reference a una sequenza contigua degli elementi di una String, e appare così:

fn main() {
    let s = String::from("hello world");

    let hello = &s[0..5];
    let world = &s[6..11];
}

Invece di un reference all’intera String, hello è un reference a una porzione della String, specificata con l’aggiunta di [0..5]. Creiamo le slice usando un intervallo all’interno delle parentesi quadre specificando [indice_inizio..indice_fine], dove indice_inizio è la prima posizione nella slice e indice_fine è l’ultima posizione nella slice più uno. Internamente, la struttura dati della slice memorizza la posizione iniziale e la lunghezza della slice, che corrisponde a indice_fine meno indice_inizio. Quindi, nel caso di let world = &s[6..11];, world sarebbe una slice che contiene un puntatore al byte all’indice 6 di w con un valore di lunghezza di 5.

La Figura 4-7 mostra questo in un diagramma.

Figura 4-7: Slice di stringa che si riferisce a parte di una String

Con la sintassi d’intervallo .. di Rust, se vuoi iniziare dall’indice 0, puoi omettere il valore prima dei due punti. In altre parole, questi sono equivalenti:

#![allow(unused)]
fn main() {
let s = String::from("hello");

let slice = &s[0..2];
let slice = &s[..2];
}

Allo stesso modo, se la tua slice include l’ultimo byte della String, puoi omettere il numero finale. Ciò significa che questi sono equivalenti:

#![allow(unused)]
fn main() {
let s = String::from("hello");

let len = s.len();

let slice = &s[3..len];
let slice = &s[3..];
}

Puoi anche omettere entrambi i valori per prendere una slice dell’intera stringa. Quindi questi sono equivalenti:

#![allow(unused)]
fn main() {
let s = String::from("hello");

let len = s.len();

let slice = &s[0..len];
let slice = &s[..];
}

Nota: Gli indici di intervallo delle slice di stringa devono trovarsi in posizioni valide tenendo conto anche dei caratteri UTF-8. Se tenti di creare una slice nel mezzo di un carattere multi-byte, il tuo programma terminerà con un errore.

Tenendo presente tutte queste informazioni, riscriviamo prima_parola per restituire una slice. Il type che indica la slice di stringa è scritto come &str:

fn prima_parola(s: &String) -> &str {
    let bytes = s.as_bytes();

    for (i, &lettera) in bytes.iter().enumerate() {
        if lettera == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

fn main() {}

Otteniamo l’indice per la fine della parola nello stesso modo in cui lo abbiamo fatto nel Listato 4-7, cercando la prima occorrenza di uno spazio. Quando troviamo uno spazio, restituiamo una slice di stringa usando l’inizio della stringa e l’indice dello spazio come indici di inizio e fine.

Ora, quando chiamiamo prima_parola, otteniamo un singolo valore che è legato ai dati sottostanti. Il valore è composto da un reference al punto di partenza della slice e dal numero di elementi nella slice.

Restituire una slice funzionerebbe anche per una funzione seconda_parola:

fn seconda_parola(s: &String) -> &str {

Ora abbiamo una funzione più semplice in cui è molto più difficile succedano cose strane perché il compilatore garantirà che i reference alla String rimangano validi. Ricordi il bug nel programma nel Listato 4-8, quando abbiamo ottenuto l’indice per la fine della prima parola ma poi abbiamo svuotato la stringa, rendendo il nostro indice non valido? Quel codice era logicamente errato ma non mostrava immediatamente errori. I problemi si sarebbero manifestati più tardi se avessimo continuato a cercare di usare l’indice della prima parola con una stringa svuotata. Le slice rendono questo bug impossibile e ci fanno sapere che abbiamo un problema con il nostro codice molto prima. Usare la versione slice di prima_parola genererà un errore di compilazione:

fn prima_parola(s: &String) -> &str {
    let bytes = s.as_bytes();

    for (i, &lettera) in bytes.iter().enumerate() {
        if lettera == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

fn main() {
    let mut s = String::from("hello world");

    let parola = prima_parola(&s);

    s.clear(); // errore!

    println!("la prima parola è: {parola}");
}

Ecco l’errore del compilatore:

$ cargo run
   Compiling ownership v0.1.0 (file:///progetti/ownership)
error[E0502]: cannot borrow `s` as mutable because it is also borrowed as immutable
  --> src/main.rs:19:5
   |
17 |     let parola = prima_parola(&s);
   |                               -- immutable borrow occurs here
18 |
19 |     s.clear(); // errore!
   |     ^^^^^^^^^ mutable borrow occurs here
20 |
21 |     println!("la prima parola è: {parola}");
   |                                   ------ immutable borrow later used here

For more information about this error, try `rustc --explain E0502`.
error: could not compile `ownership` (bin "ownership") due to 1 previous error

Ricorda le regole di borrowing: se abbiamo un reference immutabile a qualcosa, non possiamo anche prendere un reference mutabile. Poiché clear deve troncare la String, ha bisogno di ottenere un reference mutabile. Il println! dopo la chiamata a clear utilizza il reference a parola, quindi il reference immutabile deve essere ancora attivo a quel punto. Rust vieta che il reference mutabile in clear e il reference immutabile a parola esistano contemporaneamente, e la compilazione fallisce. Non solo Rust ha reso la nostra funzione più facile da usare, ma ha anche eliminato un’intera classe di errori durante la compilazione!

Letterali Stringa come Slice

Ricordi che abbiamo parlato dei letterali stringa memorizzati all’interno del binario? Ora che abbiamo scoperto le slice, possiamo comprendere correttamente i letterali stringa:

#![allow(unused)]
fn main() {
let s = "Hello, world!";
}

Il type di s qui è &str: è una slice che punta a quel punto specifico nel binario. Questo è anche il motivo per cui i letterali stringa sono immutabili; &str è un reference immutabile.

Slice di Stringa come Parametri

Sapendo che puoi avere slice di letterali e di valori String, arriviamo a un ulteriore miglioramento per prima_parola, e cioè la sua firma:

fn prima_parola(s: &String) -> &str {

Un Rustacean più esperto scriverebbe invece la firma come mostrata nel Listato 4-9, perché ci permette di usare la stessa funzione sia su valori &String che su valori &str.

fn prima_parola(s: &str) -> &str {
    let bytes = s.as_bytes();

    for (i, &lettera) in bytes.iter().enumerate() {
        if lettera == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

fn main() {
    let mia_stringa = String::from("hello world");

    // `prima_parola` funziona con slice di `String`, parziali o intere.
    let parola = prima_parola(&mia_stringa[0..6]);
    let parola = prima_parola(&mia_stringa[..]);
    // `prima_parola` funziona anche con reference a `String`, che corrisponde
    // a una slice intera di `String`.
    let parola = prima_parola(&mia_stringa);

    let mia_stringa_letterale = "hello world";

    // `prima_parola` funziona con slice di letterali di stringa,
    // parziali o intere.
    let parola = prima_parola(&mia_stringa_letterale[0..6]);
    let parola = prima_parola(&mia_stringa_letterale[..]);

    // E siccome i letterali di stringa *sono* già delle slice,
    // funziona pure così, senza usare la sintassi delle slice!
    let parola = prima_parola(mia_stringa_letterale);
}

Se abbiamo una slice di stringa, possiamo passarlo direttamente. Se abbiamo una String, possiamo passare una slice della String o un reference alla String. Questa flessibilità sfrutta la deref coercions (de-referenziazione forzata), una funzionalità che tratteremo nella sezione “Usare la De-Referenziazione Forzata in Funzioni e Metodi” del Capitolo 15.

Definire una funzione che come parametro prende una slice di stringa invece di un reference a una String rende la nostra funzione più generica e utile senza perdere alcuna funzionalità:

fn prima_parola(s: &str) -> &str {
    let bytes = s.as_bytes();

    for (i, &lettera) in bytes.iter().enumerate() {
        if lettera == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

fn main() {
    let mia_stringa = String::from("hello world");

    // `prima_parola` funziona con slice di `String`, parziali o intere.
    let parola = prima_parola(&mia_stringa[0..6]);
    let parola = prima_parola(&mia_stringa[..]);
    // `prima_parola` funziona anche con reference a `String`, che corrisponde
    // a una slice intera di `String`.
    let parola = prima_parola(&mia_stringa);

    let mia_stringa_letterale = "hello world";

    // `prima_parola` funziona con slice di letterali di stringa,
    // parziali o intere.
    let parola = prima_parola(&mia_stringa_letterale[0..6]);
    let parola = prima_parola(&mia_stringa_letterale[..]);

    // E siccome i letterali di stringa *sono* già delle slice,
    // funziona pure così, senza usare la sintassi delle slice!
    let parola = prima_parola(mia_stringa_letterale);
}

Altre Slice

Le slice di stringa, come puoi immaginare, sono specifiche per le stringhe. Ma c’è anche un tipo di slice più generale. Considera questo array:

#![allow(unused)]
fn main() {
let a = [1, 2, 3, 4, 5];
}

Proprio come potremmo voler fare riferimento a parte di una stringa, potremmo voler fare riferimento a parte di un array. Lo faremmo in questo modo:

#![allow(unused)]
fn main() {
let a = [1, 2, 3, 4, 5];

let slice = &a[1..3];

assert_eq!(slice, &[2, 3]);
}

Questa slice ha il type &[i32]. Funziona allo stesso modo delle string slice, memorizzando un reference al primo elemento e una lunghezza. Utilizzerai questo tipo di slice per tutti i type di altre collezioni. Discuteremo di queste collezioni in dettaglio quando parleremo dei vettori nel Capitolo 8.

Riepilogo

I concetti di ownership, borrowing e slice garantiscono la sicurezza della memoria nei programmi Rust già in fase d compilazione. Il linguaggio Rust ti offre il controllo sul tuo utilizzo della memoria nello stesso modo in cui fanno altri linguaggi di programmazione di sistema, ma avere un proprietario (ownership) per ogni dato e che questo pulisca automaticamente i propri dati quando se ne va (non più in scope), significa non dover scrivere e debuggare codice extra per ottenere questo controllo.

L’ownership influisce su come molte altre parti di Rust funzionano, quindi parleremo di questi concetti ulteriormente nel resto del libro. Passiamo al Capitolo 5 e vediamo come raggruppare pezzi di dati insieme in una struct.

Utilizzare le Struct per Strutturare Dati Correlati

Una struttura (struct d’ora in poi) è un tipo di dati personalizzato che ti permette di raggruppare e denominare più valori correlati che formano un gruppo significativo. Se sei familiare con un linguaggio orientato agli oggetti, una struct è simile agli attributi di dati di un oggetto. In questo capitolo, confronteremo le tuple con le struct per costruire su ciò che già conosci e dimostrare quando le struct sono un modo migliore per raggruppare dati.

Dimostreremo come definire e istanziare le struct. Discuteremo come definire funzioni associate, in particolare il tipo di funzioni associate chiamate metodi (method), per specificare il comportamento associato a un type struct. Le struct ed enum (discussi nel Capitolo 6) sono i blocchi di costruzione per creare nuovi type nel dominio del tuo programma per sfruttare appieno il controllo dei type in fase di compilazione di Rust.

Definire e Istanziare le Struct

Le struct sono simili alle tuple, discussi nella sezione “Il Type Tupla”, in quanto entrambi possono contenere più valori correlati. Come per le tuple, i componenti di una struct possono essere di type diversi. A differenza delle tuple, in una struct puoi denominare ogni pezzo di dati in modo che sia chiaro il significato dei valori. L’aggiunta di questi nomi significa che le struct sono più flessibili delle tuple: non devi fare affidamento sull’ordine dei dati per specificare o accedere ai valori di un’istanza.

Per definire una struct, inseriamo la parola chiave struct e diamo un nome all’intera struct. Il nome di una struct dovrebbe descrivere il significato dei dati raggruppati insieme. Poi, all’interno di parentesi graffe, definiamo i nomi e i type dei pezzi di dati, che chiamiamo campi (field in inglese). Ad esempio, il Listato 5-1 mostra una struct che memorizza informazioni su un account utente.

struct Utente {
    attivo: bool,
    nome_utente: String,
    email: String,
    numero_accessi: u64,
}

fn main() {}

Per utilizzare una struct dopo averla definita, creiamo un’istanza di quella struct specificando valori concreti per ciascuno dei campi. Creiamo un’istanza indicando il nome della struct e poi aggiungendo parentesi graffe contenenti coppie chiave: valore, dove le chiavi sono i nomi dei campi e i valori sono i dati che vogliamo memorizzare in quei campi. Non dobbiamo specificare i campi nello stesso ordine in cui li abbiamo dichiarati nella struct. In altre parole, la definizione della struct è come un modello generale per il type, e le istanze riempiono quel modello con dati particolari per creare valori del type. Ad esempio, possiamo dichiarare un utente particolare come mostrato nel Listato 5-2.

struct Utente {
    attivo: bool,
    nome_utente: String,
    email: String,
    numero_accessi: u64,
}

fn main() {
    let utente1 = Utente {
        attivo: true,
        nome_utente: String::from("qualcuno123"),
        email: String::from("qualcuno@mia_mail.com"),
        numero_accessi: 1,
    };
}

Per ottenere un valore specifico da una struct, usiamo la notazione col punto. Ad esempio, per accedere all’indirizzo email di questo utente, usiamo utente1.email. Se l’istanza è mutabile, possiamo cambiare un valore usando la notazione col punto assegnando un valore a un campo in particolare. Il Listato 5-3 mostra come modificare il valore del campo email di un’istanza Utente mutabile.

struct Utente {
    attivo: bool,
    nome_utente: String,
    email: String,
    numero_accessi: u64,
}

fn main() {
    let mut utente1 = Utente {
        attivo: true,
        nome_utente: String::from("qualcuno123"),
        email: String::from("qualcuno@mia_mail.com"),
        numero_accessi: 1,
    };

    user1.email = String::from("nuova_email@mia_mail.com");
}

Nota che l’intera istanza deve essere mutabile; Rust non ci permette di contrassegnare solo alcuni campi come mutabili. Come per qualsiasi espressione, possiamo costruire una nuova istanza della struct come ultima espressione nel corpo di una funzione per restituire implicitamente quella nuova istanza.

Il Listato 5-4 mostra la funzione nuovo_utente che restituisce un’istanza Utente con l’email e il nome utente indicati. Il campo attivo assume il valore true e numero_accessi prende il valore di 1.

struct Utente {
    attivo: bool,
    nome_utente: String,
    email: String,
    numero_accessi: u64,
}

fn nuovo_utente(email: String, nuome_utente: String) -> Utente {
    User {
        attivo: true,
        nuome_utente: nuome_utente,
        email: email,
        numero_accessi: 1,
    }
}

fn main() {
    let utente1 = nuovo_utente(
        String::from("qualcuno@mia_mail.com"),
        String::from("qualcuno123"),
    );
}

Ha senso chiamare i parametri della funzione con lo stesso nome dei campi della struct, ma dover ripetere i nomi dei campi email e nome_utente e delle variabili è un po’ noioso. Se la struct avesse più campi, la ripetizione di ogni nome diventerebbe ancora più fastidiosa. Per fortuna esiste una comoda scorciatoia!

Utilizzare la Sintassi Abbreviata di Inizializzazione

Poiché i nomi dei parametri e i nomi dei campi della struct sono esattamente gli stessi, possiamo usare la sintassi di inizializzazione abbreviata dei campi (field init shorthand) per riscrivere la funzione nuovo_utente in modo che si comporti esattamente allo stesso modo ma senza la ripetizione di nome_utente e email, come mostrato nel Listato 5-5.

struct Utente {
    attivo: bool,
    nome_utente: String,
    email: String,
    numero_accessi: u64,
}

fn nuovo_utente(email: String, nome_utente: String) -> Utente {
    Utente {
        attivo: true,
        nome_utente,
        email,
        numero_accessi: 1,
    }
}

fn main() {
    let utente1 = nuovo_utente(
        String::from("qualcuno@mia_mail.com"),
        String::from("qualcuno123"),
    );
}

Qui stiamo creando una nuova istanza della struct Utente, che ha un campo chiamato email. Vogliamo impostare il valore del campo email sul valore del parametro email della funzione nuovo_utente. Dato che il campo email e il parametro email hanno lo stesso nome, dobbiamo solo scrivere email invece di email: email.

Creare Istanze con la Sintassi di Aggiornamento delle Struct

Spesso è utile creare una nuova istanza di una struct che include la maggior parte dei valori da un’altra istanza dello stesso type, ma con alcune modifiche. Puoi farlo usando la sintassi di aggiornamento delle struct (struct update).

Per prima cosa, nel Listato 5-6 mostriamo come creare regolarmente una nuova istanza Utente in utente2, senza la sintassi di aggiornamento. Impostiamo un nuovo valore per email ma per il resto utilizziamo gli stessi valori di utente1 creati nel Listato 5-2.

struct Utente {
    attivo: bool,
    nome_utente: String,
    email: String,
    numero_accessi: u64,
}

fn main() {
    // --taglio--

    let utente1 = Utente {
        email: String::from("qualcuno@mia_mail.com"),
        nome_utente: String::from("qualcuno123"),
        attivo: true,
        numero_accessi: 1,
    };

    let utente2 = Utente {
        attivo: utente1.attivo,
        nome_utente: utente1.nome_utente,
        email: String::from("altra_mail@example.com"),
        numero_accessi: utente1.numero_accessi,
    };
}

Utilizzando la sintassi di aggiornamento, possiamo ottenere lo stesso effetto con meno codice, come mostrato nel Listato 5-7. La sintassi .. specifica che i restanti campi non impostati esplicitamente dovrebbero avere lo stesso valore dei campi nell’istanza data.

struct Utente {
    attivo: bool,
    nome_utente: String,
    email: String,
    numero_accessi: u64,
}

fn main() {
    // --taglio--

    let utente1 = Utente {
        email: String::from("qualcuno@mia_mail.com"),
        nome_utente: String::from("qualcuno123"),
        attivo: true,
        numero_accessi: 1,
    };

    let utente2 = Utente {
        email: String::from("altra_mail@example.com"),
        ..utente1
    };
}

Anche il codice nel Listato 5-7 crea un’istanza in utente2 che ha un valore diverso per email ma ha gli stessi valori per i campi nome_utente, attivo e numero_accessi di utente1. La parola chiave ..utente1 deve venire per ultima per specificare che tutti i campi rimanenti dovrebbero ottenere i propri valori dai campi corrispondenti in utente1, ma possiamo scegliere di specificare i valori per tutti i campi che vogliamo in qualsiasi ordine, indipendentemente dall’ordine dei campi nella definizione della struct.

Nota che la sintassi di aggiornamento utilizza = come un assegnazione; questo perché sposta i dati, proprio come abbiamo visto nella sezione ”Interazione tra Variabili e Dati con Move”. In questo esempio, non possiamo più utilizzare utente1 dopo aver creato utente2 perché la String nel campo nome_utente di utente1 è stata spostata in utente2. Se avessimo fornito a utente2 nuovi valori String sia per l’email che per nome_utente e quindi avessimo utilizzato solo i valori attivo e numero_accessi di utente1, utente1 sarebbe ancora valido dopo aver creato utente2. Sia attivo che numero_accessi sono type che implementano il trait Copy, quindi si applicherebbe il comportamento discusso nella sezione ”Duplicare dati sullo Stack”. In questo esempio possiamo ancora utilizzare utente1.email, perché il suo valore non è stato spostato da utente1.

Creare Type Diversi con Struct Tupla

Rust supporta anche struct che assomigliano alle tuple, chiamate struct tupla (tuple struct). Le struct tupla hanno il significato aggiuntivo che il nome della struct fornisce, ma non hanno nomi associati ai loro campi; piuttosto, hanno solo i type dei campi. Le struct tupla sono utili quando si vuole dare un nome all’intera tupla e renderla un type diverso da altre tuple, e quando denominare ogni campo come in una struct regolare sarebbe poco utile o ridondante. Per definire una struct tupla, inizia con la parola chiave struct e il nome della struct seguito dai type della tupla. Ad esempio, qui definiamo e utilizziamo due struct tupla chiamate Colore e Punto:

struct Colore(i32, i32, i32);
struct Punto(i32, i32, i32);

fn main() {
    let nero = Colore(0, 0, 0);
    let origine = Punto(0, 0, 0);
}

Tieni presente che i valori nero e origine sono di type diverso perché sono istanze di struct tupla diverse. Ogni struct che definisci diventa un nuovo type a sé stante, anche se i campi all’interno della struct potrebbero avere gli stessi type. Ad esempio, una funzione che accetta un parametro di type Colore non può accettare un Punto come argomento, anche se entrambi i type sono costituiti da tre valori i32. Oltretutto, le istanze di una struct tupla sono simili alle tuple in quanto puoi destrutturarle nelle loro singole parti e puoi utilizzare un . seguito dall’indice per accedere a un singolo valore. A differenza delle tuple però, le struct tupla richiedono di nominare il type di struct quando le destrutturi. Ad esempio, scriveremo let Punto(x, y, z) = origine; per destrutturare i valori del Punto origine in variabili chiamate x, y e z.

Definire Struct Unit

Puoi anche definire struct che non hanno campi! Queste sono chiamate struct unit (unit-like struct) perché si comportano in modo simile a (), il type unit menzionato nella sezione “Il Type Tupla”. Le struct unit possono essere utili quando è necessario implementare un trait su un type ma non si hanno dati che si vogliono memorizzare nel type stesso.

Parleremo dei trait nel Capitolo 10. Ecco un esempio di dichiarazione e istanziazione di una struct unit chiamata SempreUguale:

struct SempreUguale;

fn main() {
    let suggetto = SempreUguale;
}

Per definire SempreUguale, utilizziamo la parola chiave struct, il nome che vogliamo e quindi un punto e virgola. Non c’è bisogno di parentesi graffe o tonde! Quindi possiamo ottenere un’istanza di SempreUguale nella variabile soggetto in un modo simile: utilizzando il nome che abbiamo definito, senza parentesi graffe o tonde. Immagina che in seguito implementeremo il comportamento per questo type in modo tale che ogni istanza di SempreUguale sia sempre uguale a ogni istanza di qualsiasi altro type, magari per avere un risultato noto a scopo di test. Non avremmo bisogno di dati per implementare quel comportamento! Vedremo nel Capitolo 10 come definire i trait e implementarli su qualsiasi type, comprese le struct unit.

struct Utente {
    attivo: bool,
    nome_utente: &str,
    email: &str,
    numero_accessi: u64,
}

fn main() {
    let user1 = Utente {
        attivo: true,
        nome_utente: "qualcuno123",
        email: "qualcuno@mia_mail.com",
        numero_accessi: 1,
    };
}

$ cargo run
   Compiling struct v0.1.0 (file:///progetti/structs)
error[E0106]: missing lifetime specifier
 --> src/main.rs:3:18
  |
3 |     nome_utente: &str,
  |                  ^ expected named lifetime parameter
  |
help: consider introducing a named lifetime parameter
  |
1 ~ struct Utente<'a> {
2 |     attivo: bool,
3 ~     nome_utente: &'a str,
  |

error[E0106]: missing lifetime specifier
 --> src/main.rs:4:12
  |
4 |     email: &str,
  |            ^ expected named lifetime parameter
  |
help: consider introducing a named lifetime parameter
  |
1 ~ struct Utente<'a> {
2 |     attivo: bool,
3 |     nome_utente: &str,
4 ~     email: &'a str,
  |

For more information about this error, try `rustc --explain E0106`.
error: could not compile `struct` (bin "struct") due to 2 previous errors

Un Esempio di Programma Che Usa Struct

Per capire quando potremmo voler usare le struct, scriviamo un programma che calcola l’area di un rettangolo. Partiremo usando variabili singole e poi riscriveremo il programma un pezzo per volta finché non useremo le struct.

Creiamo un nuovo progetto binario con Cargo chiamato rettangoli che prenderà la larghezza e l’altezza di un rettangolo specificate in pixel e calcolerà l’area del rettangolo. Il Listato 5-8 mostra un breve programma con un modo per farlo nel file src/main.rs del nostro progetto.

fn main() {
    let larghezza1 = 30;
    let altezza1 = 50;

    println!(
        "L'area del rettangolo è di {} pixel quadrati.",
        area(larghezza1, altezza1)
    );
}

fn area(larghezza: u32, altezza: u32) -> u32 {
    larghezza * altezza
}

Ora esegui questo programma usando cargo run:

$ cargo run
   Compiling rettangoli v0.1.0 (file:///progetti/rettangoli)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.15s
     Running `target/debug/rettangoli`
L'area del rettangolo è di 1500 pixel quadrati.

Questo codice riesce a calcolare l’area del rettangolo chiamando la funzione area con ogni dimensione, ma possiamo fare di più per rendere il codice chiaro e leggibile.

Il problema con questo codice è evidente nella firma di area:

fn main() {
    let larghezza1 = 30;
    let altezza1 = 50;

    println!(
        "L'area del rettangolo è di {} pixel quadrati.",
        area(larghezza1, altezza1)
    );
}

fn area(larghezza: u32, altezza: u32) -> u32 {
    larghezza * altezza
}

La funzione area dovrebbe calcolare l’area di un rettangolo singolo, ma la funzione che abbiamo scritto ha due parametri, e non è chiaro da nessuna parte nel nostro programma che i parametri siano correlati. Sarebbe più leggibile e più gestibile raggruppare larghezza e altezza insieme. Abbiamo già discusso un modo per farlo nella sezione “Il Type Tupla” del Capitolo 3: usando le tuple.

Riscrivere con le Tuple

Il Listato 5-9 mostra un’altra versione del nostro programma che usa le tuple.

fn main() {
    let rettangolo1 = (30, 50);

    println!(
        "L'area del rettangolo è di {} pixel quadrati.",
        area(rettangolo1)
    );
}

fn area(dimensioni: (u32, u32)) -> u32 {
    dimensioni.0 * dimensioni.1
}

Da un lato, questo programma è migliore. Le tuple ci permettono di aggiungere un po’ di struttura, e ora stiamo passando un solo argomento. Ma dall’altro, questa versione è meno chiara: le tuple non nominano i loro elementi, quindi dobbiamo indicizzare le parti della tupla, rendendo il nostro calcolo meno ovvio.

Confondere larghezza e altezza non avrebbe importanza per il calcolo dell’area, ma se volessimo disegnare il rettangolo sullo schermo, importerebbe! Dovremmo tenere a mente che larghezza è l’indice della tupla 0 e altezza è l’indice della tupla 1. Questo sarebbe ancora più difficile da capire e ricordare per qualcun altro che in futuro leggesse o usasse il nostro codice. Poiché non abbiamo reso palese il significato dei nostri dati nel codice, è più facile introdurre errori.

Riscrivere con le Struct

Usiamo la struct per aggiungere significato etichettando i dati. Possiamo trasformare la tupla che stiamo usando in una struct con un nome per l’intero e nomi per le parti, come mostrato nel Listato 5-10.

struct Rettangolo {
    larghezza: u32,
    altezza: u32,
}

fn main() {
    let rettangolo1 = Rettangolo {
        larghezza: 30,
        altezza: 50,
    };

    println!(
        "L'area del rettangolo è di {} pixel quadrati.",
        area(&rettangolo1)
    );
}

fn area(rettangolo: &Rettangolo) -> u32 {
    rettangolo.larghezza * rettangolo.altezza
}

Qui abbiamo definito una struct e l’abbiamo chiamata Rettangolo. All’interno delle parentesi graffe, abbiamo definito i campi come larghezza e altezza, entrambi di type u32. Poi, in main, abbiamo creato un’istanza particolare di Rettangolo che ha larghezza 30 e altezza 50.

La nostra funzione area è ora definita con un solo parametro, che abbiamo chiamato Rettangolo, il cui type è un reference immutabile a un’istanza della struct Rettangolo. Come menzionato nel Capitolo 4, ci serve solo prendere in prestito la struct piuttosto che averne la ownership. In questo modo, main mantiene la sua ownership e può continuare a usare rettangolo1, che è il motivo per cui usiamo & nella firma della funzione e dove chiamiamo la funzione.

La funzione area accede ai campi larghezza e altezza dell’istanza di Rettangolo (nota che accedere ai campi di un’istanza di struct presa in prestito non muove i valori dei campi, motivo per cui spesso si vedono reference di struct). La nostra firma della funzione per area ora dice esattamente ciò che intendiamo: calcolare l’area di Rettangolo, usando i suoi campi larghezza e altezza. Questo comunica che larghezza e altezza sono correlate tra loro e fornisce nomi descrittivi ai valori invece di usare gli indici della tupla 0 e 1. Questo è un vantaggio in termini di chiarezza.

Aggiungere Funzionalità con i Trait Derivati

Sarebbe utile poter stampare un’istanza di Rettangolo mentre eseguiamo il debug del nostro programma e vedere i valori di tutti i suoi campi. Il Listato 5-11 prova a usare la macro println! come l’abbiamo usata nei capitoli precedenti. Questo però non funzionerà.

struct Rettangolo {
    larghezza: u32,
    altezza: u32,
}

fn main() {
    let rettangolo1 = Rettangolo {
        larghezza: 30,
        altezza: 50,
    };

    println!("rettangolo1 è {rettangolo1}");
}

Quando compiliamo questo codice, otteniamo un errore con questo messaggio principale:

error[E0277]: `Rettangolo` doesn't implement `std::fmt::Display`

La macro println! può fare molti tipi di formattazione e, come impostazione predefinita, le parentesi graffe dicono a println! di usare una formattazione conosciuta come Display, output pensato per il l’utente finale che utilizzerà il programma. I type primitivi che abbiamo visto finora implementano Display di default perché c’è un solo modo in cui vorresti mostrare un 1 o qualsiasi altro type primitivo a un utente. Ma con le struct il modo in cui println! dovrebbe formattare l’output è meno chiaro perché ci sono più possibilità di visualizzazione: vuoi le virgole o no? Vuoi stampare le parentesi graffe? Devono essere mostrati tutti i campi? A causa di questa ambiguità, Rust non cerca di indovinare ciò che vogliamo, e le struct non hanno un’implementazione standard di Display da usare con println! e il segnaposto {}.

Se continuiamo a leggere gli errori, troveremo questa nota utile:

   = help: the trait `std::fmt::Display` is not implemented for `Rettangolo`
   = note: in format strings you may be able to use `{:?}` (or {:#?} for pretty-print) instead

Proviamolo! La chiamata alla macro println! ora assomiglierà a println!("rettangolo1 è {rettangolo1:?}");. Inserire lo specificatore :? all’interno delle parentesi graffe dice a println! che vogliamo usare un formato di output chiamato Debug. Il trait Debug ci permette di stampare la nostra struct in un modo utile per gli sviluppatori, così possiamo vedere il suo valore mentre eseguiamo il debug del nostro codice.

Compila il codice con questa modifica. Accidenti! Otteniamo ancora un errore:

error[E0277]: `Rettangolo` doesn't implement `Debug`

Ma di nuovo, il compilatore ci dà una nota utile:

   = help: the trait `Debug` is not implemented for `Rettangolo`
   = note: add `#[derive(Debug)]` to `Rettangolo` or manually `impl Debug for Rettangolo`

Rust include effettivamente funzionalità per stampare informazioni di debug, ma dobbiamo esplicitamente dichiararlo per rendere disponibile quella funzionalità alla nostra struct. Per farlo, aggiungiamo l’attributo esterno #[derive(Debug)] appena prima della definizione della struct, come mostrato nel Listato 5-12.

#[derive(Debug)]
struct Rettangolo {
    larghezza: u32,
    altezza: u32,
}

fn main() {
    let rettangolo1 = Rettangolo {
        larghezza: 30,
        altezza: 50,
    };

    println!("rettangolo1 è {rettangolo1:?}");
}

Ora quando eseguiamo il programma, non otterremo errori e vedremo il seguente output:

$ cargo run
   Compiling rettangoli v0.1.0 (file:///progetti/rettangoli)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.27s
     Running `target/debug/rettangoli`
rettangolo1 è Rettangolo { larghezza: 30, altezza: 50 }

Bene! Non è l’output più bello, ma mostra i valori di tutti i campi per questa istanza, il che aiuterebbe sicuramente durante lo sviluppo e il debug del programma. Quando abbiamo struct più grandi, è utile avere un output un po’ più facile da leggere; in quei casi, possiamo usare {:#?} invece di {:?} nella stringa di println!. In questo esempio, usare lo stile {:#?} produrrà il seguente output:

$ cargo run
   Compiling rettangoli v0.1.0 (file:///progetti/rettangoli)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.26s
     Running `target/debug/rettangoli`
rettangolo1 è Rettangolo {
    larghezza: 30,
    altezza: 50,
}

Un altro modo per stampare un valore usando il formato Debug è usare la macro dbg!, che prende ownership di un’espressione (a differenza di println!, che prende un reference), stampa file e numero di linea di dove quella chiamata a dbg! si verifica nel codice insieme al valore risultante di quell’espressione, e restituisce l’ownership del valore.

Nota: Chiamare la macro dbg! stampa sullo stream di errore standard (stderr), a differenza di println!, che stampa sullo stream di output standard (stdout). Parleremo meglio di stderr e stdout nella sezione “Scrivere i Messaggi di Errore su Standard Error invece che su Standard Output” del Capitolo 12.

Ecco un esempio in cui siamo interessati al valore che viene assegnato al campo larghezza, così come al valore dell’intera struct in rettangolo1:

#[derive(Debug)]
struct Rettangolo {
    larghezza: u32,
    altezza: u32,
}

fn main() {
    let scala = 2;
    let rettangolo1 = Rettangolo {
        larghezza: dbg!(30 * scala),
        altezza: 50,
    };

    dbg!(&rettangolo1);
}

Possiamo mettere dbg! attorno all’espressione 30 * scala e, poiché dbg! restituisce l’ownership del valore dell’espressione, il campo larghezza otterrà lo stesso valore come se non avessimo la chiamata a dbg! lì. Non vogliamo che dbg! prenda ownership di rettangolo1, quindi usiamo un riferimento a rettangolo1 nella chiamata successiva. Ecco come appare l’output di questo esempio:

$ cargo run
   Compiling rettangoli v0.1.0 (file:///progetti/rettangoli)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/rettangoli`
[src/main.rs:10:20] 30 * scala = 60
[src/main.rs:14:5] &rettangolo1 = Rettangolo {
    larghezza: 60,
    altezza: 50,
}

Possiamo vedere che il primo frammento di output proviene da src/main.rs riga 10 dove stiamo facendo il debug dell’espressione 30 * scala, e il suo valore risultante è 60 (la formattazione Debug implementata per gli integer è di stampare solo il loro valore). La chiamata a dbg! alla riga 14 di src/main.rs stampa il valore di &rettangolo1, che è la struct Rettangolo. Questo output usa la formattazione Debug “pretty” del type Rettangolo. La macro dbg! può essere davvero utile quando stai cercando di capire cosa sta facendo il tuo codice!

Oltre al trait Debug, Rust fornisce diversi trait che possiamo usare con l’attributo derive che possono aggiungere comportamenti utili ai nostri type personalizzati. Quei trait e i loro comportamenti sono elencati nell’Appendice C. Tratteremo come implementare questi trait con un comportamento personalizzato e come creare i propri trait nel Capitolo 10. Ci sono anche molti attributi oltre a derive; per maggiori informazioni, vedi la sezione “Attributes” del Rust Reference.

La nostra funzione area è molto specifica: calcola solo l’area dei rettangoli. Sarebbe utile legare questo comportamento più strettamente alla nostra struct Rettangolo perché non funzionerà con altri type. Vediamo come possiamo continuare a riscrivere questo codice trasformando la funzione area in un metodo (method) definito sul nostro type Rettangolo.

Metodi

I metodi (method) sono simili alle funzioni: le dichiariamo con la parola chiave fn e un nome, possono avere parametri e un valore di ritorno, e contengono del codice che viene eseguito quando il metodo viene chiamato da un’altra parte. Diversamente dalle funzioni, i metodi sono definiti nel contesto di una struct (o di un’enum o di un trait object, che tratteremo nel Capitolo 6 e Capitolo 18, rispettivamente), e il loro primo parametro è sempre self, che rappresenta l’istanza della struct su cui il metodo viene chiamato.

Sintassi dei Metodi

Trasformiamo la funzione area che prende un’istanza di Rettangolo come parametro rendendola invece un metodo definito sulla struct Rettangolo, come mostrato nel Listato 5-13.

#[derive(Debug)]
struct Rettangolo {
    larghezza: u32,
    altezza: u32,
}

impl Rettangolo {
    fn area(&self) -> u32 {
        self.larghezza * self.altezza
    }
}

fn main() {
    let rettangolo1 = Rettangolo {
        larghezza: 30,
        altezza: 50,
    };

    println!(
        "L'area del rettangolo è di {} pixel quadrati.",
        rettangolo1.area()
    );
}

Per definire la funzione nel contesto di Rettangolo, iniziamo un blocco impl (implementazione) per Rettangolo. Tutto ciò che sta dentro questo blocco impl sarà associato al type Rettangolo. Poi spostiamo la funzione area all’interno delle parentesi graffe dell’impl e cambiamo il primo (e in questo caso, unico) parametro in self nella firma e ovunque nel corpo. In main, dove chiamavamo la funzione area passando rettangolo1 come argomento, possiamo invece usare la sintassi dei metodi per chiamare il metodo area sull’istanza di Rettangolo. La sintassi del metodo va dopo un’istanza: aggiungiamo un punto seguito dal nome del metodo, parentesi tonde ed eventuali argomenti.

Nella firma di area usiamo &self invece di rettangolo: &Rettangolo. Il &self è in realtà l’abbreviazione di self: &Self. All’interno di un blocco impl, il type Self è un alias del type per cui il blocco impl è stato scritto. I metodi devono avere un parametro chiamato self di type Self come primo parametro, quindi Rust permette di abbreviare questo con soltanto il nome self nella prima posizione dei parametri. Nota che dobbiamo comunque usare & davanti alla forma abbreviata self per indicare che questo metodo prende in prestito l’istanza Self, esattamente come facevamo con rettangolo: &Rettangolo. I metodi possono prendere la ownership di self, prendere un reference immutabile a self, come abbiamo fatto qui, oppure prendere un reference mutabile a self, proprio come possono fare con qualsiasi altro parametro.

Qui abbiamo scelto &self per lo stesso motivo per cui abbiamo usato &Rettangolo nella versione precedente: non serve che prendiamo la ownership, vogliamo solo leggere i dati nella struct, non modificarli. Se volessimo modificare l’istanza su cui chiamiamo il metodo come parte di ciò che il metodo fa, useremmo &mut self come primo parametro. Avere un metodo che prende la ownership dell’istanza usando semplicemente self come primo parametro è raro; questa tecnica è solitamente usata quando il metodo trasforma self in qualcos’altro e si vuole impedire al chiamante di usare l’istanza originale dopo la trasformazione.

La ragione principale per usare i metodi invece delle funzioni, oltre a fornire la sintassi dei metodi e a non dover ripetere il type di self in ogni firma dei metodi, è per organizzazione. Abbiamo messo tutte le cose che possiamo fare con un’istanza di un type in un unico blocco impl invece di costringere chi dovrà in futuro leggere o manutenere il nostro codice a cercare le funzionalità di Rettangolo in vari posti nella libreria che forniamo.

Nota che possiamo scegliere di dare a un metodo lo stesso nome di uno dei campi della struct. Per esempio, possiamo definire un metodo su Rettangolo che si chiama anch’esso larghezza:

#[derive(Debug)]
struct Rettangolo {
    larghezza: u32,
    altezza: u32,
}

impl Rettangolo {
    fn larghezza(&self) -> bool {
        self.larghezza > 0
    }
}

fn main() {
    let rettangolo1 = Rettangolo {
        larghezza: 30,
        altezza: 50,
    };

    if rettangolo1.larghezza() {
        println!("La larghezza del rettangolo è > 0; è {}", rettangolo1.larghezza);
    }
}

Qui scegliamo di fare in modo che il metodo larghezza ritorni true se il valore nel campo larghezza dell’istanza è maggiore di 0 e false se il valore è 0: possiamo usare un campo all’interno di un metodo con lo stesso nome per qualunque scopo. In main, quando seguiamo rettangolo1.larghezza con le parentesi tonde, Rust sa che si intende il metodo larghezza. Quando non usiamo le parentesi tonde, Rust sa che intendiamo il campo larghezza.

Spesso, ma non sempre, quando diamo a un metodo lo stesso nome di un campo vogliamo che esso ritorni soltanto il valore del campo e non faccia altro. I metodi di questo tipo sono chiamati getter (metodi di incapsulamento) e Rust non li implementa automaticamente per i campi della struct come fanno alcuni altri linguaggi di programmazione. I getter sono utili perché puoi rendere il campo privato ma il metodo pubblico, abilitando così accesso in sola lettura a quel campo come parte dell’API pubblica del type. Discuteremo cosa sono pubblico e privato e come designare un campo o un metodo come pubblico o privato nel Capitolo 7.

#![allow(unused)]
fn main() {
#[derive(Debug,Copy,Clone)]
struct Punto {
    x: f64,
    y: f64,
}

impl Punto {
   fn distanza(&self, altro: &Punto) -> f64 {
       let x_quad = f64::powi(altro.x - self.x, 2);
       let y_quad = f64::powi(altro.y - self.y, 2);

       f64::sqrt(x_quad + y_quad)
   }
}
let p1 = Punto { x: 0.0, y: 0.0 };
let p2 = Punto { x: 5.0, y: 6.5 };
p1.distanza(&p2);
(&p1).distanza(&p2);
}

Metodi con Più Parametri

Esercitiamoci ad usare i metodi implementando un secondo metodo sulla struct Rettangolo. Questa volta vogliamo che un’istanza di Rettangolo prenda un’altra istanza di Rettangolo e ritorni true se la seconda Rettangolo può entrare completamente dentro self (la prima Rettangolo); altrimenti dovrebbe ritornare false. Cioè, una volta definito il metodo può_contenere, dovremmo poter scrivere il programma mostrato nel Listato 5-14.

fn main() {
    let rettangolo1 = Rettangolo {
        larghezza: 30,
        altezza: 50,
    };
    let rettangolo2 = Rettangolo {
        larghezza: 10,
        altezza: 40,
    };
    let rettangolo3 = Rettangolo {
        larghezza: 60,
        altezza: 45,
    };

    println!("Può rettangolo1 contenere rettangolo2? {}", rettangolo1.può_contenere(&rettangolo2));
    println!("Può rettangolo1 contenere rettangolo3? {}", rettangolo1.può_contenere(&rettangolo3));
}

L’output atteso sarà il seguente perché entrambe le dimensioni di rettangolo2 sono più piccole delle dimensioni di rettangolo1, ma rettangolo3 è più larga di rettangolo1:

Può rettangolo1 contenere rettangolo2? true
Può rettangolo1 contenere rettangolo3? false

Sappiamo che vogliamo definire un metodo, quindi sarà all’interno del blocco impl Rettangolo. Il nome del metodo sarà può_contenere, e prenderà un reference immutabile di un’altra Rettangolo come parametro. Possiamo dedurre il type del parametro osservando il codice che chiama il metodo: rettangolo1.può_contenere(&rettangolo2) passa &rettangolo2, che è un reference immutabile di rettangolo2, un’istanza di Rettangolo. Questo ha senso perché abbiamo solo bisogno di leggere rettangolo2 (invece di modificarlo, il che richiederebbe un reference mutabile), e vogliamo che main mantenga l’ownership di rettangolo2 così da poterlo usare di nuovo dopo la chiamata a può_contenere. Il valore di ritorno di può_contenere sarà un Booleano, e l’implementazione verificherà se la larghezza e l’altezza di self sono maggiori rispetto alla larghezza e all’altezza dell’altra Rettangolo, rispettivamente. Aggiungiamo il nuovo metodo può_contenere al blocco impl del Listato 5-13, come mostrato nel Listato 5-15.

#[derive(Debug)]
struct Rettangolo {
    larghezza: u32,
    altezza: u32,
}

impl Rettangolo {
    fn area(&self) -> u32 {
        self.larghezza * self.altezza
    }

    fn può_contenere(&self, altro: &Rettangolo) -> bool {
        self.larghezza > altro.larghezza && self.altezza > altro.altezza
    }
}

fn main() {
    let rettangolo1 = Rettangolo {
        larghezza: 30,
        altezza: 50,
    };
    let rettangolo2 = Rettangolo {
        larghezza: 10,
        altezza: 40,
    };
    let rettangolo3 = Rettangolo {
        larghezza: 60,
        altezza: 45,
    };

    println!("Può rettangolo1 contenere rettangolo2? {}", rettangolo1.può_contenere(&rettangolo2));
    println!("Può rettangolo1 contenere rettangolo3? {}", rettangolo1.può_contenere(&rettangolo3));
}

Quando eseguiamo questo codice con la funzione main del Listato 5-14, otterremo l’output desiderato. I metodi possono prendere parametri multipli che aggiungiamo alla firma dopo il parametro self, e quei parametri funzionano proprio come i parametri nelle funzioni.

Funzioni Associate

Tutte le funzioni definite all’interno di un blocco impl sono chiamate funzioni associate (associated functions) perché sono associate al type nominato dopo la parola impl. Possiamo definire funzioni associate che non hanno self come primo parametro (e quindi non sono metodi) perché non hanno bisogno di un’istanza del type per svolgere il loro compito. Ne abbiamo già usata una: la funzione String::from implementata sul type String.

Le funzioni associate che non sono metodi sono spesso usate come costruttori che ritornano una nuova istanza della struct. Spesso si chiamano new perché new non è una parola chiave e non è incorporata nel linguaggio. Per esempio, potremmo decidere di fornire una funzione associata chiamata quadrato che prende un parametro di dimensione e lo usa sia come larghezza sia come altezza, rendendo più semplice creare un Rettangolo quadrato invece di dover specificare lo stesso valore due volte:

File: src/main.rs

#[derive(Debug)]
struct Rettangolo {
    larghezza: u32,
    altezza: u32,
}

impl Rettangolo {
    fn quadrato(dimensione: u32) -> Self {
        Self {
            larghezza: dimensione,
            altezza: dimensione,
        }
    }
}

fn main() {
    let quad = Rectangle::quadrato(3);
}

La parola chiave Self nel type di ritorno e nel corpo della funzione è un alias per il type che appare dopo la parola chiave impl, che in questo caso è Rettangolo.

Per chiamare questa funzione associata, usiamo la sintassi :: con il nome della struct; let quad = Rettangolo::quadrato(3); è un esempio. Questa funzione è organizzata nel namespace della struct: la sintassi :: è usata sia per le funzioni associate sia per i namespace creati dai moduli. Parleremo più approfonditamente dei moduli nel Capitolo 7.

Blocchi impl Multipli

A ogni struct è permesso avere più blocchi impl. Per esempio, il Listato 5-15 è equivalente al codice mostrato nel Listato 5-16, che ha ognuno dei metodi nel proprio blocco impl.

#[derive(Debug)]
struct Rettangolo {
    larghezza: u32,
    altezza: u32,
}

impl Rettangolo {
    fn area(&self) -> u32 {
        self.larghezza * self.altezza
    }
}

impl Rettangolo {
    fn può_contenere(&self, altro: &Rectangle) -> bool {
        self.larghezza > altro.larghezza && self.altezza > altro.altezza
    }
}

fn main() {
    let rettangolo1 = Rettangolo {
        larghezza: 30,
        altezza: 50,
    };
    let rettangolo2 = Rettangolo {
        larghezza: 10,
        altezza: 40,
    };
    let rettangolo3 = Rettangolo {
        larghezza: 60,
        altezza: 45,
    };

    println!("Può rettangolo1 contenere rettangolo2? {}", rettangolo1.può_contenere(&rettangolo2));
    println!("Può rettangolo1 contenere rettangolo3? {}", rettangolo1.può_contenere(&rettangolo3));
}

Non c’è motivo di separare questi metodi in più blocchi impl in questo caso, ma questa è una sintassi valida. Vedremo un caso in cui più blocchi impl sono utili nel Capitolo 10, dove discuteremo i type generici e i trait.

Riepilogo

Le struct ti permettono di creare type personalizzati significativi per il tuo dominio. Usando le struct, puoi mantenere pezzi di dati correlati tra loro e dare un nome a ciascun pezzo per rendere il codice chiaro. Nei blocchi impl puoi definire funzioni associate al tuo type, e i metodi sono un tipo di funzione associata che ti permette di specificare il comportamento che le istanze delle tue struct hanno.

Ma le struct non sono l’unico modo per creare type personalizzati: passiamo ad un altro type di Rust, le enumerazioni, per aggiungere un altro strumento alla tua cassetta degli attrezzi.

Enumerazioni e Corrispondenza dei Pattern

In questo capitolo parleremo delle enumerazioni, abbreviato in enum, termine che sarà usato d’ora in poi. Le enum permettono di definire un type enumerando le sue possibili varianti. Per prima cosa definiremo e useremo un’enum per mostrare come un’enum possa codificare un significato insieme ai dati. Poi esploreremo un’enum particolarmente utile, chiamato Option, che consente di esprimere se un valore può essere o qualcosa o niente. Poi vedremo come la corrispondenza dei pattern nell’espressione match rende facile eseguire codice diverso per valori diversi di un’enum. Infine, vedremo come il costrutto if let sia un altro idioma comodo e conciso disponibile per gestire le enum nel tuo codice.

Definire un’Enum

Laddove le struct ti danno un modo per raggruppare campi e dati correlati, per esempio un Rettangolo con i propri larghezza e altezza, le enum ti danno un modo per indicare che un valore è uno di un insieme possibile di valori. Per esempio, potremmo voler dire che Rettangolo è una delle possibili forme che include anche Cerchio e Triangolo. Per farlo, Rust ci permette di codificare queste possibilità come un’enum.

Esaminiamo una situazione che potremmo voler esprimere nel codice e vediamo perché le enum sono utili e più appropriati delle struct in questo caso. Supponiamo di dover lavorare con gli indirizzi IP. Attualmente, per gli indirizzi IP si usano due standard principali: versione quattro e versione sei. Poiché queste sono le uniche possibilità di indirizzo IP che il nostro programma incontrerà, possiamo enumerare tutte le varianti possibili, da cui il nome enum.

Qualsiasi indirizzo IP può essere o versione quattro o versione sei, ma non entrambi contemporaneamente. Questa proprietà degli indirizzi IP rende la struttura dati enum appropriata perché un valore di enum può essere solo una delle sue varianti. Sia i versione quattro sia i versione sei sono comunque fondamentalmente indirizzi IP, quindi dovrebbero essere trattati come dati dello stesso type quando il codice andrà a gestire situazioni che si applicano agli indirizzi IP d’ogni genere.

Possiamo esprimere questo concetto nel codice definendo un’enum VersioneIndirizzoIp e elencando le possibili tipologie che un indirizzo IP può essere: V4 e V6. Queste sono le varianti dell’enum:

enum VersioneIndirizzoIp {
    V4,
    V6,
}

fn main() {
    let quattro = VersioneIndirizzoIp::V4;
    let sei = VersioneIndirizzoIp::V6;

    instrada(VersioneIndirizzoIp::V4);
    instrada(VersioneIndirizzoIp::V6);
}

fn instrada(verione_ip: VersioneIndirizzoIp) {}

VersioneIndirizzoIp è ora un type di dato personalizzato che possiamo usare altrove nel nostro codice.

Valori di Enum

Possiamo creare istanze di ciascuna delle due varianti di VersioneIndirizzoIp in questo modo:

enum VersioneIndirizzoIp {
    V4,
    V6,
}

fn main() {
    let quattro = VersioneIndirizzoIp::V4;
    let sei = VersioneIndirizzoIp::V6;

    instrada(VersioneIndirizzoIp::V4);
    instrada(VersioneIndirizzoIp::V6);
}

fn instrada(verione_ip: VersioneIndirizzoIp) {}

Nota che le varianti dell’enum sono nel namespace del suo identificatore, e usiamo il doppio-due punti :: per separarle. Questo è utile perché ora entrambi i valori VersioneIndirizzoIp::V4 e VersioneIndirizzoIp::V6 sono dello stesso type: VersioneIndirizzoIp. Possiamo quindi, per esempio, definire una funzione che accetta qualsiasi VersioneIndirizzoIp:

enum VersioneIndirizzoIp {
    V4,
    V6,
}

fn main() {
    let quattro = VersioneIndirizzoIp::V4;
    let sei = VersioneIndirizzoIp::V6;

    instrada(VersioneIndirizzoIp::V4);
    instrada(VersioneIndirizzoIp::V6);
}

fn instrada(verione_ip: VersioneIndirizzoIp) {}

E possiamo chiamare questa funzione con entrambe le varianti:

enum VersioneIndirizzoIp {
    V4,
    V6,
}

fn main() {
    let quattro = VersioneIndirizzoIp::V4;
    let sei = VersioneIndirizzoIp::V6;

    instrada(VersioneIndirizzoIp::V4);
    instrada(VersioneIndirizzoIp::V6);
}

fn instrada(verione_ip: VersioneIndirizzoIp) {}

L’uso delle enum ha ulteriori vantaggi. Pensando meglio al nostro type per gli indirizzi IP, al momento non abbiamo un modo per memorizzare il vero e proprio indirizzo IP; sappiamo solo di che tipologia si tratta. Dato che hai appena imparato le struct nel Capitolo 5, potresti essere tentato di risolvere questo problema con le struct come mostrato nel Listato 6-1.

fn main() {
    enum VersioneIndirizzoIp {
        V4,
        V6,
    }

    struct IpAddr {
        tipo: VersioneIndirizzoIp,
        indirizzo: String,
    }

    let home = IpAddr {
        tipo: VersioneIndirizzoIp::V4,
        indirizzo: String::from("127.0.0.1"),
    };

    let loopback = IpAddr {
        tipo: VersioneIndirizzoIp::V6,
        indirizzo: String::from("::1"),
    };
}

Qui abbiamo definito una struct IpAddr che ha due campi: un campo tipo di type VersioneIndirizzoIp (l’enum definito prima) e un campo indirizzo di type String. Abbiamo due istanze di questa struct. La prima è home, e ha il valore VersioneIndirizzoIp::V4 come suo tipo con l’indirizzo associato 127.0.0.1. La seconda istanza è loopback. Essa ha l’altra variante di VersioneIndirizzoIp come valore del suo tipo, V6, e ha associato l’indirizzo ::1. Abbiamo usato una struct per raggruppare i valori tipo e indirizzo, così la variante è ora associata al valore.

Tuttavia, rappresentare lo stesso concetto usando solo un’enum è più conciso: invece di un’enum dentro una struct, possiamo mettere i dati direttamente in ogni variante dell’enum. Questa nuova definizione dell’enum IpAddr indica che entrambe le varianti V4 e V6 avranno valori String associati:

fn main() {
    enum IpAddr {
        V4(String),
        V6(String),
    }

    let home = IpAddr::V4(String::from("127.0.0.1"));

    let loopback = IpAddr::V6(String::from("::1"));
}

Alleghiamo i dati direttamente a ciascuna variante dell’enum, quindi non c’è bisogno di una struct aggiuntiva. Qui è anche più facile vedere un altro dettaglio di come funzionano le enum: il nome di ciascuna variante che definiamo diventa anche una funzione che costruisce un’istanza dell’enum. Cioè, IpAddr::V4() è una chiamata di funzione che prende un argomento String e ritorna un’istanza del type IpAddr. Otteniamo automaticamente questa funzione costruttrice come risultato della definizione dell’enum.

C’è un altro vantaggio nell’usare un’enum invece di una struct: ogni variante può avere type e quantità diverse di dati associati. Gli indirizzi versione quattro, ad esempio, avranno sempre quattro componenti numeriche con valori tra 0 e 255. Se volessimo memorizzare gli indirizzi V4 come quattro valori u8 ma rappresentare gli indirizzi V6 come una singola String, non potremmo farlo con un struct. Le enum gestiscono questo caso con facilità:

fn main() {
    enum IpAddr {
        V4(u8, u8, u8, u8),
        V6(String),
    }

    let home = IpAddr::V4(127, 0, 0, 1);

    let loopback = IpAddr::V6(String::from("::1"));
}

Abbiamo mostrato diversi modi per definire strutture dati per memorizzare indirizzi IP versione quattro e versione sei. Tuttavia, risulta che voler memorizzare indirizzi IP e codificare di quale tipologia siano è così comune che la libreria standard fornisce una definizione che possiamo usare! Diamo un’occhiata a come la libreria standard definisce IpAddr. Ha l’esatta enum e le varianti che abbiamo definito e usato, ma incapsula i dati dell’indirizzo dentro le varianti sotto forma di due diverse struct, definite in modo differente per ciascuna variante:

#![allow(unused)]
fn main() {
struct Ipv4Addr {
    // --taglio--
}

struct Ipv6Addr {
    // --taglio--
}

enum IpAddr {
    V4(Ipv4Addr),
    V6(Ipv6Addr),
}
}

Questo codice illustra che puoi mettere qualsiasi tipologia di dato dentro una variante di enum: stringhe, type numerici o struct, per esempio. Puoi persino includere un’altra enum! Inoltre, i type della libreria standard spesso non sono molto più complicati di quello che potresti creare tu.

Nota che anche se la libreria standard contiene una definizione per IpAddr, possiamo comunque creare e usare la nostra definizione senza conflitti perché non abbiamo importato la definizione della libreria standard nel nostro scope. Parleremo più avanti dell’importazione dei type nello scope nel Capitolo 7.

Diamo un’occhiata a un altro esempio di enum nel Listato 6-2: questo ha una grande varietà di type incorporati nelle sue varianti.

enum Messaggio {
    Esci,
    Sposta { x: i32, y: i32 },
    Scrivi(String),
    CambiaColore(i32, i32, i32),
}

fn main() {}

Questa enum ha quattro varianti con type diversi:

• Esci: non ha dati associati
• Muovi: ha campi nominati, come fa un struct
• Scrivi: include una singola String
• CambiaColore: include tre valori i32

Definire un’enum con varianti come quelle nel Listato 6-2 è simile a definire diversi type di struct, eccetto che l’enum non usa la parola chiave struct e tutte le varianti sono raggruppate sotto il type Messaggio. Le seguenti struct potrebbero contenere gli stessi dati che le varianti dell’enum precedente contengono:

struct MessaggioEsci; // unit struct
struct SpostaMessaggio {
    x: i32,
    y: i32,
}
struct ScriviMessaggio(String); // tuple struct
struct CambiaColoreMessaggio(i32, i32, i32); // tuple struct

fn main() {}

Ma se usassimo le diverse struct, ognuna con il proprio type, non potremmo definire altrettanto facilmente una funzione che accetti uno qualsiasi di questi type di messaggi come potremmo fare con l’enum Messaggio definito nel Listato 6-2, che è un singolo type.

C’è un’ulteriore somiglianza tra enum e struct: proprio come possiamo definire metodi sulle struct usando impl, possiamo anche definire metodi sulle enum. Ecco un metodo nominato chiama che potremmo definire sulla nostra enum Messaggio:

fn main() {
    enum Messaggio {
        Esci,
        Sposta { x: i32, y: i32 },
        Scrivi(String),
        CambiaColore(i32, i32, i32),
    }

    impl Messaggio {
        fn chiama(&self) {
            // il corpo del metodo sarà definito qui
        }
    }

    let m = Messaggio::Scrivi(String::from("ciao"));
    m.chiama();
}

Il corpo del metodo userebbe self per ottenere il valore su cui abbiamo chiamato il metodo. In questo esempio, abbiamo creato una variabile m che ha il valore Messaggio::Scrivi(String::from("ciao")), e quello sarà self nel corpo del metodo chiama quando m.chiama() viene eseguito.

Diamo un’occhiata a un’altra enum nella libreria standard che è molto comune e utile: Option.

L’Enum Option

Questa sezione esplora un caso di studio su Option, che è un’altra enum definito dalla libreria standard. Il type Option codifica lo scenario molto comune in cui un valore può essere qualcosa oppure niente.

Per esempio, se richiedi il primo elemento di una lista non vuota, otterrai un valore. Se richiedi il primo elemento di una lista vuota, non otterrai niente. Esprimere questo concetto in termini del sistema dei type permette al compilatore di verificare se hai gestito tutti i casi che dovresti gestire; questa funzionalità può prevenire bug estremamente comuni in altri linguaggi di programmazione.

La progettazione dei linguaggi di programmazione è spesso pensata in termini delle funzionalità che includi, ma anche le funzionalità che escludi sono importanti. Rust non prevede l’uso di null che molti altri linguaggi possiedono. Null è un valore che significa che non c’è alcun valore. Nei linguaggi con null, le variabili possono essere sempre in uno dei due stati: null o non-null.

Nella sua presentazione del 2009 “Null References: The Billion Dollar Mistake”, Tony Hoare, l’inventore del null, disse:

Lo chiamo il mio errore da un miliardo di dollari. All’epoca stavo progettando il primo sistema di type completo per i reference in un linguaggio orientato agli oggetti. Il mio obiettivo era garantire che ogni uso dei reference fosse assolutamente sicuro, con i controlli effettuati automaticamente dal compilatore. Ma non ho resistito alla tentazione di inserire un reference nullo, semplicemente perché era così facile da implementare. Questo ha portato a innumerevoli errori, vulnerabilità e crash di sistema, che probabilmente hanno causato un miliardo di dollari di dolore e danni negli ultimi quarant’anni.

Il problema con i valori null è che se provi a usare un valore null come se fosse un valore non-null, otterrai un errore di qualche tipo. Poiché questa proprietà null o no-null è pervasiva, è estremamente facile commettere questo tipo di errore.

Tuttavia, il concetto che il null cerca di esprimere è ancora utile: null è un valore che è attualmente invalido o assente per qualche motivo.

Il problema non è veramente il concetto ma l’implementazione. Di conseguenza, Rust non ha i null, ma ha un’enum che può codificare il concetto di un valore presente o assente. Questa enum è Option<T>, ed è definito dalla libreria standard come segue:

#![allow(unused)]
fn main() {
enum Option<T> {
    None,
    Some(T),
}
}

L’enum Option<T> è così utile che è incluso nel prelude (preludio è l’insieme di funzionalità che Rust include di default in ogni programma fornite dalla libreria standard); non è necessario portarlo nello scope esplicitamente. Le sue varianti sono anch’esse incluse nel prelude: puoi usare Some e None direttamente senza il prefisso Option::. L’enum Option<T> è comunque un normale enum, e Some(T) e None sono ancora varianti del type Option<T>.

La sintassi <T> è una caratteristica di Rust di cui non abbiamo ancora parlato. È un parametro di type generico, e tratteremo i type generici più in dettaglio nel Capitolo 10. Per ora, tutto ciò che devi sapere è che <T> significa che la variante Some dell’enum Option può contenere un pezzo di dato di qualsiasi type, e che ogni type concreto che viene usato al posto di T rende il type complessivo Option<T> un type diverso. Ecco alcuni esempi di utilizzo di valori Option per contenere type numerici e type carattere:

fn main() {
    let un_numero = Some(5);
    let un_carattere = Some('e');

    let nessun_numero: Option<i32> = None;
}

Il type di un_numero è Option<i32>. Il type di un_carattere è Option<char>, che è un type diverso. Rust può inferire questi type perché abbiamo specificato un valore dentro la variante Some. Per nessun_numero, Rust ci richiede di annotare il type di Option: il compilatore non può inferire il type che la variante Some corrispondente conterrà guardando solo al valore None. Qui diciamo a Rust che intendiamo che nessun_numero sia di type Option<i32>.

Quando abbiamo un valore Some, sappiamo che un valore è presente e il valore è contenuto all’interno di Some. Quando abbiamo un valore None, in un certo senso significa la stessa cosa di null: non abbiamo un valore valido. Quindi perché avere Option<T> è meglio che avere null?

In breve, perché Option<T> e T (dove T può essere qualsiasi type) sono type diversi, il compilatore non ci permetterà di usare un valore Option<T> come se fosse sicuramente un valore valido. Per esempio, questo codice non compilerà, perché sta cercando di sommare un Option<i8> a un i8:

fn main() {
    let x: i8 = 5;
    let y: Option<i8> = Some(5);

    let somma = x + y;
}

Se eseguiamo questo codice, otteniamo un messaggio di errore come questo:

$ cargo run
   Compiling enums v0.1.0 (file:///progetti/enums)
error[E0277]: cannot add `Option<i8>` to `i8`
 --> src/main.rs:6:19
  |
6 |     let somma = x + y;
  |                   ^ no implementation for `i8 + Option<i8>`
  |
  = help: the trait `Add<Option<i8>>` is not implemented for `i8`
  = help: the following other types implement trait `Add<Rhs>`:
            `&i8` implements `Add<i8>`
            `&i8` implements `Add`
            `i8` implements `Add<&i8>`
            `i8` implements `Add`

For more information about this error, try `rustc --explain E0277`.
error: could not compile `enums` (bin "enums") due to 1 previous error

Wow, quanta roba! Nel concreto, questo messaggio di errore significa che Rust non capisce come sommare un i8 e un Option<i8>, perché sono type diversi. Quando abbiamo un valore di un type come i8 in Rust, il compilatore deve assicurarsi che abbiamo sempre un valore valido. Possiamo procedere con fiducia senza dover controllare il null prima di usare quel valore. Solo quando abbiamo un Option<i8> (o qualunque type di valore con cui stiamo lavorando) dobbiamo preoccuparci della possibilità di non avere un valore, e il compilatore ci assicurerà di gestire quel caso prima di usare il valore.

In altre parole, devi convertire un Option<T> in un T prima di poter eseguire operazioni su T. Generalmente, questo aiuta a catturare uno dei problemi più comuni del null: presumere che qualcosa non sia null quando in realtà lo è.

Eliminare il rischio di presumere erroneamente un valore non-null ti aiuta a essere più sicuro nel tuo codice. Per avere un valore che può essere eventualmente null, devi esplicitamente optare per questo facendo sì che il type di quel valore sia Option<T>. Poi, quando usi quel valore, sei obbligato a gestire esplicitamente il caso in cui il valore sia null. Ovunque un valore abbia un type che non è Option<T>, puoi assumere in sicurezza che il valore non sia null. Questa è stata una decisione di design voluta in Rust per limitare la pervasività del null e aumentare la sicurezza del codice Rust.

Quindi come si estrae il valore T da una variante Some quando si ha un valore di type Option<T> in modo da poter usare quel valore? L’enum Option<T> ha un gran numero di metodi utili in varie situazioni; puoi consultarli nella sua documentazione. Familiarizzare con i metodi su Option<T> sarà estremamente utile nel tuo percorso con Rust.

In generale, per usare un valore Option<T> devi avere codice che gestisca ogni variante. Vuoi del codice che venga eseguito solo quando hai un valore Some(T), e quel codice può usare il T interno. Vuoi altro codice che venga eseguito solo se hai un valore None, e quel codice non ha un valore T disponibile. L’espressione match è un costrutto di controllo del flusso che fa esattamente questo quando viene usata con le enum: eseguirà codice diverso a seconda di quale variante dell’enum ha, e quel codice può usare i dati all’interno del valore che corrisponde.

Controllare il Flusso col Costrutto match

Rust offre un costrutto di controllo del flusso estremamente potente chiamato match (corrisponde, combacia) che permette di confrontare un valore con una serie di pattern ed eseguire codice in base al pattern che corrisponde. I pattern possono essere composti da valori letterali, nomi di variabili, caratteri jolly e molte altre cose; il Capitolo 19 copre tutte le diverse tipologie di pattern e cosa fanno. La potenza di match deriva dall’espressività dei pattern e dal fatto che il compilatore conferma che tutti i casi possibili sono gestiti.

Pensa a un’espressione match come a una macchina che smista monete: le monete scivolano lungo una guida con fori di varie dimensioni e ciascuna moneta cade nel primo foro in cui entra. Allo stesso modo, i valori passano attraverso ogni pattern in un match, e al primo pattern in cui il valore «entra», il valore viene fatto ricadere nel blocco di codice associato per essere usato durante l’esecuzione.

Parlando di monete, usiamole come esempio con match! Possiamo scrivere una funzione che prende una moneta USA sconosciuta e, in modo simile alla macchina conta-monete, determina quale moneta sia e restituisce il suo valore in centesimi, come mostrato nel Listato 6-3.

enum Moneta {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

fn valore_in_cent(moneta: Moneta) -> u8 {
    match moneta {
        Moneta::Penny => 1,
        Moneta::Nickel => 5,
        Moneta::Dime => 10,
        Moneta::Quarter => 25,
    }
}

fn main() {}

Analizziamo il match nella funzione valore_in_cent. Prima troviamo la parola chiave match seguita da un’espressione, che in questo caso è il valore moneta. Questo sembra molto simile a un’espressione condizionale usata con if, ma c’è una grande differenza: con if la condizione deve valutarsi a un valore Booleano, mentre qui può essere di qualsiasi type. Il type di moneta in questo esempio è l’enum Moneta che abbiamo definito nella prima riga.

Seguono i rami di match. Un ramo è composto da due parti: un pattern e del codice. Il primo ramo qui ha come pattern il valore Moneta::Penny e poi l’operatore => che separa il pattern dal codice da eseguire. Il codice in questo caso è semplicemente il valore 1. Ogni ramo è separato dal successivo da una virgola.

Quando l’espressione match viene eseguita, confronta il valore risultante con il pattern di ogni ramo, in ordine. Se un pattern corrisponde al valore, viene eseguito il codice associato a quel pattern. Se quel pattern non corrisponde, l’esecuzione continua con il ramo successivo, proprio come nella macchina che smista monete. Possiamo avere tanti rami quanti ce ne servono: nel Listato 6-3, il nostro match ha quattro rami.

Il codice associato a ciascun ramo è un’espressione, e il valore risultante dell’espressione nel ramo che corrisponde è il valore restituito per l’intera espressione match.

Di solito non usiamo le parentesi graffe se il codice del ramo è breve, come nel Listato 6-3 dove ogni ramo restituisce solo un valore. Se vuoi eseguire più righe di codice in un ramo del match, devi usare le parentesi graffe, e la virgola che segue il ramo diventa opzionale. Per esempio, il codice seguente stampa “Penny fortunato!” ogni volta che il metodo viene chiamato con una Coin::Penny, ma restituisce comunque l’ultimo valore del blocco, 1:

enum Moneta {
    Penny,
    Nickel,
    Dime,
    Quarter,
}

fn valore_in_cent(moneta: Moneta) -> u8 {
    match moneta {
        Moneta::Penny => {
            println!("Penny fortunato!");
            1
        }
        Moneta::Nickel => 5,
        Moneta::Dime => 10,
        Moneta::Quarter => 25,
    }
}

fn main() {}

Pattern che Si Legano ai Valori

Un’altra caratteristica utile dei rami del match è che possono legarsi alle parti dei valori che corrispondono al pattern. È così che possiamo estrarre valori dalle varianti delle enum.

Per esempio, modifichiamo una delle nostre varianti dell’enum per contenerci dei dati. Dal 1999 al 2008, gli Stati Uniti coniarono quarter con design diversi per ciascuno dei 50 stati su un lato. Nessun’altra moneta aveva design statali, quindi solo i quarter hanno questa caratteristica peculiare. Possiamo aggiungere questa informazione al nostra enum cambiando la variante Quarter per includere un valore StatoUSA all’interno, come fatto nel Listato 6-4.

#[derive(Debug)] // così possiamo vederne i valori tra un po'
enum StatoUSA {
    Alabama,
    Alaska,
    // --taglio--
}

enum Moneta {
    Penny,
    Nickel,
    Dime,
    Quarter(StatoUSA),
}

fn main() {}

Immaginiamo che un amico stia cercando di collezionare tutti e 50 i quarter statali. Mentre separiamo il nostro resto per tipo di moneta, guarderemo anche il nome dello stato associato a ciascun quarter così, se è uno che al nostro amico manca, può aggiungerlo alla collezione.

Nell’espressione match per questo codice, aggiungiamo una variabile chiamata stato al pattern che corrisponde ai valori della variante Coin::Quarter. Quando un Coin::Quarter corrisponde, la variabile stato si legherà al valore dello stato di quel quarter. Possiamo poi usare stato nel codice di quel ramo, così:

#[derive(Debug)]
enum StatoUSA {
    Alabama,
    Alaska,
    // --taglio--
}

enum Moneta {
    Penny,
    Nickel,
    Dime,
    Quarter(StatoUSA),
}

fn valore_in_cent(moneta: Moneta) -> u8 {
    match moneta {
        Moneta::Penny => 1,
        Moneta::Nickel => 5,
        Moneta::Dime => 10,
        Moneta::Quarter(stato) => {
            println!("Quarter statale del {stato:?}!");
            25
        }
    }
}

fn main() {
    valore_in_cent(Moneta::Quarter(StatoUSA::Alaska));
}

Se chiamassimo valore_in_cent(Moneta::Quarter(StatoUSA::Alaska)), moneta sarebbe Moneta::Quarter(StatoUSA::Alaska). Quando confrontiamo quel valore con ciascuno dei rami del match, nessuna corrisponde fino a che non raggiungiamo Moneta::Quarter(stato). A quel punto stato sarà vincolato al valore StatoUSA::Alaska. Possiamo quindi usare quel vincolo nell’espressione println!, ottenendo così il valore interno dello stato dalla variante Moneta::Quarter.

Corrispondenza con Option<T>

Nella sezione precedente volevamo ottenere il valore interno T di Some quando si usa Option<T>; possiamo anche gestire Option<T> usando match, proprio come abbiamo fatto con l’enum Moneta! Invece di confrontare monete, confronteremo le varianti di Option<T>, ma il funzionamento dell’espressione match rimane lo stesso.

Supponiamo di voler scrivere una funzione che prende un Option<i32> e, se c’è un valore dentro, aggiunge 1 a quel valore. Se non c’è un valore dentro, la funzione dovrebbe restituire il valore None e non tentare di eseguire alcuna operazione.

Questa funzione è molto semplice da scrivere, grazie a match, e apparirà come nel Listato 6-5.

fn main() {
    fn più_uno(x: Option<i32>) -> Option<i32> {
        match x {
            None => None,
            Some(i) => Some(i + 1),
        }
    }

    let cinque = Some(5);
    let sei = più_uno(cinque);
    let nulla = più_uno(None);
}

Esaminiamo la prima esecuzione di più_uno in maggiore dettaglio. Quando chiamiamo più_uno(cinque), la variabile x nel corpo di più_uno avrà il valore Some(5). Quindi confrontiamo quello rispetto a ciascun ramo del match:

fn main() {
    fn più_uno(x: Option<i32>) -> Option<i32> {
        match x {
            None => None,
            Some(i) => Some(i + 1),
        }
    }

    let cinque = Some(5);
    let sei = più_uno(cinque);
    let nulla = più_uno(None);
}

Il valore Some(5) non corrisponde al pattern None, quindi si continua con il ramo successivo:

fn main() {
    fn più_uno(x: Option<i32>) -> Option<i32> {
        match x {
            None => None,
            Some(i) => Some(i + 1),
        }
    }

    let cinque = Some(5);
    let sei = più_uno(cinque);
    let nulla = più_uno(None);
}

Some(5) corrisponde a Some(i)? Sì! Abbiamo la stessa variante. i si lega al valore contenuto in Some, quindi i assume il valore 5. Il codice nel ramo del match viene quindi eseguito: aggiungiamo 1 al valore di i e creiamo un nuovo valore Some con il totale 6 all’interno.

Consideriamo ora la seconda chiamata di più_uno nel Listato 6-5, dove x è None. Entriamo nel match e confrontiamolo con il primo ramo:

fn main() {
    fn più_uno(x: Option<i32>) -> Option<i32> {
        match x {
            None => None,
            Some(i) => Some(i + 1),
        }
    }

    let cinque = Some(5);
    let sei = più_uno(cinque);
    let nulla = più_uno(None);
}

Corrisponde! Non c’è alcun valore a cui aggiungere, quindi il programma si ferma e restituisce il valore None sul lato destro di =>. Poiché il primo ramo ha corrisposto, nessun altro ramo viene confrontato.

Combinare match ed enum è utile in molte situazioni. Vedrai questo schema spesso nel codice Rust: fai match su un’enum, leghi una variabile ai dati interni e poi esegui codice basato su di essi. All’inizio è un po’ ostico, ma una volta che ci prendi la mano vorrai averlo in tutti i linguaggi. È un costrutto tra i preferiti dagli utenti.

Le Corrispondenze sono Esaustive

C’è un altro aspetto di match da discutere: i pattern dei rami devono coprire tutte le possibilità. Considera questa versione della nostra funzione più_uno, che contiene un bug e non si compilerà:

fn main() {
    fn più_uno(x: Option<i32>) -> Option<i32> {
        match x {
            Some(i) => Some(i + 1),
        }
    }

    let cinque = Some(5);
    let sei = più_uno(cinque);
    let nulla = più_uno(None);
}

Non abbiamo gestito il caso None, quindi questo codice provocherà un errore. Per fortuna, è un errore che Rust sa come intercettare. Se proviamo a compilare questo codice, otterremo questo errore:

$ cargo run
   Compiling enums v0.1.0 (file:///progetti/enums)
error[E0004]: non-exhaustive patterns: `None` not covered
 --> src/main.rs:4:15
  |
4 |         match x {
  |               ^ pattern `None` not covered
  |
note: `Option<i32>` defined here
 --> /rustc/8e62bfd311791bfd9dca886abdfbab07ec54d8b4/library/core/src/option.rs:593:1
 ::: /rustc/8e62bfd311791bfd9dca886abdfbab07ec54d8b4/library/core/src/option.rs:597:5
  |
  = note: not covered
  = note: the matched value is of type `Option<i32>`
help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
  |
5 ~             Some(i) => Some(i + 1),
6 ~             None => todo!(),
  |

For more information about this error, try `rustc --explain E0004`.
error: could not compile `enums` (bin "enums") due to 1 previous error

Rust sa che non abbiamo coperto ogni possibile caso, e sa persino quale pattern abbiamo dimenticato! I match in Rust sono esaustivi (exhaustive): dobbiamo coprire ogni possibilità affinché il codice sia valido. Soprattutto nel caso di Option<T>, quando Rust ci impedisce di dimenticare di gestire esplicitamente il caso None, ci protegge dall’assumere che abbiamo un valore quando potremmo avere null, rendendo impossibile “l’errore da un miliardo di dollari” accennato nel capitolo precedente.

Pattern Pigliatutto e Segnaposto _

Usando le enum, possiamo anche eseguire determinate azioni per alcuni valori particolari, ma per tutti gli altri valori adottare un’azione predefinita. Immagina di implementare un gioco dove, se tiri un 3 in un lancio di dadi, il tuo giocatore non si muove ma riceve un nuovo cappello buffo. Se tiri un 7, il giocatore perde il cappello buffo. Per tutti gli altri valori, il giocatore si muove di quel numero di spazi sulla tavola di gioco. Ecco un match che implementa quella logica, con il risultato del lancio specificato anziché casuale, e tutta l’altra logica rappresentata da funzioni senza corpo perché implementarli esula da questo esempio:

fn main() {
    let tiro_dadi = 9;
    match tiro_dadi {
        3 => metti_cappello_buffo(),
        7 => togli_cappello_buffo(),
        altro => muovi_giocatore(altro),
    }

    fn metti_cappello_buffo() {}
    fn togli_cappello_buffo() {}
    fn muovi_giocatore(num_spazi: u8) {}
}

Per i primi due rami, i pattern sono i valori letterali 3 e 7. Per l’ultimo ramo che copre tutti gli altri valori possibili, il pattern è la variabile che abbiamo scelto di chiamare altro. Il codice che viene eseguito per il ramo altro usa la variabile passando il suo valore alla funzione muovi_giocatore.

Questo codice compila, anche se non abbiamo elencato tutti i possibili valori che un u8 può avere, perché l’ultimo pattern corrisponderà a tutti i valori non specificamente elencati. Questo pattern pigliatutto (catch-all) soddisfa il requisito che match deve essere esaustivo. Nota che dobbiamo mettere il ramo pigliatutto per ultimo perché i pattern sono valutati in ordine. Se mettessimo il ramo pigliatutto prima, gli altri rami non verrebbero mai eseguiti, quindi Rust ci avvertirebbe se aggiungessimo rami dopo un pigliatutto!

Rust ha anche un pattern che possiamo usare quando vogliamo un pigliatutto ma non vogliamo usare il valore corrispondente: _ è un pattern speciale che corrisponde a qualsiasi valore e non si lega a quel valore. Questo dice a Rust che non useremo il valore, quindi Rust non ci segnalerà una variabile inutilizzata.

Cambiamo le regole del gioco: ora, se tiri qualsiasi cosa diversa da 3 o 7, devi rilanciare. Non abbiamo più bisogno di usare il valore pigliatutto, quindi possiamo cambiare il codice per usare _ al posto della variabile chiamata altro:

fn main() {
    let tiro_dadi = 9;
    match tiro_dadi {
        3 => metti_cappello_buffo(),
        7 => togli_cappello_buffo(),
        _ => tira_ancora(),
    }

    fn metti_cappello_buffo() {}
    fn togli_cappello_buffo() {}
    fn tira_ancora() {}
}

Anche questo esempio soddisfa il requisito di esaustività perché stiamo esplicitamente ignorando tutti gli altri valori nell’ultimo ramo; non abbiamo dimenticato nulla.

Infine, cambiamo ancora una volta le regole del gioco in modo che non succeda nient’altro nel tuo turno se tiri qualcosa di diverso da 3 o 7. Possiamo esprimerlo usando il valore unit (la tupla vuota) come codice associato al ramo _:

fn main() {
    let tiro_dadi = 9;
    match tiro_dadi {
        3 => metti_cappello_buffo(),
        7 => togli_cappello_buffo(),
        _ => (),
    }

    fn metti_cappello_buffo() {}
    fn togli_cappello_buffo() {}
}

Qui stiamo dicendo esplicitamente a Rust che non useremo alcun altro valore che non corrisponda a un pattern in un ramo precedente, e non vogliamo eseguire alcun codice in questo caso.

C’è molto altro sui pattern e sul matching che tratteremo nel Capitolo 19. Per ora, passiamo alla sintassi if let, che può essere utile nelle situazioni più semplici in cui l’espressione match risulta un po’ verbosa.

Controllare il Flusso con if let e let else

La sintassi if let consente di combinare if e let in un modo meno verboso per gestire i valori che corrispondono a un singolo pattern, ignorando gli altri. Considera il programma nel Listato 6-6 che fa matching su un Option<u8> nella variabile config_max ma vuole eseguire codice solo se il valore è la variante Some.

fn main() {
    let config_max = Some(3u8);
    match config_max {
        Some(max) => println!("Il massimo è configurato per essere {max}"),
        _ => (),
    }
}

Se il valore è Some, stampiamo il valore contenuto nella variante Some legandolo alla variabile max nel pattern. Non vogliamo fare nulla per il valore None. Per soddisfare l’espressione match dobbiamo aggiungere _ => () dopo aver processato una sola variante, il che, a ben vedere, sembra codice un po’ inutile.

Invece, possiamo scrivere questo in modo più breve usando if let. Il codice seguente si comporta allo stesso modo del match nel Listato 6-6:

fn main() {
    let config_max = Some(3u8);
    if let Some(max) = config_max {
        println!("Il massimo è configurato per essere {max}");
    }
}

La sintassi if let prende un pattern e un’espressione separati da un segno di uguale. Funziona come un match, dove l’espressione è data al match e il pattern è il suo primo ramo. In questo caso il pattern è Some(max), e max si lega al valore dentro il Some. Possiamo quindi usare max nel corpo del blocco if let nello stesso modo in cui lo usavamo nel corrispondente ramo del match. Il codice nel blocco if let viene eseguito solo se il valore corrisponde al pattern.

Usare if let significa meno digitazione, meno indentazione e meno codice poco utile. Tuttavia si perde il controllo di esaustività che il match impone e che garantisce di non dimenticare di gestire dei casi. La scelta tra match e if let dipende da cosa stai facendo in quella situazione particolare e se un codice più conciso valga la perdita del controllo esaustivo.

In altre parole, puoi pensare a if let come ad una espressione match ridotta all’osso che esegue codice quando il valore corrisponde a un pattern e poi ignora tutti gli altri valori.

Possiamo includere un else con un if let. Il blocco di codice che accompagna l’else è lo stesso blocco che andrebbe con il caso _ nell’espressione match equivalente all’if let con else. Ricorda la definizione dell’enum Moneta nel Listato 6-4, dove la variante Quarter conteneva anche un valore StatoUSA. Se volessimo contare tutte le monete non-quarter che vediamo annunciando anche lo stato dei quarter, potremmo farlo con un’espressione match, così:

#[derive(Debug)]
enum StatoUSA {
    Alabama,
    Alaska,
    // --taglio--
}

enum Moneta {
    Penny,
    Nickel,
    Dime,
    Quarter(StatoUSA),
}

fn main() {
    let moneta = Moneta::Penny;
    let mut conteggio = 0;
    match moneta {
        Moneta::Quarter(stato) => println!("Quarter statale del {stato:?}!"),
        _ => conteggio += 1,
    }
}

Oppure potremmo usare un if let e un else, così:

#[derive(Debug)]
enum StatoUSA {
    Alabama,
    Alaska,
    // --taglio--
}

enum Moneta {
    Penny,
    Nickel,
    Dime,
    Quarter(StatoUSA),
}

fn main() {
    let moneta = Moneta::Penny;
    let mut conteggio = 0;
    if let Moneta::Quarter(stato) = moneta {
        println!("Quarter statale del {stato:?}!");
    } else {
        conteggio += 1;
    }
}

Restare sul “Percorso Felice” con let...else

Una buona pratica è eseguire una computazione quando un valore è presente e restituire un valore di default altrimenti. Continuando con il nostro esempio delle monete con un valore StatoUSA, se volessimo dire qualcosa di divertente a seconda di quanto fosse vecchio lo stato sul quarter, potremmo introdurre un metodo su StatoUSA per verificare l’età dello stato, così:

#[derive(Debug)] // so we can inspect the state in a minute
enum StatoUSA {
    Alabama,
    Alaska,
    // --taglio--
}

impl StatoUSA {
    fn esistente_nel(&self, anno: u16) -> bool {
        match self {
            StatoUSA::Alabama => anno >= 1819,
            StatoUSA::Alaska => anno >= 1959,
            // --taglio--
        }
    }
}

enum Moneta {
    Penny,
    Nickel,
    Dime,
    Quarter(StatoUSA),
}

fn desc_quarter_statale(moneta: Moneta) -> Option<String> {
    if let Moneta::Quarter(stato) = moneta {
        if stato.esistente_nel(1900) {
            Some(format!("{stato:?} è abbastanza vecchio, per l'America!"))
        } else {
            Some(format!("{stato:?} è abbastanza recente."))
        }
    } else {
        None
    }
}

fn main() {
    if let Some(desc) = desc_quarter_statale(Moneta::Quarter(StatoUSA::Alaska)) {
        println!("{desc}");
    }
}

Poi potremmo usare if let per fare matching sul tipo di moneta, introducendo una variabile stato all’interno del corpo della condizione, come nel Listato 6-7.

#[derive(Debug)] // so we can inspect the state in a minute
enum StatoUSA {
    Alabama,
    Alaska,
    // --taglio--
}

impl StatoUSA {
    fn esistente_nel(&self, anno: u16) -> bool {
        match self {
            StatoUSA::Alabama => anno >= 1819,
            StatoUSA::Alaska => anno >= 1959,
            // --taglio--
        }
    }
}

enum Moneta {
    Penny,
    Nickel,
    Dime,
    Quarter(StatoUSA),
}

fn desc_quarter_statale(moneta: Moneta) -> Option<String> {
    if let Moneta::Quarter(stato) = moneta {
        if stato.esistente_nel(1900) {
            Some(format!("{stato:?} è abbastanza vecchio, per l'America!"))
        } else {
            Some(format!("{stato:?} è abbastanza recente."))
        }
    } else {
        None
    }
}

fn main() {
    if let Some(desc) = desc_quarter_statale(Moneta::Quarter(StatoUSA::Alaska)) {
        println!("{desc}");
    }
}

Questo risolve il problema, ma ha spostato il lavoro nel corpo dell’if let, e se il lavoro da fare è più complicato potrebbe risultare difficile seguire come i rami di alto livello si relazionano. Potremmo anche sfruttare il fatto che le espressioni producono un valore, o per produrre stato dall’if let o per ritornare anticipatamente, come in Listato 6-8. (Si potrebbe fare qualcosa di simile anche con un match.)

#[derive(Debug)] // so we can inspect the state in a minute
enum StatoUSA {
    Alabama,
    Alaska,
    // --taglio--
}

impl StatoUSA {
    fn esistente_nel(&self, anno: u16) -> bool {
        match self {
            StatoUSA::Alabama => anno >= 1819,
            StatoUSA::Alaska => anno >= 1959,
            // --taglio--
        }
    }
}

enum Moneta {
    Penny,
    Nickel,
    Dime,
    Quarter(StatoUSA),
}

fn desc_quarter_statale(moneta: Moneta) -> Option<String> {
    let stato = if let Moneta::Quarter(stato) = moneta {
        stato
    } else {
        return None;
    };

    if stato.esistente_nel(1900) {
        Some(format!("{stato:?} è abbastanza vecchio, per l'America!"))
    } else {
        Some(format!("{stato:?} è abbastanza recente."))
    }
}

fn main() {
    if let Some(desc) = desc_quarter_statale(Moneta::Quarter(StatoUSA::Alaska)) {
        println!("{desc}");
    }
}

Questo però è un po’ scomodo da seguire: un ramo dell’if let produce un valore e l’altro ritorna dalla funzione completamente.

Per rendere più esprimibile questo pattern comune, Rust ha let...else. La sintassi let...else prende un pattern a sinistra e un’espressione a destra, molto simile a if let, ma non ha un ramo if, soltanto un ramo else. Se il pattern corrisponde, legherà il valore estratto dal pattern nello scope esterno. Se il pattern non corrisponde, il flusso va nel ramo else, che deve restituire dalla funzione.

Nel Listato 6-9 puoi vedere come Listato 6-8 appare usando let...else al posto di if let.

#[derive(Debug)] // so we can inspect the state in a minute
enum StatoUSA {
    Alabama,
    Alaska,
    // --taglio--
}

impl StatoUSA {
    fn esistente_nel(&self, anno: u16) -> bool {
        match self {
            StatoUSA::Alabama => anno >= 1819,
            StatoUSA::Alaska => anno >= 1959,
            // --taglio--
        }
    }
}

enum Moneta {
    Penny,
    Nickel,
    Dime,
    Quarter(StatoUSA),
}

fn desc_quarter_statale(moneta: Moneta) -> Option<String> {
    let Moneta::Quarter(stato) = moneta else {
        return None;
    };

    if stato.esistente_nel(1900) {
        Some(format!("{stato:?} è abbastanza vecchio, per l'America!"))
    } else {
        Some(format!("{stato:?} è abbastanza recente."))
    }
}

fn main() {
    if let Some(desc) = desc_quarter_statale(Moneta::Quarter(StatoUSA::Alaska)) {
        println!("{desc}");
    }
}

Nota che in questo modo si resta sul “percorso felice” nel corpo principale della funzione, senza avere un controllo di flusso significativamente diverso per i due rami come invece succedeva con if let.

Se hai una situazione in cui la logica è troppo verbosa per essere espressa con un match, ricorda che anche if let e let...else sono nella tua cassetta degli attrezzi di Rust.

Riepilogo

Abbiamo ora coperto come usare le enum per creare type personalizzati che possono essere uno tra un insieme di valori enumerati. Abbiamo mostrato come il type Option<T> della libreria standard ti aiuta a usare il sistema dei type per prevenire errori. Quando i valori delle enum contengono dati, puoi usare match o if let per estrarre e usare quei valori, a seconda di quanti casi devi gestire.

I tuoi programmi Rust possono ora esprimere concetti nel tuo dominio usando struct ed enum. Creare type personalizzati da usare nella tua API assicura maggiore sicurezza dei dati (type safety): il compilatore garantirà che le tue funzioni ricevano solo i valori del type che ciascuna funzione si aspetta.

Per fornire un’API ben organizzata ai tuoi utenti, chiara da usare ed esponendo solo ciò che serve, passiamo ora ai moduli di Rust.

Pacchetti, Crate, e Moduli

Quando scriverai programmi sempre più complessi, organizzare il tuo codice diventerà sempre più importante. Raccogliendo funzionalità correlate e separando il codice con caratteristiche distinte, chiarirai dove trovare il codice che implementa una particolare funzionalità e quindi dove guardare per modificare il codice di quella funzionalità se necessario.

I programmi che abbiamo scritto finora sono stati tutti implementati con un singolo modulo in un unico file. Man mano che un progetto cresce, dovresti organizzare il codice suddividendolo in più moduli e poi in più file. Un pacchetto (package) può contenere più crate binari (binary crate) e opzionalmente un crate libreria (library crate). Man mano che un pacchetto cresce, puoi estrarne parti in crate separate che diventeranno dipendenze esterne. Questo capitolo copre tutte queste tecniche. Per progetti molto grandi che comprendono un insieme di pacchetti interconnessi che evolvono insieme, Cargo fornisce degli spazi di lavoro (workspace), che tratteremo in “Cargo Workspace” nel Capitolo 14.

Discuteremo anche l’incapsulamento dei dettagli di implementazione, che ti consente di riutilizzare il codice a un livello più alto: una volta implementata un’operazione, l’altro codice può chiamare il tuo codice tramite la sua interfaccia pubblica senza dover sapere come funziona l’implementazione. Il modo in cui scrivi il codice definisce quali parti sono pubbliche per l’uso da parte di altri codici e quali parti sono dettagli di implementazione privati che ti riservi il diritto di modificare. Questo è un altro modo per limitare la quantità di dettagli che devi tenere a mente.

Un concetto correlato è lo scope: il contesto annidato in cui è scritto il codice ha un insieme di nomi definiti come “in scope”. Quando si legge, si scrive e si compila il codice, i programmatori e i compilatori devono sapere se un particolare nome in un particolare punto si riferisce a una variabile, funzione, struct, enum, modulo, costante o altro elemento e cosa significa quell’elemento. Puoi creare scope e modificare quali nomi sono in o fuori scope. Non puoi avere due elementi con lo stesso nome nello stesso scope; sono disponibili strumenti per risolvere i conflitti di nomenclatura.

Rust ha una serie di funzionalità che ti consentono di gestire l’organizzazione del tuo codice, inclusi i dettagli esposti, i dettagli privati e quali nomi sono in ogni scope nei tuoi programmi. Queste funzionalità, a volte definite collettivamente sistema dei moduli (module system), includono:

• Pacchetti: Una funzionalità di Cargo che ti consente di costruire, testare e condividere crate
• Crate: Un albero di moduli che produce una libreria o un eseguibile
• Moduli e use: Ti consentono di controllare l’organizzazione, lo scope e la privacy dei percorsi (paths)
• Path: Un modo per nominare un elemento, come una struct, una funzione o un modulo

In questo capitolo, tratteremo tutte queste funzionalità, discuteremo come interagiscono e spiegheremo come usarle per gestire lo scope. Alla fine, dovresti avere una solida comprensione del module system e essere in grado di lavorare con gli scope come un professionista!

Pacchetti e Crate

Le prime parti del sistema dei moduli che tratteremo sono i pacchetti e i crate.

Un crate è la quantità minima di codice che il compilatore Rust considera in un dato momento. Anche se esegui rustc invece di cargo e passi un singolo file di codice sorgente (come abbiamo fatto all’inizio in “Programma Rust Basilare” nel Capitolo 1), il compilatore considera quel file come un crate. I crate possono contenere moduli, e i moduli possono essere definiti in altri file che vengono compilati con il crate, come vedremo nelle sezioni successive.

Un crate può presentarsi in una delle due forme: un crate binario o un crate libreria. I crate binari sono programmi che puoi compilare in un eseguibile che puoi eseguire, come un programma da riga di comando o un server. Ognuno deve avere una funzione chiamata main che definisce cosa succede quando l’eseguibile viene eseguito. Tutti i crate che abbiamo creato finora sono stati crate binari.

I crate libreria non hanno una funzione main, e non si compilano in un eseguibile. Invece, definiscono funzionalità destinate a essere condivise con progetti multipli. Ad esempio, il crate rand che abbiamo usato nel Capitolo 2 fornisce funzionalità che generano numeri casuali. La maggior parte delle volte, quando i Rustacean dicono “crate”, intendono crate libreria, e usano “crate” in modo intercambiabile con il concetto generale di programmazione di una “libreria”.

La radice del crate (crate root) è un file sorgente da cui il compilatore Rust inizia e costituisce il modulo radice del tuo crate (spiegheremo i moduli in dettaglio nel capitolo “Controllare Scope e Privacy con i Moduli”).

Un pacchetto (package) è un insieme di uno o più crate che fornisce un insieme di funzionalità. Un pacchetto contiene un file Cargo.toml che descrive come costruire quei crate. Cargo è anch’esso in realtà un pacchetto che contiene il crate binario per lo strumento da riga di comando che hai usato per costruire il tuo codice finora. Il pacchetto Cargo contiene anche un crate libreria di cui il crate binario ha bisogno. Altri progetti possono dipendere dal crate libreria Cargo per utilizzare la stessa logica che utilizza lo strumento da riga di comando Cargo.

Un pacchetto può contenere quanti più crate binari desideri, ma al massimo solo un crate libreria. Un pacchetto deve contenere almeno un crate, sia esso un crate libreria o binario.

Esploriamo cosa succede quando creiamo un pacchetto. Cominciamo con il comando cargo new mio-progetto:

$ cargo new mio-progetto
     Created binary (application) `mio-progetto` package
$ ls mio-progetto
Cargo.toml
src
$ ls mio-progetto/src
main.rs

Dopo aver eseguito cargo new mio-progetto, usiamo ls per vedere cosa crea Cargo. Nella cartella mio-progetto, c’è un file Cargo.toml, che definisce un pacchetto. C’è anche una cartella src che contiene main.rs. Apri Cargo.toml nel tuo editor di testo e nota che non c’è menzione di src/main.rs. Cargo segue una convenzione secondo cui src/main.rs è la radice del crate di un crate binario con lo stesso nome del pacchetto. Allo stesso modo, Cargo sa che se la cartella del pacchetto contiene src/lib.rs, il pacchetto contiene un crate libreria con lo stesso nome del pacchetto, e src/lib.rs è la sua radice del crate. Cargo passa i file di radice del crate a rustc per costruire la libreria o il binario.

Qui, abbiamo un pacchetto che contiene solo src/main.rs, il che significa che contiene solo un crate binario chiamato mio-progetto. Se un pacchetto contiene src/main.rs e src/lib.rs, avrà due crate: uno binario e uno libreria, entrambi con lo stesso nome del pacchetto. Un pacchetto può avere più crate binari posizionando file nella cartella src/bin: ogni file sarà un crate binario separato.

Controllare Scope e Privacy con i Moduli

In questa sezione, parleremo dei moduli e di altre parti del sistema dei moduli, in particolare dei path (percorsi), che ti permettono di nominare gli elementi; la parola chiave use che porta un path in scope; e la parola chiave pub per rendere pubblici gli elementi. Discuteremo anche della parola chiave as, dei pacchetti esterni e dell’operatore glob.

Scheda Informativa sui Moduli

Prima di entrare nei dettagli dei moduli e dei path, qui forniamo un rapido riferimento su come funzionano i moduli, i path, la parola chiave use e la parola chiave pub nel compilatore, e come la maggior parte degli sviluppatori organizza il proprio codice. Esamineremo esempi di ciascuna di queste regole nel corso di questo capitolo, ma questo è un ottimo riassunto da consultare come promemoria su come funzionano i moduli.

• Inizia dalla radice del crate: Quando compili un crate, il compilatore prima cerca nel file di radice del crate (di solito src/lib.rs per un crate libreria e src/main.rs per un crate binario) il codice da compilare.
• Dichiarare moduli: Nel file di radice del crate, puoi dichiarare nuovi moduli; ad esempio, dichiari un modulo “giardino” con mod giardino;. Il compilatore cercherà il codice del modulo in questi luoghi:
  • Sulla linea, all’interno delle parentesi graffe che sostituiscono il punto e virgola dopo mod giardino
  • Nel file src/giardino.rs
  • Nel file src/giardino/mod.rs
• Dichiarare sottomoduli: In qualsiasi file diverso dalla radice del crate, puoi dichiarare sottomoduli. Ad esempio, potresti dichiarare mod verdure; in src/giardino.rs. Il compilatore cercherà il codice del sottomodulo all’interno della cartella nominata per il modulo genitore (parent) in questi luoghi:
  • Sulla linea, direttamente dopo mod verdure, all’interno delle parentesi graffe invece del punto e virgola
  • Nel file src/giardino/verdure.rs
  • Nel file src/giardino/verdure/mod.rs
• Path per il codice nei moduli: Una volta che un modulo è parte del tuo crate, puoi fare riferimento al codice in quel modulo da qualsiasi altro punto dello stesso crate, purché le regole di privacy lo consentano, utilizzando il path per il codice. Ad esempio, un type Asparagi nel modulo delle verdure del giardino si troverebbe al path crate::giardino::verdure::Asparagi.
• Privato vs. pubblico: Il codice all’interno di un modulo è non utilizzabile, privato, dai suoi moduli genitore come impostazione predefinita. Per rendere un modulo utilizzabile, pubblico, è necessario dichiaralo con pub mod invece di mod. Per rendere pubblici anche gli elementi all’interno di un modulo pubblico, usa pub prima delle loro dichiarazioni.
• La parola chiave use: All’interno di uno scope, la parola chiave use crea scorciatoie per gli elementi per ridurre la ripetizione di lunghi path. In qualsiasi scope che può fare riferimento a crate::giardino::verdure::Asparagi, puoi creare una scorciatoia con use crate::giardino::verdure::Asparagi; e da quel momento in poi devi scrivere solo Asparagi per utilizzare quel type nello scope.

Ora creiamo un crate binario chiamato cortile che illustra queste regole. La cartella del crate, anch’essa chiamata cortile, contiene questi file e cartelle:

cortile
├── Cargo.lock
├── Cargo.toml
└── src
    ├── giardino
    │   └── verdure.rs
    ├── giardino.rs
    └── main.rs

La radice del crate in questo caso è src/main.rs, e contiene:

use crate::giardino::verdure::Asparagi;

pub mod giardino;

fn main() {
    let pianta = Asparagi {};
    println!("Sto coltivando {pianta:?}!");
}

La riga pub mod giardino; dice al compilatore di includere il codice che trova in src/giardino.rs, che è:

pub mod verdure;

Qui, pub mod verdure; significa che il codice in src/giardino/verdure.rs è incluso anch’esso. Quel codice è:

#[derive(Debug)]
pub struct Asparagi {}

Ora entriamo nei dettagli di queste regole e dimostriamo come funzionano!

Raggruppare Codice Correlato in Moduli

I moduli ci permettono di organizzare il codice all’interno di un crate per migliore leggibilità e facilità di riutilizzo. I moduli ci consentono anche di controllare la privacy degli elementi, poiché il codice all’interno di un modulo è privato come impostazione predefinita. Gli elementi privati sono dettagli di implementazione interni non disponibili per l’uso esterno. Possiamo scegliere di rendere pubblici i moduli e gli elementi al loro interno, il che li espone per consentire al codice esterno di utilizzarli e dipendere da essi.

Come esempio, scriviamo un crate libreria che fornisce la funzionalità di un ristorante. Definiremo le firme delle funzioni ma lasceremo i loro corpi vuoti per concentrarci sull’organizzazione del codice piuttosto che sull’implementazione vera e propria.

Nel settore della ristorazione, alcune “funzioni” di un ristorante sono chiamate sala e altre cucina. La “sala” è dove si trovano i clienti; questo comprende dove l’oste riceve i clienti, i camerieri prendono ordini e pagamenti, e i baristi preparano drink. La “cucina” è dove gli chef e i cuochi lavorano in cucina, i lavapiatti puliscono e i manager svolgono lavori amministrativi.

Per strutturare il nostro crate in questo modo, possiamo organizzare le sue funzioni in moduli annidati. Crea una nuova libreria chiamata ristorante eseguendo cargo new ristorante --lib. Poi inserisci il codice nel Listato 7-1 in src/lib.rs per definire alcuni moduli e firme di funzione; questo codice è la sezione sala.

mod sala {
    mod accoglienza {
        fn aggiungi_in_lista() {}

        fn metti_al_tavolo() {}
    }

    mod servizio {
        fn prendi_ordine() {}

        fn servi_ordine() {}

        fn prendi_pagamento() {}
    }
}

Definiamo un modulo con la parola chiave mod seguita dal nome del modulo (in questo caso, sala). Il corpo del modulo va quindi all’interno delle parentesi graffe. All’interno dei moduli, possiamo inserire altri moduli, come in questo caso con i moduli accoglienza e servizio. I moduli possono anche contenere definizioni per altri elementi, come struct, enum, costanti, trait e, come nel Listato 7-1, funzioni.

Utilizzando i moduli, possiamo raggruppare definizioni correlate insieme e nominare il motivo per cui sono correlate. I programmatori che utilizzano questo codice possono navigare nel codice in base ai gruppi piuttosto che dover leggere tutte le definizioni, rendendo più facile trovare le definizioni rilevanti per loro. I programmatori che aggiungono nuove funzionalità a questo codice saprebbero dove posizionare il codice per mantenere organizzato il programma.

In precedenza, abbiamo menzionato che src/main.rs e src/lib.rs sono chiamati radici del crate. Il motivo del loro nome è che i contenuti di uno di questi due file formano un modulo chiamato crate alla radice della struttura del modulo del crate, nota come albero dei moduli (module tree).

Il Listato 7-2 mostra l’albero dei moduli per la struttura nel Listato 7-1.

crate
 └── sala
     ├── accoglienza
     │   ├── aggiungi_in_lista
     │   └── metti_al_tavolo
     └── servizio
         ├── prendi_ordine
         ├── servi_ordine
         └── prendi_pagamento

Questo albero mostra come alcuni dei moduli si annidano all’interno di altri moduli; ad esempio, accoglienza si annida all’interno di sala. L’albero mostra anche che alcuni moduli sono fratelli, il che significa che sono definiti nello stesso modulo; accoglienza e servizio sono fratelli definiti all’interno di sala. Se il modulo A è contenuto all’interno del modulo B, diciamo che il modulo A è il figlio del modulo B e che il modulo B è il genitore del modulo A. Nota che l’intero albero dei moduli è radicato sotto il modulo implicito chiamato crate.

L’albero dei moduli potrebbe ricordarti l’albero delle cartelle del filesystem sul tuo computer; questo è un confronto molto appropriato! Proprio come le cartelle in un filesystem, usi i moduli per organizzare il tuo codice. E proprio come i file in una cartella, abbiamo bisogno di un modo per trovare i nostri moduli.

Percorsi per Fare Riferimento a un Elemento nell’Albero dei Moduli

Per mostrare a Rust dove trovare un elemento in un albero dei moduli, utilizziamo un path (percorso) nello stesso modo in cui usiamo un path quando navighiamo in un filesystem. Per chiamare una funzione, dobbiamo conoscere il suo path.

Un path può assumere due forme:

• Un path assoluto è il percorso completo che inizia dalla radice del crate; per il codice di un crate esterno, il percorso assoluto inizia con il nome del crate, e per il codice del crate corrente, inizia con il letterale crate.
• Un path relativo inizia dal modulo corrente e utilizza self, super o un identificatore nel modulo corrente.

Sia i path assoluti che relativi sono seguiti da uno o più identificatori separati da doppi due punti (::).

Tornando al Listato 7-1, supponiamo di voler chiamare la funzione aggiungi_in_lista. Questo è lo stesso che chiedere: qual è il path della funzione aggiungi_in_lista? Il Listato 7-3 contiene il Listato 7-1 con alcuni dei moduli e delle funzioni rimossi.

Mostreremo due modi per chiamare la funzione aggiungi_in_lista da una nuova funzione, mangiare_al_ristorante, definita nella radice del crate. Questi path sono corretti, ma c’è un altro problema che impedirà a questo esempio di compilare così com’è. Spiegheremo perché tra poco.

La funzione mangiare_al_ristorante fa parte dell’API pubblica del nostro crate libreria, quindi la contrassegniamo con la parola chiave pub. Nella sezione “Esporre Path con la Parola Chiave pub”, entreremo nei dettagli di pub.

mod sala {
    mod accoglienza {
        fn aggiungi_in_lista() {}
    }
}

pub fn mangiare_al_ristorante() {
    // Path assoluta
    crate::sala::accoglienza::aggiungi_in_lista();

    // Path relativa
    sala::accoglienza::aggiungi_in_lista();
}

La prima volta che chiamiamo la funzione aggiungi_in_lista in mangiare_al_ristorante, utilizziamo un path assoluto. La funzione aggiungi_in_lista è definita nello stesso crate di mangiare_al_ristorante, il che significa che possiamo usare la parola chiave crate per iniziare un path assoluto. Includiamo quindi ciascuno dei moduli successivi fino a raggiungere aggiungi_in_lista. Puoi immaginare un filesystem con la stessa struttura: specificheremmo il path /sala/accoglienza/aggiungi_in_lista per eseguire il programma aggiungi_in_lista; utilizzare il nome del crate per partire dalla radice del crate è come usare / per partire dalla radice del filesystem nel tuo terminale.

La seconda volta che chiamiamo aggiungi_in_lista in mangiare_al_ristorante, utilizziamo un path relativo. Il path inizia con sala, il nome del modulo definito allo stesso livello dell’albero dei moduli di mangiare_al_ristorante. Qui l’equivalente nel filesystem sarebbe utilizzare il path sala/accoglienza/aggiungi_in_lista. Iniziare con un nome di modulo significa che il path è relativo.

Scegliere se utilizzare un path relativo o assoluto è una decisione che prenderai in base al tuo progetto, e dipende da se è più probabile che tu sposti il codice di definizione dell’elemento separatamente o insieme al codice che utilizza l’elemento. Ad esempio, se spostassimo il modulo sala e la funzione mangiare_al_ristorante in un modulo chiamato gestione_cliente, dovremmo aggiornare il path assoluto per aggiungi_in_lista, ma il path relativo rimarrebbe valido. Tuttavia, se spostassimo la funzione mangiare_al_ristorante separatamente in un modulo chiamato cena, il path assoluto per la chiamata a aggiungi_in_lista rimarrebbe lo stesso, ma il path relativo dovrebbe essere aggiornato. La nostra preferenza in generale è specificare path assoluti perché è più probabile che vogliamo spostare le definizioni di codice e le chiamate agli elementi in modo indipendente l’una dall’altra.

Proviamo a compilare il Listato 7-3 e scopriamo perché non si compila ancora! Gli errori che otteniamo sono mostrati nel Listato 7-4.

$ cargo build
   Compiling ristorante v0.1.0 (file:///progetti/ristorante)
error[E0603]: module `accoglienza` is private
 --> src/lib.rs:9:18
  |
9 |     crate::sala::accoglienza::aggiungi_in_lista();
  |                  ^^^^^^^^^^^  ----------------- function `aggiungi_in_lista` is not publicly re-exported
  |                  |
  |                  private module
  |
note: the module `accoglienza` is defined here
 --> src/lib.rs:2:5
  |
2 |     mod accoglienza {
  |     ^^^^^^^^^^^^^^^

error[E0603]: module `accoglienza` is private
  --> src/lib.rs:12:11
   |
12 |     sala::accoglienza::aggiungi_in_lista();
   |           ^^^^^^^^^^^  ----------------- function `aggiungi_in_lista` is not publicly re-exported
   |           |
   |           private module
   |
note: the module `accoglienza` is defined here
  --> src/lib.rs:2:5
   |
 2 |     mod accoglienza {
   |     ^^^^^^^^^^^^^^^

For more information about this error, try `rustc --explain E0603`.
error: could not compile `ristorante` (lib) due to 2 previous errors

I messaggi di errore dicono che il modulo accoglienza è privato. In altre parole, abbiamo i path corretti per il modulo accoglienza e la funzione aggiungi_in_lista, ma Rust non ci permette di usarli perché non ha accesso alle sezioni private. In Rust, tutti gli elementi (funzioni, metodi, struct, enum, moduli e costanti) sono privati rispetto ai moduli genitore come impostazione predefinita. Se desideri rendere un elemento come una funzione o una struct privata, lo metti in un modulo.

Gli elementi in un modulo genitore non possono utilizzare gli elementi privati all’interno dei moduli figli, ma gli elementi nei moduli figli possono utilizzare gli elementi nei loro moduli antenati. Questo perché i moduli figli incapsulano e nascondono i loro dettagli di implementazione, ma i moduli figli possono vedere il contesto in cui sono definiti. Per continuare con la nostra metafora, pensa alle regole di privacy come se fossero l’ufficio posteriore di un ristorante: ciò che accade lì è privato e nascosto per i clienti del ristorante, ma i manager dell’ufficio possono vedere e fare tutto nel ristorante che gestiscono.

Rust ha scelto che far funzionare il sistema dei moduli in questo modo, nascondendo i dettagli di implementazione interni come impostazione predefinita. In questo modo, sai quali parti del codice interno puoi modificare senza compromettere il codice esterno. Tuttavia, Rust ti offre la possibilità di esporre le parti interne del codice dei moduli figli ai moduli antenati utilizzando la parola chiave pub per rendere pubblico un elemento.

Esporre Path con la Parola Chiave pub

Torniamo all’errore nel Listato 7-4 che ci diceva che il modulo accoglienza è privato. Vogliamo che la funzione mangiare_al_ristorante nel modulo genitore abbia accesso alla funzione aggiungi_in_lista nel modulo figlio, quindi contrassegniamo il modulo accoglienza con la parola chiave pub, come mostrato nel Listato 7-5.

mod sala {
    pub mod accoglienza {
        fn aggiungi_in_lista() {}
    }
}

// --taglio--
pub fn mangiare_al_ristorante() {
    // Path assoluta
    crate::sala::accoglienza::aggiungi_in_lista();

    // Path relativa
    sala::accoglienza::aggiungi_in_lista();
}

Sfortunatamente, il codice nel Listato 7-5 genera ancora errori del compilatore, come mostrato nel Listato 7-6.

$ cargo build
   Compiling ristorante v0.1.0 (file:///progetti/ristorante)
error[E0603]: function `aggiungi_in_lista` is private
  --> src/lib.rs:12:31
   |
12 |     crate::sala::accoglienza::aggiungi_in_lista();
   |                               ^^^^^^^^^^^^^^^^^ private function
   |
note: the function `aggiungi_in_lista` is defined here
  --> src/lib.rs:4:9
   |
 4 |         fn aggiungi_in_lista() {}
   |         ^^^^^^^^^^^^^^^^^^^^^^

error[E0603]: function `aggiungi_in_lista` is private
  --> src/lib.rs:15:24
   |
15 |     sala::accoglienza::aggiungi_in_lista();
   |                        ^^^^^^^^^^^^^^^^^ private function
   |
note: the function `aggiungi_in_lista` is defined here
  --> src/lib.rs:4:9
   |
 4 |         fn aggiungi_in_lista() {}
   |         ^^^^^^^^^^^^^^^^^^^^^^

For more information about this error, try `rustc --explain E0603`.
error: could not compile `ristorante` (lib) due to 2 previous errors

Cosa è successo? Aggiungere la parola chiave pub davanti a mod accoglienza rende il modulo pubblico. Con questa modifica, se possiamo accedere a sala, possiamo accedere a accoglienza. Ma i contenuti di accoglienza sono ancora privati; rendere pubblico il modulo non rende pubblici i suoi contenuti. La parola chiave pub su un modulo consente solo al codice nei suoi moduli genitore di fare riferimento ad esso, non di accedere al suo codice interno. Poiché i moduli sono contenitori, non possiamo fare molto semplicemente rendendo pubblico il modulo; dobbiamo andare oltre e scegliere di rendere pubblici uno o più degli elementi all’interno del modulo.

Gli errori nel Listato 7-6 dicono che la funzione aggiungi_in_lista è privata. Le regole di privacy si applicano a struct, enum, funzioni e metodi, così come ai moduli.

Facciamo in modo che anche la funzione aggiungi_in_lista sia pubblica aggiungendo la parola chiave pub prima della sua definizione, come nel Listato 7-7.

mod sala {
    pub mod accoglienza {
        pub fn aggiungi_in_lista() {}
    }
}

// --taglio--
pub fn mangiare_al_ristorante() {
    // Path assoluta
    crate::sala::accoglienza::aggiungi_in_lista();

    // Path relativa
    sala::accoglienza::aggiungi_in_lista();
}

Ora il codice si compilerà! Per capire perché aggiungere la parola chiave pub ci consente di utilizzare questi path in mangiare_al_ristorante rispetto alle regole di privacy, diamo un’occhiata ai path assoluti e relativi.

Nel path assoluto, iniziamo con crate, la radice dell’albero dei moduli del nostro crate. Il modulo sala è definito nella radice del crate. Anche se sala non è pubblico, poiché la funzione mangiare_al_ristorante è definita nello stesso modulo di sala (cioè, mangiare_al_ristorante e sala sono fratelli), possiamo fare riferimento a sala da mangiare_al_ristorante. Successivamente, c’è il modulo accoglienza contrassegnato con pub. Possiamo accedere al modulo genitore di accoglienza, quindi possiamo accedere a accoglienza. Infine, la funzione aggiungi_in_lista è contrassegnata con pub e possiamo accedere al suo modulo genitore, quindi questa chiamata di funzione funziona!

Nel path relativo, la logica è la stessa del path assoluto, tranne per il primo passaggio: invece di partire dalla radice del crate, il path inizia da sala. Il modulo sala è definito all’interno dello stesso modulo di mangiare_al_ristorante, quindi il path relativo che inizia dal modulo in cui è definita mangiare_al_ristorante funziona. Poi, poiché accoglienza e aggiungi_in_lista sono contrassegnati con pub, il resto del path funziona, e questa chiamata di funzione è valida!

Se prevedi di condividere il tuo crate libreria affinché altri progetti possano utilizzare il tuo codice, la tua API pubblica è il tuo contratto con gli utenti del tuo crate che determina come possono interagire con il tuo codice. Ci sono molte considerazioni relative alla gestione delle modifiche alla tua API pubblica per facilitare la dipendenza delle persone dal tuo crate. Queste considerazioni vanno oltre l’ambito di questo libro; se sei interessato a questo argomento, consulta Le Linee Guida per l’API di Rust.

Iniziare Path Relative con super

Possiamo costruire path relative che iniziano nel modulo genitore, piuttosto che nel modulo corrente o nella radice del crate, utilizzando super all’inizio del path. Questo è simile a iniziare un path del filesystem con la sintassi .. che significa andare nella directory genitore. Utilizzare super ci consente di fare riferimento a un elemento che sappiamo essere nel modulo genitore, il che può rendere più facile riorganizzare l’albero dei moduli quando il modulo è strettamente correlato al genitore, ma il genitore potrebbe essere spostato altrove nell’albero dei moduli in futuro.

Considera il codice nel Listato 7-8 che modella la situazione in cui un cuoco corregge un ordine errato e lo porta personalmente al cliente. La funzione correzione_ordine definita nel modulo cucine chiama la funzione servi_ordine definita nel modulo genitore specificando il path per servi_ordine, iniziando con super.

fn servi_ordine() {}

mod cucine {
    fn correzione_ordine() {
        cucina_ordine();
        super::servi_ordine();
    }

    fn cucina_ordine() {}
}

La funzione correzione_ordine si trova nel modulo cucine, quindi possiamo usare super per andare al modulo genitore di cucine, che in questo caso è crate, la radice. Da lì, cerchiamo servi_ordine e lo troviamo. Successo! Pensiamo che il modulo cucine e la funzione servi_ordine siano probabilmente destinati a rimanere nella stessa relazione l’uno con l’altro e verranno spostati insieme se decidiamo di riorganizzare l’albero dei moduli del crate. Pertanto abbiamo usato super in modo da avere meno posti da aggiornare nel codice in futuro se questo codice viene spostato in un modulo diverso.

Rendere Pubbliche Struct e Enum

Possiamo anche utilizzare pub per designare struct ed enum come pubblici, ma ci sono alcuni dettagli aggiuntivi nell’uso di pub con struct ed enum. Se utilizziamo pub prima di una definizione di struct, rendiamo la struct pubblica, ma i campi della struct rimarranno privati (come per i moduli). Possiamo rendere pubblici o meno ciascun campo caso per caso. Nel Listato 7-9, abbiamo definito una struct pubblica cucine::Colazione con un campo pubblico toast ma un campo privato frutta_di_stagione. Questo modella il caso in un ristorante in cui il cliente può scegliere il tipo di pane che accompagna un pasto, ma il cuoco decide quale frutta accompagna il pasto in base a ciò che è di stagione e disponibile. La frutta disponibile cambia rapidamente, quindi i clienti non possono scegliere la frutta o vedere quale frutta riceveranno.

mod cucine {
    pub struct Colazione {
        pub toast: String,
        frutta_di_stagione: String,
    }

    impl Colazione {
        pub fn estate(toast: &str) -> Colazione {
            Colazione {
                toast: String::from(toast),
                frutta_di_stagione: String::from("pesche"),
            }
        }
    }
}

pub fn mangiare_al_ristorante() {
    // Ordina una colazione in estate con pane tostato di segale.
    let mut pasto = cucine::Colazione::estate("segale");
    // Cambiare idea sul pane che vorremmo.
    pasto.toast = String::from("integrale");
    println!("Vorrei un toast {}, grazie.", pasto.toast);

    // La riga successiva non verrà compilata se la de-commentiamo; non
    // ci è permesso vedere o modificare frutta che accompagna il pasto.
    // pasto.frutta_di_stagione = String::from("mirtilli");
}

Poiché il campo toast nella struct cucine::Colazione è pubblico, in mangiare_al_ristorante possiamo scrivere e leggere il campo toast utilizzando la notazione a punto. Nota che non possiamo utilizzare il campo frutta_di_stagione in mangiare_al_ristorante, perché frutta_di_stagione è privato. Prova a de-commentare la riga che modifica il valore del campo frutta_di_stagione per vedere quale errore ottieni!

Inoltre, nota che poiché cucine::Colazione ha un campo privato, la struct deve fornire una funzione associata pubblica che costruisce un’istanza di Colazione (qui l’abbiamo chiamata estate). Se Colazione non avesse una funzione del genere, non potremmo creare un’istanza di Colazione in mangiare_al_ristorante perché non potremmo impostare il valore del campo privato frutta_di_stagione in mangiare_al_ristorante.

Al contrario, se rendiamo un’enum pubblico, tutte le sue varianti diventano pubbliche. Abbiamo bisogno solo di pub prima della parola chiave enum, come mostrato nel Listato 7-10.

mod cucine {
    pub enum Antipasti {
        Zuppa,
        Insalata,
    }
}

pub fn mangiare_al_ristorante() {
    let ordine1 = cucine::Antipasti::Zuppa;
    let ordine2 = cucine::Antipasti::Insalata;
}

Poiché abbiamo reso pubblico l’enum Antipasti, possiamo utilizzare le varianti Zuppa e Insalata in mangiare_al_ristorante.

Le enum non sono molto utili a meno che le loro varianti non siano pubbliche; sarebbe fastidioso dover annotare tutte le varianti delle enum con pub una ad una, quindi la norma per le varianti delle enum è essere pubbliche. Le struct sono spesso utili senza che i loro campi siano pubblici, quindi i campi delle struct seguono la regola generale che tutto è privato come impostazione predefinita, a meno che non sia annotato con pub.

C’è un’ultima situazione che coinvolge pub che non abbiamo trattato, ed è la nostra ultima caratteristica del sistema dei moduli: la parola chiave use. Tratteremo use da solo prima, e poi mostreremo come combinare pub e use.

Portare i Percorsi in Scope con la Parola Chiave use

Dover scrivere i percorsi (path) per chiamare le funzioni può risultare scomodo e ripetitivo. Nel Listato 7-7, sia che scegliessimo il path assoluto o relativo per la funzione aggiungi_in_lista, ogni volta che volevamo chiamare aggiungi_in_lista dovevamo specificare anche sala e accoglienza. Fortunatamente esiste un modo per semplificare questo processo: possiamo creare un collegamento rapido a un path con la parola chiave use una volta, e poi usare il nome più corto nel resto dello scope.

Nel Listato 7-11, portiamo il modulo crate::sala::accoglienza nello scope della funzione mangiare_al_ristorante così da dover specificare solo accoglienza::aggiungi_in_lista per chiamare la funzione aggiungi_in_lista in mangiare_al_ristorante.

mod sala {
    pub mod accoglienza {
        pub fn aggiungi_in_lista() {}
    }
}

use crate::sala::accoglienza;

pub fn mangiare_al_ristorante() {
    accoglienza::aggiungi_in_lista();
}

Aggiungere use e un path in uno scope è simile a creare un collegamento simbolico nel filesystem. Aggiungendo use crate::sala::accoglienza nella radice (root) del crate, accoglienza è ora un nome valido in quello scope, come se il modulo accoglienza fosse stato definito nella radice del crate. I path portati nello scope con use rispettano anche la privacy, come qualsiasi altro path.

Nota che use crea il collegamento rapido solo per lo scope particolare in cui use è dichiarato. Il Listato 7-12 sposta la funzione mangiare_al_ristorante in un nuovo modulo figlio chiamato cliente, che ora è in uno scope diverso rispetto alla dichiarazione use, quindi il corpo della funzione non si compilerà.

mod sala {
    pub mod accoglienza {
        pub fn aggiungi_in_lista() {}
    }
}

use crate::sala::accoglienza;

mod cliente {
    pub fn mangiare_al_ristorante() {
        accoglienza::aggiungi_in_lista();
    }
}

L’errore del compilatore mostra che il collegamento non si applica più all’interno del modulo cliente:

$ cargo build
   Compiling ristorante v0.1.0 (file://progetti/ristorante)
error[E0433]: failed to resolve: use of undeclared crate or module `accoglienza`
  --> src/lib.rs:11:9
   |
11 |         accoglienza::aggiungi_in_lista();
   |         ^^^^^^^^^^^ use of undeclared crate or module `accoglienza`
   |
help: consider importing this module through its public re-export
   |
10 +     use crate::accoglienza;
   |

warning: unused import: `crate::sala::accoglienza`
 --> src/lib.rs:7:5
  |
7 | use crate::sala::accoglienza;
  |     ^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = note: `#[warn(unused_imports)]` on by default

For more information about this error, try `rustc --explain E0433`.
warning: `ristorante` (lib) generated 1 warning
error: could not compile `ristorante` (lib) due to 1 previous error; 1 warning emitted

Nota che c’è l’avviso che il use non è più usato nel suo scope! Per risolvere questo problema, sposta il use anche all’interno del modulo cliente, o riferisciti al collegamento dal modulo genitore con super::accoglienza all’interno del modulo figlio cliente.

Creare Percorsi use Idiomatici

Nel Listato 7-11, forse ti sarai chiesto perché abbiamo specificato use crate::sala::accoglienza e poi chiamato accoglienza::aggiungi_in_lista in mangiare_al_ristorante, invece di specificare il path use fino alla funzione aggiungi_in_lista per ottenere lo stesso risultato, come nel Listato 7-13.

mod sala {
    pub mod accoglienza {
        pub fn aggiungi_in_lista() {}
    }
}

use crate::sala::accoglienza::aggiungi_in_lista;

pub fn mangiare_al_ristorante() {
    aggiungi_in_lista();
}

Sebbene sia il Listato 7-11 sia il Listato 7-13 compiano lo stesso compito, il Listato 7-11 è il modo idiomatico di portare una funzione nello scope con use. Portare il modulo genitore della funzione nello scope con use significa che dobbiamo specificare il modulo genitore quando chiamiamo la funzione. Specificare il modulo genitore quando si chiama la funzione rende chiaro che la funzione non è definita localmente riducendo comunque la ripetizione del path completo. Il codice in Listato 7-13 non chiarisce dove sia definita aggiungi_in_lista.

D’altra parte, quando portiamo struct, enum e altri elementi con use, è idiomatico specificare il path completo. Il Listato 7-14 mostra il modo idiomatico per portare, ad esempio, HashMap della libreria standard nello scope di un crate binario.

use std::collections::HashMap;

fn main() {
    let mut map = HashMap::new();
    map.insert(1, 2);
}

Non c’è una ragione forte dietro questo uso: è semplicemente la convenzione che è emersa, e le persone si sono abituate a leggere e scrivere codice Rust in questo modo.

L’eccezione a questa idioma è se stiamo portando due elementi con lo stesso nome nello scope con use, perché Rust non lo permette. Il Listato 7-15 mostra come portare due Result nello scope che hanno lo stesso nome ma moduli genitore diversi, e come riferirsi a essi.

use std::fmt;
use std::io;

fn funzione1() -> fmt::Result {
    // --taglio--
    Ok(())
}

fn funzione2() -> io::Result<()> {
    // --taglio--
    Ok(())
}

Come si vede, usare i moduli genitore distingue i due type Result. Se invece avessimo specificato use std::fmt::Result e use std::io::Result, avremmo due type Result nello stesso scope, e Rust non saprebbe quale intendessimo quando avremmo usato Result.

Fornire Nuovi Nomi con la Parola Chiave as

C’è un’altra soluzione al problema di portare due type con lo stesso nome nello stesso scope con use: dopo il path, possiamo specificare as e un nuovo nome locale, o alias, per il type. Il Listato 7-16 mostra un altro modo di scrivere il codice del Listato 7-15 rinominando uno dei due type Result con as.

use std::fmt::Result;
use std::io::Result as IoResult;

fn funzione1() -> Result {
    // --taglio--
    Ok(())
}

fn funzione2() -> IoResult<()> {
    // --taglio--
    Ok(())
}

Nella seconda dichiarazione use, abbiamo scelto il nuovo alias IoResult per il type std::io::Result, che non entrerà in conflitto con il Result di std::fmt che abbiamo anch’esso portato nello scope. Sia il Listato 7-15 che il Listato 7-16 sono considerati idiomatici, quindi la scelta spetta a te!

Riesportare Nomi con pub use

Quando portiamo un nome nello scope con la parola chiave use, il nome è privato allo scope in cui lo abbiamo importato. Per consentire al codice esterno a quello scope di riferirsi a quel nome come se fosse stato definito in quello scope, possiamo combinare pub e use. Questa tecnica si chiama riesportare (re-exporting) perché portiamo un elemento nello scope ma lo rendiamo anche disponibile affinché altri possano portarlo nel loro scope.

Il Listato 7-17 mostra il codice del Listato 7-11 con use nella radice del modulo cambiato in pub use.

mod sala {
    pub mod accoglienza {
        pub fn aggiungi_in_lista() {}
    }
}

pub use crate::sala::accoglienza;

pub fn mangiare_al_ristorante() {
    accoglienza::aggiungi_in_lista();
}

Prima di questa modifica, il codice esterno avrebbe dovuto chiamare la funzione aggiungi_in_lista usando il path ristorante::sala::accoglienza::aggiungi_in_lista(), che avrebbe inoltre richiesto che il modulo sala fosse marcato come pub. Ora che questo pub use ha riesportato il modulo accoglienza dalla radice del modulo, il codice esterno può invece usare il path ristorante::accoglienza::aggiungi_in_lista().

La riesportazione è utile quando la struttura interna del tuo codice è diversa da come i programmatori che chiamano il tuo codice penserebbero al dominio. Per esempio, in questa metafora del ristorante, chi gestisce il ristorante pensa in termini di “sala” e “cucine”. Ma i clienti che visitano un ristorante probabilmente non penseranno alle parti del ristorante in questi termini. Con pub use, possiamo scrivere il nostro codice con una struttura e però esporre una struttura diversa. Ciò rende la nostra libreria ben organizzata sia per i programmatori che lavorano sulla libreria sia per i programmatori che la usano. Vedremo un altro esempio di pub use e di come influisce sulla documentazione del crate in “Esportare un API Pubblica Efficace” nel Capitolo 14.

Usare Pacchetti Esterni

Nel Capitolo 2, abbiamo programmato un progetto del gioco degli indovinelli che usava un pacchetto esterno chiamato rand per ottenere numeri casuali. Per usare rand nel nostro progetto, abbiamo aggiunto questa riga a Cargo.toml:

rand = "0.8.5"

Aggiungere rand come dipendenza in Cargo.toml dice a Cargo di scaricare il pacchetto rand e le sue dipendenze da crates.io e di rendere rand disponibile al nostro progetto.

Poi, per portare le definizioni di rand nello scope del nostro pacchetto, abbiamo aggiunto una riga use che cominciava con il nome del crate, rand, e elencava gli elementi che volevamo portare nello scope. Ricorda che in “Generare un Numero Casuale” nel Capitolo 2, abbiamo portato il trait Rng nello scope e chiamato la funzione rand::thread_rng:

use std::io;

use rand::Rng;

fn main() {
    println!("Indovina il numero!");

    let numero_segreto = rand::thread_rng().gen_range(1..=100);

    println!("Il numero segreto è: {numero_segreto}");

    println!("Inserisci la tua ipotesi.");

    let mut ipotesi = String::new();

    io::stdin()
        .read_line(&mut ipotesi)
        .expect("Errore di lettura");

    println!("Hai ipotizzato: {ipotesi}");
}

Membri della community Rust hanno reso molti pacchetti disponibili su crates.io, e includere uno di essi nel tuo pacchetto implica gli stessi passi: elencarlo nel file Cargo.toml del tuo pacchetto e usare use per portare elementi dai loro crate nello scope.

Nota che la libreria standard std è anch’essa un crate esterno al nostro pacchetto. Poiché la libreria standard è distribuita con il linguaggio Rust, non dobbiamo modificare Cargo.toml per includere std. Ma dobbiamo comunque riferirci ad essa con use per portare elementi da lì nello scope del nostro pacchetto. Per esempio, per HashMap useremmo questa riga:

#![allow(unused)]
fn main() {
use std::collections::HashMap;
}

Questo è un path assoluto che inizia con std, il nome del crate della libreria standard.

Usare Percorsi Nidificati per Accorpare Elenchi di use

Se usiamo più elementi definiti nello stesso crate o nello stesso modulo, elencare ogni elemento su una sua riga può occupare molto spazio verticale nei file. Per esempio, queste due dichiarazioni use che avevamo nel gioco degli indovinelli nel Listato 2-4 portano elementi da std nello scope:

use rand::Rng;
// --taglio--
use std::cmp::Ordering;
use std::io;
// --taglio--

fn main() {
    println!("Indovina il numero!");

    let numero_segreto = rand::thread_rng().gen_range(1..=100);

    println!("Il numero segreto è: {numero_segreto}");

    println!("Inserisci la tua ipotesi.");

    let mut ipotesi = String::new();

    io::stdin()
        .read_line(&mut ipotesi)
        .expect("Errore di lettura");

    println!("Hai ipotizzato: {ipotesi}");

    match ipotesi.cmp(&numero_segreto) {
        Ordering::Less => println!("Troppo piccolo!"),
        Ordering::Greater => println!("Troppo grande!"),
        Ordering::Equal => println!("Hai indovinato!"),
    }
}

Invece, possiamo usare path nidificati per portare gli stessi elementi nello scope in una sola riga. Lo facciamo specificando la parte comune del path, seguita da due due punti, e poi parentesi graffe intorno a una lista delle parti che differiscono dei path, come mostrato nel Listato 7-18.

use rand::Rng;
// --taglio--
use std::{cmp::Ordering, io};
// --taglio--

fn main() {
    println!("Indovina il numero!");

    let numero_segreto = rand::thread_rng().gen_range(1..=100);

    println!("Il numero segreto è: {numero_segreto}");

    println!("Inserisci la tua ipotesi.");

    let mut ipotesi = String::new();

    io::stdin()
        .read_line(&mut ipotesi)
        .expect("Errore di lettura");

    let ipotesi: u32 = ipotesi.trim().parse().expect("Inserisci un numero!");

    println!("Hai ipotizzato: {ipotesi}");

    match ipotesi.cmp(&numero_segreto) {
        Ordering::Less => println!("Troppo piccolo!"),
        Ordering::Greater => println!("Troppo grande!"),
        Ordering::Equal => println!("Hai indovinato!"),
    }
}

Nei programmi più grandi, portare molti elementi nello scope dallo stesso crate o modulo usando path nidificati può ridurre di molto il numero di dichiarazioni use separate necessarie!

Possiamo usare un path nidificato a qualsiasi livello in un path, il che è utile quando si combinano due dichiarazioni use che condividono una parte di path. Per esempio, il Listato 7-19 mostra due dichiarazioni use: una che porta std::io nello scope e una che porta std::io::Write nello scope.

use std::io;
use std::io::Write;

La parte comune di questi due path è std::io, ed è il path completo della prima path. Per unire questi due path in una sola dichiarazione use, possiamo usare self nel path nidificato, come mostrato nel Listato 7-20.

use std::io::{self, Write};

Questa riga porta std::io e std::io::Write nello scope.

Importare Elementi con l’Operatore Glob

Se vogliamo portare tutti gli elementi pubblici definiti in un path nello scope, possiamo specificare quel path seguito dall’operatore glob *:

#![allow(unused)]
fn main() {
use std::collections::*;
}

Questa dichiarazione use porta tutti gli elementi pubblici definiti in std::collections nello scope corrente. Stai attento quando usi l’operatore glob! Il glob può rendere più difficile capire quali nomi sono nello scope e da dove proviene un nome usato nel tuo programma. Inoltre, se la dipendenza cambia le sue definizioni, ciò che hai importato cambia a sua volta, il che può portare a errori del compilatore quando aggiorni la dipendenza se la dipendenza aggiunge una definizione con lo stesso nome di una tua definizione nello stesso scope, per esempio.

L’operatore glob viene spesso usato durante i test per portare tutto ciò che è sotto test nel modulo tests; parleremo di questo in “Come Scrivere dei Test” nel Capitolo 11. L’operatore glob è anche a volte usato come parte del pattern prelude: vedi la documentazione della libreria standard per ulteriori informazioni su quel pattern.

Separare i Moduli in File Diversi

Finora tutti gli esempi di questo capitolo definivano più moduli in un unico file. Quando i moduli diventano grandi, potresti voler spostare le loro definizioni in file separati per rendere il codice più facile da navigare.

Per esempio, partiamo dal codice nel Listato 7-17 che aveva più moduli del ristorante. Metteremo ogni modulo in un file invece di avere tutte le definizioni nella radice del crate. In questo caso, il file radice del crate è src/lib.rs, ma questa procedura funziona anche con crate binari il cui file radice è src/main.rs.

Per prima cosa spostiamo il modulo sala in un proprio file. Rimuovi il codice dentro le parentesi graffe del modulo sala, lasciando solo la dichiarazione mod sala;, così che src/lib.rs contenga il codice mostrato nel Listato 7-21. Nota che questo non compilerà finché non creiamo il file src/sala.rs mostrato nel Listato 7-22.

mod sala;

pub use crate::sala::accoglienza;

pub fn mangiare_al_ristorante() {
    accoglienza::aggiungi_in_lista();
}

Ora, metti il codice che era dentro le parentesi graffe in un nuovo file chiamato src/sala.rs, come mostrato nel Listato 7-22. Il compilatore sa di dover cercare in questo file perché ha incontrato la dichiarazione del modulo nella radice del crate con il nome sala.

pub mod accoglienza {
    pub fn aggiungi_in_lista() {}
}

Nota che è necessario caricare un file usando una dichiarazione mod una sola volta nell’albero dei moduli. Una volta che il compilatore sa che il file fa parte del progetto (e sa dove si trova nell’albero dei moduli grazie a dove hai messo la dichiarazione mod), gli altri file del progetto dovrebbero riferirsi al codice del file caricato usando un path verso il punto in cui è stato dichiarato, come trattato nella sezione “Percorsi per fare riferimento a un elemento nell’albero dei moduli”. In altre parole, mod non è un’operazione di “include” come potresti aver visto in altri linguaggi.

Successivamente, sposteremo il modulo accoglienza in un suo file. Il processo è un po’ diverso perché accoglienza è un modulo figlio di sala, non della radice. Metteremo il file per accoglienza in una nuova cartella che sarà chiamata come i suoi antenati nell’albero dei moduli, in questo caso src/sala.

Per iniziare a spostare accoglienza, cambiamo src/sala.rs in modo che contenga solo la dichiarazione del modulo accoglienza:

pub mod accoglienza;

Poi creiamo una cartella src/sala e un file accoglienza.rs per contenere le definizioni del modulo accoglienza:

pub fn aggiungi_in_lista() {}

Se invece mettessimo accoglienza.rs nella cartella src, il compilatore si aspetterebbe che il codice di accoglienza.rs sia in un modulo accoglienza dichiarato nella radice del crate, e non come figlio del modulo sala. Le regole del compilatore su quali file cercare per il codice di quali moduli fanno sì che cartelle e file rispecchino più da vicino l’albero dei moduli.

Abbiamo spostato il codice di ogni modulo in file separati e l’albero dei moduli rimane lo stesso. Le chiamate di funzione in mangiare_al_ristorante funzioneranno senza alcuna modifica, anche se le definizioni vivono in file diversi. Questa tecnica ti permette di muovere i moduli in nuovi file man mano che crescono di dimensione.

Nota che la dichiarazione pub use crate::sala::accoglienza in src/lib.rs non è cambiata, né use ha alcun impatto su quali file vengono compilati come parte del crate. La parola chiave mod dichiara moduli, e Rust cerca in un file con lo stesso nome del modulo il codice che va in quel modulo.

Riepilogo

Rust ti permette di dividere un pacchetto in più crate e un crate in moduli così da poter riferire elementi definiti in un modulo da un altro modulo. Puoi farlo specificando path assoluti o relativi. Questi path possono essere portati nello scope con una dichiarazione use così da poter usare un path più corto per usi ripetuti dell’elemento in quello scope. Il codice dei moduli è privato per default, ma puoi rendere le definizioni pubbliche aggiungendo la parola chiave pub.

Nel prossimo capitolo vedremo alcune strutture dati di collezione nella libreria standard che puoi usare per rendere ancor più ordinato il tuo codice.

Collezioni Comuni

La libreria standard di Rust include diverse strutture dati molto utili chiamate collezioni (collections). La maggior parte degli altri type rappresenta un valore specifico, ma le collezioni possono contenere più valori. A differenza di array e tuple, i dati a cui puntano queste collezioni vengono memorizzati nell’heap, il che significa che la quantità di dati non deve essere nota in fase di compilazione e può aumentare o diminuire durante l’esecuzione del programma. Ogni tipo di collezione ha funzionalità e costi diversi, e sceglierne una appropriata per le necessità del momento è un’abilità che si svilupperà nel tempo. In questo capitolo, parleremo di tre collezioni utilizzate molto spesso nei programmi Rust:

• Un vector che consente di memorizzare un numero variabile di valori uno accanto all’altro.
• Una string è una raccolta di caratteri. Abbiamo menzionato il type String in precedenza, ma in questo capitolo ne parleremo in modo approfondito.
• Una hash map che consente di associare un valore a una chiave specifica. Si tratta di una particolare implementazione della struttura dati più generale chiamata map.

Per saperne di più sugli altri tipi di collezioni fornite dalla libreria standard, vedere la documentazione.

Parleremo di come creare e aggiornare vector, string e hash map, nonché cosa rende ciascuna di esse speciale.

Memorizzare Elenchi di Valori con Vettori

Il primo tipo di collezione che esamineremo è Vec<T>, nota anche come vector. I vettori consentono di memorizzare più di un valore in un’unica struttura dati che mette tutti i valori uno accanto all’altro in memoria. I vettori possono memorizzare solo valori dello stesso type. Sono utili quando si ha un elenco di elementi, come le righe di testo in un file o i prezzi degli articoli in un carrello.

Creare un Nuovo Vettore

Per creare un nuovo vettore vuoto, chiamiamo la funzione Vec::new, come mostrato nel Listato 8-1.

fn main() {
    let v: Vec<i32> = Vec::new();
}

Nota che qui abbiamo aggiunto un’annotazione di type. Poiché non stiamo inserendo alcun valore in questo vettore, Rust non sa che tipo di elementi intendiamo memorizzare. Questo è un punto importante. I vettori vengono implementati utilizzando i type generici; spiegheremo come utilizzare i type generici quando si creano type propri nel Capitolo 10. Per ora, sappiamo che il type Vec<T> fornito dalla libreria standard può contenere qualsiasi type. Quando creiamo un vettore per contenere uno specifico type, possiamo specificarlo tra parentesi angolari. Nel Listato 8-1, abbiamo detto a Rust che Vec<T> in v conterrà elementi di type i32.

Più spesso, si crea un Vec<T> con valori iniziali e Rust dedurrà il type dai valori che si desidera memorizzare, quindi raramente è necessario eseguire questa annotazione di type. Rust fornisce opportunamente la macro vec!, che creerà un nuovo vettore contenente i valori che gli vengono assegnati. Il Listato 8-2 crea un nuovo Vec<i32> che contiene i valori 1, 2 e 3. Il type intero è i32 perché è il type intero predefinito, come discusso nella sezione “Tipi di Dato” del Capitolo 3.

fn main() {
    let v = vec![1, 2, 3];
}

Poiché abbiamo assegnato valori iniziali i32, Rust può dedurre che il type di v è Vec<i32> e l’annotazione di type non è necessaria. Successivamente, vedremo come modificare un vettore.

Aggiornare un Vettore

Per creare un vettore e aggiungervi elementi, possiamo usare il metodo push, come mostrato nel Listato 8-3.

fn main() {
    let mut v = Vec::new();

    v.push(5);
    v.push(6);
    v.push(7);
    v.push(8);
}

Come per qualsiasi variabile, se vogliamo poterne modificare il valore, dobbiamo renderla mutabile usando la parola chiave mut, come discusso nel Capitolo 3. I numeri che inseriamo al suo interno sono tutti di type i32, e Rust lo deduce dai dati, quindi non abbiamo bisogno dell’annotazione Vec<i32>.

Leggere Elementi dei Vettori

Esistono due modi per fare riferimento a un valore memorizzato in un vettore: tramite indicizzazione o utilizzando il metodo get. Negli esempi seguenti, abbiamo annotato i type dei valori restituiti da queste funzioni per maggiore chiarezza.

Il Listato 8-4 mostra entrambi i metodi per accedere a un valore in un vettore, con la sintassi di indicizzazione e il metodo get.

fn main() {
    let v = vec![1, 2, 3, 4, 5];

    let terzo: &i32 = &v[2];
    println!("Il terzo elemento è {terzo}");

    let terzo: Option<&i32> = v.get(2);
    match terzo {
        Some(terzo) => println!("Il terzo elemento è {terzo}"),
        None => println!("Non c'è un terzo elemento."),
    }
}

Sono da notare alcuni dettagli. Utilizziamo il valore di indice 2 per ottenere il terzo elemento poiché i vettori sono indicizzati per numero, a partire da zero. Utilizzando & e [] otteniamo un reference all’elemento a quell’indice. Quando utilizziamo il metodo get con l’indice passato come argomento, otteniamo un Option<&T> che possiamo utilizzare con match.

Rust fornisce questi due modi per ottenere un reference ad un elemento, in modo da poter scegliere come il programma si comporta quando si tenta di utilizzare un valore di indice al di fuori dell’intervallo di elementi esistenti. Ad esempio, vediamo cosa succede quando abbiamo un vettore di cinque elementi e poi proviamo ad accedere a un elemento all’indice 100 con ciascuna tecnica, come mostrato nel Listato 8-5.

fn main() {
    let v = vec![1, 2, 3, 4, 5];

    let non_esiste = &v[100];
    let non_esiste = v.get(100);
}

Quando eseguiamo questo codice, il primo metodo [] causerà un crash del programma perché fa riferimento ad un elemento inesistente. Questo metodo è ideale quando si desidera che il programma si blocchi in caso di tentativo di accesso a un elemento oltre la fine del vettore.

Quando al metodo get viene passato un indice esterno al vettore, restituisce None senza crash. Si consiglia di utilizzare questo metodo se l’accesso a un elemento oltre l’intervallo del vettore può verificarsi occasionalmente in circostanze normali. Il codice avrà quindi una logica per gestire sia Some(&element) che None, come discusso nel Capitolo 6. Ad esempio, l’indice potrebbe provenire da un utente che inserisce un numero. Se inserisce accidentalmente un numero troppo grande e il programma ottiene un valore None, è possibile indicare all’utente quanti elementi sono presenti nel vettore corrente e dargli un’altra possibilità di inserire un valore valido. Sarebbe più intuitivo che mandare in crash il programma a causa di un errore di battitura!

Quando il programma ha un reference valido, il sistema applica le regole di ownership e borrowing (trattate nel Capitolo 4) per garantire che questo reference e qualsiasi altro reference al contenuto del vettore rimangano validi. Ricordati la regola che stabilisce che non è possibile avere reference mutabili e immutabili nello stesso scope. Questa regola si applica al Listato 8-6, dove manteniamo un reference immutabile al primo elemento di un vettore e proviamo ad aggiungere un elemento alla fine. Questo programma non funzionerà se proviamo a fare reference a quell’elemento anche più avanti nella funzione.

fn main() {
    let mut v = vec![1, 2, 3, 4, 5];

    let primo = &v[0];

    v.push(6);

    println!("Il primo elemento è: {primo}");
}

La compilazione di questo codice genererà questo errore:

$ cargo run
   Compiling collections v0.1.0 (file:///progetti/collections)
error[E0502]: cannot borrow `v` as mutable because it is also borrowed as immutable
 --> src/main.rs:7:5
  |
5 |     let primo = &v[0];
  |                  - immutable borrow occurs here
6 |
7 |     v.push(6);
  |     ^^^^^^^^^ mutable borrow occurs here
8 |
9 |     println!("Il primo elemento è: {primo}");
  |                                     ----- immutable borrow later used here

For more information about this error, try `rustc --explain E0502`.
error: could not compile `collections` (bin "collections") due to 1 previous error

Il codice nel Listato 8-6 potrebbe sembrare funzionante: perché un reference al primo elemento dovrebbe preoccuparsi delle modifiche alla fine del vettore? Questo errore è dovuto al funzionamento dei vettori: poiché i vettori posizionano i valori uno accanto all’altro in memoria, se non c’è abbastanza spazio per posizionare tutti gli elementi uno accanto all’altro dove il vettore è attualmente memorizzato l’aggiunta di un nuovo elemento alla fine del vettore potrebbe richiedere l’allocazione di nuova memoria e la copia dei vecchi elementi nel nuovo spazio. In tal caso, il reference al primo elemento punterebbe alla memoria de-allocata. Le regole di borrowing impediscono ai programmi di finire in questa situazione.

Nota: per maggiori dettagli sull’implementazione del type Vec<T>, vedere “Il Rustonomicon”.

Iterare sui Valori di un Vettore

Per accedere a ogni elemento di un vettore a turno, dovremmo iterare su tutti gli elementi anziché utilizzare gli indici per accedervi uno alla volta. Il Listato 8-7 mostra come utilizzare un ciclo for per ottenere reference immutabili a ciascun elemento in un vettore di valori i32 e stamparli.

fn main() {
    let v = vec![100, 32, 57];
    for i in &v {
        println!("{i}");
    }
}

Possiamo anche iterare su reference mutabili a ciascun elemento in un vettore mutabile per apportare modifiche a tutti gli elementi. Il ciclo for nel Listato 8-8 aggiungerà 50 a ciascun elemento.

fn main() {
    let mut v = vec![100, 32, 57];
    for i in &mut v {
        *i += 50;
    }
}

Per modificare il valore a cui punta il reference mutabile, dobbiamo usare l’operatore di de-referenziazione * per arrivare al valore in i prima di poter usare l’operatore +=. Approfondiremo l’operatore di de-referenziazione nella sezione “Seguire il Reference al Valore” del Capitolo 15.

L’iterazione su un vettore, sia immutabile che mutabile, è sicura grazie alle regole di ownership e borrowing. Se tentassimo di inserire o rimuovere elementi nei corpi del ciclo for nei Listati 8-7 e 8-8, otterremmo un errore del compilatore simile a quello ottenuto con il codice nel Listato 8-6. Il reference al vettore contenuto nel ciclo for impedisce la modifica simultanea dell’intero vettore.

Utilizzare un’Enum per Memorizzare Più Type

I vettori possono memorizzare solo valori dello stesso type. Questo può essere scomodo; ci sono sicuramente casi d’uso in cui è necessario memorizzare un elenco di elementi di type diverso. Fortunatamente, le varianti di un’enum sono definite sotto lo stesso type di enum, quindi quando abbiamo bisogno di un type per rappresentare elementi di tipi diversi, possiamo definire e utilizzare un’enum!

Ad esempio, supponiamo di voler ottenere valori da una riga di un foglio di calcolo in cui alcune colonne della riga contengono numeri interi, alcuni numeri in virgola mobile e alcune stringhe. Possiamo definire un’enum le cui varianti conterranno i diversi tipi di valore, e tutte le varianti dell’enum saranno considerate dello stesso type: quello dell’enum. Possiamo adesso creare un vettore per contenere quell’enum e quindi, in definitiva, contenere type “diversi”. Lo abbiamo dimostrato nel Listato 8-9.

fn main() {
    enum CellaFoglioDiCalcolo {
        Int(i32),
        Float(f64),
        Text(String),
    }

    let row = vec![
        CellaFoglioDiCalcolo::Int(3),
        CellaFoglioDiCalcolo::Text(String::from("blu")),
        CellaFoglioDiCalcolo::Float(10.12),
    ];
}

Rust deve sapere quali type saranno presenti nel vettore in fase di compilazione, in modo da sapere esattamente quanta memoria nell’heap sarà necessaria per memorizzare ogni elemento. Dobbiamo anche essere espliciti sui type consentiti in questo vettore. Se Rust permettesse a un vettore di contenere qualsiasi type, ci sarebbe la possibilità che uno o più type causino errori nelle operazioni eseguite sugli elementi del vettore. L’utilizzo di un’enum assieme ad un’espressione match significa che Rust garantirà in fase di compilazione che ogni possibile caso venga gestito, come discusso nel Capitolo 6.

Se non si conosce l’insieme esaustivo di type che un programma avrà una volta in esecuzione da memorizzare in un vettore, la tecnica dell’enum non funzionerà. In alternativa, è possibile utilizzare un oggetto trait, che tratteremo nel Capitolo 18.

Ora che abbiamo discusso alcuni dei modi più comuni per utilizzare i vettori, assicurati di consultare la documentazione dell’API per tutti i numerosi metodi utili definiti su Vec<T> dalla libreria standard. Ad esempio, oltre a push, un metodo pop rimuove e restituisce l’ultimo elemento.

Eliminare un Vettore Elimina i Suoi Elementi

Come qualsiasi altra struct, un vettore viene rilasciato quando esce dallo scope, come annotato nel Listato 8-10.

fn main() {
    {
        let v = vec![1, 2, 3, 4];

        // esegui operazioni su `v`
    } // <- qui `v` esce dallo scope e la memoria viene liberata
}

Quando il vettore viene rilasciato, anche tutto il suo contenuto viene de-allocato, il che significa che gli interi in esso contenuti verranno de-allocati. Il borrow checker (controllo dei prestiti) garantisce che qualsiasi reference al contenuto di un vettore venga utilizzato solo finché il vettore stesso è valido.

Passiamo al tipo di collezione successivo: String!

Memorizzare Testo Codificato UTF-8 con Stringhe

Abbiamo parlato delle stringhe nel Capitolo 4, ma ora le analizzeremo più approfonditamente. I nuovi Rustacean spesso si bloccano sulle stringhe per una combinazione di tre ragioni: la propensione di Rust a esporre possibili errori, il fatto che le stringhe siano una struttura dati più complicata di quanto molti programmatori credano e la codifica UTF-8. Questi fattori si combinano in un modo che può sembrare difficile per chi proviene da altri linguaggi di programmazione.

Parleremo delle stringhe nel contesto delle collezioni perché le stringhe sono implementate come una collezione di byte, oltre ad alcuni metodi per fornire funzionalità utili quando tali byte vengono interpretati come testo. In questa sezione, parleremo delle operazioni su String che ogni tipo di collezione prevede, come creazione, aggiornamento e lettura. Discuteremo anche le differenze tra String e le altre collezioni, in particolare come l’indicizzazione in una String sia complicata dalle differenze tra il modo in cui le persone e i computer interpretano i dati String.

Definire le Stringhe

Definiremo innanzitutto cosa intendiamo con il termine stringa. Rust ha un solo type di stringa nel linguaggio principale, ovvero la slice di stringa str che viene principalmente utilizzata come reference &str. Nel Capitolo 4 abbiamo parlato delle slice di stringa, che sono reference ad alcuni dati stringa codificati in UTF-8 memorizzati altrove. I letterali stringa, ad esempio, sono memorizzati nel binario del programma e sono quindi slice di stringa.

Il type String, fornito dalla libreria standard di Rust anziché esser definito nel linguaggio principale, è un type di stringa codificato in UTF-8, con ownership, espandibile e modificabile. Quando i Rustacean fanno riferimento alle “stringhe” in Rust, potrebbero riferirsi sia al type String che alla slice di stringa &str, e non solo a uno di questi type. Sebbene questa sezione tratterà principalmente String, entrambe le tipologie sono ampiamente utilizzate nella libreria standard di Rust, e sia String che le slice sono codificate in UTF-8.

Creare una Nuova String

Molte delle operazioni disponibili con Vec<T> sono disponibili anche con String perché String è in realtà implementata come wrapper (involucro) attorno a un vettore di byte con alcune garanzie, restrizioni e funzionalità aggiuntive. Ad esempio, la funzione new per creare un’istanza, funziona allo stesso modo sia con Vec<T> che con String. Eccola mostrata nel Listato 8-11.

fn main() {
    let mut s = String::new();
}

Questa riga crea una nuova stringa vuota chiamata s, in cui possiamo quindi caricare i dati. Spesso, avremo dei dati iniziali con cui vogliamo inizializzare la stringa. Per questo, utilizziamo il metodo to_string, disponibile su qualsiasi type che implementi il trait Display, come fanno i letterali stringa. Il Listato 8-12 mostra due esempi.

fn main() {
    let data = "contenuto iniziale";

    let s = data.to_string();

    // Il metodo funziona anche direttamente sul letterale:
    let s = "contenuto iniziale".to_string();
}

Questo codice crea una stringa contenente contenuto iniziale.

Possiamo anche utilizzare la funzione String::from per creare una String da un letterale stringa. Il codice nel Listato 8-13 è equivalente al codice nel Listato 8-12 che utilizza to_string.

fn main() {
    let s = String::from("contenuto iniziale");
}

Poiché le stringhe vengono utilizzate per così tante cose, possiamo utilizzare diverse API generiche per le stringhe, offrendoci numerose opzioni. Alcune possono sembrare ridondanti, ma hanno tutte la loro importanza! In questo caso, String::from e to_string svolgono la stessa funzione, quindi la scelta è una questione di stile e leggibilità.

Ricorda che le stringhe sono codificate in UTF-8, quindi possiamo includere qualsiasi dato codificato correttamente, come mostrato nel Listato 8-14.

fn main() {
    let saluto = String::from("السلام عليكم");
    let saluto = String::from("Dobrý den");
    let saluto = String::from("Hello");
    let saluto = String::from("שלום");
    let saluto = String::from("नमस्ते");
    let saluto = String::from("こんにちは");
    let saluto = String::from("안녕하세요");
    let saluto = String::from("你好");
    let saluto = String::from("Olá");
    let saluto = String::from("Здравствуйте");
    let saluto = String::from("Hola");
}

Tutti questi sono valori String validi.

Aggiornare una String

Una String può crescere di dimensione e il suo contenuto può cambiare, proprio come il contenuto di un Vec<T>, se vi si inseriscono più dati. Inoltre, è possibile utilizzare comodamente l’operatore + o la macro format! per concatenare valori String.

Aggiungere con push_str e push

Possiamo far crescere una String utilizzando il metodo push_str per aggiungere una slice di stringa, come mostrato nel Listato 8-15.

fn main() {
    let mut s = String::from("foo");
    s.push_str("bar");
}

Dopo queste due righe, s conterrà foobar. Il metodo push_str accetta una slice di stringa perché non vogliamo necessariamente prendere ownership del parametro. Ad esempio, nel codice del Listato 8-16, vogliamo poter utilizzare s2 dopo averne aggiunto il contenuto a s1.

fn main() {
    let mut s1 = String::from("foo");
    let s2 = "bar";
    s1.push_str(s2);
    println!("s2 è {s2}");
}

Se il metodo push_str prendesse ownership di s2, non saremmo in grado di stamparne il valore sull’ultima riga. Tuttavia, questo codice funziona come previsto!

Il metodo push prende un singolo carattere come parametro e lo aggiunge alla String. Il Listato 8-17 aggiunge la lettera l a una String utilizzando il metodo push.

fn main() {
    let mut s = String::from("lo");
    s.push('l');
}

Di conseguenza, s conterrà lol.

Concatenare con + o format!

Spesso, si desidera combinare due stringhe esistenti. Un modo per farlo è utilizzare l’operatore +, come mostrato nel Listato 8-18.

fn main() {
    let s1 = String::from("Hello, ");
    let s2 = String::from("world!");
    let s3 = s1 + &s2; // nota che s1 è stato spostato qui e non può più essere utilizzato
}

La stringa s3 conterrà Hello, world!. Il motivo per cui s1 non è più valido dopo l’aggiunta, e il motivo per cui abbiamo utilizzato un reference a s2, ha a che fare con la firma del metodo chiamato quando utilizziamo l’operatore +. L’operatore + utilizza il metodo add, la cui firma è simile a questa:

fn add(self, s: &str) -> String {

Nella libreria standard, add è definito utilizzando type generici e type associati. Qui, abbiamo sostituito type concreti, che è ciò che accade quando chiamiamo questo metodo con valori String. Parleremo dei generici nel Capitolo 10. Questa firma ci fornisce gli indizi necessari per comprendere le parti più complesse dell’operatore +.

Innanzitutto, s2 ha un &, il che significa che stiamo aggiungendo un reference della seconda stringa alla prima stringa. Questo è dovuto al parametro s nella funzione add: possiamo solo aggiungere una slice di stringa a una String; non possiamo aggiungere due valori String insieme. Ma aspetta: il type di &s2 è &String, non &str, come specificato nel secondo parametro di add. Quindi perché il Listato 8-18 si compila?

Il motivo per cui possiamo usare &s2 nella chiamata a add è che il compilatore può costringere l’argomento &String in un &str. Quando chiamiamo il metodo add , Rust usa una deref coercion (de-referenziazione forzata), che qui trasforma &s2 in &s2[..]. Discuteremo la deref coercion più approfonditamente nel Capitolo 15. Poiché add non prende ownership del parametro s, s2 sarà comunque una String valida dopo questa operazione.

In secondo luogo, possiamo vedere nella firma che add prende ownership di self perché self non ha un &. Ciò significa che s1 nel Listato 8-18 verrà spostato nella chiamata add e non sarà più valido da quel momento in poi. Quindi, sebbene let s3 = s1 + &s2; sembri copiare entrambe le stringhe e crearne una nuova, questa istruzione in realtà prende ownership di s1, aggiunge una copia del contenuto di s2 per poi restituire la ownership del risultato. In altre parole, sembra che stia facendo molte copie, ma non è così; l’implementazione è più efficiente della semplice copia.

Se dobbiamo concatenare più stringhe, il comportamento dell’operatore + diventa poco pratico:

fn main() {
    let s1 = String::from("uno");
    let s2 = String::from("due");
    let s3 = String::from("tre");

    let s = s1 + "-" + &s2 + "-" + &s3;
}

A questo punto, s diventerà uno-due-tre. Con tutti i caratteri + e ", è difficile capire cosa sta succedendo. Per combinare stringhe in modi più complessi, possiamo invece usare la macro format!:

fn main() {
    let s1 = String::from("uno");
    let s2 = String::from("due");
    let s3 = String::from("tre");

    let s = format!("{s1}-{s2}-{s3}");
}

Anche questo codice risulterà in s che contiene uno-due-tre. La macro format! funziona come println!, ma invece di visualizzare l’output sullo schermo, restituisce una String con il contenuto. La versione del codice che utilizza format! è molto più facile da leggere e il codice generato dalla macro format! utilizza reference in modo che questa chiamata non assuma ownership di nessuno dei suoi parametri.

Indicizzazione in String

In molti altri linguaggi di programmazione, l’accesso a singoli caratteri in una stringa facendovi riferimento tramite indice è un’operazione valida e comune. Tuttavia, se si tenta di accedere a parti di una String utilizzando la sintassi di indicizzazione in Rust, si otterrà un errore. Considera il codice non valido nel Listato 8-19.

fn main() {
    let s1 = String::from("hi");
    let h = s1[0];
}

Questo codice genererà il seguente errore:

$ cargo run
   Compiling collections v0.1.0 (file:///progetti/collections)
error[E0277]: the type `str` cannot be indexed by `{integer}`
 --> src/main.rs:3:16
  |
3 |     let h = s1[0];
  |                ^ string indices are ranges of `usize`
  |
  = note: you can use `.chars().nth()` or `.bytes().nth()`
          for more information, see chapter 8 in The Book: <https://doc.rust-lang.org/book/ch08-02-strings.html#indexing-into-strings>
  = help: the trait `SliceIndex<str>` is not implemented for `{integer}`
          but trait `SliceIndex<[_]>` is implemented for `usize`
  = help: for that trait implementation, expected `[_]`, found `str`
  = note: required for `String` to implement `Index<{integer}>`

For more information about this error, try `rustc --explain E0277`.
error: could not compile `collections` (bin "collections") due to 1 previous error

L’errore spiega la situazione: le stringhe Rust non supportano l’indicizzazione. Ma perché no? Per rispondere a questa domanda, dobbiamo discutere come Rust memorizza le stringhe in memoria.

Rappresentazione Interna

Una String è un wrapper di un Vec<u8>. Diamo un’occhiata ad alcune delle nostre stringhe di esempio correttamente codificate UTF-8 dal Listato 8-14. Innanzitutto, questo:

fn main() {
    let saluto = String::from("السلام عليكم");
    let saluto = String::from("Dobrý den");
    let saluto = String::from("Hello");
    let saluto = String::from("שלום");
    let saluto = String::from("नमस्ते");
    let saluto = String::from("こんにちは");
    let saluto = String::from("안녕하세요");
    let saluto = String::from("你好");
    let saluto = String::from("Olá");
    let saluto = String::from("Здравствуйте");
    let saluto = String::from("Hola");
}

In questo caso, len sarà 4, il che significa che il vettore che memorizza la stringa "Hola" è lungo 4 byte. Ognuna di queste lettere occupa 1 byte se codificata in UTF-8. La riga seguente, tuttavia, potrebbe sorprendervi (nota che questa stringa inizia con la lettera maiuscola cirillica Ze, non con il numero 3):

fn main() {
    let saluto = String::from("السلام عليكم");
    let saluto = String::from("Dobrý den");
    let saluto = String::from("Hello");
    let saluto = String::from("שלום");
    let saluto = String::from("नमस्ते");
    let saluto = String::from("こんにちは");
    let saluto = String::from("안녕하세요");
    let saluto = String::from("你好");
    let saluto = String::from("Olá");
    let saluto = String::from("Здравствуйте");
    let saluto = String::from("Hola");
}

Se vi chiedessero quanto è lunga la stringa, potreste dire 12. In realtà, la risposta di Rust è 24: questo è il numero di byte necessari per codificare “Здравствуйте” in UTF-8, perché ogni valore scalare Unicode in quella stringa occupa 2 byte di spazio. Pertanto, un indice nei byte della stringa non sarà sempre correlato a un valore scalare Unicode valido. Per dimostrarlo, consideriamo questo codice Rust non valido:

let saluto = "Здравствуйте";
let risposta = &hello[0];

Sapete già che risposta non sarà З, la prima lettera. Quando codificato in UTF-8, il primo byte di З è 208 e il secondo è 151, quindi sembrerebbe che risposta dovrebbe in effetti essere 208, ma 208 non è un carattere valido da solo. Restituire 208 probabilmente non è ciò che un utente vorrebbe se chiedesse la prima lettera di questa stringa; Tuttavia, questo è l’unico dato che Rust ha all’indice di byte 0. Gli utenti generalmente non vogliono che venga restituito il valore in byte, anche se la stringa contiene solo lettere latine: se &"hi"[0] fosse codice valido che restituisce il valore in byte, restituirebbe 104, non h.

La risposta, quindi, è che per evitare di restituire un valore inaspettato e causare bug che potrebbero non essere scoperti immediatamente, Rust non compila affatto questo codice e previene malintesi fin dalle prime fasi del processo di sviluppo.

Byte, Valori Scalari e Cluster di Grafemi!

Un altro punto su UTF-8 è che in realtà ci sono tre modi rilevanti per vedere le stringhe dalla prospettiva di Rust: come byte, valori scalari e cluster di grafemi (la cosa più vicina a ciò che chiameremmo lettere).

Se consideriamo la parola hindi “नमस्ते” scritta in alfabeto Devanagari, essa è memorizzata come un vettore di valori u8 che appare così:

[224, 164, 168, 224, 164, 174, 224, 164, 184, 224, 165, 141, 224, 164, 164,
224, 165, 135]

Sono 18 byte ed è così che i computer memorizzano questi dati. Se li consideriamo come valori scalari Unicode, che corrispondono al type char di Rust, quei byte appaiono così:

['न', 'म', 'स', '्', 'त', 'े']

Ci sono sei valori char qui, ma il quarto e il sesto non sono lettere: sono segni diacritici che da soli non hanno senso. Infine, se li consideriamo come cluster di grafemi, otterremmo ciò che una persona chiamerebbe le quattro lettere che compongono la parola hindi:

["न", "म", "स्", "ते"]

Rust fornisce diversi modi di interpretare i dati stringa grezzi che i computer memorizzano, in modo che ogni programma possa scegliere l’interpretazione di cui ha bisogno, indipendentemente dal linguaggio umano in cui sono espressi i dati.

Un ultimo motivo per cui Rust non ci consente di indicizzare una String per ottenere un carattere è che le operazioni di indicizzazione dovrebbero sempre richiedere un tempo costante (O(1)). Ma non è possibile garantire tali prestazioni con una String, perché Rust dovrebbe esaminare il contenuto dall’inizio fino all’indice per determinare quanti caratteri validi ci sono.

Slicing delle Stringhe

Indicizzare una stringa è spesso una cattiva idea perché non è chiaro quale debba essere il type di ritorno dell’operazione di indicizzazione della stringa: un valore byte, un carattere, un cluster di grafemi o una slice. Se proprio si ha bisogno di usare gli indici per creare slice di stringa, Rust chiede di essere più specifici.

Invece di indicizzare usando [] con un singolo numero, si può usare [] con un intervallo per creare una slice di stringa contenente byte specifici:

#![allow(unused)]
fn main() {
let saluto = "Здравствуйте";

let s = &saluto[0..4];
}

Qui, s sarà un &str che contiene i primi 4 byte della stringa. In precedenza, abbiamo accennato al fatto che ognuno di questi caratteri era composto da due byte, il che significa che s sarà Зд.

Se provassimo a suddividere solo una parte dei byte di un carattere con qualcosa come &saluto[0..1], Rust andrebbe in panic in fase di esecuzione, proprio come se si accedesse a un indice non valido in un vettore:

$ cargo run
   Compiling collections v0.1.0 (file:///progetti/collections)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.52s
     Running `target/debug/collections`

thread 'main' (6240) panicked at src/main.rs:4:20:
byte index 1 is not a char boundary; it is inside 'З' (bytes 0..2) of `Здравствуйте`
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

È necessario prestare attenzione quando si creano slice di stringhe con intervalli, perché ciò potrebbe causare l’arresto anomalo del programma.

Iterare sulle Stringhe

Il modo migliore per operare su stringhe è specificare esplicitamente se si desidera caratteri o byte. Per singoli valori scalari Unicode, utilizzare il metodo chars. Chiamando chars su “Зд” si separano e si restituiscono due valori di type char, ed è possibile iterare sul risultato per accedere a ciascun elemento:

#![allow(unused)]
fn main() {
for c in "Зд".chars() {
    println!("{c}");
}
}

Questo codice stamperà quanto segue:

З
д

In alternativa, il metodo bytes restituisce ogni byte grezzo, che potrebbe essere appropriato per quello che ti serve:

#![allow(unused)]
fn main() {
for b in "Зд".bytes() {
    println!("{b}");
}
}

Questo codice stamperà i 4 byte che compongono questa stringa:

208
151
208
180

Ma ricorda che i valori scalari Unicode validi possono essere composti da più di 1 byte.

Ottenere cluster di grafemi dalle stringhe, come con l’alfabeto Devanagari, è complesso, quindi questa funzionalità non è fornita dalla libreria standard. I crate sono disponibili su crates.io se questa è la funzionalità di cui avete bisogno.

Gestire le Complessità delle Stringhe

In sintesi, le stringhe sono complicate. Diversi linguaggi di programmazione fanno scelte diverse su come presentare questa complessità al programmatore. Rust ha scelto di rendere la corretta gestione dei dati String il comportamento predefinito per tutti i programmi Rust, il che significa che i programmatori devono dedicare da subito maggiore attenzione alla gestione dei dati UTF-8. Questo compromesso rende più evidente la complessità delle stringhe rispetto ad altri linguaggi di programmazione, ma evita di dover gestire errori che coinvolgono caratteri non ASCII in una fase successiva del ciclo di sviluppo.

La buona notizia è che la libreria standard offre numerose funzionalità basate sui type String e &str per aiutare a gestire correttamente queste situazioni complesse. Assicuratevi di consultare la documentazione per metodi utili come contains per la ricerca in una stringa e replace per sostituire parti di una stringa con un’altra stringa.

Passiamo a qualcosa di un po’ meno complesso: le mappe hash!

Memorizzare Chiavi con Valori Associati in Mappe Hash

L’ultima delle nostre collezioni comuni è la mappa hash. Il type HashMap<K, V> memorizza una mappatura di chiavi di type K a valori di type V utilizzando una funzione di hashing, che determina come queste chiavi e valori vengono inseriti in memoria. Molti linguaggi di programmazione supportano questo tipo di struttura dati, ma spesso usano un nome diverso, come hash, map, object, hash table, dictionary o associative array, solo per citarne alcuni.

Le mappe hash (hash map d’ora in poi) sono utili quando si desidera ricercare dati non utilizzando un indice, come è possibile con i vettori, ma utilizzando una chiave che può essere di qualsiasi type. Ad esempio, in una partita, è possibile tenere traccia del punteggio di ogni squadra in una hash map in cui ogni chiave è il nome di una squadra e i valori sono il punteggio di ogni squadra. Dato il nome di una squadra, è possibile recuperarne il punteggio.

In questa sezione esamineremo l’API di base delle hash map, ma molte altre funzionalità si nascondono nelle funzioni definite su HashMap<K, V> dalla libreria standard. Come sempre, consultate la documentazione della libreria standard per ulteriori informazioni.

Creare una Nuova Hash Map

Un modo per creare una hash map vuota è usare new e aggiungere elementi con insert. Nel Listato 8-20, stiamo tenendo traccia del punteggio di due squadre i cui nomi sono Blu e Gialla. La squadra Blu inizia con 10 punti, mentre la squadra Gialla inizia con 50.

fn main() {
    use std::collections::HashMap;

    let mut punteggi = HashMap::new();

    punteggi.insert(String::from("Blu"), 10);
    punteggi.insert(String::from("Gialla"), 50);
}

Nota che dobbiamo prima portare in scope HashMap con use dalla sezione dedicata alle collezioni della libreria standard. Delle nostre tre collezioni comuni, questa è la meno utilizzata, quindi non è inclusa nelle funzionalità aggiunte allo scope dal preludio. Le hash map hanno anche un supporto minore dalla libreria standard; ad esempio, non esiste una macro integrata per costruirle.

Proprio come i vettori, le hash map memorizzano i loro dati nell’heap. Questa HashMap ha chiavi di type String e valori di type i32. Come i vettori, le hash map sono omogenee: tutte le chiavi devono avere lo stesso type e tutti i valori devono avere lo stesso type.

Accedere ai Valori in una Hash Map

Possiamo ottenere un valore dalla hash map fornendo la sua chiave al metodo get, come mostrato nel Listato 8-21.

fn main() {
    use std::collections::HashMap;

    let mut punteggi = HashMap::new();

    punteggi.insert(String::from("Blu"), 10);
    punteggi.insert(String::from("Gialla"), 50);

    let nome_squadra = String::from("Blu");
    let punteggio = punteggi.get(&nome_squadra).copied().unwrap_or(0);
}

Qui, punteggio avrà il valore associato alla squadra Blu e il risultato sarà 10. Il metodo get restituisce Option<&V>; se non c’è alcun valore per quella chiave nella hash map, get restituirà None. Questo programma gestisce Option chiamando copied per ottenere Option<i32> anziché Option<&i32>, quindi unwrap_or per impostare punteggio a zero se punteggio non ha una voce per la chiave.

Possiamo iterare su ogni coppia chiave-valore in una hash map in modo simile a come facciamo con i vettori, utilizzando un ciclo for:

fn main() {
    use std::collections::HashMap;

    let mut punteggi = HashMap::new();

    punteggi.insert(String::from("Blu"), 10);
    punteggi.insert(String::from("Gialla"), 50);

    for (chiave, valore) in &punteggi {
        println!("{chiave}: {valore}");
    }
}

Questo codice stamperà ogni coppia in un ordine arbitrario:

Gialla: 50
Blu: 10

Gestire Ownership nelle Hash Map

Per i type che implementano il trait Copy, come i32, i valori vengono copiati nella hash map. Per i valori con ownership come String, i valori verranno spostati e la hash map assumerà la ownership di tali valori, come dimostrato nel Listato 8-22.

fn main() {
    use std::collections::HashMap;

    let nome_campo = String::from("Colore preferito");
    let valore_campo = String::from("Blu");

    let mut map = HashMap::new();
    map.insert(nome_campo, valore_campo);
    // `nome_campo` e `valore_campo` non sono validi a questo punto,
    // prova a usarli e vedi quale errore di compilazione ottieni!
}

Non possiamo utilizzare le variabili nome_campo e valore_campo dopo che sono state spostate nella hash map con la chiamata a insert.

Se inseriamo reference a valori nella hash map, i valori non verranno spostati nella hash map. I valori a cui puntano i reference devono essere validi almeno per il tempo in cui è valida la hash map. Approfondiremo questi argomenti in “Validare i Reference con la Lifetime” nel Capitolo 10.

Aggiornare una Hash Map

Sebbene il numero di coppie chiave-valore sia espandibile, a ogni chiave univoca può essere associato un solo valore alla volta (ma non viceversa: ad esempio, sia la squadra Blu che quella Gialla potrebbero avere il valore 10 memorizzato nella hash map punteggi).

Quando si desidera modificare i dati in una hash map, è necessario decidere come gestire il caso in cui a una chiave sia già assegnato un valore. È possibile sostituire il vecchio valore con il nuovo valore, ignorando completamente il vecchio valore. È possibile mantenere il vecchio valore e ignorare il nuovo valore, aggiungendo il nuovo valore solo se la chiave non ha già un valore. Oppure è possibile combinare il vecchio valore e il nuovo valore. Vediamo come fare ciascuna di queste cose!

Sovrascrivere un Valore

Se inseriamo una chiave e un valore in una hash map e poi inseriamo la stessa chiave con un valore diverso, il valore associato a quella chiave verrà sostituito. Anche se il codice nel Listato 8-23 chiama insert due volte, la hash map conterrà solo una coppia chiave-valore perché stiamo inserendo il valore per la chiave della squadra Blu entrambe le volte.

fn main() {
    use std::collections::HashMap;

    let mut punteggi = HashMap::new();

    punteggi.insert(String::from("Blu"), 10);
    punteggi.insert(String::from("Blu"), 25);

    println!("{punteggi:?}");
}

Questo codice stamperà {"Blu": 25}. Il valore originale di 10 è stato sovrascritto.

Aggiungere una Chiave e un Valore Solo Se una Chiave Non è Presente

È comune verificare se una particolare chiave esiste già nella hash map con un valore e quindi eseguire le seguenti azioni: se la chiave esiste nella hash map, il valore esistente deve rimanere invariato; se la chiave non esiste, inserirla e assegnarle un valore.

Le hash map dispongono di un’API speciale per questo scopo, chiamata entry, che accetta la chiave che si desidera controllare come parametro. Il valore restituito dal metodo entry è un’enum chiamato Entry che rappresenta un valore che potrebbe esistere o meno. Supponiamo di voler verificare se la chiave per la squadra Gialla ha un valore associato. In caso contrario, vogliamo inserire il valore 50, e lo stesso vale per la squadra Blu. Utilizzando l’API entry, il codice appare come nel Listato 8-24.

fn main() {
    use std::collections::HashMap;

    let mut punteggi = HashMap::new();
    punteggi.insert(String::from("Blu"), 10);

    punteggi.entry(String::from("Gialla")).or_insert(50);
    punteggi.entry(String::from("Blu")).or_insert(50);

    println!("{punteggi:?}");
}

Il metodo or_insert su Entry è definito per restituire un reference mutabile al valore della chiave Entry corrispondente se tale chiave esiste, e in caso contrario, inserisce il parametro come nuovo valore per questa chiave e restituisce un reference mutabile al nuovo valore. Questa tecnica è molto più pulita rispetto alla scrittura manuale della logica e, inoltre, si integra meglio con il borrow checker.

L’esecuzione del codice nel Listato 8-24 stamperà {"Gialla": 50, "Blu": 10}. La prima chiamata a entry inserirà la chiave per la squadra Gialla con il valore 50 perché la squadra Gialla non ha già un valore. La seconda chiamata a entry non modificherà la hash map perché la squadra Blu ha già il valore 10.

Aggiornare un Valore in Base al Valore Precedente

Un altro caso d’uso comune per le hash map è cercare il valore di una chiave e quindi aggiornarlo in base al valore precedente. Ad esempio, il Listato 8-25 mostra un codice che conta quante volte ogni parola appare in un testo. Utilizziamo una hash map con le parole come chiavi e incrementiamo il valore per tenere traccia di quante volte abbiamo visto quella parola. Quando incontriamo una parola nuova, verrà inserita inizializzando il valore associato a 0.

fn main() {
    use std::collections::HashMap;

    let testo = "hello world wonderful world";

    let mut map = HashMap::new();

    for parola in testo.split_whitespace() {
        let conteggio = map.entry(parola).or_insert(0);
        *conteggio += 1;
    }

    println!("{map:?}");
}

Questo codice stamperà {"world": 2, "hello": 1, "wonderful": 1}. Potresti vedere le stesse coppie chiave-valore stampate in un ordine diverso: ricorda che, come menzionato precedentemente in “Accesso ai Valori in una Hash Map”, l’iterazione su una hash map avviene in un ordine arbitrario.

Il metodo split_whitespace restituisce un iteratore su slice, separate da spazi, del valore in testo. Il metodo or_insert restituisce un reference mutabile (&mut V) al valore della chiave specificata. Qui, memorizziamo quel reference mutabile nella variabile conteggio, quindi per assegnare quel valore, dobbiamo prima de-referenziare conteggio usando l’asterisco (*). Il reference mutabile esce dallo scope alla fine del ciclo for, quindi tutte queste modifiche sono sicure e consentite dalle regole di prestito.

Funzioni di Hashing

Come impostazione predefinita, HashMap utilizza una funzione di hashing chiamata SipHash che può fornire resistenza agli attacchi denial-of-service (DoS) che coinvolgono tabelle di hash¹. Questo non è l’algoritmo di hashing più veloce disponibile, ma è un buon compromesso in termini di maggiore sicurezza che ne deriva, nonostante il costo prestazionale derivato. Se si profila il codice e si scopre che la funzione di hashing predefinita è troppo lenta per i propri scopi, è possibile passare a un’altra funzione specificando un hasher diverso. Un hasher è un type che implementa il trait BuildHasher. Parleremo dei trait e di come implementarli nel Capitolo 10. Non è necessario implementare il proprio hasher da zero; crates.io offre librerie condivise da altri utenti Rust che forniscono hasher che implementano molti algoritmi di hashing comuni.