1. Il Linguaggio di Programmazione Rust
2. Prefazione
3. Introduzione
4. 1. Primi Passi
5. 1. 1.1. Installazione
   2. 1.2. Hello, World!
   3. 1.3. Hello, Cargo!
6. 2. Programmare un Gioco di Indovinelli
7. 3. Concetti Comuni di Programmazione
8. 1. 3.1. Variabili e Mutabilità
   2. 3.2. Tipi di Dato
   3. 3.3. Funzioni
   4. 3.4. Commenti
   5. 3.5. Controllare il Flusso
9. 4. Capire la Ownership
10. 1. 4.1. Cos’è la Ownership?
    2. 4.2. Reference e Borrowing
    3. 4.3. Il Type Slice
11. 5. Utilizzare le Struct per Strutturare Dati Correlati
12. 1. 5.1. Definire e Istanziare le Struct
    2. 5.2. Un Esempio di Programma Che Usa Struct
    3. 5.3. Metodi
13. 6. Enumerazioni e Corrispondenza dei Pattern
14. 1. 6.1. Definire un’Enum
    2. 6.2. Controllare il Flusso col Costrutto match
    3. 6.3. Controllare il Flusso con if let e let else
15. 7. Pacchetti, Crate, e Moduli
16. 1. 7.1. Pacchetti e Crate
    2. 7.2. Controllare Scope e Privacy con i Moduli
    3. 7.3. Percorsi per Fare Riferimento a un Elemento nell’Albero dei Moduli
    4. 7.4. Portare i Percorsi in Scope con la Parola Chiave use
    5. 7.5. Separare i Moduli in File Diversi
17. 8. Collezioni Comuni
18. 1. 8.1. Memorizzare Elenchi di Valori con Vettori
    2. 8.2. Memorizzare Testo Codificato UTF-8 con Stringhe
    3. 8.3. Memorizzare Chiavi con Valori Associati in Mappe Hash
19. 9. Gestione degli Errori
20. 1. 9.1. Errori Irreversibili con panic!
    2. 9.2. Errori Reversibili con Result
    3. 9.3. panic! o non panic!
21. 10. Type Generici, Trait e Lifetime
22. 1. 10.1. Tipi di Dati Generici
    2. 10.2. Definire il Comportamento Condiviso con i Trait
    3. 10.3. Validare i Reference con la Lifetime
23. 11. Scrivere Test Automatizzati
24. 1. 11.1. Come Scrivere dei Test
    2. 11.2. Controllare Come Vengono Eseguiti i Test
    3. 11.3. Organizzare i Test
25. 12. Un progetto I/O: Creare un Programma da Riga di Comando
26. 1. 12.1. Ricevere Argomenti dalla Riga di Comando
    2. 12.2. Leggere un File
    3. 12.3. Refactoring per Migliorare Modularità e Gestione degli Errori
    4. 12.4. Aggiungere Funzionalità con il Test-Driven Development
    5. 12.5. Lavorare con le Variabili d’Ambiente
    6. 12.6. Scrivere Messaggi di Errore su Standard Error
27. 13. Funzionalità dei Linguaggi Funzionali: Iteratori e Chiusure
28. 1. 13.1. Chiusure
    2. 13.2. Elaborare una Serie di Elementi con Iteratori
    3. 13.3. Migliorare il Nostro Progetto I/O
    4. 13.4. Prestazioni di Cicli e Iteratori
29. 14. Maggiori informazioni su Cargo e Crates.io
30. 1. 14.1. Personalizzare le Build con i Profili di Rilascio
    2. 14.2. Pubblicare un Crate su Crates.io
    3. 14.3. Spazi di Lavoro Cargo
    4. 14.4. Installazione di Binari con cargo install
    5. 14.5. Estendere Cargo con Comandi Personalizzati
31. 15. Puntatori Intelligenti
32. 1. 15.1. Utilizzare Box<T> per Puntare ai Dati nell’Heap
    2. 15.2. Trattare i Puntatori Intelligenti Come Normali Reference
    3. 15.3. Eseguire del Codice Durante la Pulizia con il Trait Drop
    4. 15.4. Rc<T>, il Puntatore Intelligente con Conteggio dei Reference
    5. 15.5. RefCell<T> e il Modello di Mutabilità Interna
    6. 15.6. Cicli di Riferimento Possono Causare Perdite di Memoria
33. 16. Concorrenza Senza Paura
34. 1. 16.1. Usare i Thread Per Eseguire Codice Simultaneamente
    2. 16.2. Trasferire Dati tra Thread Usando il Passaggio di Messaggi
    3. 16.3. Concorrenza a Stato Condiviso
    4. 16.4. Concorrenza Estensibile con Send e Sync
35. 17. Fondamenti di Programmazione Asincrona: Async, Await, Future e Stream
36. 1. 17.1. Future e la Sintassi Async
    2. 17.2. Applicare la Concorrenza con Async
    3. 17.3. Lavorare con un Numero Qualsiasi di Future
    4. 17.4. Stream: Future in Sequenza
    5. 17.5. Uno Sguardo Più Da Vicino ai Trait per Async
    6. 17.6. Future, Task e Thread
37. 18. Funzionalità della Programmazione Orientata agli Oggetti
38. 1. 18.1. Caratteristiche dei Linguaggi Orientati agli Oggetti
    2. 18.2. Usare gli Oggetti Trait per Astrarre Comportamenti Condivisi
    3. 18.3. Implementare un Modello di Design Orientato agli Oggetti
39. 19. Patterns and Matching
40. 1. 19.1. All the Places Patterns Can Be Used
    2. 19.2. Refutability: Whether a Pattern Might Fail to Match
    3. 19.3. Pattern Syntax
41. 20. Advanced Features
42. 1. 20.1. Unsafe Rust
    2. 20.2. Advanced Traits
    3. 20.3. Advanced Types
    4. 20.4. Advanced Functions and Closures
    5. 20.5. Macros
43. 21. Final Project: Building a Multithreaded Web Server
44. 1. 21.1. Building a Single-Threaded Web Server
    2. 21.2. Turning Our Single-Threaded Server into a Multithreaded Server
    3. 21.3. Graceful Shutdown and Cleanup
45. 22. Appendice
46. 1. 22.1. A - Parole Chiave
    2. 22.2. B - Operators and Symbols
    3. 22.3. C - Derivable Traits
    4. 22.4. D - Utili Strumenti di sviluppo
    5. 22.5. E - Editions
    6. 22.6. F - Traduzioni del Libro
    7. 22.7. G - How Rust is Made and “Nightly Rust”
    8. 22.8. H - Note di Traduzione