\n"
-"Key points:"
+"* Be sure to note the difference between `let mut ref_x: &i32` and `let "
+"ref_x:\n"
+" &mut i32`. The first one represents a mutable reference which can be bound "
+"to\n"
+" different values, while the second represents a reference to a mutable "
+"value."
msgstr ""
-"
\n"
-"Punti chiave:"
-
-#: src/basic-syntax/references.md:24
-#, fuzzy
-msgid ""
-"* Be sure to note the difference between `let mut ref_x: &i32` and `let ref_x:\n"
-" &mut i32`. The first one represents a mutable reference which can be bound to\n"
-" different values, while the second represents a reference to a mutable value."
-msgstr ""
-"* Assicurati di notare la differenza tra `let mut ref_x: &i32` e `let ref_x:\n"
-" &mut i32`. Il primo rappresenta un riferimento mutevole a cui può essere associato\n"
-" valori diversi, mentre il secondo rappresenta un riferimento a un valore mutabile."
+"* Assicurati di notare la differenza tra `let mut ref_x: &i32` e `let "
+"ref_x:\n"
+" &mut i32`. Il primo rappresenta un riferimento mutevole a cui può essere "
+"associato\n"
+" valori diversi, mentre il secondo rappresenta un riferimento a un valore "
+"mutabile."
#: src/basic-syntax/references-dangling.md:1
msgid "# Dangling References"
msgstr "# Riferimenti Penzolanti (Dangling References)"
#: src/basic-syntax/references-dangling.md:3
-#, fuzzy
msgid "Rust will statically forbid dangling references:"
msgstr "Rust proibirà staticamente i riferimenti penzolanti:"
@@ -2901,32 +3269,31 @@ msgid ""
msgstr ""
#: src/basic-syntax/references-dangling.md:16
-#, fuzzy
msgid ""
"* A reference is said to \"borrow\" the value it refers to.\n"
"* Rust is tracking the lifetimes of all references to ensure they live long\n"
" enough.\n"
"* We will talk more about borrowing when we get to ownership."
msgstr ""
-"* Si dice che un riferimento \"prenda in prestito\" il valore a cui si riferisce.\n"
-"* Rust tiene traccia delle vite di tutti i riferimenti per assicurarsi che durino a lungo\n"
-" Abbastanza.\n"
-"* Parleremo di più del prestito quando arriveremo alla proprietà."
+"* Si dice che un riferimento \"prenda in prestito\" (_borrow_) il valore a cui si "
+"riferisce.\n"
+"* Rust tiene traccia delle vite di tutti i riferimenti per assicurarsi che "
+"durino abbastanza a lungo.\n"
+"* Parleremo di più del _borrowing_ quando arriveremo alla proprietà (_ownership_)."
#: src/basic-syntax/slices.md:1
msgid "# Slices"
msgstr "# Slices"
#: src/basic-syntax/slices.md:3
-#, fuzzy
msgid "A slice gives you a view into a larger collection:"
-msgstr "Una sezione ti offre una vista in una raccolta più ampia:"
+msgstr "Una _slice_ ti offre una vista in una raccolta più ampia:"
#: src/basic-syntax/slices.md:5
msgid ""
"```rust,editable\n"
"fn main() {\n"
-" let a: [i32; 6] = [10, 20, 30, 40, 50, 60];\n"
+" let mut a: [i32; 6] = [10, 20, 30, 40, 50, 60];\n"
" println!(\"a: {a:?}\");\n"
"\n"
" let s: &[i32] = &a[2..4];\n"
@@ -2936,59 +3303,66 @@ msgid ""
msgstr ""
#: src/basic-syntax/slices.md:15
-#, fuzzy
msgid ""
"* Slices borrow data from the sliced type.\n"
"* Question: What happens if you modify `a[3]`?"
msgstr ""
-"* Le sezioni prendono in prestito i dati dal tipo a fette.\n"
+"* Le sezioni prendono in prestito i dati dal tipo della raccolta.\n"
"* Domanda: Cosa succede se modifichi `a[3]`?"
#: src/basic-syntax/slices.md:20
-#, fuzzy
msgid ""
-"* We create a slice by borrowing `a` and specifying the starting and ending indexes in brackets.\n"
+"* We create a slice by borrowing `a` and specifying the starting and ending "
+"indexes in brackets.\n"
"\n"
-"* If the slice starts at index 0, Rust’s range syntax allows us to drop the starting index, "
-"meaning that `&a[0..a.len()]` and `&a[..a.len()]` are identical.\n"
+"* If the slice starts at index 0, Rust’s range syntax allows us to drop the "
+"starting index, meaning that `&a[0..a.len()]` and `&a[..a.len()]` are "
+"identical.\n"
" \n"
-"* The same is true for the last index, so `&a[2..a.len()]` and `&a[2..]` are identical.\n"
+"* The same is true for the last index, so `&a[2..a.len()]` and `&a[2..]` are "
+"identical.\n"
"\n"
-"* To easily create a slice of the full array, we can therefore use `&a[..]`.\n"
+"* To easily create a slice of the full array, we can therefore use "
+"`&a[..]`.\n"
"\n"
-"* `s` is a reference to a slice of `i32`s. Notice that the type of `s` (`&[i32]`) no longer "
-"mentions the array length. This allows us to perform computation on slices of different sizes.\n"
+"* `s` is a reference to a slice of `i32`s. Notice that the type of `s` "
+"(`&[i32]`) no longer mentions the array length. This allows us to perform "
+"computation on slices of different sizes.\n"
" \n"
-"* Slices always borrow from another object. In this example, `a` has to remain 'alive' (in scope) "
-"for at least as long as our slice. \n"
+"* Slices always borrow from another object. In this example, `a` has to "
+"remain 'alive' (in scope) for at least as long as our slice. \n"
" \n"
-"* The question about modifying `a[3]` can spark an interesting discussion, but the answer is that "
-"for memory safety reasons\n"
-" you cannot do it through `a` after you created a slice, but you can read the data from both `a` "
-"and `s` safely. \n"
+"* The question about modifying `a[3]` can spark an interesting discussion, "
+"but the answer is that for memory safety reasons\n"
+" you cannot do it through `a` after you created a slice, but you can read "
+"the data from both `a` and `s` safely. \n"
" More details will be explained in the borrow checker section."
msgstr ""
-"* Creiamo una sezione prendendo in prestito `a` e specificando gli indici iniziale e finale tra "
-"parentesi.\n"
+"* Creiamo una sezione prendendo in prestito `a` e specificando gli indici "
+"iniziale e finale tra parentesi.\n"
"\n"
-"* Se la slice inizia all'indice 0, la sintassi dell'intervallo di Rust ci consente di eliminare "
-"l'indice iniziale, il che significa che `&a[0..a.len()]` e `&a[..a.len()]` sono identici .\n"
+"* Se la slice inizia all'indice 0, la sintassi dell'intervallo di Rust ci "
+"consente di eliminare l'indice iniziale, il che significa che `&a[0..a."
+"len()]` e `&a[..a.len()]` sono identici .\n"
" \n"
-"* Lo stesso vale per l'ultimo indice, quindi `&a[2..a.len()]` e `&a[2..]` sono identici.\n"
+"* Lo stesso vale per l'ultimo indice, quindi `&a[2..a.len()]` e `&a[2..]` "
+"sono identici.\n"
"\n"
-"* Per creare facilmente una porzione dell'array completo, possiamo quindi utilizzare `&a[..]`.\n"
+"* Per creare facilmente una porzione dell'array completo, possiamo quindi "
+"utilizzare `&a[..]`.\n"
"\n"
-"* `s` è un riferimento a una porzione di `i32`s. Si noti che il tipo di `s` (`&[i32]`) non "
-"menziona più la lunghezza dell'array. Questo ci permette di eseguire il calcolo su fette di "
-"diverse dimensioni.\n"
+"* `s` è un riferimento a una porzione di `i32`s. Si noti che il tipo di `s` "
+"(`&[i32]`) non menziona più la lunghezza dell'array. Questo ci permette di "
+"eseguire il calcolo su fette di diverse dimensioni.\n"
" \n"
-"* Le fette prendono sempre in prestito da un altro oggetto. In questo esempio, `a` deve rimanere "
-"'vivo' (nello scope) almeno quanto la nostra fetta.\n"
+"* Le fette prendono sempre in prestito da un altro oggetto. In questo "
+"esempio, `a` deve rimanere 'vivo' (nello scope) almeno quanto la nostra "
+"fetta.\n"
" \n"
-"* La domanda sulla modifica di `a[3]` può innescare una discussione interessante, ma la risposta è "
-"che per motivi di sicurezza della memoria\n"
-" non puoi farlo tramite \"a\" dopo aver creato una sezione, ma puoi leggere i dati sia da \"a\" "
-"che da \"s\" in modo sicuro.\n"
+"* La domanda sulla modifica di `a[3]` può innescare una discussione "
+"interessante, ma la risposta è che per motivi di sicurezza della memoria\n"
+" non puoi farlo tramite \"a\" dopo aver creato una sezione, ma puoi leggere "
+"i dati sia da \"a\" che da \"s\" in modo sicuro.\n"
" Maggiori dettagli saranno spiegati nella sezione controllo del prestito."
#: src/basic-syntax/string-slices.md:1
@@ -2996,7 +3370,6 @@ msgid "# `String` vs `str`"
msgstr "# `String` vs `str`"
#: src/basic-syntax/string-slices.md:3
-#, fuzzy
msgid "We can now understand the two string types in Rust:"
msgstr "Ora possiamo comprendere i due tipi di stringhe in Rust:"
@@ -3023,50 +3396,81 @@ msgid "Rust terminology:"
msgstr "Terminologia di Rust:"
#: src/basic-syntax/string-slices.md:22
-#, fuzzy
msgid ""
"* `&str` an immutable reference to a string slice.\n"
"* `String` a mutable string buffer."
msgstr ""
"* `&str` un riferimento immutabile a uno slice di stringa.\n"
-"* `String` un buffer di stringa mutabile."
+"* `String` è un buffer di stringa mutabile."
#: src/basic-syntax/string-slices.md:27
msgid ""
-"* `&str` introduces a string slice, which is an immutable reference to UTF-8 encoded string data \n"
-" stored in a block of memory. String literals (`”Hello”`), are stored in the program’s binary.\n"
+"* `&str` introduces a string slice, which is an immutable reference to UTF-8 "
+"encoded string data \n"
+" stored in a block of memory. String literals (`”Hello”`), are stored in "
+"the program’s binary.\n"
"\n"
-"* Rust’s `String` type is a wrapper around a vector of bytes. As with a `Vec`, it is owned.\n"
+"* Rust’s `String` type is a wrapper around a vector of bytes. As with a "
+"`Vec`, it is owned.\n"
" \n"
-"* As with many other types `String::from()` creates a string from a string literal; `String::"
-"new()` \n"
-" creates a new empty string, to which string data can be added using the `push()` and "
-"`push_str()` methods.\n"
+"* As with many other types `String::from()` creates a string from a string "
+"literal; `String::new()` \n"
+" creates a new empty string, to which string data can be added using the "
+"`push()` and `push_str()` methods.\n"
"\n"
-"* The `format!()` macro is a convenient way to generate an owned string from dynamic values. It \n"
+"* The `format!()` macro is a convenient way to generate an owned string from "
+"dynamic values. It \n"
" accepts the same format specification as `println!()`.\n"
" \n"
-"* You can borrow `&str` slices from `String` via `&` and optionally range selection.\n"
+"* You can borrow `&str` slices from `String` via `&` and optionally range "
+"selection.\n"
" \n"
-"* For C++ programmers: think of `&str` as `const char*` from C++, but the one that always points \n"
-" to a valid string in memory. Rust `String` is a rough equivalent of `std::string` from C++ \n"
-" (main difference: it can only contain UTF-8 encoded bytes and will never use a small-string "
-"optimization).\n"
+"* For C++ programmers: think of `&str` as `const char*` from C++, but the "
+"one that always points \n"
+" to a valid string in memory. Rust `String` is a rough equivalent of `std::"
+"string` from C++ \n"
+" (main difference: it can only contain UTF-8 encoded bytes and will never "
+"use a small-string optimization).\n"
" "
msgstr ""
+"* `&str` introduce una _string slice_, che è un riferimento immutabile a una "
+" stringa codificata UTF-8\n"
+" memorizzata in un blocco di memoria. Le Stringhe letterali (`”Hello”`), sono memorizzate "
+"all'interno del programma binario.\n"
+"\n"
+"* Il tipo Rust `String` è costruito attorno a un vettore di bytes. Come con un "
+"`Vec`, possiede i dati.\n"
+" \n"
+"* Come con molti altri tipi, `String::from()` crea una stringa da un "
+"carattere letterale; `String::new()` \n"
+" crea una stringa vuota a cui è possibile aggiungere dati utilizzando i metodi "
+"`push()` and `push_str()`.\n"
+"\n"
+"* La macro `format!()` è un modo conveniente per generare una "
+"stringa da valori dinamici.\n"
+" Accetta la stessa specifica di formato di `println!()`.\n"
+" \n"
+"* Puoi prendere in prestito le sezioni `&str` da `String` con `&` "
+"e la selezione dell'intervallo opzionale.\n"
+" \n"
+"* Per i programmatori C++: pensa a `&str` come a `const char*` da C++ "
+"ma che punta sempre a una stringa valida in memoria. \n"
+" Rust `String` è approssimativamente equivalente a `std::string` da C++ \n"
+" (differenza principale: può contenere solo byte codificati UTF-8 "
+" e non utilizzerà mai l'ottimizzazione di stringhe piccole).\n"
+" "
#: src/basic-syntax/functions.md:1
msgid "# Functions"
msgstr "# Funzioni"
#: src/basic-syntax/functions.md:3
-#, fuzzy
msgid ""
-"A Rust version of the famous [FizzBuzz](https://en.wikipedia.org/wiki/Fizz_buzz) interview "
-"question:"
+"A Rust version of the famous [FizzBuzz](https://en.wikipedia.org/wiki/"
+"Fizz_buzz) interview question:"
msgstr ""
-"Una versione Rust della famosa domanda dell'intervista [FizzBuzz](https://en.wikipedia.org/wiki/"
-"Fizz_buzz):"
+"Una versione Rust del famoso gioco [FizzBuzz](https://en."
+"wikipedia.org/wiki/Fizz_buzz):"
#: src/basic-syntax/functions.md:5
msgid ""
@@ -3101,91 +3505,110 @@ msgstr ""
#: src/basic-syntax/functions.md:35
msgid ""
-"* We refer in `main` to a function written below. Neither forward declarations nor headers are "
-"necessary. \n"
-"* Declaration parameters are followed by a type (the reverse of some programming languages), then "
-"a return type.\n"
-"* The last expression in a function body (or any block) becomes the return value. Simply omit the "
-"`;` at the end of the expression.\n"
-"* Some functions have no return value, and return the 'unit type', `()`. The compiler will infer "
-"this if the `-> ()` return type is omitted.\n"
-"* The range expression in the `for` loop in `print_fizzbuzz_to()` contains `=n`, which causes it "
-"to include the upper bound."
+"* We refer in `main` to a function written below. Neither forward "
+"declarations nor headers are necessary. \n"
+"* Declaration parameters are followed by a type (the reverse of some "
+"programming languages), then a return type.\n"
+"* The last expression in a function body (or any block) becomes the return "
+"value. Simply omit the `;` at the end of the expression.\n"
+"* Some functions have no return value, and return the 'unit type', `()`. The "
+"compiler will infer this if the `-> ()` return type is omitted.\n"
+"* The range expression in the `for` loop in `print_fizzbuzz_to()` contains "
+"`=n`, which causes it to include the upper bound."
msgstr ""
+"* In `main` ci si riferisce a una funzione scritta di seguito. "
+" Non sono necessarie né pre-dichiarazioni né intestazioni.\n"
+"* I parametri di dichiarazione sono seguiti da un tipo "
+"(il contrario di alcuni linguaggi di programmazione) e quindi da un tipo restituito.\n"
+"* L'ultima espressione nel corpo di una funzione (o in qualsiasi blocco) "
+"diventa il valore restituito. Basta omettere `;` alla fine dell'espressione.\n"
+"* Alcune funzioni non hanno alcun valore di ritorno e restituiscono il 'tipo di unità', `()`."
+" Il compilatore lo dedurrà se il tipo restituito `->()` viene omesso.\n"
+"* L'espressione di intervallo nel ciclo `for` in `fizzbuzz to()` contiene `=n` "
+"che include il limite superiore."
#: src/basic-syntax/rustdoc.md:1
msgid "# Rustdoc"
msgstr "# Rustdoc"
#: src/basic-syntax/rustdoc.md:3
-#, fuzzy
-msgid "All language items in Rust can be documented using special `///` syntax."
+msgid ""
+"All language items in Rust can be documented using special `///` syntax."
msgstr ""
-"Tutti gli elementi del linguaggio in Rust possono essere documentati usando la sintassi speciale "
-"`///`."
+"Tutti gli elementi del linguaggio in Rust possono essere documentati usando "
+"la sintassi speciale `///`."
#: src/basic-syntax/rustdoc.md:5
msgid ""
"```rust,editable\n"
-"/// Determine whether the first argument is divisible by the second argument.\n"
+"/// Determine whether the first argument is divisible by the second "
+"argument.\n"
"///\n"
"/// If the second argument is zero, the result is false.\n"
"fn is_divisible_by(lhs: u32, rhs: u32) -> bool {\n"
" if rhs == 0 {\n"
" return false; // Corner case, early return\n"
" }\n"
-" lhs % rhs == 0 // The last expression in a block is the return value\n"
+" lhs % rhs == 0 // The last expression in a block is the return "
+"value\n"
"}\n"
"```"
msgstr ""
#: src/basic-syntax/rustdoc.md:17
-#, fuzzy
msgid ""
"The contents are treated as Markdown. All published Rust library crates are\n"
"automatically documented at [`docs.rs`](https://docs.rs) using the\n"
-"[rustdoc](https://doc.rust-lang.org/rustdoc/what-is-rustdoc.html) tool. It is\n"
+"[rustdoc](https://doc.rust-lang.org/rustdoc/what-is-rustdoc.html) tool. It "
+"is\n"
"idiomatic to document all public items in an API using this pattern."
msgstr ""
-"I contenuti sono trattati come Markdown. Tutti i crate della libreria Rust pubblicati lo sono\n"
-"documentato automaticamente in [`docs.rs`](https://docs.rs) utilizzando il file\n"
-"[rustdoc](https://doc.rust-lang.org/rustdoc/what-is-rustdoc.html) strumento. È\n"
-"idiomatico per documentare tutti gli elementi pubblici in un'API utilizzando questo modello."
+"I contenuti sono trattati come Markdown. Tutti i _crate_ pubblicati della libreria Rust "
+"sono\n"
+"automaticamente documentati in [`docs.rs`](https://docs.rs) utilizzando lo "
+"strumento \n"
+"[rustdoc](https://doc.rust-lang.org/rustdoc/what-is-rustdoc.html). "
+"È\n"
+"idiomatico per documentare tutti gli elementi pubblici in un'API utilizzando "
+"questo modello."
#: src/basic-syntax/rustdoc.md:24
-#, fuzzy
msgid ""
"* Show students the generated docs for the `rand` crate at\n"
" [`docs.rs/rand`](https://docs.rs/rand).\n"
"\n"
-"* This course does not include rustdoc on slides, just to save space, but in\n"
+"* This course does not include rustdoc on slides, just to save space, but "
+"in\n"
" real code they should be present.\n"
"\n"
-"* Inner doc comments are discussed later (in the page on modules) and need not\n"
+"* Inner doc comments are discussed later (in the page on modules) and need "
+"not\n"
" be addressed here."
msgstr ""
-"* Mostra agli studenti i documenti generati per la cassa `rand` su\n"
+"* Mostra agli studenti i documenti generati per il _crate_ `rand` su\n"
" [`docs.rs/rand`](https://docs.rs/rand).\n"
"\n"
-"* Questo corso non include rustdoc sulle diapositive, solo per risparmiare spazio, ma in\n"
-" codice reale dovrebbero essere presenti.\n"
+"* Questo corso non include rustdoc sulle diapositive, solo per risparmiare "
+"spazio, ma nel contesto\n"
+" reale dovrebbe essere presente.\n"
"\n"
-"* I commenti interni al documento sono discussi più avanti (nella pagina sui moduli) e non sono "
-"necessari\n"
-" essere affrontato qui."
+"* I commenti interni al documento sono discussi più avanti (nella pagina sui "
+"moduli) e non è necessario\n"
+" affrontarli qui."
#: src/basic-syntax/methods.md:1 src/methods.md:1
msgid "# Methods"
msgstr "# Metodi"
#: src/basic-syntax/methods.md:3
-#, fuzzy
msgid ""
-"Methods are functions associated with a type. The `self` argument of a method is\n"
+"Methods are functions associated with a type. The `self` argument of a "
+"method is\n"
"an instance of the type it is associated with:"
msgstr ""
-"I metodi sono funzioni associate a un tipo. L'argomento `self` di un metodo è\n"
-"un'istanza del tipo a cui è associata:"
+"I metodi sono funzioni associate a un tipo. L'argomento `self` di un metodo "
+"è\n"
+"un'istanza del tipo a cui è associato:"
#: src/basic-syntax/methods.md:6
msgid ""
@@ -3215,9 +3638,12 @@ msgid ""
msgstr ""
#: src/basic-syntax/methods.md:30
-#, fuzzy
-msgid "* We will look much more at methods in today's exercise and in tomorrow's class."
-msgstr "* Approfondiremo maggiormente i metodi nell'esercizio di oggi e nella lezione di domani."
+msgid ""
+"* We will look much more at methods in today's exercise and in tomorrow's "
+"class."
+msgstr ""
+"* Approfondiremo maggiormente i metodi nell'esercizio di oggi e nella "
+"lezione di domani."
#: src/basic-syntax/methods.md:34
msgid ""
@@ -3232,6 +3658,16 @@ msgid ""
"- Add a `Rectangle::new_square(width: u32)` constructor to illustrate that\n"
" constructors can take arbitrary parameters."
msgstr ""
+"- Aggiungi un costruttore `Rectangle::new` e chiamalo da `main`:\n"
+"\n"
+" ```rust,editable,compile_fail\n"
+" fn new(width: u32, height: u32) -> Rectangle {\n"
+" Rectangle { width, height }\n"
+" }\n"
+" ```\n"
+"\n"
+"- Aggiungi un costruttore `Rectangle::new_square(width: u32)` per illustrare\n"
+" che i costruttori possono accettare parametri arbitrari."
#: src/basic-syntax/functions-interlude.md:1
msgid "# Function Overloading"
@@ -3239,10 +3675,9 @@ msgstr "# Overloading di Funzione"
#: src/basic-syntax/functions-interlude.md:3
msgid "Overloading is not supported:"
-msgstr "Overloading non è supportato:"
+msgstr "L'Overloading non è supportato:"
#: src/basic-syntax/functions-interlude.md:5
-#, fuzzy
msgid ""
"* Each function has a single implementation:\n"
" * Always takes a fixed number of parameters.\n"
@@ -3259,7 +3694,6 @@ msgstr ""
" * Le macro sono talvolta utilizzate come alternativa."
#: src/basic-syntax/functions-interlude.md:12
-#, fuzzy
msgid "However, function parameters can be generic:"
msgstr "Tuttavia, i parametri delle funzioni possono essere generici:"
@@ -3278,25 +3712,26 @@ msgid ""
msgstr ""
#: src/basic-syntax/functions-interlude.md:27
-#, fuzzy
msgid ""
-"* When using generics, the standard library's `Into` can provide a kind of limited\n"
-" polymorphism on argument types. We will see more details in a later section."
+"* When using generics, the standard library's `Into` can provide a kind "
+"of limited\n"
+" polymorphism on argument types. We will see more details in a later "
+"section."
msgstr ""
-"* Quando si usano i generici, `Into` della libreria standard può fornire una sorta di limited\n"
-" polimorfismo sui tipi di argomento. Vedremo maggiori dettagli in una sezione successiva."
+"* Quando si usano i generici, `Into` della libreria standard può fornire "
+"una sorta di\n"
+" polimorfismo limitato sui tipi dell'argomento. Vedremo maggiori dettagli in una "
+"sezione successiva."
#: src/exercises/day-1/morning.md:1
msgid "# Day 1: Morning Exercises"
msgstr "# Giorno 1: Esercizi Mattutini"
#: src/exercises/day-1/morning.md:3
-#, fuzzy
msgid "In these exercises, we will explore two parts of Rust:"
msgstr "In questi esercizi esploreremo due parti di Rust:"
#: src/exercises/day-1/morning.md:5
-#, fuzzy
msgid ""
"* Implicit conversions between types.\n"
"\n"
@@ -3307,54 +3742,58 @@ msgstr ""
"* Array e cicli `for`."
#: src/exercises/day-1/morning.md:11
-#, fuzzy
msgid "A few things to consider while solving the exercises:"
msgstr "Alcune cose da considerare durante la risoluzione degli esercizi:"
#: src/exercises/day-1/morning.md:13
-#, fuzzy
msgid ""
"* Use a local Rust installation, if possible. This way you can get\n"
-" auto-completion in your editor. See the page about [Using Cargo] for details\n"
+" auto-completion in your editor. See the page about [Using Cargo] for "
+"details\n"
" on installing Rust.\n"
"\n"
"* Alternatively, use the Rust Playground."
msgstr ""
-"* Utilizzare un'installazione locale di Rust, se possibile. In questo modo puoi ottenere\n"
-" completamento automatico nel tuo editor. Vedi la pagina su [Utilizzo del carico] per i dettagli\n"
+"* Utilizzare un'installazione locale di Rust, se possibile. In questo modo "
+"puoi ottenere\n"
+" completamento automatico nel tuo editor. Vedi la pagina su [Using Cargo] per i dettagli\n"
" sull'installazione di Rust.\n"
"\n"
"* In alternativa, usa Rust Playground."
#: src/exercises/day-1/morning.md:19
-#, fuzzy
msgid ""
-"The code snippets are not editable on purpose: the inline code snippets lose\n"
+"The code snippets are not editable on purpose: the inline code snippets "
+"lose\n"
"their state if you navigate away from the page."
msgstr ""
-"Gli snippet di codice non sono modificabili di proposito: gli snippet di codice in linea perdono\n"
+"Gli snippet di codice non sono modificabili di proposito: gli snippet di "
+"codice in linea perdono\n"
"il loro stato se esci dalla pagina."
#: src/exercises/day-1/morning.md:22 src/exercises/day-1/afternoon.md:11
#: src/exercises/day-2/morning.md:11 src/exercises/day-2/afternoon.md:7
#: src/exercises/day-3/morning.md:7 src/exercises/bare-metal/morning.md:7
-#: src/exercises/bare-metal/afternoon.md:7 src/exercises/concurrency/morning.md:12
+#: src/exercises/bare-metal/afternoon.md:7
+#: src/exercises/concurrency/morning.md:12
#: src/exercises/concurrency/afternoon.md:13
-#, fuzzy
-msgid "After looking at the exercises, you can look at the [solutions] provided."
-msgstr "Dopo aver esaminato gli esercizi, puoi esaminare le [soluzioni] fornite."
+msgid ""
+"After looking at the exercises, you can look at the [solutions] provided."
+msgstr ""
+"Dopo aver esaminato gli esercizi, puoi esaminare le [solutions] fornite."
#: src/exercises/day-1/implicit-conversions.md:1
msgid "# Implicit Conversions"
msgstr "# Conversioni Implicite"
#: src/exercises/day-1/implicit-conversions.md:3
-#, fuzzy
msgid ""
-"Rust will not automatically apply _implicit conversions_ between types ([unlike\n"
+"Rust will not automatically apply _implicit conversions_ between types "
+"([unlike\n"
"C++][3]). You can see this in a program like this:"
msgstr ""
-"Rust non applicherà automaticamente le _conversioni implicite_ tra i tipi ([a differenza di\n"
+"Rust non applicherà automaticamente le _conversioni implicite_ tra i tipi "
+"([a differenza di\n"
"C++][3]). Puoi vederlo in un programma come questo:"
#: src/exercises/day-1/implicit-conversions.md:6
@@ -3374,46 +3813,52 @@ msgid ""
msgstr ""
#: src/exercises/day-1/implicit-conversions.md:19
-#, fuzzy
msgid ""
"The Rust integer types all implement the [`From`][1] and [`Into`][2]\n"
-"traits to let us convert between them. The `From` trait has a single `from()`\n"
+"traits to let us convert between them. The `From` trait has a single "
+"`from()`\n"
"method and similarly, the `Into` trait has a single `into()` method.\n"
-"Implementing these traits is how a type expresses that it can be converted into\n"
+"Implementing these traits is how a type expresses that it can be converted "
+"into\n"
"another type."
msgstr ""
-"Tutti i tipi interi di Rust implementano [`From`][1] e [`Into`][2]\n"
-"tratti per farci convertire tra di loro. Il tratto `From` ha un singolo `from()`\n"
-"e allo stesso modo, il tratto `Into` ha un singolo metodo `into()`.\n"
-"L'implementazione di questi tratti è il modo in cui un tipo esprime ciò in cui può essere "
-"convertito\n"
-"un altro tipo."
+"Tutti i tipi interi in Rust implementano i _traits_ [`From`][1] e [`Into`][2]\n"
+"consentendo la conversione tra di loro. Il _trait_ `From` ha un singolo metodo "
+"`from()`\n"
+" e allo stesso modo, il _trait_ `Into` ha un singolo metodo `into()`.\n"
+"L'implementazione di questi _traits_ esprime il modo in cui un tipo consente "
+" di essere convertito in\n"
+" un altro tipo."
#: src/exercises/day-1/implicit-conversions.md:25
-#, fuzzy
msgid ""
-"The standard library has an implementation of `From for i16`, which means\n"
+"The standard library has an implementation of `From for i16`, which "
+"means\n"
"that we can convert a variable `x` of type `i8` to an `i16` by calling \n"
"`i16::from(x)`. Or, simpler, with `x.into()`, because `From for i16`\n"
"implementation automatically create an implementation of `Into for i8`."
msgstr ""
-"La libreria standard ha un'implementazione di `From for i16`, che significa\n"
-"che possiamo convertire una variabile `x` di tipo `i8` in una `i16` chiamando\n"
-"`i16::da(x)`. O, più semplicemente, con `x.into()`, perché `From for i16`\n"
-"l'implementazione crea automaticamente un'implementazione di `Into per i8`."
+"La libreria standard ha un'implementazione di `From for i16`, che "
+"significa\n"
+"che possiamo convertire una variabile `x` di tipo `i8` in una `i16` "
+"chiamando\n"
+"`i16::from(x)`. O, più semplicemente, con `x.into()`, perché l'implementazione `From for "
+"i16`\n"
+" crea automaticamente un'implementazione di `Into per "
+"i8`."
#: src/exercises/day-1/implicit-conversions.md:30
-#, fuzzy
msgid ""
-"The same applies for your own `From` implementations for your own types, so it is\n"
-"sufficient to only implement `From` to get a respective `Into` implementation automatically."
+"The same applies for your own `From` implementations for your own types, so "
+"it is\n"
+"sufficient to only implement `From` to get a respective `Into` "
+"implementation automatically."
msgstr ""
"Lo stesso vale per le tue implementazioni `From` per i tuoi tipi, così è\n"
-"sufficiente implementare solo `From` per ottenere automaticamente una rispettiva implementazione "
-"`Into`."
+"sufficiente implementare solo `From` per ottenere automaticamente una "
+"rispettiva implementazione `Into`."
#: src/exercises/day-1/implicit-conversions.md:33
-#, fuzzy
msgid ""
"1. Execute the above program and look at the compiler error.\n"
"\n"
@@ -3422,17 +3867,22 @@ msgid ""
"3. Change the types of `x` and `y` to other things (such as `f32`, `bool`,\n"
" `i128`) to see which types you can convert to which other types. Try\n"
" converting small types to big types and the other way around. Check the\n"
-" [standard library documentation][1] to see if `From` is implemented for\n"
+" [standard library documentation][1] to see if `From` is implemented "
+"for\n"
" the pairs you check."
msgstr ""
"1. Eseguire il programma precedente e osservare l'errore del compilatore.\n"
"\n"
-"2. Aggiorna il codice sopra per utilizzare `into()` per eseguire la conversione.\n"
+"2. Aggiornare il codice per utilizzare `into()` per eseguire la "
+"conversione.\n"
"\n"
-"3. Cambia i tipi di `x` e `y` in altre cose (come `f32`, `bool`,\n"
-" `i128`) per vedere quali tipi è possibile convertire in quali altri tipi. Tentativo\n"
-" convertire caratteri piccoli in caratteri grandi e viceversa. Controlla il\n"
-" [documentazione della libreria standard][1] per vedere se `From` è implementato per\n"
+"3. Cambiare i tipi di `x` e `y` in altre cose (come `f32`, `bool`,\n"
+" `i128`) per vedere quali tipi è possibile convertire in quali altri tipi. "
+"Provare a\n"
+" convertire tipi \"piccoli\" in tipi \"grandi\" e viceversa. Controlla "
+"la\n"
+" [documentazione della libreria standard][1] per vedere se `From` è "
+"implementato per\n"
" le coppie che controlli."
#: src/exercises/day-1/for-loops.md:1
@@ -3440,7 +3890,6 @@ msgid "# Arrays and `for` Loops"
msgstr "# Array e Cicli `for`"
#: src/exercises/day-1/for-loops.md:3
-#, fuzzy
msgid "We saw that an array can be declared like this:"
msgstr "Abbiamo visto che un array può essere dichiarato in questo modo:"
@@ -3452,9 +3901,12 @@ msgid ""
msgstr ""
#: src/exercises/day-1/for-loops.md:9
-#, fuzzy
-msgid "You can print such an array by asking for its debug representation with `{:?}`:"
-msgstr "Puoi stampare un tale array chiedendo la sua rappresentazione di debug con `{:?}`:"
+msgid ""
+"You can print such an array by asking for its debug representation with `{:?}"
+"`:"
+msgstr ""
+"Puoi stampare un tale array chiedendo la sua rappresentazione di debug con "
+"`{:?}`:"
#: src/exercises/day-1/for-loops.md:11
msgid ""
@@ -3467,13 +3919,11 @@ msgid ""
msgstr ""
#: src/exercises/day-1/for-loops.md:18
-#, fuzzy
msgid ""
"Rust lets you iterate over things like arrays and ranges using the `for`\n"
"keyword:"
msgstr ""
-"Rust ti consente di iterare cose come array e intervalli usando il `for`\n"
-"parola chiave:"
+"Rust ti consente di iterare cose come array e intervalli usando la parola chiave `for`:"
#: src/exercises/day-1/for-loops.md:21
msgid ""
@@ -3496,14 +3946,16 @@ msgid ""
msgstr ""
#: src/exercises/day-1/for-loops.md:38
-#, fuzzy
msgid ""
-"Use the above to write a function `pretty_print` which pretty-print a matrix and\n"
-"a function `transpose` which will transpose a matrix (turn rows into columns):"
+"Use the above to write a function `pretty_print` which pretty-print a matrix "
+"and\n"
+"a function `transpose` which will transpose a matrix (turn rows into "
+"columns):"
msgstr ""
-"Usa quanto sopra per scrivere una funzione `pretty_print` che stampa in modo grazioso una matrice "
-"e\n"
-"una funzione `transpose` che traspone una matrice (trasforma le righe in colonne):"
+"Usa quanto sopra per scrivere una funzione `pretty_print` che stampa in modo "
+"efficace una matrice e\n"
+"una funzione `transpose` che traspone una matrice (trasforma le righe in "
+"colonne):"
#: src/exercises/day-1/for-loops.md:41
msgid ""
@@ -3515,17 +3967,15 @@ msgid ""
msgstr ""
#: src/exercises/day-1/for-loops.md:47
-#, fuzzy
msgid "Hard-code both functions to operate on 3 × 3 matrices."
-msgstr "Hard-code entrambe le funzioni per operare su matrici 3 × 3."
+msgstr "Implementa entrambe le funzioni per operare su matrici 3 × 3."
#: src/exercises/day-1/for-loops.md:49
-#, fuzzy
msgid ""
"Copy the code below to `.\n"
+"* It isn't super common that one would need a runtime evaluated constant, "
+"but it is helpful and safer than using a static."
msgstr ""
-"* Menziona che `const` si comporta semanticamente in modo simile a `constexpr` del C++.\n"
-"* `static`, d'altra parte, è molto più simile a una `const` o variabile globale mutabile in C++.\n"
-"* Non è molto comune che si abbia bisogno di una costante valutata in fase di esecuzione, ma è "
-"utile e più sicura rispetto all'utilizzo di una statica."
+"* Menziona che `const` si comporta semanticamente in modo simile a "
+"`constexpr` del C++.\n"
+"* `static`, d'altra parte, è molto più simile a una `const` o variabile "
+"globale mutabile in C++.\n"
+"* Non è molto comune che si abbia bisogno di una costante valutata in fase "
+"di esecuzione, ma è utile e più sicura rispetto all'utilizzo di una statica."
#: src/basic-syntax/scopes-shadowing.md:1
msgid "# Scopes and Shadowing"
@@ -3823,10 +4289,12 @@ msgstr "# Scopes (Ambiti) e Shadowing"
#: src/basic-syntax/scopes-shadowing.md:3
#, fuzzy
msgid ""
-"You can shadow variables, both those from outer scopes and variables from the\n"
+"You can shadow variables, both those from outer scopes and variables from "
+"the\n"
"same scope:"
msgstr ""
-"Puoi ombreggiare le variabili, sia quelle degli ambiti esterni che le variabili del file\n"
+"Puoi ombreggiare le variabili, sia quelle degli ambiti esterni che le "
+"variabili del file\n"
"stessa portata:"
#: src/basic-syntax/scopes-shadowing.md:6
@@ -3852,22 +4320,26 @@ msgstr ""
#: src/basic-syntax/scopes-shadowing.md:25
#, fuzzy
msgid ""
-"* Definition: Shadowing is different from mutation, because after shadowing both variable's memory "
-"locations exist at the same time. Both are available under the same name, depending where you use "
-"it in the code. \n"
+"* Definition: Shadowing is different from mutation, because after shadowing "
+"both variable's memory locations exist at the same time. Both are available "
+"under the same name, depending where you use it in the code. \n"
"* A shadowing variable can have a different type. \n"
-"* Shadowing looks obscure at first, but is convenient for holding on to values after `.unwrap()`.\n"
-"* The following code demonstrates why the compiler can't simply reuse memory locations when "
-"shadowing an immutable variable in a scope, even if the type does not change."
+"* Shadowing looks obscure at first, but is convenient for holding on to "
+"values after `.unwrap()`.\n"
+"* The following code demonstrates why the compiler can't simply reuse memory "
+"locations when shadowing an immutable variable in a scope, even if the type "
+"does not change."
msgstr ""
-"* Definizione: l'ombreggiatura è diversa dalla mutazione, perché dopo l'ombreggiatura le locazioni "
-"di memoria di entrambe le variabili esistono contemporaneamente. Entrambi sono disponibili con lo "
-"stesso nome, a seconda di dove lo usi nel codice.\n"
+"* Definizione: l'ombreggiatura è diversa dalla mutazione, perché dopo "
+"l'ombreggiatura le locazioni di memoria di entrambe le variabili esistono "
+"contemporaneamente. Entrambi sono disponibili con lo stesso nome, a seconda "
+"di dove lo usi nel codice.\n"
"* Una variabile di ombreggiatura può avere un tipo diverso.\n"
-"* L'ombreggiatura all'inizio sembra oscura, ma è utile per conservare i valori dopo `.unwrap()`.\n"
-"* Il codice seguente dimostra perché il compilatore non può semplicemente riutilizzare le "
-"posizioni di memoria durante lo shadowing di una variabile immutabile in un ambito, anche se il "
-"tipo non cambia."
+"* L'ombreggiatura all'inizio sembra oscura, ma è utile per conservare i "
+"valori dopo `.unwrap()`.\n"
+"* Il codice seguente dimostra perché il compilatore non può semplicemente "
+"riutilizzare le posizioni di memoria durante lo shadowing di una variabile "
+"immutabile in un ambito, anche se il tipo non cambia."
#: src/basic-syntax/scopes-shadowing.md:30
msgid ""
@@ -3888,17 +4360,20 @@ msgstr "# Gestione della Memoria"
#: src/memory-management.md:3
#, fuzzy
msgid "Traditionally, languages have fallen into two broad categories:"
-msgstr "Tradizionalmente, le lingue sono state suddivise in due grandi categorie:"
+msgstr ""
+"Tradizionalmente, le lingue sono state suddivise in due grandi categorie:"
#: src/memory-management.md:5
#, fuzzy
msgid ""
"* Full control via manual memory management: C, C++, Pascal, ...\n"
-"* Full safety via automatic memory management at runtime: Java, Python, Go, Haskell, ..."
+"* Full safety via automatic memory management at runtime: Java, Python, Go, "
+"Haskell, ..."
msgstr ""
-"* Controllo completo tramite gestione manuale della memoria: C, C++, Pascal, ...\n"
-"* Piena sicurezza tramite la gestione automatica della memoria in fase di esecuzione: Java, "
-"Python, Go, Haskell, ..."
+"* Controllo completo tramite gestione manuale della memoria: C, C++, "
+"Pascal, ...\n"
+"* Piena sicurezza tramite la gestione automatica della memoria in fase di "
+"esecuzione: Java, Python, Go, Haskell, ..."
#: src/memory-management.md:8
msgid "Rust offers a new mix:"
@@ -3910,8 +4385,8 @@ msgid ""
"> Full control *and* safety via compile time enforcement of correct memory\n"
"> management."
msgstr ""
-"> Pieno controllo *e* sicurezza tramite applicazione in fase di compilazione della memoria "
-"corretta\n"
+"> Pieno controllo *e* sicurezza tramite applicazione in fase di compilazione "
+"della memoria corretta\n"
"> gestione."
#: src/memory-management.md:13
@@ -3921,7 +4396,8 @@ msgstr "Lo fa con un concetto di ownership (proprietà) esplicito."
#: src/memory-management.md:15
#, fuzzy
msgid "First, let's refresh how memory management works."
-msgstr "Innanzitutto, aggiorniamo il funzionamento della gestione della memoria."
+msgstr ""
+"Innanzitutto, aggiorniamo il funzionamento della gestione della memoria."
#: src/memory-management/stack-vs-heap.md:1
msgid "# The Stack vs The Heap"
@@ -3959,11 +4435,12 @@ msgstr "# Memoria sullo Stack"
#: src/memory-management/stack.md:3
#, fuzzy
msgid ""
-"Creating a `String` puts fixed-sized data on the stack and dynamically sized\n"
+"Creating a `String` puts fixed-sized data on the stack and dynamically "
+"sized\n"
"data on the heap:"
msgstr ""
-"La creazione di una `Stringa` mette i dati di dimensioni fisse nello stack e dimensionati "
-"dinamicamente\n"
+"La creazione di una `Stringa` mette i dati di dimensioni fisse nello stack e "
+"dimensionati dinamicamente\n"
"dati sull'heap:"
#: src/memory-management/stack.md:6
@@ -3994,14 +4471,15 @@ msgstr ""
#: src/memory-management/stack.md:28
msgid ""
-"* Mention that a `String` is backed by a `Vec`, so it has a capacity and length and can grow if "
-"mutable via reallocation on the heap.\n"
+"* Mention that a `String` is backed by a `Vec`, so it has a capacity and "
+"length and can grow if mutable via reallocation on the heap.\n"
"\n"
-"* If students ask about it, you can mention that the underlying memory is heap allocated using the "
-"[System Allocator] and custom allocators can be implemented using the [Allocator API]\n"
+"* If students ask about it, you can mention that the underlying memory is "
+"heap allocated using the [System Allocator] and custom allocators can be "
+"implemented using the [Allocator API]\n"
"\n"
-"* We can inspect the memory layout with `unsafe` code. However, you should point out that this is "
-"rightfully unsafe!\n"
+"* We can inspect the memory layout with `unsafe` code. However, you should "
+"point out that this is rightfully unsafe!\n"
"\n"
" ```rust,editable\n"
" fn main() {\n"
@@ -4009,11 +4487,14 @@ msgid ""
" s1.push(' ');\n"
" s1.push_str(\"world\");\n"
" // DON'T DO THIS AT HOME! For educational purposes only.\n"
-" // String provides no guarantees about its layout, so this could lead to\n"
+" // String provides no guarantees about its layout, so this could "
+"lead to\n"
" // undefined behavior.\n"
" unsafe {\n"
-" let (capacity, ptr, len): (usize, usize, usize) = std::mem::transmute(s1);\n"
-" println!(\"ptr = {ptr:#x}, len = {len}, capacity = {capacity}\");\n"
+" let (capacity, ptr, len): (usize, usize, usize) = std::mem::"
+"transmute(s1);\n"
+" println!(\"ptr = {ptr:#x}, len = {len}, capacity = "
+"{capacity}\");\n"
" }\n"
" }\n"
" ```"
@@ -4030,10 +4511,11 @@ msgstr "Allocate e de-allocate voi stessi la memoria dell'heap."
#: src/memory-management/manual.md:5
#, fuzzy
msgid ""
-"If not done with care, this can lead to crashes, bugs, security vulnerabilities, and memory leaks."
+"If not done with care, this can lead to crashes, bugs, security "
+"vulnerabilities, and memory leaks."
msgstr ""
-"Se non fatto con cura, ciò può portare a arresti anomali, bug, vulnerabilità di sicurezza e "
-"perdite di memoria."
+"Se non fatto con cura, ciò può portare a arresti anomali, bug, vulnerabilità "
+"di sicurezza e perdite di memoria."
#: src/memory-management/manual.md:7
msgid "## C Example"
@@ -4048,7 +4530,7 @@ msgstr "Devi chiamare `free` su ogni puntatore allocato con `malloc`:"
msgid ""
"```c\n"
"void foo(size_t n) {\n"
-" int* int_array = (int*)malloc(n * sizeof(int));\n"
+" int* int_array = malloc(n * sizeof(int));\n"
" //\n"
" // ... lots of code\n"
" //\n"
@@ -4060,10 +4542,12 @@ msgstr ""
#: src/memory-management/manual.md:21
#, fuzzy
msgid ""
-"Memory is leaked if the function returns early between `malloc` and `free`: the\n"
+"Memory is leaked if the function returns early between `malloc` and `free`: "
+"the\n"
"pointer is lost and we cannot deallocate the memory."
msgstr ""
-"La memoria viene persa se la funzione ritorna in anticipo tra `malloc` e `free`: the\n"
+"La memoria viene persa se la funzione ritorna in anticipo tra `malloc` e "
+"`free`: the\n"
"puntatore è perso e non possiamo deallocare la memoria."
#: src/memory-management/scope-based.md:1
@@ -4072,27 +4556,35 @@ msgstr "# Gestione della memoria basata sullo Scope (ambito)"
#: src/memory-management/scope-based.md:3
#, fuzzy
-msgid "Constructors and destructors let you hook into the lifetime of an object."
-msgstr "Costruttori e distruttori ti consentono di agganciarti alla vita di un oggetto."
+msgid ""
+"Constructors and destructors let you hook into the lifetime of an object."
+msgstr ""
+"Costruttori e distruttori ti consentono di agganciarti alla vita di un "
+"oggetto."
#: src/memory-management/scope-based.md:5
#, fuzzy
msgid ""
"By wrapping a pointer in an object, you can free memory when the object is\n"
-"destroyed. The compiler guarantees that this happens, even if an exception is\n"
+"destroyed. The compiler guarantees that this happens, even if an exception "
+"is\n"
"raised."
msgstr ""
-"Avvolgendo un puntatore in un oggetto, puoi liberare memoria quando l'oggetto è\n"
-"distrutto. Il compilatore garantisce che ciò accada, anche se lo è un'eccezione\n"
+"Avvolgendo un puntatore in un oggetto, puoi liberare memoria quando "
+"l'oggetto è\n"
+"distrutto. Il compilatore garantisce che ciò accada, anche se lo è "
+"un'eccezione\n"
"sollevato."
#: src/memory-management/scope-based.md:9
#, fuzzy
msgid ""
-"This is often called _resource acquisition is initialization_ (RAII) and gives\n"
+"This is often called _resource acquisition is initialization_ (RAII) and "
+"gives\n"
"you smart pointers."
msgstr ""
-"Questo è spesso chiamato _l'acquisizione delle risorse è l'inizializzazione_ (RAII) e dà\n"
+"Questo è spesso chiamato _l'acquisizione delle risorse è l'inizializzazione_ "
+"(RAII) e dà\n"
"puntatori intelligenti."
#: src/memory-management/scope-based.md:12
@@ -4118,14 +4610,17 @@ msgid ""
msgstr ""
"* L'oggetto `std::unique_ptr` è allocato nello stack e punta a\n"
" memoria allocata nell'heap.\n"
-"* Alla fine di `say_hello`, verrà eseguito il distruttore `std::unique_ptr`.\n"
+"* Alla fine di `say_hello`, verrà eseguito il distruttore `std::"
+"unique_ptr`.\n"
"* Il distruttore libera l'oggetto `Person` a cui punta."
#: src/memory-management/scope-based.md:25
#, fuzzy
-msgid "Special move constructors are used when passing ownership to a function:"
+msgid ""
+"Special move constructors are used when passing ownership to a function:"
msgstr ""
-"I costruttori di mosse speciali vengono utilizzati quando si passa la proprietà a una funzione:"
+"I costruttori di mosse speciali vengono utilizzati quando si passa la "
+"proprietà a una funzione:"
#: src/memory-management/scope-based.md:27
msgid ""
@@ -4142,20 +4637,24 @@ msgstr "# Gestione automatica della Memoria"
#: src/memory-management/garbage-collection.md:3
#, fuzzy
msgid ""
-"An alternative to manual and scope-based memory management is automatic memory\n"
+"An alternative to manual and scope-based memory management is automatic "
+"memory\n"
"management:"
msgstr ""
-"Un'alternativa alla gestione della memoria manuale e basata sull'ambito è la memoria automatica\n"
+"Un'alternativa alla gestione della memoria manuale e basata sull'ambito è la "
+"memoria automatica\n"
"gestione:"
#: src/memory-management/garbage-collection.md:6
#, fuzzy
msgid ""
"* The programmer never allocates or deallocates memory explicitly.\n"
-"* A garbage collector finds unused memory and deallocates it for the programmer."
+"* A garbage collector finds unused memory and deallocates it for the "
+"programmer."
msgstr ""
"* Il programmatore non alloca o dealloca mai la memoria in modo esplicito.\n"
-"* Un Garbage Collector trova la memoria inutilizzata e la dealloca per il programmatore."
+"* Un Garbage Collector trova la memoria inutilizzata e la dealloca per il "
+"programmatore."
#: src/memory-management/garbage-collection.md:9
msgid "## Java Example"
@@ -4164,7 +4663,8 @@ msgstr "## Esempio Java"
#: src/memory-management/garbage-collection.md:11
#, fuzzy
msgid "The `person` object is not deallocated after `sayHello` returns:"
-msgstr "L'oggetto `person` non viene deallocato dopo che `sayHello` restituisce:"
+msgstr ""
+"L'oggetto `person` non viene deallocato dopo che `sayHello` restituisce:"
#: src/memory-management/garbage-collection.md:13
msgid ""
@@ -4187,38 +4687,44 @@ msgstr "La gestione della memoria in Rust è un mix:"
#, fuzzy
msgid ""
"* Safe and correct like Java, but without a garbage collector.\n"
-"* Depending on which abstraction (or combination of abstractions) you choose, can be a single "
-"unique pointer, reference counted, or atomically reference counted.\n"
+"* Depending on which abstraction (or combination of abstractions) you "
+"choose, can be a single unique pointer, reference counted, or atomically "
+"reference counted.\n"
"* Scope-based like C++, but the compiler enforces full adherence.\n"
-"* A Rust user can choose the right abstraction for the situation, some even have no cost at "
-"runtime like C."
+"* A Rust user can choose the right abstraction for the situation, some even "
+"have no cost at runtime like C."
msgstr ""
"* Sicuro e corretto come Java, ma senza un garbage collector.\n"
-"* A seconda dell'astrazione (o combinazione di astrazioni) scelta, può trattarsi di un singolo "
-"puntatore univoco, del conteggio dei riferimenti o del conteggio dei riferimenti atomici.\n"
+"* A seconda dell'astrazione (o combinazione di astrazioni) scelta, può "
+"trattarsi di un singolo puntatore univoco, del conteggio dei riferimenti o "
+"del conteggio dei riferimenti atomici.\n"
"* Basato sull'ambito come C++, ma il compilatore applica la piena aderenza.\n"
-"* Un utente Rust può scegliere l'astrazione giusta per la situazione, alcuni addirittura non hanno "
-"alcun costo in fase di esecuzione come C."
+"* Un utente Rust può scegliere l'astrazione giusta per la situazione, alcuni "
+"addirittura non hanno alcun costo in fase di esecuzione come C."
#: src/memory-management/rust.md:10
#, fuzzy
-msgid "It achieves this by modeling _ownership_ explicitly."
+msgid "Rust achieves this by modeling _ownership_ explicitly."
msgstr "Raggiunge questo modellando _ownership_ in modo esplicito."
#: src/memory-management/rust.md:14
#, fuzzy
msgid ""
-"* If asked how at this point, you can mention that in Rust this is usually handled by RAII wrapper "
-"types such as [Box], [Vec], [Rc], or [Arc]. These encapsulate ownership and memory allocation via "
-"various means, and prevent the potential errors in C.\n"
+"* If asked how at this point, you can mention that in Rust this is usually "
+"handled by RAII wrapper types such as [Box], [Vec], [Rc], or [Arc]. These "
+"encapsulate ownership and memory allocation via various means, and prevent "
+"the potential errors in C.\n"
"\n"
-"* You may be asked about destructors here, the [Drop] trait is the Rust equivalent."
+"* You may be asked about destructors here, the [Drop] trait is the Rust "
+"equivalent."
msgstr ""
-"* Se ti viene chiesto come a questo punto, puoi menzionare che in Rust questo è solitamente "
-"gestito da tipi di wrapper RAII come [Box], [Vec], [Rc] o [Arc]. Questi incapsulano la proprietà e "
-"l'allocazione della memoria tramite vari mezzi e prevengono i potenziali errori in C.\n"
+"* Se ti viene chiesto come a questo punto, puoi menzionare che in Rust "
+"questo è solitamente gestito da tipi di wrapper RAII come [Box], [Vec], [Rc] "
+"o [Arc]. Questi incapsulano la proprietà e l'allocazione della memoria "
+"tramite vari mezzi e prevengono i potenziali errori in C.\n"
"\n"
-"* Qui ti potrebbe essere chiesto dei distruttori, il tratto [Drop] è l'equivalente di Rust."
+"* Qui ti potrebbe essere chiesto dei distruttori, il tratto [Drop] è "
+"l'equivalente di Rust."
#: src/memory-management/comparison.md:1
msgid "# Comparison"
@@ -4227,7 +4733,8 @@ msgstr "# Confronto"
#: src/memory-management/comparison.md:3
#, fuzzy
msgid "Here is a rough comparison of the memory management techniques."
-msgstr "Ecco un confronto approssimativo delle tecniche di gestione della memoria."
+msgstr ""
+"Ecco un confronto approssimativo delle tecniche di gestione della memoria."
#: src/memory-management/comparison.md:5
msgid "## Pros of Different Memory Management Techniques"
@@ -4305,10 +4812,12 @@ msgstr "# Ownership (Proprietà)"
#: src/ownership.md:3
#, fuzzy
msgid ""
-"All variable bindings have a _scope_ where they are valid and it is an error to\n"
+"All variable bindings have a _scope_ where they are valid and it is an error "
+"to\n"
"use a variable outside its scope:"
msgstr ""
-"Tutte le associazioni di variabili hanno un _scope_ in cui sono valide ed è un errore\n"
+"Tutte le associazioni di variabili hanno un _scope_ in cui sono valide ed è "
+"un errore\n"
"usa una variabile al di fuori del suo ambito:"
#: src/ownership.md:6
@@ -4333,7 +4842,8 @@ msgid ""
"* A destructor can run here to free up resources.\n"
"* We say that the variable _owns_ the value."
msgstr ""
-"* Alla fine dell'ambito, la variabile viene _eliminata_ ei dati vengono liberati.\n"
+"* Alla fine dell'ambito, la variabile viene _eliminata_ ei dati vengono "
+"liberati.\n"
"* Un distruttore può essere eseguito qui per liberare risorse.\n"
"* Diciamo che la variabile _possiede_ il valore."
@@ -4376,13 +4886,14 @@ msgstr ""
#: src/ownership/move-semantics.md:22
#, fuzzy
msgid ""
-"* Mention that this is the opposite of the defaults in C++, which copies by value unless you use "
-"`std::move` (and the move constructor is defined!).\n"
+"* Mention that this is the opposite of the defaults in C++, which copies by "
+"value unless you use `std::move` (and the move constructor is defined!).\n"
"\n"
"* In Rust, clones are explicit (by using `clone`)."
msgstr ""
-"* Menziona che questo è l'opposto dei valori predefiniti in C++, che copia per valore a meno che "
-"tu non usi `std::move` (e il costruttore di movimento è definito!).\n"
+"* Menziona che questo è l'opposto dei valori predefiniti in C++, che copia "
+"per valore a meno che tu non usi `std::move` (e il costruttore di movimento "
+"è definito!).\n"
"\n"
"* In Rust, i cloni sono espliciti (utilizzando `clone`)."
@@ -4478,10 +4989,12 @@ msgstr ""
#: src/ownership/double-free-modern-cpp.md:10
#, fuzzy
msgid ""
-"* The heap data from `s1` is duplicated and `s2` gets its own independent copy.\n"
+"* The heap data from `s1` is duplicated and `s2` gets its own independent "
+"copy.\n"
"* When `s1` and `s2` go out of scope, they each free their own memory."
msgstr ""
-"* I dati dell'heap da `s1` vengono duplicati e `s2` ottiene la propria copia indipendente.\n"
+"* I dati dell'heap da `s1` vengono duplicati e `s2` ottiene la propria copia "
+"indipendente.\n"
"* Quando `s1` e `s2` escono dall'ambito, ciascuno libera la propria memoria."
#: src/ownership/double-free-modern-cpp.md:13
@@ -4544,7 +5057,8 @@ msgid ""
"When you pass a value to a function, the value is assigned to the function\n"
"parameter. This transfers ownership:"
msgstr ""
-"Quando si passa un valore a una funzione, il valore viene assegnato alla funzione\n"
+"Quando si passa un valore a una funzione, il valore viene assegnato alla "
+"funzione\n"
"parametro. Questo trasferisce la proprietà:"
#: src/ownership/moves-function-calls.md:6
@@ -4565,23 +5079,30 @@ msgstr ""
#: src/ownership/moves-function-calls.md:20
#, fuzzy
msgid ""
-"* With the first call to `say_hello`, `main` gives up ownership of `name`. Afterwards, `name` "
-"cannot be used anymore within `main`.\n"
-"* The heap memory allocated for `name` will be freed at the end of the `say_hello` function.\n"
-"* `main` can retain ownership if it passes `name` as a reference (`&name`) and if `say_hello` "
-"accepts a reference as a parameter.\n"
-"* Alternatively, `main` can pass a clone of `name` in the first call (`name.clone()`).\n"
-"* Rust makes it harder than C++ to inadvertently create copies by making move semantics the "
-"default, and by forcing programmers to make clones explicit."
+"* With the first call to `say_hello`, `main` gives up ownership of `name`. "
+"Afterwards, `name` cannot be used anymore within `main`.\n"
+"* The heap memory allocated for `name` will be freed at the end of the "
+"`say_hello` function.\n"
+"* `main` can retain ownership if it passes `name` as a reference (`&name`) "
+"and if `say_hello` accepts a reference as a parameter.\n"
+"* Alternatively, `main` can pass a clone of `name` in the first call (`name."
+"clone()`).\n"
+"* Rust makes it harder than C++ to inadvertently create copies by making "
+"move semantics the default, and by forcing programmers to make clones "
+"explicit."
msgstr ""
-"* Con la prima chiamata a `say_hello`, `main` rinuncia alla proprietà di `name`. Successivamente, "
-"`name` non può più essere utilizzato all'interno di `main`.\n"
-"* La memoria heap allocata per `name` verrà liberata alla fine della funzione `say_hello`.\n"
-"* `main` può mantenere la proprietà se passa `name` come riferimento (`&name`) e se `say_hello` "
-"accetta un riferimento come parametro.\n"
-"* In alternativa, `main` può passare un clone di `name` nella prima chiamata (`name.clone()`).\n"
-"* Rust rende più difficile del C++ creare copie inavvertitamente rendendo la semantica di "
-"spostamento l'impostazione predefinita e costringendo i programmatori a rendere espliciti i cloni."
+"* Con la prima chiamata a `say_hello`, `main` rinuncia alla proprietà di "
+"`name`. Successivamente, `name` non può più essere utilizzato all'interno di "
+"`main`.\n"
+"* La memoria heap allocata per `name` verrà liberata alla fine della "
+"funzione `say_hello`.\n"
+"* `main` può mantenere la proprietà se passa `name` come riferimento "
+"(`&name`) e se `say_hello` accetta un riferimento come parametro.\n"
+"* In alternativa, `main` può passare un clone di `name` nella prima chiamata "
+"(`name.clone()`).\n"
+"* Rust rende più difficile del C++ creare copie inavvertitamente rendendo la "
+"semantica di spostamento l'impostazione predefinita e costringendo i "
+"programmatori a rendere espliciti i cloni."
#: src/ownership/copy-clone.md:1
#, fuzzy
@@ -4590,10 +5111,11 @@ msgstr "# Copia e clonazione"
#: src/ownership/copy-clone.md:3
#, fuzzy
-msgid "While move semantics are the default, certain types are copied by default:"
+msgid ""
+"While move semantics are the default, certain types are copied by default:"
msgstr ""
-"Sebbene la semantica di spostamento sia l'impostazione predefinita, alcuni tipi vengono copiati "
-"per impostazione predefinita:"
+"Sebbene la semantica di spostamento sia l'impostazione predefinita, alcuni "
+"tipi vengono copiati per impostazione predefinita:"
#: src/ownership/copy-clone.md:5
msgid ""
@@ -4615,7 +5137,9 @@ msgstr "Questi tipi implementano il tratto `Copy`."
#: src/ownership/copy-clone.md:16
#, fuzzy
msgid "You can opt-in your own types to use copy semantics:"
-msgstr "Puoi acconsentire esplicitamente ai tuoi tipi per utilizzare la semantica della copia:"
+msgstr ""
+"Puoi acconsentire esplicitamente ai tuoi tipi per utilizzare la semantica "
+"della copia:"
#: src/ownership/copy-clone.md:18
msgid ""
@@ -4649,17 +5173,20 @@ msgstr "Copiare e clonare non sono la stessa cosa:"
#: src/ownership/copy-clone.md:37
#, fuzzy
msgid ""
-"* Copying refers to bitwise copies of memory regions and does not work on arbitrary objects.\n"
-"* Copying does not allow for custom logic (unlike copy constructors in C++).\n"
-"* Cloning is a more general operation and also allows for custom behavior by implementing the "
-"`Clone` trait.\n"
+"* Copying refers to bitwise copies of memory regions and does not work on "
+"arbitrary objects.\n"
+"* Copying does not allow for custom logic (unlike copy constructors in C+"
+"+).\n"
+"* Cloning is a more general operation and also allows for custom behavior by "
+"implementing the `Clone` trait.\n"
"* Copying does not work on types that implement the `Drop` trait."
msgstr ""
-"* La copia si riferisce a copie bit per bit di aree di memoria e non funziona su oggetti "
-"arbitrari.\n"
-"* La copia non consente la logica personalizzata (a differenza dei costruttori di copia in C++).\n"
-"* La clonazione è un'operazione più generale e consente anche un comportamento personalizzato "
-"implementando il tratto `Clone`.\n"
+"* La copia si riferisce a copie bit per bit di aree di memoria e non "
+"funziona su oggetti arbitrari.\n"
+"* La copia non consente la logica personalizzata (a differenza dei "
+"costruttori di copia in C++).\n"
+"* La clonazione è un'operazione più generale e consente anche un "
+"comportamento personalizzato implementando il tratto `Clone`.\n"
"* La copia non funziona sui tipi che implementano il tratto `Drop`."
#: src/ownership/copy-clone.md:42 src/ownership/lifetimes-function-calls.md:29
@@ -4670,29 +5197,30 @@ msgstr "Nell'esempio precedente, prova quanto segue:"
#: src/ownership/copy-clone.md:44
#, fuzzy
msgid ""
-"* Add a `String` field to `struct Point`. It will not compile because `String` is not a `Copy` "
-"type.\n"
-"* Remove `Copy` from the `derive` attribute. The compiler error is now in the `println!` for "
-"`p1`.\n"
+"* Add a `String` field to `struct Point`. It will not compile because "
+"`String` is not a `Copy` type.\n"
+"* Remove `Copy` from the `derive` attribute. The compiler error is now in "
+"the `println!` for `p1`.\n"
"* Show that it works if you clone `p1` instead."
msgstr ""
-"* Aggiungi un campo `String` a `struct Point`. Non verrà compilato perché `String` non è un tipo "
-"`Copy`.\n"
-"* Rimuovi `Copy` dall'attributo `derive`. L'errore del compilatore è ora in `println!` per `p1`.\n"
+"* Aggiungi un campo `String` a `struct Point`. Non verrà compilato perché "
+"`String` non è un tipo `Copy`.\n"
+"* Rimuovi `Copy` dall'attributo `derive`. L'errore del compilatore è ora in "
+"`println!` per `p1`.\n"
"* Dimostra che funziona se invece cloni `p1`."
#: src/ownership/copy-clone.md:48
#, fuzzy
msgid ""
-"If students ask about `derive`, it is sufficient to say that this is a way to generate code in "
-"Rust\n"
-"at compile time. In this case the default implementations of `Copy` and `Clone` traits are "
-"generated."
+"If students ask about `derive`, it is sufficient to say that this is a way "
+"to generate code in Rust\n"
+"at compile time. In this case the default implementations of `Copy` and "
+"`Clone` traits are generated."
msgstr ""
-"Se gli studenti chiedono informazioni su `derive`, è sufficiente dire che questo è un modo per "
-"generare codice in Rust\n"
-"in fase di compilazione. In questo caso vengono generate le implementazioni predefinite dei tratti "
-"`Copy` e `Clone`."
+"Se gli studenti chiedono informazioni su `derive`, è sufficiente dire che "
+"questo è un modo per generare codice in Rust\n"
+"in fase di compilazione. In questo caso vengono generate le implementazioni "
+"predefinite dei tratti `Copy` e `Clone`."
#: src/ownership/borrowing.md:1
#, fuzzy
@@ -4705,7 +5233,8 @@ msgid ""
"Instead of transferring ownership when calling a function, you can let a\n"
"function _borrow_ the value:"
msgstr ""
-"Invece di trasferire la proprietà quando chiami una funzione, puoi lasciare che a\n"
+"Invece di trasferire la proprietà quando chiami una funzione, puoi lasciare "
+"che a\n"
"funzione _prende in prestito_ il valore:"
#: src/ownership/borrowing.md:6
@@ -4733,7 +5262,8 @@ msgid ""
"* The `add` function _borrows_ two points and returns a new point.\n"
"* The caller retains ownership of the inputs."
msgstr ""
-"* La funzione `add` _prende in prestito_ due punti e restituisce un nuovo punto.\n"
+"* La funzione `add` _prende in prestito_ due punti e restituisce un nuovo "
+"punto.\n"
"* Il chiamante mantiene la proprietà degli ingressi."
#: src/ownership/borrowing.md:27
@@ -4743,10 +5273,11 @@ msgstr "Note sui resi dello stack:"
#: src/ownership/borrowing.md:28
msgid ""
-"* Demonstrate that the return from `add` is cheap because the compiler can eliminate the copy "
-"operation. Change the above code to print stack addresses and run it on the [Playground]. In the "
-"\"DEBUG\" optimization level, the addresses should change, while they stay the same when changing "
-"to the \"RELEASE\" setting:\n"
+"* Demonstrate that the return from `add` is cheap because the compiler can "
+"eliminate the copy operation. Change the above code to print stack addresses "
+"and run it on the [Playground]. In the \"DEBUG\" optimization level, the "
+"addresses should change, while they stay the same when changing to the "
+"\"RELEASE\" setting:\n"
"\n"
" ```rust,editable\n"
" #[derive(Debug)]\n"
@@ -4767,9 +5298,10 @@ msgid ""
" }\n"
" ```\n"
"* The Rust compiler can do return value optimization (RVO).\n"
-"* In C++, copy elision has to be defined in the language specification because constructors can "
-"have side effects. In Rust, this is not an issue at all. If RVO did not happen, Rust will always "
-"performs a simple and efficient `memcpy` copy."
+"* In C++, copy elision has to be defined in the language specification "
+"because constructors can have side effects. In Rust, this is not an issue at "
+"all. If RVO did not happen, Rust will always perform a simple and efficient "
+"`memcpy` copy."
msgstr ""
#: src/ownership/shared-unique-borrows.md:1
@@ -4780,7 +5312,8 @@ msgstr "# Prestiti condivisi e unici"
#: src/ownership/shared-unique-borrows.md:3
#, fuzzy
msgid "Rust puts constraints on the ways you can borrow values:"
-msgstr "Rust pone dei vincoli sui modi in cui puoi prendere in prestito i valori:"
+msgstr ""
+"Rust pone dei vincoli sui modi in cui puoi prendere in prestito i valori:"
#: src/ownership/shared-unique-borrows.md:5
#, fuzzy
@@ -4812,21 +5345,22 @@ msgstr ""
#: src/ownership/shared-unique-borrows.md:25
#, fuzzy
msgid ""
-"* The above code does not compile because `a` is borrowed as mutable (through `c`) and as "
-"immutable (through `b`) at the same time.\n"
-"* Move the `println!` statement for `b` before the scope that introduces `c` to make the code "
-"compile.\n"
-"* After that change, the compiler realizes that `b` is only ever used before the new mutable "
-"borrow of `a` through `c`. This is a feature of the borrow checker called \"non-lexical "
-"lifetimes\"."
+"* The above code does not compile because `a` is borrowed as mutable "
+"(through `c`) and as immutable (through `b`) at the same time.\n"
+"* Move the `println!` statement for `b` before the scope that introduces `c` "
+"to make the code compile.\n"
+"* After that change, the compiler realizes that `b` is only ever used before "
+"the new mutable borrow of `a` through `c`. This is a feature of the borrow "
+"checker called \"non-lexical lifetimes\"."
msgstr ""
-"* Il codice precedente non viene compilato perché `a` è preso in prestito come mutabile "
-"(attraverso `c`) e come immutabile (attraverso `b`) allo stesso tempo.\n"
-"* Sposta l'istruzione `println!` per `b` prima dell'ambito che introduce `c` per far compilare il "
-"codice.\n"
-"* Dopo tale modifica, il compilatore si rende conto che `b` è sempre e solo usato prima del nuovo "
-"prestito mutabile da `a` a `c`. Questa è una caratteristica del controllo del prestito chiamata "
-"\"vita non lessicale\"."
+"* Il codice precedente non viene compilato perché `a` è preso in prestito "
+"come mutabile (attraverso `c`) e come immutabile (attraverso `b`) allo "
+"stesso tempo.\n"
+"* Sposta l'istruzione `println!` per `b` prima dell'ambito che introduce `c` "
+"per far compilare il codice.\n"
+"* Dopo tale modifica, il compilatore si rende conto che `b` è sempre e solo "
+"usato prima del nuovo prestito mutabile da `a` a `c`. Questa è una "
+"caratteristica del controllo del prestito chiamata \"vita non lessicale\"."
#: src/ownership/lifetimes.md:1
#, fuzzy
@@ -4840,14 +5374,20 @@ msgstr "Un valore preso in prestito ha una _durata_:"
#: src/ownership/lifetimes.md:5
msgid ""
-"* The lifetime can be elided: `add(p1: &Point, p2: &Point) -> Point`.\n"
+"* The lifetime can be implicit: `add(p1: &Point, p2: &Point) -> Point`.\n"
"* Lifetimes can also be explicit: `&'a Point`, `&'document str`.\n"
"* Read `&'a Point` as \"a borrowed `Point` which is valid for at least the\n"
" lifetime `a`\".\n"
-"* Lifetimes are always inferred by the compiler: you cannot assign a lifetime\n"
+"* Lifetimes are always inferred by the compiler: you cannot assign a "
+"lifetime\n"
" yourself.\n"
-" * Lifetime annotations create constraints; the compiler verifies that there is\n"
-" a valid solution."
+" * Lifetime annotations create constraints; the compiler verifies that "
+"there is\n"
+" a valid solution.\n"
+"* Lifetimes for function arguments and return values must be fully "
+"specified,\n"
+" but Rust allows lifetimes to be elided in most cases with [a few simple\n"
+" rules](https://doc.rust-lang.org/nomicon/lifetime-elision.html)."
msgstr ""
#: src/ownership/lifetimes-function-calls.md:1
@@ -4857,10 +5397,12 @@ msgstr "# Durata delle chiamate di funzione"
#: src/ownership/lifetimes-function-calls.md:3
#, fuzzy
-msgid "In addition to borrowing its arguments, a function can return a borrowed value:"
+msgid ""
+"In addition to borrowing its arguments, a function can return a borrowed "
+"value:"
msgstr ""
-"Oltre a prendere in prestito i suoi argomenti, una funzione può restituire un valore preso in "
-"prestito:"
+"Oltre a prendere in prestito i suoi argomenti, una funzione può restituire "
+"un valore preso in prestito:"
#: src/ownership/lifetimes-function-calls.md:5
msgid ""
@@ -4892,14 +5434,16 @@ msgid ""
msgstr ""
"* `'a` è un parametro generico, viene dedotto dal compilatore.\n"
"* Le durate iniziano con `'` e `'a` è un tipico nome predefinito.\n"
-"* Leggi `&'a Point` come \"un `Punto` preso in prestito che è valido almeno per il\n"
+"* Leggi `&'a Point` come \"un `Punto` preso in prestito che è valido almeno "
+"per il\n"
" vita `a`\".\n"
-" * La parte _almeno_ è importante quando i parametri si trovano in ambiti diversi."
+" * La parte _almeno_ è importante quando i parametri si trovano in ambiti "
+"diversi."
#: src/ownership/lifetimes-function-calls.md:31
msgid ""
-"* Move the declaration of `p2` and `p3` into a a new scope (`{ ... }`), resulting in the following "
-"code:\n"
+"* Move the declaration of `p2` and `p3` into a new scope (`{ ... }`), "
+"resulting in the following code:\n"
" ```rust,ignore\n"
" #[derive(Debug)]\n"
" struct Point(i32, i32);\n"
@@ -4920,15 +5464,17 @@ msgid ""
" ```\n"
" Note how this does not compile since `p3` outlives `p2`.\n"
"\n"
-"* Reset the workspace and change the function signature to `fn left_most<'a, 'b>(p1: &'a Point, "
-"p2: &'a Point) -> &'b Point`. This will not compile because the relationship between the lifetimes "
-"`'a` and `'b` is unclear.\n"
+"* Reset the workspace and change the function signature to `fn left_most<'a, "
+"'b>(p1: &'a Point, p2: &'a Point) -> &'b Point`. This will not compile "
+"because the relationship between the lifetimes `'a` and `'b` is unclear.\n"
"* Another way to explain it:\n"
-" * Two references to two values are borrowed by a function and the function returns\n"
+" * Two references to two values are borrowed by a function and the function "
+"returns\n"
" another reference.\n"
-" * It must have come from one of those two inputs (or from a global variable).\n"
-" * Which one is it? The compiler needs to to know, so at the call site the returned reference is "
-"not used\n"
+" * It must have come from one of those two inputs (or from a global "
+"variable).\n"
+" * Which one is it? The compiler needs to know, so at the call site the "
+"returned reference is not used\n"
" for longer than a variable from where the reference came from."
msgstr ""
@@ -4939,8 +5485,11 @@ msgstr "# Durata nelle strutture dati"
#: src/ownership/lifetimes-data-structures.md:3
#, fuzzy
-msgid "If a data type stores borrowed data, it must be annotated with a lifetime:"
-msgstr "Se un tipo di dati memorizza dati presi in prestito, deve essere annotato con una durata:"
+msgid ""
+"If a data type stores borrowed data, it must be annotated with a lifetime:"
+msgstr ""
+"Se un tipo di dati memorizza dati presi in prestito, deve essere annotato "
+"con una durata:"
#: src/ownership/lifetimes-data-structures.md:5
msgid ""
@@ -4953,7 +5502,8 @@ msgid ""
"}\n"
"\n"
"fn main() {\n"
-" let text = String::from(\"The quick brown fox jumps over the lazy dog.\");\n"
+" let text = String::from(\"The quick brown fox jumps over the lazy dog."
+"\");\n"
" let fox = Highlight(&text[4..19]);\n"
" let dog = Highlight(&text[35..43]);\n"
" // erase(text);\n"
@@ -4966,27 +5516,34 @@ msgstr ""
#: src/ownership/lifetimes-data-structures.md:25
#, fuzzy
msgid ""
-"* In the above example, the annotation on `Highlight` enforces that the data underlying the "
-"contained `&str` lives at least as long as any instance of `Highlight` that uses that data.\n"
-"* If `text` is consumed before the end of the lifetime of `fox` (or `dog`), the borrow checker "
-"throws an error.\n"
-"* Types with borrowed data force users to hold on to the original data. This can be useful for "
-"creating lightweight views, but it generally makes them somewhat harder to use.\n"
+"* In the above example, the annotation on `Highlight` enforces that the data "
+"underlying the contained `&str` lives at least as long as any instance of "
+"`Highlight` that uses that data.\n"
+"* If `text` is consumed before the end of the lifetime of `fox` (or `dog`), "
+"the borrow checker throws an error.\n"
+"* Types with borrowed data force users to hold on to the original data. This "
+"can be useful for creating lightweight views, but it generally makes them "
+"somewhat harder to use.\n"
"* When possible, make data structures own their data directly.\n"
-"* Some structs with multiple references inside can have more than one lifetime annotation. This "
-"can be necessary if there is a need to describe lifetime relationships between the references "
-"themselves, in addition to the lifetime of the struct itself. Those are very advanced use cases."
+"* Some structs with multiple references inside can have more than one "
+"lifetime annotation. This can be necessary if there is a need to describe "
+"lifetime relationships between the references themselves, in addition to the "
+"lifetime of the struct itself. Those are very advanced use cases."
msgstr ""
-"* Nell'esempio precedente, l'annotazione su \"Highlight\" impone che i dati sottostanti a \"&str\" "
-"contenuti durino almeno quanto qualsiasi istanza di \"Highlight\" che utilizza quei dati.\n"
-"* Se `text` viene consumato prima della fine della vita di `fox` (o `dog`), il controllo del "
-"prestito genera un errore.\n"
-"* I tipi con dati presi in prestito costringono gli utenti a conservare i dati originali. Questo "
-"può essere utile per creare viste leggere, ma in genere le rende un po' più difficili da usare.\n"
-"* Quando possibile, fare in modo che le strutture dati possiedano direttamente i propri dati.\n"
-"* Alcune strutture con più riferimenti all'interno possono avere più di un'annotazione di durata. "
-"Ciò può essere necessario se è necessario descrivere le relazioni di durata tra i riferimenti "
-"stessi, oltre alla durata della struttura stessa. Questi sono casi d'uso molto avanzati."
+"* Nell'esempio precedente, l'annotazione su \"Highlight\" impone che i dati "
+"sottostanti a \"&str\" contenuti durino almeno quanto qualsiasi istanza di "
+"\"Highlight\" che utilizza quei dati.\n"
+"* Se `text` viene consumato prima della fine della vita di `fox` (o `dog`), "
+"il controllo del prestito genera un errore.\n"
+"* I tipi con dati presi in prestito costringono gli utenti a conservare i "
+"dati originali. Questo può essere utile per creare viste leggere, ma in "
+"genere le rende un po' più difficili da usare.\n"
+"* Quando possibile, fare in modo che le strutture dati possiedano "
+"direttamente i propri dati.\n"
+"* Alcune strutture con più riferimenti all'interno possono avere più di "
+"un'annotazione di durata. Ciò può essere necessario se è necessario "
+"descrivere le relazioni di durata tra i riferimenti stessi, oltre alla "
+"durata della struttura stessa. Questi sono casi d'uso molto avanzati."
#: src/exercises/day-1/afternoon.md:1
#, fuzzy
@@ -5011,16 +5568,18 @@ msgstr ""
#: src/exercises/day-1/book-library.md:1
#, fuzzy
-msgid "# Designing a Library"
-msgstr "# Progettare una libreria"
+msgid "# Storing Books"
+msgstr "# Corda"
#: src/exercises/day-1/book-library.md:3
#, fuzzy
msgid ""
-"We will learn much more about structs and the `Vec` type tomorrow. For now,\n"
+"We will learn much more about structs and the `Vec` type tomorrow. For "
+"now,\n"
"you just need to know part of its API:"
msgstr ""
-"Impareremo molto di più sulle strutture e sul tipo `Vec` domani. Per adesso,\n"
+"Impareremo molto di più sulle strutture e sul tipo `Vec` domani. Per "
+"adesso,\n"
"devi solo conoscere parte della sua API:"
#: src/exercises/day-1/book-library.md:6
@@ -5041,7 +5600,7 @@ msgstr ""
#: src/exercises/day-1/book-library.md:18
#, fuzzy
msgid ""
-"Use this to create a library application. Copy the code below to\n"
+"Use this to model a library's book collection. Copy the code below to\n"
"- `"
msgstr ""
-"Nota che \"IntoIter\" e \"Item\" sono collegati: l'iteratore deve avere lo stesso\n"
+"Nota che \"IntoIter\" e \"Item\" sono collegati: l'iteratore deve avere lo "
+"stesso\n"
"Tipo `Item`, che significa che restituisce `Option
- `"
#: src/exercises/day-1/iterators-and-ownership.md:71
@@ -5282,7 +5857,8 @@ msgstr "Come prima, qual è il tipo restituito dall'iteratore?"
msgid ""
"```rust,editable,compile_fail\n"
"fn main() {\n"
-" let v: Vec
= vec![String::from(\"foo\"), String::from(\"bar\")];\n"
+" let v: Vec = vec![String::from(\"foo\"), String::"
+"from(\"bar\")];\n"
" let mut iter = v.into_iter();\n"
"\n"
" let v0: Option<..> = iter.next();\n"
@@ -5299,11 +5875,13 @@ msgstr "## cicli `for`"
#: src/exercises/day-1/iterators-and-ownership.md:85
#, fuzzy
msgid ""
-"Now that we know both `Iterator` and `IntoIterator`, we can build `for` loops.\n"
+"Now that we know both `Iterator` and `IntoIterator`, we can build `for` "
+"loops.\n"
"They call `into_iter()` on an expression and iterates over the resulting\n"
"iterator:"
msgstr ""
-"Ora che conosciamo sia `Iterator` che `IntoIterator`, possiamo creare cicli `for`.\n"
+"Ora che conosciamo sia `Iterator` che `IntoIterator`, possiamo creare cicli "
+"`for`.\n"
"Chiamano `into_iter()` su un'espressione e itera sul risultato\n"
"iteratore:"
@@ -5311,7 +5889,8 @@ msgstr ""
msgid ""
"```rust,editable\n"
"fn main() {\n"
-" let v: Vec = vec![String::from(\"foo\"), String::from(\"bar\")];\n"
+" let v: Vec = vec![String::from(\"foo\"), String::"
+"from(\"bar\")];\n"
"\n"
" for word in &v {\n"
" println!(\"word: {word}\");\n"
@@ -5332,22 +5911,23 @@ msgstr "Qual è il tipo di \"parola\" in ogni ciclo?"
#: src/exercises/day-1/iterators-and-ownership.md:105
#, fuzzy
msgid ""
-"Experiment with the code above and then consult the documentation for [`impl\n"
+"Experiment with the code above and then consult the documentation for "
+"[`impl\n"
"IntoIterator for\n"
-"&Vec`](https://doc.rust-lang.org/std/vec/struct.Vec.html#impl-IntoIterator-for-"
-"%26%27a%20Vec%3CT%2C%20A%3E)\n"
+"&Vec`](https://doc.rust-lang.org/std/vec/struct.Vec.html#impl-"
+"IntoIterator-for-%26'a+Vec%3CT,+A%3E)\n"
"and [`impl IntoIterator for\n"
-"Vec`](https://doc.rust-lang.org/std/vec/struct.Vec.html#impl-IntoIterator-for-"
-"Vec%3CT%2C%20A%3E)\n"
+"Vec`](https://doc.rust-lang.org/std/vec/struct.Vec.html#impl-IntoIterator-"
+"for-Vec%3CT,+A%3E)\n"
"to check your answers."
msgstr ""
"Sperimenta con il codice sopra e poi consulta la documentazione per [`impl\n"
"IntoIteratore per\n"
-"&Vec`](https://doc.rust-lang.org/std/vec/struct.Vec.html#impl-IntoIterator-for-"
-"%26%27a%20Vec%3CT%2C%20A%3E)\n"
+"&Vec`](https://doc.rust-lang.org/std/vec/struct.Vec.html#impl-"
+"IntoIterator-for-%26%27a%20Vec%3CT%2C%20A%3E)\n"
"e [`impl IntoIterator for\n"
-"Vec`](https://doc.rust-lang.org/std/vec/struct.Vec.html#impl-IntoIterator-for-"
-"Vec%3CT%2C%20A%3E)\n"
+"Vec`](https://doc.rust-lang.org/std/vec/struct.Vec.html#impl-IntoIterator-"
+"for-Vec%3CT%2C%20A%3E)\n"
"per controllare le tue risposte."
#: src/welcome-day-2.md:1
@@ -5358,7 +5938,8 @@ msgstr "# Benvenuto al giorno 2"
#: src/welcome-day-2.md:3
#, fuzzy
msgid "Now that we have seen a fair amount of Rust, we will continue with:"
-msgstr "Ora che abbiamo visto una discreta quantità di ruggine, continueremo con:"
+msgstr ""
+"Ora che abbiamo visto una discreta quantità di ruggine, continueremo con:"
#: src/welcome-day-2.md:5
#, fuzzy
@@ -5367,10 +5948,12 @@ msgid ""
"\n"
"* Pattern matching: destructuring enums, structs, and arrays.\n"
"\n"
-"* Control flow constructs: `if`, `if let`, `while`, `while let`, `break`, and\n"
+"* Control flow constructs: `if`, `if let`, `while`, `while let`, `break`, "
+"and\n"
" `continue`.\n"
"\n"
-"* The Standard Library: `String`, `Option` and `Result`, `Vec`, `HashMap`, `Rc`\n"
+"* The Standard Library: `String`, `Option` and `Result`, `Vec`, `HashMap`, "
+"`Rc`\n"
" and `Arc`.\n"
"\n"
"* Modules: visibility, paths, and filesystem hierarchy."
@@ -5379,10 +5962,12 @@ msgstr ""
"\n"
"* Pattern matching: destrutturazione di enum, struct e array.\n"
"\n"
-"* Costrutti del flusso di controllo: `if`, `if let`, `while`, `while let`, `break` e\n"
+"* Costrutti del flusso di controllo: `if`, `if let`, `while`, `while let`, "
+"`break` e\n"
" `continua`.\n"
"\n"
-"* La libreria standard: `String`, `Option` e `Result`, `Vec`, `HashMap`, `Rc`\n"
+"* La libreria standard: `String`, `Option` e `Result`, `Vec`, `HashMap`, "
+"`Rc`\n"
" e \"Arco\".\n"
"\n"
"* Moduli: visibilità, percorsi e gerarchia del filesystem."
@@ -5424,27 +6009,30 @@ msgid ""
"```"
msgstr ""
-#: src/structs.md:29
+#: src/structs.md:31 src/enums.md:34 src/enums/sizes.md:29 src/methods.md:30
+#: src/methods/example.md:46 src/pattern-matching.md:25
+#: src/pattern-matching/match-guards.md:22 src/control-flow/blocks.md:43
#, fuzzy
-msgid ""
-"
\n"
-"Key Points: "
-msgstr ""
-"\n"
-"Punti chiave:"
+msgid "Key Points:"
+msgstr "Punti chiave:"
-#: src/structs.md:32
+#: src/structs.md:33
msgid ""
"* Structs work like in C or C++.\n"
" * Like in C++, and unlike in C, no typedef is needed to define a type.\n"
" * Unlike in C++, there is no inheritance between structs.\n"
-"* Methods are defined in an `impl` block, which we will see in following slides.\n"
-"* This may be a good time to let people know there are different types of structs. \n"
-" * Zero-sized structs `e.g., struct Foo;` might be used when implementing a trait on some type "
-"but don’t have any data that you want to store in the value itself. \n"
-" * The next slide will introduce Tuple structs, used when the field names are not important.\n"
-"* The syntax `..peter` allows us to copy the majority of the fields from the old struct without "
-"having to explicitly type it all out. It must always be the last element."
+"* Methods are defined in an `impl` block, which we will see in following "
+"slides.\n"
+"* This may be a good time to let people know there are different types of "
+"structs. \n"
+" * Zero-sized structs `e.g., struct Foo;` might be used when implementing a "
+"trait on some type but don’t have any data that you want to store in the "
+"value itself. \n"
+" * The next slide will introduce Tuple structs, used when the field names "
+"are not important.\n"
+"* The syntax `..peter` allows us to copy the majority of the fields from the "
+"old struct without having to explicitly type it all out. It must always be "
+"the last element."
msgstr ""
#: src/structs/tuple-structs.md:1
@@ -5455,7 +6043,9 @@ msgstr "# Strutture di tuple"
#: src/structs/tuple-structs.md:3
#, fuzzy
msgid "If the field names are unimportant, you can use a tuple struct:"
-msgstr "Se i nomi dei campi non sono importanti, puoi utilizzare una struttura di tupla:"
+msgstr ""
+"Se i nomi dei campi non sono importanti, puoi utilizzare una struttura di "
+"tupla:"
#: src/structs/tuple-structs.md:5
msgid ""
@@ -5472,7 +6062,8 @@ msgstr ""
#: src/structs/tuple-structs.md:14
#, fuzzy
msgid "This is often used for single-field wrappers (called newtypes):"
-msgstr "Questo è spesso usato per i wrapper a campo singolo (chiamati newtypes):"
+msgstr ""
+"Questo è spesso usato per i wrapper a campo singolo (chiamati newtypes):"
#: src/structs/tuple-structs.md:16
msgid ""
@@ -5499,26 +6090,30 @@ msgstr ""
#: src/structs/tuple-structs.md:37
#, fuzzy
msgid ""
-"* Newtypes are a great way to encode additional information about the value in a primitive type, "
-"for example:\n"
+"* Newtypes are a great way to encode additional information about the value "
+"in a primitive type, for example:\n"
" * The number is measured in some units: `Newtons` in the example above.\n"
-" * The value passed some validation when it was created, so you no longer have to validate it "
-"again at every use: 'PhoneNumber(String)` or `OddNumber(u32)`.\n"
-"* Demonstrate how to add a `f64` value to a `Newtons` type by accessing the single field in the "
-"newtype.\n"
-" * Rust generally doesn’t like inexplicit things, like automatic unwrapping or for instance "
-"using booleans as integers.\n"
-" * Operator overloading is discussed on Day 3 (generics). "
+" * The value passed some validation when it was created, so you no longer "
+"have to validate it again at every use: 'PhoneNumber(String)` or "
+"`OddNumber(u32)`.\n"
+"* Demonstrate how to add a `f64` value to a `Newtons` type by accessing the "
+"single field in the newtype.\n"
+" * Rust generally doesn’t like inexplicit things, like automatic "
+"unwrapping or for instance using booleans as integers.\n"
+" * Operator overloading is discussed on Day 3 (generics).\n"
+"* The example is a subtle reference to the [Mars Climate Orbiter](https://en."
+"wikipedia.org/wiki/Mars_Climate_Orbiter) failure."
msgstr ""
-"* I newtype sono un ottimo modo per codificare informazioni aggiuntive sul valore in un tipo "
-"primitivo, ad esempio:\n"
+"* I newtype sono un ottimo modo per codificare informazioni aggiuntive sul "
+"valore in un tipo primitivo, ad esempio:\n"
" * Il numero è misurato in alcune unità: `Newton` nell'esempio precedente.\n"
-" * Il valore ha superato una certa convalida quando è stato creato, quindi non è più necessario "
-"convalidarlo nuovamente a ogni utilizzo: 'Numero di telefono (Stringa)` o `Numero dispari (u32)`.\n"
-"* Dimostra come aggiungere un valore `f64` a un tipo `Newtons` accedendo al singolo campo nel "
-"newtype.\n"
-" * A Rust in genere non piacciono le cose inesplicite, come l'unwrapping automatico o, ad "
-"esempio, l'uso di valori booleani come numeri interi.\n"
+" * Il valore ha superato una certa convalida quando è stato creato, quindi "
+"non è più necessario convalidarlo nuovamente a ogni utilizzo: 'Numero di "
+"telefono (Stringa)` o `Numero dispari (u32)`.\n"
+"* Dimostra come aggiungere un valore `f64` a un tipo `Newtons` accedendo al "
+"singolo campo nel newtype.\n"
+" * A Rust in genere non piacciono le cose inesplicite, come l'unwrapping "
+"automatico o, ad esempio, l'uso di valori booleani come numeri interi.\n"
" * Il sovraccarico degli operatori viene discusso il giorno 3 (generici)."
#: src/structs/field-shorthand.md:1
@@ -5559,8 +6154,8 @@ msgstr ""
#: src/structs/field-shorthand.md:27
msgid ""
-"* The `new` function could be written using `Self` as a type, as it is interchangeable with the "
-"struct type name\n"
+"* The `new` function could be written using `Self` as a type, as it is "
+"interchangeable with the struct type name\n"
"\n"
" ```rust,editable\n"
" #[derive(Debug)]\n"
@@ -5574,8 +6169,8 @@ msgid ""
" }\n"
" }\n"
" ``` \n"
-"* Implement the `Default` trait for the struct. Define some fields and use the default values for "
-"the other fields.\n"
+"* Implement the `Default` trait for the struct. Define some fields and use "
+"the default values for the other fields.\n"
"\n"
" ```rust,editable\n"
" #[derive(Debug)]\n"
@@ -5603,8 +6198,8 @@ msgid ""
" ```\n"
"\n"
"* Methods are defined in the `impl` block.\n"
-"* Use struct update syntax to define a new structure using `peter`. Note that the variable `peter` "
-"will no longer be accessible afterwards.\n"
+"* Use struct update syntax to define a new structure using `peter`. Note "
+"that the variable `peter` will no longer be accessible afterwards.\n"
"* Use `{:#?}` when printing structs to request the `Debug` representation."
msgstr ""
@@ -5626,6 +6221,7 @@ msgstr ""
msgid ""
"```rust,editable\n"
"fn generate_random_number() -> i32 {\n"
+" // Implementation based on https://xkcd.com/221/\n"
" 4 // Chosen by fair dice roll. Guaranteed to be random.\n"
"}\n"
"\n"
@@ -5650,34 +6246,32 @@ msgid ""
"```"
msgstr ""
-#: src/enums.md:33 src/enums/sizes.md:29 src/methods.md:30 src/methods/example.md:46
-#: src/pattern-matching.md:25 src/pattern-matching/match-guards.md:22 src/control-flow/blocks.md:42
-#, fuzzy
-msgid "Key Points:"
-msgstr "Punti chiave:"
-
-#: src/enums.md:35
+#: src/enums.md:36
#, fuzzy
msgid ""
"* Enumerations allow you to collect a set of values under one type\n"
-"* This page offers an enum type `CoinFlip` with two variants `Heads` and `Tail`. You might note "
-"the namespace when using variants.\n"
+"* This page offers an enum type `CoinFlip` with two variants `Heads` and "
+"`Tails`. You might note the namespace when using variants.\n"
"* This might be a good time to compare Structs and Enums:\n"
-" * In both, you can have a simple version without fields (unit struct) or one with different "
-"types of fields (variant payloads). \n"
+" * In both, you can have a simple version without fields (unit struct) or "
+"one with different types of fields (variant payloads). \n"
" * In both, associated functions are defined within an `impl` block.\n"
-" * You could even implement the different variants of an enum with separate structs but then they "
-"wouldn’t be the same type as they would if they were all defined in an enum. "
+" * You could even implement the different variants of an enum with separate "
+"structs but then they wouldn’t be the same type as they would if they were "
+"all defined in an enum. "
msgstr ""
-"* Le enumerazioni consentono di raccogliere un insieme di valori in un unico tipo\n"
-"* Questa pagina offre un tipo di enum `CoinFlip` con due varianti `Heads` e `Tail`. Potresti "
-"notare lo spazio dei nomi quando usi le varianti.\n"
+"* Le enumerazioni consentono di raccogliere un insieme di valori in un unico "
+"tipo\n"
+"* Questa pagina offre un tipo di enum `CoinFlip` con due varianti `Heads` e "
+"`Tail`. Potresti notare lo spazio dei nomi quando usi le varianti.\n"
"* Questo potrebbe essere un buon momento per confrontare Struct ed Enum:\n"
-" * In entrambi, puoi avere una versione semplice senza campi (unit struct) o una con diversi tipi "
-"di campi (variant payload).\n"
-" * In entrambi, le funzioni associate sono definite all'interno di un blocco `impl`.\n"
-" * Potresti persino implementare le diverse varianti di un'enumerazione con strutture separate, "
-"ma non sarebbero dello stesso tipo che sarebbero se fossero tutte definite in un'enumerazione."
+" * In entrambi, puoi avere una versione semplice senza campi (unit struct) "
+"o una con diversi tipi di campi (variant payload).\n"
+" * In entrambi, le funzioni associate sono definite all'interno di un "
+"blocco `impl`.\n"
+" * Potresti persino implementare le diverse varianti di un'enumerazione con "
+"strutture separate, ma non sarebbero dello stesso tipo che sarebbero se "
+"fossero tutte definite in un'enumerazione."
#: src/enums/variant-payloads.md:1
#, fuzzy
@@ -5687,11 +6281,12 @@ msgstr "# Payload varianti"
#: src/enums/variant-payloads.md:3
#, fuzzy
msgid ""
-"You can define richer enums where the variants carry data. You can then use the\n"
+"You can define richer enums where the variants carry data. You can then use "
+"the\n"
"`match` statement to extract the data from each variant:"
msgstr ""
-"È possibile definire enumerazioni più ricche in cui le varianti contengono dati. È quindi "
-"possibile utilizzare il\n"
+"È possibile definire enumerazioni più ricche in cui le varianti contengono "
+"dati. È quindi possibile utilizzare il\n"
"istruzione `match` per estrarre i dati da ciascuna variante:"
#: src/enums/variant-payloads.md:6
@@ -5727,41 +6322,49 @@ msgstr ""
#: src/enums/variant-payloads.md:35
#, fuzzy
msgid ""
-"* The values in the enum variants can only be accessed after being pattern matched. The pattern "
-"binds references to the fields in the \"match arm\" after the `=>`.\n"
-" * The expression is matched against the patterns from top to bottom. There is no fall-through "
-"like in C or C++.\n"
-" * The match expression has a value. The value is the last expression in the match arm which was "
-"executed.\n"
-" * Starting from the top we look for what pattern matches the value then run the code following "
-"the arrow. Once we find a match, we stop. \n"
-"* Demonstrate what happens when the search is inexhaustive. Note the advantage the Rust compiler "
-"provides by confirming when all cases are handled. \n"
+"* The values in the enum variants can only be accessed after being pattern "
+"matched. The pattern binds references to the fields in the \"match arm\" "
+"after the `=>`.\n"
+" * The expression is matched against the patterns from top to bottom. There "
+"is no fall-through like in C or C++.\n"
+" * The match expression has a value. The value is the last expression in "
+"the match arm which was executed.\n"
+" * Starting from the top we look for what pattern matches the value then "
+"run the code following the arrow. Once we find a match, we stop. \n"
+"* Demonstrate what happens when the search is inexhaustive. Note the "
+"advantage the Rust compiler provides by confirming when all cases are "
+"handled. \n"
"* `match` inspects a hidden discriminant field in the `enum`.\n"
-"* It is possible to retrieve the discriminant by calling `std::mem::discriminant()`\n"
-" * This is useful, for example, if implementing `PartialEq` for structs where comparing field "
-"values doesn't affect equality.\n"
-"* `WebEvent::Click { ... }` is not exactly the same as `WebEvent::Click(Click)` with a top level "
-"`struct Click { ... }`. The inlined version cannot implement traits, for example. \n"
+"* It is possible to retrieve the discriminant by calling `std::mem::"
+"discriminant()`\n"
+" * This is useful, for example, if implementing `PartialEq` for structs "
+"where comparing field values doesn't affect equality.\n"
+"* `WebEvent::Click { ... }` is not exactly the same as `WebEvent::"
+"Click(Click)` with a top level `struct Click { ... }`. The inlined version "
+"cannot implement traits, for example. \n"
" "
msgstr ""
-"* È possibile accedere ai valori nelle varianti enum solo dopo essere stati abbinati al modello. "
-"Il modello lega i riferimenti ai campi nel \"match arm\" dopo il `=>`.\n"
-" * L'espressione viene confrontata con i modelli dall'alto verso il basso. Non c'è fall-through "
-"come in C o C++.\n"
-" * L'espressione di corrispondenza ha un valore. Il valore è l'ultima espressione nel braccio di "
-"corrispondenza che è stata eseguita.\n"
-" * Partendo dall'alto cerchiamo quale modello corrisponde al valore, quindi eseguiamo il codice "
-"seguendo la freccia. Una volta trovata una corrispondenza, ci fermiamo.\n"
-"* Dimostrare cosa succede quando la ricerca è inesauribile. Nota il vantaggio fornito dal "
-"compilatore Rust confermando quando tutti i casi vengono gestiti.\n"
+"* È possibile accedere ai valori nelle varianti enum solo dopo essere stati "
+"abbinati al modello. Il modello lega i riferimenti ai campi nel \"match "
+"arm\" dopo il `=>`.\n"
+" * L'espressione viene confrontata con i modelli dall'alto verso il basso. "
+"Non c'è fall-through come in C o C++.\n"
+" * L'espressione di corrispondenza ha un valore. Il valore è l'ultima "
+"espressione nel braccio di corrispondenza che è stata eseguita.\n"
+" * Partendo dall'alto cerchiamo quale modello corrisponde al valore, quindi "
+"eseguiamo il codice seguendo la freccia. Una volta trovata una "
+"corrispondenza, ci fermiamo.\n"
+"* Dimostrare cosa succede quando la ricerca è inesauribile. Nota il "
+"vantaggio fornito dal compilatore Rust confermando quando tutti i casi "
+"vengono gestiti.\n"
"* `match` ispeziona un campo discriminante nascosto in `enum`.\n"
-"* È possibile recuperare il discriminante chiamando `std::mem::discriminant()`\n"
-" * Ciò è utile, ad esempio, se si implementa `PartialEq` per strutture in cui il confronto dei "
-"valori dei campi non influisce sull'uguaglianza.\n"
-"* `WebEvent::Click { ... }` non è esattamente la stessa cosa di `WebEvent::Click(Click)` con una "
-"`struct Click { ... }` di primo livello. La versione inline non può implementare tratti, per "
-"esempio.\n"
+"* È possibile recuperare il discriminante chiamando `std::mem::"
+"discriminant()`\n"
+" * Ciò è utile, ad esempio, se si implementa `PartialEq` per strutture in "
+"cui il confronto dei valori dei campi non influisce sull'uguaglianza.\n"
+"* `WebEvent::Click { ... }` non è esattamente la stessa cosa di `WebEvent::"
+"Click(Click)` con una `struct Click { ... }` di primo livello. La versione "
+"inline non può implementare tratti, per esempio.\n"
" "
#: src/enums/sizes.md:1
@@ -5771,9 +6374,12 @@ msgstr "# Enum Dimensioni"
#: src/enums/sizes.md:3
#, fuzzy
-msgid "Rust enums are packed tightly, taking constraints due to alignment into account:"
+msgid ""
+"Rust enums are packed tightly, taking constraints due to alignment into "
+"account:"
msgstr ""
-"Gli enum di Rust sono imballati strettamente, tenendo conto dei vincoli dovuti all'allineamento:"
+"Gli enum di Rust sono imballati strettamente, tenendo conto dei vincoli "
+"dovuti all'allineamento:"
#: src/enums/sizes.md:5
msgid ""
@@ -5800,14 +6406,20 @@ msgstr ""
#: src/enums/sizes.md:25
#, fuzzy
-msgid "* See the [Rust Reference](https://doc.rust-lang.org/reference/type-layout.html)."
-msgstr "* Vedere il [riferimento Rust](https://doc.rust-lang.org/reference/type-layout.html)."
+msgid ""
+"* See the [Rust Reference](https://doc.rust-lang.org/reference/type-layout."
+"html)."
+msgstr ""
+"* Vedere il [riferimento Rust](https://doc.rust-lang.org/reference/type-"
+"layout.html)."
#: src/enums/sizes.md:31
msgid ""
-" * Internally Rust is using a field (discriminant) to keep track of the enum variant.\n"
+" * Internally Rust is using a field (discriminant) to keep track of the enum "
+"variant.\n"
"\n"
-" * You can control the discriminant if needed (e.g., for compatibility with C):\n"
+" * You can control the discriminant if needed (e.g., for compatibility with "
+"C):\n"
" \n"
" ```rust,editable\n"
" #[repr(u32)]\n"
@@ -5824,35 +6436,41 @@ msgid ""
" }\n"
" ```\n"
"\n"
-" Without `repr`, the discriminant type takes 2 bytes, because 10001 fits 2\n"
+" Without `repr`, the discriminant type takes 2 bytes, because 10001 fits "
+"2\n"
" bytes.\n"
"\n"
"\n"
" * Try out other types such as\n"
" \n"
" * `dbg_size!(bool)`: size 1 bytes, align: 1 bytes,\n"
-" * `dbg_size!(Option)`: size 1 bytes, align: 1 bytes (niche optimization, see below),\n"
-" * `dbg_size!(&i32)`: size 8 bytes, align: 8 bytes (on a 64-bit machine),\n"
-" * `dbg_size!(Option<&i32>)`: size 8 bytes, align: 8 bytes (null pointer optimization, see "
-"below).\n"
+" * `dbg_size!(Option)`: size 1 bytes, align: 1 bytes (niche "
+"optimization, see below),\n"
+" * `dbg_size!(&i32)`: size 8 bytes, align: 8 bytes (on a 64-bit "
+"machine),\n"
+" * `dbg_size!(Option<&i32>)`: size 8 bytes, align: 8 bytes (null pointer "
+"optimization, see below).\n"
"\n"
-" * Niche optimization: Rust will merge use unused bit patterns for the enum\n"
+" * Niche optimization: Rust will merge unused bit patterns for the enum\n"
" discriminant.\n"
"\n"
" * Null pointer optimization: For [some\n"
-" types](https://doc.rust-lang.org/std/option/#representation), Rust guarantees\n"
+" types](https://doc.rust-lang.org/std/option/#representation), Rust "
+"guarantees\n"
" that `size_of::()` equals `size_of::>()`.\n"
"\n"
-" Example code if you want to show how the bitwise representation *may* look like in practice.\n"
-" It's important to note that the compiler provides no guarantees regarding this "
-"representation, therefore this is totally unsafe.\n"
+" Example code if you want to show how the bitwise representation *may* "
+"look like in practice.\n"
+" It's important to note that the compiler provides no guarantees "
+"regarding this representation, therefore this is totally unsafe.\n"
"\n"
" ```rust,editable\n"
" use std::mem::transmute;\n"
"\n"
" macro_rules! dbg_bits {\n"
" ($e:expr, $bit_type:ty) => {\n"
-" println!(\"- {}: {:#x}\", stringify!($e), transmute::<_, $bit_type>($e));\n"
+" println!(\"- {}: {:#x}\", stringify!($e), transmute::<_, "
+"$bit_type>($e));\n"
" };\n"
" }\n"
"\n"
@@ -5882,8 +6500,8 @@ msgid ""
" }\n"
" ```\n"
"\n"
-" More complex example if you want to discuss what happens when we chain more than 256 "
-"`Option`s together.\n"
+" More complex example if you want to discuss what happens when we chain "
+"more than 256 `Option`s together.\n"
"\n"
" ```rust,editable\n"
" #![recursion_limit = \"1000\"]\n"
@@ -5892,11 +6510,13 @@ msgid ""
" \n"
" macro_rules! dbg_bits {\n"
" ($e:expr, $bit_type:ty) => {\n"
-" println!(\"- {}: {:#x}\", stringify!($e), transmute::<_, $bit_type>($e));\n"
+" println!(\"- {}: {:#x}\", stringify!($e), transmute::<_, "
+"$bit_type>($e));\n"
" };\n"
" }\n"
"\n"
-" // Macro to wrap a value in 2^n Some() where n is the number of \"@\" signs.\n"
+" // Macro to wrap a value in 2^n Some() where n is the number of \"@\" "
+"signs.\n"
" // Increasing the recursion limit is required to evaluate this macro.\n"
" macro_rules! many_options {\n"
" ($value:expr) => { Some($value) };\n"
@@ -5914,17 +6534,21 @@ msgid ""
" unsafe {\n"
" assert_eq!(many_options!(false), Some(false));\n"
" assert_eq!(many_options!(false, @), Some(Some(false)));\n"
-" assert_eq!(many_options!(false, @@), Some(Some(Some(Some(false)))));\n"
+" assert_eq!(many_options!(false, @@), "
+"Some(Some(Some(Some(false)))));\n"
"\n"
-" println!(\"Bitwise representation of a chain of 128 Option's.\");\n"
+" println!(\"Bitwise representation of a chain of 128 Option's."
+"\");\n"
" dbg_bits!(many_options!(false, @@@@@@@), u8);\n"
" dbg_bits!(many_options!(true, @@@@@@@), u8);\n"
"\n"
-" println!(\"Bitwise representation of a chain of 256 Option's.\");\n"
+" println!(\"Bitwise representation of a chain of 256 Option's."
+"\");\n"
" dbg_bits!(many_options!(false, @@@@@@@@), u16);\n"
" dbg_bits!(many_options!(true, @@@@@@@@), u16);\n"
"\n"
-" println!(\"Bitwise representation of a chain of 257 Option's.\");\n"
+" println!(\"Bitwise representation of a chain of 257 Option's."
+"\");\n"
" dbg_bits!(many_options!(Some(false), @@@@@@@@), u16);\n"
" dbg_bits!(many_options!(Some(true), @@@@@@@@), u16);\n"
" dbg_bits!(many_options!(None::, @@@@@@@@), u16);\n"
@@ -5936,7 +6560,8 @@ msgstr ""
#: src/methods.md:3
#, fuzzy
msgid ""
-"Rust allows you to associate functions with your new types. You do this with an\n"
+"Rust allows you to associate functions with your new types. You do this with "
+"an\n"
"`impl` block:"
msgstr ""
"Rust ti consente di associare funzioni ai tuoi nuovi tipi. Lo fai con un\n"
@@ -5971,38 +6596,40 @@ msgstr ""
#, fuzzy
msgid ""
"* It can be helpful to introduce methods by comparing them to functions.\n"
-" * Methods are called on an instance of a type (such as a struct or enum), the first parameter "
-"represents the instance as `self`.\n"
-" * Developers may choose to use methods to take advantage of method receiver syntax and to help "
-"keep them more organized. By using methods we can keep all the implementation code in one "
-"predictable place.\n"
+" * Methods are called on an instance of a type (such as a struct or enum), "
+"the first parameter represents the instance as `self`.\n"
+" * Developers may choose to use methods to take advantage of method "
+"receiver syntax and to help keep them more organized. By using methods we "
+"can keep all the implementation code in one predictable place.\n"
"* Point out the use of the keyword `self`, a method receiver. \n"
-" * Show that it is an abbreviated term for `self:&Self` and perhaps show how the struct name "
-"could also be used. \n"
-" * Explain that `Self` is a type alias for the type the `impl` block is in and can be used "
-"elsewhere in the block.\n"
-" * Note how `self` is used like other structs and dot notation can be used to refer to individual "
-"fields.\n"
-" * This might be a good time to demonstrate how the `&self` differs from `self` by modifying the "
-"code and trying to run say_hello twice. \n"
+" * Show that it is an abbreviated term for `self:&Self` and perhaps show "
+"how the struct name could also be used. \n"
+" * Explain that `Self` is a type alias for the type the `impl` block is in "
+"and can be used elsewhere in the block.\n"
+" * Note how `self` is used like other structs and dot notation can be used "
+"to refer to individual fields.\n"
+" * This might be a good time to demonstrate how the `&self` differs from "
+"`self` by modifying the code and trying to run say_hello twice. \n"
"* We describe the distinction between method receivers next.\n"
" "
msgstr ""
"* Può essere utile introdurre metodi confrontandoli con funzioni.\n"
-" * I metodi vengono chiamati su un'istanza di un tipo (come struct o enum), il primo parametro "
-"rappresenta l'istanza come `self`.\n"
-" * Gli sviluppatori possono scegliere di utilizzare i metodi per sfruttare la sintassi del "
-"ricevitore del metodo e per mantenerli più organizzati. Utilizzando i metodi possiamo mantenere "
-"tutto il codice di implementazione in un posto prevedibile.\n"
+" * I metodi vengono chiamati su un'istanza di un tipo (come struct o enum), "
+"il primo parametro rappresenta l'istanza come `self`.\n"
+" * Gli sviluppatori possono scegliere di utilizzare i metodi per sfruttare "
+"la sintassi del ricevitore del metodo e per mantenerli più organizzati. "
+"Utilizzando i metodi possiamo mantenere tutto il codice di implementazione "
+"in un posto prevedibile.\n"
"* Sottolinea l'uso della parola chiave `self`, un ricevitore di metodo.\n"
-" * Mostra che è un termine abbreviato per `self:&Self` e forse mostra come potrebbe essere usato "
-"anche il nome struct.\n"
-" * Spiega che `Self` è un alias di tipo per il tipo in cui si trova il blocco `impl` e può essere "
-"utilizzato altrove nel blocco.\n"
-" * Nota come `self` viene utilizzato come altre strutture e la notazione con punto può essere "
-"utilizzata per fare riferimento a singoli campi.\n"
-" * Questo potrebbe essere un buon momento per dimostrare in che modo `&self` differisce da `self` "
-"modificando il codice e provando a eseguire say_hello due volte.\n"
+" * Mostra che è un termine abbreviato per `self:&Self` e forse mostra come "
+"potrebbe essere usato anche il nome struct.\n"
+" * Spiega che `Self` è un alias di tipo per il tipo in cui si trova il "
+"blocco `impl` e può essere utilizzato altrove nel blocco.\n"
+" * Nota come `self` viene utilizzato come altre strutture e la notazione "
+"con punto può essere utilizzata per fare riferimento a singoli campi.\n"
+" * Questo potrebbe essere un buon momento per dimostrare in che modo "
+"`&self` differisce da `self` modificando il codice e provando a eseguire "
+"say_hello due volte.\n"
"* Di seguito descriviamo la distinzione tra ricevitori di metodi.\n"
" "
@@ -6014,10 +6641,12 @@ msgstr "# Ricevitore del metodo"
#: src/methods/receiver.md:3
#, fuzzy
msgid ""
-"The `&self` above indicates that the method borrows the object immutably. There\n"
+"The `&self` above indicates that the method borrows the object immutably. "
+"There\n"
"are other possible receivers for a method:"
msgstr ""
-"Il `&self` sopra indica che il metodo prende in prestito l'oggetto in modo immutabile. Là\n"
+"Il `&self` sopra indica che il metodo prende in prestito l'oggetto in modo "
+"immutabile. Là\n"
"sono altri possibili ricevitori per un metodo:"
#: src/methods/receiver.md:6
@@ -6025,55 +6654,67 @@ msgstr ""
msgid ""
"* `&self`: borrows the object from the caller using a shared and immutable\n"
" reference. The object can be used again afterwards.\n"
-"* `&mut self`: borrows the object from the caller using a unique and mutable\n"
+"* `&mut self`: borrows the object from the caller using a unique and "
+"mutable\n"
" reference. The object can be used again afterwards.\n"
-"* `self`: takes ownership of the object and moves it away from the caller. The\n"
-" method becomes the owner of the object. The object will be dropped (deallocated)\n"
+"* `self`: takes ownership of the object and moves it away from the caller. "
+"The\n"
+" method becomes the owner of the object. The object will be dropped "
+"(deallocated)\n"
" when the method returns, unless its ownership is explicitly\n"
-" transmitted.\n"
-"* `mut self`: same as above, but while the method owns the object, it can\n"
-" mutate it too. Complete ownership does not automatically mean mutability.\n"
-"* No receiver: this becomes a static method on the struct. Typically used to\n"
+" transmitted. Complete ownership does not automatically mean mutability.\n"
+"* `mut self`: same as above, but the method can mutate the object. \n"
+"* No receiver: this becomes a static method on the struct. Typically used "
+"to\n"
" create constructors which are called `new` by convention."
msgstr ""
-"* `&self`: prende in prestito l'oggetto dal chiamante usando un oggetto condiviso e immutabile\n"
+"* `&self`: prende in prestito l'oggetto dal chiamante usando un oggetto "
+"condiviso e immutabile\n"
" riferimento. L'oggetto può essere riutilizzato in seguito.\n"
-"* `&mut self`: prende in prestito l'oggetto dal chiamante usando un oggetto unico e mutabile\n"
+"* `&mut self`: prende in prestito l'oggetto dal chiamante usando un oggetto "
+"unico e mutabile\n"
" riferimento. L'oggetto può essere riutilizzato in seguito.\n"
"* `self`: assume la proprietà dell'oggetto e lo allontana dal chiamante. IL\n"
-" metodo diventa il proprietario dell'oggetto. L'oggetto verrà eliminato (deallocato)\n"
+" metodo diventa il proprietario dell'oggetto. L'oggetto verrà eliminato "
+"(deallocato)\n"
" quando il metodo ritorna, a meno che la sua proprietà non sia esplicita\n"
" trasmesso.\n"
"* `mut self`: come sopra, ma mentre il metodo possiede l'oggetto, può farlo\n"
-" muta anche questo. Proprietà completa non significa automaticamente mutabilità.\n"
-"* Nessun ricevitore: questo diventa un metodo statico sulla struttura. Tipicamente utilizzato per\n"
+" muta anche questo. Proprietà completa non significa automaticamente "
+"mutabilità.\n"
+"* Nessun ricevitore: questo diventa un metodo statico sulla struttura. "
+"Tipicamente utilizzato per\n"
" creare costruttori che sono chiamati \"nuovi\" per convenzione."
-#: src/methods/receiver.md:19
+#: src/methods/receiver.md:18
#, fuzzy
msgid ""
"Beyond variants on `self`, there are also\n"
-"[special wrapper types](https://doc.rust-lang.org/reference/special-types-and-traits.html)\n"
+"[special wrapper types](https://doc.rust-lang.org/reference/special-types-"
+"and-traits.html)\n"
"allowed to be receiver types, such as `Box`."
msgstr ""
"Oltre alle varianti su \"self\", ci sono anche\n"
-"[tipi di wrapper speciali](https://doc.rust-lang.org/reference/special-types-and-traits.html)\n"
+"[tipi di wrapper speciali](https://doc.rust-lang.org/reference/special-types-"
+"and-traits.html)\n"
"possono essere tipi di ricevitore, come `Box`."
-#: src/methods/receiver.md:25
+#: src/methods/receiver.md:24
#, fuzzy
msgid ""
-"Consider emphasizing \"shared and immutable\" and \"unique and mutable\". These constraints always "
-"come\n"
-"together in Rust due to borrow checker rules, and `self` is no exception. It isn't possible to\n"
-"reference a struct from multiple locations and call a mutating (`&mut self`) method on it."
+"Consider emphasizing \"shared and immutable\" and \"unique and mutable\". "
+"These constraints always come\n"
+"together in Rust due to borrow checker rules, and `self` is no exception. It "
+"isn't possible to\n"
+"reference a struct from multiple locations and call a mutating (`&mut self`) "
+"method on it."
msgstr ""
-"Prendi in considerazione l'enfasi su \"condiviso e immutabile\" e \"unico e mutevole\". Questi "
-"vincoli arrivano sempre\n"
-"insieme in Rust a causa delle regole del correttore in prestito, e \"self\" non fa eccezione. Non "
-"è possibile\n"
-"fare riferimento a una struttura da più posizioni e chiamare un metodo mutante (`&mut self`) su di "
-"essa."
+"Prendi in considerazione l'enfasi su \"condiviso e immutabile\" e \"unico e "
+"mutevole\". Questi vincoli arrivano sempre\n"
+"insieme in Rust a causa delle regole del correttore in prestito, e \"self\" "
+"non fa eccezione. Non è possibile\n"
+"fare riferimento a una struttura da più posizioni e chiamare un metodo "
+"mutante (`&mut self`) su di essa."
#: src/methods/example.md:1 src/concurrency/shared_state/example.md:1
#, fuzzy
@@ -6094,7 +6735,8 @@ msgid ""
" Race { name: String::from(name), laps: Vec::new() }\n"
" }\n"
"\n"
-" fn add_lap(&mut self, lap: i32) { // Exclusive borrowed read-write access to self\n"
+" fn add_lap(&mut self, lap: i32) { // Exclusive borrowed read-write "
+"access to self\n"
" self.laps.push(lap);\n"
" }\n"
"\n"
@@ -6107,7 +6749,8 @@ msgid ""
"\n"
" fn finish(self) { // Exclusive ownership of self\n"
" let total = self.laps.iter().sum::();\n"
-" println!(\"Race {} is finished, total lap time: {}\", self.name, total);\n"
+" println!(\"Race {} is finished, total lap time: {}\", self.name, "
+"total);\n"
" }\n"
"}\n"
"\n"
@@ -6128,26 +6771,29 @@ msgstr ""
#, fuzzy
msgid ""
"* All four methods here use a different method receiver.\n"
-" * You can point out how that changes what the function can do with the variable values and if/"
-"how it can be used again in `main`.\n"
-" * You can showcase the error that appears when trying to call `finish` twice.\n"
-"* Note that although the method receivers are different, the non-static functions are called the "
-"same way in the main body. Rust enables automatic referencing and dereferencing when calling "
-"methods. Rust automatically adds in the `&`, `*`, `muts` so that that object matches the method "
-"signature.\n"
-"* You might point out that `print_laps` is using a vector that is iterated over. We describe "
-"vectors in more detail in the afternoon. "
+" * You can point out how that changes what the function can do with the "
+"variable values and if/how it can be used again in `main`.\n"
+" * You can showcase the error that appears when trying to call `finish` "
+"twice.\n"
+"* Note that although the method receivers are different, the non-static "
+"functions are called the same way in the main body. Rust enables automatic "
+"referencing and dereferencing when calling methods. Rust automatically adds "
+"in the `&`, `*`, `muts` so that that object matches the method signature.\n"
+"* You might point out that `print_laps` is using a vector that is iterated "
+"over. We describe vectors in more detail in the afternoon. "
msgstr ""
"* Tutti e quattro i metodi qui usano un ricevitore metodo diverso.\n"
-" * Puoi indicare come ciò cambia ciò che la funzione può fare con i valori delle variabili e se/"
-"come può essere riutilizzata in `main`.\n"
-" * Puoi mostrare l'errore che appare quando provi a chiamare `finish` due volte.\n"
-"* Si noti che sebbene i destinatari del metodo siano diversi, le funzioni non statiche sono "
-"chiamate allo stesso modo nel corpo principale. Rust abilita la referenziazione e la "
-"dereferenziazione automatica quando si chiamano i metodi. Rust aggiunge automaticamente `&`, `*`, "
-"`muts` in modo che quell'oggetto corrisponda alla firma del metodo.\n"
-"* Potresti sottolineare che `print_laps` sta usando un vettore che viene iterato. Descriviamo i "
-"vettori in modo più dettagliato nel pomeriggio."
+" * Puoi indicare come ciò cambia ciò che la funzione può fare con i valori "
+"delle variabili e se/come può essere riutilizzata in `main`.\n"
+" * Puoi mostrare l'errore che appare quando provi a chiamare `finish` due "
+"volte.\n"
+"* Si noti che sebbene i destinatari del metodo siano diversi, le funzioni "
+"non statiche sono chiamate allo stesso modo nel corpo principale. Rust "
+"abilita la referenziazione e la dereferenziazione automatica quando si "
+"chiamano i metodi. Rust aggiunge automaticamente `&`, `*`, `muts` in modo "
+"che quell'oggetto corrisponda alla firma del metodo.\n"
+"* Potresti sottolineare che `print_laps` sta usando un vettore che viene "
+"iterato. Descriviamo i vettori in modo più dettagliato nel pomeriggio."
#: src/pattern-matching.md:1
#, fuzzy
@@ -6157,16 +6803,21 @@ msgstr "# Corrispondenza modello"
#: src/pattern-matching.md:3
#, fuzzy
msgid ""
-"The `match` keyword let you match a value against one or more _patterns_. The\n"
+"The `match` keyword let you match a value against one or more _patterns_. "
+"The\n"
"comparisons are done from top to bottom and the first match wins."
msgstr ""
-"La parola chiave `match` ti consente di confrontare un valore con uno o più _pattern_. IL\n"
-"i confronti vengono effettuati dall'alto verso il basso e vince la prima partita."
+"La parola chiave `match` ti consente di confrontare un valore con uno o più "
+"_pattern_. IL\n"
+"i confronti vengono effettuati dall'alto verso il basso e vince la prima "
+"partita."
#: src/pattern-matching.md:6
#, fuzzy
msgid "The patterns can be simple values, similarly to `switch` in C and C++:"
-msgstr "I modelli possono essere valori semplici, in modo simile a `switch` in C e C++:"
+msgstr ""
+"I modelli possono essere valori semplici, in modo simile a `switch` in C e C+"
+"+:"
#: src/pattern-matching.md:8
msgid ""
@@ -6187,33 +6838,39 @@ msgstr ""
#: src/pattern-matching.md:21
#, fuzzy
msgid "The `_` pattern is a wildcard pattern which matches any value."
-msgstr "Il modello `_` è un modello di caratteri jolly che corrisponde a qualsiasi valore."
+msgstr ""
+"Il modello `_` è un modello di caratteri jolly che corrisponde a qualsiasi "
+"valore."
#: src/pattern-matching.md:26
#, fuzzy
msgid ""
-"* You might point out how some specific characters are being used when in a pattern\n"
+"* You might point out how some specific characters are being used when in a "
+"pattern\n"
" * `|` as an `or`\n"
" * `..` can expand as much as it needs to be\n"
" * `1..=5` represents an inclusive range\n"
" * `_` is a wild card\n"
-"* It can be useful to show how binding works, by for instance replacing a wildcard character with "
-"a variable, or removing the quotes around `q`.\n"
+"* It can be useful to show how binding works, by for instance replacing a "
+"wildcard character with a variable, or removing the quotes around `q`.\n"
"* You can demonstrate matching on a reference.\n"
-"* This might be a good time to bring up the concept of irrefutable patterns, as the term can show "
-"up in error messages.\n"
+"* This might be a good time to bring up the concept of irrefutable patterns, "
+"as the term can show up in error messages.\n"
" "
msgstr ""
-"* Potresti sottolineare come vengono utilizzati alcuni caratteri specifici quando in uno schema\n"
+"* Potresti sottolineare come vengono utilizzati alcuni caratteri specifici "
+"quando in uno schema\n"
" * `|` come `o`\n"
" * `..` può espandersi quanto deve essere\n"
" * `1..=5` rappresenta un intervallo inclusivo\n"
" * `_` è un carattere jolly\n"
-"* Può essere utile mostrare come funziona l'associazione, ad esempio sostituendo un carattere "
-"jolly con una variabile o rimuovendo le virgolette intorno a `q`.\n"
+"* Può essere utile mostrare come funziona l'associazione, ad esempio "
+"sostituendo un carattere jolly con una variabile o rimuovendo le virgolette "
+"intorno a `q`.\n"
"* Puoi dimostrare la corrispondenza su un riferimento.\n"
-"* Questo potrebbe essere un buon momento per far emergere il concetto di modelli inconfutabili, "
-"poiché il termine può apparire nei messaggi di errore.\n"
+"* Questo potrebbe essere un buon momento per far emergere il concetto di "
+"modelli inconfutabili, poiché il termine può apparire nei messaggi di "
+"errore.\n"
" "
#: src/pattern-matching/destructuring-enums.md:1
@@ -6224,11 +6881,13 @@ msgstr "# Destrutturazione delle enum"
#: src/pattern-matching/destructuring-enums.md:3
#, fuzzy
msgid ""
-"Patterns can also be used to bind variables to parts of your values. This is how\n"
-"you inspect the structure of your types. Let us start with a simple `enum` type:"
+"Patterns can also be used to bind variables to parts of your values. This is "
+"how\n"
+"you inspect the structure of your types. Let us start with a simple `enum` "
+"type:"
msgstr ""
-"I modelli possono anche essere usati per associare variabili a parti dei tuoi valori. Questo è "
-"come\n"
+"I modelli possono anche essere usati per associare variabili a parti dei "
+"tuoi valori. Questo è come\n"
"ispezioni la struttura dei tuoi tipi. Iniziamo con un semplice tipo `enum`:"
#: src/pattern-matching/destructuring-enums.md:6
@@ -6260,27 +6919,33 @@ msgstr ""
#: src/pattern-matching/destructuring-enums.md:29
#, fuzzy
msgid ""
-"Here we have used the arms to _destructure_ the `Result` value. In the first\n"
-"arm, `half` is bound to the value inside the `Ok` variant. In the second arm,\n"
+"Here we have used the arms to _destructure_ the `Result` value. In the "
+"first\n"
+"arm, `half` is bound to the value inside the `Ok` variant. In the second "
+"arm,\n"
"`msg` is bound to the error message."
msgstr ""
-"Qui abbiamo usato le braccia per _destrutturare_ il valore `Result`. Nel primo\n"
-"arm, \"half\" è legato al valore all'interno della variante \"Ok\". Nel secondo braccio,\n"
+"Qui abbiamo usato le braccia per _destrutturare_ il valore `Result`. Nel "
+"primo\n"
+"arm, \"half\" è legato al valore all'interno della variante \"Ok\". Nel "
+"secondo braccio,\n"
"`msg` è associato al messaggio di errore."
#: src/pattern-matching/destructuring-enums.md:36
#, fuzzy
msgid ""
-"* The `if`/`else` expression is returning an enum that is later unpacked with a `match`.\n"
-"* You can try adding a third variant to the enum definition and displaying the errors when running "
-"the code. Point out the places where your code is now inexhaustive and how the compiler tries to "
-"give you hints."
+"* The `if`/`else` expression is returning an enum that is later unpacked "
+"with a `match`.\n"
+"* You can try adding a third variant to the enum definition and displaying "
+"the errors when running the code. Point out the places where your code is "
+"now inexhaustive and how the compiler tries to give you hints."
msgstr ""
-"* L'espressione `if`/`else` restituisce un enum che viene successivamente decompresso con un "
-"`match`.\n"
-"* Puoi provare ad aggiungere una terza variante alla definizione enum e visualizzare gli errori "
-"durante l'esecuzione del codice. Indica i punti in cui il tuo codice è ora inesausto e come il "
-"compilatore cerca di darti suggerimenti."
+"* L'espressione `if`/`else` restituisce un enum che viene successivamente "
+"decompresso con un `match`.\n"
+"* Puoi provare ad aggiungere una terza variante alla definizione enum e "
+"visualizzare gli errori durante l'esecuzione del codice. Indica i punti in "
+"cui il tuo codice è ora inesausto e come il compilatore cerca di darti "
+"suggerimenti."
#: src/pattern-matching/destructuring-structs.md:1
#, fuzzy
@@ -6306,7 +6971,8 @@ msgid ""
" match foo {\n"
" Foo { x: (1, b), y } => println!(\"x.0 = 1, b = {b}, y = {y}\"),\n"
" Foo { y: 2, x: i } => println!(\"y = 2, x = {i:?}\"),\n"
-" Foo { y, .. } => println!(\"y = {y}, other fields were ignored\"),\n"
+" Foo { y, .. } => println!(\"y = {y}, other fields were "
+"ignored\"),\n"
" }\n"
"}\n"
"```"
@@ -6317,15 +6983,20 @@ msgstr ""
msgid ""
"* Change the literal values in `foo` to match with the other patterns.\n"
"* Add a new field to `Foo` and make changes to the pattern as needed.\n"
-"* The distinction between a capture and a constant expression can be hard to\n"
-" spot. Try changing the `2` in the second arm to a variable, and see that it subtly\n"
+"* The distinction between a capture and a constant expression can be hard "
+"to\n"
+" spot. Try changing the `2` in the second arm to a variable, and see that "
+"it subtly\n"
" doesn't work. Change it to a `const` and see it working again."
msgstr ""
-"* Cambia i valori letterali in `foo` in modo che corrispondano agli altri modelli.\n"
-"* Aggiungi un nuovo campo a \"Foo\" e apporta le modifiche al modello secondo necessità.\n"
-"* La distinzione tra una cattura e un'espressione costante può essere difficile da fare\n"
-" macchiare. Prova a cambiare il \"2\" nel secondo braccio in una variabile e osservalo "
-"sottilmente\n"
+"* Cambia i valori letterali in `foo` in modo che corrispondano agli altri "
+"modelli.\n"
+"* Aggiungi un nuovo campo a \"Foo\" e apporta le modifiche al modello "
+"secondo necessità.\n"
+"* La distinzione tra una cattura e un'espressione costante può essere "
+"difficile da fare\n"
+" macchiare. Prova a cambiare il \"2\" nel secondo braccio in una variabile "
+"e osservalo sottilmente\n"
" non funziona. Cambialo in un `const` e guardalo funzionare di nuovo."
#: src/pattern-matching/destructuring-arrays.md:1
@@ -6335,7 +7006,8 @@ msgstr "# Array destrutturanti"
#: src/pattern-matching/destructuring-arrays.md:3
#, fuzzy
-msgid "You can destructure arrays, tuples, and slices by matching on their elements:"
+msgid ""
+"You can destructure arrays, tuples, and slices by matching on their elements:"
msgstr "Puoi destrutturare array, tuple e slice abbinando i loro elementi:"
#: src/pattern-matching/destructuring-arrays.md:5
@@ -6356,7 +7028,8 @@ msgstr ""
#: src/pattern-matching/destructuring-arrays.md:21
msgid ""
-"* Destructuring of slices of unknown length also works with patterns of fixed length.\n"
+"* Destructuring of slices of unknown length also works with patterns of "
+"fixed length.\n"
"\n"
"\n"
" ```rust,editable\n"
@@ -6370,7 +7043,8 @@ msgid ""
" println!(\"Tell me about {slice:?}\");\n"
" match slice {\n"
" &[0, y, z] => println!(\"First is 0, y = {y}, and z = {z}\"),\n"
-" &[1, ..] => println!(\"First is 1 and the rest were ignored\"),\n"
+" &[1, ..] => println!(\"First is 1 and the rest were "
+"ignored\"),\n"
" _ => println!(\"All elements were ignored\"),\n"
" }\n"
" }\n"
@@ -6378,7 +7052,8 @@ msgid ""
" \n"
"* Create a new pattern using `_` to represent an element. \n"
"* Add more values to the array.\n"
-"* Point out that how `..` will expand to account for different number of elements.\n"
+"* Point out that how `..` will expand to account for different number of "
+"elements.\n"
"* Show matching against the tail with patterns `[.., b]` and `[a@..,b]`"
msgstr ""
@@ -6390,11 +7065,12 @@ msgstr "# Partita Guardie"
#: src/pattern-matching/match-guards.md:3
#, fuzzy
msgid ""
-"When matching, you can add a _guard_ to a pattern. This is an arbitrary Boolean\n"
+"When matching, you can add a _guard_ to a pattern. This is an arbitrary "
+"Boolean\n"
"expression which will be executed if the pattern matches:"
msgstr ""
-"Durante la corrispondenza, puoi aggiungere una _guard_ a un pattern. Questo è un booleano "
-"arbitrario\n"
+"Durante la corrispondenza, puoi aggiungere una _guard_ a un pattern. Questo "
+"è un booleano arbitrario\n"
"espressione che verrà eseguita se il modello corrisponde:"
#: src/pattern-matching/match-guards.md:6
@@ -6417,25 +7093,31 @@ msgstr ""
#: src/pattern-matching/match-guards.md:23
#, fuzzy
msgid ""
-"* Match guards as a separate syntax feature are important and necessary when we wish to concisely "
-"express more complex ideas than patterns alone would allow.\n"
-"* They are not the same as separate `if` expression inside of the match arm. An `if` expression "
-"inside of the branch block (after `=>`) happens after the match arm is selected. Failing the `if` "
-"condition inside of that block won't result in other arms\n"
+"* Match guards as a separate syntax feature are important and necessary when "
+"we wish to concisely express more complex ideas than patterns alone would "
+"allow.\n"
+"* They are not the same as separate `if` expression inside of the match arm. "
+"An `if` expression inside of the branch block (after `=>`) happens after the "
+"match arm is selected. Failing the `if` condition inside of that block won't "
+"result in other arms\n"
"of the original `match` expression being considered. \n"
"* You can use the variables defined in the pattern in your if expression.\n"
-"* The condition defined in the guard applies to every expression in a pattern with an `|`."
+"* The condition defined in the guard applies to every expression in a "
+"pattern with an `|`."
msgstr ""
-"* Le guardie di corrispondenza come caratteristica di sintassi separata sono importanti e "
-"necessarie quando desideriamo esprimere in modo conciso idee più complesse di quanto i soli schemi "
-"consentirebbero.\n"
-"* Non sono la stessa cosa dell'espressione `if` separata all'interno del braccio della "
-"corrispondenza. Un'espressione `if` all'interno del blocco di diramazione (dopo `=>`) si verifica "
-"dopo che è stato selezionato il braccio di corrispondenza. Il fallimento della condizione \"if\" "
-"all'interno di quel blocco non comporterà altre braccia\n"
+"* Le guardie di corrispondenza come caratteristica di sintassi separata sono "
+"importanti e necessarie quando desideriamo esprimere in modo conciso idee "
+"più complesse di quanto i soli schemi consentirebbero.\n"
+"* Non sono la stessa cosa dell'espressione `if` separata all'interno del "
+"braccio della corrispondenza. Un'espressione `if` all'interno del blocco di "
+"diramazione (dopo `=>`) si verifica dopo che è stato selezionato il braccio "
+"di corrispondenza. Il fallimento della condizione \"if\" all'interno di quel "
+"blocco non comporterà altre braccia\n"
"dell'espressione `match` originale considerata.\n"
-"* È possibile utilizzare le variabili definite nel modello nell'espressione if.\n"
-"* La condizione definita nella guardia si applica a ogni espressione in un modello con un `|`."
+"* È possibile utilizzare le variabili definite nel modello nell'espressione "
+"if.\n"
+"* La condizione definita nella guardia si applica a ogni espressione in un "
+"modello con un `|`."
#: src/exercises/day-2/morning.md:1
#, fuzzy
@@ -6466,31 +7148,37 @@ msgstr "# Statistiche sanitarie"
#: src/exercises/day-2/health-statistics.md:3
#, fuzzy
msgid ""
-"You're working on implementing a health-monitoring system. As part of that, you\n"
+"You're working on implementing a health-monitoring system. As part of that, "
+"you\n"
"need to keep track of users' health statistics."
msgstr ""
-"Stai lavorando all'implementazione di un sistema di monitoraggio sanitario. Come parte di questo, "
-"tu\n"
+"Stai lavorando all'implementazione di un sistema di monitoraggio sanitario. "
+"Come parte di questo, tu\n"
"necessità di tenere traccia delle statistiche sulla salute degli utenti."
#: src/exercises/day-2/health-statistics.md:6
#, fuzzy
msgid ""
-"You'll start with some stubbed functions in an `impl` block as well as a `User`\n"
+"You'll start with some stubbed functions in an `impl` block as well as a "
+"`User`\n"
"struct definition. Your goal is to implement the stubbed out methods on the\n"
"`User` `struct` defined in the `impl` block."
msgstr ""
-"Inizierai con alcune funzioni stubbed in un blocco `impl` così come in un `User`\n"
-"definizione di struttura. Il tuo obiettivo è implementare i metodi eliminati sul file\n"
+"Inizierai con alcune funzioni stubbed in un blocco `impl` così come in un "
+"`User`\n"
+"definizione di struttura. Il tuo obiettivo è implementare i metodi eliminati "
+"sul file\n"
"`User` `struct` definito nel blocco `impl`."
#: src/exercises/day-2/health-statistics.md:10
#, fuzzy
msgid ""
-"Copy the code below to ` on every\n"
-"call to `next()`. It returns `Some(x)` until it is done, after which it will\n"
+"Here the iterator returned by `v.iter()` will return a `Option` on "
+"every\n"
+"call to `next()`. It returns `Some(x)` until it is done, after which it "
+"will\n"
"return `None`. The `while let` lets us keep iterating through all items."
msgstr ""
-"Qui l'iteratore restituito da `v.iter()` restituirà una `Option` su ogni\n"
-"chiamata a `next()`. Restituisce `Some(x)` finché non è finito, dopodiché lo farà\n"
-"restituire \"Nessuno\". Il `while let` ci consente di continuare a scorrere tutti gli elementi."
+"Qui l'iteratore restituito da `v.iter()` restituirà una `Option` su "
+"ogni\n"
+"chiamata a `next()`. Restituisce `Some(x)` finché non è finito, dopodiché lo "
+"farà\n"
+"restituire \"Nessuno\". Il `while let` ci consente di continuare a scorrere "
+"tutti gli elementi."
#: src/control-flow/while-let-expressions.md:26
#, fuzzy
msgid ""
-"* Point out that the `while let` loop will keep going as long as the value matches the pattern.\n"
-"* You could rewrite the `while let` loop as an infinite loop with an if statement that breaks when "
-"there is no value to unwrap for `iter.next()`. The `while let` provides syntactic sugar for the "
-"above scenario.\n"
+"* Point out that the `while let` loop will keep going as long as the value "
+"matches the pattern.\n"
+"* You could rewrite the `while let` loop as an infinite loop with an if "
+"statement that breaks when there is no value to unwrap for `iter.next()`. "
+"The `while let` provides syntactic sugar for the above scenario.\n"
" "
msgstr ""
-"* Fai notare che il ciclo `while let` continuerà finché il valore corrisponde al modello.\n"
-"* Potresti riscrivere il ciclo `while let` come un ciclo infinito con un'istruzione if che si "
-"interrompe quando non c'è alcun valore da scartare per `iter.next()`. Il `while let` fornisce lo "
-"zucchero sintattico per lo scenario di cui sopra.\n"
+"* Fai notare che il ciclo `while let` continuerà finché il valore "
+"corrisponde al modello.\n"
+"* Potresti riscrivere il ciclo `while let` come un ciclo infinito con "
+"un'istruzione if che si interrompe quando non c'è alcun valore da scartare "
+"per `iter.next()`. Il `while let` fornisce lo zucchero sintattico per lo "
+"scenario di cui sopra.\n"
" "
#: src/control-flow/for-expressions.md:1
@@ -7021,12 +7796,14 @@ msgstr "# Cicli `for`"
#, fuzzy
msgid ""
"The [`for` loop](https://doc.rust-lang.org/std/keyword.for.html) is closely\n"
-"related to the [`while let` loop](while-let-expression.md). It will\n"
+"related to the [`while let` loop](while-let-expressions.md). It will\n"
"automatically call `into_iter()` on the expression and then iterate over it:"
msgstr ""
-"Il [ciclo `for`](https://doc.rust-lang.org/std/keyword.for.html) è strettamente\n"
+"Il [ciclo `for`](https://doc.rust-lang.org/std/keyword.for.html) è "
+"strettamente\n"
"relativo al [ciclo `while let`](while-let-expression.md). Lo farà\n"
-"chiama automaticamente `into_iter()` sull'espressione e quindi itera su di essa:"
+"chiama automaticamente `into_iter()` sull'espressione e quindi itera su di "
+"essa:"
#: src/control-flow/for-expressions.md:7
msgid ""
@@ -7055,15 +7832,19 @@ msgstr "Puoi usare `break` e `continue` qui come al solito."
msgid ""
"* Index iteration is not a special syntax in Rust for just that case.\n"
"* `(0..10)` is a range that implements an `Iterator` trait. \n"
-"* `step_by` is a method that returns another `Iterator` that skips every other element. \n"
-"* Modify the elements in the vector and explain the compiler errors. Change vector `v` to be "
-"mutable and the for loop to `for x in v.iter_mut()`."
+"* `step_by` is a method that returns another `Iterator` that skips every "
+"other element. \n"
+"* Modify the elements in the vector and explain the compiler errors. Change "
+"vector `v` to be mutable and the for loop to `for x in v.iter_mut()`."
msgstr ""
-"* L'iterazione dell'indice non è una sintassi speciale in Rust solo per quel caso.\n"
+"* L'iterazione dell'indice non è una sintassi speciale in Rust solo per quel "
+"caso.\n"
"* `(0..10)` è un intervallo che implementa un tratto `Iterator`.\n"
-"* `step_by` è un metodo che restituisce un altro `Iterator` che salta ogni altro elemento.\n"
-"* Modifica gli elementi nel vettore e spiega gli errori del compilatore. Cambia il vettore `v` in "
-"modo che sia mutabile e il ciclo for in `for x in v.iter_mut()`."
+"* `step_by` è un metodo che restituisce un altro `Iterator` che salta ogni "
+"altro elemento.\n"
+"* Modifica gli elementi nel vettore e spiega gli errori del compilatore. "
+"Cambia il vettore `v` in modo che sia mutabile e il ciclo for in `for x in v."
+"iter_mut()`."
#: src/control-flow/loop-expressions.md:1
#, fuzzy
@@ -7073,12 +7854,12 @@ msgstr "# Espressioni `loop`"
#: src/control-flow/loop-expressions.md:3
#, fuzzy
msgid ""
-"Finally, there is a [`loop` keyword](https://doc.rust-lang.org/reference/expressions/loop-expr."
-"html#infinite-loops)\n"
+"Finally, there is a [`loop` keyword](https://doc.rust-lang.org/reference/"
+"expressions/loop-expr.html#infinite-loops)\n"
"which creates an endless loop."
msgstr ""
-"Infine, c'è una [parola chiave `loop`](https://doc.rust-lang.org/reference/expressions/loop-expr."
-"html#infinite-loops)\n"
+"Infine, c'è una [parola chiave `loop`](https://doc.rust-lang.org/reference/"
+"expressions/loop-expr.html#infinite-loops)\n"
"che crea un loop infinito."
#: src/control-flow/loop-expressions.md:6
@@ -7110,13 +7891,17 @@ msgstr ""
#, fuzzy
msgid ""
"* Break the `loop` with a value (e.g. `break 8`) and print it out.\n"
-"* Note that `loop` is the only looping construct which returns a non-trivial\n"
-" value. This is because it's guaranteed to be entered at least once (unlike\n"
+"* Note that `loop` is the only looping construct which returns a non-"
+"trivial\n"
+" value. This is because it's guaranteed to be entered at least once "
+"(unlike\n"
" `while` and `for` loops)."
msgstr ""
"* Interrompi il `loop` con un valore (ad es. `break 8`) e stampalo.\n"
-"* Si noti che `loop` è l'unico costrutto di ciclo che restituisce un valore non banale\n"
-" valore. Questo perché è garantito che venga inserito almeno una volta (a differenza di\n"
+"* Si noti che `loop` è l'unico costrutto di ciclo che restituisce un valore "
+"non banale\n"
+" valore. Questo perché è garantito che venga inserito almeno una volta (a "
+"differenza di\n"
" cicli `while` e `for`)."
#: src/control-flow/match-expressions.md:1
@@ -7127,12 +7912,16 @@ msgstr "# Espressioni `match`"
#: src/control-flow/match-expressions.md:3
#, fuzzy
msgid ""
-"The [`match` keyword](https://doc.rust-lang.org/reference/expressions/match-expr.html)\n"
-"is used to match a value against one or more patterns. In that sense, it works\n"
+"The [`match` keyword](https://doc.rust-lang.org/reference/expressions/match-"
+"expr.html)\n"
+"is used to match a value against one or more patterns. In that sense, it "
+"works\n"
"like a series of `if let` expressions:"
msgstr ""
-"La [parola chiave `match`](https://doc.rust-lang.org/reference/expressions/match-expr.html)\n"
-"viene utilizzato per confrontare un valore con uno o più modelli. In questo senso funziona\n"
+"La [parola chiave `match`](https://doc.rust-lang.org/reference/expressions/"
+"match-expr.html)\n"
+"viene utilizzato per confrontare un valore con uno o più modelli. In questo "
+"senso funziona\n"
"come una serie di espressioni `if let`:"
#: src/control-flow/match-expressions.md:7
@@ -7157,7 +7946,8 @@ msgid ""
"Like `if let`, each match arm must have the same type. The type is the last\n"
"expression of the block, if any. In the example above, the type is `()`."
msgstr ""
-"Come `if let`, ogni braccio di corrispondenza deve avere lo stesso tipo. Il tipo è l'ultimo\n"
+"Come `if let`, ogni braccio di corrispondenza deve avere lo stesso tipo. Il "
+"tipo è l'ultimo\n"
"espressione del blocco, se esiste. Nell'esempio precedente, il tipo è `()`."
#: src/control-flow/match-expressions.md:28
@@ -7165,19 +7955,21 @@ msgstr ""
msgid ""
"* Save the match expression to a variable and print it out.\n"
"* Remove `.as_deref()` and explain the error.\n"
-" * `std::env::args().next()` returns an `Option`, but we cannot match against "
-"`String`.\n"
-" * `as_deref()` transforms an `Option` to `Option<&T::Target>`. In our case, this turns "
-"`Option` into `Option<&str>`.\n"
-" * We can now use pattern matching to match against the `&str` inside `Option`."
+" * `std::env::args().next()` returns an `Option`, but we cannot "
+"match against `String`.\n"
+" * `as_deref()` transforms an `Option` to `Option<&T::Target>`. In our "
+"case, this turns `Option` into `Option<&str>`.\n"
+" * We can now use pattern matching to match against the `&str` inside "
+"`Option`."
msgstr ""
"* Salva l'espressione di corrispondenza in una variabile e stampala.\n"
"* Rimuovi `.as_deref()` e spiega l'errore.\n"
-" * `std::env::args().next()` restituisce un `Option`, ma non possiamo confrontare "
-"`String`.\n"
-" * `as_deref()` trasforma una `Opzione` in `Opzione<&T::Target>`. Nel nostro caso, questo "
-"trasforma `Option` in `Option<&str>`.\n"
-" * Ora possiamo usare il pattern matching per confrontare con `&str` all'interno di `Option`."
+" * `std::env::args().next()` restituisce un `Option`, ma non "
+"possiamo confrontare `String`.\n"
+" * `as_deref()` trasforma una `Opzione` in `Opzione<&T::Target>`. Nel "
+"nostro caso, questo trasforma `Option` in `Option<&str>`.\n"
+" * Ora possiamo usare il pattern matching per confrontare con `&str` "
+"all'interno di `Option`."
#: src/control-flow/break-continue.md:1
#, fuzzy
@@ -7187,26 +7979,27 @@ msgstr "# `interrompi` e `continua`"
#: src/control-flow/break-continue.md:3
#, fuzzy
msgid ""
-"- If you want to exit a loop early, use [`break`](https://doc.rust-lang.org/reference/expressions/"
-"loop-expr.html#break-expressions),\n"
+"- If you want to exit a loop early, use [`break`](https://doc.rust-lang.org/"
+"reference/expressions/loop-expr.html#break-expressions),\n"
"- If you want to immediately start\n"
-"the next iteration use [`continue`](https://doc.rust-lang.org/reference/expressions/loop-expr."
-"html#continue-expressions)."
+"the next iteration use [`continue`](https://doc.rust-lang.org/reference/"
+"expressions/loop-expr.html#continue-expressions)."
msgstr ""
-"- Se vuoi uscire prima da un ciclo, usa [`break`](https://doc.rust-lang.org/reference/expressions/"
-"loop-expr.html#break-expressions),\n"
+"- Se vuoi uscire prima da un ciclo, usa [`break`](https://doc.rust-lang.org/"
+"reference/expressions/loop-expr.html#break-expressions),\n"
"- Se vuoi iniziare subito\n"
-"l'iterazione successiva usa [`continue`](https://doc.rust-lang.org/reference/expressions/loop-expr."
-"html#continue-expressions)."
+"l'iterazione successiva usa [`continue`](https://doc.rust-lang.org/reference/"
+"expressions/loop-expr.html#continue-expressions)."
#: src/control-flow/break-continue.md:7
#, fuzzy
msgid ""
-"Both `continue` and `break` can optionally take a label argument which is used\n"
+"Both `continue` and `break` can optionally take a label argument which is "
+"used\n"
"to break out of nested loops:"
msgstr ""
-"Sia `continue` che `break` possono facoltativamente accettare un argomento label che viene "
-"utilizzato\n"
+"Sia `continue` che `break` possono facoltativamente accettare un argomento "
+"label che viene utilizzato\n"
"per uscire dai cicli nidificati:"
#: src/control-flow/break-continue.md:10
@@ -7232,8 +8025,11 @@ msgstr ""
#: src/control-flow/break-continue.md:28
#, fuzzy
-msgid "In this case we break the outer loop after 3 iterations of the inner loop."
-msgstr "In questo caso interrompiamo il ciclo esterno dopo 3 iterazioni del ciclo interno."
+msgid ""
+"In this case we break the outer loop after 3 iterations of the inner loop."
+msgstr ""
+"In questo caso interrompiamo il ciclo esterno dopo 3 iterazioni del ciclo "
+"interno."
#: src/std.md:1
#, fuzzy
@@ -7243,13 +8039,16 @@ msgstr "# Libreria standard"
#: src/std.md:3
#, fuzzy
msgid ""
-"Rust comes with a standard library which helps establish a set of common types\n"
-"used by Rust library and programs. This way, two libraries can work together\n"
+"Rust comes with a standard library which helps establish a set of common "
+"types\n"
+"used by Rust library and programs. This way, two libraries can work "
+"together\n"
"smoothly because they both use the same `String` type."
msgstr ""
-"Rust viene fornito con una libreria standard che aiuta a stabilire un insieme di tipi comuni\n"
-"utilizzato dalla libreria e dai programmi Rust. In questo modo, due librerie possono lavorare "
-"insieme\n"
+"Rust viene fornito con una libreria standard che aiuta a stabilire un "
+"insieme di tipi comuni\n"
+"utilizzato dalla libreria e dai programmi Rust. In questo modo, due librerie "
+"possono lavorare insieme\n"
"senza problemi perché entrambi usano lo stesso tipo `Stringa`."
#: src/std.md:7
@@ -7260,7 +8059,8 @@ msgstr "I tipi di vocabolario comuni includono:"
#: src/std.md:9
#, fuzzy
msgid ""
-"* [`Option` and `Result`](std/option-result.md) types: used for optional values\n"
+"* [`Option` and `Result`](std/option-result.md) types: used for optional "
+"values\n"
" and [error handling](error-handling.md).\n"
"\n"
"* [`String`](std/string.md): the default string type used for owned data.\n"
@@ -7272,37 +8072,49 @@ msgid ""
"\n"
"* [`Box`](std/box.md): an owned pointer for heap-allocated data.\n"
"\n"
-"* [`Rc`](std/rc.md): a shared reference-counted pointer for heap-allocated data."
+"* [`Rc`](std/rc.md): a shared reference-counted pointer for heap-allocated "
+"data."
msgstr ""
-"* [Tipi `Option` e `Result`](std/option-result.md): usati per valori facoltativi\n"
+"* [Tipi `Option` e `Result`](std/option-result.md): usati per valori "
+"facoltativi\n"
" e [gestione degli errori](error-handling.md).\n"
"\n"
-"* [`String`](std/string.md): il tipo di stringa predefinito utilizzato per i dati di proprietà.\n"
+"* [`String`](std/string.md): il tipo di stringa predefinito utilizzato per i "
+"dati di proprietà.\n"
"\n"
"* [`Vec`](std/vec.md): un vettore estensibile standard.\n"
"\n"
-"* [`HashMap`](std/hashmap.md): un tipo di mappa hash con un hash configurabile\n"
+"* [`HashMap`](std/hashmap.md): un tipo di mappa hash con un hash "
+"configurabile\n"
" algoritmo.\n"
"\n"
-"* [`Box`](std/box.md): un puntatore di proprietà per i dati allocati nell'heap.\n"
+"* [`Box`](std/box.md): un puntatore di proprietà per i dati allocati "
+"nell'heap.\n"
"\n"
-"* [`Rc`](std/rc.md): un puntatore con conteggio dei riferimenti condiviso per i dati allocati "
-"nell'heap."
+"* [`Rc`](std/rc.md): un puntatore con conteggio dei riferimenti condiviso "
+"per i dati allocati nell'heap."
#: src/std.md:25
#, fuzzy
msgid ""
-" * In fact, Rust contains several layers of the Standard Library: `core`, `alloc` and `std`. \n"
-" * `core` includes the most basic types and functions that don't depend on `libc`, allocator or\n"
+" * In fact, Rust contains several layers of the Standard Library: `core`, "
+"`alloc` and `std`. \n"
+" * `core` includes the most basic types and functions that don't depend on "
+"`libc`, allocator or\n"
" even the presence of an operating system. \n"
-" * `alloc` includes types which require a global heap allocator, such as `Vec`, `Box` and `Arc`.\n"
+" * `alloc` includes types which require a global heap allocator, such as "
+"`Vec`, `Box` and `Arc`.\n"
" * Embedded Rust applications often only use `core`, and sometimes `alloc`."
msgstr ""
-" * Infatti, Rust contiene diversi strati della Libreria Standard: `core`, `alloc` e `std`.\n"
-" * `core` include i tipi e le funzioni più basilari che non dipendono da `libc`, allocator o\n"
+" * Infatti, Rust contiene diversi strati della Libreria Standard: `core`, "
+"`alloc` e `std`.\n"
+" * `core` include i tipi e le funzioni più basilari che non dipendono da "
+"`libc`, allocator o\n"
" anche la presenza di un sistema operativo.\n"
-" * `alloc` include tipi che richiedono un allocatore heap globale, come `Vec`, `Box` e `Arc`.\n"
-" * Le applicazioni embedded di Rust spesso usano solo `core` e talvolta `alloc`."
+" * `alloc` include tipi che richiedono un allocatore heap globale, come "
+"`Vec`, `Box` e `Arc`.\n"
+" * Le applicazioni embedded di Rust spesso usano solo `core` e talvolta "
+"`alloc`."
#: src/std/option-result.md:1
#, fuzzy
@@ -7333,18 +8145,22 @@ msgstr ""
msgid ""
"* `Option` and `Result` are widely used not just in the standard library.\n"
"* `Option<&T>` has zero space overhead compared to `&T`.\n"
-"* `Result` is the standard type to implement error handling as we will see on Day 3.\n"
+"* `Result` is the standard type to implement error handling as we will see "
+"on Day 3.\n"
"* `binary_search` returns `Result`.\n"
" * If found, `Result::Ok` holds the index where the element is found.\n"
-" * Otherwise, `Result::Err` contains the index where such an element should be inserted."
+" * Otherwise, `Result::Err` contains the index where such an element should "
+"be inserted."
msgstr ""
-"* `Option` e `Result` sono ampiamente usati non solo nella libreria standard.\n"
+"* `Option` e `Result` sono ampiamente usati non solo nella libreria "
+"standard.\n"
"* `Option<&T>` ha un sovraccarico di spazio pari a zero rispetto a `&T`.\n"
-"* `Result` è il tipo standard per implementare la gestione degli errori, come vedremo il giorno "
-"3.\n"
+"* `Result` è il tipo standard per implementare la gestione degli errori, "
+"come vedremo il giorno 3.\n"
"* `binary_search` restituisce `Result`.\n"
" * Se trovato, `Result::Ok` contiene l'indice in cui si trova l'elemento.\n"
-" * Altrimenti, `Result::Err` contiene l'indice in cui tale elemento dovrebbe essere inserito."
+" * Altrimenti, `Result::Err` contiene l'indice in cui tale elemento "
+"dovrebbe essere inserito."
#: src/std/string.md:1
#, fuzzy
@@ -7353,8 +8169,11 @@ msgstr "# Corda"
#: src/std/string.md:3
#, fuzzy
-msgid "[`String`][1] is the standard heap-allocated growable UTF-8 string buffer:"
-msgstr "[`String`][1] è il buffer di stringa UTF-8 espandibile allocato nell'heap standard:"
+msgid ""
+"[`String`][1] is the standard heap-allocated growable UTF-8 string buffer:"
+msgstr ""
+"[`String`][1] è il buffer di stringa UTF-8 espandibile allocato nell'heap "
+"standard:"
#: src/std/string.md:5
msgid ""
@@ -7379,32 +8198,39 @@ msgstr ""
#: src/std/string.md:22
#, fuzzy
msgid ""
-"`String` implements [`Deref`][2], which means that you can call all\n"
+"`String` implements [`Deref`][2], which means that you can "
+"call all\n"
"`str` methods on a `String`."
msgstr ""
-"`String` implementa [`Deref`][2], il che significa che puoi chiamare tutti\n"
+"`String` implementa [`Deref`][2], il che significa che puoi "
+"chiamare tutti\n"
"metodi `str` su una `stringa`."
#: src/std/string.md:30
msgid ""
-"* `String::new` returns a new empty string, use `String::with_capacity` when you know how much "
-"data you want to push to the string.\n"
-"* `String::len` returns the size of the `String` in bytes (which can be different from its length "
-"in characters).\n"
-"* `String::chars` returns an iterator over the actual characters. Note that a `char` can be "
-"different from what a human will consider a \"character\" due to [grapheme clusters](https://docs."
-"rs/unicode-segmentation/latest/unicode_segmentation/struct.Graphemes.html).\n"
-"* When people refer to strings they could either be talking about `&str` or `String`. \n"
-"* When a type implements `Deref`, the compiler will let you transparently call methods "
-"from `T`.\n"
-" * `String` implements `Deref` which transparently gives it access to `str`'s "
-"methods.\n"
+"* `String::new` returns a new empty string, use `String::with_capacity` when "
+"you know how much data you want to push to the string.\n"
+"* `String::len` returns the size of the `String` in bytes (which can be "
+"different from its length in characters).\n"
+"* `String::chars` returns an iterator over the actual characters. Note that "
+"a `char` can be different from what a human will consider a \"character\" "
+"due to [grapheme clusters](https://docs.rs/unicode-segmentation/latest/"
+"unicode_segmentation/struct.Graphemes.html).\n"
+"* When people refer to strings they could either be talking about `&str` or "
+"`String`. \n"
+"* When a type implements `Deref`, the compiler will let you "
+"transparently call methods from `T`.\n"
+" * `String` implements `Deref` which transparently gives it "
+"access to `str`'s methods.\n"
" * Write and compare `let s3 = s1.deref();` and `let s3 = &*s1`;.\n"
-"* `String` is implemented as a wrapper around a vector of bytes, many of the operations you see "
-"supported on vectors are also supported on `String`, but with some extra guarantees.\n"
+"* `String` is implemented as a wrapper around a vector of bytes, many of the "
+"operations you see supported on vectors are also supported on `String`, but "
+"with some extra guarantees.\n"
"* Compare the different ways to index a `String`:\n"
-" * To a character by using `s3.chars().nth(i).unwrap()` where `i` is in-bound, out-of-bounds.\n"
-" * To a substring by using `s3[0..4]`, where that slice is on character boundaries or not."
+" * To a character by using `s3.chars().nth(i).unwrap()` where `i` is in-"
+"bound, out-of-bounds.\n"
+" * To a substring by using `s3[0..4]`, where that slice is on character "
+"boundaries or not."
msgstr ""
#: src/std/vec.md:1
@@ -7447,26 +8273,32 @@ msgstr ""
#: src/std/vec.md:29
#, fuzzy
msgid ""
-"`Vec` implements [`Deref`][2], which means that you can call slice\n"
+"`Vec` implements [`Deref`][2], which means that you can call "
+"slice\n"
"methods on a `Vec`."
msgstr ""
-"`Vec` implementa [`Deref`][2], il che significa che puoi chiamare slice\n"
+"`Vec` implementa [`Deref`][2], il che significa che puoi "
+"chiamare slice\n"
"metodi su un `Vec`."
#: src/std/vec.md:37
msgid ""
-"* `Vec` is a type of collection, along with `String` and `HashMap`. The data it contains is "
-"stored\n"
-" on the heap. This means the amount of data doesn't need to be known at compile time. It can "
-"grow\n"
+"* `Vec` is a type of collection, along with `String` and `HashMap`. The data "
+"it contains is stored\n"
+" on the heap. This means the amount of data doesn't need to be known at "
+"compile time. It can grow\n"
" or shrink at runtime.\n"
-"* Notice how `Vec` is a generic type too, but you don't have to specify `T` explicitly. As "
-"always\n"
-" with Rust type inference, the `T` was established during the first `push` call.\n"
-"* `vec![...]` is a canonical macro to use instead of `Vec::new()` and it supports adding initial\n"
+"* Notice how `Vec` is a generic type too, but you don't have to specify "
+"`T` explicitly. As always\n"
+" with Rust type inference, the `T` was established during the first `push` "
+"call.\n"
+"* `vec![...]` is a canonical macro to use instead of `Vec::new()` and it "
+"supports adding initial\n"
" elements to the vector.\n"
-"* To index the vector you use `[` `]`, but they will panic if out of bounds. Alternatively, using\n"
-" `get` will return an `Option`. The `pop` function will remove the last element.\n"
+"* To index the vector you use `[` `]`, but they will panic if out of bounds. "
+"Alternatively, using\n"
+" `get` will return an `Option`. The `pop` function will remove the last "
+"element.\n"
"* Show iterating over a vector and mutating the value:\n"
" `for e in &mut v { *e += 50; }`"
msgstr ""
@@ -7488,7 +8320,8 @@ msgid ""
"\n"
"fn main() {\n"
" let mut page_counts = HashMap::new();\n"
-" page_counts.insert(\"Adventures of Huckleberry Finn\".to_string(), 207);\n"
+" page_counts.insert(\"Adventures of Huckleberry Finn\".to_string(), "
+"207);\n"
" page_counts.insert(\"Grimms' Fairy Tales\".to_string(), 751);\n"
" page_counts.insert(\"Pride and Prejudice\".to_string(), 303);\n"
"\n"
@@ -7497,7 +8330,8 @@ msgid ""
" page_counts.len());\n"
" }\n"
"\n"
-" for book in [\"Pride and Prejudice\", \"Alice's Adventure in Wonderland\"] {\n"
+" for book in [\"Pride and Prejudice\", \"Alice's Adventure in "
+"Wonderland\"] {\n"
" match page_counts.get(book) {\n"
" Some(count) => println!(\"{book}: {count} pages\"),\n"
" None => println!(\"{book} is unknown.\")\n"
@@ -7505,8 +8339,10 @@ msgid ""
" }\n"
"\n"
" // Use the .entry() method to insert a value if nothing is found.\n"
-" for book in [\"Pride and Prejudice\", \"Alice's Adventure in Wonderland\"] {\n"
-" let page_count: &mut i32 = page_counts.entry(book.to_string()).or_insert(0);\n"
+" for book in [\"Pride and Prejudice\", \"Alice's Adventure in "
+"Wonderland\"] {\n"
+" let page_count: &mut i32 = page_counts.entry(book.to_string())."
+"or_insert(0);\n"
" *page_count += 1;\n"
" }\n"
"\n"
@@ -7517,10 +8353,11 @@ msgstr ""
#: src/std/hashmap.md:38
msgid ""
-"* `HashMap` is not defined in the prelude and needs to be brought into scope.\n"
-"* Try the following lines of code. The first line will see if a book is in the hashmap and if not "
-"return an alternative value. The second line will insert the alternative value in the hashmap if "
-"the book is not found.\n"
+"* `HashMap` is not defined in the prelude and needs to be brought into "
+"scope.\n"
+"* Try the following lines of code. The first line will see if a book is in "
+"the hashmap and if not return an alternative value. The second line will "
+"insert the alternative value in the hashmap if the book is not found.\n"
"\n"
" ```rust,ignore\n"
" let pc1 = page_counts\n"
@@ -7531,8 +8368,8 @@ msgid ""
" .or_insert(374);\n"
" ```\n"
"* Unlike `vec!`, there is unfortunately no standard `hashmap!` macro.\n"
-" * Although, since Rust 1.56, HashMap implements [`From<[(K, V); N]>`][1], which allows us to "
-"easily initialize a hash map from a literal array:\n"
+" * Although, since Rust 1.56, HashMap implements [`From<[(K, V); N]>`][1], "
+"which allows us to easily initialize a hash map from a literal array:\n"
"\n"
" ```rust,ignore\n"
" let page_counts = HashMap::from([\n"
@@ -7541,12 +8378,14 @@ msgid ""
" ]);\n"
" ```\n"
"\n"
-" * Alternatively HashMap can be built from any `Iterator` which yields key-value tuples.\n"
-"* We are showing `HashMap`, and avoid using `&str` as key to make examples easier. "
-"Using references in collections can, of course, be done,\n"
+" * Alternatively HashMap can be built from any `Iterator` which yields key-"
+"value tuples.\n"
+"* We are showing `HashMap`, and avoid using `&str` as key to "
+"make examples easier. Using references in collections can, of course, be "
+"done,\n"
" but it can lead into complications with the borrow checker.\n"
-" * Try removing `to_string()` from the example above and see if it still compiles. Where do you "
-"think we might run into issues?"
+" * Try removing `to_string()` from the example above and see if it still "
+"compiles. Where do you think we might run into issues?"
msgstr ""
#: src/std/box.md:1
@@ -7588,32 +8427,38 @@ msgstr ""
#: src/std/box.md:26
#, fuzzy
msgid ""
-"`Box` implements `Deref`, which means that you can [call methods\n"
+"`Box` implements `Deref`, which means that you can [call "
+"methods\n"
"from `T` directly on a `Box`][2]."
msgstr ""
-"`Box` implementa `Deref`, il che significa che puoi [chiamare metodi\n"
+"`Box` implementa `Deref`, il che significa che puoi [chiamare "
+"metodi\n"
"da `T` direttamente su un `Box`][2]."
#: src/std/box.md:34
#, fuzzy
msgid ""
-"* `Box` is like `std::unique_ptr` in C++, except that it's guaranteed to be not null. \n"
-"* In the above example, you can even leave out the `*` in the `println!` statement thanks to "
-"`Deref`. \n"
+"* `Box` is like `std::unique_ptr` in C++, except that it's guaranteed to be "
+"not null. \n"
+"* In the above example, you can even leave out the `*` in the `println!` "
+"statement thanks to `Deref`. \n"
"* A `Box` can be useful when you:\n"
-" * have a type whose size that can't be known at compile time, but the Rust compiler wants to "
-"know an exact size.\n"
-" * want to transfer ownership of a large amount of data. To avoid copying large amounts of data "
-"on the stack, instead store the data on the heap in a `Box` so only the pointer is moved."
+" * have a type whose size that can't be known at compile time, but the "
+"Rust compiler wants to know an exact size.\n"
+" * want to transfer ownership of a large amount of data. To avoid copying "
+"large amounts of data on the stack, instead store the data on the heap in a "
+"`Box` so only the pointer is moved."
msgstr ""
-"* `Box` è come `std::unique_ptr` in C++, tranne per il fatto che è garantito che non sia nullo.\n"
-"* Nell'esempio sopra, puoi anche tralasciare `*` nell'istruzione `println!` grazie a `Deref`.\n"
+"* `Box` è come `std::unique_ptr` in C++, tranne per il fatto che è garantito "
+"che non sia nullo.\n"
+"* Nell'esempio sopra, puoi anche tralasciare `*` nell'istruzione `println!` "
+"grazie a `Deref`.\n"
"* Una `Box` può essere utile quando:\n"
-" * hanno un tipo la cui dimensione non può essere conosciuta in fase di compilazione, ma il "
-"compilatore Rust vuole conoscere una dimensione esatta.\n"
-" * desidera trasferire la proprietà di una grande quantità di dati. Per evitare di copiare "
-"grandi quantità di dati nello stack, archivia invece i dati nell'heap in un \"Box\" in modo che "
-"venga spostato solo il puntatore."
+" * hanno un tipo la cui dimensione non può essere conosciuta in fase di "
+"compilazione, ma il compilatore Rust vuole conoscere una dimensione esatta.\n"
+" * desidera trasferire la proprietà di una grande quantità di dati. Per "
+"evitare di copiare grandi quantità di dati nello stack, archivia invece i "
+"dati nell'heap in un \"Box\" in modo che venga spostato solo il puntatore."
#: src/std/box-recursive.md:1
#, fuzzy
@@ -7622,9 +8467,11 @@ msgstr "# Box con strutture dati ricorsive"
#: src/std/box-recursive.md:3
#, fuzzy
-msgid "Recursive data types or data types with dynamic sizes need to use a `Box`:"
+msgid ""
+"Recursive data types or data types with dynamic sizes need to use a `Box`:"
msgstr ""
-"I tipi di dati ricorsivi o i tipi di dati con dimensioni dinamiche devono utilizzare un `Box`:"
+"I tipi di dati ricorsivi o i tipi di dati con dimensioni dinamiche devono "
+"utilizzare un `Box`:"
#: src/std/box-recursive.md:5 src/std/box-niche.md:3
msgid ""
@@ -7636,7 +8483,8 @@ msgid ""
"}\n"
"\n"
"fn main() {\n"
-" let list: List = List::Cons(1, Box::new(List::Cons(2, Box::new(List::Nil))));\n"
+" let list: List = List::Cons(1, Box::new(List::Cons(2, Box::"
+"new(List::Nil))));\n"
" println!(\"{list:?}\");\n"
"}\n"
"```"
@@ -7646,45 +8494,54 @@ msgstr ""
msgid ""
"```bob\n"
" Stack Heap\n"
-".- - - - - - - - - - - - -. .- - - - - - - - - - - - - - - - - - - - - - - -.\n"
+".- - - - - - - - - - - - -. .- - - - - - - - - - - - - - - - - - - - - - "
+"- -.\n"
": : : :\n"
-": list : : :\n"
-": +------+----+----+ : : +------+----+----+ +------+----+----+ :\n"
-": | Cons | 1 | o--+----+-----+--->| Cons | 2 | o--+--->| Nil | // | // | :\n"
-": +------+----+----+ : : +------+----+----+ +------+----+----+ :\n"
+": "
+"list : : :\n"
+": +------+----+----+ : : +------+----+----+ +------+----+----"
+"+ :\n"
+": | Cons | 1 | o--+----+-----+--->| Cons | 2 | o--+--->| Nil | // | // "
+"| :\n"
+": +------+----+----+ : : +------+----+----+ +------+----+----"
+"+ :\n"
": : : :\n"
": : : :\n"
-"'- - - - - - - - - - - - -' '- - - - - - - - - - - - - - - - - - - - - - - -'\n"
+"'- - - - - - - - - - - - -' '- - - - - - - - - - - - - - - - - - - - - - "
+"- -'\n"
"```"
msgstr ""
#: src/std/box-recursive.md:33
#, fuzzy
msgid ""
-"* If the `Box` was not used here and we attempted to embed a `List` directly into the `List`,\n"
-"the compiler would not compute a fixed size of the struct in memory, it would look infinite.\n"
+"* If `Box` was not used and we attempted to embed a `List` directly into the "
+"`List`,\n"
+"the compiler would not compute a fixed size of the struct in memory (`List` "
+"would be of infinite size).\n"
"\n"
-"* `Box` solves this problem as it has the same size as a regular pointer and just points at the "
-"next\n"
+"* `Box` solves this problem as it has the same size as a regular pointer and "
+"just points at the next\n"
"element of the `List` in the heap.\n"
"\n"
-"* Remove the `Box` in the List definition and show the compiler error. \"Recursive with "
-"indirection\" is a hint you might want to use a Box or reference of some kind, instead of storing "
-"a value directly. \n"
+"* Remove the `Box` in the List definition and show the compiler error. "
+"\"Recursive with indirection\" is a hint you might want to use a Box or "
+"reference of some kind, instead of storing a value directly. \n"
" "
msgstr ""
-"* Se la `Box` non è stata utilizzata qui e abbiamo tentato di incorporare una `Lista` direttamente "
-"nella `Lista`,\n"
-"il compilatore non calcolerebbe una dimensione fissa della struttura in memoria, sembrerebbe "
-"infinita.\n"
+"* Se la `Box` non è stata utilizzata qui e abbiamo tentato di incorporare "
+"una `Lista` direttamente nella `Lista`,\n"
+"il compilatore non calcolerebbe una dimensione fissa della struttura in "
+"memoria, sembrerebbe infinita.\n"
"\n"
-"* `Box` risolve questo problema poiché ha le stesse dimensioni di un normale puntatore e punta "
-"solo al successivo\n"
+"* `Box` risolve questo problema poiché ha le stesse dimensioni di un normale "
+"puntatore e punta solo al successivo\n"
"elemento della \"Lista\" nell'heap.\n"
"\n"
-"* Rimuovi il `Box` nella definizione dell'elenco e mostra l'errore del compilatore. \"Ricorsivo "
-"con indiretto\" è un suggerimento che potresti voler utilizzare un Box o un riferimento di qualche "
-"tipo, invece di memorizzare direttamente un valore.\n"
+"* Rimuovi il `Box` nella definizione dell'elenco e mostra l'errore del "
+"compilatore. \"Ricorsivo con indiretto\" è un suggerimento che potresti "
+"voler utilizzare un Box o un riferimento di qualche tipo, invece di "
+"memorizzare direttamente un valore.\n"
" "
#: src/std/box-niche.md:1
@@ -7695,25 +8552,33 @@ msgstr "# Ottimizzazione di nicchia"
#: src/std/box-niche.md:16
#, fuzzy
msgid ""
-"A `Box` cannot be empty, so the pointer is always valid and non-`null`. This\n"
+"A `Box` cannot be empty, so the pointer is always valid and non-`null`. "
+"This\n"
"allows the compiler to optimize the memory layout:"
msgstr ""
-"Un `Box` non può essere vuoto, quindi il puntatore è sempre valido e non `null`. Questo\n"
+"Un `Box` non può essere vuoto, quindi il puntatore è sempre valido e non "
+"`null`. Questo\n"
"consente al compilatore di ottimizzare il layout della memoria:"
#: src/std/box-niche.md:19
msgid ""
"```bob\n"
" Stack Heap\n"
-".- - - - - - - - - - - - -. .- - - - - - - - - - - - - - - - - - - - - - -.\n"
+".- - - - - - - - - - - - -. .- - - - - - - - - - - - - - - - - - - - - - "
+"-.\n"
": : : :\n"
-": list : : :\n"
-": +----+----+ : : +----+----+ +----+------+ :\n"
-": | 1 | o--+-----------+-----+--->| 2 | o--+--->| // | null | :\n"
-": +----+----+ : : +----+----+ +----+------+ :\n"
+": "
+"list : : :\n"
+": +----+----+ : : +----+----+ +----+------"
+"+ :\n"
+": | 1 | o--+-----------+-----+--->| 2 | o--+--->| // | null "
+"| :\n"
+": +----+----+ : : +----+----+ +----+------"
+"+ :\n"
": : : :\n"
": : : :\n"
-"`- - - - - - - - - - - - -' '- - - - - - - - - - - - - - - - - - - - - - -'\n"
+"`- - - - - - - - - - - - -' '- - - - - - - - - - - - - - - - - - - - - - "
+"-'\n"
"```"
msgstr ""
@@ -7725,11 +8590,12 @@ msgstr "# `Rc`"
#: src/std/rc.md:3
#, fuzzy
msgid ""
-"[`Rc`][1] is a reference-counted shared pointer. Use this when you need to refer\n"
+"[`Rc`][1] is a reference-counted shared pointer. Use this when you need to "
+"refer\n"
"to the same data from multiple places:"
msgstr ""
-"[`Rc`][1] è un puntatore condiviso con conteggio dei riferimenti. Usalo quando hai bisogno di fare "
-"riferimento\n"
+"[`Rc`][1] è un puntatore condiviso con conteggio dei riferimenti. Usalo "
+"quando hai bisogno di fare riferimento\n"
"agli stessi dati da più posizioni:"
#: src/std/rc.md:6
@@ -7750,50 +8616,59 @@ msgstr ""
#: src/std/rc.md:18
#, fuzzy
msgid ""
-"* If you need to mutate the data inside an `Rc`, you will need to wrap the data in\n"
+"* If you need to mutate the data inside an `Rc`, you will need to wrap the "
+"data in\n"
" a type such as [`Cell` or `RefCell`][2].\n"
"* See [`Arc`][3] if you are in a multi-threaded context.\n"
-"* You can *downgrade* a shared pointer into a [`Weak`][4] pointer to create cycles\n"
+"* You can *downgrade* a shared pointer into a [`Weak`][4] pointer to create "
+"cycles\n"
" that will get dropped."
msgstr ""
-"* Se hai bisogno di mutare i dati all'interno di un `Rc`, dovrai racchiudere i dati\n"
+"* Se hai bisogno di mutare i dati all'interno di un `Rc`, dovrai racchiudere "
+"i dati\n"
" un tipo come [`Cell` o `RefCell`][2].\n"
"* Vedere [`Arc`][3] se ci si trova in un contesto multi-thread.\n"
-"* Puoi *declassare* un puntatore condiviso in un puntatore [`Weak`][4] per creare cicli\n"
+"* Puoi *declassare* un puntatore condiviso in un puntatore [`Weak`][4] per "
+"creare cicli\n"
" che verrà abbandonato."
#: src/std/rc.md:31
#, fuzzy
msgid ""
-"* `Rc`'s count ensures that its contained value is valid for as long as there are references.\n"
-"* Like C++'s `std::shared_ptr`.\n"
-"* `Rc::clone` is cheap: it creates a pointer to the same allocation and increases the reference "
-"count. Does not make a deep clone and can generally be ignored when looking for performance issues "
-"in code.\n"
-"* `make_mut` actually clones the inner value if necessary (\"clone-on-write\") and returns a "
-"mutable reference.\n"
+"* `Rc`'s count ensures that its contained value is valid for as long as "
+"there are references.\n"
+"* `Rc` in Rust is like `std::shared_ptr` in C++.\n"
+"* `Rc::clone` is cheap: it creates a pointer to the same allocation and "
+"increases the reference count. Does not make a deep clone and can generally "
+"be ignored when looking for performance issues in code.\n"
+"* `make_mut` actually clones the inner value if necessary (\"clone-on-"
+"write\") and returns a mutable reference.\n"
"* Use `Rc::strong_count` to check the reference count.\n"
-"* Compare the different datatypes mentioned. `Box` enables (im)mutable borrows that are enforced "
-"at compile time. `RefCell` enables (im)mutable borrows that are enforced at run time and will "
-"panic if it fails at runtime.\n"
+"* Compare the different datatypes mentioned. `Box` enables (im)mutable "
+"borrows that are enforced at compile time. `RefCell` enables (im)mutable "
+"borrows that are enforced at run time and will panic if it fails at "
+"runtime.\n"
"* `Rc::downgrade` gives you a *weakly reference-counted* object to\n"
" create cycles that will be dropped properly (likely in combination with\n"
" `RefCell`)."
msgstr ""
-"* Il conteggio di `Rc` assicura che il suo valore contenuto sia valido finché ci sono "
-"riferimenti.\n"
+"* Il conteggio di `Rc` assicura che il suo valore contenuto sia valido "
+"finché ci sono riferimenti.\n"
"* Come `std::shared_ptr` di C++.\n"
-"* `Rc::clone` è economico: crea un puntatore alla stessa allocazione e aumenta il conteggio dei "
-"riferimenti. Non crea un clone profondo e generalmente può essere ignorato quando si cercano "
-"problemi di prestazioni nel codice.\n"
-"* `make_mut` in realtà clona il valore interno se necessario (\"clone-on-write\") e restituisce un "
-"riferimento mutabile.\n"
+"* `Rc::clone` è economico: crea un puntatore alla stessa allocazione e "
+"aumenta il conteggio dei riferimenti. Non crea un clone profondo e "
+"generalmente può essere ignorato quando si cercano problemi di prestazioni "
+"nel codice.\n"
+"* `make_mut` in realtà clona il valore interno se necessario (\"clone-on-"
+"write\") e restituisce un riferimento mutabile.\n"
"* Usa `Rc::strong_count` per controllare il conteggio dei riferimenti.\n"
-"* Confronta i diversi tipi di dati menzionati. `Box` abilita i prestiti (im)mutabili che vengono "
-"applicati in fase di compilazione. `RefCell` abilita i prestiti (im)mutabili che vengono applicati "
-"in fase di esecuzione e andranno in panico se falliscono in fase di esecuzione.\n"
+"* Confronta i diversi tipi di dati menzionati. `Box` abilita i prestiti "
+"(im)mutabili che vengono applicati in fase di compilazione. `RefCell` "
+"abilita i prestiti (im)mutabili che vengono applicati in fase di esecuzione "
+"e andranno in panico se falliscono in fase di esecuzione.\n"
"* `Rc::downgrade` fornisce un oggetto *debolmente contato* a\n"
-" creare cicli che verranno eliminati correttamente (probabilmente in combinazione con\n"
+" creare cicli che verranno eliminati correttamente (probabilmente in "
+"combinazione con\n"
" `RefCella`)."
#: src/std/rc.md:41
@@ -7836,12 +8711,14 @@ msgstr "# Moduli"
#, fuzzy
msgid "We have seen how `impl` blocks let us namespace functions to a type."
msgstr ""
-"Abbiamo visto come i blocchi `impl` ci permettono di utilizzare lo spazio dei nomi per un tipo."
+"Abbiamo visto come i blocchi `impl` ci permettono di utilizzare lo spazio "
+"dei nomi per un tipo."
#: src/modules.md:5
#, fuzzy
msgid "Similarly, `mod` lets us namespace types and functions:"
-msgstr "Allo stesso modo, `mod` ci consente tipi e funzioni dello spazio dei nomi:"
+msgstr ""
+"Allo stesso modo, `mod` ci consente tipi e funzioni dello spazio dei nomi:"
#: src/modules.md:7
msgid ""
@@ -7868,17 +8745,18 @@ msgstr ""
#: src/modules.md:28
#, fuzzy
msgid ""
-"* Packages provide functionality and include a `Cargo.toml` file that describes how to build a "
-"bundle of 1+ crates.\n"
-"* Crates are a tree of modules, where a binary crate creates an executable and a library crate "
-"compiles to a library.\n"
+"* Packages provide functionality and include a `Cargo.toml` file that "
+"describes how to build a bundle of 1+ crates.\n"
+"* Crates are a tree of modules, where a binary crate creates an executable "
+"and a library crate compiles to a library.\n"
"* Modules define organization, scope, and are the focus of this section."
msgstr ""
-"* I pacchetti forniscono funzionalità e includono un file `Cargo.toml` che descrive come costruire "
-"un pacchetto di 1+ casse.\n"
-"* I crate sono un albero di moduli, in cui un crate binario crea un eseguibile e un crate di "
-"libreria viene compilato in una libreria.\n"
-"* I moduli definiscono l'organizzazione, l'ambito e sono il fulcro di questa sezione."
+"* I pacchetti forniscono funzionalità e includono un file `Cargo.toml` che "
+"descrive come costruire un pacchetto di 1+ casse.\n"
+"* I crate sono un albero di moduli, in cui un crate binario crea un "
+"eseguibile e un crate di libreria viene compilato in una libreria.\n"
+"* I moduli definiscono l'organizzazione, l'ambito e sono il fulcro di questa "
+"sezione."
#: src/modules/visibility.md:1
#, fuzzy
@@ -7895,13 +8773,15 @@ msgstr "I moduli sono un limite di privacy:"
msgid ""
"* Module items are private by default (hides implementation details).\n"
"* Parent and sibling items are always visible.\n"
-"* In other words, if an item is visible in module `foo`, it's visible in all the\n"
+"* In other words, if an item is visible in module `foo`, it's visible in all "
+"the\n"
" descendants of `foo`."
msgstr ""
-"* Gli elementi del modulo sono privati per impostazione predefinita (nasconde i dettagli di "
-"implementazione).\n"
+"* Gli elementi del modulo sono privati per impostazione predefinita "
+"(nasconde i dettagli di implementazione).\n"
"* Gli elementi dei genitori e dei fratelli sono sempre visibili.\n"
-"* In altre parole, se un elemento è visibile nel modulo `foo`, è visibile in tutti i file\n"
+"* In altre parole, se un elemento è visibile nel modulo `foo`, è visibile in "
+"tutti i file\n"
" discendenti di `foo`."
#: src/modules/visibility.md:10
@@ -7942,26 +8822,28 @@ msgstr "* Usa la parola chiave `pub` per rendere pubblici i moduli."
#: src/modules/visibility.md:41
#, fuzzy
msgid ""
-"Additionally, there are advanced `pub(...)` specifiers to restrict the scope of public visibility."
+"Additionally, there are advanced `pub(...)` specifiers to restrict the scope "
+"of public visibility."
msgstr ""
-"Inoltre, ci sono specificatori avanzati `pub(...)` per restringere l'ambito della visibilità "
-"pubblica."
+"Inoltre, ci sono specificatori avanzati `pub(...)` per restringere l'ambito "
+"della visibilità pubblica."
#: src/modules/visibility.md:43
#, fuzzy
msgid ""
-"* See the [Rust Reference](https://doc.rust-lang.org/reference/visibility-and-privacy.html#pubin-"
-"path-pubcrate-pubsuper-and-pubself).\n"
+"* See the [Rust Reference](https://doc.rust-lang.org/reference/visibility-"
+"and-privacy.html#pubin-path-pubcrate-pubsuper-and-pubself).\n"
"* Configuring `pub(crate)` visibility is a common pattern.\n"
"* Less commonly, you can give visibility to a specific path.\n"
-"* In any case, visibility must be granted to an ancestor module (and all of its descendants)."
+"* In any case, visibility must be granted to an ancestor module (and all of "
+"its descendants)."
msgstr ""
-"* Vedere il [riferimento Rust](https://doc.rust-lang.org/reference/visibility-and-privacy."
-"html#pubin-path-pubcrate-pubsuper-and-pubself).\n"
+"* Vedere il [riferimento Rust](https://doc.rust-lang.org/reference/"
+"visibility-and-privacy.html#pubin-path-pubcrate-pubsuper-and-pubself).\n"
"* La configurazione della visibilità di `pub(crate)` è un modello comune.\n"
"* Meno comunemente, puoi dare visibilità a un percorso specifico.\n"
-"* In ogni caso, la visibilità deve essere concessa a un modulo predecessore (ea tutti i suoi "
-"discendenti)."
+"* In ogni caso, la visibilità deve essere concessa a un modulo predecessore "
+"(ea tutti i suoi discendenti)."
#: src/modules/paths.md:1
#, fuzzy
@@ -8043,7 +8925,8 @@ msgstr ""
#: src/modules/filesystem.md:14
#, fuzzy
msgid "Similarly, a `garden::vegetables` module can be found at:"
-msgstr "Allo stesso modo, un modulo `garden::vegetables` può essere trovato in:"
+msgstr ""
+"Allo stesso modo, un modulo `garden::vegetables` può essere trovato in:"
#: src/modules/filesystem.md:16
#, fuzzy
@@ -8071,17 +8954,19 @@ msgstr ""
#: src/modules/filesystem.md:24
#, fuzzy
msgid ""
-"Modules defined in files can be documented, too, using \"inner doc comments\".\n"
+"Modules defined in files can be documented, too, using \"inner doc "
+"comments\".\n"
"These document the item that contains them -- in this case, a module."
msgstr ""
-"Anche i moduli definiti nei file possono essere documentati utilizzando \"commenti interni al "
-"documento\".\n"
+"Anche i moduli definiti nei file possono essere documentati utilizzando "
+"\"commenti interni al documento\".\n"
"Questi documentano l'elemento che li contiene, in questo caso un modulo."
#: src/modules/filesystem.md:27
msgid ""
"```rust,editable,compile_fail\n"
-"//! This module implements the garden, including a highly performant germination\n"
+"//! This module implements the garden, including a highly performant "
+"germination\n"
"//! implementation.\n"
"\n"
"// Re-export types from this module.\n"
@@ -8098,8 +8983,8 @@ msgstr ""
#: src/modules/filesystem.md:44
msgid ""
-"* The change from `module/mod.rs` to `module.rs` doesn't preclude the use of submodules in Rust "
-"2018.\n"
+"* The change from `module/mod.rs` to `module.rs` doesn't preclude the use of "
+"submodules in Rust 2018.\n"
" (It was mandatory in Rust 2015.)\n"
"\n"
" The following is valid:\n"
@@ -8112,10 +8997,12 @@ msgid ""
" └── sub_module.rs\n"
" ```\n"
"\n"
-"* The main reason for the change is to prevent many files named `mod.rs`, which can be hard\n"
+"* The main reason for the change is to prevent many files named `mod.rs`, "
+"which can be hard\n"
" to distinguish in IDEs.\n"
"\n"
-"* Rust will look for modules in `modulename/mod.rs` and `modulename.rs`, but this can be changed\n"
+"* Rust will look for modules in `modulename/mod.rs` and `modulename.rs`, but "
+"this can be changed\n"
" with a compiler directive:\n"
"\n"
" ```rust,ignore\n"
@@ -8123,7 +9010,8 @@ msgid ""
" mod some_module { }\n"
" ```\n"
"\n"
-" This is useful, for example, if you would like to place tests for a module in a file named\n"
+" This is useful, for example, if you would like to place tests for a module "
+"in a file named\n"
" `some_module_test.rs`, similar to the convention in Go."
msgstr ""
@@ -8135,7 +9023,8 @@ msgstr "# Giorno 2: Esercizi pomeridiani"
#: src/exercises/day-2/afternoon.md:3
#, fuzzy
msgid "The exercises for this afternoon will focus on strings and iterators."
-msgstr "Gli esercizi di questo pomeriggio si concentreranno su stringhe e iteratori."
+msgstr ""
+"Gli esercizi di questo pomeriggio si concentreranno su stringhe e iteratori."
#: src/exercises/day-2/luhn.md:1
#, fuzzy
@@ -8145,12 +9034,16 @@ msgstr "# Algoritmo di Luhn"
#: src/exercises/day-2/luhn.md:3
#, fuzzy
msgid ""
-"The [Luhn algorithm](https://en.wikipedia.org/wiki/Luhn_algorithm) is used to\n"
-"validate credit card numbers. The algorithm takes a string as input and does the\n"
+"The [Luhn algorithm](https://en.wikipedia.org/wiki/Luhn_algorithm) is used "
+"to\n"
+"validate credit card numbers. The algorithm takes a string as input and does "
+"the\n"
"following to validate the credit card number:"
msgstr ""
-"L'[algoritmo di Luhn](https://en.wikipedia.org/wiki/Luhn_algorithm) viene utilizzato per\n"
-"convalidare i numeri di carta di credito. L'algoritmo prende una stringa come input e fa il\n"
+"L'[algoritmo di Luhn](https://en.wikipedia.org/wiki/Luhn_algorithm) viene "
+"utilizzato per\n"
+"convalidare i numeri di carta di credito. L'algoritmo prende una stringa "
+"come input e fa il\n"
"seguente per convalidare il numero della carta di credito:"
#: src/exercises/day-2/luhn.md:7
@@ -8158,10 +9051,12 @@ msgstr ""
msgid ""
"* Ignore all spaces. Reject number with less than two digits.\n"
"\n"
-"* Moving from right to left, double every second digit: for the number `1234`,\n"
+"* Moving from right to left, double every second digit: for the number "
+"`1234`,\n"
" we double `3` and `1`.\n"
"\n"
-"* After doubling a digit, sum the digits. So doubling `7` becomes `14` which\n"
+"* After doubling a digit, sum the digits. So doubling `7` becomes `14` "
+"which\n"
" becomes `5`.\n"
"\n"
"* Sum all the undoubled and doubled digits.\n"
@@ -8170,10 +9065,12 @@ msgid ""
msgstr ""
"* Ignora tutti gli spazi. Rifiuta il numero con meno di due cifre.\n"
"\n"
-"* Spostandoti da destra a sinistra, raddoppia ogni seconda cifra: per il numero `1234`,\n"
+"* Spostandoti da destra a sinistra, raddoppia ogni seconda cifra: per il "
+"numero `1234`,\n"
" raddoppiamo \"3\" e \"1\".\n"
"\n"
-"* Dopo aver raddoppiato una cifra, somma le cifre. Quindi raddoppiando \"7\" diventa \"14\" which\n"
+"* Dopo aver raddoppiato una cifra, somma le cifre. Quindi raddoppiando \"7\" "
+"diventa \"14\" which\n"
" diventa \"5\".\n"
"\n"
"* Somma tutte le cifre non raddoppiate e raddoppiate.\n"
@@ -8186,7 +9083,8 @@ msgid ""
"Copy the following code to Point {}`? Isn't that redundant?\n"
-" * This is because it is a generic implementation section for generic type. They are "
-"independently generic.\n"
+"* *Q:* Why `T` is specified twice in `impl Point {}`? Isn't that "
+"redundant?\n"
+" * This is because it is a generic implementation section for generic "
+"type. They are independently generic.\n"
" * It means these methods are defined for any `T`.\n"
" * It is possible to write `impl Point { .. }`. \n"
-" * `Point` is still generic and you can use `Point`, but methods in this block will only "
-"be available for `Point`."
+" * `Point` is still generic and you can use `Point`, but methods "
+"in this block will only be available for `Point`."
msgstr ""
-"* *D:* Perché `T` è specificato due volte in `impl Point {}`? Non è ridondante?\n"
-" * Questo perché si tratta di una sezione di implementazione generica per un tipo generico. "
-"Sono indipendentemente generici.\n"
+"* *D:* Perché `T` è specificato due volte in `impl Point {}`? Non è "
+"ridondante?\n"
+" * Questo perché si tratta di una sezione di implementazione generica per "
+"un tipo generico. Sono indipendentemente generici.\n"
" * Significa che questi metodi sono definiti per qualsiasi `T`.\n"
" * È possibile scrivere `impl Point { .. }`.\n"
-" * `Point` è ancora generico e puoi usare `Point`, ma i metodi in questo blocco saranno "
-"disponibili solo per `Point`."
+" * `Point` è ancora generico e puoi usare `Point`, ma i metodi in "
+"questo blocco saranno disponibili solo per `Point`."
#: src/generics/monomorphization.md:1
#, fuzzy
@@ -8458,7 +9375,9 @@ msgstr "# Monomorfizzazione"
#: src/generics/monomorphization.md:3
#, fuzzy
msgid "Generic code is turned into non-generic code based on the call sites:"
-msgstr "Il codice generico viene trasformato in codice non generico in base ai siti di chiamata:"
+msgstr ""
+"Il codice generico viene trasformato in codice non generico in base ai siti "
+"di chiamata:"
#: src/generics/monomorphization.md:5
msgid ""
@@ -8498,10 +9417,12 @@ msgstr ""
#: src/generics/monomorphization.md:31
#, fuzzy
msgid ""
-"This is a zero-cost abstraction: you get exactly the same result as if you had\n"
+"This is a zero-cost abstraction: you get exactly the same result as if you "
+"had\n"
"hand-coded the data structures without the abstraction."
msgstr ""
-"Questa è un'astrazione a costo zero: ottieni esattamente lo stesso risultato che se avessi\n"
+"Questa è un'astrazione a costo zero: ottieni esattamente lo stesso risultato "
+"che se avessi\n"
"codificato a mano le strutture dati senza l'astrazione."
#: src/traits.md:1
@@ -8511,8 +9432,11 @@ msgstr "# Tratti"
#: src/traits.md:3
#, fuzzy
-msgid "Rust lets you abstract over types with traits. They're similar to interfaces:"
-msgstr "Rust ti consente di astrarre sui tipi con tratti. Sono simili alle interfacce:"
+msgid ""
+"Rust lets you abstract over types with traits. They're similar to interfaces:"
+msgstr ""
+"Rust ti consente di astrarre sui tipi con tratti. Sono simili alle "
+"interfacce:"
#: src/traits.md:5
msgid ""
@@ -8535,7 +9459,8 @@ msgid ""
"\n"
"impl Pet for Cat {\n"
" fn name(&self) -> String {\n"
-" String::from(\"The cat\") // No name, cats won't respond to it anyway.\n"
+" String::from(\"The cat\") // No name, cats won't respond to it "
+"anyway.\n"
" }\n"
"}\n"
"\n"
@@ -8560,8 +9485,12 @@ msgstr "# Oggetti tratto"
#: src/traits/trait-objects.md:3
#, fuzzy
-msgid "Trait objects allow for values of different types, for instance in a collection:"
-msgstr "Gli oggetti tratto consentono valori di tipi diversi, ad esempio in una raccolta:"
+msgid ""
+"Trait objects allow for values of different types, for instance in a "
+"collection:"
+msgstr ""
+"Gli oggetti tratto consentono valori di tipi diversi, ad esempio in una "
+"raccolta:"
#: src/traits/trait-objects.md:5
msgid ""
@@ -8584,7 +9513,8 @@ msgid ""
"\n"
"impl Pet for Cat {\n"
" fn name(&self) -> String {\n"
-" String::from(\"The cat\") // No name, cats won't respond to it anyway.\n"
+" String::from(\"The cat\") // No name, cats won't respond to it "
+"anyway.\n"
" }\n"
"}\n"
"\n"
@@ -8609,45 +9539,70 @@ msgstr "Layout della memoria dopo l'allocazione di \"animali domestici\":"
msgid ""
"```bob\n"
" Stack Heap\n"
-".- - - - - - - - - - - - - -. .- - - - - - - - - - - - - - - - - - - - - - -.\n"
+".- - - - - - - - - - - - - -. .- - - - - - - - - - - - - - - - - - - - - "
+"- -.\n"
": : : :\n"
-": pets : : :\n"
-": +-----------+-------+ : : +-----+-----+ :\n"
-": | ptr | o---+---+-----+-->| o o | o o | :\n"
-": | len | 2 | : : +-|-|-+-|-|-+ :\n"
-": | capacity | 2 | : : | | | | +---------------+ :\n"
-": +-----------+-------+ : : | | | '-->| name: \"Fido\" | :\n"
-": : : | | | +---------------+ :\n"
-"`- - - - - - - - - - - - - -' : | | | :\n"
-" : | | | +----------------------+ : \n"
-" : | | '---->| \"::name\" | :\n"
-" : | | +----------------------+ : \n"
-" : | | : \n"
-" : | | +-+ : \n"
-" : | '-->|\\| : \n"
-" : | +-+ : \n"
-" : | : \n"
-" : | +----------------------+ : \n"
-" : '---->| \"::name\" | : \n"
-" : +----------------------+ :\n"
+": "
+"pets : : :\n"
+": +-----------+-------+ : : +-----+-----"
+"+ :\n"
+": | ptr | o---+---+-----+-->| o o | o o "
+"| :\n"
+": | len | 2 | : : +-|-|-+-|-|-"
+"+ :\n"
+": | capacity | 2 | : : | | | | +---------------"
+"+ :\n"
+": +-----------+-------+ : : | | | '-->| name: \"Fido\" "
+"| :\n"
+": : : | | | +---------------"
+"+ :\n"
+"`- - - - - - - - - - - - - -' : | | "
+"| :\n"
+" : | | | +----------------------"
+"+ : \n"
+" : | | '---->| \"::name\" "
+"| :\n"
+" : | | +----------------------"
+"+ : \n"
+" : | "
+"| : \n"
+" : | | +-"
+"+ : \n"
+" : | '-->|"
+"\\| : \n"
+" : | +-"
+"+ : \n"
+" : "
+"| : \n"
+" : | +----------------------"
+"+ : \n"
+" : '---->| \"::name\" "
+"| : \n"
+" : +----------------------"
+"+ :\n"
" : :\n"
-" '- - - - - - - - - - - - - - - - - - - - - - -'\n"
+" '- - - - - - - - - - - - - - - - - - - - - "
+"- -'\n"
"\n"
"```"
msgstr ""
#: src/traits/trait-objects.md:72
msgid ""
-"* Types that implement a given trait may be of different sizes. This makes it impossible to have "
-"things like `Vec` in the example above.\n"
-"* `dyn Pet` is a way to tell the compiler about a dynamically sized type that implements `Pet`.\n"
-"* In the example, `pets` holds *fat pointers* to objects that implement `Pet`. The fat pointer "
-"consists of two components, a pointer to the actual object and a pointer to the virtual method "
-"table for the `Pet` implementation of that particular object.\n"
+"* Types that implement a given trait may be of different sizes. This makes "
+"it impossible to have things like `Vec` in the example above.\n"
+"* `dyn Pet` is a way to tell the compiler about a dynamically sized type "
+"that implements `Pet`.\n"
+"* In the example, `pets` holds *fat pointers* to objects that implement "
+"`Pet`. The fat pointer consists of two components, a pointer to the actual "
+"object and a pointer to the virtual method table for the `Pet` "
+"implementation of that particular object.\n"
"* Compare these outputs in the above example:\n"
" ```rust,ignore\n"
-" println!(\"{} {}\", std::mem::size_of::(), std::mem::size_of::());\n"
-" println!(\"{} {}\", std::mem::size_of::<&Dog>(), std::mem::size_of::<&Cat>());\n"
+" println!(\"{} {}\", std::mem::size_of::(), std::mem::size_of::"
+"());\n"
+" println!(\"{} {}\", std::mem::size_of::<&Dog>(), std::mem::size_of::"
+"<&Cat>());\n"
" println!(\"{}\", std::mem::size_of::<&dyn Pet>());\n"
" println!(\"{}\", std::mem::size_of::>());\n"
" ```"
@@ -8690,7 +9645,9 @@ msgstr "# Metodi predefiniti"
#: src/traits/default-methods.md:3
#, fuzzy
msgid "Traits can implement behavior in terms of other trait methods:"
-msgstr "I tratti possono implementare il comportamento in termini di altri metodi di tratto:"
+msgstr ""
+"I tratti possono implementare il comportamento in termini di altri metodi di "
+"tratto:"
#: src/traits/default-methods.md:5
msgid ""
@@ -8723,28 +9680,50 @@ msgstr ""
#: src/traits/default-methods.md:32
#, fuzzy
msgid ""
-"* Traits may specify pre-implemented (default) methods and methods that users are required to\n"
-" implement themselves. Methods with default implementations can rely on required methods.\n"
+"* Traits may specify pre-implemented (default) methods and methods that "
+"users are required to\n"
+" implement themselves. Methods with default implementations can rely on "
+"required methods.\n"
"\n"
"* Move method `not_equal` to a new trait `NotEqual`.\n"
"\n"
-"* Make `NotEqual` a super trait for `Equal`.\n"
+"* Make `Equals` a super trait for `NotEqual`.\n"
+" ```rust,editable,compile_fail\n"
+" trait NotEqual: Equals {\n"
+" fn not_equal(&self, other: &Self) -> bool {\n"
+" !self.equal(other)\n"
+" }\n"
+" }\n"
+" ```\n"
"\n"
"* Provide a blanket implementation of `NotEqual` for `Equal`.\n"
-" * With the blanket implementation, you no longer need `NotEqual` as a super trait for `Equal`."
+" ```rust,editable,compile_fail\n"
+" trait NotEqual {\n"
+" fn not_equal(&self, other: &Self) -> bool;\n"
+" }\n"
+"\n"
+" impl NotEqual for T where T: Equals {\n"
+" fn not_equal(&self, other: &Self) -> bool {\n"
+" !self.equal(other)\n"
+" }\n"
+" }\n"
+" ```\n"
+" * With the blanket implementation, you no longer need `Equals` as a super "
+"trait for `NotEqual`.\n"
+" "
msgstr ""
-"* I tratti possono specificare metodi pre-implementati (predefiniti) e metodi richiesti agli "
-"utenti\n"
-" implementare se stessi. I metodi con implementazioni predefinite possono fare affidamento sui "
-"metodi richiesti.\n"
+"* I tratti possono specificare metodi pre-implementati (predefiniti) e "
+"metodi richiesti agli utenti\n"
+" implementare se stessi. I metodi con implementazioni predefinite possono "
+"fare affidamento sui metodi richiesti.\n"
"\n"
"* Sposta il metodo `not_equal` in un nuovo tratto `NotEqual`.\n"
"\n"
"* Rendi `NotEqual` un super tratto per `Equal`.\n"
"\n"
"* Fornire un'implementazione globale di \"NotEqual\" per \"Equal\".\n"
-" * Con l'implementazione coperta, non hai più bisogno di \"NotEqual\" come super tratto per "
-"\"Equal\"."
+" * Con l'implementazione coperta, non hai più bisogno di \"NotEqual\" come "
+"super tratto per \"Equal\"."
#: src/traits/trait-bounds.md:1
#, fuzzy
@@ -8754,10 +9733,12 @@ msgstr "# Limiti dei tratti"
#: src/traits/trait-bounds.md:3
#, fuzzy
msgid ""
-"When working with generics, you often want to require the types to implement\n"
+"When working with generics, you often want to require the types to "
+"implement\n"
"some trait, so that you can call this trait's methods."
msgstr ""
-"Quando si lavora con i generici, spesso si desidera richiedere i tipi da implementare\n"
+"Quando si lavora con i generici, spesso si desidera richiedere i tipi da "
+"implementare\n"
"qualche tratto, in modo da poter chiamare i metodi di questo tratto."
#: src/traits/trait-bounds.md:6
@@ -8796,7 +9777,9 @@ msgstr ""
#: src/traits/trait-bounds.md:35
#, fuzzy
msgid "Show a `where` clause, students will encounter it when reading code."
-msgstr "Mostra una clausola `where`, gli studenti la incontreranno durante la lettura del codice."
+msgstr ""
+"Mostra una clausola `where`, gli studenti la incontreranno durante la "
+"lettura del codice."
#: src/traits/trait-bounds.md:37
msgid ""
@@ -8815,14 +9798,14 @@ msgstr ""
msgid ""
"* It declutters the function signature if you have many parameters.\n"
"* It has additional features making it more powerful.\n"
-" * If someone asks, the extra feature is that the type on the left of \":\" can be arbitrary, "
-"like `Option`.\n"
+" * If someone asks, the extra feature is that the type on the left of \":"
+"\" can be arbitrary, like `Option`.\n"
" "
msgstr ""
"* Riordina la firma della funzione se hai molti parametri.\n"
"* Ha funzionalità aggiuntive che lo rendono più potente.\n"
-" * Se qualcuno lo chiede, la caratteristica extra è che il tipo a sinistra di \":\" può essere "
-"arbitrario, come `Option`.\n"
+" * Se qualcuno lo chiede, la caratteristica extra è che il tipo a "
+"sinistra di \":\" può essere arbitrario, come `Option`.\n"
" "
#: src/traits/impl-trait.md:1
@@ -8836,7 +9819,8 @@ msgid ""
"Similar to trait bounds, an `impl Trait` syntax can be used in function\n"
"arguments and return values:"
msgstr ""
-"Simile ai limiti dei tratti, in funzione può essere utilizzata una sintassi `impl Trait`\n"
+"Simile ai limiti dei tratti, in funzione può essere utilizzata una sintassi "
+"`impl Trait`\n"
"argomenti e valori restituiti:"
#: src/traits/impl-trait.md:6
@@ -8862,59 +9846,77 @@ msgstr "* `impl Trait` ti permette di lavorare con tipi che non puoi nominare."
#: src/traits/impl-trait.md:23
#, fuzzy
-msgid "The meaning of `impl Trait` is a bit different in the different positions."
-msgstr "Il significato di \"impl Trait\" è leggermente diverso nelle diverse posizioni."
+msgid ""
+"The meaning of `impl Trait` is a bit different in the different positions."
+msgstr ""
+"Il significato di \"impl Trait\" è leggermente diverso nelle diverse "
+"posizioni."
#: src/traits/impl-trait.md:25
#, fuzzy
msgid ""
-"* For a parameter, `impl Trait` is like an anonymous generic parameter with a trait bound.\n"
+"* For a parameter, `impl Trait` is like an anonymous generic parameter with "
+"a trait bound.\n"
"\n"
-"* For a return type, it means that the return type is some concrete type that implements the "
-"trait,\n"
-" without naming the type. This can be useful when you don't want to expose the concrete type in "
-"a\n"
+"* For a return type, it means that the return type is some concrete type "
+"that implements the trait,\n"
+" without naming the type. This can be useful when you don't want to expose "
+"the concrete type in a\n"
" public API.\n"
"\n"
-" Inference is hard in return position. A function returning `impl Foo` picks\n"
-" the concrete type it returns, without writing it out in the source. A function\n"
+" Inference is hard in return position. A function returning `impl Foo` "
+"picks\n"
+" the concrete type it returns, without writing it out in the source. A "
+"function\n"
" returning a generic type like `collect() -> B` can return any type\n"
-" satisfying `B`, and the caller may need to choose one, such as with `let x:\n"
+" satisfying `B`, and the caller may need to choose one, such as with `let "
+"x:\n"
" Vec<_> = foo.collect()` or with the turbofish, `foo.collect::>()`."
msgstr ""
-"* Per un parametro, `impl Trait` è come un parametro generico anonimo con un tratto associato.\n"
+"* Per un parametro, `impl Trait` è come un parametro generico anonimo con un "
+"tratto associato.\n"
"\n"
-"* Per un tipo restituito, significa che il tipo restituito è un tipo concreto che implementa il "
-"tratto,\n"
-" senza nominare il tipo. Questo può essere utile quando non vuoi esporre il tipo concreto in a\n"
+"* Per un tipo restituito, significa che il tipo restituito è un tipo "
+"concreto che implementa il tratto,\n"
+" senza nominare il tipo. Questo può essere utile quando non vuoi esporre il "
+"tipo concreto in a\n"
" API pubblica.\n"
"\n"
-" L'inferenza è difficile nella posizione di ritorno. Una funzione che restituisce le scelte `impl "
-"Foo`\n"
-" il tipo concreto che restituisce, senza scriverlo nella fonte. Una funzione\n"
-" restituire un tipo generico come `collect() -> B` può restituire qualsiasi tipo\n"
-" soddisfacente `B`, e il chiamante potrebbe aver bisogno di sceglierne uno, come con `let x:\n"
+" L'inferenza è difficile nella posizione di ritorno. Una funzione che "
+"restituisce le scelte `impl Foo`\n"
+" il tipo concreto che restituisce, senza scriverlo nella fonte. Una "
+"funzione\n"
+" restituire un tipo generico come `collect() -> B` può restituire "
+"qualsiasi tipo\n"
+" soddisfacente `B`, e il chiamante potrebbe aver bisogno di sceglierne uno, "
+"come con `let x:\n"
" Vec<_> = foo.collect()` o con il turbofish, `foo.collect::>()`."
#: src/traits/impl-trait.md:37
#, fuzzy
msgid ""
-"This example is great, because it uses `impl Display` twice. It helps to explain that\n"
-"nothing here enforces that it is _the same_ `impl Display` type. If we used a single \n"
-"`T: Display`, it would enforce the constraint that input `T` and return `T` type are the same "
-"type.\n"
-"It would not work for this particular function, as the type we expect as input is likely not\n"
-"what `format!` returns. If we wanted to do the same via `: Display` syntax, we'd need two\n"
+"This example is great, because it uses `impl Display` twice. It helps to "
+"explain that\n"
+"nothing here enforces that it is _the same_ `impl Display` type. If we used "
+"a single \n"
+"`T: Display`, it would enforce the constraint that input `T` and return `T` "
+"type are the same type.\n"
+"It would not work for this particular function, as the type we expect as "
+"input is likely not\n"
+"what `format!` returns. If we wanted to do the same via `: Display` syntax, "
+"we'd need two\n"
"independent generic parameters."
msgstr ""
-"Questo esempio è fantastico, perché utilizza `impl Display` due volte. Aiuta a spiegarlo\n"
-"nulla qui impone che sia _lo stesso_ tipo `impl Display`. Se usiamo un singolo\n"
-"`T: Display`, imporrebbe il vincolo secondo cui l'input `T` e il tipo restituito `T` sono dello "
-"stesso tipo.\n"
-"Non funzionerebbe per questa particolare funzione, poiché probabilmente non lo è il tipo che ci "
-"aspettiamo come input\n"
-"quale `formato!` restituisce. Se volessimo fare lo stesso tramite la sintassi `: Display`, ne "
-"avremmo bisogno di due\n"
+"Questo esempio è fantastico, perché utilizza `impl Display` due volte. Aiuta "
+"a spiegarlo\n"
+"nulla qui impone che sia _lo stesso_ tipo `impl Display`. Se usiamo un "
+"singolo\n"
+"`T: Display`, imporrebbe il vincolo secondo cui l'input `T` e il tipo "
+"restituito `T` sono dello stesso tipo.\n"
+"Non funzionerebbe per questa particolare funzione, poiché probabilmente non "
+"lo è il tipo che ci aspettiamo come input\n"
+"quale `formato!` restituisce. Se volessimo fare lo stesso tramite la "
+"sintassi `: Display`, ne avremmo bisogno di due\n"
"parametri generici indipendenti."
#: src/traits/important-traits.md:1
@@ -8924,8 +9926,11 @@ msgstr "# Tratti importanti"
#: src/traits/important-traits.md:3
#, fuzzy
-msgid "We will now look at some of the most common traits of the Rust standard library:"
-msgstr "Vedremo ora alcuni dei tratti più comuni della libreria standard di Rust:"
+msgid ""
+"We will now look at some of the most common traits of the Rust standard "
+"library:"
+msgstr ""
+"Vedremo ora alcuni dei tratti più comuni della libreria standard di Rust:"
#: src/traits/important-traits.md:5
#, fuzzy
@@ -8985,32 +9990,33 @@ msgstr ""
#: src/traits/iterator.md:32
#, fuzzy
msgid ""
-"* The `Iterator` trait implements many common functional programming operations over collections \n"
-" (e.g. `map`, `filter`, `reduce`, etc). This is the trait where you can find all the "
-"documentation\n"
-" about them. In Rust these functions should produce the code as efficient as equivalent "
-"imperative\n"
+"* The `Iterator` trait implements many common functional programming "
+"operations over collections \n"
+" (e.g. `map`, `filter`, `reduce`, etc). This is the trait where you can "
+"find all the documentation\n"
+" about them. In Rust these functions should produce the code as efficient "
+"as equivalent imperative\n"
" implementations.\n"
" \n"
-"* `IntoIterator` is the trait that makes for loops work. It is implemented by collection types "
-"such as\n"
-" `Vec` and references to them such as `&Vec` and `&[T]`. Ranges also implement it. This is "
-"why\n"
+"* `IntoIterator` is the trait that makes for loops work. It is implemented "
+"by collection types such as\n"
+" `Vec` and references to them such as `&Vec` and `&[T]`. Ranges also "
+"implement it. This is why\n"
" you can iterate over a vector with `for i in some_vec { .. }` but\n"
" `some_vec.next()` doesn't exist."
msgstr ""
-"* Il tratto `Iterator` implementa molte comuni operazioni di programmazione funzionale sulle "
-"raccolte\n"
-" (ad es. `map`, `filter`, `reduce`, ecc.). Questo è il tratto in cui puoi trovare tutta la "
-"documentazione\n"
-" su di loro. In Rust queste funzioni dovrebbero produrre il codice tanto efficiente quanto "
-"imperativo equivalente\n"
+"* Il tratto `Iterator` implementa molte comuni operazioni di programmazione "
+"funzionale sulle raccolte\n"
+" (ad es. `map`, `filter`, `reduce`, ecc.). Questo è il tratto in cui puoi "
+"trovare tutta la documentazione\n"
+" su di loro. In Rust queste funzioni dovrebbero produrre il codice tanto "
+"efficiente quanto imperativo equivalente\n"
" implementazioni.\n"
" \n"
-"* `IntoIterator` è la caratteristica che fa funzionare i cicli for. È implementato da tipi di "
-"raccolta come\n"
-" `Vec` e riferimenti ad essi come `&Vec` e `&[T]`. Anche le gamme lo implementano. Ecco "
-"perché\n"
+"* `IntoIterator` è la caratteristica che fa funzionare i cicli for. È "
+"implementato da tipi di raccolta come\n"
+" `Vec` e riferimenti ad essi come `&Vec` e `&[T]`. Anche le gamme lo "
+"implementano. Ecco perché\n"
" puoi iterare su un vettore con `for i in some_vec { .. }` ma\n"
" `some_vec.next()` non esiste."
@@ -9021,8 +10027,10 @@ msgstr "# FromIterator"
#: src/traits/from-iterator.md:3
#, fuzzy
-msgid "[`FromIterator`][1] lets you build a collection from an [`Iterator`][2]."
-msgstr "[`FromIterator`][1] consente di creare una raccolta da un [`Iterator`][2]."
+msgid ""
+"[`FromIterator`][1] lets you build a collection from an [`Iterator`][2]."
+msgstr ""
+"[`FromIterator`][1] consente di creare una raccolta da un [`Iterator`][2]."
#: src/traits/from-iterator.md:5
msgid ""
@@ -9058,7 +10066,8 @@ msgid ""
"There are also implementations which let you do cool things like convert an\n"
"`Iterator- >` into a `Result
, E>`."
msgstr ""
-"Ci sono anche implementazioni che ti permettono di fare cose interessanti come convertire un file\n"
+"Ci sono anche implementazioni che ti permettono di fare cose interessanti "
+"come convertire un file\n"
"`Iterator- >` in un `Result
, E>`."
#: src/traits/from-into.md:1
@@ -9068,8 +10077,11 @@ msgstr "# `Da` e `Into`"
#: src/traits/from-into.md:3
#, fuzzy
-msgid "Types implement [`From`][1] and [`Into`][2] to facilitate type conversions:"
-msgstr "I tipi implementano [`From`][1] e [`Into`][2] per facilitare le conversioni di tipo:"
+msgid ""
+"Types implement [`From`][1] and [`Into`][2] to facilitate type conversions:"
+msgstr ""
+"I tipi implementano [`From`][1] e [`Into`][2] per facilitare le conversioni "
+"di tipo:"
#: src/traits/from-into.md:5
msgid ""
@@ -9086,8 +10098,11 @@ msgstr ""
#: src/traits/from-into.md:15
#, fuzzy
-msgid "[`Into`][2] is automatically implemented when [`From`][1] is implemented:"
-msgstr "[`Into`][2] viene implementato automaticamente quando [`From`][1] è implementato:"
+msgid ""
+"[`Into`][2] is automatically implemented when [`From`][1] is implemented:"
+msgstr ""
+"[`Into`][2] viene implementato automaticamente quando [`From`][1] è "
+"implementato:"
#: src/traits/from-into.md:17
msgid ""
@@ -9105,18 +10120,21 @@ msgstr ""
#: src/traits/from-into.md:29
#, fuzzy
msgid ""
-"* That's why it is common to only implement `From`, as your type will get `Into` implementation "
-"too.\n"
-"* When declaring a function argument input type like \"anything that can be converted into a "
-"`String`\", the rule is opposite, you should use `Into`.\n"
-" Your function will accept types that implement `From` and those that _only_ implement `Into`.\n"
+"* That's why it is common to only implement `From`, as your type will get "
+"`Into` implementation too.\n"
+"* When declaring a function argument input type like \"anything that can be "
+"converted into a `String`\", the rule is opposite, you should use `Into`.\n"
+" Your function will accept types that implement `From` and those that "
+"_only_ implement `Into`.\n"
" "
msgstr ""
-"* Ecco perché è comune implementare solo `From`, poiché anche il tuo tipo otterrà "
-"l'implementazione di `Into`.\n"
-"* Quando si dichiara un tipo di input per l'argomento di una funzione come \"qualsiasi cosa che "
-"può essere convertita in una `Stringa`\", la regola è opposta, si dovrebbe usare `Into`.\n"
-" La tua funzione accetterà tipi che implementano `From` e quelli che _solo_ implementano `Into`.\n"
+"* Ecco perché è comune implementare solo `From`, poiché anche il tuo tipo "
+"otterrà l'implementazione di `Into`.\n"
+"* Quando si dichiara un tipo di input per l'argomento di una funzione come "
+"\"qualsiasi cosa che può essere convertita in una `Stringa`\", la regola è "
+"opposta, si dovrebbe usare `Into`.\n"
+" La tua funzione accetterà tipi che implementano `From` e quelli che _solo_ "
+"implementano `Into`.\n"
" "
#: src/traits/read-write.md:1
@@ -9126,7 +10144,8 @@ msgstr "# `Leggi` e `Scrivi`"
#: src/traits/read-write.md:3
#, fuzzy
-msgid "Using [`Read`][1] and [`BufRead`][2], you can abstract over `u8` sources:"
+msgid ""
+"Using [`Read`][1] and [`BufRead`][2], you can abstract over `u8` sources:"
msgstr "Usando [`Read`][1] e [`BufRead`][2], puoi astrarre su fonti `u8`:"
#: src/traits/read-write.md:5
@@ -9182,10 +10201,12 @@ msgstr "# Il tratto `Drop`"
#: src/traits/drop.md:3
#, fuzzy
-msgid "Values which implement [`Drop`][1] can specify code to run when they go out of scope:"
+msgid ""
+"Values which implement [`Drop`][1] can specify code to run when they go out "
+"of scope:"
msgstr ""
-"I valori che implementano [`Drop`][1] possono specificare il codice da eseguire quando escono "
-"dall'ambito:"
+"I valori che implementano [`Drop`][1] possono specificare il codice da "
+"eseguire quando escono dall'ambito:"
#: src/traits/drop.md:5
msgid ""
@@ -9226,14 +10247,17 @@ msgstr "Punti di discussione:"
#, fuzzy
msgid ""
"* Why doesn't `Drop::drop` take `self`?\n"
-" * Short-answer: If it did, `std::mem::drop` would be called at the end of\n"
+" * Short-answer: If it did, `std::mem::drop` would be called at the end "
+"of\n"
" the block, resulting in another call to `Drop::drop`, and a stack\n"
" overflow!\n"
"* Try replacing `drop(a)` with `a.drop()`."
msgstr ""
"* Perché `Drop::drop` non accetta `self`?\n"
-" * Risposta breve: se così fosse, `std::mem::drop` verrebbe chiamato alla fine di\n"
-" il blocco, risultando in un'altra chiamata a `Drop::drop` e uno stack\n"
+" * Risposta breve: se così fosse, `std::mem::drop` verrebbe chiamato alla "
+"fine di\n"
+" il blocco, risultando in un'altra chiamata a `Drop::drop` e uno "
+"stack\n"
" traboccare!\n"
"* Prova a sostituire `drop(a)` con `a.drop()`."
@@ -9244,8 +10268,10 @@ msgstr "# Il tratto `Predefinito`"
#: src/traits/default.md:3
#, fuzzy
-msgid "[`Default`][1] trait provides a default implementation of a trait."
-msgstr "Il tratto [`Default`][1] fornisce un'implementazione predefinita di un tratto."
+msgid "[`Default`][1] trait produces a default value for a type."
+msgstr ""
+"Il tratto [`Default`][1] fornisce un'implementazione predefinita di un "
+"tratto."
#: src/traits/default.md:5
msgid ""
@@ -9286,24 +10312,28 @@ msgstr ""
#: src/traits/default.md:40
#, fuzzy
msgid ""
-" * It can be implemented directly or it can be derived via `#[derive(Default)]`.\n"
-" * Derived implementation will produce an instance where all fields are set to their default "
-"values.\n"
+" * It can be implemented directly or it can be derived via "
+"`#[derive(Default)]`.\n"
+" * A derived implementation will produce a value where all fields are set "
+"to their default values.\n"
" * This means all types in the struct must implement `Default` too.\n"
-" * Standard Rust types often implement `Default` with reasonable values (e.g. `0`, `\"\"`, etc).\n"
+" * Standard Rust types often implement `Default` with reasonable values (e."
+"g. `0`, `\"\"`, etc).\n"
" * The partial struct copy works nicely with default.\n"
-" * Rust standard library is aware that types can implement `Default` and provides convenience "
-"methods that use it."
+" * Rust standard library is aware that types can implement `Default` and "
+"provides convenience methods that use it."
msgstr ""
-" * Può essere implementato direttamente o può essere derivato tramite `#[derive(Default)]`.\n"
-" * L'implementazione derivata produrrà un'istanza in cui tutti i campi sono impostati sui valori "
-"predefiniti.\n"
-" * Ciò significa che anche tutti i tipi nella struttura devono implementare `Default`.\n"
-" * I tipi Rust standard spesso implementano `Default` con valori ragionevoli (ad esempio `0`, "
-"`\"\"`, ecc.).\n"
+" * Può essere implementato direttamente o può essere derivato tramite "
+"`#[derive(Default)]`.\n"
+" * L'implementazione derivata produrrà un'istanza in cui tutti i campi sono "
+"impostati sui valori predefiniti.\n"
+" * Ciò significa che anche tutti i tipi nella struttura devono "
+"implementare `Default`.\n"
+" * I tipi Rust standard spesso implementano `Default` con valori "
+"ragionevoli (ad esempio `0`, `\"\"`, ecc.).\n"
" * La copia parziale della struttura funziona bene con default.\n"
-" * La libreria standard di Rust sa che i tipi possono implementare `Default` e fornisce comodi "
-"metodi che lo utilizzano."
+" * La libreria standard di Rust sa che i tipi possono implementare "
+"`Default` e fornisce comodi metodi che lo utilizzano."
#: src/traits/operators.md:1
#, fuzzy
@@ -9313,7 +10343,9 @@ msgstr "# `Aggiungi`, `Mul`, ..."
#: src/traits/operators.md:3
#, fuzzy
msgid "Operator overloading is implemented via traits in [`std::ops`][1]:"
-msgstr "L'overload degli operatori è implementato tramite i tratti in [`std::ops`][1]:"
+msgstr ""
+"L'overload degli operatori è implementato tramite i tratti in [`std::ops`]"
+"[1]:"
#: src/traits/operators.md:5
msgid ""
@@ -9340,24 +10372,36 @@ msgstr ""
#: src/traits/operators.md:28
#, fuzzy
msgid ""
-"* You could implement `Add` for `&Point`. In which situations is that useful? \n"
+"* You could implement `Add` for `&Point`. In which situations is that "
+"useful? \n"
" * Answer: `Add:add` consumes `self`. If type `T` for which you are\n"
-" overloading the operator is not `Copy`, you should consider overloading\n"
-" the operator for `&T` as well. This avoids unnecessary cloning on the\n"
+" overloading the operator is not `Copy`, you should consider "
+"overloading\n"
+" the operator for `&T` as well. This avoids unnecessary cloning on "
+"the\n"
" call site.\n"
-"* Why is `Output` an associated type? Could it be made a type parameter?\n"
-" * Short answer: Type parameters are controlled by the caller, but\n"
-" associated types (like `Output`) are controlled by the implementor of a\n"
-" trait."
+"* Why is `Output` an associated type? Could it be made a type parameter of "
+"the method?\n"
+" * Short answer: Function type parameters are controlled by the caller, "
+"but\n"
+" associated types (like `Output`) are controlled by the implementor "
+"of a\n"
+" trait.\n"
+"* You could implement `Add` for two different types, e.g.\n"
+" `impl Add<(i32, i32)> for Point` would add a tuple to a `Point`."
msgstr ""
"* Puoi implementare `Aggiungi` per `&Punto`. In quali situazioni è utile?\n"
" * Risposta: `Add:add` consuma `self`. Se digita \"T\" per cui sei\n"
-" l'overloading dell'operatore non è `Copy`, dovresti considerare l'overloading\n"
+" l'overloading dell'operatore non è `Copy`, dovresti considerare "
+"l'overloading\n"
" anche l'operatore per `&T`. Ciò evita inutili clonazioni sul file\n"
" sito di chiamata.\n"
-"* Perché `Output` è un tipo associato? Potrebbe essere reso un parametro di tipo?\n"
-" * Risposta breve: i parametri di tipo sono controllati dal chiamante, ma\n"
-" i tipi associati (come `Output`) sono controllati dall'implementatore di a\n"
+"* Perché `Output` è un tipo associato? Potrebbe essere reso un parametro di "
+"tipo?\n"
+" * Risposta breve: i parametri di tipo sono controllati dal chiamante, "
+"ma\n"
+" i tipi associati (come `Output`) sono controllati "
+"dall'implementatore di a\n"
" tratto."
#: src/traits/closures.md:1
@@ -9368,15 +10412,19 @@ msgstr "# Chiusure"
#: src/traits/closures.md:3
#, fuzzy
msgid ""
-"Closures or lambda expressions have types which cannot be named. However, they\n"
+"Closures or lambda expressions have types which cannot be named. However, "
+"they\n"
"implement special [`Fn`](https://doc.rust-lang.org/std/ops/trait.Fn.html),\n"
"[`FnMut`](https://doc.rust-lang.org/std/ops/trait.FnMut.html), and\n"
"[`FnOnce`](https://doc.rust-lang.org/std/ops/trait.FnOnce.html) traits:"
msgstr ""
-"Le chiusure o le espressioni lambda hanno tipi che non possono essere nominati. Tuttavia, loro\n"
-"implementare speciali [`Fn`](https://doc.rust-lang.org/std/ops/trait.Fn.html),\n"
+"Le chiusure o le espressioni lambda hanno tipi che non possono essere "
+"nominati. Tuttavia, loro\n"
+"implementare speciali [`Fn`](https://doc.rust-lang.org/std/ops/trait.Fn."
+"html),\n"
"[`FnMut`](https://doc.rust-lang.org/std/ops/trait.FnMut.html) e\n"
-"[`FnOnce`](https://doc.rust-lang.org/std/ops/trait.FnOnce.html) caratteristiche:"
+"[`FnOnce`](https://doc.rust-lang.org/std/ops/trait.FnOnce.html) "
+"caratteristiche:"
#: src/traits/closures.md:8
msgid ""
@@ -9388,54 +10436,96 @@ msgid ""
"\n"
"fn main() {\n"
" let add_3 = |x| x + 3;\n"
-" let mul_5 = |x| x * 5;\n"
-"\n"
" println!(\"add_3: {}\", apply_with_log(add_3, 10));\n"
-" println!(\"mul_5: {}\", apply_with_log(mul_5, 20));\n"
+" println!(\"add_3: {}\", apply_with_log(add_3, 20));\n"
+"\n"
+" let mut v = Vec::new();\n"
+" let mut accumulate = |x: i32| {\n"
+" v.push(x);\n"
+" v.iter().sum::()\n"
+" };\n"
+" println!(\"accumulate: {}\", apply_with_log(&mut accumulate, 4));\n"
+" println!(\"accumulate: {}\", apply_with_log(&mut accumulate, 5));\n"
+"\n"
+" let multiply_sum = |x| x * v.into_iter().sum::();\n"
+" println!(\"multiply_sum: {}\", apply_with_log(multiply_sum, 3));\n"
"}\n"
"```"
msgstr ""
-#: src/traits/closures.md:25
-#, fuzzy
-msgid "If you have an `FnOnce`, you may only call it once. It might consume captured values."
-msgstr "Se hai un `FnOnce`, puoi chiamarlo solo una volta. Potrebbe consumare i valori acquisiti."
-
-#: src/traits/closures.md:27
+#: src/traits/closures.md:34
#, fuzzy
msgid ""
-"An `FnMut` might mutate captured values, so you can call it multiple times but not concurrently."
+"An `Fn` (e.g. `add_3`) neither consumes nor mutates captured values, or "
+"perhaps captures\n"
+"nothing at all. It can be called multiple times concurrently."
msgstr ""
-"Un `FnMut` potrebbe mutare i valori catturati, quindi puoi chiamarlo più volte ma non "
-"contemporaneamente."
-
-#: src/traits/closures.md:29
-#, fuzzy
-msgid ""
-"An `Fn` neither consumes nor mutates captured values, or perhaps captures nothing at all, so it "
-"can\n"
-"be called multiple times concurrently."
-msgstr ""
-"Un \"Fn\" non consuma né muta i valori acquisiti, o forse non cattura nulla, quindi può farlo\n"
+"Un \"Fn\" non consuma né muta i valori acquisiti, o forse non cattura nulla, "
+"quindi può farlo\n"
"essere chiamato più volte contemporaneamente."
-#: src/traits/closures.md:32
+#: src/traits/closures.md:37
#, fuzzy
msgid ""
-"`FnMut` is a subtype of `FnOnce`. `Fn` is a subtype of `FnMut` and `FnOnce`. I.e. you can use an\n"
-"`FnMut` wherever an `FnOnce` is called for, and you can use an `Fn` wherever an `FnMut` or "
-"`FnOnce`\n"
+"An `FnMut` (e.g. `accumulate`) might mutate captured values. You can call it "
+"multiple times,\n"
+"but not concurrently."
+msgstr ""
+"Un `FnMut` potrebbe mutare i valori catturati, quindi puoi chiamarlo più "
+"volte ma non contemporaneamente."
+
+#: src/traits/closures.md:40
+#, fuzzy
+msgid ""
+"If you have an `FnOnce` (e.g. `multiply_sum`), you may only call it once. It "
+"might consume\n"
+"captured values."
+msgstr ""
+"Se hai un `FnOnce`, puoi chiamarlo solo una volta. Potrebbe consumare i "
+"valori acquisiti."
+
+#: src/traits/closures.md:43
+#, fuzzy
+msgid ""
+"`FnMut` is a subtype of `FnOnce`. `Fn` is a subtype of `FnMut` and `FnOnce`. "
+"I.e. you can use an\n"
+"`FnMut` wherever an `FnOnce` is called for, and you can use an `Fn` wherever "
+"an `FnMut` or `FnOnce`\n"
"is called for."
msgstr ""
-"\"FnMut\" è un sottotipo di \"FnOnce\". \"Fn\" è un sottotipo di \"FnMut\" e \"FnOnce\". Cioè. "
-"puoi usare un\n"
-"`FnMut` ovunque sia richiesto un `FnOnce` e puoi usare un `Fn` ovunque sia `FnMut` o `FnOnce`\n"
+"\"FnMut\" è un sottotipo di \"FnOnce\". \"Fn\" è un sottotipo di \"FnMut\" e "
+"\"FnOnce\". Cioè. puoi usare un\n"
+"`FnMut` ovunque sia richiesto un `FnOnce` e puoi usare un `Fn` ovunque sia "
+"`FnMut` o `FnOnce`\n"
"è richiesto."
-#: src/traits/closures.md:36
-#, fuzzy
-msgid "`move` closures only implement `FnOnce`."
-msgstr "Le chiusure `move` implementano solo `FnOnce`."
+#: src/traits/closures.md:47
+msgid ""
+"The compiler also infers `Copy` (e.g. for `add_3`) and `Clone` (e.g. "
+"`multiply_sum`),\n"
+"depending on what the closure captures."
+msgstr ""
+
+#: src/traits/closures.md:50
+msgid ""
+"By default, closures will capture by reference if they can. The `move` "
+"keyword makes them capture\n"
+"by value."
+msgstr ""
+
+#: src/traits/closures.md:52
+msgid ""
+"```rust,editable\n"
+"fn make_greeter(prefix: String) -> impl Fn(&str) {\n"
+" return move |name| println!(\"{} {}\", prefix, name)\n"
+"}\n"
+"\n"
+"fn main() {\n"
+" let hi = make_greeter(\"Hi\".to_string());\n"
+" hi(\"there\");\n"
+"}\n"
+"```"
+msgstr ""
#: src/exercises/day-3/morning.md:1
#, fuzzy
@@ -9458,7 +10548,8 @@ msgid ""
"Let us design a classical GUI library using our new knowledge of traits and\n"
"trait objects."
msgstr ""
-"Progettiamo una libreria GUI classica utilizzando la nostra nuova conoscenza dei tratti e\n"
+"Progettiamo una libreria GUI classica utilizzando la nostra nuova conoscenza "
+"dei tratti e\n"
"oggetti di tratto."
#: src/exercises/day-3/simple-gui.md:6
@@ -9475,7 +10566,8 @@ msgid ""
"* `Label`: has a `label`."
msgstr ""
"* `Window`: ha un `title` e contiene altri widget.\n"
-"* `Button`: ha una `label` e una funzione di callback che viene richiamata quando il\n"
+"* `Button`: ha una `label` e una funzione di callback che viene richiamata "
+"quando il\n"
" pulsante viene premuto.\n"
"* `Etichetta`: ha una `etichetta`."
@@ -9490,7 +10582,8 @@ msgid ""
"Copy the code below to {\n"
" let username_file_result = fs::File::open(path);\n"
@@ -9890,16 +11008,17 @@ msgid ""
"```"
msgstr ""
-#: src/error-handling/try-operator.md:50 src/error-handling/converting-error-types-example.md:52
+#: src/error-handling/try-operator.md:50
+#: src/error-handling/converting-error-types-example.md:52
#, fuzzy
msgid ""
"* The `username` variable can be either `Ok(string)` or `Err(error)`.\n"
-"* Use the `fs::write` call to test out the different scenarios: no file, empty file, file with "
-"username."
+"* Use the `fs::write` call to test out the different scenarios: no file, "
+"empty file, file with username."
msgstr ""
"* La variabile `username` può essere `Ok(string)` o `Err(error)`.\n"
-"* Usa la chiamata `fs::write` per testare i diversi scenari: nessun file, file vuoto, file con "
-"nome utente."
+"* Usa la chiamata `fs::write` per testare i diversi scenari: nessun file, "
+"file vuoto, file con nome utente."
#: src/error-handling/converting-error-types.md:1
#: src/error-handling/converting-error-types-example.md:1
@@ -9909,8 +11028,12 @@ msgstr "# Conversione dei tipi di errore"
#: src/error-handling/converting-error-types.md:3
#, fuzzy
-msgid "The effective expansion of `?` is a little more complicated than previously indicated:"
-msgstr "L'effettiva espansione di `?` è un po' più complicata di quanto precedentemente indicato:"
+msgid ""
+"The effective expansion of `?` is a little more complicated than previously "
+"indicated:"
+msgstr ""
+"L'effettiva espansione di `?` è un po' più complicata di quanto "
+"precedentemente indicato:"
#: src/error-handling/converting-error-types.md:5
msgid ""
@@ -9937,10 +11060,12 @@ msgstr ""
#: src/error-handling/converting-error-types.md:18
#, fuzzy
msgid ""
-"The `From::from` call here means we attempt to convert the error type to the\n"
+"The `From::from` call here means we attempt to convert the error type to "
+"the\n"
"type returned by the function:"
msgstr ""
-"La chiamata `From::from` qui significa che tentiamo di convertire il tipo di errore in\n"
+"La chiamata `From::from` qui significa che tentiamo di convertire il tipo di "
+"errore in\n"
"tipo restituito dalla funzione:"
#: src/error-handling/converting-error-types-example.md:3
@@ -9963,7 +11088,8 @@ msgid ""
" fn fmt(&self, f: &mut Formatter) -> fmt::Result {\n"
" match self {\n"
" Self::IoError(e) => write!(f, \"IO error: {e}\"),\n"
-" Self::EmptyUsername(filename) => write!(f, \"Found no username in {filename}\"),\n"
+" Self::EmptyUsername(filename) => write!(f, \"Found no username "
+"in {filename}\"),\n"
" }\n"
" }\n"
"}\n"
@@ -9994,18 +11120,20 @@ msgstr ""
#: src/error-handling/converting-error-types-example.md:55
#, fuzzy
msgid ""
-"It is good practice for all error types to implement `std::error::Error`, which requires `Debug` "
-"and\n"
-"`Display`. It's generally helpful for them to implement `Clone` and `Eq` too where possible, to "
-"make\n"
-"life easier for tests and consumers of your library. In this case we can't easily do so, because\n"
+"It is good practice for all error types to implement `std::error::Error`, "
+"which requires `Debug` and\n"
+"`Display`. It's generally helpful for them to implement `Clone` and `Eq` too "
+"where possible, to make\n"
+"life easier for tests and consumers of your library. In this case we can't "
+"easily do so, because\n"
"`io::Error` doesn't implement them."
msgstr ""
-"È buona pratica per tutti i tipi di errore implementare `std::error::Error`, che richiede `Debug` "
-"e\n"
-"`Display`. In genere è utile per loro implementare anche `Clone` e `Eq`, ove possibile, per fare\n"
-"vita più facile per i test e i consumatori della tua libreria. In questo caso non possiamo farlo "
-"facilmente, perché\n"
+"È buona pratica per tutti i tipi di errore implementare `std::error::Error`, "
+"che richiede `Debug` e\n"
+"`Display`. In genere è utile per loro implementare anche `Clone` e `Eq`, ove "
+"possibile, per fare\n"
+"vita più facile per i test e i consumatori della tua libreria. In questo "
+"caso non possiamo farlo facilmente, perché\n"
"`io::Error` non li implementa."
#: src/error-handling/deriving-error-enums.md:1
@@ -10016,10 +11144,12 @@ msgstr "# Derivazione delle enumerazioni degli errori"
#: src/error-handling/deriving-error-enums.md:3
#, fuzzy
msgid ""
-"The [thiserror](https://docs.rs/thiserror/) crate is a popular way to create an\n"
+"The [thiserror](https://docs.rs/thiserror/) crate is a popular way to create "
+"an\n"
"error enum like we did on the previous page:"
msgstr ""
-"Il crate [thiserror](https://docs.rs/thiserror/) è un modo popolare per creare un\n"
+"Il crate [thiserror](https://docs.rs/thiserror/) è un modo popolare per "
+"creare un\n"
"error enum come abbiamo fatto nella pagina precedente:"
#: src/error-handling/deriving-error-enums.md:6
@@ -10038,7 +11168,7 @@ msgid ""
"}\n"
"\n"
"fn read_username(path: &str) -> Result {\n"
-" let mut username = String::with_capacity(100);\n"
+" let mut username = String::new();\n"
" fs::File::open(path)?.read_to_string(&mut username)?;\n"
" if username.is_empty() {\n"
" return Err(ReadUsernameError::EmptyUsername(String::from(path)));\n"
@@ -10059,21 +11189,23 @@ msgstr ""
#: src/error-handling/deriving-error-enums.md:39
#, fuzzy
msgid ""
-"`thiserror`'s derive macro automatically implements `std::error::Error`, and optionally `Display`\n"
-"(if the `#[error(...)]` attributes are provided) and `From` (if the `#[from]` attribute is "
-"added).\n"
+"`thiserror`'s derive macro automatically implements `std::error::Error`, and "
+"optionally `Display`\n"
+"(if the `#[error(...)]` attributes are provided) and `From` (if the "
+"`#[from]` attribute is added).\n"
"It also works for structs."
msgstr ""
-"La macro deriva di `thiserror` implementa automaticamente `std::error::Error` e facoltativamente "
-"`Display`\n"
-"(se vengono forniti gli attributi `#[error(...)]`) e `From` (se viene aggiunto l'attributo "
-"`#[from]`).\n"
+"La macro deriva di `thiserror` implementa automaticamente `std::error::"
+"Error` e facoltativamente `Display`\n"
+"(se vengono forniti gli attributi `#[error(...)]`) e `From` (se viene "
+"aggiunto l'attributo `#[from]`).\n"
"Funziona anche per le strutture."
#: src/error-handling/deriving-error-enums.md:43
#, fuzzy
msgid "It doesn't affect your public API, which makes it good for libraries."
-msgstr "Non influisce sulla tua API pubblica, il che lo rende utile per le librerie."
+msgstr ""
+"Non influisce sulla tua API pubblica, il che lo rende utile per le librerie."
#: src/error-handling/dynamic-errors.md:1
#, fuzzy
@@ -10083,17 +11215,18 @@ msgstr "# Tipi di errori dinamici"
#: src/error-handling/dynamic-errors.md:3
#, fuzzy
msgid ""
-"Sometimes we want to allow any type of error to be returned without writing our own enum covering\n"
+"Sometimes we want to allow any type of error to be returned without writing "
+"our own enum covering\n"
"all the different possibilities. `std::error::Error` makes this easy."
msgstr ""
-"A volte vogliamo consentire la restituzione di qualsiasi tipo di errore senza scrivere la nostra "
-"copertura enum\n"
+"A volte vogliamo consentire la restituzione di qualsiasi tipo di errore "
+"senza scrivere la nostra copertura enum\n"
"tutte le diverse possibilità. `std::error::Error` lo rende facile."
#: src/error-handling/dynamic-errors.md:6
msgid ""
"```rust,editable,compile_fail\n"
-"use std::fs::{self, File};\n"
+"use std::fs;\n"
"use std::io::Read;\n"
"use thiserror::Error;\n"
"use std::error::Error;\n"
@@ -10103,8 +11236,8 @@ msgid ""
"struct EmptyUsernameError(String);\n"
"\n"
"fn read_username(path: &str) -> Result> {\n"
-" let mut username = String::with_capacity(100);\n"
-" File::open(path)?.read_to_string(&mut username)?;\n"
+" let mut username = String::new();\n"
+" fs::File::open(path)?.read_to_string(&mut username)?;\n"
" if username.is_empty() {\n"
" return Err(EmptyUsernameError(String::from(path)).into());\n"
" }\n"
@@ -10124,20 +11257,20 @@ msgstr ""
#: src/error-handling/dynamic-errors.md:36
#, fuzzy
msgid ""
-"This saves on code, but gives up the ability to cleanly handle different error cases differently "
-"in\n"
-"the program. As such it's generally not a good idea to use `Box` in the public API of "
-"a\n"
-"library, but it can be a good option in a program where you just want to display the error "
-"message\n"
+"This saves on code, but gives up the ability to cleanly handle different "
+"error cases differently in\n"
+"the program. As such it's generally not a good idea to use `Box` "
+"in the public API of a\n"
+"library, but it can be a good option in a program where you just want to "
+"display the error message\n"
"somewhere."
msgstr ""
-"Ciò consente di risparmiare sul codice, ma rinuncia alla possibilità di gestire in modo pulito "
-"diversi casi di errore in modo diverso\n"
-"il programma. Pertanto, generalmente non è una buona idea utilizzare `Box` nell'API "
-"pubblica di a\n"
-"library, ma può essere una buona opzione in un programma in cui si desidera solo visualizzare il "
-"messaggio di errore\n"
+"Ciò consente di risparmiare sul codice, ma rinuncia alla possibilità di "
+"gestire in modo pulito diversi casi di errore in modo diverso\n"
+"il programma. Pertanto, generalmente non è una buona idea utilizzare "
+"`Box` nell'API pubblica di a\n"
+"library, ma può essere una buona opzione in un programma in cui si desidera "
+"solo visualizzare il messaggio di errore\n"
"in qualche luogo."
#: src/error-handling/error-contexts.md:1
@@ -10152,7 +11285,8 @@ msgid ""
"contextual information to your errors and allows you to have fewer\n"
"custom error types:"
msgstr ""
-"La cassa ampiamente utilizzata [comunque](https://docs.rs/anyhow/) può aiutarti ad aggiungere\n"
+"La cassa ampiamente utilizzata [comunque](https://docs.rs/anyhow/) può "
+"aiutarti ad aggiungere\n"
"informazioni contestuali ai tuoi errori e ti permette di averne meno\n"
"tipi di errore personalizzati:"
@@ -10189,21 +11323,26 @@ msgstr ""
#, fuzzy
msgid ""
"* `anyhow::Result` is a type alias for `Result`.\n"
-"* `anyhow::Error` is essentially a wrapper around `Box`. As such it's again generally "
-"not\n"
-" a good choice for the public API of a library, but is widely used in applications.\n"
-"* Actual error type inside of it can be extracted for examination if necessary.\n"
-"* Functionality provided by `anyhow::Result` may be familiar to Go developers, as it provides\n"
+"* `anyhow::Error` is essentially a wrapper around `Box`. As such "
+"it's again generally not\n"
+" a good choice for the public API of a library, but is widely used in "
+"applications.\n"
+"* Actual error type inside of it can be extracted for examination if "
+"necessary.\n"
+"* Functionality provided by `anyhow::Result` may be familiar to Go "
+"developers, as it provides\n"
" similar usage patterns and ergonomics to `(T, error)` from Go."
msgstr ""
-"* `comunque::Risultato` è un alias di tipo per `Risultato`.\n"
-"* `anyhow::Error` è essenzialmente un wrapper attorno a `Box`. In quanto tale, "
-"generalmente non lo è\n"
-" una buona scelta per l'API pubblica di una libreria, ma è ampiamente utilizzata nelle "
-"applicazioni.\n"
-"* Il tipo di errore effettivo all'interno di esso può essere estratto per l'esame, se necessario.\n"
-"* La funzionalità fornita da `anyhow::Result` potrebbe essere familiare agli sviluppatori Go, "
-"in quanto fornisce\n"
+"* `comunque::Risultato` è un alias di tipo per `Risultato`.\n"
+"* `anyhow::Error` è essenzialmente un wrapper attorno a `Box`. In "
+"quanto tale, generalmente non lo è\n"
+" una buona scelta per l'API pubblica di una libreria, ma è ampiamente "
+"utilizzata nelle applicazioni.\n"
+"* Il tipo di errore effettivo all'interno di esso può essere estratto per "
+"l'esame, se necessario.\n"
+"* La funzionalità fornita da `anyhow::Result` potrebbe essere familiare "
+"agli sviluppatori Go, in quanto fornisce\n"
" modelli di utilizzo ed ergonomia simili a `(T, errore)` di Go."
#: src/testing.md:1
@@ -10280,7 +11419,8 @@ msgid ""
"Unit tests are often put in a nested module (run tests on the\n"
"[Playground](https://play.rust-lang.org/)):"
msgstr ""
-"I test unitari vengono spesso inseriti in un modulo nidificato (esegui test sul file\n"
+"I test unitari vengono spesso inseriti in un modulo nidificato (esegui test "
+"sul file\n"
"[Parco giochi](https://play.rust-lang.org/)):"
#: src/testing/test-modules.md:6
@@ -10349,9 +11489,11 @@ msgid ""
"* Test the above code on the [Rust Playground](https://play.rust-lang.org/?"
"version=stable&mode=debug&edition=2021&gist=3ce2ad13ea1302f6572cb15cd96becf0)."
msgstr ""
-"* I blocchi di codice nei commenti `///` sono visti automaticamente come codice Rust.\n"
+"* I blocchi di codice nei commenti `///` sono visti automaticamente come "
+"codice Rust.\n"
"* Il codice verrà compilato ed eseguito come parte di `cargo test`.\n"
-"* Prova il codice precedente su [Rust Playground](https://play.rust-lang.org/?"
+"* Prova il codice precedente su [Rust Playground](https://play.rust-lang."
+"org/?"
"version=stable&mode=debug&edition=2021&gist=3ce2ad13ea1302f6572cb15cd96becf0)."
#: src/testing/integration-tests.md:1
@@ -10362,7 +11504,9 @@ msgstr "# Test di integrazione"
#: src/testing/integration-tests.md:3
#, fuzzy
msgid "If you want to test your library as a client, use an integration test."
-msgstr "Se desideri testare la tua libreria come client, utilizza un test di integrazione."
+msgstr ""
+"Se desideri testare la tua libreria come client, utilizza un test di "
+"integrazione."
#: src/testing/integration-tests.md:5
#, fuzzy
@@ -10402,10 +11546,11 @@ msgstr ""
#: src/testing/useful-crates.md:7
msgid ""
-"* [googletest](https://docs.rs/googletest): Comprehensive test assertion library in the tradition "
-"of GoogleTest for C++.\n"
+"* [googletest](https://docs.rs/googletest): Comprehensive test assertion "
+"library in the tradition of GoogleTest for C++.\n"
"* [proptest](https://docs.rs/proptest): Property-based testing for Rust.\n"
-"* [rstest](https://docs.rs/rstest): Support for fixtures and parameterised tests."
+"* [rstest](https://docs.rs/rstest): Support for fixtures and parameterised "
+"tests."
msgstr ""
#: src/unsafe.md:1
@@ -10422,15 +11567,18 @@ msgstr "Il linguaggio Rust ha due parti:"
#, fuzzy
msgid ""
"* **Safe Rust:** memory safe, no undefined behavior possible.\n"
-"* **Unsafe Rust:** can trigger undefined behavior if preconditions are violated."
+"* **Unsafe Rust:** can trigger undefined behavior if preconditions are "
+"violated."
msgstr ""
"* **Safe Rust:** memoria sicura, nessun comportamento indefinito possibile.\n"
-"* **Unsafe Rust:** può attivare un comportamento indefinito se vengono violate le precondizioni."
+"* **Unsafe Rust:** può attivare un comportamento indefinito se vengono "
+"violate le precondizioni."
#: src/unsafe.md:8
#, fuzzy
msgid ""
-"We will be seeing mostly safe Rust in this course, but it's important to know\n"
+"We will be seeing mostly safe Rust in this course, but it's important to "
+"know\n"
"what Unsafe Rust is."
msgstr ""
"Vedremo Rust per lo più sicuro in questo corso, ma è importante saperlo\n"
@@ -10439,11 +11587,12 @@ msgstr ""
#: src/unsafe.md:11
#, fuzzy
msgid ""
-"Unsafe code is usually small and isolated, and its correctness should be carefully\n"
+"Unsafe code is usually small and isolated, and its correctness should be "
+"carefully\n"
"documented. It is usually wrapped in a safe abstraction layer."
msgstr ""
-"Il codice non sicuro è solitamente piccolo e isolato e la sua correttezza dovrebbe essere "
-"attentamente\n"
+"Il codice non sicuro è solitamente piccolo e isolato e la sua correttezza "
+"dovrebbe essere attentamente\n"
"documentato. Di solito è racchiuso in uno strato di astrazione sicuro."
#: src/unsafe.md:14
@@ -10469,25 +11618,33 @@ msgstr ""
#: src/unsafe.md:22
#, fuzzy
msgid ""
-"We will briefly cover unsafe capabilities next. For full details, please see\n"
-"[Chapter 19.1 in the Rust Book](https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html)\n"
+"We will briefly cover unsafe capabilities next. For full details, please "
+"see\n"
+"[Chapter 19.1 in the Rust Book](https://doc.rust-lang.org/book/ch19-01-"
+"unsafe-rust.html)\n"
"and the [Rustonomicon](https://doc.rust-lang.org/nomicon/)."
msgstr ""
-"Tratteremo brevemente le capacità non sicure in seguito. Per tutti i dettagli, vedere\n"
-"[Capitolo 19.1 nel Rust Book](https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html)\n"
+"Tratteremo brevemente le capacità non sicure in seguito. Per tutti i "
+"dettagli, vedere\n"
+"[Capitolo 19.1 nel Rust Book](https://doc.rust-lang.org/book/ch19-01-unsafe-"
+"rust.html)\n"
"e il [Rustonomicon](https://doc.rust-lang.org/nomicon/)."
#: src/unsafe.md:28
#, fuzzy
msgid ""
-"Unsafe Rust does not mean the code is incorrect. It means that developers have\n"
+"Unsafe Rust does not mean the code is incorrect. It means that developers "
+"have\n"
"turned off the compiler safety features and have to write correct code by\n"
-"themselves. It means the compiler no longer enforces Rust's memory-safety rules."
+"themselves. It means the compiler no longer enforces Rust's memory-safety "
+"rules."
msgstr ""
-"Unsafe Rust non significa che il codice non sia corretto. Significa che gli sviluppatori hanno\n"
-"ha disattivato le funzionalità di sicurezza del compilatore e deve scrivere il codice corretto\n"
-"loro stessi. Significa che il compilatore non applica più le regole di sicurezza della memoria di "
-"Rust."
+"Unsafe Rust non significa che il codice non sia corretto. Significa che gli "
+"sviluppatori hanno\n"
+"ha disattivato le funzionalità di sicurezza del compilatore e deve scrivere "
+"il codice corretto\n"
+"loro stessi. Significa che il compilatore non applica più le regole di "
+"sicurezza della memoria di Rust."
#: src/unsafe/raw-pointers.md:1
#, fuzzy
@@ -10497,7 +11654,9 @@ msgstr "# Dereferenziazione dei puntatori grezzi"
#: src/unsafe/raw-pointers.md:3
#, fuzzy
msgid "Creating pointers is safe, but dereferencing them requires `unsafe`:"
-msgstr "La creazione di puntatori è sicura, ma la loro dereferenziazione richiede `unsafe`:"
+msgstr ""
+"La creazione di puntatori è sicura, ma la loro dereferenziazione richiede "
+"`unsafe`:"
#: src/unsafe/raw-pointers.md:5
msgid ""
@@ -10509,7 +11668,8 @@ msgid ""
" let r2 = r1 as *const i32;\n"
"\n"
" // Safe because r1 and r2 were obtained from references and so are\n"
-" // guaranteed to be non-null and properly aligned, the objects underlying\n"
+" // guaranteed to be non-null and properly aligned, the objects "
+"underlying\n"
" // the references from which they were obtained are live throughout the\n"
" // whole unsafe block, and they are not accessed either through the\n"
" // references or concurrently through any other pointers.\n"
@@ -10525,14 +11685,16 @@ msgstr ""
#: src/unsafe/raw-pointers.md:27
#, fuzzy
msgid ""
-"It is good practice (and required by the Android Rust style guide) to write a comment for each\n"
-"`unsafe` block explaining how the code inside it satisfies the safety requirements of the unsafe\n"
+"It is good practice (and required by the Android Rust style guide) to write "
+"a comment for each\n"
+"`unsafe` block explaining how the code inside it satisfies the safety "
+"requirements of the unsafe\n"
"operations it is doing."
msgstr ""
-"È buona norma (e richiesto dalla guida allo stile di Android Rust) scrivere un commento per "
-"ciascuno\n"
-"Blocco `unsafe` che spiega come il codice al suo interno soddisfi i requisiti di sicurezza "
-"dell'unsafe\n"
+"È buona norma (e richiesto dalla guida allo stile di Android Rust) scrivere "
+"un commento per ciascuno\n"
+"Blocco `unsafe` che spiega come il codice al suo interno soddisfi i "
+"requisiti di sicurezza dell'unsafe\n"
"operazioni che sta compiendo."
#: src/unsafe/raw-pointers.md:31
@@ -10541,31 +11703,37 @@ msgid ""
"In the case of pointer dereferences, this means that the pointers must be\n"
"[_valid_](https://doc.rust-lang.org/std/ptr/index.html#safety), i.e.:"
msgstr ""
-"Nel caso di dereferenze puntatore, ciò significa che i puntatori devono essere\n"
+"Nel caso di dereferenze puntatore, ciò significa che i puntatori devono "
+"essere\n"
"[_valid_](https://doc.rust-lang.org/std/ptr/index.html#safety), ovvero:"
#: src/unsafe/raw-pointers.md:34
#, fuzzy
msgid ""
" * The pointer must be non-null.\n"
-" * The pointer must be _dereferenceable_ (within the bounds of a single allocated object).\n"
+" * The pointer must be _dereferenceable_ (within the bounds of a single "
+"allocated object).\n"
" * The object must not have been deallocated.\n"
" * There must not be concurrent accesses to the same location.\n"
-" * If the pointer was obtained by casting a reference, the underlying object must be live and no\n"
+" * If the pointer was obtained by casting a reference, the underlying object "
+"must be live and no\n"
" reference may be used to access the memory."
msgstr ""
" * Il puntatore deve essere diverso da null.\n"
-" * Il puntatore deve essere _dereferenceable_ (entro i limiti di un singolo oggetto allocato).\n"
+" * Il puntatore deve essere _dereferenceable_ (entro i limiti di un singolo "
+"oggetto allocato).\n"
" * L'oggetto non deve essere stato deallocato.\n"
" * Non devono esserci accessi contemporanei alla stessa posizione.\n"
-" * Se il puntatore è stato ottenuto lanciando un riferimento, l'oggetto sottostante deve essere "
-"live e no\n"
+" * Se il puntatore è stato ottenuto lanciando un riferimento, l'oggetto "
+"sottostante deve essere live e no\n"
" riferimento può essere utilizzato per accedere alla memoria."
#: src/unsafe/raw-pointers.md:41
#, fuzzy
msgid "In most cases the pointer must also be properly aligned."
-msgstr "Nella maggior parte dei casi anche il puntatore deve essere correttamente allineato."
+msgstr ""
+"Nella maggior parte dei casi anche il puntatore deve essere correttamente "
+"allineato."
#: src/unsafe/mutable-static-variables.md:1
#, fuzzy
@@ -10594,7 +11762,8 @@ msgid ""
"However, since data races can occur, it is unsafe to read and write mutable\n"
"static variables:"
msgstr ""
-"Tuttavia, poiché possono verificarsi corse di dati, non è sicuro leggere e scrivere mutabili\n"
+"Tuttavia, poiché possono verificarsi corse di dati, non è sicuro leggere e "
+"scrivere mutabili\n"
"variabili statiche:"
#: src/unsafe/mutable-static-variables.md:16
@@ -10617,14 +11786,15 @@ msgstr ""
#: src/unsafe/mutable-static-variables.md:32
#, fuzzy
msgid ""
-"Using a mutable static is generally a bad idea, but there are some cases where it might make "
-"sense\n"
-"in low-level `no_std` code, such as implementing a heap allocator or working with some C APIs."
+"Using a mutable static is generally a bad idea, but there are some cases "
+"where it might make sense\n"
+"in low-level `no_std` code, such as implementing a heap allocator or working "
+"with some C APIs."
msgstr ""
-"L'uso di una statica mutabile è generalmente una cattiva idea, ma ci sono alcuni casi in cui "
-"potrebbe avere senso\n"
-"nel codice `no_std` di basso livello, come implementare un allocatore di heap o lavorare con "
-"alcune API C."
+"L'uso di una statica mutabile è generalmente una cattiva idea, ma ci sono "
+"alcuni casi in cui potrebbe avere senso\n"
+"nel codice `no_std` di basso livello, come implementare un allocatore di "
+"heap o lavorare con alcune API C."
#: src/unsafe/unions.md:1
#, fuzzy
@@ -10634,7 +11804,8 @@ msgstr "# Sindacati"
#: src/unsafe/unions.md:3
#, fuzzy
msgid "Unions are like enums, but you need to track the active field yourself:"
-msgstr "Le unioni sono come le enum, ma devi monitorare tu stesso il campo attivo:"
+msgstr ""
+"Le unioni sono come le enum, ma devi monitorare tu stesso il campo attivo:"
#: src/unsafe/unions.md:5
msgid ""
@@ -10656,24 +11827,27 @@ msgstr ""
#: src/unsafe/unions.md:21
#, fuzzy
msgid ""
-"Unions are very rarely needed in Rust as you can usually use an enum. They are occasionally "
-"needed\n"
+"Unions are very rarely needed in Rust as you can usually use an enum. They "
+"are occasionally needed\n"
"for interacting with C library APIs."
msgstr ""
-"Le unioni sono molto raramente necessarie in Rust poiché di solito puoi usare un enum. "
-"Occasionalmente sono necessari\n"
+"Le unioni sono molto raramente necessarie in Rust poiché di solito puoi "
+"usare un enum. Occasionalmente sono necessari\n"
"per interagire con le API della libreria C."
#: src/unsafe/unions.md:24
#, fuzzy
msgid ""
-"If you just want to reinterpret bytes as a different type, you probably want\n"
-"[`std::mem::transmute`](https://doc.rust-lang.org/stable/std/mem/fn.transmute.html) or a safe\n"
+"If you just want to reinterpret bytes as a different type, you probably "
+"want\n"
+"[`std::mem::transmute`](https://doc.rust-lang.org/stable/std/mem/fn."
+"transmute.html) or a safe\n"
"wrapper such as the [`zerocopy`](https://crates.io/crates/zerocopy) crate."
msgstr ""
-"Se vuoi solo reinterpretare i byte come un tipo diverso, probabilmente lo vuoi\n"
-"[`std::mem::transmute`](https://doc.rust-lang.org/stable/std/mem/fn.transmute.html) o una "
-"cassaforte\n"
+"Se vuoi solo reinterpretare i byte come un tipo diverso, probabilmente lo "
+"vuoi\n"
+"[`std::mem::transmute`](https://doc.rust-lang.org/stable/std/mem/fn."
+"transmute.html) o una cassaforte\n"
"wrapper come la cassa [`zerocopy`](https://crates.io/crates/zerocopy)."
#: src/unsafe/calling-unsafe-functions.md:1
@@ -10684,11 +11858,12 @@ msgstr "# Chiamata di funzioni non sicure"
#: src/unsafe/calling-unsafe-functions.md:3
#, fuzzy
msgid ""
-"A function or method can be marked `unsafe` if it has extra preconditions you\n"
+"A function or method can be marked `unsafe` if it has extra preconditions "
+"you\n"
"must uphold to avoid undefined behaviour:"
msgstr ""
-"Una funzione o un metodo può essere contrassegnato come \"non sicuro\" se ha precondizioni "
-"aggiuntive\n"
+"Una funzione o un metodo può essere contrassegnato come \"non sicuro\" se ha "
+"precondizioni aggiuntive\n"
"deve sostenere per evitare comportamenti indefiniti:"
#: src/unsafe/calling-unsafe-functions.md:6
@@ -10697,7 +11872,8 @@ msgid ""
"fn main() {\n"
" let emojis = \"🗻∈🌏\";\n"
"\n"
-" // Safe because the indices are in the correct order, within the bounds of\n"
+" // Safe because the indices are in the correct order, within the bounds "
+"of\n"
" // the string slice, and lie on UTF-8 sequence boundaries.\n"
" unsafe {\n"
" println!(\"emoji: {}\", emojis.get_unchecked(0..4));\n"
@@ -10705,11 +11881,13 @@ msgid ""
" println!(\"emoji: {}\", emojis.get_unchecked(7..11));\n"
" }\n"
"\n"
-" println!(\"char count: {}\", count_chars(unsafe { emojis.get_unchecked(0..7) }));\n"
+" println!(\"char count: {}\", count_chars(unsafe { emojis."
+"get_unchecked(0..7) }));\n"
"\n"
" // Not upholding the UTF-8 encoding requirement breaks memory safety!\n"
" // println!(\"emoji: {}\", unsafe { emojis.get_unchecked(0..3) });\n"
-" // println!(\"char count: {}\", count_chars(unsafe { emojis.get_unchecked(0..3) }));\n"
+" // println!(\"char count: {}\", count_chars(unsafe { emojis."
+"get_unchecked(0..3) }));\n"
"}\n"
"\n"
"fn count_chars(s: &str) -> usize {\n"
@@ -10726,12 +11904,12 @@ msgstr "# Scrittura di funzioni non sicure"
#: src/unsafe/writing-unsafe-functions.md:3
#, fuzzy
msgid ""
-"You can mark your own functions as `unsafe` if they require particular conditions to avoid "
-"undefined\n"
+"You can mark your own functions as `unsafe` if they require particular "
+"conditions to avoid undefined\n"
"behaviour."
msgstr ""
-"Puoi contrassegnare le tue funzioni come \"non sicure\" se richiedono condizioni particolari per "
-"evitare undefined\n"
+"Puoi contrassegnare le tue funzioni come \"non sicure\" se richiedono "
+"condizioni particolari per evitare undefined\n"
"comportamento."
#: src/unsafe/writing-unsafe-functions.md:6
@@ -10764,20 +11942,25 @@ msgstr ""
#: src/unsafe/writing-unsafe-functions.md:33
#, fuzzy
-msgid "We wouldn't actually use pointers for this because it can be done safely with references."
+msgid ""
+"We wouldn't actually use pointers for this because it can be done safely "
+"with references."
msgstr ""
-"In realtà non useremmo i puntatori per questo perché può essere fatto in sicurezza con i "
-"riferimenti."
+"In realtà non useremmo i puntatori per questo perché può essere fatto in "
+"sicurezza con i riferimenti."
#: src/unsafe/writing-unsafe-functions.md:35
#, fuzzy
msgid ""
-"Note that unsafe code is allowed within an unsafe function without an `unsafe` block. We can\n"
-"prohibit this with `#[deny(unsafe_op_in_unsafe_fn)]`. Try adding it and see what happens."
+"Note that unsafe code is allowed within an unsafe function without an "
+"`unsafe` block. We can\n"
+"prohibit this with `#[deny(unsafe_op_in_unsafe_fn)]`. Try adding it and see "
+"what happens."
msgstr ""
-"Si noti che il codice non sicuro è consentito all'interno di una funzione non sicura senza un "
-"blocco `unsafe`. Noi possiamo\n"
-"proibiscilo con `#[deny(unsafe_op_in_unsafe_fn)]`. Prova ad aggiungerlo e guarda cosa succede."
+"Si noti che il codice non sicuro è consentito all'interno di una funzione "
+"non sicura senza un blocco `unsafe`. Noi possiamo\n"
+"proibiscilo con `#[deny(unsafe_op_in_unsafe_fn)]`. Prova ad aggiungerlo e "
+"guarda cosa succede."
#: src/unsafe/extern-functions.md:1
#, fuzzy
@@ -10787,10 +11970,12 @@ msgstr "# Chiamata codice esterno"
#: src/unsafe/extern-functions.md:3
#, fuzzy
msgid ""
-"Functions from other languages might violate the guarantees of Rust. Calling\n"
+"Functions from other languages might violate the guarantees of Rust. "
+"Calling\n"
"them is thus unsafe:"
msgstr ""
-"Le funzioni di altri linguaggi potrebbero violare le garanzie di Rust. Chiamata\n"
+"Le funzioni di altri linguaggi potrebbero violare le garanzie di Rust. "
+"Chiamata\n"
"loro è quindi pericoloso:"
#: src/unsafe/extern-functions.md:6
@@ -10812,21 +11997,23 @@ msgstr ""
#: src/unsafe/extern-functions.md:21
#, fuzzy
msgid ""
-"This is usually only a problem for extern functions which do things with pointers which might\n"
-"violate Rust's memory model, but in general any C function might have undefined behaviour under "
-"any\n"
+"This is usually only a problem for extern functions which do things with "
+"pointers which might\n"
+"violate Rust's memory model, but in general any C function might have "
+"undefined behaviour under any\n"
"arbitrary circumstances."
msgstr ""
-"Questo di solito è solo un problema per le funzioni esterne che fanno cose con i puntatori che "
-"potrebbero\n"
-"violare il modello di memoria di Rust, ma in generale qualsiasi funzione C potrebbe avere un "
-"comportamento indefinito sotto qualsiasi\n"
+"Questo di solito è solo un problema per le funzioni esterne che fanno cose "
+"con i puntatori che potrebbero\n"
+"violare il modello di memoria di Rust, ma in generale qualsiasi funzione C "
+"potrebbe avere un comportamento indefinito sotto qualsiasi\n"
"circostanze arbitrarie."
#: src/unsafe/extern-functions.md:25
msgid ""
"The `\"C\"` in this example is the ABI;\n"
-"[other ABIs are available too](https://doc.rust-lang.org/reference/items/external-blocks.html)."
+"[other ABIs are available too](https://doc.rust-lang.org/reference/items/"
+"external-blocks.html)."
msgstr ""
#: src/unsafe/unsafe-traits.md:1
@@ -10837,21 +12024,24 @@ msgstr "# Implementazione di tratti non sicuri"
#: src/unsafe/unsafe-traits.md:3
#, fuzzy
msgid ""
-"Like with functions, you can mark a trait as `unsafe` if the implementation must guarantee\n"
+"Like with functions, you can mark a trait as `unsafe` if the implementation "
+"must guarantee\n"
"particular conditions to avoid undefined behaviour."
msgstr ""
-"Come con le funzioni, puoi contrassegnare un tratto come \"non sicuro\" se l'implementazione deve "
-"garantire\n"
+"Come con le funzioni, puoi contrassegnare un tratto come \"non sicuro\" se "
+"l'implementazione deve garantire\n"
"condizioni particolari per evitare comportamenti indefiniti."
#: src/unsafe/unsafe-traits.md:6
#, fuzzy
msgid ""
"For example, the `zerocopy` crate has an unsafe trait that looks\n"
-"[something like this](https://docs.rs/zerocopy/latest/zerocopy/trait.AsBytes.html):"
+"[something like this](https://docs.rs/zerocopy/latest/zerocopy/trait.AsBytes."
+"html):"
msgstr ""
"Ad esempio, la cassa \"zerocopy\" ha un tratto non sicuro che sembra\n"
-"[qualcosa del genere](https://docs.rs/zerocopy/latest/zerocopy/trait.AsBytes.html):"
+"[qualcosa del genere](https://docs.rs/zerocopy/latest/zerocopy/trait.AsBytes."
+"html):"
#: src/unsafe/unsafe-traits.md:9
msgid ""
@@ -10865,7 +12055,8 @@ msgid ""
"pub unsafe trait AsBytes {\n"
" fn as_bytes(&self) -> &[u8] {\n"
" unsafe {\n"
-" slice::from_raw_parts(self as *const Self as *const u8, size_of_val(self))\n"
+" slice::from_raw_parts(self as *const Self as *const u8, "
+"size_of_val(self))\n"
" }\n"
" }\n"
"}\n"
@@ -10878,16 +12069,22 @@ msgstr ""
#: src/unsafe/unsafe-traits.md:30
#, fuzzy
msgid ""
-"There should be a `# Safety` section on the Rustdoc for the trait explaining the requirements for\n"
+"There should be a `# Safety` section on the Rustdoc for the trait explaining "
+"the requirements for\n"
"the trait to be safely implemented."
msgstr ""
-"Dovrebbe esserci una sezione `# Safety` su Rustdoc per il tratto che spiega i requisiti per\n"
+"Dovrebbe esserci una sezione `# Safety` su Rustdoc per il tratto che spiega "
+"i requisiti per\n"
"il tratto da implementare in modo sicuro."
#: src/unsafe/unsafe-traits.md:33
#, fuzzy
-msgid "The actual safety section for `AsBytes` is rather longer and more complicated."
-msgstr "L'attuale sezione sulla sicurezza per `AsBytes` è piuttosto lunga e complicata."
+msgid ""
+"The actual safety section for `AsBytes` is rather longer and more "
+"complicated."
+msgstr ""
+"L'attuale sezione sulla sicurezza per `AsBytes` è piuttosto lunga e "
+"complicata."
#: src/unsafe/unsafe-traits.md:35
#, fuzzy
@@ -10904,10 +12101,22 @@ msgstr "# Giorno 3: Esercizi pomeridiani"
msgid "Let us build a safe wrapper for reading directory content!"
msgstr "Costruiamo un wrapper sicuro per leggere il contenuto della directory!"
-#: src/exercises/day-3/afternoon.md:7
+#: src/exercises/day-3/afternoon.md:5
+msgid ""
+"For this exercise, we suggest using a local dev environment instead\n"
+"of the Playground. This will allow you to run your binary on your own "
+"machine."
+msgstr ""
+
+#: src/exercises/day-3/afternoon.md:8
+msgid "To get started, follow the [running locally] instructions."
+msgstr ""
+
+#: src/exercises/day-3/afternoon.md:14
#, fuzzy
msgid "After looking at the exercise, you can look at the [solution] provided."
-msgstr "Dopo aver esaminato l'esercizio, puoi esaminare la [soluzione] fornita."
+msgstr ""
+"Dopo aver esaminato l'esercizio, puoi esaminare la [soluzione] fornita."
#: src/exercises/day-3/safe-ffi-wrapper.md:1
#, fuzzy
@@ -10921,7 +12130,8 @@ msgid ""
"interface_ (FFI). We will use this to build a safe wrapper for the `libc`\n"
"functions you would use from C to read the filenames of a directory."
msgstr ""
-"Rust ha un ottimo supporto per le funzioni di chiamata attraverso una funzione _foreign\n"
+"Rust ha un ottimo supporto per le funzioni di chiamata attraverso una "
+"funzione _foreign\n"
"interfaccia_ (FFI). Lo useremo per costruire un wrapper sicuro per `libc`\n"
"funzioni che useresti da C per leggere i nomi dei file di una directory."
@@ -10944,7 +12154,8 @@ msgstr ""
#: src/exercises/day-3/safe-ffi-wrapper.md:13
#, fuzzy
msgid ""
-"You will also want to browse the [`std::ffi`] module. There you find a number of\n"
+"You will also want to browse the [`std::ffi`] module. There you find a "
+"number of\n"
"string types which you need for the exercise:"
msgstr ""
"Dovrai anche sfogliare il modulo [`std::ffi`]. Lì trovi un numero di\n"
@@ -10953,18 +12164,24 @@ msgstr ""
#: src/exercises/day-3/safe-ffi-wrapper.md:16
#, fuzzy
msgid ""
-"| Types | Encoding | Use |\n"
+"| Types | Encoding | "
+"Use |\n"
"|----------------------------|----------------|--------------------------------|\n"
-"| [`str`] and [`String`] | UTF-8 | Text processing in Rust |\n"
-"| [`CStr`] and [`CString`] | NUL-terminated | Communicating with C functions |\n"
-"| [`OsStr`] and [`OsString`] | OS-specific | Communicating with the OS |"
+"| [`str`] and [`String`] | UTF-8 | Text processing in "
+"Rust |\n"
+"| [`CStr`] and [`CString`] | NUL-terminated | Communicating with C "
+"functions |\n"
+"| [`OsStr`] and [`OsString`] | OS-specific | Communicating with the "
+"OS |"
msgstr ""
"| Tipi | Codifica | Usa |\n"
-"|----------------------------|----------------|--- -----------------------------|\n"
+"|----------------------------|----------------|--- "
+"-----------------------------|\n"
"| [`str`] e [`String`] | UTF-8 | Elaborazione del testo in Rust |\n"
-"| [`CStr`] e [`CString`] | con terminazione NUL | Comunicare con le funzioni C |\n"
-"| [`OsStr`] e [`OsString`] | specifico del sistema operativo | Comunicazione con il sistema "
-"operativo |"
+"| [`CStr`] e [`CString`] | con terminazione NUL | Comunicare con le funzioni "
+"C |\n"
+"| [`OsStr`] e [`OsString`] | specifico del sistema operativo | Comunicazione "
+"con il sistema operativo |"
#: src/exercises/day-3/safe-ffi-wrapper.md:22
#, fuzzy
@@ -10974,26 +12191,35 @@ msgstr "Potrai convertire tra tutti questi tipi:"
#: src/exercises/day-3/safe-ffi-wrapper.md:24
#, fuzzy
msgid ""
-"- `&str` to `CString`: you need to allocate space for a trailing `\\0` character,\n"
+"- `&str` to `CString`: you need to allocate space for a trailing `\\0` "
+"character,\n"
"- `CString` to `*const i8`: you need a pointer to call C functions,\n"
-"- `*const i8` to `&CStr`: you need something which can find the trailing `\\0` character,\n"
-"- `&CStr` to `&[u8]`: a slice of bytes is the universal interface for \"some unknow data\",\n"
+"- `*const i8` to `&CStr`: you need something which can find the trailing "
+"`\\0` character,\n"
+"- `&CStr` to `&[u8]`: a slice of bytes is the universal interface for \"some "
+"unknow data\",\n"
"- `&[u8]` to `&OsStr`: `&OsStr` is a step towards `OsString`, use\n"
-" [`OsStrExt`](https://doc.rust-lang.org/std/os/unix/ffi/trait.OsStrExt.html)\n"
+" [`OsStrExt`](https://doc.rust-lang.org/std/os/unix/ffi/trait.OsStrExt."
+"html)\n"
" to create it,\n"
-"- `&OsStr` to `OsString`: you need to clone the data in `&OsStr` to be able to return it and call\n"
+"- `&OsStr` to `OsString`: you need to clone the data in `&OsStr` to be able "
+"to return it and call\n"
" `readdir` again."
msgstr ""
-"- Da `&str` a `CString`: è necessario allocare spazio per un carattere finale `\\0`,\n"
-"- Da `CString` a `*const i8`: è necessario un puntatore per chiamare le funzioni C,\n"
-"- Da `*const i8` a `&CStr`: hai bisogno di qualcosa che possa trovare il carattere finale `\\0`,\n"
-"- da `&CStr` a `&[u8]`: una fetta di byte è l'interfaccia universale per \"alcuni dati "
-"sconosciuti\",\n"
+"- Da `&str` a `CString`: è necessario allocare spazio per un carattere "
+"finale `\\0`,\n"
+"- Da `CString` a `*const i8`: è necessario un puntatore per chiamare le "
+"funzioni C,\n"
+"- Da `*const i8` a `&CStr`: hai bisogno di qualcosa che possa trovare il "
+"carattere finale `\\0`,\n"
+"- da `&CStr` a `&[u8]`: una fetta di byte è l'interfaccia universale per "
+"\"alcuni dati sconosciuti\",\n"
"- Da `&[u8]` a `&OsStr`: `&OsStr` è un passo verso `OsString`, usa\n"
-" [`OsStrExt`](https://doc.rust-lang.org/std/os/unix/ffi/trait.OsStrExt.html)\n"
+" [`OsStrExt`](https://doc.rust-lang.org/std/os/unix/ffi/trait.OsStrExt."
+"html)\n"
" per crearlo,\n"
-"- `&OsStr` a `OsString`: è necessario clonare i dati in `&OsStr` per poterlo restituire e "
-"chiamare\n"
+"- `&OsStr` a `OsString`: è necessario clonare i dati in `&OsStr` per poterlo "
+"restituire e chiamare\n"
" `readdir` di nuovo."
#: src/exercises/day-3/safe-ffi-wrapper.md:34
@@ -11004,10 +12230,12 @@ msgstr "Il [Nomicon] ha anche un capitolo molto utile su FFI."
#: src/exercises/day-3/safe-ffi-wrapper.md:45
#, fuzzy
msgid ""
-"Copy the code below to {\n"
+" fn wishHappyBirthday(&self, name: &str, years: i32) -> binder::"
+"Result {\n"
" Ok(format!(\n"
-" \"Happy Birthday {name}, congratulations with the {years} years!\"\n"
+" \"Happy Birthday {name}, congratulations with the {years} years!"
+"\"\n"
" ))\n"
" }\n"
"}\n"
"```"
msgstr ""
-#: src/android/aidl/implementation.md:26 src/android/aidl/server.md:28 src/android/aidl/client.md:37
+#: src/android/aidl/implementation.md:26 src/android/aidl/server.md:28
+#: src/android/aidl/client.md:37
#, fuzzy
msgid "*birthday_service/Android.bp*:"
msgstr "*servizio_compleanno/Android.bp*:"
@@ -11535,8 +12818,8 @@ msgid ""
"```rust,ignore\n"
"//! Birthday service.\n"
"use birthdayservice::BirthdayService;\n"
-"use com_example_birthdayservice::aidl::com::example::birthdayservice::IBirthdayService::"
-"BnBirthdayService;\n"
+"use com_example_birthdayservice::aidl::com::example::birthdayservice::"
+"IBirthdayService::BnBirthdayService;\n"
"use com_example_birthdayservice::binder;\n"
"\n"
"const SERVICE_IDENTIFIER: &str = \"birthdayservice\";\n"
@@ -11548,7 +12831,8 @@ msgid ""
" birthday_service,\n"
" binder::BinderFeatures::default(),\n"
" );\n"
-" binder::add_service(SERVICE_IDENTIFIER, birthday_service_binder.as_binder())\n"
+" binder::add_service(SERVICE_IDENTIFIER, birthday_service_binder."
+"as_binder())\n"
" .expect(\"Failed to register service\");\n"
" binder::ProcessState::join_thread_pool()\n"
"}\n"
@@ -11585,9 +12869,10 @@ msgstr "Ora possiamo creare, inviare e avviare il servizio:"
#: src/android/aidl/deploy.md:5
msgid ""
"```shell\n"
-"$ m birthday_server\n"
-"$ adb push $ANDROID_PRODUCT_OUT/system/bin/birthday_server /data/local/tmp\n"
-"$ adb shell /data/local/tmp/birthday_server\n"
+"m birthday_server\n"
+"adb push \"$ANDROID_PRODUCT_OUT/system/bin/birthday_server /data/local/"
+"tmp\"\n"
+"adb shell /data/local/tmp/birthday_server\n"
"```"
msgstr ""
@@ -11599,20 +12884,32 @@ msgstr "In un altro terminale, controlla che il servizio sia in esecuzione:"
#: src/android/aidl/deploy.md:13
msgid ""
"```shell\n"
-"$ adb shell service check birthdayservice\n"
+"adb shell service check birthdayservice\n"
+"```"
+msgstr ""
+
+#: src/android/aidl/deploy.md:17
+msgid ""
+"```text\n"
"Service birthdayservice: found\n"
"```"
msgstr ""
-#: src/android/aidl/deploy.md:18
+#: src/android/aidl/deploy.md:21
#, fuzzy
msgid "You can also call the service with `service call`:"
msgstr "Puoi anche chiamare il servizio con `service call`:"
-#: src/android/aidl/deploy.md:20
+#: src/android/aidl/deploy.md:23
msgid ""
"```shell\n"
-"$ $ adb shell service call birthdayservice 1 s16 Bob i32 24\n"
+"adb shell service call birthdayservice 1 s16 Bob i32 24\n"
+"```"
+msgstr ""
+
+#: src/android/aidl/deploy.md:27
+msgid ""
+"```text\n"
"Result: Parcel(\n"
" 0x00000000: 00000000 00000036 00610048 00700070 '....6...H.a.p.p.'\n"
" 0x00000010: 00200079 00690042 00740072 00640068 'y. .B.i.r.t.h.d.'\n"
@@ -11644,14 +12941,15 @@ msgstr "*servizio_compleanno/src/client.rs*:"
msgid ""
"```rust,ignore\n"
"//! Birthday service.\n"
-"use com_example_birthdayservice::aidl::com::example::birthdayservice::IBirthdayService::"
-"IBirthdayService;\n"
+"use com_example_birthdayservice::aidl::com::example::birthdayservice::"
+"IBirthdayService::IBirthdayService;\n"
"use com_example_birthdayservice::binder;\n"
"\n"
"const SERVICE_IDENTIFIER: &str = \"birthdayservice\";\n"
"\n"
"/// Connect to the BirthdayService.\n"
-"pub fn connect() -> Result, binder::StatusCode> {\n"
+"pub fn connect() -> Result, binder::"
+"StatusCode> {\n"
" binder::get_interface(SERVICE_IDENTIFIER)\n"
"}\n"
"\n"
@@ -11666,7 +12964,8 @@ msgid ""
" .unwrap_or(42);\n"
"\n"
" binder::ProcessState::start_thread_pool();\n"
-" let service = connect().expect(\"Failed to connect to BirthdayService\");\n"
+" let service = connect().expect(\"Failed to connect to "
+"BirthdayService\");\n"
" let msg = service.wishHappyBirthday(&name, years)?;\n"
" println!(\"{msg}\");\n"
" Ok(())\n"
@@ -11703,9 +13002,16 @@ msgstr "Crea, invia ed esegui il client sul tuo dispositivo:"
#: src/android/aidl/client.md:56
msgid ""
"```shell\n"
-"$ m birthday_client\n"
-"$ adb push $ANDROID_PRODUCT_OUT/system/bin/birthday_client /data/local/tmp\n"
-"$ adb shell /data/local/tmp/birthday_client Charlie 60\n"
+"m birthday_client\n"
+"adb push \"$ANDROID_PRODUCT_OUT/system/bin/birthday_client /data/local/"
+"tmp\"\n"
+"adb shell /data/local/tmp/birthday_client Charlie 60\n"
+"```"
+msgstr ""
+
+#: src/android/aidl/client.md:62
+msgid ""
+"```text\n"
"Happy Birthday Charlie, congratulations with the 60 years!\n"
"```"
msgstr ""
@@ -11718,10 +13024,12 @@ msgstr "# Modifica dell'API"
#: src/android/aidl/changing.md:3
#, fuzzy
msgid ""
-"Let us extend the API with more functionality: we want to let clients specify a\n"
+"Let us extend the API with more functionality: we want to let clients "
+"specify a\n"
"list of lines for the birthday card:"
msgstr ""
-"Estendiamo l'API con più funzionalità: vogliamo consentire ai client di specificare a\n"
+"Estendiamo l'API con più funzionalità: vogliamo consentire ai client di "
+"specificare a\n"
"elenco delle righe per il biglietto d'auguri:"
#: src/android/aidl/changing.md:6
@@ -11745,10 +13053,12 @@ msgstr "# Registrazione"
#: src/android/logging.md:3
#, fuzzy
msgid ""
-"You should use the `log` crate to automatically log to `logcat` (on-device) or\n"
+"You should use the `log` crate to automatically log to `logcat` (on-device) "
+"or\n"
"`stdout` (on-host):"
msgstr ""
-"Dovresti usare la cassa `log` per accedere automaticamente a `logcat` (sul dispositivo) o\n"
+"Dovresti usare la cassa `log` per accedere automaticamente a `logcat` (sul "
+"dispositivo) o\n"
"`stdout` (sull'host):"
#: src/android/logging.md:6
@@ -11808,9 +13118,10 @@ msgstr "Crea, invia ed esegui il file binario sul tuo dispositivo:"
#: src/android/logging.md:44
msgid ""
"```shell\n"
-"$ m hello_rust_logs\n"
-"$ adb push $ANDROID_PRODUCT_OUT/system/bin/hello_rust_logs /data/local/tmp\n"
-"$ adb shell /data/local/tmp/hello_rust_logs\n"
+"m hello_rust_logs\n"
+"adb push \"$ANDROID_PRODUCT_OUT/system/bin/hello_rust_logs /data/local/"
+"tmp\"\n"
+"adb shell /data/local/tmp/hello_rust_logs\n"
"```"
msgstr ""
@@ -11822,10 +13133,18 @@ msgstr "I log vengono visualizzati in `adb logcat`:"
#: src/android/logging.md:52
msgid ""
"```shell\n"
-"$ adb logcat -s rust\n"
+"adb logcat -s rust\n"
+"```"
+msgstr ""
+
+#: src/android/logging.md:56
+msgid ""
+"```text\n"
"09-08 08:38:32.454 2420 2420 D rust: hello_rust_logs: Starting program.\n"
-"09-08 08:38:32.454 2420 2420 I rust: hello_rust_logs: Things are going fine.\n"
-"09-08 08:38:32.454 2420 2420 E rust: hello_rust_logs: Something went wrong!\n"
+"09-08 08:38:32.454 2420 2420 I rust: hello_rust_logs: Things are going "
+"fine.\n"
+"09-08 08:38:32.454 2420 2420 E rust: hello_rust_logs: Something went "
+"wrong!\n"
"```"
msgstr ""
@@ -11837,10 +13156,12 @@ msgstr "# Interoperabilità"
#: src/android/interoperability.md:3
#, fuzzy
msgid ""
-"Rust has excellent support for interoperability with other languages. This means\n"
+"Rust has excellent support for interoperability with other languages. This "
+"means\n"
"that you can:"
msgstr ""
-"Rust ha un eccellente supporto per l'interoperabilità con altri linguaggi. Questo significa\n"
+"Rust ha un eccellente supporto per l'interoperabilità con altri linguaggi. "
+"Questo significa\n"
"che tu puoi:"
#: src/android/interoperability.md:6
@@ -11872,7 +13193,8 @@ msgid ""
"Rust has full support for linking object files with a C calling convention.\n"
"Similarly, you can export Rust functions and call them from C."
msgstr ""
-"Rust ha il pieno supporto per il collegamento di file oggetto con una convenzione di chiamata C.\n"
+"Rust ha il pieno supporto per il collegamento di file oggetto con una "
+"convenzione di chiamata C.\n"
"Allo stesso modo, puoi esportare le funzioni di Rust e chiamarle da C."
#: src/android/interoperability/with-c.md:6
@@ -11910,7 +13232,8 @@ msgid ""
"> This assumes full knowledge of the target platform. Not recommended for\n"
"> production."
msgstr ""
-"> Ciò presuppone la piena conoscenza della piattaforma di destinazione. Non consigliato per\n"
+"> Ciò presuppone la piena conoscenza della piattaforma di destinazione. Non "
+"consigliato per\n"
"> produzione."
#: src/android/interoperability/with-c.md:26
@@ -11926,10 +13249,12 @@ msgstr "# Utilizzo di Bindgen"
#: src/android/interoperability/with-c/bindgen.md:3
#, fuzzy
msgid ""
-"The [bindgen](https://rust-lang.github.io/rust-bindgen/introduction.html) tool\n"
+"The [bindgen](https://rust-lang.github.io/rust-bindgen/introduction.html) "
+"tool\n"
"can auto-generate bindings from a C header file."
msgstr ""
-"Lo strumento [bindgen](https://rust-lang.github.io/rust-bindgen/introduction.html)\n"
+"Lo strumento [bindgen](https://rust-lang.github.io/rust-bindgen/introduction."
+"html)\n"
"può generare automaticamente collegamenti da un file di intestazione C."
#: src/android/interoperability/with-c/bindgen.md:6
@@ -12003,7 +13328,8 @@ msgid ""
"Create a wrapper header file for the library (not strictly needed in this\n"
"example):"
msgstr ""
-"Crea un file di intestazione wrapper per la libreria (non strettamente necessario in questo\n"
+"Crea un file di intestazione wrapper per la libreria (non strettamente "
+"necessario in questo\n"
"esempio):"
#: src/android/interoperability/with-c/bindgen.md:47
@@ -12080,9 +13406,10 @@ msgstr ""
#: src/android/interoperability/with-c/bindgen.md:100
msgid ""
"```shell\n"
-"$ m print_birthday_card\n"
-"$ adb push $ANDROID_PRODUCT_OUT/system/bin/print_birthday_card /data/local/tmp\n"
-"$ adb shell /data/local/tmp/print_birthday_card\n"
+"m print_birthday_card\n"
+"adb push \"$ANDROID_PRODUCT_OUT/system/bin/print_birthday_card /data/local/"
+"tmp\"\n"
+"adb shell /data/local/tmp/print_birthday_card\n"
"```"
msgstr ""
@@ -12090,7 +13417,8 @@ msgstr ""
#, fuzzy
msgid "Finally, we can run auto-generated tests to ensure the bindings work:"
msgstr ""
-"Infine, possiamo eseguire test generati automaticamente per garantire che i binding funzionino:"
+"Infine, possiamo eseguire test generati automaticamente per garantire che i "
+"binding funzionino:"
#: src/android/interoperability/with-c/bindgen.md:110
msgid ""
@@ -12110,7 +13438,7 @@ msgstr ""
#: src/android/interoperability/with-c/bindgen.md:122
msgid ""
"```shell\n"
-"$ atest libbirthday_bindgen_test\n"
+"atest libbirthday_bindgen_test\n"
"```"
msgstr ""
@@ -12227,23 +13555,25 @@ msgstr ""
#: src/android/interoperability/with-c/rust.md:75
msgid ""
"```shell\n"
-"$ m analyze_numbers\n"
-"$ adb push $ANDROID_PRODUCT_OUT/system/bin/analyze_numbers /data/local/tmp\n"
-"$ adb shell /data/local/tmp/analyze_numbers\n"
+"m analyze_numbers\n"
+"adb push \"$ANDROID_PRODUCT_OUT/system/bin/analyze_numbers /data/local/"
+"tmp\"\n"
+"adb shell /data/local/tmp/analyze_numbers\n"
"```"
msgstr ""
#: src/android/interoperability/with-c/rust.md:83
#, fuzzy
msgid ""
-"`#[no_mangle]` disables Rust's usual name mangling, so the exported symbol will just be the name "
-"of\n"
-"the function. You can also use `#[export_name = \"some_name\"]` to specify whatever name you want."
+"`#[no_mangle]` disables Rust's usual name mangling, so the exported symbol "
+"will just be the name of\n"
+"the function. You can also use `#[export_name = \"some_name\"]` to specify "
+"whatever name you want."
msgstr ""
-"`#[no_mangle]` disabilita la solita alterazione del nome di Rust, quindi il simbolo esportato sarà "
-"solo il nome di\n"
-"la funzione. Puoi anche usare `#[export_name = \"some_name\"]` per specificare il nome che "
-"desideri."
+"`#[no_mangle]` disabilita la solita alterazione del nome di Rust, quindi il "
+"simbolo esportato sarà solo il nome di\n"
+"la funzione. Puoi anche usare `#[export_name = \"some_name\"]` per "
+"specificare il nome che desideri."
#: src/android/interoperability/cpp.md:1
#, fuzzy
@@ -12253,7 +13583,8 @@ msgstr "# Con C++"
#: src/android/interoperability/cpp.md:3
#, fuzzy
msgid ""
-"The [CXX crate][1] makes it possible to do safe interoperability between Rust\n"
+"The [CXX crate][1] makes it possible to do safe interoperability between "
+"Rust\n"
"and C++."
msgstr ""
"Il [CXX crate][1] rende possibile l'interoperabilità sicura tra Rust\n"
@@ -12272,7 +13603,8 @@ msgstr "![](\"cpp/overview.svg\")
"
#: src/android/interoperability/cpp.md:10
#, fuzzy
msgid "See the [CXX tutorial][2] for an full example of using this."
-msgstr "Vedere il [tutorial CXX][2] per un esempio completo di utilizzo di questo."
+msgstr ""
+"Vedere il [tutorial CXX][2] per un esempio completo di utilizzo di questo."
#: src/android/interoperability/java.md:1
#, fuzzy
@@ -12324,7 +13656,8 @@ msgid ""
"```"
msgstr ""
-#: src/android/interoperability/java.md:32 src/android/interoperability/java.md:62
+#: src/android/interoperability/java.md:32
+#: src/android/interoperability/java.md:62
#, fuzzy
msgid "_interoperability/java/Android.bp_:"
msgstr "_interoperabilità/java/Android.bp_:"
@@ -12389,14 +13722,15 @@ msgstr "Infine, puoi creare, sincronizzare ed eseguire il binario:"
#: src/android/interoperability/java.md:75
msgid ""
"```shell\n"
-"$ m helloworld_jni\n"
-"$ adb sync # requires adb root && adb remount\n"
-"$ adb shell /system/bin/helloworld_jni\n"
+"m helloworld_jni\n"
+"adb sync # requires adb root && adb remount\n"
+"adb shell /system/bin/helloworld_jni\n"
"```"
msgstr ""
#: src/exercises/android/morning.md:1 src/exercises/bare-metal/morning.md:1
-#: src/exercises/bare-metal/afternoon.md:1 src/exercises/concurrency/morning.md:1
+#: src/exercises/bare-metal/afternoon.md:1
+#: src/exercises/concurrency/morning.md:1
#: src/exercises/concurrency/afternoon.md:1
#, fuzzy
msgid "# Exercises"
@@ -12405,10 +13739,12 @@ msgstr "# Esercizi"
#: src/exercises/android/morning.md:3
#, fuzzy
msgid ""
-"This is a group exercise: We will look at one of the projects you work with and\n"
+"This is a group exercise: We will look at one of the projects you work with "
+"and\n"
"try to integrate some Rust into it. Some suggestions:"
msgstr ""
-"Questo è un esercizio di gruppo: esamineremo uno dei progetti con cui lavori e\n"
+"Questo è un esercizio di gruppo: esamineremo uno dei progetti con cui lavori "
+"e\n"
"prova a integrarci un po' di ruggine. Alcuni suggerimenti:"
#: src/exercises/android/morning.md:6
@@ -12425,11 +13761,12 @@ msgstr ""
#: src/exercises/android/morning.md:12
#, fuzzy
msgid ""
-"No solution is provided here since this is open-ended: it relies on someone in\n"
+"No solution is provided here since this is open-ended: it relies on someone "
+"in\n"
"the class having a piece of code which you can turn in to Rust on the fly."
msgstr ""
-"Nessuna soluzione viene fornita qui poiché questo è a tempo indeterminato: si basa su qualcuno "
-"dentro\n"
+"Nessuna soluzione viene fornita qui poiché questo è a tempo indeterminato: "
+"si basa su qualcuno dentro\n"
"la classe ha un pezzo di codice che puoi consegnare a Rust al volo."
#: src/bare-metal.md:1
@@ -12440,27 +13777,28 @@ msgstr "# Benvenuto in Bare Metal Rust"
#: src/bare-metal.md:3
#, fuzzy
msgid ""
-"This is a standalone one-day course about bare-metal Rust, aimed at people who are familiar with "
-"the\n"
-"basics of Rust (perhaps from completing the Comprehensive Rust course), and ideally also have "
-"some\n"
+"This is a standalone one-day course about bare-metal Rust, aimed at people "
+"who are familiar with the\n"
+"basics of Rust (perhaps from completing the Comprehensive Rust course), and "
+"ideally also have some\n"
"experience with bare-metal programming in some other language such as C."
msgstr ""
-"Questo è un corso autonomo di un giorno sul bare metal Rust, rivolto a persone che hanno "
-"familiarità con il\n"
-"nozioni di base di Rust (forse completando il corso completo di Rust), e idealmente anche averne "
-"alcune\n"
-"esperienza con la programmazione bare metal in qualche altro linguaggio come C."
+"Questo è un corso autonomo di un giorno sul bare metal Rust, rivolto a "
+"persone che hanno familiarità con il\n"
+"nozioni di base di Rust (forse completando il corso completo di Rust), e "
+"idealmente anche averne alcune\n"
+"esperienza con la programmazione bare metal in qualche altro linguaggio come "
+"C."
#: src/bare-metal.md:7
#, fuzzy
msgid ""
-"Today we will talk about 'bare-metal' Rust: running Rust code without an OS underneath us. This "
-"will\n"
+"Today we will talk about 'bare-metal' Rust: running Rust code without an OS "
+"underneath us. This will\n"
"be divided into several parts:"
msgstr ""
-"Oggi parleremo di Rust 'bare-metal': eseguire il codice Rust senza un sistema operativo sotto di "
-"noi. Questo sarà\n"
+"Oggi parleremo di Rust 'bare-metal': eseguire il codice Rust senza un "
+"sistema operativo sotto di noi. Questo sarà\n"
"essere suddiviso in più parti:"
#: src/bare-metal.md:10
@@ -12473,37 +13811,42 @@ msgid ""
msgstr ""
"- Cos'è \"no_std\" Rust?\n"
"- Scrittura firmware per microcontrollori.\n"
-"- Scrittura del codice bootloader/kernel per i processori delle applicazioni.\n"
+"- Scrittura del codice bootloader/kernel per i processori delle "
+"applicazioni.\n"
"- Alcune casse utili per lo sviluppo di ruggine a metallo nudo."
#: src/bare-metal.md:15
#, fuzzy
msgid ""
-"For the microcontroller part of the course we will use the [BBC micro:bit](https://microbit.org/) "
-"v2\n"
-"as an example. It's a [development board](https://tech.microbit.org/hardware/) based on the "
-"Nordic\n"
-"nRF51822 microcontroller with some LEDs and buttons, an I2C-connected accelerometer and compass, "
-"and\n"
+"For the microcontroller part of the course we will use the [BBC micro:bit]"
+"(https://microbit.org/) v2\n"
+"as an example. It's a [development board](https://tech.microbit.org/"
+"hardware/) based on the Nordic\n"
+"nRF51822 microcontroller with some LEDs and buttons, an I2C-connected "
+"accelerometer and compass, and\n"
"an on-board SWD debugger."
msgstr ""
-"Per la parte del corso sui microcontrollori utilizzeremo la [BBC micro:bit](https://microbit.org/) "
-"v2\n"
-"come esempio. È una [scheda di sviluppo](https://tech.microbit.org/hardware/) basata sul Nordic\n"
-"microcontrollore nRF51822 con alcuni LED e pulsanti, un accelerometro e una bussola collegati a "
-"I2C e\n"
+"Per la parte del corso sui microcontrollori utilizzeremo la [BBC micro:bit]"
+"(https://microbit.org/) v2\n"
+"come esempio. È una [scheda di sviluppo](https://tech.microbit.org/"
+"hardware/) basata sul Nordic\n"
+"microcontrollore nRF51822 con alcuni LED e pulsanti, un accelerometro e una "
+"bussola collegati a I2C e\n"
"un debugger SWD integrato."
#: src/bare-metal.md:20
#, fuzzy
-msgid "To get started, install some tools we'll need later. On gLinux or Debian:"
-msgstr "Per iniziare, installa alcuni strumenti che ci serviranno in seguito. Su gLinux o Debian:"
+msgid ""
+"To get started, install some tools we'll need later. On gLinux or Debian:"
+msgstr ""
+"Per iniziare, installa alcuni strumenti che ci serviranno in seguito. Su "
+"gLinux o Debian:"
#: src/bare-metal.md:22
msgid ""
"```bash\n"
-"sudo apt install gcc-aarch64-linux-gnu gdb-multiarch libudev-dev picocom pkg-config qemu-system-"
-"arm\n"
+"sudo apt install gcc-aarch64-linux-gnu gdb-multiarch libudev-dev picocom pkg-"
+"config qemu-system-arm\n"
"rustup update\n"
"rustup target add aarch64-unknown-none thumbv7em-none-eabihf\n"
"rustup component add llvm-tools-preview\n"
@@ -12513,13 +13856,16 @@ msgstr ""
#: src/bare-metal.md:30
#, fuzzy
-msgid "And give users in the `plugdev` group access to the micro:bit programmer:"
-msgstr "E dai agli utenti del gruppo `plugdev` l'accesso al programmatore micro:bit:"
+msgid ""
+"And give users in the `plugdev` group access to the micro:bit programmer:"
+msgstr ""
+"E dai agli utenti del gruppo `plugdev` l'accesso al programmatore micro:bit:"
#: src/bare-metal.md:32
msgid ""
"```bash\n"
-"echo 'SUBSYSTEM==\"usb\", ATTR{idVendor}==\"0d28\", MODE=\"0664\", GROUP=\"plugdev\"' |\\\n"
+"echo 'SUBSYSTEM==\"usb\", ATTR{idVendor}==\"0d28\", MODE=\"0664\", "
+"GROUP=\"plugdev\"' |\\\n"
" sudo tee /etc/udev/rules.d/50-microbit.rules\n"
"sudo udevadm control --reload-rules\n"
"```"
@@ -12715,12 +14061,13 @@ msgid ""
"* This will compile to an empty binary.\n"
"* `std` provides a panic handler; without it we must provide our own.\n"
"* It can also be provided by another crate, such as `panic-halt`.\n"
-"* Depending on the target, you may need to compile with `panic = \"abort\"` to avoid an error "
-"about\n"
+"* Depending on the target, you may need to compile with `panic = \"abort\"` "
+"to avoid an error about\n"
" `eh_personality`.\n"
-"* Note that there is no `main` or any other entry point; it's up to you to define your own entry\n"
-" point. This will typically involve a linker script and some assembly code to set things up "
-"ready\n"
+"* Note that there is no `main` or any other entry point; it's up to you to "
+"define your own entry\n"
+" point. This will typically involve a linker script and some assembly code "
+"to set things up ready\n"
" for Rust code to run."
msgstr ""
@@ -12733,10 +14080,12 @@ msgstr "# `alloc`"
#, fuzzy
msgid ""
"To use `alloc` you must implement a\n"
-"[global (heap) allocator](https://doc.rust-lang.org/stable/std/alloc/trait.GlobalAlloc.html)."
+"[global (heap) allocator](https://doc.rust-lang.org/stable/std/alloc/trait."
+"GlobalAlloc.html)."
msgstr ""
"Per usare `alloc` devi implementare a\n"
-"[allocatore globale (heap)](https://doc.rust-lang.org/stable/std/alloc/trait.GlobalAlloc.html)."
+"[allocatore globale (heap)](https://doc.rust-lang.org/stable/std/alloc/trait."
+"GlobalAlloc.html)."
#: src/bare-metal/alloc.md:6
msgid ""
@@ -12757,7 +14106,8 @@ msgid ""
"static mut HEAP: [u8; 65536] = [0; 65536];\n"
"\n"
"pub fn entry() {\n"
-" // Safe because `HEAP` is only used here and `entry` is only called once.\n"
+" // Safe because `HEAP` is only used here and `entry` is only called "
+"once.\n"
" unsafe {\n"
" // Give the allocator some memory to allocate.\n"
" HEAP_ALLOCATOR\n"
@@ -12774,15 +14124,19 @@ msgstr ""
#: src/bare-metal/alloc.md:39
msgid ""
-"* `buddy_system_allocator` is a third-party crate implementing a basic buddy system allocator. "
-"Other\n"
-" crates are available, or you can write your own or hook into your existing allocator.\n"
-"* The const parameter of `LockedHeap` is the max order of the allocator; i.e. in this case it can\n"
+"* `buddy_system_allocator` is a third-party crate implementing a basic buddy "
+"system allocator. Other\n"
+" crates are available, or you can write your own or hook into your existing "
+"allocator.\n"
+"* The const parameter of `LockedHeap` is the max order of the allocator; i."
+"e. in this case it can\n"
" allocate regions of up to 2**32 bytes.\n"
-"* If any crate in your dependency tree depends on `alloc` then you must have exactly one global\n"
-" allocator defined in your binary. Usually this is done in the top-level binary crate.\n"
-"* `extern crate panic_halt as _` is necessary to ensure that the `panic_halt` crate is linked in "
-"so\n"
+"* If any crate in your dependency tree depends on `alloc` then you must have "
+"exactly one global\n"
+" allocator defined in your binary. Usually this is done in the top-level "
+"binary crate.\n"
+"* `extern crate panic_halt as _` is necessary to ensure that the "
+"`panic_halt` crate is linked in so\n"
" we get its panic handler.\n"
"* This example will build but not run, as it doesn't have an entry point."
msgstr ""
@@ -12795,11 +14149,11 @@ msgstr "# Microcontrollori"
#: src/bare-metal/microcontrollers.md:3
#, fuzzy
msgid ""
-"The `cortex_m_rt` crate provides (among other things) a reset handler for Cortex M "
-"microcontrollers."
+"The `cortex_m_rt` crate provides (among other things) a reset handler for "
+"Cortex M microcontrollers."
msgstr ""
-"Il crate `cortex_m_rt` fornisce (tra le altre cose) un gestore di reset per i microcontrollori "
-"Cortex M."
+"Il crate `cortex_m_rt` fornisce (tra le altre cose) un gestore di reset per "
+"i microcontrollori Cortex M."
#: src/bare-metal/microcontrollers.md:5
msgid ""
@@ -12822,19 +14176,23 @@ msgstr ""
#: src/bare-metal/microcontrollers.md:21
#, fuzzy
-msgid "Next we'll look at how to access peripherals, with increasing levels of abstraction."
-msgstr "Successivamente vedremo come accedere alle periferiche, con livelli crescenti di astrazione."
+msgid ""
+"Next we'll look at how to access peripherals, with increasing levels of "
+"abstraction."
+msgstr ""
+"Successivamente vedremo come accedere alle periferiche, con livelli "
+"crescenti di astrazione."
#: src/bare-metal/microcontrollers.md:25
#, fuzzy
msgid ""
-"* The `cortex_m_rt::entry` macro requires that the function have type `fn() -> !`, because "
-"returning\n"
+"* The `cortex_m_rt::entry` macro requires that the function have type `fn() -"
+"> !`, because returning\n"
" to the reset handler doesn't make sense.\n"
"* Run the example with `cargo embed --bin minimal`"
msgstr ""
-"* La macro `cortex_m_rt::entry` richiede che la funzione abbia il tipo `fn() -> !`, perché "
-"restituisce\n"
+"* La macro `cortex_m_rt::entry` richiede che la funzione abbia il tipo `fn() "
+"-> !`, perché restituisce\n"
" al gestore di ripristino non ha senso.\n"
"* Esegui l'esempio con `cargo embed --bin minimal`"
@@ -12846,11 +14204,12 @@ msgstr "# MMIO grezzo"
#: src/bare-metal/microcontrollers/mmio.md:3
#, fuzzy
msgid ""
-"Most microcontrollers access peripherals via memory-mapped IO. Let's try turning on an LED on our\n"
+"Most microcontrollers access peripherals via memory-mapped IO. Let's try "
+"turning on an LED on our\n"
"micro:bit:"
msgstr ""
-"La maggior parte dei microcontrollori accede alle periferiche tramite IO mappato in memoria. "
-"Proviamo ad accendere un LED sul nostro\n"
+"La maggior parte dei microcontrollori accede alle periferiche tramite IO "
+"mappato in memoria. Proviamo ad accendere un LED sul nostro\n"
"micro:bit:"
#: src/bare-metal/microcontrollers/mmio.md:6
@@ -12884,23 +14243,29 @@ msgid ""
"#[entry]\n"
"fn main() -> ! {\n"
" // Configure GPIO 0 pins 21 and 28 as push-pull outputs.\n"
-" let pin_cnf_21 = (GPIO_P0 + PIN_CNF + 21 * size_of::()) as *mut u32;\n"
-" let pin_cnf_28 = (GPIO_P0 + PIN_CNF + 28 * size_of::()) as *mut u32;\n"
-" // Safe because the pointers are to valid peripheral control registers, and\n"
+" let pin_cnf_21 = (GPIO_P0 + PIN_CNF + 21 * size_of::()) as *mut "
+"u32;\n"
+" let pin_cnf_28 = (GPIO_P0 + PIN_CNF + 28 * size_of::()) as *mut "
+"u32;\n"
+" // Safe because the pointers are to valid peripheral control registers, "
+"and\n"
" // no aliases exist.\n"
" unsafe {\n"
" pin_cnf_21.write_volatile(\n"
-" DIR_OUTPUT | INPUT_DISCONNECT | PULL_DISABLED | DRIVE_S0S1 | SENSE_DISABLED,\n"
+" DIR_OUTPUT | INPUT_DISCONNECT | PULL_DISABLED | DRIVE_S0S1 | "
+"SENSE_DISABLED,\n"
" );\n"
" pin_cnf_28.write_volatile(\n"
-" DIR_OUTPUT | INPUT_DISCONNECT | PULL_DISABLED | DRIVE_S0S1 | SENSE_DISABLED,\n"
+" DIR_OUTPUT | INPUT_DISCONNECT | PULL_DISABLED | DRIVE_S0S1 | "
+"SENSE_DISABLED,\n"
" );\n"
" }\n"
"\n"
" // Set pin 28 low and pin 21 high to turn the LED on.\n"
" let gpio0_outset = (GPIO_P0 + OUTSET) as *mut u32;\n"
" let gpio0_outclr = (GPIO_P0 + OUTCLR) as *mut u32;\n"
-" // Safe because the pointers are to valid peripheral control registers, and\n"
+" // Safe because the pointers are to valid peripheral control registers, "
+"and\n"
" // no aliases exist.\n"
" unsafe {\n"
" gpio0_outclr.write_volatile(1 << 28);\n"
@@ -12915,12 +14280,16 @@ msgstr ""
#: src/bare-metal/microcontrollers/mmio.md:64
#, fuzzy
msgid ""
-"* GPIO 0 pin 21 is connected to the first column of the LED matrix, and pin 28 to the first row."
+"* GPIO 0 pin 21 is connected to the first column of the LED matrix, and pin "
+"28 to the first row."
msgstr ""
-"* Il pin 21 di GPIO 0 è collegato alla prima colonna della matrice LED e il pin 28 alla prima riga."
+"* Il pin 21 di GPIO 0 è collegato alla prima colonna della matrice LED e il "
+"pin 28 alla prima riga."
-#: src/bare-metal/microcontrollers/mmio.md:66 src/bare-metal/microcontrollers/pacs.md:59
-#: src/bare-metal/microcontrollers/hals.md:43 src/bare-metal/microcontrollers/board-support.md:34
+#: src/bare-metal/microcontrollers/mmio.md:66
+#: src/bare-metal/microcontrollers/pacs.md:59
+#: src/bare-metal/microcontrollers/hals.md:43
+#: src/bare-metal/microcontrollers/board-support.md:34
#, fuzzy
msgid "Run the example with:"
msgstr "Esegui l'esempio con:"
@@ -12940,14 +14309,16 @@ msgstr "# Casse di accesso periferico"
#: src/bare-metal/microcontrollers/pacs.md:3
#, fuzzy
msgid ""
-"[`svd2rust`](https://crates.io/crates/svd2rust) generates mostly-safe Rust wrappers for\n"
-"memory-mapped peripherals from [CMSIS-SVD](https://www.keil.com/pack/doc/CMSIS/SVD/html/index."
-"html)\n"
+"[`svd2rust`](https://crates.io/crates/svd2rust) generates mostly-safe Rust "
+"wrappers for\n"
+"memory-mapped peripherals from [CMSIS-SVD](https://www.keil.com/pack/doc/"
+"CMSIS/SVD/html/index.html)\n"
"files."
msgstr ""
-"[`svd2rust`](https://crates.io/crates/svd2rust) genera wrapper Rust per lo più sicuri per\n"
-"periferiche mappate in memoria da [CMSIS-SVD](https://www.keil.com/pack/doc/CMSIS/SVD/html/index."
-"html)\n"
+"[`svd2rust`](https://crates.io/crates/svd2rust) genera wrapper Rust per lo "
+"più sicuri per\n"
+"periferiche mappate in memoria da [CMSIS-SVD](https://www.keil.com/pack/doc/"
+"CMSIS/SVD/html/index.html)\n"
"File."
#: src/bare-metal/microcontrollers/pacs.md:7
@@ -12996,28 +14367,33 @@ msgstr ""
#: src/bare-metal/microcontrollers/pacs.md:49
#, fuzzy
msgid ""
-"* SVD (System View Description) files are XML files typically provided by silicon vendors which\n"
+"* SVD (System View Description) files are XML files typically provided by "
+"silicon vendors which\n"
" describe the memory map of the device.\n"
-" * They are organised by peripheral, register, field and value, with names, descriptions, "
-"addresses\n"
+" * They are organised by peripheral, register, field and value, with names, "
+"descriptions, addresses\n"
" and so on.\n"
-" * SVD files are often buggy and incomplete, so there are various projects which patch the\n"
+" * SVD files are often buggy and incomplete, so there are various projects "
+"which patch the\n"
" mistakes, add missing details, and publish the generated crates.\n"
"* `cortex-m-rt` provides the vector table, among other things.\n"
"* If you `cargo install cargo-binutils` then you can run\n"
-" `cargo objdump --bin pac -- -d --no-show-raw-insn` to see the resulting binary."
+" `cargo objdump --bin pac -- -d --no-show-raw-insn` to see the resulting "
+"binary."
msgstr ""
-"* I file SVD (System View Description) sono file XML generalmente forniti da fornitori di silicio "
-"che\n"
+"* I file SVD (System View Description) sono file XML generalmente forniti da "
+"fornitori di silicio che\n"
" descrivere la mappa di memoria del dispositivo.\n"
-" * Sono organizzati per periferica, registro, campo e valore, con nomi, descrizioni, indirizzi\n"
+" * Sono organizzati per periferica, registro, campo e valore, con nomi, "
+"descrizioni, indirizzi\n"
" e così via.\n"
-" * I file SVD sono spesso difettosi e incompleti, quindi ci sono vari progetti che correggono il "
-"file\n"
+" * I file SVD sono spesso difettosi e incompleti, quindi ci sono vari "
+"progetti che correggono il file\n"
" errori, aggiungere i dettagli mancanti e pubblicare le casse generate.\n"
"* `cortex-m-rt` fornisce la tabella dei vettori, tra le altre cose.\n"
"* Se `cargo installi cargo-binutils` allora puoi eseguire\n"
-" `cargo objdump --bin pac -- -d --no-show-raw-insn` per vedere il binario risultante."
+" `cargo objdump --bin pac -- -d --no-show-raw-insn` per vedere il binario "
+"risultante."
#: src/bare-metal/microcontrollers/pacs.md:61
msgid ""
@@ -13034,15 +14410,16 @@ msgstr "# casse HAL"
#: src/bare-metal/microcontrollers/hals.md:3
#, fuzzy
msgid ""
-"[HAL crates](https://github.com/rust-embedded/awesome-embedded-rust#hal-implementation-crates) "
-"for\n"
-"many microcontrollers provide wrappers around various peripherals. These generally implement "
-"traits\n"
+"[HAL crates](https://github.com/rust-embedded/awesome-embedded-rust#hal-"
+"implementation-crates) for\n"
+"many microcontrollers provide wrappers around various peripherals. These "
+"generally implement traits\n"
"from [`embedded-hal`](https://crates.io/crates/embedded-hal)."
msgstr ""
-"[Casse HAL](https://github.com/rust-embedded/awesome-embedded-rust#hal-implementation-crates) per\n"
-"molti microcontrollori forniscono wrapper attorno a varie periferiche. Questi generalmente "
-"implementano i tratti\n"
+"[Casse HAL](https://github.com/rust-embedded/awesome-embedded-rust#hal-"
+"implementation-crates) per\n"
+"molti microcontrollori forniscono wrapper attorno a varie periferiche. "
+"Questi generalmente implementano i tratti\n"
"da [`embedded-hal`](https://crates.io/crates/embedded-hal)."
#: src/bare-metal/microcontrollers/hals.md:7
@@ -13081,14 +14458,16 @@ msgstr ""
#: src/bare-metal/microcontrollers/hals.md:39
#, fuzzy
msgid ""
-" * `set_low` and `set_high` are methods on the `embedded_hal` `OutputPin` trait.\n"
-" * HAL crates exist for many Cortex-M and RISC-V devices, including various STM32, GD32, nRF, "
-"NXP,\n"
+" * `set_low` and `set_high` are methods on the `embedded_hal` `OutputPin` "
+"trait.\n"
+" * HAL crates exist for many Cortex-M and RISC-V devices, including various "
+"STM32, GD32, nRF, NXP,\n"
" MSP430, AVR and PIC microcontrollers."
msgstr ""
-" * `set_low` e `set_high` sono metodi sul tratto `embedded_hal` `OutputPin`.\n"
-" * Esistono casse HAL per molti dispositivi Cortex-M e RISC-V, inclusi vari STM32, GD32, nRF, "
-"NXP,\n"
+" * `set_low` e `set_high` sono metodi sul tratto `embedded_hal` "
+"`OutputPin`.\n"
+" * Esistono casse HAL per molti dispositivi Cortex-M e RISC-V, inclusi vari "
+"STM32, GD32, nRF, NXP,\n"
" Microcontrollori MSP430, AVR e PIC."
#: src/bare-metal/microcontrollers/hals.md:45
@@ -13106,10 +14485,11 @@ msgstr "# Casse di supporto della scheda"
#: src/bare-metal/microcontrollers/board-support.md:3
#, fuzzy
msgid ""
-"Board support crates provide a further level of wrapping for a specific board for convenience."
+"Board support crates provide a further level of wrapping for a specific "
+"board for convenience."
msgstr ""
-"Le casse di supporto della tavola forniscono un ulteriore livello di avvolgimento per una tavola "
-"specifica per comodità."
+"Le casse di supporto della tavola forniscono un ulteriore livello di "
+"avvolgimento per una tavola specifica per comodità."
#: src/bare-metal/microcontrollers/board-support.md:5
msgid ""
@@ -13138,16 +14518,19 @@ msgstr ""
#: src/bare-metal/microcontrollers/board-support.md:28
#, fuzzy
msgid ""
-" * In this case the board support crate is just providing more useful names, and a bit of\n"
+" * In this case the board support crate is just providing more useful names, "
+"and a bit of\n"
" initialisation.\n"
-" * The crate may also include drivers for some on-board devices outside of the microcontroller\n"
+" * The crate may also include drivers for some on-board devices outside of "
+"the microcontroller\n"
" itself.\n"
" * `microbit-v2` includes a simple driver for the LED matrix."
msgstr ""
-" * In questo caso la cassa di supporto della scheda fornisce solo nomi più utili e un po' di\n"
+" * In questo caso la cassa di supporto della scheda fornisce solo nomi più "
+"utili e un po' di\n"
" inizializzazione.\n"
-" * Il crate può anche includere driver per alcuni dispositivi integrati al di fuori del "
-"microcontrollore\n"
+" * Il crate può anche includere driver per alcuni dispositivi integrati al "
+"di fuori del microcontrollore\n"
" si.\n"
" * `microbit-v2` include un semplice driver per la matrice LED."
@@ -13179,14 +14562,17 @@ msgid ""
" // ...\n"
" }\n"
" let mut pin_output: P0_01> = pin_input\n"
-" .into_open_drain_output(OpenDrainConfig::Disconnect0Standard1, Level::Low);\n"
+" .into_open_drain_output(OpenDrainConfig::Disconnect0Standard1, "
+"Level::Low);\n"
" pin_output.set_high().unwrap();\n"
" // pin_input.is_high(); // Error, moved.\n"
"\n"
" let _pin2: P0_02> = gpio0\n"
" .p0_02\n"
-" .into_open_drain_output(OpenDrainConfig::Disconnect0Standard1, Level::Low);\n"
-" let _pin3: P0_03> = gpio0.p0_03.into_push_pull_output(Level::Low);\n"
+" .into_open_drain_output(OpenDrainConfig::Disconnect0Standard1, "
+"Level::Low);\n"
+" let _pin3: P0_03> = gpio0.p0_03."
+"into_push_pull_output(Level::Low);\n"
"\n"
" loop {}\n"
"}\n"
@@ -13196,33 +14582,38 @@ msgstr ""
#: src/bare-metal/microcontrollers/type-state.md:32
#, fuzzy
msgid ""
-" * Pins don't implement `Copy` or `Clone`, so only one instance of each can exist. Once a pin is\n"
+" * Pins don't implement `Copy` or `Clone`, so only one instance of each can "
+"exist. Once a pin is\n"
" moved out of the port struct nobody else can take it.\n"
-" * Changing the configuration of a pin consumes the old pin instance, so you can’t keep use the "
-"old\n"
+" * Changing the configuration of a pin consumes the old pin instance, so you "
+"can’t keep use the old\n"
" instance afterwards.\n"
-" * The type of a value indicates the state that it is in: e.g. in this case, the configuration "
-"state\n"
-" of a GPIO pin. This encodes the state machine into the type system, and ensures that you don't\n"
-" try to use a pin in a certain way without properly configuring it first. Illegal state\n"
+" * The type of a value indicates the state that it is in: e.g. in this case, "
+"the configuration state\n"
+" of a GPIO pin. This encodes the state machine into the type system, and "
+"ensures that you don't\n"
+" try to use a pin in a certain way without properly configuring it first. "
+"Illegal state\n"
" transitions are caught at compile time.\n"
-" * You can call `is_high` on an input pin and `set_high` on an output pin, but not vice-versa.\n"
+" * You can call `is_high` on an input pin and `set_high` on an output pin, "
+"but not vice-versa.\n"
" * Many HAL crates follow this pattern."
msgstr ""
-" * I pin non implementano `Copy` o `Clone`, quindi può esistere solo un'istanza di ciascuno. Una "
-"volta che uno spillo è\n"
+" * I pin non implementano `Copy` o `Clone`, quindi può esistere solo "
+"un'istanza di ciascuno. Una volta che uno spillo è\n"
" spostato fuori dalla struttura portuale nessun altro può prenderlo.\n"
-" * La modifica della configurazione di un pin consuma la vecchia istanza del pin, quindi non puoi "
-"continuare a utilizzare il vecchio\n"
+" * La modifica della configurazione di un pin consuma la vecchia istanza del "
+"pin, quindi non puoi continuare a utilizzare il vecchio\n"
" esempio dopo.\n"
-" * Il tipo di un valore indica lo stato in cui si trova: ad es. in questo caso, lo stato di "
-"configurazione\n"
-" di un pin GPIO. Questo codifica la macchina a stati nel sistema di tipi e garantisce che non lo "
-"fai\n"
-" provare a utilizzare un pin in un certo modo senza prima configurarlo correttamente. Stato "
-"illegale\n"
+" * Il tipo di un valore indica lo stato in cui si trova: ad es. in questo "
+"caso, lo stato di configurazione\n"
+" di un pin GPIO. Questo codifica la macchina a stati nel sistema di tipi e "
+"garantisce che non lo fai\n"
+" provare a utilizzare un pin in un certo modo senza prima configurarlo "
+"correttamente. Stato illegale\n"
" le transizioni vengono rilevate in fase di compilazione.\n"
-" * Puoi chiamare `is_high` su un pin di input e `set_high` su un pin di output, ma non viceversa.\n"
+" * Puoi chiamare `is_high` su un pin di input e `set_high` su un pin di "
+"output, ma non viceversa.\n"
" * Molte casse HAL seguono questo schema."
#: src/bare-metal/microcontrollers/embedded-hal.md:1
@@ -13233,11 +14624,12 @@ msgstr "# `hal incorporato`"
#: src/bare-metal/microcontrollers/embedded-hal.md:3
#, fuzzy
msgid ""
-"The [`embedded-hal`](https://crates.io/crates/embedded-hal) crate provides a number of traits\n"
+"The [`embedded-hal`](https://crates.io/crates/embedded-hal) crate provides a "
+"number of traits\n"
"covering common microcontroller peripherals."
msgstr ""
-"Il crate [`embedded-hal`](https://crates.io/crates/embedded-hal) fornisce una serie di "
-"caratteristiche\n"
+"Il crate [`embedded-hal`](https://crates.io/crates/embedded-hal) fornisce "
+"una serie di caratteristiche\n"
"che copre le comuni periferiche del microcontrollore."
#: src/bare-metal/microcontrollers/embedded-hal.md:6
@@ -13261,26 +14653,31 @@ msgstr ""
#, fuzzy
msgid ""
"Other crates then implement\n"
-"[drivers](https://github.com/rust-embedded/awesome-embedded-rust#driver-crates) in terms of these\n"
-"traits, e.g. an accelerometer driver might need an I2C or SPI bus implementation."
+"[drivers](https://github.com/rust-embedded/awesome-embedded-rust#driver-"
+"crates) in terms of these\n"
+"traits, e.g. an accelerometer driver might need an I2C or SPI bus "
+"implementation."
msgstr ""
"Altre casse quindi implementano\n"
-"[driver](https://github.com/rust-embedded/awesome-embedded-rust#driver-crates) in termini di "
-"questi\n"
-"tratti, ad es. un driver dell'accelerometro potrebbe richiedere un'implementazione del bus I2C o "
-"SPI."
+"[driver](https://github.com/rust-embedded/awesome-embedded-rust#driver-"
+"crates) in termini di questi\n"
+"tratti, ad es. un driver dell'accelerometro potrebbe richiedere "
+"un'implementazione del bus I2C o SPI."
#: src/bare-metal/microcontrollers/embedded-hal.md:19
#, fuzzy
msgid ""
-" * There are implementations for many microcontrollers, as well as other platforms such as Linux "
-"on\n"
+" * There are implementations for many microcontrollers, as well as other "
+"platforms such as Linux on\n"
"Raspberry Pi.\n"
-" * There is work in progress on an `async` version of `embedded-hal`, but it isn't stable yet."
+" * There is work in progress on an `async` version of `embedded-hal`, but it "
+"isn't stable yet."
msgstr ""
-" * Ci sono implementazioni per molti microcontrollori, così come altre piattaforme come Linux su\n"
+" * Ci sono implementazioni per molti microcontrollori, così come altre "
+"piattaforme come Linux su\n"
"Lampone Pi.\n"
-" * C'è lavoro in corso su una versione `async` di `embedded-hal`, ma non è ancora stabile."
+" * C'è lavoro in corso su una versione `async` di `embedded-hal`, ma non è "
+"ancora stabile."
#: src/bare-metal/microcontrollers/probe-rs.md:1
#, fuzzy
@@ -13290,68 +14687,88 @@ msgstr "# `probe-rs`, `cargo-embed`"
#: src/bare-metal/microcontrollers/probe-rs.md:3
#, fuzzy
msgid ""
-"[probe-rs](https://probe.rs/) is a handy toolset for embedded debugging, like OpenOCD but better\n"
+"[probe-rs](https://probe.rs/) is a handy toolset for embedded debugging, "
+"like OpenOCD but better\n"
"integrated."
msgstr ""
-"[probe-rs](https://probe.rs/) è un utile set di strumenti per il debug integrato, come OpenOCD ma "
-"migliore\n"
+"[probe-rs](https://probe.rs/) è un utile set di strumenti per il debug "
+"integrato, come OpenOCD ma migliore\n"
"integrato."
#: src/bare-metal/microcontrollers/probe-rs.md:6
#, fuzzy
msgid ""
-"* SWD and JTAG via CMSIS-DAP, ST-Link and J-Link probes\n"
-"* GDB stub and Microsoft DAP server\n"
+"* SWD and JTAG via CMSIS-DAP, ST-"
+"Link and J-Link probes\n"
+"* GDB stub and Microsoft DAP "
+"server\n"
"* Cargo integration"
msgstr ""
-"* SWD e JTAG tramite sonde CMSIS-DAP, ST-Link e J-Link\n"
-"* GDB stub e server Microsoft DAP\n"
+"* SWD e JTAG tramite sonde CMSIS-"
+"DAP, ST-Link e J-Link\n"
+"* GDB stub e server Microsoft DAP\n"
"* Integrazione del carico"
#: src/bare-metal/microcontrollers/probe-rs.md:10
#, fuzzy
msgid ""
"`cargo-embed` is a cargo subcommand to build and flash binaries, log\n"
-"RTT output and connect GDB. It's configured by an\n"
+"RTT output and connect GDB. It's "
+"configured by an\n"
"`Embed.toml` file in your project directory."
msgstr ""
-"`cargo-embed` è un sottocomando cargo per compilare e aggiornare binari, log\n"
-"RTT emette e collega GDB. È configurato da un\n"
+"`cargo-embed` è un sottocomando cargo per compilare e aggiornare binari, "
+"log\n"
+"RTT emette e collega GDB. È "
+"configurato da un\n"
"\"Embed.toml\" nella directory del progetto."
#: src/bare-metal/microcontrollers/probe-rs.md:16
#, fuzzy
msgid ""
-"* [CMSIS-DAP](https://arm-software.github.io/CMSIS_5/DAP/html/index.html) is an Arm standard\n"
-" protocol over USB for an in-circuit debugger to access the CoreSight Debug Access Port of "
-"various\n"
-" Arm Cortex processors. It's what the on-board debugger on the BBC micro:bit uses.\n"
-"* ST-Link is a range of in-circuit debuggers from ST Microelectronics, J-Link is a range from\n"
+"* [CMSIS-DAP](https://arm-software.github.io/CMSIS_5/DAP/html/index.html) is "
+"an Arm standard\n"
+" protocol over USB for an in-circuit debugger to access the CoreSight Debug "
+"Access Port of various\n"
+" Arm Cortex processors. It's what the on-board debugger on the BBC micro:"
+"bit uses.\n"
+"* ST-Link is a range of in-circuit debuggers from ST Microelectronics, J-"
+"Link is a range from\n"
" SEGGER.\n"
-"* The Debug Access Port is usually either a 5-pin JTAG interface or 2-pin Serial Wire Debug.\n"
-"* probe-rs is a library which you can integrate into your own tools if you want to.\n"
-"* The [Microsoft Debug Adapter Protocol](https://microsoft.github.io/debug-adapter-protocol/) "
-"lets\n"
-" VSCode and other IDEs debug code running on any supported microcontroller.\n"
+"* The Debug Access Port is usually either a 5-pin JTAG interface or 2-pin "
+"Serial Wire Debug.\n"
+"* probe-rs is a library which you can integrate into your own tools if you "
+"want to.\n"
+"* The [Microsoft Debug Adapter Protocol](https://microsoft.github.io/debug-"
+"adapter-protocol/) lets\n"
+" VSCode and other IDEs debug code running on any supported "
+"microcontroller.\n"
"* cargo-embed is a binary built using the probe-rs library.\n"
-"* RTT (Real Time Transfers) is a mechanism to transfer data between the debug host and the target\n"
+"* RTT (Real Time Transfers) is a mechanism to transfer data between the "
+"debug host and the target\n"
" through a number of ringbuffers."
msgstr ""
-"* [CMSIS-DAP](https://arm-software.github.io/CMSIS_5/DAP/html/index.html) è uno standard Arm\n"
-" protocollo su USB per un debugger in-circuit per accedere alla porta di accesso di debug "
-"CoreSight di vari\n"
-" Processori Arm Cortex. È ciò che utilizza il debugger integrato sul micro: bit della BBC.\n"
-"* ST-Link è una gamma di debugger in-circuit di ST Microelectronics, J-Link è una gamma di\n"
+"* [CMSIS-DAP](https://arm-software.github.io/CMSIS_5/DAP/html/index.html) è "
+"uno standard Arm\n"
+" protocollo su USB per un debugger in-circuit per accedere alla porta di "
+"accesso di debug CoreSight di vari\n"
+" Processori Arm Cortex. È ciò che utilizza il debugger integrato sul micro: "
+"bit della BBC.\n"
+"* ST-Link è una gamma di debugger in-circuit di ST Microelectronics, J-Link "
+"è una gamma di\n"
" SEGGER.\n"
-"* La porta di accesso al debug è in genere un'interfaccia JTAG a 5 pin o un cavo di debug seriale "
-"a 2 pin.\n"
-"* probe-rs è una libreria che puoi integrare nei tuoi strumenti se lo desideri.\n"
-"* Il [Microsoft Debug Adapter Protocol](https://microsoft.github.io/debug-adapter-protocol/) "
-"consente\n"
-" VSCode e altri IDE eseguono il debug del codice in esecuzione su qualsiasi microcontrollore "
-"supportato.\n"
+"* La porta di accesso al debug è in genere un'interfaccia JTAG a 5 pin o un "
+"cavo di debug seriale a 2 pin.\n"
+"* probe-rs è una libreria che puoi integrare nei tuoi strumenti se lo "
+"desideri.\n"
+"* Il [Microsoft Debug Adapter Protocol](https://microsoft.github.io/debug-"
+"adapter-protocol/) consente\n"
+" VSCode e altri IDE eseguono il debug del codice in esecuzione su qualsiasi "
+"microcontrollore supportato.\n"
"* cargo-embed è un binario creato utilizzando la libreria probe-rs.\n"
-"* RTT (Real Time Transfers) è un meccanismo per trasferire i dati tra l'host di debug e il target\n"
+"* RTT (Real Time Transfers) è un meccanismo per trasferire i dati tra l'host "
+"di debug e il target\n"
" attraverso una serie di ringbuffer."
#: src/bare-metal/microcontrollers/debugging.md:1
@@ -13395,8 +14812,8 @@ msgstr "In un altro terminale nella stessa directory:"
#: src/bare-metal/microcontrollers/debugging.md:21
msgid ""
"```sh\n"
-"gdb-multiarch target/thumbv7em-none-eabihf/debug/board_support --eval-command=\"target "
-"remote :1337\"\n"
+"gdb-multiarch target/thumbv7em-none-eabihf/debug/board_support --eval-"
+"command=\"target remote :1337\"\n"
"```"
msgstr ""
@@ -13417,7 +14834,8 @@ msgid ""
"```"
msgstr ""
-#: src/bare-metal/microcontrollers/other-projects.md:1 src/bare-metal/aps/other-projects.md:1
+#: src/bare-metal/microcontrollers/other-projects.md:1
+#: src/bare-metal/aps/other-projects.md:1
#, fuzzy
msgid "# Other projects"
msgstr "# Altri progetti"
@@ -13427,59 +14845,70 @@ msgstr "# Altri progetti"
msgid ""
" * [RTIC](https://rtic.rs/)\n"
" * \"Real-Time Interrupt-driven Concurrency\"\n"
-" * Shared resource management, message passing, task scheduling, timer queue\n"
+" * Shared resource management, message passing, task scheduling, timer "
+"queue\n"
" * [Embassy](https://embassy.dev/)\n"
" * `async` executors with priorities, timers, networking, USB\n"
" * [TockOS](https://www.tockos.org/documentation/getting-started)\n"
-" * Security-focused RTOS with preemptive scheduling and Memory Protection Unit support\n"
+" * Security-focused RTOS with preemptive scheduling and Memory Protection "
+"Unit support\n"
" * [Hubris](https://hubris.oxide.computer/)\n"
-" * Microkernel RTOS from Oxide Computer Company with memory protection, unprivileged drivers, "
-"IPC\n"
+" * Microkernel RTOS from Oxide Computer Company with memory protection, "
+"unprivileged drivers, IPC\n"
" * [Bindings for FreeRTOS](https://github.com/lobaro/FreeRTOS-rust)\n"
" * Some platforms have `std` implementations, e.g.\n"
-" [esp-idf](https://esp-rs.github.io/book/overview/using-the-standard-library.html)."
+" [esp-idf](https://esp-rs.github.io/book/overview/using-the-standard-"
+"library.html)."
msgstr ""
" * [RTIC](https://rtic.rs/)\n"
" * \"Concorrenza basata su interrupt in tempo reale\"\n"
-" * Gestione delle risorse condivise, passaggio di messaggi, pianificazione delle attività, coda "
-"del timer\n"
+" * Gestione delle risorse condivise, passaggio di messaggi, pianificazione "
+"delle attività, coda del timer\n"
" * [Ambasciata](https://embassy.dev/)\n"
" * Esecutori `async` con priorità, timer, networking, USB\n"
" * [TockOS](https://www.tockos.org/documentation/getting-started)\n"
-" * RTOS incentrato sulla sicurezza con pianificazione preventiva e supporto dell'unità di "
-"protezione della memoria\n"
+" * RTOS incentrato sulla sicurezza con pianificazione preventiva e "
+"supporto dell'unità di protezione della memoria\n"
" * [Hubris](https://hubris.oxide.computer/)\n"
-" * Microkernel RTOS di Oxide Computer Company con protezione della memoria, driver non "
-"privilegiati, IPC\n"
+" * Microkernel RTOS di Oxide Computer Company con protezione della "
+"memoria, driver non privilegiati, IPC\n"
" * [Binding per FreeRTOS](https://github.com/lobaro/FreeRTOS-rust)\n"
" * Alcune piattaforme hanno implementazioni `std`, ad es.\n"
-" [esp-idf](https://esp-rs.github.io/book/overview/using-the-standard-library.html)."
+" [esp-idf](https://esp-rs.github.io/book/overview/using-the-standard-"
+"library.html)."
#: src/bare-metal/microcontrollers/other-projects.md:18
#, fuzzy
msgid ""
" * RTIC can be considered either an RTOS or a concurrency framework.\n"
" * It doesn't include any HALs.\n"
-" * It uses the Cortex-M NVIC (Nested Virtual Interrupt Controller) for scheduling rather than a\n"
+" * It uses the Cortex-M NVIC (Nested Virtual Interrupt Controller) for "
+"scheduling rather than a\n"
" proper kernel.\n"
" * Cortex-M only.\n"
" * Google uses TockOS on the Haven microcontroller for Titan security keys.\n"
-" * FreeRTOS is mostly written in C, but there are Rust bindings for writing applications."
+" * FreeRTOS is mostly written in C, but there are Rust bindings for writing "
+"applications."
msgstr ""
" * RTIC può essere considerato un RTOS o un framework di concorrenza.\n"
" * Non include nessun HAL.\n"
-" * Utilizza Cortex-M NVIC (Nested Virtual Interrupt Controller) per la pianificazione piuttosto "
-"che un\n"
+" * Utilizza Cortex-M NVIC (Nested Virtual Interrupt Controller) per la "
+"pianificazione piuttosto che un\n"
" kernel corretto.\n"
" * Solo Cortex-M.\n"
-" * Google utilizza TockOS sul microcontrollore Haven per le chiavi di sicurezza Titan.\n"
-" * FreeRTOS è principalmente scritto in C, ma ci sono collegamenti Rust per la scrittura di "
-"applicazioni."
+" * Google utilizza TockOS sul microcontrollore Haven per le chiavi di "
+"sicurezza Titan.\n"
+" * FreeRTOS è principalmente scritto in C, ma ci sono collegamenti Rust per "
+"la scrittura di applicazioni."
#: src/exercises/bare-metal/morning.md:3
#, fuzzy
-msgid "We will read the direction from an I2C compass, and log the readings to a serial port."
-msgstr "Leggeremo la direzione da una bussola I2C e registreremo le letture su una porta seriale."
+msgid ""
+"We will read the direction from an I2C compass, and log the readings to a "
+"serial port."
+msgstr ""
+"Leggeremo la direzione da una bussola I2C e registreremo le letture su una "
+"porta seriale."
#: src/exercises/bare-metal/compass.md:1
#, fuzzy
@@ -13489,12 +14918,14 @@ msgstr "# Bussola"
#: src/exercises/bare-metal/compass.md:3
#, fuzzy
msgid ""
-"We will read the direction from an I2C compass, and log the readings to a serial port. If you "
-"have\n"
+"We will read the direction from an I2C compass, and log the readings to a "
+"serial port. If you have\n"
"time, try displaying it on the LEDs somehow too, or use the buttons somehow."
msgstr ""
-"Leggeremo la direzione da una bussola I2C e registreremo le letture su una porta seriale. Se hai\n"
-"tempo, prova a visualizzarlo in qualche modo anche sui LED o usa i pulsanti in qualche modo."
+"Leggeremo la direzione da una bussola I2C e registreremo le letture su una "
+"porta seriale. Se hai\n"
+"tempo, prova a visualizzarlo in qualche modo anche sui LED o usa i pulsanti "
+"in qualche modo."
#: src/exercises/bare-metal/compass.md:6
#, fuzzy
@@ -13504,61 +14935,69 @@ msgstr "Suggerimenti:"
#: src/exercises/bare-metal/compass.md:8
#, fuzzy
msgid ""
-"- Check the documentation for the [`lsm303agr`](https://docs.rs/lsm303agr/latest/lsm303agr/) and\n"
-" [`microbit-v2`](https://docs.rs/microbit-v2/latest/microbit/) crates, as well as the\n"
+"- Check the documentation for the [`lsm303agr`](https://docs.rs/lsm303agr/"
+"latest/lsm303agr/) and\n"
+" [`microbit-v2`](https://docs.rs/microbit-v2/latest/microbit/) crates, as "
+"well as the\n"
" [micro:bit hardware](https://tech.microbit.org/hardware/).\n"
-"- The LSM303AGR Inertial Measurement Unit is connected to the internal I2C bus.\n"
+"- The LSM303AGR Inertial Measurement Unit is connected to the internal I2C "
+"bus.\n"
"- TWI is another name for I2C, so the I2C master peripheral is called TWIM.\n"
-"- The LSM303AGR driver needs something implementing the `embedded_hal::blocking::i2c::WriteRead`\n"
+"- The LSM303AGR driver needs something implementing the `embedded_hal::"
+"blocking::i2c::WriteRead`\n"
" trait. The\n"
-" [`microbit::hal::Twim`](https://docs.rs/microbit-v2/latest/microbit/hal/struct.Twim.html) "
-"struct\n"
+" [`microbit::hal::Twim`](https://docs.rs/microbit-v2/latest/microbit/hal/"
+"struct.Twim.html) struct\n"
" implements this.\n"
-"- You have a [`microbit::Board`](https://docs.rs/microbit-v2/latest/microbit/struct.Board.html)\n"
+"- You have a [`microbit::Board`](https://docs.rs/microbit-v2/latest/microbit/"
+"struct.Board.html)\n"
" struct with fields for the various pins and peripherals.\n"
"- You can also look at the\n"
-" [nRF52833 datasheet](https://infocenter.nordicsemi.com/pdf/nRF52833_PS_v1.5.pdf) if you want, "
-"but\n"
+" [nRF52833 datasheet](https://infocenter.nordicsemi.com/pdf/"
+"nRF52833_PS_v1.5.pdf) if you want, but\n"
" it shouldn't be necessary for this exercise."
msgstr ""
-"- Controlla la documentazione per [`lsm303agr`](https://docs.rs/lsm303agr/latest/lsm303agr/) e\n"
+"- Controlla la documentazione per [`lsm303agr`](https://docs.rs/lsm303agr/"
+"latest/lsm303agr/) e\n"
" [`microbit-v2`](https://docs.rs/microbit-v2/latest/microbit/) e le\n"
" [micro:bit hardware](https://tech.microbit.org/hardware/).\n"
"- L'unità di misura inerziale LSM303AGR è collegata al bus I2C interno.\n"
-"- TWI è un altro nome per I2C, quindi la periferica master I2C si chiama TWIM.\n"
-"- Il driver LSM303AGR necessita di qualcosa che implementi `embedded_hal::blocking::i2c::"
-"WriteRead`\n"
+"- TWI è un altro nome per I2C, quindi la periferica master I2C si chiama "
+"TWIM.\n"
+"- Il driver LSM303AGR necessita di qualcosa che implementi `embedded_hal::"
+"blocking::i2c::WriteRead`\n"
" tratto. IL\n"
-" [`microbit::hal::Twim`](https://docs.rs/microbit-v2/latest/microbit/hal/struct.Twim.html) "
-"struttura\n"
+" [`microbit::hal::Twim`](https://docs.rs/microbit-v2/latest/microbit/hal/"
+"struct.Twim.html) struttura\n"
" implementa questo.\n"
-"- Hai un [`microbit::Board`](https://docs.rs/microbit-v2/latest/microbit/struct.Board.html)\n"
+"- Hai un [`microbit::Board`](https://docs.rs/microbit-v2/latest/microbit/"
+"struct.Board.html)\n"
" struct con campi per i vari pin e periferiche.\n"
"- Puoi anche guardare il\n"
-" [scheda tecnica nRF52833](https://infocenter.nordicsemi.com/pdf/nRF52833_PS_v1.5.pdf) se vuoi, "
-"ma\n"
+" [scheda tecnica nRF52833](https://infocenter.nordicsemi.com/pdf/"
+"nRF52833_PS_v1.5.pdf) se vuoi, ma\n"
" non dovrebbe essere necessario per questo esercizio."
#: src/exercises/bare-metal/compass.md:23
#, fuzzy
msgid ""
-"Download the [exercise template](../../comprehensive-rust-exercises.zip) and look in the "
-"`compass`\n"
+"Download the [exercise template](../../comprehensive-rust-exercises.zip) and "
+"look in the `compass`\n"
"directory for the following files."
msgstr ""
-"Scarica il [modello di esercizio](../../comprehensive-rust-exercises.zip) e guarda nella "
-"`bussola`\n"
+"Scarica il [modello di esercizio](../../comprehensive-rust-exercises.zip) e "
+"guarda nella `bussola`\n"
"directory per i seguenti file."
#: src/exercises/bare-metal/compass.md:26 src/exercises/bare-metal/rtc.md:19
-#: src/exercises/concurrency/elevator.md:17
#, fuzzy
msgid "`src/main.rs`:"
msgstr "`src/principale.rs`:"
#: src/exercises/bare-metal/compass.md:28 src/exercises/bare-metal/rtc.md:21
-#: src/exercises/concurrency/dining-philosophers.md:17 src/exercises/concurrency/link-checker.md:55
-#: src/exercises/concurrency/dining-philosophers-async.md:11 src/exercises/concurrency/elevator.md:19
+#: src/exercises/concurrency/dining-philosophers.md:17
+#: src/exercises/concurrency/link-checker.md:55
+#: src/exercises/concurrency/dining-philosophers-async.md:11
#, fuzzy
msgid ""
msgstr ""
@@ -13601,15 +15040,15 @@ msgid ""
msgstr ""
#: src/exercises/bare-metal/compass.md:64 src/exercises/bare-metal/rtc.md:385
-#: src/exercises/concurrency/elevator.md:365
#, fuzzy
msgid "`Cargo.toml` (you shouldn't need to change this):"
msgstr "`Cargo.toml` (non dovrebbe essere necessario modificarlo):"
#: src/exercises/bare-metal/compass.md:66 src/exercises/bare-metal/rtc.md:387
-#: src/exercises/concurrency/dining-philosophers.md:63 src/exercises/concurrency/link-checker.md:35
+#: src/exercises/concurrency/dining-philosophers.md:63
+#: src/exercises/concurrency/link-checker.md:35
#: src/exercises/concurrency/dining-philosophers-async.md:60
-#: src/exercises/concurrency/elevator.md:367
+#: src/exercises/concurrency/chat-app.md:17
#, fuzzy
msgid ""
msgstr ""
@@ -13693,9 +15132,11 @@ msgstr ""
#: src/exercises/bare-metal/compass.md:118
#, fuzzy
-msgid "Or on Mac OS something like (the device name may be slightly different):"
+msgid ""
+"Or on Mac OS something like (the device name may be slightly different):"
msgstr ""
-"O su Mac OS qualcosa di simile (il nome del dispositivo potrebbe essere leggermente diverso):"
+"O su Mac OS qualcosa di simile (il nome del dispositivo potrebbe essere "
+"leggermente diverso):"
#: src/exercises/bare-metal/compass.md:120
msgid ""
@@ -13717,32 +15158,168 @@ msgstr "# Processori di applicazioni"
#: src/bare-metal/aps.md:3
#, fuzzy
msgid ""
-"So far we've talked about microcontrollers, such as the Arm Cortex-M series. Now let's try "
-"writing\n"
+"So far we've talked about microcontrollers, such as the Arm Cortex-M series. "
+"Now let's try writing\n"
"something for Cortex-A. For simplicity we'll just work with QEMU's aarch64\n"
"['virt'](https://qemu-project.gitlab.io/qemu/system/arm/virt.html) board."
msgstr ""
-"Finora abbiamo parlato di microcontrollori, come la serie Arm Cortex-M. Ora proviamo a scrivere\n"
+"Finora abbiamo parlato di microcontrollori, come la serie Arm Cortex-M. Ora "
+"proviamo a scrivere\n"
"qualcosa per Cortex-A. Per semplicità lavoreremo solo con aarch64 di QEMU\n"
"['virt'](https://qemu-project.gitlab.io/qemu/system/arm/virt.html) scheda."
#: src/bare-metal/aps.md:9
#, fuzzy
msgid ""
-"* Broadly speaking, microcontrollers don't have an MMU or multiple levels of privilege (exception\n"
+"* Broadly speaking, microcontrollers don't have an MMU or multiple levels of "
+"privilege (exception\n"
" levels on Arm CPUs, rings on x86), while application processors do.\n"
-"* QEMU supports emulating various different machines or board models for each architecture. The\n"
-" 'virt' board doesn't correspond to any particular real hardware, but is designed purely for\n"
+"* QEMU supports emulating various different machines or board models for "
+"each architecture. The\n"
+" 'virt' board doesn't correspond to any particular real hardware, but is "
+"designed purely for\n"
" virtual machines."
msgstr ""
-"* In generale, i microcontrollori non hanno una MMU o più livelli di privilegio (eccezione\n"
-" livelli su CPU Arm, anelli su x86), mentre i processori delle applicazioni lo fanno.\n"
-"* QEMU supporta l'emulazione di diverse macchine o modelli di scheda per ciascuna architettura. "
-"IL\n"
-" La scheda 'virt' non corrisponde a nessun particolare hardware reale, ma è progettata "
-"esclusivamente per\n"
+"* In generale, i microcontrollori non hanno una MMU o più livelli di "
+"privilegio (eccezione\n"
+" livelli su CPU Arm, anelli su x86), mentre i processori delle applicazioni "
+"lo fanno.\n"
+"* QEMU supporta l'emulazione di diverse macchine o modelli di scheda per "
+"ciascuna architettura. IL\n"
+" La scheda 'virt' non corrisponde a nessun particolare hardware reale, ma è "
+"progettata esclusivamente per\n"
" macchine virtuali."
+#: src/bare-metal/aps/entry-point.md:1
+msgid "# Getting Ready to Rust"
+msgstr ""
+
+#: src/bare-metal/aps/entry-point.md:3
+msgid ""
+"Before we can start running Rust code, we need to do some initialisation."
+msgstr ""
+
+#: src/bare-metal/aps/entry-point.md:5
+msgid ""
+"```armasm\n"
+".section .init.entry, \"ax\"\n"
+".global entry\n"
+"entry:\n"
+" /*\n"
+" * Load and apply the memory management configuration, ready to enable "
+"MMU and\n"
+" * caches.\n"
+" */\n"
+" adrp x30, idmap\n"
+" msr ttbr0_el1, x30\n"
+"\n"
+" mov_i x30, .Lmairval\n"
+" msr mair_el1, x30\n"
+"\n"
+" mov_i x30, .Ltcrval\n"
+" /* Copy the supported PA range into TCR_EL1.IPS. */\n"
+" mrs x29, id_aa64mmfr0_el1\n"
+" bfi x30, x29, #32, #4\n"
+"\n"
+" msr tcr_el1, x30\n"
+"\n"
+" mov_i x30, .Lsctlrval\n"
+"\n"
+" /*\n"
+" * Ensure everything before this point has completed, then invalidate "
+"any\n"
+" * potentially stale local TLB entries before they start being used.\n"
+" */\n"
+" isb\n"
+" tlbi vmalle1\n"
+" ic iallu\n"
+" dsb nsh\n"
+" isb\n"
+"\n"
+" /*\n"
+" * Configure sctlr_el1 to enable MMU and cache and don't proceed until "
+"this\n"
+" * has completed.\n"
+" */\n"
+" msr sctlr_el1, x30\n"
+" isb\n"
+"\n"
+" /* Disable trapping floating point access in EL1. */\n"
+" mrs x30, cpacr_el1\n"
+" orr x30, x30, #(0x3 << 20)\n"
+" msr cpacr_el1, x30\n"
+" isb\n"
+"\n"
+" /* Zero out the bss section. */\n"
+" adr_l x29, bss_begin\n"
+" adr_l x30, bss_end\n"
+"0: cmp x29, x30\n"
+" b.hs 1f\n"
+" stp xzr, xzr, [x29], #16\n"
+" b 0b\n"
+"\n"
+"1: /* Prepare the stack. */\n"
+" adr_l x30, boot_stack_end\n"
+" mov sp, x30\n"
+"\n"
+" /* Set up exception vector. */\n"
+" adr x30, vector_table_el1\n"
+" msr vbar_el1, x30\n"
+"\n"
+" /* Call into Rust code. */\n"
+" bl main\n"
+"\n"
+" /* Loop forever waiting for interrupts. */\n"
+"2: wfi\n"
+" b 2b\n"
+"```"
+msgstr ""
+
+#: src/bare-metal/aps/entry-point.md:77
+msgid ""
+"* This is the same as it would be for C: initialising the processor state, "
+"zeroing the BSS, and\n"
+" setting up the stack pointer.\n"
+" * The BSS (block starting symbol, for historical reasons) is the part of "
+"the object file which\n"
+" containing statically allocated variables which are initialised to zero. "
+"They are omitted from\n"
+" the image, to avoid wasting space on zeroes. The compiler assumes that "
+"the loader will take care\n"
+" of zeroing them.\n"
+"* The BSS may already be zeroed, depending on how memory is initialised and "
+"the image is loaded, but\n"
+" we zero it to be sure.\n"
+"* We need to enable the MMU and cache before reading or writing any memory. "
+"If we don't:\n"
+" * Unaligned accesses will fault. We build the Rust code for the `aarch64-"
+"unknown-none` target\n"
+" which sets `+strict-align` to prevent the compiler generating unaligned "
+"accesses, so it should\n"
+" be fine in this case, but this is not necessarily the case in general.\n"
+" * If it were running in a VM, this can lead to cache coherency issues. The "
+"problem is that the VM\n"
+" is accessing memory directly with the cache disabled, while the host has "
+"cachable aliases to the\n"
+" same memory. Even if the host doesn't explicitly access the memory, "
+"speculative accesses can\n"
+" lead to cache fills, and then changes from one or the other will get "
+"lost when the cache is\n"
+" cleaned or the VM enables the cache. (Cache is keyed by physical "
+"address, not VA or IPA.)\n"
+"* For simplicity, we just use a hardcoded pagetable (see `idmap.S`) which "
+"identity maps the first 1\n"
+" GiB of address space for devices, the next 1 GiB for DRAM, and another 1 "
+"GiB higher up for more\n"
+" devices. This matches the memory layout that QEMU uses.\n"
+"* We also set up the exception vector (`vbar_el1`), which we'll see more "
+"about later.\n"
+"* All examples this afternoon assume we will be running at exception level 1 "
+"(EL1). If you need to\n"
+" run at a different exception level you'll need to modify `entry.S` "
+"accordingly."
+msgstr ""
+
#: src/bare-metal/aps/inline-assembly.md:1
#, fuzzy
msgid "# Inline assembly"
@@ -13751,13 +15328,15 @@ msgstr "# Assemblaggio in linea"
#: src/bare-metal/aps/inline-assembly.md:3
#, fuzzy
msgid ""
-"Sometimes we need to use assembly to do things that aren't possible with Rust code. For example,\n"
-"to make an HVC to tell the firmware to power off the system:"
+"Sometimes we need to use assembly to do things that aren't possible with "
+"Rust code. For example,\n"
+"to make an HVC to tell the firmware "
+"to power off the system:"
msgstr ""
-"A volte abbiamo bisogno di usare l'assembly per fare cose che non sono possibili con il codice "
-"Rust. Per esempio,\n"
-"per effettuare un HVC per dire al firmware di spegnere il "
-"sistema:"
+"A volte abbiamo bisogno di usare l'assembly per fare cose che non sono "
+"possibili con il codice Rust. Per esempio,\n"
+"per effettuare un HVC per dire al "
+"firmware di spegnere il sistema:"
#: src/bare-metal/aps/inline-assembly.md:6
msgid ""
@@ -13798,56 +15377,64 @@ msgstr ""
#: src/bare-metal/aps/inline-assembly.md:39
#, fuzzy
msgid ""
-"(If you actually want to do this, use the [`smccc`][1] crate which has wrappers for all these "
-"functions.)"
-msgstr "(Se vuoi davvero farlo, usa la cassa [`smccc`][1] che ha wrapper per tutte queste funzioni.)"
+"(If you actually want to do this, use the [`smccc`][1] crate which has "
+"wrappers for all these functions.)"
+msgstr ""
+"(Se vuoi davvero farlo, usa la cassa [`smccc`][1] che ha wrapper per tutte "
+"queste funzioni.)"
#: src/bare-metal/aps/inline-assembly.md:43
#, fuzzy
msgid ""
-"* PSCI is the Arm Power State Coordination Interface, a standard set of functions to manage "
-"system\n"
-" and CPU power states, among other things. It is implemented by EL3 firmware and hypervisors on\n"
+"* PSCI is the Arm Power State Coordination Interface, a standard set of "
+"functions to manage system\n"
+" and CPU power states, among other things. It is implemented by EL3 "
+"firmware and hypervisors on\n"
" many systems.\n"
-"* The `0 => _` syntax means initialise the register to 0 before running the inline assembly code,\n"
-" and ignore its contents afterwards. We need to use `inout` rather than `in` because the call "
-"could\n"
+"* The `0 => _` syntax means initialise the register to 0 before running the "
+"inline assembly code,\n"
+" and ignore its contents afterwards. We need to use `inout` rather than "
+"`in` because the call could\n"
" potentially clobber the contents of the registers.\n"
-"* This `main` function needs to be `#[no_mangle]` and `extern \"C\"` because it is called from "
-"our\n"
+"* This `main` function needs to be `#[no_mangle]` and `extern \"C\"` because "
+"it is called from our\n"
" entry point in `entry.S`.\n"
-"* `_x0`–`_x3` are the values of registers `x0`–`x3`, which are conventionally used by the "
-"bootloader\n"
-" to pass things like a pointer to the device tree. According to the standard aarch64 calling\n"
-" convention (which is what `extern \"C\"` specifies to use), registers `x0`–`x7` are used for "
-"the\n"
-" first 8 arguments passed to a function, so `entry.S` doesn't need to do anything special except\n"
+"* `_x0`–`_x3` are the values of registers `x0`–`x3`, which are "
+"conventionally used by the bootloader\n"
+" to pass things like a pointer to the device tree. According to the "
+"standard aarch64 calling\n"
+" convention (which is what `extern \"C\"` specifies to use), registers `x0`–"
+"`x7` are used for the\n"
+" first 8 arguments passed to a function, so `entry.S` doesn't need to do "
+"anything special except\n"
" make sure it doesn't change these registers.\n"
-"* Run the example in QEMU with `make qemu_psci` under `src/bare-metal/aps/examples`."
+"* Run the example in QEMU with `make qemu_psci` under `src/bare-metal/aps/"
+"examples`."
msgstr ""
-"* PSCI è l'Arm Power State Coordination Interface, un insieme standard di funzioni per gestire il "
-"sistema\n"
-" e gli stati di alimentazione della CPU, tra le altre cose. È implementato dal firmware EL3 e "
-"dagli hypervisor su\n"
+"* PSCI è l'Arm Power State Coordination Interface, un insieme standard di "
+"funzioni per gestire il sistema\n"
+" e gli stati di alimentazione della CPU, tra le altre cose. È implementato "
+"dal firmware EL3 e dagli hypervisor su\n"
" molti sistemi.\n"
-"* La sintassi `0 => _` significa inizializzare il registro a 0 prima di eseguire il codice "
-"assembly inline,\n"
-" e ignorarne il contenuto in seguito. Dobbiamo usare \"inout\" piuttosto che \"in\" perché la "
-"chiamata potrebbe\n"
+"* La sintassi `0 => _` significa inizializzare il registro a 0 prima di "
+"eseguire il codice assembly inline,\n"
+" e ignorarne il contenuto in seguito. Dobbiamo usare \"inout\" piuttosto "
+"che \"in\" perché la chiamata potrebbe\n"
" potenzialmente intasare il contenuto dei registri.\n"
-"* Questa funzione `main` deve essere `#[no_mangle]` e `extern \"C\"` perché viene chiamata dal "
-"nostro\n"
+"* Questa funzione `main` deve essere `#[no_mangle]` e `extern \"C\"` perché "
+"viene chiamata dal nostro\n"
" punto di ingresso in \"entry.S\".\n"
-"* `_x0`–`_x3` sono i valori dei registri `x0`–`x3`, che sono convenzionalmente utilizzati dal "
-"bootloader\n"
-" per passare cose come un puntatore all'albero dei dispositivi. Secondo la chiamata standard "
-"aarch64\n"
-" convenzione (che è ciò che `extern \"C\"` specifica di usare), i registri `x0`–`x7` sono usati "
-"per\n"
-" primi 8 argomenti passati a una funzione, quindi `entry.S` non ha bisogno di fare niente di "
-"speciale tranne\n"
+"* `_x0`–`_x3` sono i valori dei registri `x0`–`x3`, che sono "
+"convenzionalmente utilizzati dal bootloader\n"
+" per passare cose come un puntatore all'albero dei dispositivi. Secondo la "
+"chiamata standard aarch64\n"
+" convenzione (che è ciò che `extern \"C\"` specifica di usare), i registri "
+"`x0`–`x7` sono usati per\n"
+" primi 8 argomenti passati a una funzione, quindi `entry.S` non ha bisogno "
+"di fare niente di speciale tranne\n"
" assicurati che non modifichi questi registri.\n"
-"* Eseguire l'esempio in QEMU con `make qemu_psci` in `src/bare-metal/aps/examples`."
+"* Eseguire l'esempio in QEMU con `make qemu_psci` in `src/bare-metal/aps/"
+"examples`."
#: src/bare-metal/aps/mmio.md:1
#, fuzzy
@@ -13859,36 +15446,43 @@ msgstr "# Accesso alla memoria volatile per MMIO"
msgid ""
" * Use `pointer::read_volatile` and `pointer::write_volatile`.\n"
" * Never hold a reference.\n"
-" * `addr_of!` lets you get fields of structs without creating an intermediate reference."
+" * `addr_of!` lets you get fields of structs without creating an "
+"intermediate reference."
msgstr ""
" * Usa `pointer::read_volatile` e `pointer::write_volatile`.\n"
" * Non tenere mai un riferimento.\n"
-" * `addr_of!` consente di ottenere campi di struct senza creare un riferimento intermedio."
+" * `addr_of!` consente di ottenere campi di struct senza creare un "
+"riferimento intermedio."
#: src/bare-metal/aps/mmio.md:9
#, fuzzy
msgid ""
-" * Volatile access: read or write operations may have side-effects, so prevent the compiler or\n"
+" * Volatile access: read or write operations may have side-effects, so "
+"prevent the compiler or\n"
" hardware from reordering, duplicating or eliding them.\n"
-" * Usually if you write and then read, e.g. via a mutable reference, the compiler may assume "
-"that\n"
-" the value read is the same as the value just written, and not bother actually reading "
-"memory.\n"
-" * Some existing crates for volatile access to hardware do hold references, but this is unsound.\n"
+" * Usually if you write and then read, e.g. via a mutable reference, the "
+"compiler may assume that\n"
+" the value read is the same as the value just written, and not bother "
+"actually reading memory.\n"
+" * Some existing crates for volatile access to hardware do hold references, "
+"but this is unsound.\n"
" Whenever a reference exist, the compiler may choose to dereference it.\n"
-" * Use the `addr_of!` macro to get struct field pointers from a pointer to the struct."
+" * Use the `addr_of!` macro to get struct field pointers from a pointer to "
+"the struct."
msgstr ""
-" * Accesso volatile: le operazioni di lettura o scrittura possono avere effetti collaterali, "
-"quindi impedisci al compilatore o\n"
+" * Accesso volatile: le operazioni di lettura o scrittura possono avere "
+"effetti collaterali, quindi impedisci al compilatore o\n"
" hardware dal riordinarli, duplicarli o eliminarli.\n"
-" * Di solito se scrivi e poi leggi, ad es. tramite un riferimento mutabile, il compilatore può "
-"assumerlo\n"
-" il valore letto è uguale al valore appena scritto, e non disturba effettivamente la lettura "
-"della memoria.\n"
-" * Alcuni crate esistenti per l'accesso volatile all'hardware contengono riferimenti, ma questo "
-"non è corretto.\n"
-" Ogni volta che esiste un riferimento, il compilatore può scegliere di dereferenziarlo.\n"
-" * Usa la macro `addr_of!` per ottenere i puntatori di campo struct da un puntatore alla struct."
+" * Di solito se scrivi e poi leggi, ad es. tramite un riferimento "
+"mutabile, il compilatore può assumerlo\n"
+" il valore letto è uguale al valore appena scritto, e non disturba "
+"effettivamente la lettura della memoria.\n"
+" * Alcuni crate esistenti per l'accesso volatile all'hardware contengono "
+"riferimenti, ma questo non è corretto.\n"
+" Ogni volta che esiste un riferimento, il compilatore può scegliere di "
+"dereferenziarlo.\n"
+" * Usa la macro `addr_of!` per ottenere i puntatori di campo struct da un "
+"puntatore alla struct."
#: src/bare-metal/aps/uart.md:1
#, fuzzy
@@ -13897,8 +15491,12 @@ msgstr "# Scriviamo un driver UART"
#: src/bare-metal/aps/uart.md:3
#, fuzzy
-msgid "The QEMU 'virt' machine has a [PL011][1] UART, so let's write a driver for that."
-msgstr "La macchina QEMU 'virt' ha un [PL011][1] UART, quindi scriviamo un driver per quello."
+msgid ""
+"The QEMU 'virt' machine has a [PL011][1] UART, so let's write a driver for "
+"that."
+msgstr ""
+"La macchina QEMU 'virt' ha un [PL011][1] UART, quindi scriviamo un driver "
+"per quello."
#: src/bare-metal/aps/uart.md:5
msgid ""
@@ -13914,13 +15512,16 @@ msgid ""
"}\n"
"\n"
"impl Uart {\n"
-" /// Constructs a new instance of the UART driver for a PL011 device at the\n"
+" /// Constructs a new instance of the UART driver for a PL011 device at "
+"the\n"
" /// given base address.\n"
" ///\n"
" /// # Safety\n"
" ///\n"
-" /// The given base address must point to the 8 MMIO control registers of a\n"
-" /// PL011 device, which must be mapped into the address space of the process\n"
+" /// The given base address must point to the 8 MMIO control registers of "
+"a\n"
+" /// PL011 device, which must be mapped into the address space of the "
+"process\n"
" /// as device memory and not have any other aliases.\n"
" pub unsafe fn new(base_address: *mut u8) -> Self {\n"
" Self { base_address }\n"
@@ -13945,7 +15546,8 @@ msgid ""
" fn read_flag_register(&self) -> u8 {\n"
" // Safe because we know that the base address points to the control\n"
" // registers of a PL011 device which is appropriately mapped.\n"
-" unsafe { self.base_address.add(FLAG_REGISTER_OFFSET).read_volatile() }\n"
+" unsafe { self.base_address.add(FLAG_REGISTER_OFFSET)."
+"read_volatile() }\n"
" }\n"
"}\n"
"```"
@@ -13954,34 +15556,40 @@ msgstr ""
#: src/bare-metal/aps/uart.md:55
#, fuzzy
msgid ""
-"* Note that `Uart::new` is unsafe while the other methods are safe. This is because as long as "
-"the\n"
-" caller of `Uart::new` guarantees that its safety requirements are met (i.e. that there is only\n"
-" ever one instance of the driver for a given UART, and nothing else aliasing its address space),\n"
-" then it is always safe to call `write_byte` later because we can assume the necessary\n"
+"* Note that `Uart::new` is unsafe while the other methods are safe. This is "
+"because as long as the\n"
+" caller of `Uart::new` guarantees that its safety requirements are met (i."
+"e. that there is only\n"
+" ever one instance of the driver for a given UART, and nothing else "
+"aliasing its address space),\n"
+" then it is always safe to call `write_byte` later because we can assume "
+"the necessary\n"
" preconditions.\n"
-"* We could have done it the other way around (making `new` safe but `write_byte` unsafe), but "
-"that\n"
-" would be much less convenient to use as every place that calls `write_byte` would need to "
-"reason\n"
+"* We could have done it the other way around (making `new` safe but "
+"`write_byte` unsafe), but that\n"
+" would be much less convenient to use as every place that calls "
+"`write_byte` would need to reason\n"
" about the safety\n"
-"* This is a common pattern for writing safe wrappers of unsafe code: moving the burden of proof "
-"for\n"
+"* This is a common pattern for writing safe wrappers of unsafe code: moving "
+"the burden of proof for\n"
" soundness from a large number of places to a smaller number of places."
msgstr ""
-"* Nota che `Uart::new` non è sicuro mentre gli altri metodi sono sicuri. Questo perché finché il\n"
-" chiamante di `Uart::new` garantisce che i suoi requisiti di sicurezza siano soddisfatti (cioè "
-"che ci sia solo\n"
-" mai un'istanza del driver per un dato UART, e nient'altro che alias il suo spazio degli "
-"indirizzi),\n"
-" quindi è sempre sicuro chiamare `write_byte` in seguito perché possiamo assumere il necessario\n"
+"* Nota che `Uart::new` non è sicuro mentre gli altri metodi sono sicuri. "
+"Questo perché finché il\n"
+" chiamante di `Uart::new` garantisce che i suoi requisiti di sicurezza "
+"siano soddisfatti (cioè che ci sia solo\n"
+" mai un'istanza del driver per un dato UART, e nient'altro che alias il suo "
+"spazio degli indirizzi),\n"
+" quindi è sempre sicuro chiamare `write_byte` in seguito perché possiamo "
+"assumere il necessario\n"
" precondizioni.\n"
-"* Avremmo potuto fare il contrario (rendere `new` sicuro ma `write_byte` non sicuro), ma quello\n"
-" sarebbe molto meno conveniente da usare poiché ogni posto che chiama `write_byte` dovrebbe "
-"ragionare\n"
+"* Avremmo potuto fare il contrario (rendere `new` sicuro ma `write_byte` non "
+"sicuro), ma quello\n"
+" sarebbe molto meno conveniente da usare poiché ogni posto che chiama "
+"`write_byte` dovrebbe ragionare\n"
" sulla sicurezza\n"
-"* Questo è un modello comune per scrivere wrapper sicuri di codice non sicuro: spostare l'onere "
-"della prova per\n"
+"* Questo è un modello comune per scrivere wrapper sicuri di codice non "
+"sicuro: spostare l'onere della prova per\n"
" solidità da un gran numero di posti a un numero minore di posti."
#: src/bare-metal/aps/uart.md:66
@@ -13996,8 +15604,12 @@ msgstr "# Altri tratti"
#: src/bare-metal/aps/uart/traits.md:3
#, fuzzy
-msgid "We derived the `Debug` trait. It would be useful to implement a few more traits too."
-msgstr "Abbiamo derivato il tratto `Debug`. Sarebbe utile implementare anche qualche altro tratto."
+msgid ""
+"We derived the `Debug` trait. It would be useful to implement a few more "
+"traits too."
+msgstr ""
+"Abbiamo derivato il tratto `Debug`. Sarebbe utile implementare anche qualche "
+"altro tratto."
#: src/bare-metal/aps/uart/traits.md:5
msgid ""
@@ -14022,12 +15634,15 @@ msgstr ""
#: src/bare-metal/aps/uart/traits.md:24
#, fuzzy
msgid ""
-"* Implementing `Write` lets us use the `write!` and `writeln!` macros with our `Uart` type.\n"
-"* Run the example in QEMU with `make qemu_minimal` under `src/bare-metal/aps/examples`."
+"* Implementing `Write` lets us use the `write!` and `writeln!` macros with "
+"our `Uart` type.\n"
+"* Run the example in QEMU with `make qemu_minimal` under `src/bare-metal/aps/"
+"examples`."
msgstr ""
-"* L'implementazione di `Write` ci permette di usare le macro `write!` e `writeln!` con il nostro "
-"tipo `Uart`.\n"
-"* Esegui l'esempio in QEMU con `make qemu_minimal` sotto `src/bare-metal/aps/examples`."
+"* L'implementazione di `Write` ci permette di usare le macro `write!` e "
+"`writeln!` con il nostro tipo `Uart`.\n"
+"* Esegui l'esempio in QEMU con `make qemu_minimal` sotto `src/bare-metal/aps/"
+"examples`."
#: src/bare-metal/aps/better-uart.md:1
#, fuzzy
@@ -14037,15 +15652,16 @@ msgstr "# Un driver UART migliore"
#: src/bare-metal/aps/better-uart.md:3
#, fuzzy
msgid ""
-"The PL011 actually has [a bunch more registers][1], and adding offsets to construct pointers to "
-"access\n"
-"them is error-prone and hard to read. Plus, some of them are bit fields which would be nice to\n"
+"The PL011 actually has [a bunch more registers][1], and adding offsets to "
+"construct pointers to access\n"
+"them is error-prone and hard to read. Plus, some of them are bit fields "
+"which would be nice to\n"
"access in a structured way."
msgstr ""
-"Il PL011 in realtà ha [un mucchio di registri in più][1] e aggiunge offset per costruire puntatori "
-"a cui accedere\n"
-"è soggetto a errori e difficile da leggere. Inoltre, alcuni di loro sono campi di bit che "
-"sarebbero carini\n"
+"Il PL011 in realtà ha [un mucchio di registri in più][1] e aggiunge offset "
+"per costruire puntatori a cui accedere\n"
+"è soggetto a errori e difficile da leggere. Inoltre, alcuni di loro sono "
+"campi di bit che sarebbero carini\n"
"accedere in modo strutturato."
#: src/bare-metal/aps/better-uart.md:7
@@ -14088,7 +15704,9 @@ msgstr ""
#: src/bare-metal/aps/better-uart.md:26
#, fuzzy
msgid "- There are also some ID registers which have been omitted for brevity."
-msgstr "- Sono inoltre presenti alcuni registri identificativi che per brevità sono stati omessi."
+msgstr ""
+"- Sono inoltre presenti alcuni registri identificativi che per brevità sono "
+"stati omessi."
#: src/bare-metal/aps/better-uart/bitflags.md:1
#, fuzzy
@@ -14098,9 +15716,11 @@ msgstr "# Bitflag"
#: src/bare-metal/aps/better-uart/bitflags.md:3
#, fuzzy
msgid ""
-"The [`bitflags`](https://crates.io/crates/bitflags) crate is useful for working with bitflags."
+"The [`bitflags`](https://crates.io/crates/bitflags) crate is useful for "
+"working with bitflags."
msgstr ""
-"Il crate [`bitflags`](https://crates.io/crates/bitflags) è utile per lavorare con i bitflags."
+"Il crate [`bitflags`](https://crates.io/crates/bitflags) è utile per "
+"lavorare con i bitflags."
#: src/bare-metal/aps/better-uart/bitflags.md:5
msgid ""
@@ -14138,12 +15758,12 @@ msgstr ""
#: src/bare-metal/aps/better-uart/bitflags.md:37
#, fuzzy
msgid ""
-"* The `bitflags!` macro creates a newtype something like `Flags(u16)`, along with a bunch of "
-"method\n"
+"* The `bitflags!` macro creates a newtype something like `Flags(u16)`, along "
+"with a bunch of method\n"
" implementations to get and set flags."
msgstr ""
-"* La macro `bitflags!` crea un nuovo tipo qualcosa come `Flags(u16)`, insieme a una serie di "
-"metodi\n"
+"* La macro `bitflags!` crea un nuovo tipo qualcosa come `Flags(u16)`, "
+"insieme a una serie di metodi\n"
" implementazioni per ottenere e impostare flag."
#: src/bare-metal/aps/better-uart/registers.md:1
@@ -14153,8 +15773,11 @@ msgstr "# Più registri"
#: src/bare-metal/aps/better-uart/registers.md:3
#, fuzzy
-msgid "We can use a struct to represent the memory layout of the UART's registers."
-msgstr "Possiamo usare una struct per rappresentare il layout di memoria dei registri dell'UART."
+msgid ""
+"We can use a struct to represent the memory layout of the UART's registers."
+msgstr ""
+"Possiamo usare una struct per rappresentare il layout di memoria dei "
+"registri dell'UART."
#: src/bare-metal/aps/better-uart/registers.md:5
msgid ""
@@ -14196,17 +15819,20 @@ msgstr ""
#: src/bare-metal/aps/better-uart/registers.md:41
#, fuzzy
msgid ""
-"* [`#[repr(C)]`](https://doc.rust-lang.org/reference/type-layout.html#the-c-representation) tells\n"
-" the compiler to lay the struct fields out in order, following the same rules as C. This is\n"
-" necessary for our struct to have a predictable layout, as default Rust representation allows "
-"the\n"
+"* [`#[repr(C)]`](https://doc.rust-lang.org/reference/type-layout.html#the-c-"
+"representation) tells\n"
+" the compiler to lay the struct fields out in order, following the same "
+"rules as C. This is\n"
+" necessary for our struct to have a predictable layout, as default Rust "
+"representation allows the\n"
" compiler to (among other things) reorder fields however it sees fit."
msgstr ""
-"* [`#[repr(C)]`](https://doc.rust-lang.org/reference/type-layout.html#the-c-representation) "
-"indica\n"
-" il compilatore per disporre i campi struct in ordine, seguendo le stesse regole di C. Questo è\n"
-" necessario affinché la nostra struttura abbia un layout prevedibile, poiché la rappresentazione "
-"predefinita di Rust lo consente\n"
+"* [`#[repr(C)]`](https://doc.rust-lang.org/reference/type-layout.html#the-c-"
+"representation) indica\n"
+" il compilatore per disporre i campi struct in ordine, seguendo le stesse "
+"regole di C. Questo è\n"
+" necessario affinché la nostra struttura abbia un layout prevedibile, "
+"poiché la rappresentazione predefinita di Rust lo consente\n"
" compilatore per (tra le altre cose) riordinare i campi come meglio crede."
#: src/bare-metal/aps/better-uart/driver.md:1
@@ -14229,13 +15855,16 @@ msgid ""
"}\n"
"\n"
"impl Uart {\n"
-" /// Constructs a new instance of the UART driver for a PL011 device at the\n"
+" /// Constructs a new instance of the UART driver for a PL011 device at "
+"the\n"
" /// given base address.\n"
" ///\n"
" /// # Safety\n"
" ///\n"
-" /// The given base address must point to the 8 MMIO control registers of a\n"
-" /// PL011 device, which must be mapped into the address space of the process\n"
+" /// The given base address must point to the 8 MMIO control registers of "
+"a\n"
+" /// PL011 device, which must be mapped into the address space of the "
+"process\n"
" /// as device memory and not have any other aliases.\n"
" pub unsafe fn new(base_address: *mut u32) -> Self {\n"
" Self {\n"
@@ -14259,12 +15888,14 @@ msgid ""
" while self.read_flag_register().contains(Flags::BUSY) {}\n"
" }\n"
"\n"
-" /// Reads and returns a pending byte, or `None` if nothing has been received.\n"
+" /// Reads and returns a pending byte, or `None` if nothing has been "
+"received.\n"
" pub fn read_byte(&self) -> Option {\n"
" if self.read_flag_register().contains(Flags::RXFE) {\n"
" None\n"
" } else {\n"
-" let data = unsafe { addr_of!((*self.registers).dr).read_volatile() };\n"
+" let data = unsafe { addr_of!((*self.registers).dr)."
+"read_volatile() };\n"
" // TODO: Check for error conditions in bits 8-11.\n"
" Some(data as u8)\n"
" }\n"
@@ -14282,14 +15913,16 @@ msgstr ""
#: src/bare-metal/aps/better-uart/driver.md:64
#, fuzzy
msgid ""
-"* Note the use of `addr_of!` / `addr_of_mut!` to get pointers to individual fields without "
-"creating\n"
+"* Note the use of `addr_of!` / `addr_of_mut!` to get pointers to individual "
+"fields without creating\n"
" an intermediate reference, which would be unsound."
msgstr ""
-"* Notare l'uso di `addr_of!` / `addr_of_mut!` per ottenere puntatori a singoli campi senza creare\n"
+"* Notare l'uso di `addr_of!` / `addr_of_mut!` per ottenere puntatori a "
+"singoli campi senza creare\n"
" un riferimento intermedio, che sarebbe errato."
-#: src/bare-metal/aps/better-uart/using.md:1 src/bare-metal/aps/logging/using.md:1
+#: src/bare-metal/aps/better-uart/using.md:1
+#: src/bare-metal/aps/logging/using.md:1
#, fuzzy
msgid "# Using it"
msgstr "# Usandolo"
@@ -14297,11 +15930,12 @@ msgstr "# Usandolo"
#: src/bare-metal/aps/better-uart/using.md:3
#, fuzzy
msgid ""
-"Let's write a small program using our driver to write to the serial console, and echo incoming\n"
+"Let's write a small program using our driver to write to the serial console, "
+"and echo incoming\n"
"bytes."
msgstr ""
-"Scriviamo un piccolo programma usando il nostro driver per scrivere sulla console seriale ed echo "
-"in entrata\n"
+"Scriviamo un piccolo programma usando il nostro driver per scrivere sulla "
+"console seriale ed echo in entrata\n"
"byte."
#: src/bare-metal/aps/better-uart/using.md:6
@@ -14325,7 +15959,8 @@ msgid ""
"\n"
"#[no_mangle]\n"
"extern \"C\" fn main(x0: u64, x1: u64, x2: u64, x3: u64) {\n"
-" // Safe because `PL011_BASE_ADDRESS` is the base address of a PL011 device,\n"
+" // Safe because `PL011_BASE_ADDRESS` is the base address of a PL011 "
+"device,\n"
" // and nothing else accesses that address range.\n"
" let mut uart = unsafe { Uart::new(PL011_BASE_ADDRESS) };\n"
"\n"
@@ -14353,24 +15988,28 @@ msgstr ""
#: src/bare-metal/aps/better-uart/using.md:51
#, fuzzy
msgid ""
-"* As in the [inline assembly](../inline-assembly.md) example, this `main` function is called from "
-"our\n"
+"* As in the [inline assembly](../inline-assembly.md) example, this `main` "
+"function is called from our\n"
" entry point code in `entry.S`. See the speaker notes there for details.\n"
-"* Run the example in QEMU with `make qemu` under `src/bare-metal/aps/examples`."
+"* Run the example in QEMU with `make qemu` under `src/bare-metal/aps/"
+"examples`."
msgstr ""
-"* Come nell'esempio [inline assembly](../inline-assembly.md), questa funzione `main` è chiamata "
-"dal nostro\n"
-" codice del punto di ingresso in \"entry.S\". Vedi le note del relatore lì per i dettagli.\n"
-"* Esegui l'esempio in QEMU con `make qemu` sotto `src/bare-metal/aps/examples`."
+"* Come nell'esempio [inline assembly](../inline-assembly.md), questa "
+"funzione `main` è chiamata dal nostro\n"
+" codice del punto di ingresso in \"entry.S\". Vedi le note del relatore lì "
+"per i dettagli.\n"
+"* Esegui l'esempio in QEMU con `make qemu` sotto `src/bare-metal/aps/"
+"examples`."
#: src/bare-metal/aps/logging.md:3
#, fuzzy
msgid ""
-"It would be nice to be able to use the logging macros from the [`log`][1] crate. We can do this "
-"by\n"
+"It would be nice to be able to use the logging macros from the [`log`][1] "
+"crate. We can do this by\n"
"implementing the `Log` trait."
msgstr ""
-"Sarebbe bello poter usare le macro di registrazione dalla cassa [`log`][1]. Possiamo farlo con\n"
+"Sarebbe bello poter usare le macro di registrazione dalla cassa [`log`][1]. "
+"Possiamo farlo con\n"
"implementando il tratto `Log`."
#: src/bare-metal/aps/logging.md:6
@@ -14408,7 +16047,8 @@ msgid ""
"}\n"
"\n"
"/// Initialises UART logger.\n"
-"pub fn init(uart: Uart, max_level: LevelFilter) -> Result<(), SetLoggerError> {\n"
+"pub fn init(uart: Uart, max_level: LevelFilter) -> Result<(), "
+"SetLoggerError> {\n"
" LOGGER.uart.lock().replace(uart);\n"
"\n"
" log::set_logger(&LOGGER)?;\n"
@@ -14420,8 +16060,12 @@ msgstr ""
#: src/bare-metal/aps/logging.md:50
#, fuzzy
-msgid "* The unwrap in `log` is safe because we initialise `LOGGER` before calling `set_logger`."
-msgstr "* L'unwrap in `log` è sicuro perché inizializziamo `LOGGER` prima di chiamare `set_logger`."
+msgid ""
+"* The unwrap in `log` is safe because we initialise `LOGGER` before calling "
+"`set_logger`."
+msgstr ""
+"* L'unwrap in `log` è sicuro perché inizializziamo `LOGGER` prima di "
+"chiamare `set_logger`."
#: src/bare-metal/aps/logging/using.md:3
#, fuzzy
@@ -14449,7 +16093,8 @@ msgid ""
"\n"
"#[no_mangle]\n"
"extern \"C\" fn main(x0: u64, x1: u64, x2: u64, x3: u64) {\n"
-" // Safe because `PL011_BASE_ADDRESS` is the base address of a PL011 device,\n"
+" // Safe because `PL011_BASE_ADDRESS` is the base address of a PL011 "
+"device,\n"
" // and nothing else accesses that address range.\n"
" let uart = unsafe { Uart::new(PL011_BASE_ADDRESS) };\n"
" logger::init(uart, LevelFilter::Trace).unwrap();\n"
@@ -14474,10 +16119,106 @@ msgstr ""
#, fuzzy
msgid ""
"* Note that our panic handler can now log details of panics.\n"
-"* Run the example in QEMU with `make qemu_logger` under `src/bare-metal/aps/examples`."
+"* Run the example in QEMU with `make qemu_logger` under `src/bare-metal/aps/"
+"examples`."
+msgstr ""
+"* Nota che il nostro gestore del panico ora può registrare i dettagli dei "
+"panico.\n"
+"* Eseguire l'esempio in QEMU con `make qemu_logger` in `src/bare-metal/aps/"
+"examples`."
+
+#: src/bare-metal/aps/exceptions.md:1
+#, fuzzy
+msgid "# Exceptions"
+msgstr "# Funzioni"
+
+#: src/bare-metal/aps/exceptions.md:3
+msgid ""
+"AArch64 defines an exception vector table with 16 entries, for 4 types of "
+"exceptions (synchronous,\n"
+"IRQ, FIQ, SError) from 4 states (current EL with SP0, current EL with SPx, "
+"lower EL using AArch64,\n"
+"lower EL using AArch32). We implement this in assembly to save volatile "
+"registers to the stack\n"
+"before calling into Rust code:"
+msgstr ""
+
+#: src/bare-metal/aps/exceptions.md:8
+msgid ""
+"```rust,editable,compile_fail\n"
+"use log::error;\n"
+"use smccc::psci::system_off;\n"
+"use smccc::Hvc;\n"
+"\n"
+"#[no_mangle]\n"
+"extern \"C\" fn sync_exception_current(_elr: u64, _spsr: u64) {\n"
+" error!(\"sync_exception_current\");\n"
+" system_off::().unwrap();\n"
+"}\n"
+"\n"
+"#[no_mangle]\n"
+"extern \"C\" fn irq_current(_elr: u64, _spsr: u64) {\n"
+" error!(\"irq_current\");\n"
+" system_off::().unwrap();\n"
+"}\n"
+"\n"
+"#[no_mangle]\n"
+"extern \"C\" fn fiq_current(_elr: u64, _spsr: u64) {\n"
+" error!(\"fiq_current\");\n"
+" system_off::().unwrap();\n"
+"}\n"
+"\n"
+"#[no_mangle]\n"
+"extern \"C\" fn serr_current(_elr: u64, _spsr: u64) {\n"
+" error!(\"serr_current\");\n"
+" system_off::().unwrap();\n"
+"}\n"
+"\n"
+"#[no_mangle]\n"
+"extern \"C\" fn sync_lower(_elr: u64, _spsr: u64) {\n"
+" error!(\"sync_lower\");\n"
+" system_off::().unwrap();\n"
+"}\n"
+"\n"
+"#[no_mangle]\n"
+"extern \"C\" fn irq_lower(_elr: u64, _spsr: u64) {\n"
+" error!(\"irq_lower\");\n"
+" system_off::().unwrap();\n"
+"}\n"
+"\n"
+"#[no_mangle]\n"
+"extern \"C\" fn fiq_lower(_elr: u64, _spsr: u64) {\n"
+" error!(\"fiq_lower\");\n"
+" system_off::().unwrap();\n"
+"}\n"
+"\n"
+"#[no_mangle]\n"
+"extern \"C\" fn serr_lower(_elr: u64, _spsr: u64) {\n"
+" error!(\"serr_lower\");\n"
+" system_off::().unwrap();\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/bare-metal/aps/exceptions.md:64
+msgid ""
+"* EL is exception level; all our examples this afternoon run in EL1.\n"
+"* For simplicity we aren't distinguishing between SP0 and SPx for the "
+"current EL exceptions, or\n"
+" between AArch32 and AArch64 for the lower EL exceptions.\n"
+"* For this example we just log the exception and power down, as we don't "
+"expect any of them to\n"
+" actually happen.\n"
+"* We can think of exception handlers and our main execution context more or "
+"less like different\n"
+" threads. [`Send` and `Sync`][1] will control what we can share between "
+"them, just like with threads.\n"
+" For example, if we want to share some value between exception handlers and "
+"the rest of the\n"
+" program, and it's `Send` but not `Sync`, then we'll need to wrap it in "
+"something like a `Mutex`\n"
+" and put it in a static."
msgstr ""
-"* Nota che il nostro gestore del panico ora può registrare i dettagli dei panico.\n"
-"* Eseguire l'esempio in QEMU con `make qemu_logger` in `src/bare-metal/aps/examples`."
#: src/bare-metal/aps/other-projects.md:3
#, fuzzy
@@ -14486,10 +16227,14 @@ msgid ""
" * \"coreboot without the C\"\n"
" * Supports x86, aarch64 and RISC-V.\n"
" * Relies on LinuxBoot rather than having many drivers itself.\n"
-" * [Rust RaspberryPi OS tutorial](https://github.com/rust-embedded/rust-raspberrypi-OS-tutorials)\n"
-" * Initialisation, UART driver, simple bootloader, JTAG, exception levels, exception handling, "
-"page tables\n"
-" * Not all very well written, so beware.\n"
+" * [Rust RaspberryPi OS tutorial](https://github.com/rust-embedded/rust-"
+"raspberrypi-OS-tutorials)\n"
+" * Initialisation, UART driver, simple bootloader, JTAG, exception levels, "
+"exception handling,\n"
+" page tables\n"
+" * Some dodginess around cache maintenance and initialisation in Rust, not "
+"necessarily a good\n"
+" example to copy for production code.\n"
" * [`cargo-call-stack`](https://crates.io/crates/cargo-call-stack)\n"
" * Static analysis to determine maximum stack usage."
msgstr ""
@@ -14497,14 +16242,37 @@ msgstr ""
" * \"coreboot senza la C\"\n"
" * Supporta x86, aarch64 e RISC-V.\n"
" * Si basa su LinuxBoot piuttosto che avere molti driver.\n"
-" * [Tutorial sul sistema operativo Rust RaspberryPi](https://github.com/rust-embedded/rust-"
-"raspberrypi-OS-tutorials)\n"
-" * Inizializzazione, driver UART, bootloader semplice, JTAG, livelli di eccezione, gestione "
-"delle eccezioni, tabelle delle pagine\n"
+" * [Tutorial sul sistema operativo Rust RaspberryPi](https://github.com/rust-"
+"embedded/rust-raspberrypi-OS-tutorials)\n"
+" * Inizializzazione, driver UART, bootloader semplice, JTAG, livelli di "
+"eccezione, gestione delle eccezioni, tabelle delle pagine\n"
" * Non tutto molto ben scritto, quindi attenzione.\n"
" * [`cargo-call-stack`](https://crates.io/crates/cargo-call-stack)\n"
" * Analisi statica per determinare l'utilizzo massimo dello stack."
+#: src/bare-metal/aps/other-projects.md:17
+msgid ""
+"* The RaspberryPi OS tutorial runs Rust code before the MMU and caches are "
+"enabled. This will read\n"
+" and write memory (e.g. the stack). However:\n"
+" * Without the MMU and cache, unaligned accesses will fault. It builds with "
+"`aarch64-unknown-none`\n"
+" which sets `+strict-align` to prevent the compiler generating unaligned "
+"accesses so it should be\n"
+" alright, but this is not necessarily the case in general.\n"
+" * If it were running in a VM, this can lead to cache coherency issues. The "
+"problem is that the VM\n"
+" is accessing memory directly with the cache disabled, while the host has "
+"cachable aliases to the\n"
+" same memory. Even if the host doesn't explicitly access the memory, "
+"speculative accesses can\n"
+" lead to cache fills, and then changes from one or the other will get "
+"lost. Again this is alright\n"
+" in this particular case (running directly on the hardware with no "
+"hypervisor), but isn't a good\n"
+" pattern in general."
+msgstr ""
+
#: src/bare-metal/useful-crates.md:1
#, fuzzy
msgid "# Useful crates"
@@ -14512,9 +16280,12 @@ msgstr "# Casse utili"
#: src/bare-metal/useful-crates.md:3
#, fuzzy
-msgid "We'll go over a few crates which solve some common problems in bare-metal programming."
+msgid ""
+"We'll go over a few crates which solve some common problems in bare-metal "
+"programming."
msgstr ""
-"Esamineremo alcune casse che risolvono alcuni problemi comuni nella programmazione bare-metal."
+"Esamineremo alcune casse che risolvono alcuni problemi comuni nella "
+"programmazione bare-metal."
#: src/bare-metal/useful-crates/zerocopy.md:1
#, fuzzy
@@ -14524,10 +16295,12 @@ msgstr "# `zerocopia`"
#: src/bare-metal/useful-crates/zerocopy.md:3
#, fuzzy
msgid ""
-"The [`zerocopy`][1] crate (from Fuchsia) provides traits and macros for safely converting between\n"
+"The [`zerocopy`][1] crate (from Fuchsia) provides traits and macros for "
+"safely converting between\n"
"byte sequences and other types."
msgstr ""
-"La cassa [`zerocopy`][1] (da Fuchsia) fornisce tratti e macro per la conversione sicura tra\n"
+"La cassa [`zerocopy`][1] (da Fuchsia) fornisce tratti e macro per la "
+"conversione sicura tra\n"
"sequenze di byte e altri tipi."
#: src/bare-metal/useful-crates/zerocopy.md:6
@@ -14570,38 +16343,41 @@ msgstr ""
#: src/bare-metal/useful-crates/zerocopy.md:40
#, fuzzy
msgid ""
-"This is not suitable for MMIO (as it doesn't use volatile reads and writes), but can be useful "
-"for\n"
-"working with structures shared with hardware e.g. by DMA, or sent over some external interface."
+"This is not suitable for MMIO (as it doesn't use volatile reads and writes), "
+"but can be useful for\n"
+"working with structures shared with hardware e.g. by DMA, or sent over some "
+"external interface."
msgstr ""
-"Questo non è adatto per MMIO (poiché non utilizza letture e scritture volatili), ma può essere "
-"utile per\n"
-"lavorare con strutture condivise con l'hardware, ad es. tramite DMA o inviato tramite "
-"un'interfaccia esterna."
+"Questo non è adatto per MMIO (poiché non utilizza letture e scritture "
+"volatili), ma può essere utile per\n"
+"lavorare con strutture condivise con l'hardware, ad es. tramite DMA o "
+"inviato tramite un'interfaccia esterna."
#: src/bare-metal/useful-crates/zerocopy.md:45
#, fuzzy
msgid ""
-"* `FromBytes` can be implemented for types for which any byte pattern is valid, and so can safely "
-"be\n"
+"* `FromBytes` can be implemented for types for which any byte pattern is "
+"valid, and so can safely be\n"
" converted from an untrusted sequence of bytes.\n"
-"* Attempting to derive `FromBytes` for these types would fail, because `RequestType` doesn't use "
-"all\n"
+"* Attempting to derive `FromBytes` for these types would fail, because "
+"`RequestType` doesn't use all\n"
" possible u32 values as discriminants, so not all byte patterns are valid.\n"
"* `zerocopy::byteorder` has types for byte-order aware numeric primitives.\n"
-"* Run the example with `cargo run` under `src/bare-metal/useful-crates/zerocopy-example/`. (It "
-"won't\n"
+"* Run the example with `cargo run` under `src/bare-metal/useful-crates/"
+"zerocopy-example/`. (It won't\n"
" run in the Playground because of the crate dependency.)"
msgstr ""
-"* `FromBytes` può essere implementato per i tipi per i quali qualsiasi modello di byte è valido, e "
-"quindi può tranquillamente esserlo\n"
+"* `FromBytes` può essere implementato per i tipi per i quali qualsiasi "
+"modello di byte è valido, e quindi può tranquillamente esserlo\n"
" convertito da una sequenza di byte non attendibile.\n"
-"* Il tentativo di derivare `FromBytes` per questi tipi fallirebbe, perché `RequestType` non usa "
-"tutti\n"
-" possibili valori u32 come discriminanti, quindi non tutti i modelli di byte sono validi.\n"
-"* `zerocopy::byteorder` ha tipi per primitive numeriche che riconoscono l'ordine dei byte.\n"
-"* Esegui l'esempio con `cargo run` sotto `src/bare-metal/useful-crates/zerocopy-example/`. (Non lo "
-"farà\n"
+"* Il tentativo di derivare `FromBytes` per questi tipi fallirebbe, perché "
+"`RequestType` non usa tutti\n"
+" possibili valori u32 come discriminanti, quindi non tutti i modelli di "
+"byte sono validi.\n"
+"* `zerocopy::byteorder` ha tipi per primitive numeriche che riconoscono "
+"l'ordine dei byte.\n"
+"* Esegui l'esempio con `cargo run` sotto `src/bare-metal/useful-crates/"
+"zerocopy-example/`. (Non lo farà\n"
" eseguito nel Parco giochi a causa della dipendenza dalla cassa.)"
#: src/bare-metal/useful-crates/aarch64-paging.md:1
@@ -14612,12 +16388,12 @@ msgstr "# `aarch64-paging`"
#: src/bare-metal/useful-crates/aarch64-paging.md:3
#, fuzzy
msgid ""
-"The [`aarch64-paging`][1] crate lets you create page tables according to the AArch64 Virtual "
-"Memory\n"
+"The [`aarch64-paging`][1] crate lets you create page tables according to the "
+"AArch64 Virtual Memory\n"
"System Architecture."
msgstr ""
-"Il crate [`aarch64-paging`][1] consente di creare tabelle di pagine in base alla memoria virtuale "
-"AArch64\n"
+"Il crate [`aarch64-paging`][1] consente di creare tabelle di pagine in base "
+"alla memoria virtuale AArch64\n"
"Architettura di sistema."
#: src/bare-metal/useful-crates/aarch64-paging.md:6
@@ -14646,18 +16422,19 @@ msgstr ""
#: src/bare-metal/useful-crates/aarch64-paging.md:28
#, fuzzy
msgid ""
-"* For now it only supports EL1, but support for other exception levels should be straightforward "
-"to\n"
+"* For now it only supports EL1, but support for other exception levels "
+"should be straightforward to\n"
" add.\n"
"* This is used in Android for the [Protected VM Firmware][2].\n"
-"* There's no easy way to run this example, as it needs to run on real hardware or under QEMU."
+"* There's no easy way to run this example, as it needs to run on real "
+"hardware or under QEMU."
msgstr ""
-"* Per ora supporta solo EL1, ma il supporto per altri livelli di eccezione dovrebbe essere "
-"semplice\n"
+"* Per ora supporta solo EL1, ma il supporto per altri livelli di eccezione "
+"dovrebbe essere semplice\n"
" aggiungere.\n"
"* Viene utilizzato in Android per il [Firmware VM protetto][2].\n"
-"* Non esiste un modo semplice per eseguire questo esempio, poiché deve essere eseguito su hardware "
-"reale o sotto QEMU."
+"* Non esiste un modo semplice per eseguire questo esempio, poiché deve "
+"essere eseguito su hardware reale o sotto QEMU."
#: src/bare-metal/useful-crates/buddy_system_allocator.md:1
#, fuzzy
@@ -14667,18 +16444,20 @@ msgstr "# `buddy_system_allocator`"
#: src/bare-metal/useful-crates/buddy_system_allocator.md:3
#, fuzzy
msgid ""
-"[`buddy_system_allocator`][1] is a third-party crate implementing a basic buddy system allocator.\n"
-"It can be used both for [`LockedHeap`][2] implementing [`GlobalAlloc`][3] so you can use the\n"
-"standard `alloc` crate (as we saw [before][4]), or for allocating other address space. For "
-"example,\n"
+"[`buddy_system_allocator`][1] is a third-party crate implementing a basic "
+"buddy system allocator.\n"
+"It can be used both for [`LockedHeap`][2] implementing [`GlobalAlloc`][3] so "
+"you can use the\n"
+"standard `alloc` crate (as we saw [before][4]), or for allocating other "
+"address space. For example,\n"
"we might want to allocate MMIO space for PCI BARs:"
msgstr ""
-"[`buddy_system_allocator`][1] è un crate di terze parti che implementa un allocatore di sistema "
-"buddy di base.\n"
-"Può essere utilizzato sia per [`LockedHeap`][2] che implementa [`GlobalAlloc`][3] in modo da poter "
-"utilizzare il\n"
-"crate standard `alloc` (come abbiamo visto [prima][4]), o per allocare altro spazio di indirizzi. "
-"Per esempio,\n"
+"[`buddy_system_allocator`][1] è un crate di terze parti che implementa un "
+"allocatore di sistema buddy di base.\n"
+"Può essere utilizzato sia per [`LockedHeap`][2] che implementa "
+"[`GlobalAlloc`][3] in modo da poter utilizzare il\n"
+"crate standard `alloc` (come abbiamo visto [prima][4]), o per allocare altro "
+"spazio di indirizzi. Per esempio,\n"
"potremmo voler allocare spazio MMIO per PCI BAR:"
#: src/bare-metal/useful-crates/buddy_system_allocator.md:8
@@ -14704,13 +16483,13 @@ msgstr ""
#, fuzzy
msgid ""
"* PCI BARs always have alignment equal to their size.\n"
-"* Run the example with `cargo run` under `src/bare-metal/useful-crates/allocator-example/`. (It "
-"won't\n"
+"* Run the example with `cargo run` under `src/bare-metal/useful-crates/"
+"allocator-example/`. (It won't\n"
" run in the Playground because of the crate dependency.)"
msgstr ""
"* Le barre PCI hanno sempre un allineamento uguale alla loro dimensione.\n"
-"* Esegui l'esempio con `cargo run` sotto `src/bare-metal/useful-crates/allocator-example/`. (Non "
-"lo farà\n"
+"* Esegui l'esempio con `cargo run` sotto `src/bare-metal/useful-crates/"
+"allocator-example/`. (Non lo farà\n"
" eseguito nel Parco giochi a causa della dipendenza dalla cassa.)"
#: src/bare-metal/useful-crates/tinyvec.md:1
@@ -14721,18 +16500,20 @@ msgstr "# `tinyvec`"
#: src/bare-metal/useful-crates/tinyvec.md:3
#, fuzzy
msgid ""
-"Sometimes you want something which can be resized like a `Vec`, but without heap allocation.\n"
-"[`tinyvec`][1] provides this: a vector backed by an array or slice, which could be statically\n"
-"allocated or on the stack, which keeps track of how many elements are used and panics if you try "
-"to\n"
+"Sometimes you want something which can be resized like a `Vec`, but without "
+"heap allocation.\n"
+"[`tinyvec`][1] provides this: a vector backed by an array or slice, which "
+"could be statically\n"
+"allocated or on the stack, which keeps track of how many elements are used "
+"and panics if you try to\n"
"use more than are allocated."
msgstr ""
-"A volte vuoi qualcosa che possa essere ridimensionato come un `Vec`, ma senza allocazione "
-"dell'heap.\n"
-"[`tinyvec`][1] fornisce questo: un vettore supportato da un array o da una slice, che potrebbe "
-"essere staticamente\n"
-"allocato o in pila, che tiene traccia di quanti elementi vengono utilizzati e va in panico se ci "
-"provi\n"
+"A volte vuoi qualcosa che possa essere ridimensionato come un `Vec`, ma "
+"senza allocazione dell'heap.\n"
+"[`tinyvec`][1] fornisce questo: un vettore supportato da un array o da una "
+"slice, che potrebbe essere staticamente\n"
+"allocato o in pila, che tiene traccia di quanti elementi vengono utilizzati "
+"e va in panico se ci provi\n"
"utilizzare più di quanto assegnato."
#: src/bare-metal/useful-crates/tinyvec.md:8
@@ -14754,11 +16535,15 @@ msgstr ""
#: src/bare-metal/useful-crates/tinyvec.md:23
#, fuzzy
msgid ""
-"* `tinyvec` requires that the element type implement `Default` for initialisation.\n"
-"* The Rust Playground includes `tinyvec`, so this example will run fine inline."
+"* `tinyvec` requires that the element type implement `Default` for "
+"initialisation.\n"
+"* The Rust Playground includes `tinyvec`, so this example will run fine "
+"inline."
msgstr ""
-"* `tinyvec` richiede che il tipo di elemento implementi `Default` per l'inizializzazione.\n"
-"* Rust Playground include `tinyvec`, quindi questo esempio funzionerà correttamente in linea."
+"* `tinyvec` richiede che il tipo di elemento implementi `Default` per "
+"l'inizializzazione.\n"
+"* Rust Playground include `tinyvec`, quindi questo esempio funzionerà "
+"correttamente in linea."
#: src/bare-metal/useful-crates/spin.md:1
#, fuzzy
@@ -14768,20 +16553,26 @@ msgstr "# `gira`"
#: src/bare-metal/useful-crates/spin.md:3
#, fuzzy
msgid ""
-"`std::sync::Mutex` and the other synchronisation primitives from `std::sync` are not available in\n"
-"`core` or `alloc`. How can we manage synchronisation or interior mutability, such as for sharing\n"
+"`std::sync::Mutex` and the other synchronisation primitives from `std::sync` "
+"are not available in\n"
+"`core` or `alloc`. How can we manage synchronisation or interior mutability, "
+"such as for sharing\n"
"state between different CPUs?"
msgstr ""
-"`std::sync::Mutex` e le altre primitive di sincronizzazione da `std::sync` non sono disponibili "
-"in\n"
-"`core` o `alloc`. Come gestire la sincronizzazione o la mutevolezza interiore, ad esempio per la "
-"condivisione\n"
+"`std::sync::Mutex` e le altre primitive di sincronizzazione da `std::sync` "
+"non sono disponibili in\n"
+"`core` o `alloc`. Come gestire la sincronizzazione o la mutevolezza "
+"interiore, ad esempio per la condivisione\n"
"stato tra diverse CPU?"
#: src/bare-metal/useful-crates/spin.md:7
#, fuzzy
-msgid "The [`spin`][1] crate provides spinlock-based equivalents of many of these primitives."
-msgstr "La cassa [`spin`][1] fornisce equivalenti basati su spinlock di molte di queste primitive."
+msgid ""
+"The [`spin`][1] crate provides spinlock-based equivalents of many of these "
+"primitives."
+msgstr ""
+"La cassa [`spin`][1] fornisce equivalenti basati su spinlock di molte di "
+"queste primitive."
#: src/bare-metal/useful-crates/spin.md:9
msgid ""
@@ -14801,10 +16592,11 @@ msgstr ""
#: src/bare-metal/useful-crates/spin.md:23
msgid ""
"* Be careful to avoid deadlock if you take locks in interrupt handlers.\n"
-"* `spin` also has a ticket lock mutex implementation; equivalents of `RwLock`, `Barrier` and "
-"`Once`\n"
+"* `spin` also has a ticket lock mutex implementation; equivalents of "
+"`RwLock`, `Barrier` and `Once`\n"
" from `std::sync`; and `Lazy` for lazy initialisation.\n"
-"* The [`once_cell`][2] crate also has some useful types for late initialisation with a slightly\n"
+"* The [`once_cell`][2] crate also has some useful types for late "
+"initialisation with a slightly\n"
" different approach to `spin::once::Once`.\n"
"* The Rust Playground includes `spin`, so this example will run fine inline."
msgstr ""
@@ -14817,16 +16609,18 @@ msgstr "#Androide"
#: src/bare-metal/android.md:3
#, fuzzy
msgid ""
-"To build a bare-metal Rust binary in AOSP, you need to use a `rust_ffi_static` Soong rule to "
-"build\n"
-"your Rust code, then a `cc_binary` with a linker script to produce the binary itself, and then a\n"
+"To build a bare-metal Rust binary in AOSP, you need to use a "
+"`rust_ffi_static` Soong rule to build\n"
+"your Rust code, then a `cc_binary` with a linker script to produce the "
+"binary itself, and then a\n"
"`raw_binary` to convert the ELF to a raw binary ready to be run."
msgstr ""
-"Per costruire un binario Rust bare-metal in AOSP, devi usare una regola `rust_ffi_static` Soong "
-"per costruire\n"
-"il tuo codice Rust, poi un `cc_binary` con uno script linker per produrre il binario stesso, e poi "
-"a\n"
-"`raw_binary` per convertire l'ELF in un binario grezzo pronto per essere eseguito."
+"Per costruire un binario Rust bare-metal in AOSP, devi usare una regola "
+"`rust_ffi_static` Soong per costruire\n"
+"il tuo codice Rust, poi un `cc_binary` con uno script linker per produrre il "
+"binario stesso, e poi a\n"
+"`raw_binary` per convertire l'ELF in un binario grezzo pronto per essere "
+"eseguito."
#: src/bare-metal/android.md:7
msgid ""
@@ -14878,14 +16672,15 @@ msgstr "# vbase"
#: src/bare-metal/android/vmbase.md:3
#, fuzzy
msgid ""
-"For VMs running under crosvm on aarch64, the [vmbase][1] library provides a linker script and "
-"useful\n"
-"defaults for the build rules, along with an entry point, UART console logging and more."
+"For VMs running under crosvm on aarch64, the [vmbase][1] library provides a "
+"linker script and useful\n"
+"defaults for the build rules, along with an entry point, UART console "
+"logging and more."
msgstr ""
-"Per le VM in esecuzione in crosvm su aarch64, la libreria [vmbase][1] fornisce uno script linker e "
-"utili\n"
-"impostazioni predefinite per le regole di compilazione, insieme a un punto di ingresso, la "
-"registrazione della console UART e altro ancora."
+"Per le VM in esecuzione in crosvm su aarch64, la libreria [vmbase][1] "
+"fornisce uno script linker e utili\n"
+"impostazioni predefinite per le regole di compilazione, insieme a un punto "
+"di ingresso, la registrazione della console UART e altro ancora."
#: src/bare-metal/android/vmbase.md:6
msgid ""
@@ -14906,15 +16701,16 @@ msgstr ""
#: src/bare-metal/android/vmbase.md:21
#, fuzzy
msgid ""
-"* The `main!` macro marks your main function, to be called from the `vmbase` entry point.\n"
-"* The `vmbase` entry point handles console initialisation, and issues a PSCI_SYSTEM_OFF to "
-"shutdown\n"
+"* The `main!` macro marks your main function, to be called from the `vmbase` "
+"entry point.\n"
+"* The `vmbase` entry point handles console initialisation, and issues a "
+"PSCI_SYSTEM_OFF to shutdown\n"
" the VM if your main function returns."
msgstr ""
-"* La macro `main!` contrassegna la tua funzione principale, da chiamare dal punto di ingresso "
-"`vmbase`.\n"
-"* Il punto di ingresso `vmbase` gestisce l'inizializzazione della console ed emette un "
-"PSCI_SYSTEM_OFF per l'arresto\n"
+"* La macro `main!` contrassegna la tua funzione principale, da chiamare dal "
+"punto di ingresso `vmbase`.\n"
+"* Il punto di ingresso `vmbase` gestisce l'inizializzazione della console ed "
+"emette un PSCI_SYSTEM_OFF per l'arresto\n"
" la VM se la tua funzione principale ritorna."
#: src/exercises/bare-metal/afternoon.md:3
@@ -14930,53 +16726,58 @@ msgstr "# Driver RTC"
#: src/exercises/bare-metal/rtc.md:3
#, fuzzy
msgid ""
-"The QEMU aarch64 virt machine has a [PL031][1] real-time clock at 0x9010000. For this exercise, "
-"you\n"
+"The QEMU aarch64 virt machine has a [PL031][1] real-time clock at 0x9010000. "
+"For this exercise, you\n"
"should write a driver for it."
msgstr ""
-"La macchina QEMU aarch64 virt ha un orologio in tempo reale [PL031][1] a 0x9010000. Per questo "
-"esercizio, tu\n"
+"La macchina QEMU aarch64 virt ha un orologio in tempo reale [PL031][1] a "
+"0x9010000. Per questo esercizio, tu\n"
"dovrebbe scrivere un driver per esso."
#: src/exercises/bare-metal/rtc.md:6
#, fuzzy
msgid ""
-"1. Use it to print the current time to the serial console. You can use the [`chrono`][2] crate "
-"for\n"
+"1. Use it to print the current time to the serial console. You can use the "
+"[`chrono`][2] crate for\n"
" date/time formatting.\n"
-"2. Use the match register and raw interrupt status to busy-wait until a given time, e.g. 3 "
-"seconds\n"
+"2. Use the match register and raw interrupt status to busy-wait until a "
+"given time, e.g. 3 seconds\n"
" in the future. (Call [`core::hint::spin_loop`][3] inside the loop.)\n"
-"3. _Extension if you have time:_ Enable and handle the interrupt generated by the RTC match. You "
-"can\n"
-" use the driver provided in the [`arm-gic`][4] crate to configure the Arm Generic Interrupt "
-"Controller.\n"
+"3. _Extension if you have time:_ Enable and handle the interrupt generated "
+"by the RTC match. You can\n"
+" use the driver provided in the [`arm-gic`][4] crate to configure the Arm "
+"Generic Interrupt Controller.\n"
" - Use the RTC interrupt, which is wired to the GIC as `IntId::spi(2)`.\n"
-" - Once the interrupt is enabled, you can put the core to sleep via `arm_gic::wfi()`, which will "
-"cause the core to sleep until it receives an interrupt.\n"
+" - Once the interrupt is enabled, you can put the core to sleep via "
+"`arm_gic::wfi()`, which will cause the core to sleep until it receives an "
+"interrupt.\n"
" "
msgstr ""
-"1. Usalo per stampare l'ora corrente sulla console seriale. Puoi usare la cassa [`chrono`][2] per\n"
+"1. Usalo per stampare l'ora corrente sulla console seriale. Puoi usare la "
+"cassa [`chrono`][2] per\n"
" formattazione data/ora.\n"
-"2. Utilizzare il registro delle corrispondenze e lo stato di interrupt non elaborato per attendere "
-"occupato fino a un determinato momento, ad es. 3 secondi\n"
+"2. Utilizzare il registro delle corrispondenze e lo stato di interrupt non "
+"elaborato per attendere occupato fino a un determinato momento, ad es. 3 "
+"secondi\n"
" in futuro. (Chiama [`core::hint::spin_loop`][3] all'interno del ciclo.)\n"
-"3. _Estensione se hai tempo:_ Abilita e gestisci l'interrupt generato dalla corrispondenza RTC. "
-"Puoi\n"
-" utilizzare il driver fornito nella cassa [`arm-gic`][4] per configurare Arm Generic Interrupt "
-"Controller.\n"
+"3. _Estensione se hai tempo:_ Abilita e gestisci l'interrupt generato dalla "
+"corrispondenza RTC. Puoi\n"
+" utilizzare il driver fornito nella cassa [`arm-gic`][4] per configurare "
+"Arm Generic Interrupt Controller.\n"
" - Usa l'interrupt RTC, che è cablato al GIC come `IntId::spi(2)`.\n"
-" - Una volta abilitato l'interrupt, puoi mettere il core in sleep tramite `arm_gic::wfi()`, che "
-"farà dormire il core finché non riceve un interrupt.\n"
+" - Una volta abilitato l'interrupt, puoi mettere il core in sleep tramite "
+"`arm_gic::wfi()`, che farà dormire il core finché non riceve un interrupt.\n"
" "
#: src/exercises/bare-metal/rtc.md:16
#, fuzzy
msgid ""
-"Download the [exercise template](../../comprehensive-rust-exercises.zip) and look in the `rtc`\n"
+"Download the [exercise template](../../comprehensive-rust-exercises.zip) and "
+"look in the `rtc`\n"
"directory for the following files."
msgstr ""
-"Scarica il [modello di esercizio](../../comprehensive-rust-exercises.zip) e cerca in `rtc`\n"
+"Scarica il [modello di esercizio](../../comprehensive-rust-exercises.zip) e "
+"cerca in `rtc`\n"
"directory per i seguenti file."
#: src/exercises/bare-metal/rtc.md:23
@@ -15005,17 +16806,20 @@ msgid ""
"\n"
"#[no_mangle]\n"
"extern \"C\" fn main(x0: u64, x1: u64, x2: u64, x3: u64) {\n"
-" // Safe because `PL011_BASE_ADDRESS` is the base address of a PL011 device,\n"
+" // Safe because `PL011_BASE_ADDRESS` is the base address of a PL011 "
+"device,\n"
" // and nothing else accesses that address range.\n"
" let uart = unsafe { Uart::new(PL011_BASE_ADDRESS) };\n"
" logger::init(uart, LevelFilter::Trace).unwrap();\n"
"\n"
" info!(\"main({:#x}, {:#x}, {:#x}, {:#x})\", x0, x1, x2, x3);\n"
"\n"
-" // Safe because `GICD_BASE_ADDRESS` and `GICR_BASE_ADDRESS` are the base\n"
+" // Safe because `GICD_BASE_ADDRESS` and `GICR_BASE_ADDRESS` are the "
+"base\n"
" // addresses of a GICv3 distributor and redistributor respectively, and\n"
" // nothing else accesses those address ranges.\n"
-" let mut gic = unsafe { GicV3::new(GICD_BASE_ADDRESS, GICR_BASE_ADDRESS) };\n"
+" let mut gic = unsafe { GicV3::new(GICD_BASE_ADDRESS, "
+"GICR_BASE_ADDRESS) };\n"
" gic.setup();\n"
"\n"
" // TODO: Create instance of RTC driver and print current time.\n"
@@ -15036,8 +16840,12 @@ msgstr ""
#: src/exercises/bare-metal/rtc.md:75
#, fuzzy
-msgid "`src/exceptions.rs` (you should only need to change this for the 3rd part of the exercise):"
-msgstr "`src/exceptions.rs` (dovresti solo cambiarlo per la terza parte dell'esercizio):"
+msgid ""
+"`src/exceptions.rs` (you should only need to change this for the 3rd part of "
+"the exercise):"
+msgstr ""
+"`src/exceptions.rs` (dovresti solo cambiarlo per la terza parte "
+"dell'esercizio):"
#: src/exercises/bare-metal/rtc.md:77
#, fuzzy
@@ -15075,7 +16883,8 @@ msgid ""
"#[no_mangle]\n"
"extern \"C\" fn irq_current(_elr: u64, _spsr: u64) {\n"
" trace!(\"irq_current\");\n"
-" let intid = GicV3::get_and_acknowledge_interrupt().expect(\"No pending interrupt\");\n"
+" let intid = GicV3::get_and_acknowledge_interrupt().expect(\"No pending "
+"interrupt\");\n"
" info!(\"IRQ {intid:?}\");\n"
"}\n"
"\n"
@@ -15177,7 +16986,8 @@ msgid ""
"}\n"
"\n"
"/// Initialises UART logger.\n"
-"pub fn init(uart: Uart, max_level: LevelFilter) -> Result<(), SetLoggerError> {\n"
+"pub fn init(uart: Uart, max_level: LevelFilter) -> Result<(), "
+"SetLoggerError> {\n"
" LOGGER.uart.lock().replace(uart);\n"
"\n"
" log::set_logger(&LOGGER)?;\n"
@@ -15307,13 +17117,16 @@ msgid ""
"}\n"
"\n"
"impl Uart {\n"
-" /// Constructs a new instance of the UART driver for a PL011 device at the\n"
+" /// Constructs a new instance of the UART driver for a PL011 device at "
+"the\n"
" /// given base address.\n"
" ///\n"
" /// # Safety\n"
" ///\n"
-" /// The given base address must point to the MMIO control registers of a\n"
-" /// PL011 device, which must be mapped into the address space of the process\n"
+" /// The given base address must point to the MMIO control registers of "
+"a\n"
+" /// PL011 device, which must be mapped into the address space of the "
+"process\n"
" /// as device memory and not have any other aliases.\n"
" pub unsafe fn new(base_address: *mut u32) -> Self {\n"
" Self {\n"
@@ -15337,12 +17150,14 @@ msgid ""
" while self.read_flag_register().contains(Flags::BUSY) {}\n"
" }\n"
"\n"
-" /// Reads and returns a pending byte, or `None` if nothing has been received.\n"
+" /// Reads and returns a pending byte, or `None` if nothing has been "
+"received.\n"
" pub fn read_byte(&self) -> Option {\n"
" if self.read_flag_register().contains(Flags::RXFE) {\n"
" None\n"
" } else {\n"
-" let data = unsafe { addr_of!((*self.registers).dr).read_volatile() };\n"
+" let data = unsafe { addr_of!((*self.registers).dr)."
+"read_volatile() };\n"
" // TODO: Check for error conditions in bits 8-11.\n"
" Some(data as u8)\n"
" }\n"
@@ -15489,24 +17304,29 @@ msgid ""
".set .L_TCR_TG0_4KB, 0x0 << 14\n"
"/* 4 KiB granule size for TTBR1_EL1. */\n"
".set .L_TCR_TG1_4KB, 0x2 << 30\n"
-"/* Disable translation table walk for TTBR1_EL1, generating a translation fault instead. */\n"
+"/* Disable translation table walk for TTBR1_EL1, generating a translation "
+"fault instead. */\n"
".set .L_TCR_EPD1, 0x1 << 23\n"
"/* Translation table walks for TTBR0_EL1 are inner sharable. */\n"
".set .L_TCR_SH_INNER, 0x3 << 12\n"
"/*\n"
-" * Translation table walks for TTBR0_EL1 are outer write-back read-allocate write-allocate\n"
+" * Translation table walks for TTBR0_EL1 are outer write-back read-allocate "
+"write-allocate\n"
" * cacheable.\n"
" */\n"
".set .L_TCR_RGN_OWB, 0x1 << 10\n"
"/*\n"
-" * Translation table walks for TTBR0_EL1 are inner write-back read-allocate write-allocate\n"
+" * Translation table walks for TTBR0_EL1 are inner write-back read-allocate "
+"write-allocate\n"
" * cacheable.\n"
" */\n"
".set .L_TCR_RGN_IWB, 0x1 << 8\n"
"/* Size offset for TTBR0_EL1 is 2**39 bytes (512 GiB). */\n"
".set .L_TCR_T0SZ_512, 64 - 39\n"
-".set .Ltcrval, .L_TCR_TG0_4KB | .L_TCR_TG1_4KB | .L_TCR_EPD1 | .L_TCR_RGN_OWB\n"
-".set .Ltcrval, .Ltcrval | .L_TCR_RGN_IWB | .L_TCR_SH_INNER | .L_TCR_T0SZ_512\n"
+".set .Ltcrval, .L_TCR_TG0_4KB | .L_TCR_TG1_4KB | .L_TCR_EPD1 | ."
+"L_TCR_RGN_OWB\n"
+".set .Ltcrval, .Ltcrval | .L_TCR_RGN_IWB | .L_TCR_SH_INNER | ."
+"L_TCR_T0SZ_512\n"
"\n"
"/* Stage 1 instruction access cacheability is unaffected. */\n"
".set .L_SCTLR_ELx_I, 0x1 << 12\n"
@@ -15522,23 +17342,27 @@ msgid ""
".set .L_SCTLR_EL1_SED, 0x1 << 8\n"
"/* Various IT instructions are disabled at EL0 in aarch32 mode. */\n"
".set .L_SCTLR_EL1_ITD, 0x1 << 7\n"
-".set .L_SCTLR_EL1_RES1, (0x1 << 11) | (0x1 << 20) | (0x1 << 22) | (0x1 << 28) | (0x1 << 29)\n"
-".set .Lsctlrval, .L_SCTLR_ELx_M | .L_SCTLR_ELx_C | .L_SCTLR_ELx_SA | .L_SCTLR_EL1_ITD | ."
-"L_SCTLR_EL1_SED\n"
-".set .Lsctlrval, .Lsctlrval | .L_SCTLR_ELx_I | .L_SCTLR_EL1_SPAN | .L_SCTLR_EL1_RES1\n"
+".set .L_SCTLR_EL1_RES1, (0x1 << 11) | (0x1 << 20) | (0x1 << 22) | (0x1 << "
+"28) | (0x1 << 29)\n"
+".set .Lsctlrval, .L_SCTLR_ELx_M | .L_SCTLR_ELx_C | .L_SCTLR_ELx_SA | ."
+"L_SCTLR_EL1_ITD | .L_SCTLR_EL1_SED\n"
+".set .Lsctlrval, .Lsctlrval | .L_SCTLR_ELx_I | .L_SCTLR_EL1_SPAN | ."
+"L_SCTLR_EL1_RES1\n"
"\n"
"/**\n"
-" * This is a generic entry point for an image. It carries out the operations required to prepare "
-"the\n"
-" * loaded image to be run. Specifically, it zeroes the bss section using registers x25 and above,\n"
-" * prepares the stack, enables floating point, and sets up the exception vector. It preserves x0-"
-"x3\n"
+" * This is a generic entry point for an image. It carries out the operations "
+"required to prepare the\n"
+" * loaded image to be run. Specifically, it zeroes the bss section using "
+"registers x25 and above,\n"
+" * prepares the stack, enables floating point, and sets up the exception "
+"vector. It preserves x0-x3\n"
" * for the Rust entry point, as these may contain boot parameters.\n"
" */\n"
".section .init.entry, \"ax\"\n"
".global entry\n"
"entry:\n"
-"\t/* Load and apply the memory management configuration, ready to enable MMU and caches. */\n"
+"\t/* Load and apply the memory management configuration, ready to enable MMU "
+"and caches. */\n"
"\tadrp x30, idmap\n"
"\tmsr ttbr0_el1, x30\n"
"\n"
@@ -15555,7 +17379,8 @@ msgid ""
"\tmov_i x30, .Lsctlrval\n"
"\n"
"\t/*\n"
-"\t * Ensure everything before this point has completed, then invalidate any potentially stale\n"
+"\t * Ensure everything before this point has completed, then invalidate any "
+"potentially stale\n"
"\t * local TLB entries before they start being used.\n"
"\t */\n"
"\tisb\n"
@@ -15565,7 +17390,8 @@ msgid ""
"\tisb\n"
"\n"
"\t/*\n"
-"\t * Configure sctlr_el1 to enable MMU and cache and don't proceed until this has completed.\n"
+"\t * Configure sctlr_el1 to enable MMU and cache and don't proceed until "
+"this has completed.\n"
"\t */\n"
"\tmsr sctlr_el1, x30\n"
"\tisb\n"
@@ -15632,11 +17458,14 @@ msgid ""
"\n"
"/**\n"
" * Saves the volatile registers onto the stack. This currently takes 14\n"
-" * instructions, so it can be used in exception handlers with 18 instructions\n"
+" * instructions, so it can be used in exception handlers with 18 "
+"instructions\n"
" * left.\n"
" *\n"
-" * On return, x0 and x1 are initialised to elr_el2 and spsr_el2 respectively,\n"
-" * which can be used as the first and second arguments of a subsequent call.\n"
+" * On return, x0 and x1 are initialised to elr_el2 and spsr_el2 "
+"respectively,\n"
+" * which can be used as the first and second arguments of a subsequent "
+"call.\n"
" */\n"
".macro save_volatile_to_stack\n"
"\t/* Reserve stack space and save registers x0-x18, x29 & x30. */\n"
@@ -15663,7 +17492,8 @@ msgid ""
"\n"
"/**\n"
" * Restores the volatile registers from the stack. This currently takes 14\n"
-" * instructions, so it can be used in exception handlers while still leaving 18\n"
+" * instructions, so it can be used in exception handlers while still leaving "
+"18\n"
" * instructions left; if paired with save_volatile_to_stack, there are 4\n"
" * instructions to spare.\n"
" */\n"
@@ -15690,12 +17520,15 @@ msgid ""
".endm\n"
"\n"
"/**\n"
-" * This is a generic handler for exceptions taken at the current EL while using\n"
-" * SP0. It behaves similarly to the SPx case by first switching to SPx, doing\n"
+" * This is a generic handler for exceptions taken at the current EL while "
+"using\n"
+" * SP0. It behaves similarly to the SPx case by first switching to SPx, "
+"doing\n"
" * the work, then switching back to SP0 before returning.\n"
" *\n"
" * Switching to SPx and calling the Rust handler takes 16 instructions. To\n"
-" * restore and return we need an additional 16 instructions, so we can implement\n"
+" * restore and return we need an additional 16 instructions, so we can "
+"implement\n"
" * the whole handler within the allotted 32 instructions.\n"
" */\n"
".macro current_exception_sp0 handler:req\n"
@@ -15708,15 +17541,18 @@ msgid ""
".endm\n"
"\n"
"/**\n"
-" * This is a generic handler for exceptions taken at the current EL while using\n"
-" * SPx. It saves volatile registers, calls the Rust handler, restores volatile\n"
+" * This is a generic handler for exceptions taken at the current EL while "
+"using\n"
+" * SPx. It saves volatile registers, calls the Rust handler, restores "
+"volatile\n"
" * registers, then returns.\n"
" *\n"
" * This also works for exceptions taken from EL0, if we don't care about\n"
" * non-volatile registers.\n"
" *\n"
" * Saving state and jumping to the Rust handler takes 15 instructions, and\n"
-" * restoring and returning also takes 15 instructions, so we can fit the whole\n"
+" * restoring and returning also takes 15 instructions, so we can fit the "
+"whole\n"
" * handler in 30 instructions, under the limit of 32.\n"
" */\n"
".macro current_exception_spx handler:req\n"
@@ -15835,7 +17671,8 @@ msgid ""
".set .L_TT_XN, 0x3 << 53\n"
"\n"
".set .L_TT_MT_DEV, 0x0 << 2\t\t\t// MAIR #0 (DEV_nGnRE)\n"
-".set .L_TT_MT_MEM, (0x1 << 2) | (0x3 << 8)\t// MAIR #1 (MEM_WBWA), inner shareable\n"
+".set .L_TT_MT_MEM, (0x1 << 2) | (0x3 << 8)\t// MAIR #1 (MEM_WBWA), inner "
+"shareable\n"
"\n"
".set .L_BLOCK_DEV, .L_TT_TYPE_BLOCK | .L_TT_MT_DEV | .L_TT_AF | .L_TT_XN\n"
".set .L_BLOCK_MEM, .L_TT_TYPE_BLOCK | .L_TT_MT_MEM | .L_TT_AF | .L_TT_NG\n"
@@ -15883,7 +17720,8 @@ msgid ""
" */\n"
"\n"
"/*\n"
-" * Code will start running at this symbol which is placed at the start of the\n"
+" * Code will start running at this symbol which is placed at the start of "
+"the\n"
" * image.\n"
" */\n"
"ENTRY(entry)\n"
@@ -16019,8 +17857,8 @@ msgid ""
"\t$(OBJCOPY) -O binary target/aarch64-unknown-none/debug/rtc $@\n"
"\n"
"qemu: rtc.bin\n"
-"\tqemu-system-aarch64 -machine virt,gic-version=3 -cpu max -serial mon:stdio -display none -kernel "
-"$< -s\n"
+"\tqemu-system-aarch64 -machine virt,gic-version=3 -cpu max -serial mon:stdio "
+"-display none -kernel $< -s\n"
"\n"
"clean:\n"
"\tcargo clean\n"
@@ -16053,20 +17891,25 @@ msgid ""
"Rust has full support for concurrency using OS threads with mutexes and\n"
"channels."
msgstr ""
-"Rust ha il pieno supporto per la concorrenza utilizzando i thread del sistema operativo con mutex "
-"e\n"
+"Rust ha il pieno supporto per la concorrenza utilizzando i thread del "
+"sistema operativo con mutex e\n"
"canali."
#: src/concurrency.md:6
#, fuzzy
msgid ""
-"The Rust type system plays an important role in making many concurrency bugs\n"
-"compile time bugs. This is often referred to as _fearless concurrency_ since you\n"
+"The Rust type system plays an important role in making many concurrency "
+"bugs\n"
+"compile time bugs. This is often referred to as _fearless concurrency_ since "
+"you\n"
"can rely on the compiler to ensure correctness at runtime."
msgstr ""
-"Il sistema di tipo Rust gioca un ruolo importante nella creazione di molti bug di concorrenza\n"
-"bug in fase di compilazione. Questo è spesso indicato come _concorrenza senza paura_ da quando tu\n"
-"può fare affidamento sul compilatore per garantire la correttezza in fase di esecuzione."
+"Il sistema di tipo Rust gioca un ruolo importante nella creazione di molti "
+"bug di concorrenza\n"
+"bug in fase di compilazione. Questo è spesso indicato come _concorrenza "
+"senza paura_ da quando tu\n"
+"può fare affidamento sul compilatore per garantire la correttezza in fase di "
+"esecuzione."
#: src/concurrency/threads.md:1
#, fuzzy
@@ -16109,31 +17952,39 @@ msgid ""
msgstr ""
"* I thread sono tutti thread demoni, il thread principale non li aspetta.\n"
"* I thread panic sono indipendenti l'uno dall'altro.\n"
-" * Panics può trasportare un payload, che può essere decompresso con `downcast_ref`."
+" * Panics può trasportare un payload, che può essere decompresso con "
+"`downcast_ref`."
#: src/concurrency/threads.md:32
#, fuzzy
msgid ""
-"* Notice that the thread is stopped before it reaches 10 — the main thread is\n"
+"* Notice that the thread is stopped before it reaches 10 — the main thread "
+"is\n"
" not waiting.\n"
"\n"
-"* Use `let handle = thread::spawn(...)` and later `handle.join()` to wait for\n"
+"* Use `let handle = thread::spawn(...)` and later `handle.join()` to wait "
+"for\n"
" the thread to finish.\n"
"\n"
"* Trigger a panic in the thread, notice how this doesn't affect `main`.\n"
"\n"
-"* Use the `Result` return value from `handle.join()` to get access to the panic\n"
+"* Use the `Result` return value from `handle.join()` to get access to the "
+"panic\n"
" payload. This is a good time to talk about [`Any`]."
msgstr ""
-"* Si noti che il thread viene interrotto prima che raggiunga 10 — il thread principale lo è\n"
+"* Si noti che il thread viene interrotto prima che raggiunga 10 — il thread "
+"principale lo è\n"
" non aspettare.\n"
"\n"
-"* Usa `let handle = thread::spawn(...)` e successivamente `handle.join()` per aspettare\n"
+"* Usa `let handle = thread::spawn(...)` e successivamente `handle.join()` "
+"per aspettare\n"
" il filo per finire.\n"
"\n"
-"* Attivare un panico nel thread, notare come questo non influisca su `main`.\n"
+"* Attivare un panico nel thread, notare come questo non influisca su "
+"`main`.\n"
"\n"
-"* Usa il valore di ritorno `Result` da `handle.join()` per ottenere l'accesso al panico\n"
+"* Usa il valore di ritorno `Result` da `handle.join()` per ottenere "
+"l'accesso al panico\n"
" carico utile. Questo è un buon momento per parlare di [`Any`]."
#: src/concurrency/scoped-threads.md:1
@@ -16186,16 +18037,19 @@ msgstr ""
#: src/concurrency/scoped-threads.md:37
#, fuzzy
msgid ""
-"* The reason for that is that when the `thread::scope` function completes, all the threads are "
-"guaranteed to be joined, so they can return borrowed data.\n"
-"* Normal Rust borrowing rules apply: you can either borrow mutably by one thread, or immutably by "
-"any number of threads.\n"
+"* The reason for that is that when the `thread::scope` function completes, "
+"all the threads are guaranteed to be joined, so they can return borrowed "
+"data.\n"
+"* Normal Rust borrowing rules apply: you can either borrow mutably by one "
+"thread, or immutably by any number of threads.\n"
" "
msgstr ""
-"* La ragione di ciò è che quando la funzione `thread::scope` viene completata, è garantito che "
-"tutti i thread vengano uniti, in modo che possano restituire dati presi in prestito.\n"
-"* Si applicano le normali regole di prestito di Rust: puoi prendere in prestito in modo mutabile "
-"da un thread o immutabile da un numero qualsiasi di thread.\n"
+"* La ragione di ciò è che quando la funzione `thread::scope` viene "
+"completata, è garantito che tutti i thread vengano uniti, in modo che "
+"possano restituire dati presi in prestito.\n"
+"* Si applicano le normali regole di prestito di Rust: puoi prendere in "
+"prestito in modo mutabile da un thread o immutabile da un numero qualsiasi "
+"di thread.\n"
" "
#: src/concurrency/channels.md:1
@@ -16206,10 +18060,12 @@ msgstr "# Canali"
#: src/concurrency/channels.md:3
#, fuzzy
msgid ""
-"Rust channels have two parts: a `Sender` and a `Receiver`. The two parts\n"
+"Rust channels have two parts: a `Sender` and a `Receiver`. The two "
+"parts\n"
"are connected via the channel, but you only see the end-points."
msgstr ""
-"I canali Rust hanno due parti: un `Sender` e un `Receiver`. Le due parti\n"
+"I canali Rust hanno due parti: un `Sender` e un `Receiver`. Le due "
+"parti\n"
"sono collegati tramite il canale, ma vedi solo i punti finali."
#: src/concurrency/channels.md:6
@@ -16237,18 +18093,18 @@ msgstr ""
#: src/concurrency/channels.md:27
#, fuzzy
msgid ""
-"* `mpsc` stands for Multi-Producer, Single-Consumer. `Sender` and `SyncSender` implement `Clone` "
-"(so\n"
+"* `mpsc` stands for Multi-Producer, Single-Consumer. `Sender` and "
+"`SyncSender` implement `Clone` (so\n"
" you can make multiple producers) but `Receiver` does not.\n"
-"* `send()` and `recv()` return `Result`. If they return `Err`, it means the counterpart `Sender` "
-"or\n"
+"* `send()` and `recv()` return `Result`. If they return `Err`, it means the "
+"counterpart `Sender` or\n"
" `Receiver` is dropped and the channel is closed."
msgstr ""
-"* `mpsc` sta per Multi-Producer, Single-Consumer. `Sender` e `SyncSender` implementano `Clone` "
-"(quindi\n"
+"* `mpsc` sta per Multi-Producer, Single-Consumer. `Sender` e `SyncSender` "
+"implementano `Clone` (quindi\n"
" puoi creare più produttori) ma `Receiver` no.\n"
-"* `send()` e `recv()` restituiscono `Risultato`. Se restituiscono \"Err\", significa che la "
-"controparte \"Mittente\" o\n"
+"* `send()` e `recv()` restituiscono `Risultato`. Se restituiscono \"Err\", "
+"significa che la controparte \"Mittente\" o\n"
" `Receiver` viene eliminato e il canale viene chiuso."
#: src/concurrency/channels/unbounded.md:1
@@ -16282,7 +18138,7 @@ msgid ""
" thread::sleep(Duration::from_millis(100));\n"
"\n"
" for msg in rx.iter() {\n"
-" println!(\"Main: got {}\", msg);\n"
+" println!(\"Main: got {msg}\");\n"
" }\n"
"}\n"
"```"
@@ -16295,8 +18151,11 @@ msgstr "# Canali delimitati"
#: src/concurrency/channels/bounded.md:3
#, fuzzy
-msgid "Bounded and synchronous channels make `send` block the current thread:"
-msgstr "I canali limitati e sincroni fanno in modo che `send` blocchi il thread corrente:"
+msgid ""
+"With bounded (synchronous) channels, `send` can block the current thread:"
+msgstr ""
+"I canali limitati e sincroni fanno in modo che `send` blocchi il thread "
+"corrente:"
#: src/concurrency/channels/bounded.md:5
msgid ""
@@ -16325,6 +18184,19 @@ msgid ""
"```"
msgstr ""
+#: src/concurrency/channels/bounded.md:31
+msgid ""
+"* Calling `send` will block the current thread until there is space in the "
+"channel for the new message. The thread can be blocked indefinitely if there "
+"is nobody who reads from the channel.\n"
+"* A call to `send` will abort with an error (that is why it returns "
+"`Result`) if the channel is closed. A channel is closed when the receiver is "
+"dropped.\n"
+"* A bounded channel with a size of zero is called a \"rendezvous channel\". "
+"Every send will block the current thread until another thread calls `read`.\n"
+" "
+msgstr ""
+
#: src/concurrency/send-sync.md:1
#, fuzzy
msgid "# `Send` and `Sync`"
@@ -16332,47 +18204,55 @@ msgstr "# `Invia` e `Sincronizza`"
#: src/concurrency/send-sync.md:3
#, fuzzy
-msgid "How does Rust know to forbid shared access across thread? The answer is in two traits:"
+msgid ""
+"How does Rust know to forbid shared access across thread? The answer is in "
+"two traits:"
msgstr ""
-"Come fa Rust a sapere di vietare l'accesso condiviso attraverso il thread? La risposta è in due "
-"tratti:"
+"Come fa Rust a sapere di vietare l'accesso condiviso attraverso il thread? "
+"La risposta è in due tratti:"
#: src/concurrency/send-sync.md:5
#, fuzzy
msgid ""
-"* [`Send`][1]: a type `T` is `Send` if it is safe to move a `T` across a thread\n"
+"* [`Send`][1]: a type `T` is `Send` if it is safe to move a `T` across a "
+"thread\n"
" boundary.\n"
-"* [`Sync`][2]: a type `T` is `Sync` if it is safe to move a `&T` across a thread\n"
+"* [`Sync`][2]: a type `T` is `Sync` if it is safe to move a `&T` across a "
+"thread\n"
" boundary."
msgstr ""
-"* [`Send`][1]: un tipo `T` è `Send` se è sicuro spostare una `T` attraverso un thread\n"
+"* [`Send`][1]: un tipo `T` è `Send` se è sicuro spostare una `T` attraverso "
+"un thread\n"
" confine.\n"
-"* [`Sync`][2]: un tipo `T` è `Sync` se è sicuro spostare una `&T` attraverso un thread\n"
+"* [`Sync`][2]: un tipo `T` è `Sync` se è sicuro spostare una `&T` attraverso "
+"un thread\n"
" confine."
#: src/concurrency/send-sync.md:10
#, fuzzy
msgid ""
-"`Send` and `Sync` are [unsafe traits][3]. The compiler will automatically derive them for your "
-"types\n"
-"as long as they only contain `Send` and `Sync` types. You can also implement them manually when "
-"you\n"
+"`Send` and `Sync` are [unsafe traits][3]. The compiler will automatically "
+"derive them for your types\n"
+"as long as they only contain `Send` and `Sync` types. You can also implement "
+"them manually when you\n"
"know it is valid."
msgstr ""
-"\"Send\" e \"Sync\" sono [tratti non sicuri][3]. Il compilatore li deriverà automaticamente per i "
-"tuoi tipi\n"
-"purché contengano solo i tipi \"Send\" e \"Sync\". Puoi anche implementarli manualmente quando tu\n"
+"\"Send\" e \"Sync\" sono [tratti non sicuri][3]. Il compilatore li deriverà "
+"automaticamente per i tuoi tipi\n"
+"purché contengano solo i tipi \"Send\" e \"Sync\". Puoi anche implementarli "
+"manualmente quando tu\n"
"sapere che è valido."
#: src/concurrency/send-sync.md:20
#, fuzzy
msgid ""
-"* One can think of these traits as markers that the type has certain thread-safety properties.\n"
+"* One can think of these traits as markers that the type has certain thread-"
+"safety properties.\n"
"* They can be used in the generic constraints as normal traits.\n"
" "
msgstr ""
-"* Si può pensare a questi tratti come indicatori che il tipo ha determinate proprietà di sicurezza "
-"del thread.\n"
+"* Si può pensare a questi tratti come indicatori che il tipo ha determinate "
+"proprietà di sicurezza del thread.\n"
"* Possono essere usati nei vincoli generici come tratti normali.\n"
" "
@@ -16383,24 +18263,32 @@ msgstr "# `Invia`"
#: src/concurrency/send-sync/send.md:3
#, fuzzy
-msgid "> A type `T` is [`Send`][1] if it is safe to move a `T` value to another thread."
-msgstr "> Un tipo `T` è [`Send`][1] se è sicuro spostare un valore `T` in un altro thread."
+msgid ""
+"> A type `T` is [`Send`][1] if it is safe to move a `T` value to another "
+"thread."
+msgstr ""
+"> Un tipo `T` è [`Send`][1] se è sicuro spostare un valore `T` in un altro "
+"thread."
#: src/concurrency/send-sync/send.md:5
#, fuzzy
msgid ""
-"The effect of moving ownership to another thread is that _destructors_ will run\n"
-"in that thread. So the question is when you can allocate a value in one thread\n"
+"The effect of moving ownership to another thread is that _destructors_ will "
+"run\n"
+"in that thread. So the question is when you can allocate a value in one "
+"thread\n"
"and deallocate it in another."
msgstr ""
-"L'effetto dello spostamento della proprietà su un altro thread è che i _destructors_ verranno "
-"eseguiti\n"
-"in quel filo. Quindi la domanda è quando puoi allocare un valore in un thread\n"
+"L'effetto dello spostamento della proprietà su un altro thread è che i "
+"_destructors_ verranno eseguiti\n"
+"in quel filo. Quindi la domanda è quando puoi allocare un valore in un "
+"thread\n"
"e deallocarlo in un altro."
#: src/concurrency/send-sync/send.md:13
msgid ""
-"As an example, a connection to the SQLite library must only be accessed from a\n"
+"As an example, a connection to the SQLite library must only be accessed from "
+"a\n"
"single thread."
msgstr ""
@@ -16412,7 +18300,8 @@ msgstr "# `Sincronizza`"
#: src/concurrency/send-sync/sync.md:3
#, fuzzy
msgid ""
-"> A type `T` is [`Sync`][1] if it is safe to access a `T` value from multiple\n"
+"> A type `T` is [`Sync`][1] if it is safe to access a `T` value from "
+"multiple\n"
"> threads at the same time."
msgstr ""
"> Un tipo `T` è [`Sync`][1] se è sicuro accedere a un valore `T` da più\n"
@@ -16431,24 +18320,29 @@ msgstr "> `T` è `Sync` se e solo se `&T` è `Send`"
#: src/concurrency/send-sync/sync.md:14
#, fuzzy
msgid ""
-"This statement is essentially a shorthand way of saying that if a type is thread-safe for shared "
-"use, it is also thread-safe to pass references of it across threads."
+"This statement is essentially a shorthand way of saying that if a type is "
+"thread-safe for shared use, it is also thread-safe to pass references of it "
+"across threads."
msgstr ""
-"Questa affermazione è essenzialmente un modo abbreviato per dire che se un tipo è thread-safe per "
-"l'uso condiviso, è anche thread-safe per passarne i riferimenti attraverso i thread."
+"Questa affermazione è essenzialmente un modo abbreviato per dire che se un "
+"tipo è thread-safe per l'uso condiviso, è anche thread-safe per passarne i "
+"riferimenti attraverso i thread."
#: src/concurrency/send-sync/sync.md:16
#, fuzzy
msgid ""
-"This is because if a type is Sync it means that it can be shared across multiple threads without "
-"the risk of data races or other synchronization issues, so it is safe to move it to another "
-"thread. A reference to the type is also safe to move to another thread, because the data it "
-"references can be accessed from any thread safely."
+"This is because if a type is Sync it means that it can be shared across "
+"multiple threads without the risk of data races or other synchronization "
+"issues, so it is safe to move it to another thread. A reference to the type "
+"is also safe to move to another thread, because the data it references can "
+"be accessed from any thread safely."
msgstr ""
-"Questo perché se un tipo è Sync significa che può essere condiviso tra più thread senza il rischio "
-"di corse di dati o altri problemi di sincronizzazione, quindi è sicuro spostarlo su un altro "
-"thread. Un riferimento al tipo è anche sicuro da spostare in un altro thread, perché è possibile "
-"accedere ai dati a cui fa riferimento da qualsiasi thread in modo sicuro."
+"Questo perché se un tipo è Sync significa che può essere condiviso tra più "
+"thread senza il rischio di corse di dati o altri problemi di "
+"sincronizzazione, quindi è sicuro spostarlo su un altro thread. Un "
+"riferimento al tipo è anche sicuro da spostare in un altro thread, perché è "
+"possibile accedere ai dati a cui fa riferimento da qualsiasi thread in modo "
+"sicuro."
#: src/concurrency/send-sync/examples.md:1
#, fuzzy
@@ -16463,7 +18357,8 @@ msgstr "## \"Invia + Sincronizza\"."
#: src/concurrency/send-sync/examples.md:5
#, fuzzy
msgid "Most types you come across are `Send + Sync`:"
-msgstr "La maggior parte dei tipi che incontri sono \"Invia + sincronizzazione\":"
+msgstr ""
+"La maggior parte dei tipi che incontri sono \"Invia + sincronizzazione\":"
#: src/concurrency/send-sync/examples.md:7
msgid ""
@@ -16481,7 +18376,8 @@ msgid ""
"The generic types are typically `Send + Sync` when the type parameters are\n"
"`Send + Sync`."
msgstr ""
-"I tipi generici sono in genere \"Send + Sync\" quando i parametri di tipo lo sono\n"
+"I tipi generici sono in genere \"Send + Sync\" quando i parametri di tipo lo "
+"sono\n"
"\"Invia + Sincronizza\"."
#: src/concurrency/send-sync/examples.md:17
@@ -16495,7 +18391,8 @@ msgid ""
"These types can be moved to other threads, but they're not thread-safe.\n"
"Typically because of interior mutability:"
msgstr ""
-"Questi tipi possono essere spostati in altri thread, ma non sono thread-safe.\n"
+"Questi tipi possono essere spostati in altri thread, ma non sono thread-"
+"safe.\n"
"Tipicamente a causa della mutevolezza interna:"
#: src/concurrency/send-sync/examples.md:22
@@ -16518,17 +18415,21 @@ msgstr "## `!Invia + Sincronizza`"
#: src/concurrency/send-sync/examples.md:29
#, fuzzy
-msgid "These types are thread-safe, but they cannot be moved to another thread:"
-msgstr "Questi tipi sono thread-safe, ma non possono essere spostati in un altro thread:"
+msgid ""
+"These types are thread-safe, but they cannot be moved to another thread:"
+msgstr ""
+"Questi tipi sono thread-safe, ma non possono essere spostati in un altro "
+"thread:"
#: src/concurrency/send-sync/examples.md:31
#, fuzzy
msgid ""
-"* `MutexGuard`: Uses OS level primitives which must be deallocated on the\n"
+"* `MutexGuard`: Uses OS level primitives which must be deallocated on "
+"the\n"
" thread which created them."
msgstr ""
-"* `MutexGuard`: utilizza primitive a livello di sistema operativo che devono essere deallocate "
-"su\n"
+"* `MutexGuard`: utilizza primitive a livello di sistema operativo che "
+"devono essere deallocate su\n"
" thread che li ha creati."
#: src/concurrency/send-sync/examples.md:34
@@ -16539,7 +18440,9 @@ msgstr "## `!Invia + !Sync`"
#: src/concurrency/send-sync/examples.md:36
#, fuzzy
msgid "These types are not thread-safe and cannot be moved to other threads:"
-msgstr "Questi tipi non sono thread-safe e non possono essere spostati in altri thread:"
+msgstr ""
+"Questi tipi non sono thread-safe e non possono essere spostati in altri "
+"thread:"
#: src/concurrency/send-sync/examples.md:38
#, fuzzy
@@ -16551,7 +18454,8 @@ msgid ""
msgstr ""
"* `Rc`: ogni `Rc` ha un riferimento a un `RcBox`, che contiene un\n"
" conteggio dei riferimenti non atomici.\n"
-"* `*const T`, `*mut T`: Rust presuppone che i puntatori grezzi possano avere caratteri speciali\n"
+"* `*const T`, `*mut T`: Rust presuppone che i puntatori grezzi possano avere "
+"caratteri speciali\n"
" considerazioni sulla concorrenza"
#: src/concurrency/shared_state.md:1
@@ -16562,20 +18466,24 @@ msgstr "# Stato condiviso"
#: src/concurrency/shared_state.md:3
#, fuzzy
msgid ""
-"Rust uses the type system to enforce synchronization of shared data. This is\n"
+"Rust uses the type system to enforce synchronization of shared data. This "
+"is\n"
"primarily done via two types:"
msgstr ""
-"Rust utilizza il sistema dei tipi per imporre la sincronizzazione dei dati condivisi. Questo è\n"
+"Rust utilizza il sistema dei tipi per imporre la sincronizzazione dei dati "
+"condivisi. Questo è\n"
"fatto principalmente tramite due tipi:"
#: src/concurrency/shared_state.md:6
#, fuzzy
msgid ""
-"* [`Arc`][1], atomic reference counted `T`: handles sharing between threads and\n"
+"* [`Arc`][1], atomic reference counted `T`: handles sharing between "
+"threads and\n"
" takes care to deallocate `T` when the last reference is dropped,\n"
"* [`Mutex`][2]: ensures mutually exclusive access to the `T` value."
msgstr ""
-"* [`Arc`][1], riferimento atomico contato `T`: gestisce la condivisione tra thread e\n"
+"* [`Arc`][1], riferimento atomico contato `T`: gestisce la condivisione "
+"tra thread e\n"
" si occupa di deallocare `T` quando viene eliminato l'ultimo riferimento,\n"
"* [`Mutex`][2]: garantisce l'accesso mutuamente esclusivo al valore `T`."
@@ -16587,7 +18495,9 @@ msgstr "# `Arco`"
#: src/concurrency/shared_state/arc.md:3
#, fuzzy
msgid "[`Arc`][1] allows shared read-only access via `Arc::clone`:"
-msgstr "[`Arc`][1] consente l'accesso condiviso in sola lettura tramite `Arc::clone`:"
+msgstr ""
+"[`Arc`][1] consente l'accesso condiviso in sola lettura tramite `Arc::"
+"clone`:"
#: src/concurrency/shared_state/arc.md:5
msgid ""
@@ -16615,24 +18525,30 @@ msgstr ""
#: src/concurrency/shared_state/arc.md:29
#, fuzzy
msgid ""
-"* `Arc` stands for \"Atomic Reference Counted\", a thread safe version of `Rc` that uses atomic\n"
+"* `Arc` stands for \"Atomic Reference Counted\", a thread safe version of "
+"`Rc` that uses atomic\n"
" operations.\n"
-"* `Arc` implements `Clone` whether or not `T` does. It implements `Send` and `Sync` iff `T`\n"
+"* `Arc` implements `Clone` whether or not `T` does. It implements `Send` "
+"and `Sync` iff `T`\n"
" implements them both.\n"
-"* `Arc::clone()` has the cost of atomic operations that get executed, but after that the use of "
-"the\n"
+"* `Arc::clone()` has the cost of atomic operations that get executed, but "
+"after that the use of the\n"
" `T` is free.\n"
-"* Beware of reference cycles, `Arc` does not use a garbage collector to detect them.\n"
+"* Beware of reference cycles, `Arc` does not use a garbage collector to "
+"detect them.\n"
" * `std::sync::Weak` can help."
msgstr ""
-"* `Arc` sta per \"Atomic Reference Counted\", una versione thread-safe di `Rc` che usa atomic\n"
+"* `Arc` sta per \"Atomic Reference Counted\", una versione thread-safe di "
+"`Rc` che usa atomic\n"
" operazioni.\n"
-"* `Arc` implementa `Clone` indipendentemente dal fatto che `T` lo faccia. Implementa `Send` e "
-"`Sync` se e solo `T`\n"
+"* `Arc` implementa `Clone` indipendentemente dal fatto che `T` lo faccia. "
+"Implementa `Send` e `Sync` se e solo `T`\n"
" li implementa entrambi.\n"
-"* `Arc::clone()` ha il costo delle operazioni atomiche che vengono eseguite, ma dopo ciò l'uso di\n"
+"* `Arc::clone()` ha il costo delle operazioni atomiche che vengono eseguite, "
+"ma dopo ciò l'uso di\n"
" `T` è gratuito.\n"
-"* Attenzione ai cicli di riferimento, `Arc` non usa un garbage collector per rilevarli.\n"
+"* Attenzione ai cicli di riferimento, `Arc` non usa un garbage collector per "
+"rilevarli.\n"
" * `std::sync::Weak` può aiutare."
#: src/concurrency/shared_state/mutex.md:1
@@ -16646,7 +18562,8 @@ msgid ""
"[`Mutex`][1] ensures mutual exclusion _and_ allows mutable access to `T`\n"
"behind a read-only interface:"
msgstr ""
-"[`Mutex`][1] garantisce l'esclusione reciproca _e_ consente l'accesso mutabile a `T`\n"
+"[`Mutex`][1] garantisce l'esclusione reciproca _e_ consente l'accesso "
+"mutabile a `T`\n"
"dietro un'interfaccia di sola lettura:"
#: src/concurrency/shared_state/mutex.md:6
@@ -16680,35 +18597,41 @@ msgstr ""
#: src/concurrency/shared_state/mutex.md:31
#, fuzzy
msgid ""
-"* `Mutex` in Rust looks like a collection with just one element - the protected data.\n"
-" * It is not possible to forget to acquire the mutex before accessing the protected data.\n"
-"* You can get an `&mut T` from an `&Mutex` by taking the lock. The `MutexGuard` ensures that "
-"the\n"
+"* `Mutex` in Rust looks like a collection with just one element - the "
+"protected data.\n"
+" * It is not possible to forget to acquire the mutex before accessing the "
+"protected data.\n"
+"* You can get an `&mut T` from an `&Mutex` by taking the lock. The "
+"`MutexGuard` ensures that the\n"
" `&mut T` doesn't outlive the lock being held.\n"
-"* `Mutex` implements both `Send` and `Sync` iff `T` implements `Send`.\n"
+"* `Mutex` implements both `Send` and `Sync` iff (if and only if) `T` "
+"implements `Send`.\n"
"* A read-write lock counterpart - `RwLock`.\n"
"* Why does `lock()` return a `Result`? \n"
-" * If the thread that held the `Mutex` panicked, the `Mutex` becomes \"poisoned\" to signal "
-"that\n"
-" the data it protected might be in an inconsistent state. Calling `lock()` on a poisoned "
-"mutex\n"
-" fails with a [`PoisonError`]. You can call `into_inner()` on the error to recover the data\n"
+" * If the thread that held the `Mutex` panicked, the `Mutex` becomes "
+"\"poisoned\" to signal that\n"
+" the data it protected might be in an inconsistent state. Calling "
+"`lock()` on a poisoned mutex\n"
+" fails with a [`PoisonError`]. You can call `into_inner()` on the error "
+"to recover the data\n"
" regardless."
msgstr ""
-"* `Mutex` in Rust sembra una raccolta con un solo elemento: i dati protetti.\n"
-" * Non è possibile dimenticare di acquisire il mutex prima di accedere ai dati protetti.\n"
-"* Puoi ottenere un `&mut T` da un `&Mutex` prendendo il lock. Il `MutexGuard` assicura che il "
-"file\n"
+"* `Mutex` in Rust sembra una raccolta con un solo elemento: i dati "
+"protetti.\n"
+" * Non è possibile dimenticare di acquisire il mutex prima di accedere ai "
+"dati protetti.\n"
+"* Puoi ottenere un `&mut T` da un `&Mutex
"
#: src/android/interoperability/cpp.md:10
#, fuzzy
msgid "See the [CXX tutorial][2] for an full example of using this."
-msgstr "Vedere il [tutorial CXX][2] per un esempio completo di utilizzo di questo."
+msgstr ""
+"Vedere il [tutorial CXX][2] per un esempio completo di utilizzo di questo."
#: src/android/interoperability/java.md:1
#, fuzzy
@@ -12324,7 +13656,8 @@ msgid ""
"```"
msgstr ""
-#: src/android/interoperability/java.md:32 src/android/interoperability/java.md:62
+#: src/android/interoperability/java.md:32
+#: src/android/interoperability/java.md:62
#, fuzzy
msgid "_interoperability/java/Android.bp_:"
msgstr "_interoperabilità/java/Android.bp_:"
@@ -12389,14 +13722,15 @@ msgstr "Infine, puoi creare, sincronizzare ed eseguire il binario:"
#: src/android/interoperability/java.md:75
msgid ""
"```shell\n"
-"$ m helloworld_jni\n"
-"$ adb sync # requires adb root && adb remount\n"
-"$ adb shell /system/bin/helloworld_jni\n"
+"m helloworld_jni\n"
+"adb sync # requires adb root && adb remount\n"
+"adb shell /system/bin/helloworld_jni\n"
"```"
msgstr ""
#: src/exercises/android/morning.md:1 src/exercises/bare-metal/morning.md:1
-#: src/exercises/bare-metal/afternoon.md:1 src/exercises/concurrency/morning.md:1
+#: src/exercises/bare-metal/afternoon.md:1
+#: src/exercises/concurrency/morning.md:1
#: src/exercises/concurrency/afternoon.md:1
#, fuzzy
msgid "# Exercises"
@@ -12405,10 +13739,12 @@ msgstr "# Esercizi"
#: src/exercises/android/morning.md:3
#, fuzzy
msgid ""
-"This is a group exercise: We will look at one of the projects you work with and\n"
+"This is a group exercise: We will look at one of the projects you work with "
+"and\n"
"try to integrate some Rust into it. Some suggestions:"
msgstr ""
-"Questo è un esercizio di gruppo: esamineremo uno dei progetti con cui lavori e\n"
+"Questo è un esercizio di gruppo: esamineremo uno dei progetti con cui lavori "
+"e\n"
"prova a integrarci un po' di ruggine. Alcuni suggerimenti:"
#: src/exercises/android/morning.md:6
@@ -12425,11 +13761,12 @@ msgstr ""
#: src/exercises/android/morning.md:12
#, fuzzy
msgid ""
-"No solution is provided here since this is open-ended: it relies on someone in\n"
+"No solution is provided here since this is open-ended: it relies on someone "
+"in\n"
"the class having a piece of code which you can turn in to Rust on the fly."
msgstr ""
-"Nessuna soluzione viene fornita qui poiché questo è a tempo indeterminato: si basa su qualcuno "
-"dentro\n"
+"Nessuna soluzione viene fornita qui poiché questo è a tempo indeterminato: "
+"si basa su qualcuno dentro\n"
"la classe ha un pezzo di codice che puoi consegnare a Rust al volo."
#: src/bare-metal.md:1
@@ -12440,27 +13777,28 @@ msgstr "# Benvenuto in Bare Metal Rust"
#: src/bare-metal.md:3
#, fuzzy
msgid ""
-"This is a standalone one-day course about bare-metal Rust, aimed at people who are familiar with "
-"the\n"
-"basics of Rust (perhaps from completing the Comprehensive Rust course), and ideally also have "
-"some\n"
+"This is a standalone one-day course about bare-metal Rust, aimed at people "
+"who are familiar with the\n"
+"basics of Rust (perhaps from completing the Comprehensive Rust course), and "
+"ideally also have some\n"
"experience with bare-metal programming in some other language such as C."
msgstr ""
-"Questo è un corso autonomo di un giorno sul bare metal Rust, rivolto a persone che hanno "
-"familiarità con il\n"
-"nozioni di base di Rust (forse completando il corso completo di Rust), e idealmente anche averne "
-"alcune\n"
-"esperienza con la programmazione bare metal in qualche altro linguaggio come C."
+"Questo è un corso autonomo di un giorno sul bare metal Rust, rivolto a "
+"persone che hanno familiarità con il\n"
+"nozioni di base di Rust (forse completando il corso completo di Rust), e "
+"idealmente anche averne alcune\n"
+"esperienza con la programmazione bare metal in qualche altro linguaggio come "
+"C."
#: src/bare-metal.md:7
#, fuzzy
msgid ""
-"Today we will talk about 'bare-metal' Rust: running Rust code without an OS underneath us. This "
-"will\n"
+"Today we will talk about 'bare-metal' Rust: running Rust code without an OS "
+"underneath us. This will\n"
"be divided into several parts:"
msgstr ""
-"Oggi parleremo di Rust 'bare-metal': eseguire il codice Rust senza un sistema operativo sotto di "
-"noi. Questo sarà\n"
+"Oggi parleremo di Rust 'bare-metal': eseguire il codice Rust senza un "
+"sistema operativo sotto di noi. Questo sarà\n"
"essere suddiviso in più parti:"
#: src/bare-metal.md:10
@@ -12473,37 +13811,42 @@ msgid ""
msgstr ""
"- Cos'è \"no_std\" Rust?\n"
"- Scrittura firmware per microcontrollori.\n"
-"- Scrittura del codice bootloader/kernel per i processori delle applicazioni.\n"
+"- Scrittura del codice bootloader/kernel per i processori delle "
+"applicazioni.\n"
"- Alcune casse utili per lo sviluppo di ruggine a metallo nudo."
#: src/bare-metal.md:15
#, fuzzy
msgid ""
-"For the microcontroller part of the course we will use the [BBC micro:bit](https://microbit.org/) "
-"v2\n"
-"as an example. It's a [development board](https://tech.microbit.org/hardware/) based on the "
-"Nordic\n"
-"nRF51822 microcontroller with some LEDs and buttons, an I2C-connected accelerometer and compass, "
-"and\n"
+"For the microcontroller part of the course we will use the [BBC micro:bit]"
+"(https://microbit.org/) v2\n"
+"as an example. It's a [development board](https://tech.microbit.org/"
+"hardware/) based on the Nordic\n"
+"nRF51822 microcontroller with some LEDs and buttons, an I2C-connected "
+"accelerometer and compass, and\n"
"an on-board SWD debugger."
msgstr ""
-"Per la parte del corso sui microcontrollori utilizzeremo la [BBC micro:bit](https://microbit.org/) "
-"v2\n"
-"come esempio. È una [scheda di sviluppo](https://tech.microbit.org/hardware/) basata sul Nordic\n"
-"microcontrollore nRF51822 con alcuni LED e pulsanti, un accelerometro e una bussola collegati a "
-"I2C e\n"
+"Per la parte del corso sui microcontrollori utilizzeremo la [BBC micro:bit]"
+"(https://microbit.org/) v2\n"
+"come esempio. È una [scheda di sviluppo](https://tech.microbit.org/"
+"hardware/) basata sul Nordic\n"
+"microcontrollore nRF51822 con alcuni LED e pulsanti, un accelerometro e una "
+"bussola collegati a I2C e\n"
"un debugger SWD integrato."
#: src/bare-metal.md:20
#, fuzzy
-msgid "To get started, install some tools we'll need later. On gLinux or Debian:"
-msgstr "Per iniziare, installa alcuni strumenti che ci serviranno in seguito. Su gLinux o Debian:"
+msgid ""
+"To get started, install some tools we'll need later. On gLinux or Debian:"
+msgstr ""
+"Per iniziare, installa alcuni strumenti che ci serviranno in seguito. Su "
+"gLinux o Debian:"
#: src/bare-metal.md:22
msgid ""
"```bash\n"
-"sudo apt install gcc-aarch64-linux-gnu gdb-multiarch libudev-dev picocom pkg-config qemu-system-"
-"arm\n"
+"sudo apt install gcc-aarch64-linux-gnu gdb-multiarch libudev-dev picocom pkg-"
+"config qemu-system-arm\n"
"rustup update\n"
"rustup target add aarch64-unknown-none thumbv7em-none-eabihf\n"
"rustup component add llvm-tools-preview\n"
@@ -12513,13 +13856,16 @@ msgstr ""
#: src/bare-metal.md:30
#, fuzzy
-msgid "And give users in the `plugdev` group access to the micro:bit programmer:"
-msgstr "E dai agli utenti del gruppo `plugdev` l'accesso al programmatore micro:bit:"
+msgid ""
+"And give users in the `plugdev` group access to the micro:bit programmer:"
+msgstr ""
+"E dai agli utenti del gruppo `plugdev` l'accesso al programmatore micro:bit:"
#: src/bare-metal.md:32
msgid ""
"```bash\n"
-"echo 'SUBSYSTEM==\"usb\", ATTR{idVendor}==\"0d28\", MODE=\"0664\", GROUP=\"plugdev\"' |\\\n"
+"echo 'SUBSYSTEM==\"usb\", ATTR{idVendor}==\"0d28\", MODE=\"0664\", "
+"GROUP=\"plugdev\"' |\\\n"
" sudo tee /etc/udev/rules.d/50-microbit.rules\n"
"sudo udevadm control --reload-rules\n"
"```"
@@ -12715,12 +14061,13 @@ msgid ""
"* This will compile to an empty binary.\n"
"* `std` provides a panic handler; without it we must provide our own.\n"
"* It can also be provided by another crate, such as `panic-halt`.\n"
-"* Depending on the target, you may need to compile with `panic = \"abort\"` to avoid an error "
-"about\n"
+"* Depending on the target, you may need to compile with `panic = \"abort\"` "
+"to avoid an error about\n"
" `eh_personality`.\n"
-"* Note that there is no `main` or any other entry point; it's up to you to define your own entry\n"
-" point. This will typically involve a linker script and some assembly code to set things up "
-"ready\n"
+"* Note that there is no `main` or any other entry point; it's up to you to "
+"define your own entry\n"
+" point. This will typically involve a linker script and some assembly code "
+"to set things up ready\n"
" for Rust code to run."
msgstr ""
@@ -12733,10 +14080,12 @@ msgstr "# `alloc`"
#, fuzzy
msgid ""
"To use `alloc` you must implement a\n"
-"[global (heap) allocator](https://doc.rust-lang.org/stable/std/alloc/trait.GlobalAlloc.html)."
+"[global (heap) allocator](https://doc.rust-lang.org/stable/std/alloc/trait."
+"GlobalAlloc.html)."
msgstr ""
"Per usare `alloc` devi implementare a\n"
-"[allocatore globale (heap)](https://doc.rust-lang.org/stable/std/alloc/trait.GlobalAlloc.html)."
+"[allocatore globale (heap)](https://doc.rust-lang.org/stable/std/alloc/trait."
+"GlobalAlloc.html)."
#: src/bare-metal/alloc.md:6
msgid ""
@@ -12757,7 +14106,8 @@ msgid ""
"static mut HEAP: [u8; 65536] = [0; 65536];\n"
"\n"
"pub fn entry() {\n"
-" // Safe because `HEAP` is only used here and `entry` is only called once.\n"
+" // Safe because `HEAP` is only used here and `entry` is only called "
+"once.\n"
" unsafe {\n"
" // Give the allocator some memory to allocate.\n"
" HEAP_ALLOCATOR\n"
@@ -12774,15 +14124,19 @@ msgstr ""
#: src/bare-metal/alloc.md:39
msgid ""
-"* `buddy_system_allocator` is a third-party crate implementing a basic buddy system allocator. "
-"Other\n"
-" crates are available, or you can write your own or hook into your existing allocator.\n"
-"* The const parameter of `LockedHeap` is the max order of the allocator; i.e. in this case it can\n"
+"* `buddy_system_allocator` is a third-party crate implementing a basic buddy "
+"system allocator. Other\n"
+" crates are available, or you can write your own or hook into your existing "
+"allocator.\n"
+"* The const parameter of `LockedHeap` is the max order of the allocator; i."
+"e. in this case it can\n"
" allocate regions of up to 2**32 bytes.\n"
-"* If any crate in your dependency tree depends on `alloc` then you must have exactly one global\n"
-" allocator defined in your binary. Usually this is done in the top-level binary crate.\n"
-"* `extern crate panic_halt as _` is necessary to ensure that the `panic_halt` crate is linked in "
-"so\n"
+"* If any crate in your dependency tree depends on `alloc` then you must have "
+"exactly one global\n"
+" allocator defined in your binary. Usually this is done in the top-level "
+"binary crate.\n"
+"* `extern crate panic_halt as _` is necessary to ensure that the "
+"`panic_halt` crate is linked in so\n"
" we get its panic handler.\n"
"* This example will build but not run, as it doesn't have an entry point."
msgstr ""
@@ -12795,11 +14149,11 @@ msgstr "# Microcontrollori"
#: src/bare-metal/microcontrollers.md:3
#, fuzzy
msgid ""
-"The `cortex_m_rt` crate provides (among other things) a reset handler for Cortex M "
-"microcontrollers."
+"The `cortex_m_rt` crate provides (among other things) a reset handler for "
+"Cortex M microcontrollers."
msgstr ""
-"Il crate `cortex_m_rt` fornisce (tra le altre cose) un gestore di reset per i microcontrollori "
-"Cortex M."
+"Il crate `cortex_m_rt` fornisce (tra le altre cose) un gestore di reset per "
+"i microcontrollori Cortex M."
#: src/bare-metal/microcontrollers.md:5
msgid ""
@@ -12822,19 +14176,23 @@ msgstr ""
#: src/bare-metal/microcontrollers.md:21
#, fuzzy
-msgid "Next we'll look at how to access peripherals, with increasing levels of abstraction."
-msgstr "Successivamente vedremo come accedere alle periferiche, con livelli crescenti di astrazione."
+msgid ""
+"Next we'll look at how to access peripherals, with increasing levels of "
+"abstraction."
+msgstr ""
+"Successivamente vedremo come accedere alle periferiche, con livelli "
+"crescenti di astrazione."
#: src/bare-metal/microcontrollers.md:25
#, fuzzy
msgid ""
-"* The `cortex_m_rt::entry` macro requires that the function have type `fn() -> !`, because "
-"returning\n"
+"* The `cortex_m_rt::entry` macro requires that the function have type `fn() -"
+"> !`, because returning\n"
" to the reset handler doesn't make sense.\n"
"* Run the example with `cargo embed --bin minimal`"
msgstr ""
-"* La macro `cortex_m_rt::entry` richiede che la funzione abbia il tipo `fn() -> !`, perché "
-"restituisce\n"
+"* La macro `cortex_m_rt::entry` richiede che la funzione abbia il tipo `fn() "
+"-> !`, perché restituisce\n"
" al gestore di ripristino non ha senso.\n"
"* Esegui l'esempio con `cargo embed --bin minimal`"
@@ -12846,11 +14204,12 @@ msgstr "# MMIO grezzo"
#: src/bare-metal/microcontrollers/mmio.md:3
#, fuzzy
msgid ""
-"Most microcontrollers access peripherals via memory-mapped IO. Let's try turning on an LED on our\n"
+"Most microcontrollers access peripherals via memory-mapped IO. Let's try "
+"turning on an LED on our\n"
"micro:bit:"
msgstr ""
-"La maggior parte dei microcontrollori accede alle periferiche tramite IO mappato in memoria. "
-"Proviamo ad accendere un LED sul nostro\n"
+"La maggior parte dei microcontrollori accede alle periferiche tramite IO "
+"mappato in memoria. Proviamo ad accendere un LED sul nostro\n"
"micro:bit:"
#: src/bare-metal/microcontrollers/mmio.md:6
@@ -12884,23 +14243,29 @@ msgid ""
"#[entry]\n"
"fn main() -> ! {\n"
" // Configure GPIO 0 pins 21 and 28 as push-pull outputs.\n"
-" let pin_cnf_21 = (GPIO_P0 + PIN_CNF + 21 * size_of::