diff --git a/po/it.po b/po/it.po index 6df1081a..42fb5346 100644 --- a/po/it.po +++ b/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 " -"[1.0 nel 2015][1]:" +"Rust è un nuovo linguaggio di programmazione che ha avuto la sua " +"[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'overflow di numeri interi è definito." +"* L'accesso agli array è controllato dai loro limiti.\n" +"* 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" -"* Generici.\n" +"* Enumerazioni (_Enums_) e pattern matching.\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` e `Risultato`.\n" +" `Option` e `Result`.\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" -" _pronto all'uso_', pronto per il copia-incolla nel tuo codice.\n" +" \"loquace\" rispetto ad altri compilatori. Spesso fornirà feedback\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" -" aiuta in questo consentendo di confrontare le metriche " +" 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#\"link\"#);\n" +" println!(\"link\");\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`, 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"