it: Day 1 - Morning (update and missing strings)

po/it.po

@@ -119,7 +119,7 @@ msgstr "Funzioni"
 
 #: src/SUMMARY.md:34
 msgid "Rustdoc"
-msgstr "Rustico"
+msgstr "Rustdoc"
 
 #: src/SUMMARY.md:35 src/SUMMARY.md:82
 msgid "Methods"
@@ -2267,7 +2267,7 @@ msgid ""
 "This is the first day of Comprehensive Rust. We will cover a lot of ground\n"
 "today:"
 msgstr ""
-"Questo è il primo giorno di Comprehensive Rust. Oggi copriremo un sacco di strada:\n"
+"Questo è il primo giorno di 'Comprehensive Rust'. Oggi copriremo un sacco di strada:\n"
 
 #: src/welcome-day-1.md:6
 msgid ""
@@ -2286,7 +2286,7 @@ msgstr ""
 "\n"
 "* Gestione della memoria: stack vs heap, gestione manuale della memoria, "
 "memoria basata sull'ambito (scoped),\n"
-"  garbage collection.\n"
+" garbage collection.\n"
 "\n"
 "* Ownership: semantica di spostamento (move), copia e clonazione, prestito (borrowing) e durata (lifetimes)."
 
@@ -2314,20 +2314,20 @@ msgid ""
 "    that the slides are just a support and you are free to skip them as you\n"
 "    like."
 msgstr ""
-"* Dovrebbero fare domande quando le ricevono, non salvarle fino alla fine.\n"
+"* Dovrebbero fare domande quando ne sentono il bisogno, non trattenerle fino alla fine.\n"
 "* La lezione è pensata per essere interattiva e le discussioni sono molto "
 "incoraggiate!\n"
 "  * In qualità di istruttore, dovresti cercare di mantenere le discussioni "
 "pertinenti, ad es.\n"
 "    mantieni la relazione con il modo in cui Rust fa le cose rispetto a "
-"qualche altra lingua. Può essere\n"
+"qualche altro linguaggio. Può essere\n"
 "    difficile trovare il giusto equilibrio, ma è meglio permettere "
 "discussioni che\n"
-"    coinvolgono le persone piuttosto della comunicazione "
+"    coinvolgono le persone piuttosto che una comunicazione "
 "unidirezionale.\n"
 "* Le domande probabilmente significheranno che parleremo di cose prima delle "
 "diapositive.\n"
-"  * Questo è perfettamente a posto! La ripetizione è una parte importante "
+"  * Questo è perfettamente okay! La ripetizione è una parte importante "
 "dell'apprendimento. Ricordare\n"
 "    che le diapositive sono solo un supporto e sei libero di saltarle come "
 "preferisci."
@@ -2351,7 +2351,7 @@ msgid ""
 "If you're teaching this in a classroom, this is a good place to go over the\n"
 "schedule. We suggest splitting the day into two parts (following the slides):"
 msgstr ""
-"Se stai insegnando questo in un'aula, questo è un buon posto per esaminare "
+"Se stai insegnando in un'aula, questo è un buon posto per esaminare "
 "il\n"
 "programma. Suggeriamo di dividere la giornata in due parti (seguendo le "
 "slide):"
@@ -2381,8 +2381,8 @@ msgstr "# Cos'è Rust?"
 msgid ""
 "Rust is a new programming language which had its [1.0 release in 2015][1]:"
 msgstr ""
-"Rust è un nuovo linguaggio di programmazione che ha avuto la sua versione "
+"Rust è un nuovo linguaggio di programmazione che ha avuto la sua "
-"[1.0 nel 2015][1]:"
+"[versione 1.0 nel 2015][1]:"
 
 #: src/welcome-day-1/what-is-rust.md:5
 msgid ""
@@ -2400,7 +2400,7 @@ msgid ""
 "  * desktops,\n"
 "  * servers."
 msgstr ""
-"* Rust è un linguaggio compilato staticamente con un ruolo simile a C++\n"
+"* Rust è un linguaggio compilato staticamente in modo simile a C++\n"
 "  * `rustc` utilizza LLVM come backend.\n"
 "* Rust supporta molte [piattaforme e\n"
 "  architetture](https://doc.rust-lang.org/nightly/rustc/platform-support."
@@ -2409,7 +2409,7 @@ msgstr ""
 "  * Linux, Mac, Windows, ...\n"
 "* Rust è utilizzato per un'ampia gamma di dispositivi:\n"
 "  * firmware e _boot loaders_,\n"
-"  * display intelligenti,\n"
+"  * display 'smart',\n"
 "  * cellulari,\n"
 "  * desktop,\n"
 "  * server."
@@ -2455,7 +2455,7 @@ msgstr ""
 
 #: src/hello-world.md:12
 msgid "What you see:"
-msgstr "Quello che vedi:"
+msgstr "Quello che si vede:"
 
 #: src/hello-world.md:14
 msgid ""
@@ -2505,16 +2505,16 @@ msgid ""
 msgstr ""
 "* Rust è molto simile ad altri linguaggi della tradizione C/C++/Java. È\n"
 "  imperativo (non funzionale) e non cerca di reinventare le cose a meno che\n"
-"  assolutamente necessario.\n"
+"  non sia assolutamente necessario.\n"
 "\n"
 "* Rust è moderno con pieno supporto per cose come Unicode.\n"
 "\n"
 "* Rust utilizza le macro per le situazioni in cui si desidera avere un "
 "numero variabile di\n"
-"  argomenti (nessuna funzione [sovraccarico](basic-syntax/functions-"
+"  argomenti (nessun [overloading di funzione](basic-syntax/functions-"
 "interlude.md)).\n"
 "\n"
-"* Le macro essendo \"igieniche\" significa che non catturano accidentalmente "
+"* Le macro definite \"igieniche\" significa che non catturano accidentalmente "
 "identificatori da\n"
 "  l'ambito in cui vengono utilizzate. Le macro di Rust sono in realtà solo\n"
 "  [parzialmente igieniche](https://veykril.github.io/tlborm/decl-macros/"
@@ -2630,7 +2630,7 @@ msgid ""
 "Depending\n"
 "on the answer you can highlight different features of Rust:"
 msgstr ""
-"Assicurati di chiedere alla classe con quali lingue ha esperienza. "
+"Assicurati di chiedere alla classe con quali linguaggi hanno esperienza. "
 "In base alla\n"
 "risposta puoi evidenziare diverse caratteristiche di Rust:"
 
@@ -2654,20 +2654,20 @@ msgid ""
 msgstr ""
 "* Esperienza con C o C++: Rust elimina un'intera classe di _errori di "
 "runtime_\n"
-"  tramite il _borrow checker_. Ottieni prestazioni come in C e C++, ma "
+"  tramite il _borrow checker_. Ottiene prestazioni come in C e C++, ma "
 "non\n"
-"  hai i problemi di sicurezza della memoria. Inoltre, ottieni un "
+"  hai i problemi di sicurezza della memoria. Inoltre, si ha un "
 "linguaggio moderno con\n"
 "  costrutti come il pattern matching e la gestione delle dipendenze "
 "incorporata.\n"
 "\n"
-"* Esperienza con Java, Go, Python, JavaScript...: Ottieni la stessa "
+"* Esperienza con Java, Go, Python, JavaScript...: Ottiene la stessa "
 "sicurezza della memoria\n"
-"  come in quelle lingue, più una simile sensazione linguistica di alto "
+"  come in quei linguaggi, più una sensazione simile ad un linguaggio di alto "
 "livello. Inoltre\n"
-"  ottieni prestazioni veloci e prevedibili come C e C++ (nessun Garbage "
+"  raggiunge prestazioni veloci e prevedibili come C e C++ (nessun Garbage "
 "Collector)\n"
-"  così come l'accesso all'hardware di basso livello (se ne hai bisogno)"
+"  così come l'accesso all'hardware di basso livello (quando serve)"
 
 #: src/why-rust/compile-time.md:1
 msgid "# Compile Time Guarantees"
@@ -2689,7 +2689,7 @@ msgid ""
 "* No iterator invalidation."
 msgstr ""
 "* Nessuna variabile non inizializzata.\n"
-"* Nessuna perdita di memoria (_principalmente_, vedi note).\n"
+"* Nessun _memory leaks_ (_principalmente_, vedi note).\n"
 "* Nessun _double-frees_.\n"
 "* Nessun _use-after-free_.\n"
 "* Nessun puntatore `NULL`.\n"
@@ -2702,7 +2702,7 @@ msgid ""
 "It is possible to produce memory leaks in (safe) Rust. Some examples\n"
 "are:"
 msgstr ""
-"È possibile produrre perdite di memoria in (sicuro) Rust. Qualche esempio\n"
+"È possibile produrre perdite di memoria in Rust sicuro (Safe Rust). Qualche esempio\n"
 "Sono:"
 
 #: src/why-rust/compile-time.md:19
@@ -2750,8 +2750,8 @@ msgid ""
 "* Array access is bounds checked.\n"
 "* Integer overflow is defined (panic or wrap-around)."
 msgstr ""
-"* L'accesso all'array è controllato dai limiti.\n"
+"* L'accesso agli array è controllato dai loro limiti.\n"
-"* L'overflow di numeri interi è definito."
+"* L'overflow di numeri interi è definito (panic or wrap-around)."
 
 #: src/why-rust/runtime.md:12
 msgid ""
@@ -2801,8 +2801,8 @@ msgid ""
 "* No overhead FFI.\n"
 "* Zero-cost abstractions."
 msgstr ""
-"* Enumerazioni e pattern matching.\n"
+"* Enumerazioni (_Enums_) e pattern matching.\n"
-"* Generici.\n"
+"* Generici (_generic_).\n"
 "* Nessun _overhead_ FFI.\n"
 "* Astrazioni a costo zero (_Zero-cost abstractions_)."
 
@@ -2876,35 +2876,35 @@ msgstr ""
 "  per costrutti di programmazione di livello superiore con memoria o CPU. "
 "Per esempio,\n"
 "  scrivere un ciclo usando `for` dovrebbe comportare all'incirca lo stesso "
-"livello basso\n"
+"livello di\n"
 "  istruzioni come usare il costrutto `.iter().fold()`.\n"
 "\n"
 "* Potrebbe valere la pena ricordare che anche le enum di Rust sono \"tipi di "
-"dati algebrici\".\n"
+"dati algebrici\"\n"
 "  noti come \"tipi di somma\", che consentono al sistema di tipi di "
 "esprimere cose come\n"
-"  `Opzione<T>` e `Risultato<T, E>`.\n"
+"  `Option<T>` e `Result<T, E>`.\n"
 "\n"
-"* Ricorda alle persone di leggere gli errori --- molti sviluppatori si "
+"* Ricordare alle persone di leggere gli errori --- molti sviluppatori si "
 "sono abituati a\n"
-"  ignorare il lungo output del compilatore. Il compilatore Rust è molto di "
+"  ignorare l'output del compilatore. Il compilatore Rust è molto "
 "più\n"
-"  loquace rispetto ad altri compilatori. Ti fornirà spesso feedback\n"
+"  \"loquace\" rispetto ad altri compilatori. Spesso fornirà feedback\n"
-"  _pronto all'uso_', pronto per il copia-incolla nel tuo codice.\n"
+"  _pronti all'uso_, pronti per il copia-incolla nel tuo codice.\n"
 "\n"
 "* La libreria standard di Rust è piccola rispetto a linguaggi come Java, "
 "Python,\n"
 "  e Go. Rust non viene fornito con molte cose che potresti considerare "
 "standard e\n"
-"  essenziale:\n"
+"  essenziali:\n"
 "\n"
 "  * un generatore di numeri casuali, ma vedi [rand].\n"
 "  * supporto per SSL o TLS, ma vedi [rusttls].\n"
 "  * supporto per JSON, ma vedi [serde_json].\n"
 "\n"
-"  Il ragionamento alla base di ciò è che la funzionalità nella libreria "
+"  Il ragionamento alla base di ciò è che una funzionalità nella libreria "
 "standard non può\n"
-"  essere tolto, quindi deve essere molto stabile. Per gli esempi precedenti, "
+"  essere tolta, quindi deve essere molto stabile. Per gli esempi precedenti, "
 "la comunità Rust\n"
 "  sta ancora lavorando per trovare la soluzione migliore --- e "
 "forse \n"
@@ -2916,11 +2916,11 @@ msgstr ""
 "ciò\n"
 "  è che la libreria standard può essere più piccola.\n"
 "\n"
-"  La scoperta di buoni pacchetti (_crates_) di terze parti può essere un problema. Siti "
+"  La ricerca di buoni 'pacchetti' (_crates_) di terze parti può essere un problema. Siti "
 "come\n"
-"  <https://lib.rs/> aiuta in questo consentendo di confrontare le metriche "
+"  <https://lib.rs/> aiutano in questo consentendo di confrontare le metriche "
 "per specifiche\n"
-"  _crate_ per trovarne una buona e fidata.\n"
+"  _crate_ per trovarne uno buona e affidabile.\n"
 "  \n"
 "* [rust-analyzer] è un'implementazione LSP ben supportata utilizzata nei"
 "maggiori\n"
@@ -3029,6 +3029,28 @@ msgid ""
 "  }\n"
 "  ```"
 msgstr ""
+"- Le stringhe non elaborate (_raw_) consentono di creare un valore `&str` con i caratteri"
+" di escape disabilitati: "
+"`r\"\\n\"\n"
+"  == \"\\\\\\\\n\"`. Puoi racchiudere le doppie virgolette usando una quantità uguale di "
+"`#` su\n"
+"  entrambi i lati delle virgolette:\n"
+"\n"
+"  ```rust,editable\n"
+"  fn main() {\n"
+"      println!(r#\"<a href=\"link.html\">link</a>\"#);\n"
+"      println!(\"<a href=\\\"link.html\\\">link</a>\");\n"
+"  }\n"
+"  ```\n"
+"\n"
+"- Le stringhe di byte consentono di creare direttamente un valore `&[u8]`:\n"
+"\n"
+"  ```rust,editable\n"
+"  fn main() {\n"
+"      println!(\"{:?}\", b\"abc\");\n"
+"      println!(\"{:?}\", &[97, 98, 99]);\n"
+"  }\n"
+"  ```"
 
 #: src/basic-syntax/compound-types.md:1
 msgid "# Compound Types"
@@ -3044,6 +3066,13 @@ msgid ""
 "| Tuples | `()`, `(T,)`, `(T1, T2)`, ... | `()`, `('x',)`, `('x', 1.2)`, ... "
 "|"
 msgstr ""
+"|        | Tipi                         | Letterali                          "
+"|\n"
+"|--------|-------------------------------|-----------------------------------|\n"
+"| Array | `[T; N]`                      | `[20, 30, 40]`, `[0; 3]`          "
+"|\n"
+"| Tuple | `()`, `(T,)`, `(T1, T2)`, ... | `()`, `('x',)`, `('x', 1.2)`, ... "
+"|"
 
 #: src/basic-syntax/compound-types.md:8
 msgid "Array assignment and access:"
@@ -3100,6 +3129,22 @@ msgid ""
 "* Adding `#`, eg `{a:#?}`, invokes a \"pretty printing\" format, which can "
 "be easier to read."
 msgstr ""
+"* Un valore di un array tipo `[T; N]` contiene `N` (una costante _compile-time_) "
+"elementi dello stesso tipo `T`.\n"
+"  Nota che la lunghezza dell'array è *parte del suo tipo*, il che significa che "
+"`[u8; 3]` e\n"
+"  `[u8; 4]` sono considerati due tipi diversi.\n"
+"\n"
+"* Si possono usare i letterali per assegnare i valori agli array.\n"
+"\n"
+"* Nalla funzione main, l'istruzione print richiede l'implementazione 'debug' "
+"con il parametro `?`:\n"
+"   `{}` da l'output predefinito (_default_), `{:?}` da l'output tipo debug. "
+"Si sarebbe\n"
+"  anche potuto usare `{a}` e `{a:?}` senza specificare il valore dopo la stringa formattata.\n"
+"\n"
+"* Aggiungendo `#`, eg `{a:#?}`, si invoca un formato \"pretty printing\", il quale può "
+"essere più facile da leggere."
 
 #: src/basic-syntax/compound-types.md:47
 msgid "Tuples:"
@@ -3137,7 +3182,7 @@ msgstr ""
 "valore\n"
 "  sono espressi come `()`. Viene utilizzato per indicare, ad esempio, che "
 "una funzione o\n"
-"  expression non ha alcun valore di ritorno, come vedremo in una diapositiva "
+"  espressione che non ha alcun valore di ritorno, come vedremo in una diapositiva "
 "futura.\n"
 "    * Puoi pensarlo come un \"vuoto\" che può esserti familiare da altri\n"
 "      linguaggi di programmazione."
@@ -3179,7 +3224,7 @@ msgstr ""
 "puntatori C e C++.\n"
 "* In alcuni casi Rust dereferenzia automaticamente, in particolare durante "
 "l'invocazione\n"
-"  metodi (prova `ref_x.count_ones()`).\n"
+"  di metodi (prova `ref_x.count_ones()`).\n"
 "* I riferimenti dichiarati come `mut` possono essere associati a valori "
 "diversi nel corso della loro durata."
 
@@ -3231,7 +3276,7 @@ msgstr ""
 "* 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 a abbastanza a lungo.\n"
+"durino abbastanza a lungo.\n"
 "* Parleremo di più del _borrowing_ quando arriveremo alla proprietà (_ownership_)."
 
 #: src/basic-syntax/slices.md:1
@@ -3386,6 +3431,32 @@ msgid ""
 "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<T>`, 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"
@@ -3443,6 +3514,16 @@ msgid ""
 "* 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"
@@ -3575,6 +3656,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"