diff --git a/_includes/it-IT/example.rs b/_includes/it-IT/example.rs new file mode 100644 index 000000000..bb3f2430a --- /dev/null +++ b/_includes/it-IT/example.rs @@ -0,0 +1,22 @@ +// Questo codice é modificabile e eseguibile! +fn main() { + // Una semplice calcolatrice per numeri interi: + // `+` o `-` aggiunge o sottrae 1 + // `*` o `/` moltiplica o divide per 2 + + let programma = "+ + * - /"; + let mut accumulatore = 0; + + for simbolo in programma.chars() { + match simbolo { + '+' => accumulatore += 1, + '-' => accumulatore -= 1, + '*' => accumulatore *= 2, + '/' => accumulatore /= 2, + _ => { /* ignora gli altri caratteri */ } + } + } + + println!("Il programma \"{}\" calcola il valore {}", + programma, accumulatore); +} diff --git a/_includes/it-IT/example.rs.html b/_includes/it-IT/example.rs.html new file mode 100644 index 000000000..8c1a21ee8 --- /dev/null +++ b/_includes/it-IT/example.rs.html @@ -0,0 +1,23 @@ +
+fn main() {
+// Una semplice calcolatrice per numeri interi:
+// `+` o `-` aggiunge o sottrae 1
+// `*` o `/` moltiplica o divide per 2
+
+let programma = "+ + * - /";
+let mut accumulatore = 0;
+
+for simbolo in programma.chars() {
+match simbolo {
+    '+' => accumulatore += 1,
+    '-' => accumulatore -= 1,
+    '*' => accumulatore *= 2,
+    '/' => accumulatore /= 2,
+    _ => { /* ignora gli altri caratteri */ }
+}
+}
+
+println!("Il programma \"{}\" calcola il valore {}",
+   programma, accumulatore);
+}
+
diff --git a/_layouts/basic.html b/_layouts/basic.html index 39f2f85b0..d70f09067 100644 --- a/_layouts/basic.html +++ b/_layouts/basic.html @@ -40,10 +40,12 @@

Contribute

Our site in other languages: Español, Français, - 日本語, + 日本語, 한국어, Português, Русский, + 简体中文, + Italiano Tiếng việt, 简体中文

diff --git a/_layouts/fr-FR/basic.html b/_layouts/fr-FR/basic.html index 444f575db..65e421c56 100644 --- a/_layouts/fr-FR/basic.html +++ b/_layouts/fr-FR/basic.html @@ -39,11 +39,13 @@

Contribuer

diff --git a/_layouts/it-IT/basic.html b/_layouts/it-IT/basic.html new file mode 100644 index 000000000..0944b0167 --- /dev/null +++ b/_layouts/it-IT/basic.html @@ -0,0 +1,62 @@ + + + + + + + + {{ page.title }} + + + + + + + + + + + + +
+ +
+ + {{ content }} + + + + + + diff --git a/_layouts/it-IT/default.html b/_layouts/it-IT/default.html new file mode 100644 index 000000000..6e11e387a --- /dev/null +++ b/_layouts/it-IT/default.html @@ -0,0 +1,7 @@ +--- +layout: it-IT/basic +--- + +
+ {{ content }} +
diff --git a/_layouts/ja-JP/basic.html b/_layouts/ja-JP/basic.html index 3252fd789..5785b43a0 100644 --- a/_layouts/ja-JP/basic.html +++ b/_layouts/ja-JP/basic.html @@ -43,7 +43,8 @@

開発に参加する

한국어, Português, Русский, - 简体中文 + 简体中文, + Italiano

diff --git a/_layouts/ko-KR/basic.html b/_layouts/ko-KR/basic.html index ad8851c64..4735f96a9 100644 --- a/_layouts/ko-KR/basic.html +++ b/_layouts/ko-KR/basic.html @@ -43,6 +43,8 @@

기여하기

日本語, Português, Русский, + 简体中文, + Italiano Tiếng việt, 简体中文

diff --git a/_layouts/pt-BR/basic.html b/_layouts/pt-BR/basic.html index e6fad7bfc..5efa25df9 100644 --- a/_layouts/pt-BR/basic.html +++ b/_layouts/pt-BR/basic.html @@ -43,6 +43,8 @@

Contribua

日本語, 한국어, Русский, + 简体中文, + Italiano Tiếng việt, 简体中文

diff --git a/_layouts/redirect.html b/_layouts/redirect.html index 76e612c4b..b5d59d25f 100644 --- a/_layouts/redirect.html +++ b/_layouts/redirect.html @@ -19,6 +19,8 @@ "ru-RU": "ru-RU", "zh": "zh-CN", "zh-CN": "zh-CN", + "it": "it-IT", + "it-IT": "it-IT" }; // look up the provided language in the map diff --git a/_layouts/ru-RU/basic.html b/_layouts/ru-RU/basic.html index 89fd1d8dc..c8fb24312 100644 --- a/_layouts/ru-RU/basic.html +++ b/_layouts/ru-RU/basic.html @@ -43,6 +43,8 @@

Участие

日本語, 한국어, Português, + 简体中文, + Italiano Tiếng việt, 简体中文

diff --git a/_layouts/vi-VN/basic.html b/_layouts/vi-VN/basic.html index c2fa05aa6..d2adc3408 100644 --- a/_layouts/vi-VN/basic.html +++ b/_layouts/vi-VN/basic.html @@ -43,7 +43,8 @@

Đóng góp

한국어, Português, Русский, - 简体中文 + 简体中文, + Italiano

diff --git a/_layouts/zh-CN/basic.html b/_layouts/zh-CN/basic.html index c46a8e186..69d361591 100644 --- a/_layouts/zh-CN/basic.html +++ b/_layouts/zh-CN/basic.html @@ -44,7 +44,11 @@

贡献

한국어, Português, Русский, +<<<<<<< HEAD + Italiano +======= Tiếng việt +>>>>>>> upstream/master

diff --git a/it-IT/community.md b/it-IT/community.md new file mode 100644 index 000000000..2b3ad2859 --- /dev/null +++ b/it-IT/community.md @@ -0,0 +1,245 @@ +--- +layout: it-IT/default +title: La comunitá di Rust · Il linguaggio di programmazione Rust +--- + +# La comunitá di Rust + +Il linguaggio di programmazione Rust ha molte qualitá ma la forza piú +grande di Rust sta nella comunitá di persone che si sono unite per +rendere il lavorare in Rust un'esperienza appagante. + +Noi ci impegniamo a allestire un ambiente amichevole, sicuro +e accomondante per tutti, a prescindere da sesso, orientamento +sessuale, disabilitá, etnia, religione o altre caratteristiche +personali. Il nostro [codice di comportamento][coc] definisce +gli standard comportamentali in tutti i forum di Rust. + +Se sei stato o sei in questo momento vittima di attacchi +o disturbato da un membro della comunitá, per favore +[contatta][mod_team_email] qualcuno dal [team di moderazione di Rust] +[mod_team] immediatamente. Che tu sia un regolare frequentatore o +un nuovo arrivato, ci impegniamo per rendere la comunitá uno spazio +sicuro per te. + +[coc]: conduct.html +[mod_team_email]: mailto:rust-mods@rust-lang.org + +## Per iniziare + +Le risorse piú importanti della comunitá per coloro che sono nuovi a Rust sono: + +- [#rust-beginners][beginners_irc], un canale IRC che + ama rispondere a domande di qualsiasi difficoltá. +- Il [Forum Utenti][users_forum], per parlare di tutto + ció che riguarda Rust. + +Potresti anche trovare aiuto sul sito di domande e risposte [Stack Overflow][stack_overflow]. + +[stack_overflow]: https://stackoverflow.com/questions/tagged/rust + +## Novitá + +[This Week in Rust][twir] raccoglie le ultime news, eventi futuri +e racconta su base settimanale dei cambiamenti in Rust e le +sue librerie. [Il Blog di Rust][rust_blog] é dove il team di Rust +annuncia sviluppi importanti del linguaggio. Quasi ogni cosa +viene discussa anche nel subreddit non ufficiale [/r/rust][reddit]. + +Siamo anche su [Twitter][twitter]. +Se non conosci l'inglese, puoi anche seguire il nostro [Weibo][weibo] per gli utenti cinesi. + +[twir]: https://this-week-in-rust.org/ +[rust_blog]: http://blog.rust-lang.org/ +[reddit]: https://www.reddit.com/r/rust +[reddit_coc]: https://www.reddit.com/r/rust/comments/2rvrzx/our_code_of_conduct_please_read/ +[twitter]: https://twitter.com/rustlang +[weibo]: http://weibo.com/u/5616913483 + +## Canali IRC + +I Rustacchiani mantengono un numero di canali [IRC] amichevoli e molto frequentati sulla rete IRC di Mozilla, irc.mozilla.org. + +Il canale [#rust][rust_irc] é dedicato alle discussioni +generali su Rust ed é anche un buon posto per cercare aiuto. +Troverai persone disposte a rispondere a qualsiasi domanda +su Rust, tipicamente in poco tempo. + +Gli sviluppatori di Rust si organizzano su [#rust-internals][internals_irc]. Dedicato alla discussione continua sulla modifica di Rust stesso. Qui si possono chiedere informazioni su come contribuire a Rust. + +### Canali principali + +- [#rust][rust_irc] per tutto ció che riguarda Rust +- [#rust-beginners][beginners_irc] per coloro che sono nuovi al linguaggio, é meno trafficato di #rust +- [#rust-internals][internals_irc] per discutere sui dettagli di come é fatto Rust e la sua implementazione +- [#rustc][rustc_irc] dove parla il [team di sviluppo del compilatore][compiler_team] +- [#rust-libs][libs_irc] dove parla il [team di sviluppo delle librerie][library_team] +- [#rust-tools][tools_irc] dove parla il [team di sviluppo degli strumenti][tool_team] +- [#rust-lang][lang_irc] dove parla il [team della sintassi][language_team] +- [#rust-community][community_irc] dove parla il [team di moderazione][community_team] + +### Canali internazionali + +- [#rust-br][br_irc] é dedicado à discussão sobre Rust no Brasil +- [#rust-de][de_irc] ist für die allgemeine Diskussion über Rust auf Deutsch +- [#rust-es][es_irc] es para una discusión general sobre Rust en español +- [#rust-fr][fr_irc] est dédié à la programmation en Rust en français +- [#rust-ru][ru_irc] для общих дискуссий о Rust на русском языке + +### Canali specifici + +- [#cargo][cargo_irc] per parlare di Cargo, il gestore di pacchetti di Rust +- [#rust-bots][bots_irc] notifiche su Rust da parte di bot automatici +- [#rust-docs][docs_irc] dove si parlano i membri del team non ufficiale di documentazione +- [#rust-crypto][crypto_irc] per discutere della crittografia in Rust +- [#rust-gamedev][gamedev_irc] per coloro che sviluppano videogiochi in Rust +- [#rust-networking][networking_irc] per coloro che sviluppano reti di computer con Rust +- [#rust-offtopic][offtopic_irc] per parlare di cose non correlate a Rust tra Rustacchiani +- [#rust-osdev][osdev_irc] per lo sviluppo di sistemi operativi in Rust +- [#rust-webdev][webdev_irc] per coloro che sviluppano applicazioni e server web in Rust +- [#servo][servo_irc] il canale di Servo, il motore di navigazione scritto in Rust + +[IRC]: https://en.wikipedia.org/wiki/Internet_Relay_Chat +[beginners_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-beginners +[bots_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-bots +[br_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-br +[cargo_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23cargo +[community_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-community +[crypto_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-crypto +[de_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-de +[es_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-es +[fr_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-fr +[gamedev_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-gamedev +[internals_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-internals +[lang_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-lang +[libs_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-libs +[networking_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-networking +[offtopic_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-offtopic +[osdev_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-osdev +[ru_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-ru +[rust_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust +[rustc_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rustc +[servo_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23servo +[tools_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-tools +[webdev_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-webdev +[docs_irc]: https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-docs + +## Forum di discussione + +Abbiamo due forum per le discussioni sul lungo periodo: + +- Il [Forum Utenti][users_forum], per fare domande, condividere + frammenti di codice, parlare dei progetti in Rust e via dicendo. + +- Il [Forum Sviluppo][internals_forum], un luogo dedicato alla discussione + del design e dell'implementazione di Rust (includendo Cargo, la libreria standard + e altre componenti chiave dell'infrastruttura). + +[users_forum]: https://users.rust-lang.org/ +[internals_forum]: https://internals.rust-lang.org/ + +## Canale YouTube + +Rust ha un [Canale YouTube][youtube_channel] dove viene caricato del materiale +sul linguaggiodi programmazione. Si trovano qui registrazioni di varie conferenze +tenute da membri della comunitá Rust. + +[youtube_channel]: https://www.youtube.com/channel/UCaYhcUwRBNscFNUKTjgPFiA + +## Gruppi Utenti e Incontri + +Ci sono oltre 50 [Gruppi Utenti Rust][user_group] nel mondo fra oltre 20 +countries che contano oltre 7,000 membri. I Rustacchiani si incontrano periodicamente +nei Gruppi Utenti Rust. +Un ottimo modo per entrare nella comunitá, per imparare e per socializzare +con persone che hanno interessi simili. Gli incontri sono tenuti su base mensile +e sono molto informali. Gli incontri sono aperti a tutti. + +C'é un [calendario][calendar] globale per organizzare gli eventi Rust. +Contatta il [team di moderazione][community_team] per aggiungere il tuo. + +[user_group]: ./user-groups.html +[calendar]: https://www.google.com/calendar/embed?src=apd9vmbc22egenmtu5l6c5jbfc@group.calendar.google.com + +## Il team di Rust + +Rust ha un modello di sviluppo guidato dalla comunitá dove la maggior parte +delle decisioni sono fatte in discussioni aperte e condivise, sotto la +supervisione di diversi [team][teams]: + +* Il [Team Base][core_team] si occupa di guidare il processo di design +e sviluppo, controllando l'introduzione delle nuove funzionalitá e +come ultima voce in capitolo per risolvere le controversie per le +quali non vi é un chiaro consenso(ció succede raramente). + +* Il [Team della sintassi][language_team] si occupa di progettare le nuove +funzionalitá del linguaggio. + +* Il [Team delle librerie][library_team] si occupa della libreria standard, +i pacchetti gestiti da rust-lang e le convenzioni da tenere. + +* Il [Team del compilatore][compiler_team] si occupa del funzionamento del +compilatore e delle ottimizzazioni. + +* Il [Team degli strumenti][tool_team] si occupa degli strumenti ufficiali +come [Cargo], [rustup] e [rustfmt] ma anche della piattaforma di testing e +rilascio continuo del progetto. + +[Cargo]: https://crates.io +[rustup]: https://www.rustup.rs +[rustfmt]: https://github.com/rust-lang-nursery/rustfmt + +* Il [Team della comunitá][community_team] coordina gli eventi, +la portata pubblica, l'utilizzo commerciale, il materiale didattico e l'immagine. +Possono anche rivolgersi direttamente ai membri dell'organizzazione nel caso +in cui non sia chiaro chi contattare in delle discussioni riguardanti Rust. + +* Il [Team di moderazione][mod_team] assicura il rispetto del +[codice di condotta][coc]. + +* Il [Team di documentazione][doc_team] si assicura che Rust abbia + una documentazione fantastica. + +Oltre ai diversi team ufficiali, molti team hanno dei revisori che possono +verificare del codice. Se volessi entrare a far parte di uno di questi team +sentiti libero di incontrare un capogruppo o un qualsiasi altro membro in modo +che ti possa aiutare a partecipare. + +[teams]: team.html +[core_team]: team.html#Core-team +[language_team]: team.html#Language-design-team +[library_team]: team.html#Library-team +[compiler_team]: team.html#Compiler-team +[tool_team]: team.html#Tooling-and-infrastructure +[community_team]: team.html#Community-team +[mod_team]: team.html#Moderation-team +[doc_team]: team.html#Documentation-team + +## Sviluppo di Rust + +Rust ha avuto oltre [1'200 diversi sviluppatori][authors], un numero che cresce +di settimana in settimana. [Vorremmo che tu ti unissi a quella lista][contribute]! + +Come menzionato sopra, il [Forum Sviluppo][internals_forum] é dedicato alla discussione +sul design e implementazione di Rust. Molte discussioni avvengono anche su +GitHub: + +- Nel [repository principale][github] e nella [bacheca problemi][issue_tracking] + si svolge il lavoro principale di implementazione. I nostri revisori si impegnano + ad essere amichevoli e utili ai nuovi sviluppatori, quindi non esitare a mandare + una tua pull request! + +- Il [repository per le RFC][rfcs] traccia il nostro processo di Request for Comment, + il modo principale in cui la comunitá Rust e il team raggiungono il consenso + sulle nuove funzionalitá proposte per il linguaggio, le librerie ufficiali e gli strumenti. + +Circa settimanalmente, il team di Rust emana un [rapporto dei team][team_reports] +che indica su cosa sono impegnati i team, inclusa l'analisi delle RFC e il +processo di implementazione. + +[authors]: https://github.com/rust-lang/rust/blob/88397e092e01b6043b6f65772710dfe0e59056c5/AUTHORS.txt +[contribute]: contribute.html +[github]: https://github.com/rust-lang/rust +[rfcs]: https://github.com/rust-lang/rfcs +[team_reports]: https://github.com/rust-lang/subteams +[issue_tracking]: https://github.com/rust-lang/rust/issues diff --git a/it-IT/conduct.md b/it-IT/conduct.md new file mode 100644 index 000000000..1a80fb524 --- /dev/null +++ b/it-IT/conduct.md @@ -0,0 +1,40 @@ +--- +layout: it-IT/default +title: Il codice di comportamento di Rust · Il linguaggio di programmazione Rust +--- + +# Il codice di comportamento di Rust + +## Comportamento + +**Contatto**: [rust-mods@rust-lang.org](mailto:rust-mods@rust-lang.org) + +* Noi ci impegniamo a fornire un ambiente amichevole, sicuro e accomodante per tutti, a prescindere dal livello di esperienza, sesso, identitá ed espressione sessuale, orientamento sessuale, disabilitá, aspetto estetico, dimensione corporea, razza, etnia, etá, religione, nazionalitá o altre caratteristiche personali. +* Su IRC, evita di utilizzare pseudonimi troppo sessualizzanti o altri pseudonimi che potrebbero rovinare un ambiente amichevole, sicuro e accomodante per tutti. +* Sii gentile e servizievole. Non c'é alcun bisogno di essere cattivi o maleducati. +* Rispetta le persone che non la pensano come te e che ogni scelta di design o implementazione porta molti compromessi e cosi. C'é raramente una vera risposta giusta. +* Per favore limita al minimo la critica non costruttiva. Se hai delle idee valide con cui vuoi sperimentare, fai un fork del progetto e guarda come funziona. +* Ti impediremo di interagire se insulti, parodizzi o disturbi qualcuno. Quello non é un comportamento accettato. Con "disturbo" intendiamo la definizione che si puó trovare nel Citizen Code of Conduct; se hai qualche dubbio su cosa potrebbe essere incluso in tale concetto, per favore leggi la loro definizione. In particolare non tolleriamo comportamenti che escludono persone appartenenti a gruppi sociali emarginati. +* La molestia privata é anch'essa inaccettabile. Non interessa chi sei, se stai o sei stato molestato o reso a disagio da un membro della comunitá, per favore contatta uno dei moderatori o qualcuno dal [Team di moderazione](/team.html#Moderation) immediatamente. Che tu sia un frequentatore abituale o un nuovo arrivato, ci interessa rendere questa comunitá un posto sicuro per te. +* Ogni attivitá pubblicitaria, molesta, offensiva, volutamente provocatoria o ogni ricerca immotivata di attenzione non é benvenuta. + +## Moderazione + +Queste sono le politiche per mantenere fede al nostro codice di comportamento. Se pensi che una discussione abbia bisogno di moderazione, per favore contatta il [team di Moderazione](/team.html#Moderation). + +1. Frasi che violano gli standard del codice di comportamento di Rust, includendo frasi di odio, offensive, oppressive o emarginanti non sono ammesse. (Sono ammesse le imprecazioni ma non se rivolte a altri utenti o con finalitá di odio.) +2. Frasi che i moderatori giudicano come inappropriate e inaccettabili, anche se non in esplicita violazione del codice di comportamento. +3. I moderatori reagiranno alle frasi di cui sopra con un avvertimento iniziale. +4. Se l'avvertimento viene ignorato, l'utente riceverá un allontanamento temporaneo per calmarsi e riflettere. +5. Se l'utente ritorna e continua a essere problematico verrá allontanato permanentemente. +6. I moderatori hanno facoltá a loro discrezione di annullare l'allontanamento qualora l'utente sia alla sua prima violazione e offra una sincera scusa alla parte offesa. +7. Se un moderatore allontana qualcuno e tu non condividi la sua decisione, per favore parlane direttamente con lui o con un altro moderatoe, **in privato**. Le lamentele sui provvedimenti disciplinari non sono ammesse nei luoghi di discussione pubblica. +8. I moderatori sono impegnati a dare il buon esempio, qualora creassero una situazione inappropriata saranno soggetti a reazioni piú decise. + +Nella comunitá di Rust cerchiamo di andare oltre e di prenderci cura l'uno dell'altro, Non cercare solo di essere tecnicamente inattaccabile, cerca di tirare fuori il meglio che hai in te. In particolare evita di dare corda a discussioni offensive, specialmente se fuori argomento; questo troppo spesso conduce a combattimenti inutili, sentimenti offesi e orgoglio ferito. Inoltre puó condurre alcune persone ad abbandonare la comunitá per sempre. + +Se qualcuno si fa un problema per qualcosa che hai detto o fatto, resisti all'impulso di essere difensivo. Smetti di fare ció e scusati. Anche se ti senti incompreso o accusato ingiustamente, c'é una discreta possibilitá che tu non ti sia spiegato correttamente - ricordati che é una tua responsabilitá di far sentire gli altri Rustacchiani a loro agio. Tutti vogliono stare insieme e siamo qui in primo luogo perché vogliamo parlare di alta tecnologia. Troverai persone pronte a perdonarti e prenderti in buona fede se otterrai la loro fiducia. + +Le politiche di cui sopra si applicano a tutti i luoghi ufficiali di Rust; includendo i canali IRC ufficiali(#rust, #rust-internals, #rust-tools, #rust-libs, #rustc, #rust-beginners, #rust-docs, #rust-community, #rust-lang, and #cargo); i repositories GitHub sotto rust-lang, rust-lang-nursery e rust-lang-deprecated; tutti i forum di rust-lang.org(sers.rust-lang.org, internals.rust-lang.org). Qualora un altro progetto volesse adottare il codice di comportamento di Rust, per favore contatti uno sviluppatore di questi progetti per assistenza. Se volessi usare questo codice di comportamento per il tuo progetto personale ti suggeriamo di menzionare esplicitamente la tua politica di moderazione o di fare una copia includendo la tua politica di moderazione per evitare confusione. + +*Adattato e tradotto dall'inglese dalla [politica di Node.js sul trolling](http://blog.izs.me/post/30036893703/policy-on-trolling) e da [Contributor Covenant v1.3.0](http://contributor-covenant.org/version/1/3/0/).* \ No newline at end of file diff --git a/it-IT/contribute-bugs.md b/it-IT/contribute-bugs.md new file mode 100644 index 000000000..a7af376a1 --- /dev/null +++ b/it-IT/contribute-bugs.md @@ -0,0 +1,72 @@ +--- +layout: it-IT/default +title: Contribuire a Rust — trovare, analizzare e risolvere problemi · Linguaggio di programmazione Rust +--- + +# Contribuire a Rust — trovare, analizzare e risolvere problemi + +La manutenzione giorno per giorno del progetto ruota attorno al +[controllo bug][issue tracker] e alle [richieste di unione][PR], +una mano in piú é sempre richiesta. +Il modo piú semplice per iniziare a contribuire a Rust é guardare +i bug caratterizzati dalle etichette [E-easy] o [E-mentor]. +Questi bug sono stati raccolti con la finalitá di essere accessibili +anche per i programmatori di Rust alla loro prima contribuzione. + +Nelle problematiche identificate da `E-mentor` uno sviluppatore di Rust +esperto si offre volontario di aiutarti nella risoluzione del problema e +a [spedire le tue modifiche con una richiesta di unione su GitHub][pull]. +Potrai contattarlo per discutere del problema direttamente dalla pagina +di controllo bug [@menzionando][@mentioning] il suo nome in un commento, +su IRC o tramite email. Nota che ricevendo molte notifiche gli sviluppatori +Rust potrebbero non vedere il tuo messaggio; non esitare quindi a cercarli +di contattarli a tutti i costi! + +Molti altri progetti in Rust mantengono una lista simile di problematiche +facili, includendo il browser web [Servo], la libreria [hyper], il suggeritore +di sintassi [rustfmt], la libreria di supporto a Unix[nix] e la collezione +di aiuti automatici alla programmazione [clippy]. + +Anche se Rust possiede una [comprensiva suite di prova][test] c'é +sempre di piú da controllare. +I problemi classificati come [E-needstest] indicano le problematiche +che si pensano risolte ma non possiedono ancora delle verifiche automatiche. +Scrivere queste verifiche é un ottimo modo per comprendere un nuovo progetto +e per iniziare a contribuire ad esso. + +Rust é continuamente alla ricerca di persone che [analizzino][triage] problemi: +riprodurli, ridurre la suite di prove automatiche, applicare etichette, chiudere +i problemi risolti. +Nota che per applicare etichette é richiesta un'autorizzazione elevata su GitHub +facilmente ottenibile per coloro che hanno un po' di esperienza con il progetto. +Chiedi a un [membro del team][team]. + +Una volta orientato nel progetto e create una serie di richieste di unione +in una particolare area, considera di iniziare a visionare le richieste altrui: +la capacitá di saper valutare il codice altrui é un'abilitá rara e sempre +apprezzata. Non é richiesta alcuna autorizzazione — inizia semplicemente +a commentare gentilmente e costruttivamente sulle richieste di unione che ti interessano. +Se vuoi piú informazioni su come fare una buona valutazione del codice altrui +segui [questa guida][reviews]. + + + +[@mentioning]: https://github.com/blog/821 +[E-easy]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy +[E-mentor]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy+label%3AE-mentor +[E-needstest]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-needstest +[PR]: https://github.com/rust-lang/rust/pulls +[Servo]: https://github.com/servo/servo +[clippy]: https://github.com/Manishearth/rust-clippy +[hyper]: https://github.com/hyperium/hyper +[issue tracker]: https://github.com/rust-lang/rust/issues +[nix]: https://github.com/nix-rust/nix/ +[pull]: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#pull-requests +[reviews]: http://blog.originate.com/blog/2014/09/29/effective-code-reviews/ +[rustfmt]: https://github.com/rust-lang-nursery/rustfmt +[team]: team.html +[test]: https://github.com/rust-lang/rust-wiki-backup/blob/master/Note-testsuite.md +[triage]: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#issue-triage diff --git a/it-IT/contribute-community.md b/it-IT/contribute-community.md new file mode 100644 index 000000000..2e154b89c --- /dev/null +++ b/it-IT/contribute-community.md @@ -0,0 +1,88 @@ +--- +layout: it-IT/default +title: Contribuire a Rust — creazione di una comunitá · Linguaggio di programmazione Rust +--- + +# Contribuire a Rust — creazione di una comunitá + +Aiuta i novizi, spargi la voce, incontra persone interessanti. +Rendi Rust un esempio brillante di sviluppo open source nel +modo in cui tutti noi desideriamo che sia. + +Controlla il canale [#rust-beginners]. +Qui é dove dirigiamo i nuovi programmatori Rust per chiedere aiuto, +é quindi vitale che quando succede, venga impartita una risposta +rapida, accurata e gentile. +Similarmente su [Stack Overflow], [users.rust-lang.org] e [/r/rust], +dove i programmatori generalmente richiedono assistenza. +Se vuoi un aiuto su come rispondere a domande di programmazione +[consulta questa guida][helpful]. + +Se sei giá esperto in qualche area del progetto, per favore controlla +per dei potenziali problemi marcati come [E-easy]. +Quando vedi un problema di cui conosci la soluzione, scrivi una descrizione +della tua idea e apponi l'etichetta E-easy. +Nota che quello che potrebbe apparirti come ovvio potrebbe non esserlo +per nuovo sviluppatore Rust, é quindi importante descrivere chiaramente +il problema e la soluzione. +Questo risulta utile anche per analizzare i problemi etichettati come E-easy +dotati di descrizioni incomplete per migliorarli. + +Gli sviluppatori esperti che sono pazienti e riescono a comunicare chiaramente +dovrebbero considerare [di seguire i nuovi arrivati][mentor]. +Etichetta problemi semplici con [E-mentor] e menziona nei commenti che +seguirai gli altri, poi attendi di essere contattato dagli utenti +riguardo al problema e cerca di rispondere prontamente. + +Manutenere piccoli impegni non solo fa bene al progetto Rust ma +anche al suo ecosistema. +Se un progetto ha un flusso costante di piccoli impegni potresti considerare +di adottare una soluzione simile anche tu. +***Questa attivitá di manutenzione é uno dei modi piú efficaci per portare +nuovi sviluppatori al progetto***. Se hai bisogno di aiuto su come +assistere i nuovi utenti [leggi questa guida][mentor-guide]. + +Parla di ció a cui stai lavorando nella rubrica settimanale +"what's everyone working on this week" su [/r/rust] e [users.rust-lang.org] e +indica di cosa hai bisogno. +Questi sono degli ottimi punti di partenza per collaborare. + +Diffondi Rust nella tua comunitá locale. I [gruppi utenti][user groups] Rust e +gli [eventi][events] sono una componente unica ed eccitante dell'esperienza Rust: +sono tantissimi e sono ovunque! +Se non ci sei ancora stato, vai e goditi delle nuove esperienze. +Se non c'é niente riguardante Rust attorno a te, puoi anche considerare di +organizzare qualcosa. Puoi verificare l'interesse e annunciare gli eventi +su [/r/rust] o [users.rust-lang.org]. Contatta il [team della comunitá][community team] +per inserire il tuo evento nel calendario che verrá annunciato anche su +[Questa Settimana In Rust][This Week in Rust]. + +Ricordati mentre pubblicizzi Rust di tenere in conto le idee altrui — +non tutti saranno colpiti da Rust e va bene cosí. + +Incontra alti creatori di comunitá Rust su [#rust-community]. + + + +[#rust-beginners]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-beginners +[#rust-community]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-community +[/r/rust]: https://reddit.com/r/rust +[E-easy]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy +[E-mentor]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AE-easy+label%3AE-mentor +[Stack Overflow]: https://stackoverflow.com/questions/tagged/rust +[This Week in Rust]: https://this-week-in-rust.org +[community team]: it-IT/team.html#Community +[events]: https://www.google.com/calendar/embed?src=apd9vmbc22egenmtu5l6c5jbfc@group.calendar.google.com +[helpful]: https://codeblog.jonskeet.uk/2009/02/17/answering-technical-questions-helpfully/ +[mentor]: https://users.rust-lang.org/t/mentoring-newcomers-to-the-rust-ecosystem/3088 +[mentor-guide]: https://manishearth.github.io/blog/2016/01/03/making-your-open-source-project-newcomer-friendly/ +[user groups]: user-groups.html +[users.rust-lang.org]: https://users.rust-lang.org diff --git a/it-IT/contribute-compiler.md b/it-IT/contribute-compiler.md new file mode 100644 index 000000000..8f4d06558 --- /dev/null +++ b/it-IT/contribute-compiler.md @@ -0,0 +1,112 @@ +--- +layout: it-IT/default +title: Contribuire a Rust — linguaggio, compilatore e la libreria standard · Linguaggio di programmazione Rust +--- + +# Contribuire a Rust — linguaggio, compilatore e la libreria standard + +Il sorgente della libreria standard e del compilatore sono nel repository principale +ed essendo la loro manutenzione uno degli obiettivi primari di quel repository +la maggior parte dei problemi riportati nel tracciatore delle problematiche li riguardano. +Alcune tra le etichette interessanti includono [A-codegen] per la traduzione di Rust in +rappresentazione intermedia LLVM; [A-debuginfo], la generazione di metadati utilizzata +per la risoluzione dei problemi; [A-diagnostics] per gli errori mostrati dal compilatore; +[A-libs] per i problemi con la libreria standard; [A-macros] e [A-syntaxext], entrambi +dedicati all'espansione della sintassi e [A-typesystem] per parlare dei tipi. + +Non esiste alcuna guida ben mantenuta all'architettura del compilatore +ma ne [esiste una piccola carrellata nel repository principale][rustc-guide]. +La [documentazione delle API che compongono il compilatore][internals-docs] +possono aiutarti a navigare il codice, come puó farlo anche il navigatore di codice +[Rust DXR]. La [guida per Rust e la sua piattaforma di controllo][testsuite] +ti insegnerá come utilizzare al meglio il sistema di compilazione di Rust, +come farebbe anche il comando [`make tips`][tips] da riga di comando. + +Per il futuro prossimo, una delle maggiori spinte per il compilatore Rust +é convertire le sue componenti interne per lavorare direttamente dall'Albero +di Sintassi Astratto, per elaborare su una [rappresentazione intermedia chiamata MIR][mir]. +Questo lavoro si preannuncia come l'inizio di molte nuove possibilitá +per semplificare il compilatore ed é richiesto dell'aiuto per esempio +creare una fase di traduzione basata su MIR, ottimizzare la MIR e implementare +la compilazione incrementale. +Non esiste una fonte unica per informazioni sul lavoro richiesto ma chiedi +su [internals.rust-lang.org] o su +[#rust-internals] per ulteriori informazioni. + +[É imbarazzante se il nostro compilatore si blocca][ice] — il +nefasto 'errore interno di compilazione' ('internal compiler error' ICE). +L'etichetta [I-ICE] tiene traccia di questi problemi e spesso sono molti. +Questi sono usualmente degli ottimi problemi per iniziare a contribuire +perché é facile comprendere quando vengono riparati e sono relativamente +isolati dal resto del codice. + +Le prestazioni di Rust é uno dei suoi piú grossi vantaggi; e quella +del suo compilatore é uno dei suoi piú grossi problemi. +Ogni miglioramento della prestazione degli eseguibili or — specialmente — +delle prestazioni del compilatore sono largamente celebrati. +Le etichette [I-slow] e [A-optimization] si occupano delle prestazioni +degli eseguibili e [I-compiletime] di quella del compilatore. Abbiamo un +[sito che tiene traccia delle prestazioni del compilatore][rustc-perf] +durante alcuni carichi di lavoro. +L'opzione da riga di comando `-Z time-passes` puó aiutare a ispezionare +le prestazioni del compilatore e il codice di Rust puó essere profilato +da tutti i profilatori standard come `perf` su Linux. + +Funzionalitá importanti passano attraverso il processo di [Request for Comments (RFC)][rfc] +dal quale ci si accorda sul design. Anche se aperto a tutti é un'interazione tra +sviluppatori che giá hanno un discreto quantitivo di esperienza in comune ed é +consigliato prendere parte al processo lentamente — +inviare una RFC ostica senza comprendere il contesto storico, tecnico o sociale +é un modo facile per dare una cattiva impressione e andarsene delusi. +Leggi il collegamento sopra per comprendere al meglio come tutto il sistema funziona. +Molte idee sono giá state discusse durante il passato di Rust, alcune sono state +rifiutate, altre rimandate al futuro e la [portale delle RFC][rfc-issues] +elenca alcune idee desiderate che non sono ancora riuscite a entrare +nel linguaggio. +Poco prima che una RFC venga accettata per l'implementazione, entra in +una 'fase finale di commento' indicata dall'etichetta +[final-comment-period sul repository rust-lang/rfcs][rfc-fcp]. +Similarmente, prima che una funzionalitá venga abilitata nel compilatore +stabile (procedura definita 'ungating') essa entra nella [final-comment-period sul repository rust-lang/rust][issue-fcp]. +Entrambe le fasi di commento finale sono momenti critici per essere coinvolti +ed esprimere opinioni sulla direzione del linguaggio e sono indicate +nei report settimanali dei vari gruppi di lavoro su [internals.rust-lang.org]. + +Incontra altri progettisti di compilatori su [#rustc], progettisti del linguaggio +su [#rust-lang] e progettisti di librerie su [#rust-libs]. + + + + +[#rust-internals]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-internals +[#rust-lang]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-lang +[#rust-libs]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-libs +[#rustc]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rustc +[A-codegen]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-codegen +[A-debuginfo]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-debuginfo +[A-diagnostics]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-diagnostics +[A-libs]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-libs +[A-macros]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-macros +[A-optimization]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-optimization +[A-syntaxext]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-syntaxext +[A-typesystem]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-typesystem +[I-ICE]: https://github.com/rust-lang/rust/labels/I-ICE +[I-compiletime]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AI-compiletime +[I-slow]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AI-slow +[Rust DXR]: https://dxr.mozilla.org/rust/source/src +[ice]: https://users.rust-lang.org/t/glacier-a-big-ol-pile-of-ice/3380 +[internals-docs]: https://manishearth.github.io/rust-internals-docs +[internals.rust-lang.org]: https://internals.rust-lang.org/ +[issue-fcp]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AB-unstable+label%3Afinal-comment-period +[mir]: https://github.com/rust-lang/rust/issues/27840 +[rfc-fcp]: https://github.com/rust-lang/rfcs/pulls?q=is%3Aopen+is%3Apr+label%3Afinal-comment-period +[rfc-issues]: https://github.com/rust-lang/rfcs/issues +[rfc]: https://github.com/rust-lang/rfcs#table-of-contents +[rustc-guide]: https://github.com/rust-lang/rust/blob/master/src/librustc/README.md +[rustc-perf]: http://ncameron.org/perf-rustc/ +[testsuite]: https://github.com/rust-lang/rust-wiki-backup/blob/master/Note-testsuite.md +[tips]: https://github.com/rust-lang/rust/blob/3d1f3c9d389d46607ae28c51cc94c1f43d65f3f9/Makefile.in#L48 diff --git a/it-IT/contribute-docs.md b/it-IT/contribute-docs.md new file mode 100644 index 000000000..df086cd62 --- /dev/null +++ b/it-IT/contribute-docs.md @@ -0,0 +1,70 @@ +--- +layout: it-IT/default +title: Contribuire a Rust — documentazione · Linguaggio di programmazione Rust +--- + +# Contribuire a Rust — documentazione + +La documentazione non é mai abbastanza buona e non ce n'é mai troppa. +Molti aspetti della documentazione di Rust non richiedono una profonda conoscenza +per essere migliorati, scritti, corretti o modificati, inoltre modificare la documentazione +é un ottimo modo per imparare Rust. +Ulteriormente i miglioramenti sono semplici da identificare e potenzialmente infiniti: +non ti piace come suona una frase? Hai scoperto qualcosa che nella documentazione non é presente? +La tua richiesta di modifica verrá calorosamente accolta. + +***La documentazione piú importante che tu possa scrivere é per [i pacchetti +che fanno parte dell'ecosistema di Rust][crate_docs]***. +Mentre la documentazione principale é relativamente esaustiva, ció non é vero +per [molti pacchetti e strumenti popolari][awesome-rust] con cui gli sviluppatori +Rust interagiscono ogni giorno. +Contribuire alla documentazione delle API per un progetto popolare ti garantirá +l'amore da parte dello sviluppatore del progetto. + +[Il libro][The Book] é la documentazione base per Rust, +scritto nel repository principale. +Possiede anche la sua etichetta per le problematiche, [A-book] ed +é continuamente in miglioramento. +Ulteriore documentazione nel repository principale include [il riferimento di Rust][The Rust Reference], +la [documentazione della libreria standard][std], [Il Rustonomico][The Rustonomicon] (un guida su come usare `unsafe` +correttamente). Le [guide di stile di Rust][Rust Style Guidelines] sono cosí incomplete che non vengono elencate spesso; +uno sviluppatore ambizioso puó sicuramente fare molta strada contribuendo lí. +L'[indice degli errori][err] fornisce spiegazioni dettagliate agli errori del compilatore. +Quando vengono aggiunti nuovi errori, essi devono essere [inclusi nella documentazione][err-issue], quindi ci sono +sempre errori non presenti ancora ma con la necessitá di essere aggiunti. +La maggior parte della documentazione nel repository principale risiede nella cartella [src/doc]. +Tutti i problemi di documentazione sono sotto all'etichetta [A-docs] sul portale delle problematiche. +Finalmente questo documento e altri correlati con il sito web sono mantenuti nel [repository Git del sito][Rust website Git repository]. +Per contribuire modificalo e manda una pull request. + +Una buona quantitá di documentazione importante per Rust non si trova +nel repository principale o non é mantenuta dal progetto Rust ma é +comunque importantissima per il successo di Rust. +Esempi di documentazione eccellente sotto attivo sviluppo con domanda +per altri sviluppatori includono [Rust By Example], [Rust Design Patterns] e [rust-rosetta]. +Per altri progetti di documentazione esistenti a cui contribuire vedi [rust-learning]. + +Incontra altri documentatori su [#rust-docs]. + + + +[#rust-docs]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-docs +[A-book]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-book +[A-docs]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-docs +[Rust By Example]: https://github.com/rust-lang/rust-by-example +[Rust Design Patterns]: https://github.com/nrc/patterns +[Rust Style Guidelines]: https://doc.rust-lang.org/style/index.html +[The Book]: https://doc.rust-lang.org/book/index.html +[The Rust Reference]: https://doc.rust-lang.org/reference.html +[The Rustonomicon]: https://doc.rust-lang.org/nomicon/index.html +[awesome-rust]: https://github.com/kud1ing/awesome-rust +[crate_docs]: https://users.rust-lang.org/t/lets-talk-about-ecosystem-documentation/2791 +[err-issue]: https://github.com/rust-lang/rust/issues/24407 +[err]: https://doc.rust-lang.org/error-index.html +[rust-learning]: https://github.com/ctjhoa/rust-learning +[rust-rosetta]: https://github.com/Hoverbear/rust-rosetta +[src/doc]: https://github.com/rust-lang/rust/tree/master/src/doc +[std]: https://doc.rust-lang.org/std/index.html +[Rust website Git repository]: https://github.com/rust-lang/rust-www diff --git a/it-IT/contribute-libs.md b/it-IT/contribute-libs.md new file mode 100644 index 000000000..ad698019b --- /dev/null +++ b/it-IT/contribute-libs.md @@ -0,0 +1,63 @@ +--- +layout: it-IT/default +title: Contribuire a Rust — librerie · Linguaggio di programmazione Rust +--- + +# Contribuire a Rust — librerie + +Se vuoi contribuire a Rust scrivendo molto codice, +le librerie sono il modo per farlo: visto che Rust é ancora +un linguaggio giovane, ci sono ancora molti tipi di librerie che +o non esistono ancora o sono incompleti e necessitano di miglioramenti o competizione. + +Decidere cosa scrivere per avere un impatto ed essere divertenti sono due difficoltá comuni. +Ecco alcune idee: +* Leggi e partecipa ai "what's everyone working on this week" su [/r/rust] + e [users.rust-lang.org]. Questi forum sono pieni di annunci emozionanti + da parte di altri sviluppatori in cerca di aiuto. +* Familiarizza con le migliori librerie Rust con + [awesome-rust] e [libs.rs]. +* Alcuni progetti grandi, incluso il browser web [Servo], la libreria HTTP [hyper], + il suggeritore di sintassi [rustfmt], la libreria di integrazione con Unix[nix] e + il suggeritore automatico [clippy], includono delle problematiche identificate + come 'easy' specifiche per i nuovi sviluppatori. +* Fatti coinvolgere in una delle organizzazioni Rust-centriche su GitHub + tipo [PistonDevelopers], [servo], [redox-os], + [iron], [contain-rs], [hyperium]. Spesso é piú facile ricavarsi un posto + in queste comunitá, che hanno ancora piú bisogno di rust-lang stesso. + Sono anche piene di sviluppatori Rust esperti che possono aiutarti. +* Aiuta il passaggio delle librerie da [rust-lang-nursery] a rust-lang. + Sfortunatamente non vi é ancora molta documentazione su cosa sia necessario fare. + Puoi comunque chiedere su [#rust-libs]. +* Ispeziona le RFC di una [libreria richiesta dalla community][requested] e creala. +* Guarda [ció che é in voga su Github][trending] per vedere altri progetti Rust attivi. + +Come autore di librerie potresti desiderare di essere a conoscenza dei +[migliori consigli su come implementare una libreria Rust][lib-prac]. + +Incontrati con gli altri progettisti di librerie su [#rust-libs]. + + + +[#rust-libs]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-libs +[/r/rust]: https://reddit.com/r/rust +[PistonDevelopers]: https://github.com/PistonDevelopers +[Servo]: https://github.com/servo/servo +[Servo]: https://github.com/servo/servo +[awesome-rust]: https://github.com/kud1ing/awesome-rust +[clippy]: https://github.com/Manishearth/rust-clippy +[contain-rs]: https://github.com/contain-rs +[hyper]: https://github.com/hyperium/hyper +[hyperium]: https://github.com/hyperium +[iron]: https://github.com/iron +[lib-prac]: https://pascalhertleif.de/artikel/good-practices-for-writing-rust-libraries/ +[libs.rs]: http://libs.rs +[nix]: https://github.com/nix-rust/nix/ +[redox-os]: https://github.com/redox-os +[requested]: https://github.com/rust-lang/rfcs/labels/A-community-library +[rust-lang-nursery]: https://github.com/rust-lang-nursery +[rustfmt]: https://github.com/rust-lang-nursery/rustfmt +[trending]: https://github.com/trending?l=rust +[users.rust-lang.org]: https://users.rust-lang.org diff --git a/it-IT/contribute-tools.md b/it-IT/contribute-tools.md new file mode 100644 index 000000000..d98eef8a3 --- /dev/null +++ b/it-IT/contribute-tools.md @@ -0,0 +1,48 @@ +--- +layout: it-IT/default +title: Contribuire a Rust — strumenti, ambienti di sviluppo e infrastrutture · Linguaggio di programmazione Rust +--- + +# Contribuire a Rust — strumenti, ambienti di sviluppo e infrastrutture + +Gli strumenti giocano una parte fondamentale nel successo di un linguaggio +e rimangono ancora molte cose da implementare. +***Al momento buona parte dello sviluppo in questa area di Rust si concentra +sul [migliorare l'esperienza con gli ambienti di sviluppo][ides]***. +Questo richiede impegno da parte di tutto l'ecosistema Rust, dal compilatore +stesso fino al tuo ambiente di sviluppo preferito. +Segui il link per saperne di piú. + +Sia Cargo, il gestore di pacchetti di Rust e rustdoc +il generatore di documentazione per Rust, sebbene +siano in possesso di tutte le funzioni richieste e +validamente funzionanti, soffrono di una carenza di sviluppatori. +Rustdoc ha molte problematiche aperte sotto l'etichetta +[A-rustdoc] del repository principale. +Queste problematiche sono principalmente composte da +errori e contribuire é semplicmente una questione di +risolverli e inviare una richiesta di unione. +Cargo, possiede [il suo personale repository con relativi problemi][Cargo], +coloro fossero interessati a contribuire possono anche presentarsi +nel canale IRC [#cargo]. + +Anche se Rust funziona sia con il debugger gdb che in lldb con discreti +risultati, ci sono ancora molti casi in cui la risoluzione di problemi +non funziona come previsto. L'etichetta [A-debuginfo] segue proprio +questi problemi. + +Per idee su altri strumenti a cui contribuire vedi +[awesome-rust]. + +Ci sono spesso altri progetti interessanti di strumenti in attesa +giusto di persone che possano venire ad implementarli. +Vieni a discuterne con gli altri appassionati di questo aspetto di +Rust su [#rust-tools]. + +[#cargo]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rustc +[#rust-tools]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-tools +[A-debuginfo]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-debuginfo +[A-rustdoc]: https://github.com/rust-lang/rust/issues?q=is%3Aopen+is%3Aissue+label%3AA-rustdoc +[Cargo]: https://github.com/rust-lang/cargo/issues +[awesome-rust]: https://github.com/kud1ing/awesome-rust +[ides]: https://forge.rust-lang.org/ides.html diff --git a/it-IT/contribute-translations.md b/it-IT/contribute-translations.md new file mode 100644 index 000000000..878a863ef --- /dev/null +++ b/it-IT/contribute-translations.md @@ -0,0 +1,8 @@ +--- +layout: it-IT/default +title: Tradurre rust-lang.org in altri linguaggi per adottare l'internazionalizzazione +--- + +# Rust é universale + +Manca la documentazione su come contribuire a tradurre! diff --git a/it-IT/contribute.md b/it-IT/contribute.md new file mode 100644 index 000000000..3e06c74a3 --- /dev/null +++ b/it-IT/contribute.md @@ -0,0 +1,62 @@ +--- +layout: it-IT/default +title: Contribuire a Rust · Linguaggio di programmazione Rust +--- + +# Contribuire a Rust + +Una volta iniziato a imparare Rust. Lo amerai e vorrai divenire parte di esso. +Se non sei sicuro su come essere coinvolto, questa pagina ti aiuterá. + +**Trovato un problema e vuoi notificarlo?** [segui la guida su come riportare i problemi][bugs]. Grazie in anticipo! + +Rust é un espanso sistema di progetti, in cui i piú prominenti di questions +sono mantenuti dagli [sviluppatori del progetto Rust][devs] nella [organizzazione +rust-lang su GitHub][rust-lang]. +I nuovi arrivati potrebbero essere interessati al file [CONTRIBUTING.md] +che illustra le meccaniche con cui contribuire a [rust-lang/rust]. + +Ci sono molti modi per contribuire al successo di Rust. +Questa guida indica alcune strade per i nuovi arrivati: + +* [Trovare, gestire e risolvere problematiche](contribute-bugs.html). Il + lavoro base per mantenere un progetto grande e attivo come Rust +* [Documentazione](contribute-docs.html). Non solo + documentazione ufficiale ma anche per pacchetti, post sul blog + e altre fonti non ufficiali. +* [Creazione di comunitá](contribute-community.html). Aiutare gli altri + Rustacchiani e espandendo le frontiere di Rust. +* [Strumenti, ambienti di sviluppo e infrastrutture](contribute-tools.html). Gli + importanti pezzi che rendono un linguaggio pratico e piacevole. +* [Librerie](contribute-libs.html). L'idoneitá di Rust a un compito + é subordinata alla presenza di librerie di alta qualitá. +* [Liguaggio, compilatore e la libreria + standard](contribute-compiler.html). Design del linguaggio, implementazione + funzionalitá, ottimizzazioni. +* [Internazionalizzazione](contribute-translations.html). Aiuta a spargere + l'amore per Rust traducendo il nostro sito in altre lingue. + +Se hai bisogno di ulteriore aiuto chiedi su [#rust-internals] o su +[internals.rust-lang.org]. + +Siamo orgogliosi di mantenere discussioni civili e con questo scopo +i nostri sviluppatori sono tenuti a seguire il [codice di comportamento][coc]. +If hai delle domande a questo proposito per favore parlane con il [Team comunitá][community team]. + + + +[#rust-internals]: https://client00.chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust-internals +[CONTRIBUTING.md]: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md +[bugs]: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#bug-reports +[coc]: https://www.rust-lang.org/it-IT/conduct.html +[community team]: https://www.rust-lang.org/team.html#Community +[dev_proc]: community.html#rust-development +[devs]: https://github.com/rust-lang/rust/graphs/contributors +[internals.rust-lang.org]: https://internals.rust-lang.org/ +[rust-lang/rust]: https://github.com/rust-lang/rust +[rust-lang]: https://github.com/rust-lang diff --git a/it-IT/documentation.md b/it-IT/documentation.md new file mode 100644 index 000000000..f1faa8fe2 --- /dev/null +++ b/it-IT/documentation.md @@ -0,0 +1,101 @@ +--- +layout: it-IT/default +title: Documentazione di Rust · Linguaggio di programmazione Rust +--- + +# Documentazione di Rust + +Se non hai proprio mai visto Rust, la prima cosa che dovresti leggere +é l'introduzione del [Libro di Rust][book]. +Ti dará una buona idea di com'é Rust, ti mostrerá come installarlo, +illustrando anche la sua sintassi e i suoi concetti. +Una volta letto sarai uno sviluppatore Rust discreto e avrai una +buona idea dei concetti fondamentali di Rust. + +## Imparare Rust + +[Il Libro di Rust][book]. Conosciuto anche come "Il libro", +é la risorsa piú completa per tutti gli argomenti correlati a Rust e +rappresenta il documento primario ufficiale del linguaggio. + +[Rust per Esempi][rbe]. Una collezione di diversi problemi indipendenti +commentati e eseguibili dal browser. + +[Domande Frequenti][faq]. + +[Il Rustonomicon][nomicon]. +Un intero libro dedicato a scrivere codice Rust insicuro. +Dedicato ai programmatori Rust esperti. + +[rust-learning]. Una risorsa fornita dalla comunitá di fonti dove imparare Rust. + +[book]: https://doc.rust-lang.org/book/ +[rbe]: http://rustbyexample.com +[faq]: faq.html +[nomicon]: https://doc.rust-lang.org/nomicon/ +[rust-learning]: https://github.com/ctjhoa/rust-learning + +## Riferimenti + +[Riferimento della libreria standard][api]. Documentazione sull'utilizzo della libreria standard. + +[docs.rs]. Documentazione per i pacchetti rilasciati su [crates.io]. + +[Riferimento del linguaggio Rust][ref]. +Anche se Rust non ha una specifica, il riferimento +prova a spiegare il suo funzionamento nel dettaglio. +Spesso non é aggiornato. + +[Indice sintassi][syn]. +Questa appendice del Libro di Rust contiene esempi di tutte +le sintassi menzionate nel libro, descrivendole. + +[La guida di Cargo][cargo]. La documentazione di Cargo, +il gestore di pacchetti di Rust. + +[Indice errori compilatore][err]. Spiegazioni dettagliate agli +errori emessi dal compilatore Rust. + +[Note di rilascio][release_notes]. Un archivio delle modifiche apportate in ciascuna versione. + +[api]: https://doc.rust-lang.org/std/ +[syn]: https://doc.rust-lang.org/book/syntax-index.html +[ref]: https://doc.rust-lang.org/reference.html +[cargo]: http://doc.crates.io/guide.html +[err]: https://doc.rust-lang.org/error-index.html +[release_notes]: https://github.com/rust-lang/rust/blob/stable/RELEASES.md +[docs.rs]: https://docs.rs +[crates.io]: https://crates.io + +## Politiche del progetto + +[Politica rilascio vulnerabilitá][security]. Le politiche del progetto +per notificare, risolvere e rivelare problematiche di sicurezza. + +[Diritti sul nome e marchio di Rust][legal]. I diritti di Rust +appartengono agli sviluppatori del Progetto Rust, i suoi marchi +sono proprietá di Mozilla. Nel collegamento si possono trovare le +norme di utilizzo. + +[Codice di comportamento][coc]. Si applica all' organizzazione rust-lang +su GitHub, i forum ufficiali, i canali IRC e in diversi angoli del mondo di Rust. + +[security]: security.html +[legal]: legal.html +[coc]: https://www.rust-lang.org/it-IT/conduct.html + +## Documentazione versioni nightly e beta + +La maggior parte della documentazione ufficiale di Rust é disponibile +anche per le versioni [nightly] e [beta], in aggiunta alla documentazione +menzionata sopra. + +[nightly]: https://doc.rust-lang.org/nightly/ +[beta]: https://doc.rust-lang.org/beta/ + +## Risorse non inglesi + +Per risorse non in lingua inglese +[risorse in lingua su rust-learning][locale]. + +[locale]: https://github.com/ctjhoa/rust-learning#locale-links diff --git a/it-IT/downloads.html b/it-IT/downloads.html new file mode 100644 index 000000000..0f3bde88d --- /dev/null +++ b/it-IT/downloads.html @@ -0,0 +1,5 @@ + + + + + diff --git a/it-IT/faq.md b/it-IT/faq.md new file mode 100644 index 000000000..916232229 --- /dev/null +++ b/it-IT/faq.md @@ -0,0 +1,1891 @@ +--- +layout: it-IT/basic +title: Domande Frequenti · Linguaggio di programmazione Rust +--- + +# Domande Frequenti + +

+Questa pagina esiste per rispondere a domande comuni inerenti il linguaggio di programmazione Rust. +Non rappresenta una guida completa al linguaggio e nemmeno uno strumento per insegnarlo. +Costituisce invece un riferimento per rispondere alle domande piú frequenti concernenti le scelte di progettazione dietro a Rust. +

+ +

+Se c'é una domanda comune o importante che pensi sia ingiustamente non inclusa qui, sentiti libero di aiutarci ad aggiungerla. +

+ +
+

Indice

+
+
    +
  1. Il progetto Rust
  2. +
  3. Prestazione
  4. +
  5. Sintassi
  6. +
  7. Numeri
  8. +
  9. Strings
  10. +
  11. Collezioni
  12. +
  13. Possesso
  14. +
  15. Campo di esistenza
  16. +
  17. Generici
  18. +
  19. Input / Output
  20. +
  21. Gestione Errori
  22. +
  23. Concorrenza
  24. +
  25. Macro
  26. +
  27. Debugging e Strumentazione
  28. +
  29. Basso Livello
  30. +
  31. Multipiattaforma
  32. +
  33. Moduli e Pacchetti
  34. +
  35. Librerie
  36. +
  37. Paradigmi di progettazione
  38. +
  39. Altri Linguaggi
  40. +
  41. Documentazione
  42. +
+
+
+ + +

Il progetto Rust

+ +

+Qual'é lo scopo del progetto? +

+ +Progettare e implementare un linguaggio sicuro, concorrente e pratico per la programmazione di sistemi. + +Rust nasce perché altri linguaggi a questo livello di astrazione e efficienza non sono soddisfacenti. In particolare: + +1. Non viene posta la dovuta attenzione alla sicurezza. +2. Supportano malamente la concorrenza. +3. Vi é una carenza di ergonomia. +4. Offrono un controllo limitato delle risorse. + +Rust esiste come un'alternativa che fornisce sia codice efficiente che un livello confortevole di astrazione, contemporaneamente migliorando tutti questi quattro punti. +

+Questo progetto é controllato da Mozilla? +

+No. Rust é iniziato come un progetto hobbystico da parte di Graydon Hoare nel 2006 ed é rimasto cosí per oltre 3 anni. La Mozilla é entrata nel 2009, dopo che il linguaggio si é dimostrato abbastanza maturo per eseguire una serie di basici test automatizzati e dimostrare la valenza dei suoi principi base. Anche se sponsorizzato da Mozilla, Rust é un progetto sviluppato da +una variegata comunitá di appassionati da molti paesi del mondo. Il [Team di Rust](team.html) é composto sia da membri Mozilla che da esterni e `rust` su GitHub ha avuto oltre [1,500 sviluppatori diversi](https://github.com/rust-lang/rust/) fino ad oggi. + +Finché concesso [dalla politica di gestione del progetto](https://github.com/rust-lang/rfcs/blob/master/text/1068-rust-governance.md), Rust é amministrato da un team base che imposta +la visione e le prioritá del progetto, guidandolo globalmente. +Esistono anche dei sottogruppi per guidare e incoraggiare lo sviluppo in alcune aree di interesse, inclusi il linguaggio, il compilatore, le librerie, gli strumenti, la moderazione delle comunitá ufficiali. +La progettazione é guidata da un processo [RFC](https://github.com/rust-lang/rfcs). +Per cambiamenti che non richiedono una RFC, le decisioni sono fatte attraverso richieste di unione sul [repository `rustc`](https://github.com/rust-lang/rust). + +

+WQuali sono i non-obiettivi di Rust? +

+ +1. Non impieghiamo nessuna tecnologia particolarmente nuova. Le vecchie tecniche ben consolidate sono meglio. +2. Non ci preme incentivare l'espressivitá, il minimalismo o l'eleganza sopra ogni altra cosa. Sono obiettivi desiderati ma non fondamentali. +3. Non ci interessa coprire tutte le funzionalitá del C++ o di qualsiasi altro linguaggio. Rust dovrebbe fornire le funzionalitá piú richieste. +4. Non vogliamo essere immobili al 100%, sicuri al 100%, riflessivi al 100% o troppo dogmatici in qualche modo. Esistono dei compromessi. +5. Non domandiamo che Rust funzioni "su ogni piattaforma possibile". Dovrá eventualmente funzionare senza inutili compromessi sulle piattaforme hardware e software piú diffuse. + +

+In quali progetti Mozilla utilizza Rust? +

+ +Principalmente in [Servo](https://github.com/servo/servo), un motore di navigazione sperimentale a cui Mozilla sta lavorando. Stanno anche lavorando per [integrare componenti Rust](https://bugzilla.mozilla.org/show_bug.cgi?id=1135640) in Firefox. + +

+Che esempi ci sono di grandi progetti in Rust? +

+ +I due piú grandi progetti open source sono al momento [Servo](https://github.com/servo/servo) e il [compilatore Rust](https://github.com/rust-lang/rust) stesso. + +

+Chi altro utilizza Rust? +

+ +[Un crescente numero di organizzazioni!](friends.html) + + + +

+Come posso provare Rust facilmente? +

+ +Il modo piú facile per provare Rust é sulla [playpen](https://play.rust-lang.org/), un'applicazione online per scrivere e provare codice Rust. Se invece desideri provare Rust sul tuo computer, [installalo](https://www.rust-lang.org/install.html) e prova a seguire la guida al [gioco dell'indovino](https://doc.rust-lang.org/stable/book/guessing-game.html) dal libro. + +

+Come posso ricevere aiuto con Rust? +

+ +Ci sono diversi modi. Puoi: + +- Scrivere su [users.rust-lang.org](https://users.rust-lang.org/), il forum ufficiale di Rust +- Chiedere sul [canale IRC ufficiale di Rust](https://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust) (#rust on irc.mozilla.org) +- Chiedere su [Stack Overflow](https://stackoverflow.com/questions/tagged/rust) with the "rust" tag +- Scrivere su [/r/rust](https://www.reddit.com/r/rust), il subreddit non ufficiale di Rust + +

+Perché Rust é cambiato cosí tanto col tempo? +

+ +Rust é iniziato con l'obiettivo di creare un linguaggio di programmazione per sistemi stabile e utilizzabile. Per perseguire questo scopo ha esplorato molte idee, alcune sono state preservate(campi di esistenza, tratti) mentre altre sono state scartate (il sistema di stati dei tipi, il green threading). +Inoltre durante la transizione verso la versione 1.0, buona parte della libreria standard é stata riscritta per consentire al codice passato di sfruttare al meglio le funzionalitá di Rust, +fornendo interfacce di programmazione di qualitá, stabili e multipiattaforma. +Ora che Rust é alla versione 1.0, il linguaggio é garantito come "stabile"; e mentre potrebbe continuare ad evolversi, il codice funzionante sulla versione attuale dovrebbe continuare a farlo +anche nelle versioni future. + +

+Come funziona il numero di versione di Rust? +

+ +Rust segue lo standard [SemVer](http://semver.org/), dove cambiamenti non compatibili con le versioni passate sono ammesse nelle versioni minori se questi cambiamenti +risolvono errori del compilatore, risolvono problemi di sicurezza o cambiano le regole di dichiarazione o inferenza dei tipi in modo da richiedere ulteriore specifica. +Linee guida piú dettagliate per cambi di versione minori sono disponibili come RFC approvate sia per il [linguaggio](https://github.com/rust-lang/rfcs/blob/master/text/1122-language-semver.md) che per la [libreria standard](https://github.com/rust-lang/rfcs/blob/master/text/1105-api-evolution.md). + +Rust mantiene tre canali di rilascio: stabile, beta e "nightly". +I canali stabile e beta sono aggiornati ogni sei settimane, con la nightly che diviene la nuova beta e la beta che diviene la nuova stabile. +Le funzionalitá del linguaggio e della libreria standard indicate come non stabili o nascoste dietro a blocchi di implementazione possono essere utilizzati solo +nel canale di rilascio "nightly". Le nuove funzionalitá arrivano come instabili ma sono "liberate" una volta approvate dal team di sviluppo e relativi sottogruppi. +Questo approccio consente di sperimentare e di contemporaneamente fornire una forte garanzia di retrompatibilitá del canale stabile. + +Per dettagli ulteriori, leggi il post sul blog di Rust ["Stability as a Deliverable."](http://blog.rust-lang.org/2014/10/30/Stability.html) + +

+Posso utilizzare funzionalitá non stabili nei canali stabile e beta? +

+ +No, non puoi. Rust cerca duramente di fornire garanzie sulla stabilitá delle funzioni incluse nei canali beta e stabile. +Quando qualcosa é non stabile significa che non é possibile ancora garantire il suo utilizzo e quindi non desideriamo che ci +si basi su queste funzionalitá o che queste non vengano modificate. +Questo ci permette di provare i cambiamenti nel canale nightly, preservando le promesse di stabilitá. + +Molte cose vengono incluse nella stabile e i canali beta e stabile vengono aggiornati ogni sei settimane, con occasionali modifiche dirette anche al canale beta a volte. +Se stai aspettando la disponbilitá di una funzionalitá e non vuoi usufruire del canale nighly, puoi seguirne lo stato controllando l'etichetta [`B-unstable`](https://github.com/rust-lang/rust/issues?q=is%3Aissue+is%3Aopen+tracking+label%3AB-unstable) sulla bacheca dei problemi. + +

+Cosa sono i "Feature Gates"? +

+ +I "Feature gates" sono il modo con cui Rust stabilizza funzionalitá del compilatore, del linguaggio e della libreria standard. +Una funzione protetta é accessibile esclusivamente nel canale di rilascio "nighly" e solo quando abilitata esplicitamente con la direttiva `#[feature]` o con l'argomento a linea di comando `-Z unstable-options`. +Quando una funzione é stabilizzata diviene disponbile sul canale di rilascio stabile e non é necessario abilitarla esplicitamente. +A quel punto la funzione é considerata "libera". +I "Feature gates" consentono agli sviluppatori di provare funzionalitá sperimentali mentre sono in fase di implementazione, prima che giungano nel linguaggio stabile. + +

+Perché la doppia licenza MIT/ASL2? +

+ +La licenza Apache include importanti protezioni contro le aggressioni legali ma non é compatibile con la GPL versione 2. +Per evitare problemi nell'utilizzo di Rust e GPL2 é aggiunta la licenza alternativa MIT. + +

+Perché una licenza simil-BSD aperta invece che la MPL o la tri-licenza? +

+ +Questo é parzialmente dovuto alla preferenza dello sviluppatore originario (Graydon) e parzialmente al fatto che i linguaggi tendono ad avere un pubblico piú vasto e una serie piú variegata di implementazioni e utilizzi di altri prodotti come i browser web. Noi vorremmo appellarci al maggior numero possibile di sviluppatori. + +

Prestazioni

+ +

+Quanto é performante Rust? +

+ +Molto! Rust é giá competitivo con programmi C e C++ ben scritti in una serie di prove (come nel [Benchmarks Game](https://benchmarksgame.alioth.debian.org/u64q/compare.php?lang=rust&lang2=gpp) e [altri](https://github.com/kostya/benchmarks)). + +Come il C++, il Rust possiede [astrazioni a costo zero](http://blog.rust-lang.org/2015/05/11/traits.html) come uno dei suoi principi chiave: nessuna delle astrazioni di Rust impone un rallentamento, in qualsiasi caso. + +Dato che Rust utilizza LLVM e cerca di assomigliare a Clang dal punto di vista dell'interazione con LLVM, ogni miglioramento di LLVM é condiviso da Rust. +Nel lungo periodo, la quantitá elevata di informazioni presente nel sistema dei tipi di Rust dovrebbe permettere ottimizzazioni difficili o impossibili da implementare in C/C++. + +

+Rust é un linguaggio dotato di garbage collection? +

+ +No. Una delle innovazioni fondamentali di Rust é il garantire la sicurezza della memoria (nessun errore di segmentazione) *senza* richiedere un garbage collector. + +Evitando di utilizzare un GC, Rust offre numerosi vantaggi: liberazione prevedibile delle risorse, gestione della memoria meno onerosa e soprattutto nessun sistema aggiuntivo operante durante l'esecuzione. +Tutte queste caratteristiche rendono Rust leggero e facile da implementare in contesti arbitrari e rendono piú facile [integrare Rust con i linguaggi in possesso di un GC](http://calculist.org/blog/2015/12/23/neon-node-rust/). + +Rust non necessita di un GC grazie al suo sistema di possesso e passaggio ma lo stesso sistema aiuta con una moltitudine di altri problemi, inclusi [la gestione delle risorse in generale](http://blog.skylight.io/rust-means-never-having-to-close-a-socket/) +e la [concorrenza](http://blog.rust-lang.org/2015/04/10/Fearless-Concurrency.html). + +Per quando il possesso di un valore non fosse abbastanza, i programmi Rust fanno riferimento al tipo puntatore intelligente standard a conteggio dei riferimenti [`Rc`](https://doc.rust-lang.org/std/rc/struct.Rc.html) e alla sua versione sicura in contesti paralleli [`Arc`](https://doc.rust-lang.org/std/sync/struct.Arc.html), invece di affidarsi a un GC. + +Stiamo comunque investigando una garbage collection *opzionale* come estensione futura. +L'obiettivo é integrarsi fluidamente con ambienti garbage-collected, come quelli offerti dai +motori di Javascript [Spidermonkey](https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey) e [V8](https://developers.google.com/v8/?hl=en). +Inoltre, qualcuno sta investigando l'implementazione di un garbage collector +[interamente in Rust](https://manishearth.github.io/blog/2015/09/01/designing-a-gc-in-rust/) +senza supporto del compilatore. + +

+Perché il mio programma é lento? +

+ +Il compilatore di Rust non compila con le ottimizzazioni se non esplicitamente istruito [considerato che le ottimizzazioni rallentano la compilazione e sono scosigliate durante lo sviluppo](https://users.rust-lang.org/t/why-does-cargo-build-not-optimise-by-default/4150/3). + +Se compili con `cargo` usa il parametro `--release`. +Se compili direttamente con `rustc`, usa il parametro `-O`. +Ciascuno di questi abiliterá le ottimizzazioni. + +

+Rust compila lentamente. Perché? +

+ +Principalmente per la traduzione del codice e le ottimizzazioni. +Rust fornisce delle astrazioni ad alto livello che vengono compilate in un codice macchina efficiente e queste trasformazioni richiedono molto tempo per essere effettuate, specialmente se in combinazione con le ottimizzazioni. + +Ma il tempo di compilazione di Rust non é male come sembra e c'é da essere fiduciosi in un suo miglioramento futuro. +Comparando progetti di dimensioni simili tra il C++ e Rust il tempo di compilazione é generalmente comparabile. +La percezione di lentezza é largamente dovuta alle differenze tra il *modello di compilazione* del C++ da quello di Rust, l'unitá base del C++ é il file mentre in Rust é l'intero pacchetto, composto da molti file. +Di conseguenza durante lo sviluppo la modifica di un file causa molta meno ricompilazione che in Rust. +In questo momento é in corso uno sforzo per implementare una ristrutturazione del compilatore che permetta di effettuare la +[compilazione incrementale](https://github.com/rust-lang/rfcs/blob/master/text/1298-incremental-compilation.md), che consentirá a Rust di implementare un modello piú rapido e simile al C++. + +Oltre al modello di compilazione, ci sono molti altri aspetti dell'implementazione di Rust e il suo compilatore che ne impattano le prestazioni in fase di compilazione. + +Inizialmente, Rust has un sistema di tipi moderatamente complesso e deve spendere un discreto quantitativo di tempo durante la compilazione a verificarne limitazioni e utilizzi, rendendo Rust sicuro durante la sua esecuzione. + +Secondariamente, il compilatore di Rust soffre di un debito tecnico di lunga data e risaputamente genera una rappresentazione intermedia per LLVM di bassa qualitá a cui LLVM deve porre rimedio. +Si spera che i futuri passaggi di trasformazione e ottimizzazione [basati su MIR](https://github.com/rust-lang/rfcs/blob/master/text/1211-mir.md) riducano la quantitá di lavoro che Rust impone a LLVM. + +Terziariamente, l'utilizzo da parte di Rust di LLVM per la generazione del codice macchina é una spada a doppio taglio: se da un lato questo permette a Rust di avere prestazioni degne di nota, +LLVM é un insieme di strumenti non focalizzato alla velocitá di compilazione, specialmente con input di bassa qualitá. + +Inoltre, mentre la strategia preferita da Rust per monomorfizzare i generici (simil C++) produca codice performante, domanda di generare molto piú codice rispetto ad altre strategie di implementazione. +I programmatori Rust possono utilizzare i tratti per rimuovere questo codice extra e utilizzando un dispacciamento dinamico. + +

+Perché le HashMap di Rust sono cosílente? +

+ +Di base, le [`HashMap`][HashMap] di Rust utilizzano l'algoritmo di hashing [SipHash](https://131002.net/siphash/), progettato per prevenire [attacchi basati sulla collisione di hash](http://programmingisterrible.com/post/40620375793/hash-table-denial-of-service-attacks-revisited) fornendo comunque [un livello di prestazione accettabile in una varietá di compiti](https://www.reddit.com/r/rust/comments/3hw9zf/rust_hasher_comparisons/cub4oh6). + +Mentre SipHash [dimostra prestazioni competitive](http://cglab.ca/%7Eabeinges/blah/hash-rs/) in molti casi, un caso in cui é conclamatamente lento é in presenza di chiavi corte, come ad esempio i numeri interi. +Questo é perché i programmatori Rust spesso incontrano problemi prestazionali con [`HashMap`][HashMap]. +[FNV hasher](https://crates.io/crates/fnv) é spesso consigliato per queste casistiche, tenendo comunque in considerazione che non possiede le stesse caratteristiche di protezione dagli attacchi a collisione di SipHash. + +

+Perché non esiste una piattaforma integrata di misurazione delle prestazioni? +

+ +Esiste ma é riservata al canale di rilascio "nightly". +Progettiamo di costituire un sistema integrato e modulare di misurazione delle prestazioni ma nel frattempo il sistema attuale é [considerato instabile](https://github.com/rust-lang/rust/issues/29553). + +

+Rust ottimizza le tail-call? +

+ +In generale, no. +Le ottimizzazioni delle tail-call sono riservate ad alcune [condizioni particolari](http://llvm.org/docs/CodeGenerator.html#sibling-call-optimization) +ma [non é assicurato](https://mail.mozilla.org/pipermail/rust-dev/2013-April/003557.html). +Siccome é sempre stata una funzionalitá desiderata, Rust ha riservato l'identificatore (`become`), +anche se non é ancora chiaro se sia possibile questa ottimizzazione o se verrá implementata. +Era stata [proposta un'estensione](https://github.com/rust-lang/rfcs/pull/81) che avrebbe permesso di eliminare le tail-call in alcuni casi ma al momento é stata rimandata. + +

+Rust ha un ambiente di esecuzione? +

+ +Non nel senso tipico utilizzato da linguaggi come il Java ma componenti della libreria standard di Rust possono essere considerati un "ambiente di esecuzione", fornendo controlli per heap, backtrace, unwinding, e stack. +C'é un piccolo quantitativo [di codice di inizializzazione](https://github.com/rust-lang/rust/blob/33916307780495fe311fe9c080b330d266f35bfb/src/libstd/rt.rs#L43) che viene eseguito prima della funzione `main`. +La libreria standard di Rust inoltre é collegata alla libreria standard del C, che effettua una simile [inizializzazione](http://www.embecosm.com/appnotes/ean9/html/ch05s02.html). +Il codice di Rust puó essere compilato anche senza la libreria standard, in questo caso il suo ambiente é circa equivalente a quello del C. + +

Sintassi

+ +

+Perché le parentesi graffe? La sintassi di Rust non poteva ispirarsi a Haskell o a Python? +

+ +L'utilizzo delle graffe per indicare blocchi di codice é una scelta comune in una moltitudine di linguaggi di programmazione e l'adesione di Rust allo standard é utile per le persone giá familiari con lo stile. + +Le graffe consentono inoltre una sintassi piú flessibile per il programmatore e per un preprocessore piú semplice nel compilatore. + +

+Posso omettere le parentesi nelle condizioni degli if, +perché allora devo mettere delle parentesi attorno a righe di codice singole? +Perché non é ammesso lo stile del C? +

+ +Mentre il C richiede parentesi obbligatorie per le condizioni dell'istruzione `if` ma rende le parentesi del corpo opzionali, +Rust fa la scelta opposta per i suoi `if`. +Questo lascia la condizione separata chiaramente dal corpo e evita il pericolo delle parentesi opzionali, +che possono condurre in inganno durante la modifica del codice, come il famoso errore [goto fail](https://gotofail.com/) commesso da Apple. + +

+Perché non c'é una sintassi letterale per i dizionari? +

+ +Le scelte stilistiche di Rust sono per limitare la dimensione del *linguaggio* contemporaneamente sfruttando potenti *librerie*. +Anche se Rust fornisce una sintassi per inizializzare array e costanti letterali stringa, questi sono gli unici tipi collezione inseriti nel linguaggio. +Tutti gli altri tipi definiti da librerie, incluso l'onnipresente [`Vec`][Vec] utilizzano macro per la loro inizializzazione, ad esempio la macro [`vec!`][VecMacro]. + +La scelta di utilizzare le macro di Rust per facilitare l'inizializzazione di collezioni verrá probabilmente estesa a altre collezioni in futuro, permettendo inizializzazioni semplici non solo di +[`HashMap`][HashMap] e [`Vec`][Vec], ma anche altri tipi di collezioni come [`BTreeMap`][BTreeMap]. +Nel frattempo, se vuoi una sintassi piú comoda per inizializzare le collezioni, puoi [creare la tua macro](https://stackoverflow.com/questions/27582739/how-do-i-create-a-hashmap-literal) per fornirla. + +

+Quando dovrei utilizzare un ritorno implicito? +

+ +Rust é un linguaggio molto espression-centrico e i ritorni impliciti fanno parte del suo design. +Costrutti come gli `if`, i `match`e i normali blocchi sono tutte espressioni in Rust. + +Ad esempio, il codice seguente controlla se un [`i64`][i64] é dispari, ritornando il risultato semplicamente fornendone il risultato: + +```rust +fn dispari(x: i64) -> bool { + if x % 2 != 0 { true } else { false } +} +``` + +Anche se puó essere ulteriormente semplificato come qui: + + +```rust +fn dispari(x: i64) -> bool { + x % 2 != 0 +} +``` + +In ciascun esempio, l'ultima riga rappresenta il valore di ritorno della funzione. +Risulta importante specificare che se una funzione termina con un punto e virgola il suo tipo di ritorno sará `()`, indicando nessun valore di ritorno. +I ritorni impliciti funzionano quindi esclusivamente in assenza del punto e virgola. + +I ritorni espliciti sono utilizzati solo se un ritorno implicito risulta impossibile perché si desidera ritornare un valore prima della fine del corpo della funzione. +Mentre ciascuna delle funzioni sopra avrebbe potuto includere un `return` e un punto e virgola, questa aggiunta sarebbe inutilmente prolissa e inconsistente con le convenzioni del codice Rust. + +

+Perché i tipi delle funzioni non sono dedotti automaticamente? +

+ +In Rust le dichiarazioni sono tendelzialmente accompagnate da un tipo esplicito, mentre nel codice i tipi vengono dedotti. +Ci sono multiple ragioni per questa scelta: + +- Dichiarazioni obbligatorie dei tipi obbligano a mantenere un'interfaccia stabile a livello di modulo e di pacchetto. +- I tipi facilitano la comprensione del codice per il programmatore, eliminando la necessitá di un ambiente di sviluppo che possa desumere il tipo analizzando il codice dell'intero pacchetto: +il tipo é sempre disponibile nelle vicinanze e in modo esplicito. +- Semplifica gli algoritmi che gesticono la deduzione dei tipi, visto che puó essere analizzata una funzione alla volta. + +

+Perché match deve essere cosí completo? +

+ +Per assistere nelle modifiche e in chiarezza. + +Prima di tutto, se ogni possibilitá viene coperta da un `match`, l'aggiunta di varianti a un `enum` causerá un errore di compilazione, invece che un problema durante l'esecuzione. +Questo tipo di assistenza permette di modificare il codice Rust liberamente e senza paura. + +Secondariamente, il controllo dettagliato rende esplicito il caso predefinito: in generale l'unico modo per creare un `match` non esaustivo sarebbe di far andare in errore il processo se non viene incontrato alcun valore previsto. +Le versioni iniziali di Rust non prevedevano la completezza di `match` ed é stato accertato che questa scelta ha causato una moltitudine di problematiche. + + +Risulta comunque semplice ignorare tutti i casi non specificati usando il carattere speciale `_`: + +```rust +match val.fai_qualcosa() { + Gatto(a) => { /* ... */ } + _ => { /* ... */ } +} +``` + +

Numerici

+ +

+Quale dovrei scegliere tra f32 e f64 per i calcoli in virgola mobile? +

+ +La scelta dipende dallo scopo del programma. + +Se ció che conta é la precisione massima, [`f64`][f64] é da preferire. +Se invece si vuole minimizzare l'impatto in memoria e l'efficienza, ignorando la precisione persa, [`f32`][f32] é piú appropriato. +Svolgere operazioni sugli [`f32`][f32] é generalmente piú veloce, anche in piattaforme a 64-bit. +Come esempio, la grafica sfrutta tipicamente gli [`f32`][f32] perché richiede alte prestazioni e i numeri in virgola mobile a 32-bit bastano per rappresentare i pixel a schermo. + +Nel dubbio, scegli [`f64`][f64] per una maggiore precisione. + +

+Perché non posso comparare i numeri a virgola mobile o usarli come chiave per un HashMap o un BTreeMap? +

+ +I numeri a virgola mobile si possono comparare con gli operatori `==`, `!=`, `<`, `<=`, `>`, e `>=` , e attraverso la funzione `partial_cmp()`. +`==` e `!=` possiedono il tratto [`PartialEq`][PartialEq], mentre `<`, `<=`, `>`, `>=`, e `partial_cmp()` possiedono il tratto [`PartialOrd`][PartialOrd]. + +I numeri a virgola mobile non sono confrontabili con la funzione `cmp()`, possidente il tratto [`Ord`][Ord], dato che i numeri a virgola mobile non costituiscono insieme totalmente ordinato. +Inoltre non esiste relazione di uguaglianza completa numeri a virgola mobile e quindi non implementano il tratto[`Eq`][Eq]. + +Non esiste l'ordinamento totale o l'uguaglianza tra numeri a virgola mobile a causa del valore [`NaN`](https://en.wikipedia.org/wiki/NaN) che non é minore, maggiore o uguale di alcun altro numero o sé stesso. + +Visto che i numeri a virgola mobile non implementano i tratti [`Eq`][Eq] o [`Ord`][Ord], non sono utilizzabili nei tipi le cui limitazioni esigono l'implementazione di queste caratteristiche, come [`BTreeMap`][BTreeMap] o [`HashMap`][HashMap]. +Questo é importante perché questi tipi *suppongono* che le chiavi forniscano relazioni di ordinamento totale o di uguaglianza, a pena di malfunzionamenti. + +Esiste [un pacchetto](https://crates.io/crates/ordered-float) che racchiude [`f32`][f32] e [`f64`][f64] in modo da fornire i tratti [`Ord`][Ord] e [`Eq`][Eq] che potrebbe assistere in certi casi. + +

+Come posso convertire tra i tipi numerici? +

+ +Ci sono due modi: la parola chiave `as`, che esegue una semplice conversione per tipi primitivi e i tratti [`Into`][Into] e [`From`][From], +che sono implementati per una serie di conversioni tra tipi numerici (e che anche tu puoi implementare sui tuoi tipi). +I tratti [`Into`][Into] e [`From`][From] sono implementati esclusivamente per le conversioni prive di perdita, qundi ad esempio, `f64::from(0f32)` funziona mentre `f32::from(0f64)` no. +D'altro canto, `as` convertirá tra qualsiasi coppia di tipi primitivi, effettuando i necessari troncamenti.. + + +

+Perché Rust non possiede operatori per il decremento e incremento? +

+ +Gli operatori di preincremento e postincremento (e relativi opposti equivalenti), anche se convenienti presentano una discreta complessitá; +Richiedono una conoscenza dell'ordine di esecuzione e spesso conducono a piccoli problemi e comportamenti anormali in C e C++. +`x = x + 1` o `x += 1` é leggermente piú prolisso ma chiaro. + +

Stringhe

+ +

+Come posso convertire una String o un Vec<T> a una partizione (&str e &[T])? +

+ +Solitamente, puoi passare un riferimento a una `String` o ad un `Vec` ovunque ci si aspetti una partizione. +Utilizzando le [costrizione da de-riferimento](https://doc.rust-lang.org/stable/book/deref-coercions.html), [`String`][String] e [`Vec`][Vec] verrano automaticamente ridotti alle rispettive partizioni quando passate come riferimento tramite `&` o `& mut`. + +I metodi implementati su `&str` e `&[T]` possono essere utilizzati direttamente su `String` e `Vec`. +Ad esempio `una_stringa.char_at(0)` funzionerá anche se `char_at` é un metodo su `&str` e `una_stringa` é una `String`. + +In alcuni casi, come nella programmazione generica é necessario convertire manualmente, questa operazione é effettuabile utilizzando l'operatore di partizione, in questo modo: `&mio_vettore[..]`. + +

+Come posso convertire una &str in String e viceversa? +

+ +Il metodo [`to_string()`][to_string] converte una [`&str`][str] in una [`String`][String] e le [`String`][String] sono automaticamente convertite in [`&str`][str] quando ne acquisisci un riferimento. +Entrambe sono visibili nell'esempio seguente: + +```rust +fn main() { + let s = "Maria Rossi".to_string(); + saluta(&s); +} + +fn saluta(nome: &str) { + println!("Ciao {}!", nome); +} +``` + +

+In cosa differiscono i due tipi stringa? +

+ +[`String`][String] é un'area di memoria allocata nel heap di byte UTF-8. +Le [`String`][String] mutabili possono essere modificate, espanendosi se necessario. +[`&str`][str] é una "vista" di capacitá fissata in una [`String`][String] allocata altrove, generalmente nel heap, in caso di partizioni riferite a [`String`][String], o in memoria statica, per le costanti letterali. + +[`&str`][str] é un tipo primitivo implementato nel linguaggio Rust, mentre [`String`][String] é implementato dalla libreria standard. + +

+Come accedo ai caratteri di una String con complessitá asintottica O(1)? +

+ +Non é possibile. Senza una chiara comprensione di cosa intendi per "carattere" e una pre-elaborazione della stringa per ritrovare l'indice del carattere desiderato. + +Le stringhe in Rust sono codificate in UTF-8. +Un singolo carattere UTF-8 non é obbligatoriamente grande un singolo byte come sarebbe una stringa codificata in ASCII. +Ogni byte é chiamato una "unitá di codice" (nello UTF-16, le unitá di codice sono di 2 byte, nello UTF-32 sono di 4 byte). +I "punti di codice" sono composti di una o piú unitá di codice, combinate in "gruppi di grafemi" che fedelmente ricalcano il concetto tradizionale di caratteri. + +Anche con la possibilitá di indicizzare i byte in una stringa UTF-8, non puoi accedere all'`i`-esimo elemento del gruppo di grafemi in un tempo costante. +Ad ogni modo, se conosci a quale byte si trova il punto di codice o gruppo di grafemi desiderato, quindi _puoi_ accedervi in tempo costante. +Le funzioni, incluse [`str::find()`][str__find] e le espressioni regolari ritornano indici dei byte, facilitando questo tipo di accesso. + +

+Perché le stringhe sono UTF-8? +

+ +Le [`str`][str] sono UTF-8 perché nel mondo questa codifica é frequente - specialmente in trasmissioni di rete, che ignorano l'ordine di bit della piattaforma - pensiamo quindi sia meglio che il trattamento standard dell'I/O non preveda la ricodifica in entrambe le direzioni. + +Questo significa che individuare un particolare punto di codice Unicode dentro una stringa é un'operazione O(n), anche se, conoscendo l'indice del byte ci si puó accedere in un tempo O(1) come previsto. +Sotto un certo punto di vista questo é chiaramente sconveniente; ma d'altro canto questo problema é pieno di compromessi e vorremmo sottolineare alcune precisazioni importanti: + +Scorrere una [`str`][str] per valori della codifica ASCII puó essere fatto in sicurezza byte per byte, +utilizzando [`.as_bytes()`][str__as_bytes] ed estraendo [`u8`][u8] con un costo `O(1)` e producendo valori che possono essere trasformati e comparati con la codifica ASCII con il tipo [`char`][char]. +Quindi se per (ad esempio) vogliamo andare a capo ad ogni `'\n'`, una ricerca byte a byte continua a essere funzionante, grazie alla flessibilitá dello standard UTF-8. + +La maggior parte delle operazioni orientate ai caratteri sul testo funzionano su presupposti molto ristretti come ad esempio l'esclusione dei caratteri non ASCII. +Anche in questo caso all'esterno della codifica ASCII si tende a utilizzare comunque un algoritmo complesso(con complessitá non costante) per determinare i bordi di caratteri, parole e paragrafi. +Noi consigliamo di utilizzare un algoritmo "onesto", approvato da Unicode e adattato al linguaggio da considerare. + +Il tipo [`char`][char] é UTF-32. +Se hai la certezza di dover richiedere l'analisi di un "punto di codice" alla volta é semplicissimo scrivere `type wstr = [char]` e caricarci dentro una [`str`][str] in un solo passaggio, per poi lavorare con il nuovo `wstr`. +In altre parole: il fatto che il linguaggio non decodifichi a UTF32 come prima opzione non ti deve inibire da decodificare(o ri-codificare per il processo inverso) i caratteri se necessiti di lavorare in quella codifica. + +Per una spiegazione piú dettagliata su perché UTF-8 é preferibile rispetto a UTF-16 o UTF-32, leggi il [manifesto di UTF-8 Everywhere](http://utf8everywhere.org/). + +

+Quale tipo stringa dovrei usare? +

+ +Rust ha quattro paia di tipi stringa, [ciascuno assolve un ruolo distinto](http://www.suspectsemantics.com/blog/2016/03/27/string-types-in-rust/). +In ciascun paio, c'é un tipo stringa "posseduto" e un tipo stringa "partizione". +I tipi sono suddivisi cosí: + +| | tipo "Partizione" | tipo "Posseduto" | +|:----------------------|:------------------|:-----------------| +| UTF-8 | `str` | `String` | +| Compatibile con il SO | `OsStr` | `OsString` | +| Compatibile con il C | `CStr` | `CString` | +| Percorso di sistema | `Path` | `PathBuf` | + +I diversi tipi di stringa di Rust assolvono ruoli diversi. +`String` e `str` sono stringhe ad uso generico codificate in in UTF-8. +`OsString` e `OsStr` sono codificati a seconda della piattaforma corrente e sono utilizzati per interagire con il sistema operativo. +`CString` e `CStr` sono l'equivalente in Rust delle stringhe del C, si utilizzano nelle chiamate FFI, mentre `PathBuf` e `Path` sono un'aggiunta di `OsString` e `OsStr` ed implementano metodi specifici alla manipolazione di percorsi. + +

+Come faccio a scrivere una funzione che accetti sia &str che String? +

+ +Ci sono diverse opzioni, a seconda delle necessitá della funzione: + +- Se la funzione richiede una stringa posseduta ma vuole accettare una qualsiasi stringa utilizza la restrizione al tratto `Into`. +- Se la funzione richiede una partizione di stringa ma vuole accettare una qualsiasi stringa utilizza la restrizione al tratto `AsRef`. +- Se alla funzione non interessa del tipo di stringa e vuole gestire uniformemente le due possibilitá utilizza il tipo `Cow.` + +__Usare `Into`__ + +In questo esempio, la funzione accetta sia stringhe possedute che partizioni di stringa o facendo nulla o convertendo l'ingresso in stringa posseduta. +Nota che la conversione deve essere fatta esplicitamente e non succede altrimenti. + +```rust +fn accetta_entrambe>(s: S) { + let s = s.into(); // Questo converte s in una `String`. + // ... il resto della funzione +} +``` + +__Usare `AsRef`__ + +In questo esempio, la funzione accetta sia stringhe possedute che partizioni di stringa o facendo nulla o convertendo l'ingresso in una partizione di stringa. +Questo viene fatto automaticamente prendendo l'ingresso per riferimento, come qui: + +```rust +fn accetta_entrambe>(s: &S) { + // ... il corpo della funzione +} +``` + +__Usare `Cow`__ + +In questo esempio, la funzione accetta un `Cow`, che non é un tipo generico ma un contenitore, contenente o una stringa posseduta o una partizione di stringa all'occorrenza. + +```rust +fn accetta_cow(s: Cow) { + // ... il corpo della funzione +} +``` + + +

Collezioni

+ +

+Posso implementare efficientemente strutture dati come vettori e liste concatenate in Rust? +

+ +If vuoi implementare queste strutture dati per utilizzarle in altri programmi non é necessario, essendo implementazioni efficienti di queste strutture giá disponibili nella libreria standard. + +Se invece, [vuoi solo imparare](http://cglab.ca/~abeinges/blah/too-many-lists/book/), probabilmente dovrai entrare nel codice insicuro. +Anche se é _possibile_ implementarle solo con codice sicuro, le prestazioni sarebbero probabilmente peggiori di come sarebbe stato lo stesso codice con l'utilizzo di codice insicuro. +La semplice ragione per ció é che le strutture dati come vettori e liste concatenate fanno affidamento a operazioni su puntatori e memoria che sono proibiti nel Rust sicuro. + +Per esempio, una lista concatenata doppia richiede due riferimenti mutabili a ciascun nodo ma questo viola le regole di Rust sull'esclusivitá dei riferimenti mutabili. +Si puó risolvere il problema utilizzando [`Weak`][Weak], ma le prestazioni sarebbero probabilmente peggiori di quanto desiderato. +Con il codice insicuro puoi ignorare le regole di esclusivitá ma devi verificare manualmente che il tuo codice non introduca violazioni nella sua gestione della memoria. + +

+Come posso iterare una collezione senza muoverla o consumarla? +

+ +Il modo piú semplice é utilizzare l'implementazione del tratto [`IntoIterator`][IntoIterator]. +Ecco qui un esempio con [`&Vec`][Vec]: + +```rust +let v = vec![1,2,3,4,5]; +for oggetto in &v { + print!("{} ", oggetto); +} +println!("\nLunghezza: {}", v.len()); +``` + +I cicli `for` in Rust chiamano la funzione `into_iter()` (definita dal tratto [`IntoIterator`][IntoIterator]) per qualsiasi cosa stiano analizzando. +Tutto ció che implementa il tratto [`IntoIterator`][IntoIterator] puó essere traversato con un ciclo `for`. +[`IntoIterator`][IntoIterator] é implementato per [`&Vec`][Vec] e [`&mut Vec`][Vec], obbligando l'iteratore generato da `into_iter()` a prendere in prestito i contenuti della collezione, al posto di consumarli o muoverli. +Lo stesso é vero per le altre collezioni della libreria standard. + +Se si desidera un iteratore che muova/consumi i valori, basta scrivere lo stesso ciclo `for` omettendo `&` o `&mut`. + +Se si necessita accesso diretto all'iteratore, vi si puó usualmente accedere invocando il metodo `iter()`. + +

+Perché devo inserire la dimensione del vettore alla sua dichiarazione? +

+ +Non é necessario. Se dichiari direttamente un vettore, la dimensione é dedotta dal numero di elementi. Se invece dichiari una funzione che accetta un vettore di dimensione prefissata il compilatore deve avere modo di sapere quale sará la dimensione di quel vettore. + +Una cosa da notare é che attualmente Rust non offere generici su array di dimensioni diverse. +Se desideri quindi accettare un contenitore continuo di un numero variabile di valori, utilizza [`Vec`][Vec] o una partizione (a seconda che tu richieda il possesso o no). + +

Possesso

+ +

+Come posso implementare un grafo o altra struttura contenente cicli? +

+ +Esistono almeno quattro diverse opzioni (largamente discusse in [Too Many Linked Lists](http://cglab.ca/~abeinges/blah/too-many-lists/book/)): + +- Puoi implementarlo usando [`Rc`][Rc] e [`Weak`][Weak] per permettere il possesso condiviso dei nodi, +anche se questo approccio richiede la gestione della memoria. +- Puoi implementarlo usando codice `unsafe` e i puntatori. +Anche se efficiente questo metodo ignora i paradigmi di sicurezza di Rust. +- Usando vettori indici al loro interno. Esistono [diversi](http://smallcultfollowing.com/babysteps/blog/2015/04/06/modeling-graphs-in-rust-using-vector-indices/) modi [disponibili](https://featherweightmusings.blogspot.com/2015/04/graphs-in-rust.html), esempi e spiegazioni di questo metodo. +- Usando [`UnsafeCell`][UnsafeCell]. Esistono [spiegazioni e codice](https://github.com/nrc/r4cppp/blob/master/graphs/README.md#node-and-unsafecell) per questo metodo. + +

+Come posso definire una struttura che contiene un riferimento a un suo campo? +

+ +Si puó fare ma é inutile. +La struttura diventa permanentemente prestata a sé stessa e quindi non puó essere copiata. +Ecco del codice per capire meglio: + +```rust +use std::cell::Cell; + +#[derive(Debug)] +struct Immobile<'a> { + x: u32, + y: Cell>, +} + + +fn main() { + let test = Immobile { x: 42, y: Cell::new(None) }; + test.y.set(Some(&test.x)); + + println!("{:?}", test); +} +``` + +

+Che differenza sussiste tra passare per valore, consumare, spostare e trasferire la proprietá? +

+ +Sono parole diverse per dire la stessa cosa. +In tutti i casi significa che il valore é stato trasferito a un nuovo proprietario, o che la proprietá é stata trasferita dal possessore originario, che quindi non puó piú accedervi. +Se un tipo implementa il tratto `Copy`, il valore del proprietario originale non viene invalidato e puó essere utilizzato nuovamente. + +

+Perché alcuni valori di alcuni tipi possono essere utilizzati dopo il passaggio a una funzione mentre il riutilizzo di valori di altri tipi genera errori? +

+ +Se un tipo implementa il tratto [`Copy`][Copy], esso verrá copiato durante il suo passaggio a una funzione. +Tutti i tipi numerici in Rust implementano [`Copy`][Copy] ma le strutture in maniera predefinita non implementano [`Copy`][Copy], quindi invece di essere copiate sono mosse. +Ció implica che la struttura non possa piú essere utilizzata altrove, se non viene ritornata dalla funzione tramite un `return`. + +

+Come si gestice l'errore "utilizzo di un valore spostato"? +

+ +Questo errore significa che il valore che stai cercando di utilizzare é stato trasferito a un nuovo proprietario. +La prima cosa da controllare in questo caso é se il trasferimento era davvero necessario: se il valore era stato mosso a una funzione, potrebbe essere possibile riscriverla per utilizzare un riferimento invece che il trasferimento, ad esempio. +Altrimenti se il tipo mosso implementa il tratto [`Clone`][Clone], chiamare `clone()` su di esso prima di muoverlo trasferirá una sua copia, mantenendo l'originale disponibile per utilizzi futuri. +Nota che la clonazione di un valore dovrebbe essere l'ultima spiaggia, essendo la procedura di clonazione costosa e causa di allocazioni di memoria. + +Se il valore mosso é uno dei tuoi tipi personalizzati, considera implementare il tratto [`Copy`][Copy] (per la copia implicita al posto del trasferimento) o [`Clone`][Clone] (copia esplicita). +[`Copy`][Copy] é generalmente implementato con la direttiva `#[derive(Copy, Clone)]` ([`Copy`][Copy] richiede [`Clone`][Clone]), e [`Clone`][Clone] con la direttiva `#[derive(Clone)]`. + +Se nulla di tutto questo é possibile, probabilmente devi modificare la funzione che ha acquisito il possesso per fare in modo che restituisca la proprietá alla sua uscita. + +

+Quali regole disciplinano l'utilizzo di self, &self o &mut self nella dichiarazione di un metodo? +

+ +- Usa `self` quando una funzione deve consumare il valore +- Usa `&self` quando una funzione necessita solo di una copia di sola lettura del valore +- Usa `&mut self` quando una funzione necessita di modificare un valore ma senza consumarlo + +

+Come faccio a comprendere il gestore dei prestiti? +

+ +Il gestore dei prestiti, mentre analizza il codice, applica poche semplici regole, che sono illustrate nella sezione del libro di Rust [dedicata ai prestiti](https://doc.rust-lang.org/stable/book/references-and-borrowing.html#the-rules). +Queste regole sono: + +> Prima cosa, ogni prestito deve durare per un periodo di tempo non superiore alla vita del possessore originale. +Seconda cosa, puoi avere accesso a uno o l'altro di questi due tipi di prestiti, ma non a entrambi contemporaneamente: +> +> - uno o piú riferimenti (&T) a una risorsa. +> - esattamente un riferimento mutabile (&mut T) + +Nonostante le regole siano molto semplici, seguirle correttamente puó essere molto complicato, specialmente per coloro che non sono abitutati a ragionare in termini di campi di esistenza e possesso. + +La prima regola é comprendere che il gestore dei prestiti identifica veramente gli errori che produce: molto lavoro é stato profuso per renderlo un assistente di qualitá nella risoluzione delle problematiche che individua. +Quando incontri un problema segnalato dal gestore dei prestiti, il primo passo é di leggere lentamente e con attenzione l'errore e poi approcciarsi al codice una volta compreso davvero l'errore descritto. + +Il secondo passo é cercare di familiarizzare con i tipi contenitore associati con i concetti di possesso e mutabilitá forniti dalla libreria standard di Rust, includendo [`Cell`][Cell], [`RefCell`][RefCell] e [`Cow`][Cow]. +Questi utili e necessari strumenti possono aiutare ad esprimere efficientemente alcune situazioni complesse di possesso e mutabilitá. + +La singola cosa piú importante nella comprensione del gestore dei prestiti é la pratica. +La potente analisi statica fatta da Rust é particolare e molto differente da molte esperienze di programmazione precedente. +Ci vorrá un po' di tempo per acquisire la giusta tranquillitá. + +Se ti ritrovi in difficoltá con il gestore dei prestiti, oppure hai finito la pazienza, sentiti libero di chiedere un aiuto alla [comunitá di Rust](community.html). + +

+Quando puó venire utile utilizzare una Rc? +

+ +Questo é coperto dalla documentazione ufficiale per [`Rc`][Rc] il tipo di puntatore non-atomico utilizzante il reference counting di Rust. +In breve, [`Rc`][Rc] e il suo cugino, amico del multithreading [`Arc`][Arc] sono utili per indicare possesso condiviso e vengono deallocati automaticamente dal sistema quando nessuno vi accede. + +

+Come posso ritornare una chiusura da una funzione? +

+ +Per ritornare una chiusura da una funzione, essa deve essere una "chiusura da movimento", ovvero che essa deve essere dichiarata dalla parola `move`. +Come [illustrato nel libro di Rust](https://doc.rust-lang.org/book/closures.html#move-closures), questo fornisce alla chiusura la sua copia delle variabili catturate, indipendentemente dal quadro di allocazione del chiamante. +Altrimenti, ritornare da una chiusura sarebbe insicuro, visto che permetterebbe di accedere a variabili non piú disponibili; detto in un altro modo: permetterebbe di leggere dati da locazioni di memoria errate. +La chiusura deve anche essere racchiusa in un [`Box`][Box], in modo da essere allocata nella heap. +Puoi saperne di piú [nel libro](https://doc.rust-lang.org/book/closures.html#returning-closures). + +

+Cos'é un deriferimento forzato e come funziona? +

+ +Un [deriferimento forzato](https://doc.rust-lang.org/book/deref-coercions.html) é una pratica conversione automatica di delle referenze +a puntatori (es., `&Rc` or `&Box`) a referenze ai loro contenuti +(es., `&T`). +Il deriferimento forzato esiste per rendere l'utilizzo di Rust piú comodo e sono implementati dal tratto [`Deref`][Deref]. + +Una implementazione di `Deref` indica che il tipo implementante potrebbe essere convertito in un valore con una chiamata al metodo `deref`, che prende un riferimento immutabile al tipo chiamante e ritorna un riferimento(senza violare peró il campo di esistenza) del tipo obiettivo. +L'operatore `*`, se utilizzato come prefisso é un metodo piú veloce per accedere a `deref`. + +Sono chiamate "forzature" a causa delle regole spiegate qui [nel libro di Rust](https://doc.rust-lang.org/stable/book/deref-coercions.html): + +> Se hai un tipo `U` ed esso implementa `Deref`, i valori `&U` verranno automaticamente convertiti in `&T`. + +Ad esempio, se hai un `&Rc`, esso verrá forzato per questa regola a `&String`, che puó essere forzato anche a `&str` nello stesso modo. +Quindi se una funzione accettasse un parametro `&str`, puoi passare direttamente un `&Rc` e tutte le forzature e verranno gestite automaticamente dal tratto `Deref`. + +I tipici deriferimenti forzati sono: + +- `&Rc` a `&T` +- `&Box` a `&T` +- `&Arc` a `&T` +- `&Vec` a `&[T]` +- `&String` a `&str` + +

Campi di esistenza

+ +

+Perché i campi di esistenza? +

+ +I campi di esistenza sono la soluzione di Rust al problema della sicurezza della memoria. +Questi consentono a Rust di assicurare la sicurezza della memoria senza i costi prestazionali della garbage collection. +Sono basati su una serie di articoli accademici che possono essere trovati nel [libro di Rust](https://doc.rust-lang.org/stable/book/bibliography.html#type-system). + +

+Perché la sintassi dei campi di esistenza é fatta cosí? +

+ +La sintassi `'a` proviene dalla famiglia ML di linguaggi di programmazione, dove `'a` viene utilizzato per indicare un parametro di tipo generico. +In Rust, la sintassi doveva rappresentare qualcosa di univoco, chiaramente visibile e integrato con le altre dichiarazioni dei tipi insieme ai vari tratti e riferimenti. +Sono state prese in considerazione anche altre scelte ma nessuna sintassi alternativa si é dimostrata chiaramente migliore. + +

+Come posso ritornare un prestito a qualcosa che ho creato in una funzione? +

+ +Devi assicurarti che il campo di esistenza del valore prestato sia piú lungo di quello della funzione. +Puoi ottenere questo effetto puoi assegnare il campo di esistenza dell'uscita a quello di un parametro di ingresso come qui: + +```rust +type Gruppo = TypedArena; + +// (Il campo di esistenza sotto é esplicitato esclusivamente +/// per facilitarne la comprensione; esso puó essere omesso +// tramite le regole di elisione consultabili in un'altra +// risposta presente in questa pagina) + +fn crea_prestato<'a>(gruppo: &'a Gruppo, + x: i32, + y: i32) -> &'a Cosa { + gruppo.alloc(Cosa { x: x, y: y }) +} +``` + +Un'alternativa é eliminare interamente il riferimento ritornando un valore posseduto come [`String`][String]: + +```rust +fn buon_compleanno(nome: &str, eta: i64) -> String { + format!("Ciao {}! Hai {} anni!", nome, eta) +} +``` + +Questo approccio é piú semplice ma spesso genera allocazioni in memoria non necessarie. + +

+Perché alcuni riferimenti hanno un campo di esistenza, come &'a T e altri no, tipo &T? +

+ +In realtá, *tutti* i riferimenti hanno un campo di esistenza ma nella maggior parte dei casi non +ti devi preoccupare di gestirlo esplicitamente. Le regole sono le seguenti: + +1. Nel corpo di una funzione non devi mai specificare un campo di esistenza esplicitamente; + il valore corretto dovrebbe essere sempre dedotto correttamente. +2. Nella *dichiarazione* di una funzione (ad esempio, nei tipi dei suoi parametri + o il suo tipo di ritorno), *potresti* dover specificare un campo di esistenza manualmente. + I campi di esistenza in questo contesto utilizzano un semplice metodo chiamato + ["elisione del campo di esistenza"](https://doc.rust-lang.org/book/lifetimes.html#lifetime-elision), + che a sua volta consiste in queste tre regole: + - Ciascun campo di esistenza eliso nei parametri di una funzione diviene un campo di esistenza distinto. + - Se vi é esattamente un singolo campo di esistenza in ingresso, eliso o no, quel campo di esistenza + viene assegnato a tutti i campi di esistenza elisi utilizzati per i valori di ritorno di quella funzione. + - Se ci sono piú campi di esistenza in ingresso ma uno di quelli é un `&self` o un `&mut self`, il campo di esistenza + di `self` viene assegnato a tutti i campi di esistenza di uscita. +3. Se si sta definendo una `struct` o `enum` i campi di esistenza sono da dichiarare espressamente. + +Se queste regole danno origine a un errore di compilazione, il compilatore di Rust fornirá un messaggio di errore indicante l'errore e anche una potenziale soluzione basata sugli algoritmi di deduzione. + +

+Come puó Rust garantire l'assenza di "puntatori nulli" e "puntatori sospesi"? +

+ +L'unico modo di creare un valore `&Cosa` or `&mut Cosa` é di specificare un valore preesistente di tipo `Coso` a cui la referenza deve fare riferimento. +Il riferimento in questo modo ottiene in prestito il valore originale per un determinato blocco di codice(il campo di esistenza del riferimento) e il valore prestato non puó essere spostato o distrutto per tutta la durata del prestito. + +

+Come faccio a indicare l'assenza di un valore senza utilizzare null? +

+ +Puoi fare ció con il tipo [`Option`][Option] che puó alternativamente essere `Some(T)` o `None`. +`Some(T)` indica che un valore di tipo `T` é contenuto all'interno, mentre `None` ne indica l'assenza. + +

Generici

+ +

+Cos'é la "monomorfizzazione"? +

+ +La monomorfizzazione specializza ciascun utilizzo di una funzione(o struttura) generica in base ai tipi di parametri di ciascuna chiamata(o agli utilizzi della struttura). + +Durante la monomorfizzazione viene generata una nuova versione specializzata della funzione per ciascun set univoco di tipi. +Questa strategia, giá utilizzata nel C++, genera del codice macchina efficiente, specializzato per ciascuna chiamata e invocato staticamente, con lo svantaggio che una funzione istanziata con tanti tipi diversi +puó dare luogo a molta duplicazione nel codice generato, generando quindi eseguibili piú grandi rispetto ad altre strategie di traduzione. + +Le funzioni che accettano [oggetti caratterizzati solo da tratti](https://doc.rust-lang.org/book/trait-objects.html) invece dei tipi non sono soggette alla monomorfizzazione. +Invece, i metodi invocati su oggetti tratto sono gestiti dinamicamente durante l'esecuzione. + +

+Qual'é la differenza tra una funzione e una chiusura che non cattura nessuna variabile? +

+ +Le funzioni e le chiusure si utilizzano allo stesso modo ma hanno una gestione differente in fase di esecuzione a causa di una implementazione diversa. + +Le funzioni sono un costrutto fondamentale del linguaggio, mentre le chiusure sono essenzialemente un modo piú semplice per indicare uno di questi tre tratti: [`Fn`][Fn], [`FnMut`][FnMut] e [`FnOnce`][FnOnce]. +Quando scrivi una chiusura, il compilatore di Rust automaticamente provvede a generare una struttura implementante il tratto piú idoneo tra quei tre e a catturare le variabili corrette come membri, +generando anche la possibilitá di utilizzare la struttura come una funzione. Le strutture, al contrario, non catturano alcuna variabile. + +La fondamentale differenza tra questi tratti é come acquisiscono il parametro `self`. +[`Fn`][Fn] prende `&self`, [`FnMut`][FnMut] prende `&mut self` mentre[`FnOnce`][FnOnce] prende `self`. + +Anche se una cattura non cattura alcuna variabile di ambiente, viene rappresentata in fase di esecuzione tramite due puntatori, come qualsiasi altra chiusura. + +

+Cosa sono i tipi di piú alto livello, perché sono richiesti e perché Rust non li implementa? +

+ +I tipi di piú alto livello sono tipi con parametri non specificati. I costruttori di tipi come [`Vec`][Vec], [`Result`][Result] e [`HashMap`][HashMap] sono tutti esempi di tipi di piú alto livello: +ciascuno richiede alcuni tipi aggiuntivi per poter denotare effettivamente il suo tipo, come nel caso di `Vec`. +Il supporto per i tipi di alto livello significa che questi tipi "incompleti" possono essere utilizzati ovunque possano essere utilizzati anche i tipi "completi", non escludendo le funzioni generiche. + +Ogni tipo completo, come [`i32`][i32], [`bool`][bool], o [`char`][char] é di tipo `*` (questa notazione deriva dalla teoria correlata con il sistema dei tipi). +Un tipo a parametro singolo, come [`Vec`][Vec] é invece `* -> *`, ovvero che vec [`Vec`][Vec] accetta un tipo completo come [`i32`][i32] e ritorna il tipo completo `Vec`. +Un tipo con tre parametri, come [`HashMap`][HashMap] é di tipo `* -> * -> * -> *` perché accetta tre tipi completi (come [`i32`][i32], [`String`][String] e [`RandomState`][RandomState]) per generare un nuovo tipo completo `HashMap`. + +In aggiunta a questi esempi, i costruttori di tipo possono accettare dei parametri sul *campo di esistenza*, che denoteremo con `Lt`. +Ad esempio `slice::Iter` ha il tipo `Lt -> * -> *`, perché va istanziato ad esempio come `Iter<'a, u32>`. + +La mancanza di supporto per i tipi di piú alto livello rende difficile scrivere alcuni tipi di codice generico. +Risulta particolarmente problematico astrarre su concetti come gli iteratori, dato che essi sono spesso parametrizzati nei confronti di uno specifico campo di esistenza. +Queste premesse hanno impedito la creazione di tratti che astraggano ulteriormente le collezioni presenti in Rust. + +Un altro esempio frequente é da ricercare nei concetti di functor e monad, entrambi dei quali sono costruttori di tipi, invece che tipi individuali. + +Rust al momento non possiede supporto per i tipi di piú alto livello perché non é stato prioritizzato lo sviluppo di questa funzione rispetto ad altre funzionalitá che rispecchiano meglio gli obiettivi del progetto. +Essendo la progettazione di funzionalitá importanti come queste un campo minato, vorremmo procedere con cautela, non c'é un'altra ragione particolare sul perché Rust non possiede questa funzionalitá. + +

+Cosa significano i parametri fatti tipo <T=Foo> nel codice generico? +

+ +Questi sono chiamati [tipi associati](https://doc.rust-lang.org/stable/book/associated-types.html), permettono di indicare limitazioni di tratto non esprimibili con un costrutto `where`. +Ad esempio, una limitazione generica `X: Bar` significa che `X` deve implementare il tratto `Bar` e in tale implementazione di bar `Bar`, `X` deve scegliere `Foo` come il tipo associato di `Bar`, `T`. +Gli esempi in cui una limitazione di tal genere non é esprimibile con un costrutto `where` includono i tipi tratto come `Box>`. + +I tipi associati esistono perché spesso i generici riguardano famiglie di tipi, dove un tipo determina tutti gli altri membri. Per esempio, un tratto per grafi potrebbe avere per `Self` il grafo stesso e avere dei tipi correlati per i suoi nodi e vertici. Ciascun tipo grafo identifica univocamente i tipi associato, rendendo molto piú conciso lavorare con questi tipi di strutture e fornendo anche una migliore gestione sulla deduzione dei tipi in molti casi. + +

+Posso sovrascrivere gli operatore? Se sí, quali? Come faccio? +

+ +Puoi personalizzare l'implementazione di una varietá di operatori utilizzando i loro tratti associati: [`Add`][Add] per il `+`, [`Mul`][Mul] per il `*` e via dicendo. Si puó fare cosí: + +```rust +use std::ops::Add; + +struct Foo; + +impl Add for Foo { + type Uscita = Foo; + fn add(self, rhs: Foo) -> Self::Uscita { + println!("Sommando!"); + self + } +} +``` + +I seguenti operatori possono essere sovrascritti: + +| Operation | Trait | +|:---------------------|:-------------------------------| +| `+` | [`Add`][Add] | +| `+=` | [`AddAssign`][AddAssign] | +| `- binario` | [`Sub`][Sub] | +| `-=` | [`SubAssign`][SubAssign] | +| `*` | [`Mul`][Mul] | +| `*=` | [`MulAssign`][MulAssign] | +| `/` | [`Div`][Div] | +| `/=` | [`DivAssign`][DivAssign] | +| `unary -` | [`Neg`][Neg] | +| `%` | [`Rem`][Rem] | +| `%=` | [`RemAssign`][RemAssign] | +| `&` | [`BitAnd`][BitAnd] | +| | | [`BitOr`][BitOr] | +| |= | [`BitOrAssign`][BitOrAssign] | +| `^` | [`BitXor`][BitXor] | +| `^=` | [`BitXorAssign`][BitXorAssign] | +| `!` | [`Not`][Not] | +| `<<` | [`Shl`][Shl] | +| `<<=` | [`ShlAssign`][ShlAssign] | +| `>>` | [`Shr`][Shr] | +| `>>=` | [`ShrAssign`][ShrAssign] | +| `*` | [`Deref`][Deref] | +| `mut *` | [`DerefMut`][DerefMut] | +| `[]` | [`Index`][Index] | +| `mut []` | [`IndexMut`][IndexMut] | + +

+Cosa distingue Eq/PartialEq e Ord/PartialOrd? +

+ +Ci sono alcuni tipi in Rust i cui valori sono solo parzialmente ordinati oppure hanno relazioni di equivalenza parziali. Ordinamento parziale significa che potrebbero esserci valori di quel tipo che non sono né piú piccoli né piú grandi di un altro. Uguaglianza parziale significa che ci potrebbero essere dei valori di un certo tipo che non sono uguali a loro stessi. + +I tipi a virgola mobile ([`f32`][f32] e [`f64`][f64]) sono un buon esempio di questo. Ogni tipo in virgola mobile potrebbe avere il valore `NaN` (ovvero "non un numero"). `NaN` non é uguale a sé stesso (`NaN == NaN` é falso) e nemmeno piú grande o piú piccolo di un qualsiasi valore. +Di conseguenza sia [`f32`][f32] che [`f64`][f64] implementano [`PartialOrd`][PartialOrd] e [`PartialEq`][PartialEq] ma non [`Ord`][Ord] e nemmeno [`Eq`][Eq]. + +Come spiegato nella [precedente domanda sui numeri in virgola mobile](#why-cant-i-compare-floats), queste distinzioni sono importanti perché alcune collezioni fanno affidamento sul totale ordinamento/uguaglianza per funzionare. + +

Input / Output

+ +

+Come legge un file in una String? +

+ +Usando la funzione [`read_to_string()`][read__read_to_string], definita nel tratto [`Read`][Read] di [`std::io`][std-io]. + +```rust +use std::io::Read; +use std::fs::File; + +fn leggi_file(path: &str) -> Result { + let mut f = try!(File::open(path)); + let mut s = String::new(); + try!(f.read_to_string(&mut s)); // `s` contiene il contenuto di "foo.txt" + Ok(s) +} + +fn main() { + match leggi_file("foo.txt") { + Ok(_) => println!("Letti i contenuti del file!"), + Err(err) => println!("Non sono riuscito a leggere i contenuti del file, errore: {}", err) + }; +} +``` + +

+Come leggo un file efficientemente? +

+ +Il tipo [`File`][File] implementa il tratto [`Read`][Read] che include una moltitudine di funzioni per leggere e scrivere, includendo [`read()`][read__read], [`read_to_end()`][read__read_to_end], [`bytes()`][read__bytes], [`chars()`][read__chars] e [`take()`][read__take]. +Ciascuna di queste funzioni legge un pochino dal file. +[`read()`][read__read] legge quanto il sottostante sistema di input fornisce. +[`read_to_end()`][read__read_to_end] legge l'intero buffer in un vettore, allocando lo spazio necessario. [`bytes()`][read__bytes] e [`chars()`][read__chars] permettono rispettivamente di iterare sui byte e caratteri del file, respectively. +Inoltre, [`take()`][read__take] permette di leggere un numero arbitrario di byte dal file. Insieme, questi metodi permettono di leggere efficientemente ogni tipo di file. + +Per le letture con buffer utilizza la struttura [`BufReader`][BufReader] che aiuta a ridurre il carico di lavoro al sistema durante la lettura. + +

+Come faccio a gestire input e output asincroni in Rust? +

+ +Ci sono molte librerie che forniscono input / output asincroni in Rust, come [mioco](https://github.com/dpc/mioco), [coio-rs](https://github.com/zonyitoo/coio-rs) e [rotor](https://github.com/tailhook/rotor). + +

+Come faccio a prendere parametri da riga di comando in Rust? +

+ +Il modo piú semplice é utilizzare [`Args`][Args], che fornisce un iteratore sui parametri da riga di comando. + +Se stai cercando qualcosa di piú potente, ci sono [una serie di librerie disponbili su crates.io](https://crates.io/keywords/argument). + +

Gestione degli errori

+ +

+Perché Rust non ha le eccezioni? +

+ +Le eccezioni complicano la comprensione del flusso del programma, esprimono validitá o invaliditá all'infuori del sistema dei tipi e funzionano male in ambienti multicore(un obiettivo primario per Rust). + +Rust preferisce un approccio alla gestione degli errori basato sui tipi come [spiegato nel dettaglio nel libro](https://doc.rust-lang.org/stable/book/error-handling.html). +Questo é piú compatibile con il flusso di controllo tipico di Rust, la concorrenza e tutto il resto. + +

+Perché c'é unwrap() ovunque? +

+ +`unwrap()` é una funzione che estrae il valore da una [`Option`][Option] o un [`Result`][Result] e va in errore se il valore non é presente. + +`unwrap()` non dovrebbe essere il tuo modo principale per gestire gli errori prevedibili, tipo un errore nell'input dell'utente. +Nel tuo codice, dovrebbe essere trattato come test per la non nullitá di un valore, pena il mandare in errore il programma. + +Viene utilizzato anche per provare velocemente quando non si vuole ancora gestire tutti i casi o negli articoli, quando la gestione degli errori potrebbe distrarre dal resto. + +

+Perché ottengo un errore quando provo a eseguire codice di esempio che utilizza la macro try!? +

+ +Quasi sicuramente é un problema con il tipo ritornato dalla funzione. La macro [`try!`][TryMacro] estrae un valore da [`Result`][Result] o ritorna con l'errore portato in [`Result`][Result]. +Ció significa che [`try`][TryMacro] vale solo per le funzioni che ritornano un [`Result`][Result], dove il tipo costruito `Err` implementa `From::from(err)`. +In particolare ció significa che la macro [`try!`][TryMacro] non é utlizzabile nella funzione `main`. + +

+Esiste un modo piú semplice per gestire gli errori rispetto a inserire Result ovunque? +

+ +Se stai cercando un modo per evitare di gestire i [`Result`][Result] nel codice di altre persone, puoi sempre utilizzare [`unwrap()`][unwrap] ma probabilmente non é ció che desideri. +[`Result`][Result] indica che una qualche operazione potrebbe fallire. Richiedere di gestire esplicitamente questi problemi é uno dei tanti modi in cui Rust incoraggia la scrittura di programmi affidabili. +Rust fornisce degli strumenti come la [macro `try!`][TryMacro] per gestire in ergonomia queste situazioni. + +Se davvero desideri non gestire un errore, utilizza [`unwrap()`][unwrap] ma sappi che fare ció implica che il codice arresterá la sua esecuzione in caso di fallimento, usualmente terminando il processo. + +

Concorrenza

+ +

+Posso utilizzare valori statici attraverso i thread senza utilizzare unsafe? +

+ +La mutabilitá é sicura solo se sincronizzata. Mutare un [`Mutex`][Mutex] statico (inizializzato tramite il pacchetto [lazy-static](https://crates.io/crates/lazy_static/)) non richiede un blocco di codice `unsafe` come non lo richiede la modifica di un [`AtomicUsize`][AtomicUsize] +(inizializzabile anche senza lazy_static). + +Piú in generale, se un tipo implementa il tratto [`Sync`][Sync] e non implementa [`Drop`][Drop], esso [é utilizzabile in una `static`](https://doc.rust-lang.org/book/const-and-static.html#static). + +

Macro

+ +

+Posso scrivere una macro per generare identificatori? +

+ +Al momento no. +Le macro di Rust sono ["hygienic macros"](https://en.wikipedia.org/wiki/Hygienic_macro) che intenzionalmente evitano la cattura o la creazione di identificatori che potrebbero collidere con altri. +Le loro capacitá sono significativamente differenti dagli stili delle macro normalmente associate ai preprocessori C. +Le invocazioni delle macro possono comparire sono il luoghi dove sono esplicitamente supportate: oggetti, dichiarazioni, espressioni e motivi. +Dove per "dichiarazioni" si intende uno spazio dove é possibile inserire un metodo. +Non si possono utilizzare le macro per completare una dichiarazione avventura parzialmente e seguendo la stessa logica, nemmeno per completare dichiarazioni parziali di variabili. + +

Debugging e strumentazione

+ +

+Come si debuggano i programmi Rust? +

+ +Si possono debuggare con [gdb](https://sourceware.org/gdb/current/onlinedocs/gdb/) o [lldb](http://lldb.llvm.org/tutorial.html), allo stesso modo di C e C++. +In realtá, ogni installazione di Rust viene fornita con uno o entrambi tra rust-gdb e rust-lldb(a seconda della piattaforma). Questi due componenti estendono gdb e lldb con funzioni per permettere una migliore esperienza. + +

+rustc ha detto che del codice della libreria standard é andato in crash, come faccio a trovare il problema? +

+ +Questo errore é spesso causato dall'utilizzo di [`unwrap()`][unwrap] su un `None` o `Err`. +Abilitando la variabile di ambiente `RUST_BACKTRACE=1` potresti ottenere ulteriori informazioni. +Potrebbe essere di aiuto anche la compilazione in modalitá debug (predefinita per il comando `cargo build`). +Si possono anche utilizzare i sopracitati `rust-gdb` o `rust-lldb`. + +

+Quale ambiente di sviluppo integrato dovrei utilizzare? +

+ +Ci sono molte opzioni per sviluppare in Rust, tutte illustrate sulla pagina ufficiale [sul supporto agli ambienti di sviluppo](https://forge.rust-lang.org/ides.html). + +

+gofmt é fantastico. Dov'é rustfmt? +

+ +`rustfmt` é [proprio qui](https://github.com/rust-lang-nursery/rustfmt), sta venendo sviluppato proprio per permettere di rendere il codice Rust il piú semplice e prevedibile possibile. + +

Low-Level

+ +

+Come posso usare memcpy? +

+ +Se vuoi clonare una partizione esistente in sicurezza, puoi usare [`clone_from_slice`][clone_from_slice]. + +Per copiare byte potenzialmente in conflitto usa [`copy`][copy]. +Per copiare byte non in conflitto usa [`copy_nonoverlapping`][copy_nonoverlapping]. +Entrambe le funzioni elencate sono `unsafe`, visto che possono eludere le garanzie di sicurezza. Sono quindi da utilizzare con attenzione. + +

+Puó Rust operare senza la sua libreria standard? +

+ +Sí. I programmi Rust possono scegliere di non caricare la libreria standard utilizzando l'attributo `#![no_std]`. +Una volta impostato, é ancora possibile utilizzare la libreria chiave di Rust, composta esclusivamente da primitivi indipendenti dalla piattaforma di esecuzione. Essa non include IO, concorrenza, allocazioni nella heap, ecc. + +

+Posso scrivere un sistema operativo in Rust? +

+ +Sí! In realtá al momento [ci sono molti progetti che stanno facendo proprio questo](http://wiki.osdev.org/Rust). + +

+Come faccio a scrivere o leggere tipi numerici come i32 o f64 in formato big-endian o little-endian in un file o un flusso di bit? +

+ +Dovresti provare il [pacchetto byteorder](http://burntsushi.net/rustdoc/byteorder/), che fornisce strumenti proprio per quello. + +

+Rust garantisce una specifica organizzazione dei dati? +

+ +Non in maniera predefinita. In generale, `enum` e `struct` non sono definiti. +Questo per permettere al compilatore di effettuare delle ottimizzazioni tipo riutilizzare la distanziatura per il discriminante, compattare le varianti di `enum` annidate, riordinare campi per eliminare spaziature, ecc. +Le `enum` prive di dati ("simil-C") possono avere rappresentazione definita. Tali `enum` sono facilmente distinte dal fatto che sono semplicemente una lista di nomi senza dati: + +```rust +enum SimilC { + A, + B = 32, + C = 34, + D +} +``` + +L'attributo `#[repr(C)]` se applicato a tali `enum` gli fornisce la stessa rappresentazione che avrebbero avuto nel C. +Questo permette nella maggior parte dei casi di utilizzare le `enum` di Rust nella FFI insieme alle `enum` fornite dal C. +Tale attributo é applicabile alle `struct` per ottenere la stessa rappresentazione delle `struct` del C. + +

Multipiattaforma

+ + + + + +

+Qual'é il modo consigliato per indicare comportamenti specifici a una piattaforma in Rust? +

+ +I comportamenti specifici alla piattaforma sono esprimibili utilizzando [attributi di compilazione condizionale](https://doc.rust-lang.org/reference.html#conditional-compilation) come ad esempio `target_os`, `target_family`, `target_endian`, ecc. + +

+Posso programmare per Android/iOS in Rust? +

+ +Sí! Ci sono giá alcuni esempi utilizzanti Rust sia per [Android](https://github.com/tomaka/android-rs-glue) che per [iOS](https://www.bignerdranch.com/blog/building-an-ios-app-in-rust-part-1/). +Richiede un pochino di lavoro di preparazione ma Rust funziona correttamente su entrambe le piattaforme. + +

+Posso eseguire il mio programma Rust in un browser web? +

+ +Non ancora ma sono in corso degli sforzi per permettere di compilare Rust per il web con [Emscripten](https://kripken.github.io/emscripten-site/). + +

+Come faccio a usare la compilazione incrociata in Rust? +

+ +La compilazione incrociata é possibile in Rust ma richiede [alcune accortezze](https://github.com/japaric/rust-cross/blob/master/README.md) per essere impostata. +Ogni compilatore Rust permette anche la compilazione incrociata ma le librerie necessitano di essere ricompilate per ogni piattaforma obiettivo. + +Rust distribuisce [copie della libreria standard](https://static.rust-lang.org/dist/) per ciascuna delle piattaforme supportate, ritrovabili nei file `rust-std-*` presenti nella pagina citata ma ad oggi non esistono metodi automatizzati per installarle. + +

Moduli e pacchetti

+ +

+Come si correlano moduli e pacchetti? +

+ +- Un pacchetto é un'unitá compilabile, ovvero la minima quantitá di codice su cui il compilatore Rust puó ancora operare. +- Un modulo é una organizzazione di unitá compilabili(anche annidate) all'interno di un pacchetto. +- Un pacchetto contiene un modulo implicito e senza nome nel suo livello piú alto. +- Le definizioni ricorsive sono propagabili ai moduli ma non ai pacchetti. + +

+Perché il compilatore Rust non riesce a trovare questa libreria che sto importando con use? +

+ +Ci sono diverse possibilitá ma un errore comune é non comprendere che le dichiarazioni `use` sono relative al livello base del pacchetto. +Prova a riscrivere le tue dichiarazioni in modo che utilizzino i percorsi relativi alla cartella base del pacchett per provare a risolvere il problema. + +Ci sono anche `self` e `super`, che rendono i percorsi di `use` riferiti rispettivamente al modulo corrente o al modulo padre. + +Per ulteriori informazioni su come utilizzare `use`, leggi il capitolo del libro di Rust ["Crates and Modules"](https://doc.rust-lang.org/stable/book/crates-and-modules.html). + +

+Perché devo dichiarare i file dei moduli con mod al posto di poterli invocare con use direttamente? +

+ +Ci sono due modi per dichiarare i moduli in Rust, in linea o in un altro file. Ecco un esempio: + +```rust +// Dentro a main.rs +mod ciao { + pub fn f() { + println!("ciao!"); + } +} + +fn main() { + ciao::f(); +} +``` + +```rust +// Dentro a main.rs +mod ciao; + +fn main() { + ciao::f(); +} + +// Dentro a ciao.rs +pub fn f() { + println!("ciao!"); +} +``` + +Nel primo esempio, il modulo é definito nello stesso file in cui é utilizzato, nel secondo, la dichiarazione del modulo dice al compilatore di cercare o il file `ciao.rs` o `ciao/mod.rs` e di caricarlo. + +Notare la differenza tra `mod` e `use`: `mod` dichiara l'esistenza di un modulo, mentre `use` fa riferimento a un modulo dichiarato altrove, rendendone accessibili i suoi contenuti all'interno del modulo corrente. + +

+Come configuro Cargo all'utilizzo di un proxy? +

+ +Come spiegato nella [guida alla configurazione di Cargo](http://doc.crates.io/config.html), puó essere impostato un proxy impostando la variabile "proxy" sotto `[http]` nel file di configurazione. + +

+Perché il compilatore non riesce a trovare l'implementazione del metodo anche se ho giá specificato la direttiva use sul pacchetto che la contiene? +

+ +Per i metodi definiti su un tratto, devi esplicitamente importare la dichiarazione del tratto. Questo significa che non é sufficiente importare un modulo dove una `struct` implementa un tratto, bisogna importare anche il tratto stesso. + +

+Perché il compilatore non puó capire gli use da solo? +

+ +Probabilmente potrebbe ma non lo vorresti. Mentre in molti casi é probabile che il compilatore possa determinare correttamente il modulo da importare guardando le definizioni questo potrebbe non applicarsi a tutte le casistiche. +Ogni decisione fatta da `rustc` genererebbe sopresa e confusione in alcuni casi e Rust preferisce essere esplicito riguardo all'origine dei nomi. + +Ad esempio, il compilatore potrebbe decidere che nel casi due identificatori fossero in conflitto sia da preferire l'identificatore la cui dichiarazione é meno recente. +In questo caso sia il modulo `foo` che il modulo `bar` definiscono l'identificatore `baz` ma `foo` viene registrato per primo e quindi il compilatore inserirebbe `use foo::baz;`. + +```rust +mod foo; +mod bar; + +// use foo::baz // ció che sarebbe inserito. + +fn main() { + baz(); +} +``` + +Sapendo questa dinamica, probabilmente risparmieresti qualche carattere ma aumenteresti anche la possibilitá di generare degli errori imprevisti quando in realtá al posto di `baz()` intendevi `bar::baz()`, diminuendo anche la leggibilitá del codice, +avendo reso la chiamata alla funzione dipendente dall'ordine di dichiarazione. Questi sono compromessi che Rust non ha intenzione di prendere. + +Ad ogni modo, in futuro, un ambiente di sviluppo integrato potrebbe assistere nella gestione delle dichiarazioni, fornendo il massimo di entrambi i mondi: assistenza automatica nelle dichiarazioni ma chiarezza sulle origini dei nomi importati. + + + +

+Come carico dinamicamente librerie in Rust? +

+ +Puoi importare librerie dinamiche in Rust con [libloading](https://crates.io/crates/libloading), che fornisce un sistema multipiattaforma per il link dinamico. + +

+Perché crates.io non ha uno spazio dei nomi? +

+ +Citando la [spiegazione ufficiale](https://internals.rust-lang.org/t/crates-io-package-policies/1041) sul design di [https://crates.io](https://crates.io): + +> Nel primo mese di crates.io, un buon numero di persone hanno richiesto la possibilitá di introdurre [pacchetti con spazi dei nomi](https://github.com/rust-lang/crates.io/issues/58).

+> +> Mentre questi permettono a autori multipli di utilizzare un singolo nome generico, aggiungono complessitá su come i pacchetti vengono indicati nel codice Rust e nella comunicazione su di essi. A una prima occhiata questo permetterebbe a piú persone di associarsi al nome `http`, ma questo implicherebbe che per riferirsi a due pacchetti di autori diversi si debbe parlare ad esempio di `http di wycats` o di `http di reem`, offrendo pochi vantaggi rispetto a nomi come `wycats-http` o `reem-http`.

+> +> Inoltre, osservando questa scelta abbiamo scoperto che le persone tendono a utilizzare nomi piú creativi (come `nokogiri` invece che "libxml2 di tendelove"). Questi nomi creativi tendono a essere brevi e memorabili, in parte anche grazie della mancanza di dipendenze da altri. Rendono anche piú semplice parlare in modo conciso e non ambiguo di pacchetti, creando nuovi nomi altisonanti. Esistono diversi ecosistemi da oltre 10,000 pacchetti come NPM e RubyGems le cui comunitá prosperano anche sotto un singolo spazio dei nomi.

+> +> In breve, non pensiamo che l'ecosistema Cargo avrebbe giovamento se Piston scegliesse un nome come `bvssvni/game-engine` (permettendo ad altri di scegliere `wycats/game-engine`) invece che semplicemente `piston`.

+> +> Proprio perché gli spazi dei nomi sono piú complessi in diversi ambiti ed essendo la loro aggiunta possibile se necessario, per ora abbiamo intenzione di preservare un singolo spazio dei nomi condiviso. + +

Librerie

+ +

+Come faccio a fare una richiesta HTTP? +

+ +La libreria standard non contiene un'implementazione di HTTP quindi dovrai utilizzare un pacchetto esterno. +[Hyper](https://github.com/hyperium/hyper) é la piú popolare ma ce ne sono [tante altre](https://crates.io/keywords/http). + +

+Come faccio a scrivere un applicativo con interfaccia grafica in Rust? +

+ +Ci sono molti modi per fare applicazioni con interfaccia grafica in Rust. +Guarda questa lista di [librerie per realizzare interfacce grafiche](https://github.com/kud1ing/awesome-rust#gui). + +

+Come faccio a deserializzare JSON/XML? +

+ +[Serde](https://github.com/serde-rs/serde) é la libreria consigliata per serializzare e deserializzare di dati in Rust da e verso una moltitudine di formati. + +

+Esiste una libreria standard per la geometria e vettoriali 2D+? +

+ +Non ancora! Puoi farne una tu? + +

+Come faccio a creare un applicativo OpenGL in Rust? +

+ +[Glium](https://github.com/tomaka/glium) é la principale libreria per utilizzare OpenGL in Rust. [GLFW](https://github.com/bjz/glfw-rs) é un'altra opzione valida. + +

+Posso fare un videogioco in Rust? +

+ +Certo! La principale libreria per programmare giochi in Rust é [Piston](http://www.piston.rs/) ci sono sia un [subreddit per la creazione di videogiochi in Rust](https://www.reddit.com/r/rust_gamedev/) e un canale IRC (`#rust-gamedev` su [Mozilla IRC](https://wiki.mozilla.org/IRC)). + +

Paradigmi di programmazione

+ +

+Rust é orientato agli oggetti? +

+ +Rust é multi paradigma. Molte cose possibili in linguaggi orientati agli oggetti sono possibili in Rust ma non proprio tutto e non sempre utilizzando un livello di astrazione uguale a quello a cui si é abituati. + +

+Come converto concetti della programmazione orientata agli oggetti in Rust? +

+ +Dipende. _Esistono_ modi per convertire concetti orientati agli oggetti come [ereditarietá multiple](https://www.reddit.com/r/rust/comments/2sryuw/ideaquestion_about_multiple_inheritence/) a Rust ma non essendo Rust orientato agli oggetti il risultato della conversione potrenne apparire sostanzialmente diverso dalla sua rappresentazione in un linguaggio orientato agli oggetti. + +

+Come gestisco la configurazione di una `struct` con parametri opzionali? +

+ +Il modo piú semplice é utilizzare il tipo [`Option`][Option] in qualsiasi funzione venga utilizzata per costruire istanze della struttura (generalmente `new()`). +Un altro modo é utilizzare il [metodo del costruttore](https://aturon.github.io/ownership/builders.html), dove alcune funzioni devono essere chiamate dopo la costruzione del tipo. + +

+Come faccio le variabili globali in Rust? +

+ +Le globali in Rust possono essere fatte utilizzando la dichiarazione `const` per le globali computate al momento della compilazione, mentre `static` é utilizzabile per globali mutabili. +Nota che la modifica di una variabile `static mut` richiede `unsafe`, visto che permette problemi di concorrenza, una cosa impossibile nel Rust sicuro. +Una differenza importante tra `const` e `static` é che si possono prendere riferimenti a valori `static` ma non a valori `const` se privi di posizione in memoria specificata. +Per ulteriori informazioni su `const` e `static`, leggi [il libro di Rust](https://doc.rust-lang.org/book/const-and-static.html). + +

+Come faccio a impostare delle costanti al momento della compilazione proceduralmente? +

+ +Rust attualmente possiede un supporto limitato per le costanti al momento della compilazione. +Puoi definire dei primitivi con le dichiarazioni `const` (simili a `static` ma immutabili e senza una specifica locazione in memoria) funzioni `const` e metodi correlati. + +Per definire costanti procedurali che non possono essere definite tramite questi meccanismi usa il pacchetto [`lazy-static`](https://github.com/rust-lang-nursery/lazy-static.rs), che emula l'assegnazione al momento della compilazione assegnando il valore al primo utilizzo. + +

+Posso eseguire del codice di inizializzazione prima di main? +

+ +Rust non consente l'esistenza di qualcosa prima di `main`. +La cosa piú vicina puó essere fatta tramite il pacchetto [`lazy-static`](https://github.com/Kimundi/lazy-static.rs), simulante una situazione "pre-main" in cui le variabili statiche vengono inizializzate al loro primo utilizzo. + + + +

+Rust permette di assegnare alle globali espressioni non costanti? +

+ +No. Le globali non possono non avere un costruttore costante e non possiedono un destrutture. I costruttori statici sono sconvenienti perché assicurare un ordine di inizializzazione statico é complesso. Le situazioni "pre-main" sono spesso considerate sconvenienti e Rust non le consente. + +Leggi anche il [domande frequenti del C++](http://yosefk.com/c++fqa/ctors.html#fqa-10.12) che fa menzione del "problema dell'ordine di inizializzazione per le static" e il [blog di Eric Lippert](https://ericlippert.com/2013/02/06/static-constructors-part-one/) per le problematiche in C#, che anche esso possiede queste funzioni. + +Puoi emulare globali il cui valore non é costante con il pacchetto [lazy-static](https://crates.io/crates/lazy_static/). + +

Altri linguaggi

+ +

+Come posso implementare in Rust quello che in C si puó ottenere con struct X { static int X; }; ? +

+ +Rust non possiede campi `static` come nel codice sopra. Al loro posto puoi dichiarare una varibile `static` a un determinato modulo, che viene preservata privata all'interno dello stesso. + +

+Come converto una enum simil-C a un intero e vice versa? +

+ +Convertire una enum simil-C a un intero é possibile con l'espressione `as` come in `e as i64` (dove `e` é una enum). + +La conversione in altre direzioni puó essere svolta tramite `match`, che associa differenti valori numerici a differenti potenziali valori per la enum. + +

+Perché i programmi in Rust sono piú grandi su disco di programmi C? +

+ +Ci sono diversi fattori che contribuiscono alla tendenza di Rust di avere in generale file binari piú grandi di programmi funzionalmente equivalenti in C. +In generale Rust si focalizza su ottimizzare le prestazioni di programmi reali, non le dimensioni di piccoli programmi. + +__Monomorfizzazione__ + +Rust monomorfizza i generici, ovvero che viene generata una nuova versione di una funzione generica o tipo per ciascuna dichiarazione effettuata con tipi distinti. Questo assomiglia ai template in C++. Ad esempio, nel programma seguente: + +```rust +fn foo(t: T) { + // ... qualcosa +} + +fn main() { + foo(10); // i32 + foo("ciao"); // &str +} +``` + +Nel file eseguibile finale vi saranno due versioni diverse di `foo`, una specifica al tipo in ingresso `i32` e l'altra specifica al tipo in ingresso `&str`. +Questo permette un efficiente dispacciamento statico della funzione generica ma aumentando le dimensioni dell'eseguibile finale. + +__Simboli di debug__ + +I programmi Rust sono compilati con i simboli di debug inclusi, anche se in modalitá rilascio. Questi sono utilizzabili per fornire informazioni in caso di crash e possono essere rimossi con `strip`, o un qualsiasi altro strumento per la rimozione di simboli di debug. +Risulta utile sapere anche che compilare in modalitá rilascio con Cargo equivale a impostare il livello di ottimizzazione 3 con rustc. +Un livello alternativo di ottimizzazione (chiamato `s` o `z`) [aggiunto recentemente](https://github.com/rust-lang/rust/pull/32386) indica al compilatore di focalizzarsi invece che sulle prestazioni, sulle dimensioni dell'eseguibile finale. + +__Jemalloc__ + +Rust utilizza jemalloc come il suo allocatore predefinito, questo aumenta le dimensioni dei binari compilati. +Jemalloc é stato scelto perché é un allocatore consistente e di qualitá con caratteristiche prestazionali preferibili rispetto agli allocatori forniti da molti sistemi. +Al momento si stanno facendo esperimenti su come [rendere piú facile l'utilizzo di allocatori personalizzati](https://github.com/rust-lang/rust/issues/32838) ma la funzionalitá non é stata ancora ultimata. + +__Ottimizzazione del linker__ + +Rust di base non effettua ottimizzazioni al momento del linking ma gli piú essere detto di farlo. +Questo incrementa la quantitá di ottimizzazioni effettuabili e puó avere un effetto sulle dimensioni dei binari generati, questo effetto puó essere amplificato se in combinazione con l'opzione di ottimizzazione per dimensioni sopracitata. + +__Libreria standard__ + +La libreria standard di Rust include libbacktrace e libunwind, che potrebbero essere non volute in alcuni programmi. +Utilizzare `#![no_std]` puó quindi fornire dei binari piú piccoli ma cambia in modo sostanziale il modo in cui il codice deve essere scritto. +Nota che utilizzare Rust senza la libreria standard é spesso funzionalmente vicino al codice C equivalente. + +Per esempio, il programma seguente in C legge un nome e dice "ciao" alla persona con quel nome: + +```c +#include + +int main(void) { + printf("Come ti chiami?\n"); + char input[100] = {0}; + scanf("%s", input); + printf("Ciao %s!\n", input); + return 0; +} +``` + +Per riscrivere questo programma in Rust scriveresti una cosa del genere: + +```rust +use std::io; + +fn main() { + println!("Come ti chiami?"); + let mut input = String::new(); + io::stdin().read_line(&mut input).unwrap(); + println!("Ciao {}!", input); +} +``` + +Questo programma, quando compilato e confrontato con il programma C avrá una dimensione maggiore e utilizzerá piú memoria ma non é esattamente equivalente al codice C che lo precede. +Il reale equivalente in realtá assomiglia di piú a questo: + +```rust +#![feature(lang_items)] +#![feature(libc)] +#![feature(no_std)] +#![feature(start)] +#![no_std] + +extern crate libc; + +extern "C" { + fn printf(fmt: *const u8, ...) -> i32; + fn scanf(fmt: *const u8, ...) -> i32; +} + +#[start] +fn start(_argc: isize, _argv: *const *const u8) -> isize { + unsafe { + printf(b"Come ti chiami?\n\0".as_ptr()); + let mut input = [0u8; 100]; + scanf(b"%s\0".as_ptr(), &mut input); + printf(b"Ciao %s!\n\0".as_ptr(), &input); + 0 + } +} + +#[lang="eh_personality"] extern fn eh_personality() {} +#[lang="panic_fmt"] fn panic_fmt() -> ! { loop {} } +#[lang="stack_exhausted"] extern fn stack_exhausted() {} +``` + +Che dovrebbe certamente eguagliare il C nell'utilizzo della memoria, incrementando peró la complessitá e rimuovendo le garanzie fornite dal codice Rust (evitate utilizzando `unsafe`). + +

+Perché Rust non ha una ABI stabile come il C e perché devo annotare le cose con extern? +

+ +Dedicarsi a una ABI é una decisione importante che puó limitare i cambiamenti vantaggiosi futuri. Dato che Rust ha raggiunto la versione 1.0 a Maggio 2015 é troppo presto per impegnarsi a costruire una ABI stabile. Ció peró non implica che non possa succedere nel futuro. +(Nonostante questo il C++ é riuscito a vivere per molti anni senza specificare una ABI stabile.) + +Il lemma `extern` permette di usare con Rust specifiche ABI, come quella ben definita del C, per interoperare con altri linguaggi. + +

+Puó il codice Rust chiamare il codice C? +

+ +Sí. Chiamare il C da Rust é progettato per avere la stessa efficienza delle chiamate di codice C dal C++. + +

+Puó il codice C chiamare il codice Rust? +

+ +Sí. Il codice Rust deve essere sposto mediante una dichiarazione `extern`, che lo rende compatibile con la ABI del C. +Tale funzione puó essere passata al codice C come puntatore a una funzione o, se con l'attributo `#[no_mangle]` chiamata direttamente dal C. + +

+Scrivo giá del C++ perfetto. Cosa mi fornisce di piú Rust? +

+ +Il C++ moderno include molte funzioni che rendono la scrittura di codice sicuro e corretto meno prono ad errori ma non é perfetto e rimane comunque facile introdurre vulnerabilitá. +Gli sviluppatori del C++ stanno cercando di porre rimedio a queste problematiche ma il C++ é limitato da una lunga storia che impedisce di attuare molte idee che si vorrebbero sperimentare. + +Rust é stato disegnato sin dal primo giorno per essere un linguaggio di programmazione per sistemi sicuro, questo significa che non é limitato da scelte pregresse che potrebbero impedire di raggiungere il corretto livello di sicurezza come il C++. +In C++, la sicurezza si ottiene mediante una rigorosa disciplina personale ed é semplice commettere errori mentre in Rust, la sicurezza é predefinita. +Rust permette quindi di lavorare in un gruppo di persone meno perfette di te, senza dover spendere il tuo tempo per controllare il codice altrui per controllare potenziali falle di sicurezza nel codice altrui. + +

+Come creo l'equivalente della specializzazione dei template del C++ in Rust? +

+ +Rust attualmente non ha un equivalente esatto alla specializzazione dei template ma [ci si sta lavorando su](https://github.com/rust-lang/rfcs/pull/1210) e verrá probabilmente aggiunta a presto. +Ad ogni modo, effetti simili si possono ottenere con i [tipi associati](https://doc.rust-lang.org/stable/book/associated-types.html). + +

+Come si compara il sistema dei possessi in Rust con le semantiche del movimento in C++? +

+ +I concetti base sono simili ma i due sistemi differiscono nella pratica. +In entrambi i sistemi "muovere" un valore é un modo per trasferire il possesso +delle risorse sottostanti. Ad esempio, muovere una stringa trasferisce il suo buffer +al posto di copiarla. + +In Rust il trasferimento di possesso é il comportamento standard. +Ad esempio, se scrivo una funzione che accetta una `String` come parametro, +questa funzione prenderá possesso del valore della `String` fornita dal chiamante: + +```rust +fn elabora(s: String) { } + +fn chiamante() { + let s = String::from("Ciao mondo!"); + elabora(s); // Trasferisce la proprietá di `s` a `elabora` + elabora(s); // Errore! il possesso é giá stato trasferito. +} +``` + +Come puoi vedere nel frammento di codice sopra, nella funzione `chiamante`, +la prima chiamata a `elabora` trasferisce il possesso della variabile `s`. +Il compilatore tiene traccia del possesso, quindi una seconda chiamata a +`elabora` genere un errore perché non é consentito trasferire il possesso +dello stesso valore due volte. +Rust previene anche il movimento di un valore se vi é ancora un +riferimente ad esso. + +Il C++ ha un approccio distinto, il comportamento predefinito é infatti +di copiare un valore (nello specifico invocandone il costruttore della copia). +Ad ogni modo i chiamati possono dichiarare i loro parametri utilizzando +un "riferimento rvalore" come `string&&`, per indicare che prenderanno +possesso di parte delle risorse possedute dal paramentro(in questo caso +il buffer interno della stringa). +Il chiamante deve quindi passare un'espressione temporanea o effettuare +un movimento esplicito utilizzando `std::move`. +Un abbozzo della funzione `elabora` sopra sarebbe quindi: + +``` +void elabora(string&& s) { } + +void chiamante() { + string s("Ciao mondo!"); + elabora(std::move(s)); + elabora(std::move(s)); +} +``` + +I compilatori C++ non sono tenuti a tenere traccia dei movimenti. +Ad esempio, il codice sopra viene compilato senza alcun avviso o errore +utilizzando l'ultima versione di Clang. +Inoltre in C++ il possesso della stringa `s` stessa +(se non del suo buffer interno) rimane in `chiamante`, e quindi il +destruttore di `s` verrá eseguito quando `chiamante` ritorna, anche se +é stato spostato (in Rust, al contrario, i valori spostati sono rimossi +dai nuovi proprietari). + +

+Come posso interoperare il C++ da Rust, o il Rust da C++? +

+ +Il Rust é il C++ possono interoperare tramite il C. Sia il Rust che il C++ forniscono una [foreign function interface](https://doc.rust-lang.org/book/ffi.html) per il C, che puó essere utilizzata per comunicare tra di loro. +Se scrivere dei collegamenti in C é troppo complicato, puoi sempre utilizzare [rust-bindgen](https://github.com/crabtw/rust-bindgen) per generare automaticamente dei collegamenti C++ funzionanti. + +

+Rust possiede dei costruttori in stile C++? +

+ +No. Al loro posto si utilizzano delle funzioni, il cui nome usuale é `new()`, ad ogni modo questa é semplicemente una convenzione e non una regola del linguaggio. +La funzione `new()` é semplicemente un'altra funzione. Un esempio di ció é questo: + +```rust +struct Foo { + a: i32, + b: f64, + c: bool, +} + +impl Foo { + fn new() -> Foo { + Foo { + a: 0, + b: 0.0, + c: false, + } + } +} +``` + +

+Rust possiede dei costruttori copia? +

+ +Non esattamente. I tipi che implementano `Copy` faranno una copia simil-C senza alcun lavoro aggiuntivo. +Non é possibile peró implementare tipi `Copy` che richiedono un comportamento personalizzato alla copia. +Al loro posto in Rust i costruttori copia sono creati implementando il tratto e successivamente chiamando il metodo `clone`. +Permettere di definire manualmente l'operatore copia permette di ridurre la complessitá, facilitando per lo sviluppatore l'identificazione di operazioni potenzialmente costose. + +

+Rust possiede dei costruttori di movimento? +

+ +No. I valori di tutti i tipi sono mossi tramite `memcpy`. +Questo permette di scrivere del codice `unsafe` generico molto piú semplice, dato che l'assegnazione, il passaggio e il ritorno di valori sono privi di effetti collaterali. + +

+In cosa si assomigliano Go e Rust, in cosa sono invece diversi? +

+ +Rust e Go hanno degli obiettivi molto differenti. Le differenze seguenti non sono le uniche (sarebbero troppe per elencarle) ma eccone alcune tra le piú importanti: + +- Rust é di piú basso livello di Go. Ad esempio, Rust non richiede un garbage collector, mentre Go sí. In generale Rust permette un livello di controllo comparabile con il C o il C++. +- Rust si focalizza sul garantire sicurezza ed efficienza mantenendo astrazioni di alto livello mentre Go vuole essere un linguaggio compatto e semplice che compila velocemente e puó funzionare con molti strumenti. +- Rust supporta la programmazione generica, Go no. +- Rust ha forti influenze dal mondo della programmazione funzionale, includendo il sistema dei tipi derivato dalle typeclasses di Haskell. Go ha un sistema dei tipi piú semplici, utilizzanti interfacce compatibili con la programmazione generica. + +

+Come si comparano i tratti di Rust con le typeclasses di Haskell? +

+ +I tratti in Rust somigliano alle typeclasses di Haskell ma attualmente non sono cosí potenti, dato che Rust non puó esprimere i tipi di piú altro livello. I tipi associati di Rust sono gli equivalenti delle famiglie di tipi di Haskell. + +Alcune differenze specifiche tra le typeclasses di Haskell e i tratti di Rust includono: + +- I tratti in Rusta hanno un primo parametro implicito chiamato `Self`. `trait Bar` in Rust corrisponde a `class Bar self` in Haskell e `trait Bar` in Rust corrisponde a `class Bar foo self` in Haskell. +- I "Supertratti" o "limitatori di superclass" in Rust sono scritti `trait Sub: Super`, mentre in Haskell `class Super self => Sub self`. +- Rust vieta istanze orfanes, indicando regole di coerenza differenti tra Rust e Haskell. +- La risoluzione dell `impl` di Rust considera le clausole `where` e i relativi tratti per decidere se due `impl` si sovrappongono, o per scegliere tra diverse `impl` possibili. Haskell considera ció solo nelle dichiarazioni `instance`, ignorando ogni limitazione posta altrove. +- Un sottoinsieme dei tratti di Rust (Quelli ["object safe"](https://github.com/rust-lang/rfcs/blob/master/text/0255-object-safety.md)) puó essere usato per il dispacciamento dinamico mediante tratti. La stessa funzionalitá é disponibile in Haskell attraverso il metodo di GHC `ExistentialQuantification`. + +

Documentazione

+ +

+Perché su Stack Overflow molte delle risposte su Rust sono sbagliate? +

+ +Il linguaggio Rust é pubblico da diversi anni e ha raggiunto la versione 1.0 a Maggio del 2015. +Nei periodi precedenti il linguaggio ha ricevuto delle modifiche sostanziali e molte risposte fanno riferimento a versioni vecchie del linguaggio. + +Nel tempo sempre piú risposte saranno disponibili per la versione corrente, migliorando la problematica alterando il rapporto tra le risposte corrette e quelle sbagliate. + +

+Dove segnalo problemi alla documentazione di Rust? +

+ +Puoi segnalare problemi con la documentazione sul [pannello delle problematiche](https://github.com/rust-lang/rust/issues) di Rust. +Assicurati peró di leggere [linee guida alla contribuzione](https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#writing-documentation) prima. + +

+Come posso vedere la documentazione di rustdoc di una dipendenza del mio progetto? +

+ +Quando utilizzi `cargo doc` per generare la documentazione per il tuo progetto, il comando genera anche la documentazione per le dipendenze attive. +Le puoi trovare nella cartella `target/doc` del progetto. +Usa `cargo doc --open` per aprire i documenti dopo averli generati o semplicemente apri da solo `target/doc/index.html`. + +[Vec]: https://doc.rust-lang.org/stable/std/vec/struct.Vec.html +[HashMap]: https://doc.rust-lang.org/stable/std/collections/struct.HashMap.html +[Into]: https://doc.rust-lang.org/stable/std/convert/trait.Into.html +[From]: https://doc.rust-lang.org/stable/std/convert/trait.From.html +[Eq]: https://doc.rust-lang.org/stable/std/cmp/trait.Eq.html +[PartialEq]: https://doc.rust-lang.org/stable/std/cmp/trait.PartialEq.html +[Ord]: https://doc.rust-lang.org/stable/std/cmp/trait.Ord.html +[PartialOrd]: https://doc.rust-lang.org/stable/std/cmp/trait.PartialOrd.html +[f32]: https://doc.rust-lang.org/stable/std/primitive.f32.html +[f64]: https://doc.rust-lang.org/stable/std/primitive.f64.html +[i32]: https://doc.rust-lang.org/stable/std/primitive.i32.html +[i64]: https://doc.rust-lang.org/stable/std/primitive.i64.html +[bool]: https://doc.rust-lang.org/stable/std/primitive.bool.html +[Hash]: https://doc.rust-lang.org/stable/std/hash/trait.Hash.html +[BTreeMap]: https://doc.rust-lang.org/stable/std/collections/struct.BTreeMap.html +[VecMacro]: https://doc.rust-lang.org/stable/std/macro.vec!.html +[String]: https://doc.rust-lang.org/stable/std/string/struct.String.html +[to_string]: https://doc.rust-lang.org/stable/std/string/trait.ToString.html#tymethod.to_string +[str]: https://doc.rust-lang.org/stable/std/primitive.str.html +[str__find]: https://doc.rust-lang.org/stable/std/primitive.str.html#method.find +[str__as_bytes]: https://doc.rust-lang.org/stable/std/primitive.str.html#method.as_bytes +[u8]: https://doc.rust-lang.org/stable/std/primitive.u8.html +[char]: https://doc.rust-lang.org/stable/std/primitive.char.html +[Weak]: https://doc.rust-lang.org/stable/std/rc/struct.Weak.html +[IntoIterator]: https://doc.rust-lang.org/stable/std/iter/trait.IntoIterator.html +[Rc]: https://doc.rust-lang.org/stable/std/rc/struct.Rc.html +[UnsafeCell]: https://doc.rust-lang.org/stable/std/cell/struct.UnsafeCell.html +[Copy]: https://doc.rust-lang.org/stable/std/marker/trait.Copy.html +[Clone]: https://doc.rust-lang.org/stable/std/clone/trait.Clone.html +[Cell]: https://doc.rust-lang.org/stable/std/cell/struct.Cell.html +[RefCell]: https://doc.rust-lang.org/stable/std/cell/struct.RefCell.html +[Cow]: https://doc.rust-lang.org/stable/std/borrow/enum.Cow.html +[Deref]: https://doc.rust-lang.org/stable/std/ops/trait.Deref.html +[Arc]: https://doc.rust-lang.org/stable/std/sync/struct.Arc.html +[Box]: https://doc.rust-lang.org/stable/std/boxed/struct.Box.html +[Option]: https://doc.rust-lang.org/stable/std/option/enum.Option.html +[Fn]: https://doc.rust-lang.org/stable/std/ops/trait.Fn.html +[FnMut]: https://doc.rust-lang.org/stable/std/ops/trait.FnMut.html +[FnOnce]: https://doc.rust-lang.org/stable/std/ops/trait.FnOnce.html +[Result]: https://doc.rust-lang.org/stable/std/result/enum.Result.html +[RandomState]: https://doc.rust-lang.org/stable/std/collections/hash_map/struct.RandomState.html +[Add]: https://doc.rust-lang.org/stable/std/ops/trait.Add.html +[AddAssign]: https://doc.rust-lang.org/stable/std/ops/trait.AddAssign.html +[Sub]: https://doc.rust-lang.org/stable/std/ops/trait.Sub.html +[SubAssign]: https://doc.rust-lang.org/stable/std/ops/trait.SubAssign.html +[Mul]: https://doc.rust-lang.org/stable/std/ops/trait.Mul.html +[MulAssign]: https://doc.rust-lang.org/stable/std/ops/trait.MulAssign.html +[Div]: https://doc.rust-lang.org/stable/std/ops/trait.Div.html +[DivAssign]: https://doc.rust-lang.org/stable/std/ops/trait.DivAssign.html +[Neg]: https://doc.rust-lang.org/stable/std/ops/trait.Neg.html +[Rem]: https://doc.rust-lang.org/stable/std/ops/trait.Rem.html +[RemAssign]: https://doc.rust-lang.org/stable/std/ops/trait.RemAssign.html +[BitAnd]: https://doc.rust-lang.org/stable/std/ops/trait.BitAnd.html +[BitAndAssign]: https://doc.rust-lang.org/stable/std/ops/trait.BitAndAssign.html +[BitOr]: https://doc.rust-lang.org/stable/std/ops/trait.BitOr.html +[BitOrAssign]: https://doc.rust-lang.org/stable/std/ops/trait.BitOrAssign.html +[BitXor]: https://doc.rust-lang.org/stable/std/ops/trait.BitXor.html +[BitXorAssign]: https://doc.rust-lang.org/stable/std/ops/trait.BitXorAssign.html +[Not]: https://doc.rust-lang.org/stable/std/ops/trait.Not.html +[Shl]: https://doc.rust-lang.org/stable/std/ops/trait.Shl.html +[ShlAssign]: https://doc.rust-lang.org/stable/std/ops/trait.ShlAssign.html +[Shr]: https://doc.rust-lang.org/stable/std/ops/trait.Shr.html +[ShrAssign]: https://doc.rust-lang.org/stable/std/ops/trait.ShrAssign.html +[Deref]: https://doc.rust-lang.org/stable/std/ops/trait.Deref.html +[DerefMut]: https://doc.rust-lang.org/stable/std/ops/trait.DerefMut.html +[Index]: https://doc.rust-lang.org/stable/std/ops/trait.Index.html +[IndexMut]: https://doc.rust-lang.org/stable/std/ops/trait.IndexMut.html +[read__read_to_string]: https://doc.rust-lang.org/stable/std/io/trait.Read.html#method.read_to_string +[Read]: https://doc.rust-lang.org/stable/std/io/trait.Read.html +[std-io]: https://doc.rust-lang.org/stable/std/io/index.html +[File]: https://doc.rust-lang.org/stable/std/fs/struct.File.html +[read__read]: https://doc.rust-lang.org/stable/std/io/trait.Read.html#tymethod.read +[read__read_to_end]: https://doc.rust-lang.org/stable/std/io/trait.Read.html#method.read_to_end +[read__bytes]: https://doc.rust-lang.org/stable/std/io/trait.Read.html#method.bytes +[read__chars]: https://doc.rust-lang.org/stable/std/io/trait.Read.html#method.chars +[read__take]: https://doc.rust-lang.org/stable/std/io/trait.Read.html#method.take +[BufReader]: https://doc.rust-lang.org/stable/std/io/struct.BufReader.html +[Args]: https://doc.rust-lang.org/stable/std/env/struct.Args.html +[TryMacro]: https://doc.rust-lang.org/stable/std/macro.try!.html +[unwrap]: https://doc.rust-lang.org/stable/core/option/enum.Option.html#method.unwrap +[Mutex]: https://doc.rust-lang.org/stable/std/sync/struct.Mutex.html +[AtomicUsize]: https://doc.rust-lang.org/stable/std/sync/atomic/struct.AtomicUsize.html +[Sync]: https://doc.rust-lang.org/stable/std/marker/trait.Sync.html +[Drop]: https://doc.rust-lang.org/stable/std/ops/trait.Drop.html +[clone_from_slice]: https://doc.rust-lang.org/stable/std/primitive.slice.html#method.clone_from_slice +[copy]: https://doc.rust-lang.org/stable/std/ptr/fn.copy.html +[copy_nonoverlapping]: https://doc.rust-lang.org/stable/std/ptr/fn.copy_nonoverlapping.html +[clone]: https://doc.rust-lang.org/stable/std/clone/trait.Clone.html#tymethod.clone diff --git a/it-IT/friends.html b/it-IT/friends.html new file mode 100644 index 000000000..374f068a5 --- /dev/null +++ b/it-IT/friends.html @@ -0,0 +1,71 @@ +--- +layout: it-IT/basic +title: Gli amici di Rust · Linguaggio di programmazione Rust +--- + +
+ +

Gli amici di Rust

+

(Organizzazioni che utilizzano Rust in prodotti e sistemi)

+ + {% for user in site.data.users %} + {% assign mod = forloop.index | minus:1 | modulo:3 %} + {% if mod != 0 %} + {% continue %} + {% endif %} + + {% assign offset = forloop.index | minus:1 %} + +
+ {% for user in site.data.users limit:3 offset:offset %} +
+
+ + + +
+
+

{{user.name}} : {{user.how}}

+
+
+ + + {% endfor %} + +
+ + {% endfor %} + +

+ Se la tua organizzazione utilizza Rust nei suoi prodotti o internamente e desideri che compaia in questa pagina + ,
per favore + + apri una problematica e compila le informazioni richieste. +

+ +
diff --git a/it-IT/index.html b/it-IT/index.html new file mode 100644 index 000000000..155c19baf --- /dev/null +++ b/it-IT/index.html @@ -0,0 +1,63 @@ +--- +layout: it-IT/basic +title: Il linguaggio di programmazione Rust +--- + +
+
+

+ Rust é un linguaggio di programmazione per sistemi + ad altissime prestazioni + che previene errori di segmentazione + e garantisce la sicurezza dei dati tra i thread. +
+ Guarda chi utilizza Rust. +

+
+
+ +
Installa Rust {{ site.stable }}
+
+
{{ site.stable_date | date: "%B %-d, %Y" }}
+
+
+ +
+
+

Caratteristiche:

+
    +
  • astrazioni a costo zero
  • +
  • semantica movimenti in memoria
  • +
  • accesso sicuro alla memoria garantito
  • +
  • concorrenza senza data race
  • +
  • programmazione generica basata sui tratti
  • +
  • pattern matching
  • +
  • deduzione automatica dei tipi
  • +
  • tempo di esecuzione ridotto
  • +
  • interoperabilitá efficiente con il C
  • +
+
+
+
+ +
{% include it-IT/example.rs %}
+
+ +
+
+
{% include it-IT/example.rs.html %}
+ +
+
+ + diff --git a/it-IT/install.html b/it-IT/install.html new file mode 100644 index 000000000..3f4e8b328 --- /dev/null +++ b/it-IT/install.html @@ -0,0 +1,200 @@ +--- +layout: it-IT/default +title: Installazione · Linguaggio di programmazione Rust +--- +

Installa Rust

+ +
+
+ + + + + + + + +
+
+

Per installare Rust, su sistemi Unix,
esegui il seguente comando + nel tuo terminale e poi segui le istruzioni.

+
curl https://sh.rustup.rs -sSf | sh
+
+ +
+ +
+

+ Se sei su Windows,
scarica e esegui + rustup‑init.exe + poi segui le istruzioni a schermo. +

+
+
+ +
+ + + +
+ +

Note sull'installazione di Rust

+ +
+
+ +

Gestione del compilatore con rustup

+ +

+ Rust é installato e gestito da + rustup + . Rust é soggetto a un ciclo di + + rilascio rapido ogni 6 settimane + e supporta un + + gran numero di piattaforme + , quindi in ogni momento sono disponbili molte versioni di rust. + rustup gestisce queste versioni in modo affidabile su + ogni piattaforma supportata, permettendo di installare Rust dai canali + beta e nightly, includendo anche il supporto per la compilazione incrociata. +

+ +

+ Per ulteriori informazioni guarda la + + documentazione di + rustup + . +

+ +

Configurare la variable di ambiente PATH

+ +

+ Nell'ambiente di sviluppo Rust, tutti gli strumenti sono installati nelle cartelle + + ~/.cargo/bin + + , + qui é dove puoi trovare glis strumenti di rust, inclusi + rustc, cargo, and rustup. +

+ +

+ Di conseguenza, é corretto per gli sviluppatori Rust di + includere questa cartella nella loro + + Variabile di ambiente + PATH. + Durante l'installazione, rustup, + cercherá di configurare + PATH ma a causa delle disuguaglianze tra le + righe di comando delle piattaforme e bug in rustup, + le modifiche a + PATH potrebbero non avvenire fino al riavvio + della riga di comano, alla disconnessione dell'utente e + potrebbero non avvenire del tutto. +

+ +

+ Se, dopo l'installazione, l'esecuzione di rustc --version nella + riga di comando fallisce, questa é la ragione piú probabile. +

+ +
+ +

Considerazioni su Windows

+ + + +

+ Su Windows, Rust richiede inoltre gli strumenti di compilazione + C++ per Visual Studio 2013 o superiori. + Il modo piú semplice per ottenerli é installare + + Microsoft Visual C++ Build Tools 2015 + + che fornisce solo gli strumenti di compilazione Visual C++. + Alternativamente puoi + installare + Visual Studio 2015 o Visual Studio 2013 e durante l'installazione selezionare + gli "strumenti C++". +

+ +

+ Per ulteriori informazioni su come configurare Rust su Windows consulta la + documentazione di rustup + specifica per Windows. +

+ +
+ +
+
+ +

Altri metodi di installazione

+ +
+
+

+ L'installazione descritta sopra, tramite + rustup, é il modo piú consigliato per installare Rust per la maggior parte degli sviluppatori, + ma Rust puó anche + essere installato tramite altri metodi +

+
+
+ + + diff --git a/it-IT/legal.md b/it-IT/legal.md new file mode 100644 index 000000000..da6389c24 --- /dev/null +++ b/it-IT/legal.md @@ -0,0 +1,204 @@ +--- +layout: it-IT/default +title: Informazioni legali su Rust · Linguaggio di programmazione Rust +--- + +# Attribuzione e diritti + +## Codice sorgente + +Il [codice sorgente](https://github.com/rust-lang/rust) di Rust é distribuito +principalmente seguendo i termini della licenza MIT e della licenza Apache (versione 2.0), +con parti coperte da varie licenze simil-BSD. +Vedi [LICENSE-APACHE](https://github.com/rust-lang/rust/blob/master/LICENSE-APACHE), +[LICENSE-MIT](https://github.com/rust-lang/rust/blob/master/LICENSE-MIT), +e [COPYRIGHT](https://github.com/rust-lang/rust/blob/master/COPYRIGHT) per ulteriori dettagli. + +## Loghi e marchi + +I loghi di Rust e Cargo (bitmap e vettoriali) sono di proprietá di Mozilla e +distribuiti sotto i termini della +[Creative Commons Attribution license (CC-BY)](https://creativecommons.org/licenses/by/4.0/). +Questa é la licenza Creative Commons piú aperta che permette il riuso e la modifica +per qualsiasi scopo. Le restizioni sono che i distributori devono "creditare appropriatamente +fornendo un link alla licenza e indicare se sono state apportate modificazioni". +**Nota che l'utilizzo di questi loghi e dei nomi Rust, Cargo sono soggetti anche essi +ad attribuzione, con le norme illustrate sotto**. + +Varianti del logo di Rust si possono trovare qui: + +* [rust-logo-128x128-blk.png](/logos/rust-logo-128x128-blk.png) +* [rust-logo-128x128-blk-v2.png](/logos/rust-logo-128x128-blk-v2.png) +* [rust-logo-128x128.png](/logos/rust-logo-128x128.png) +* [rust-logo-16x16-blk.png](/logos/rust-logo-16x16-blk.png) +* [rust-logo-16x16.png](/logos/rust-logo-16x16.png) +* [rust-logo-256x256-blk.png](/logos/rust-logo-256x256-blk.png) +* [rust-logo-256x256.png](/logos/rust-logo-256x256.png) +* [rust-logo-32x32-blk.png](/logos/rust-logo-32x32-blk.png) +* [rust-logo-32x32.png](/logos/rust-logo-32x32.png) +* [rust-logo-512x512-blk.png](/logos/rust-logo-512x512-blk.png) +* [rust-logo-512x512.png](/logos/rust-logo-512x512.png) +* [rust-logo-64x64-blk.png](/logos/rust-logo-64x64-blk.png) +* [rust-logo-64x64.png](/logos/rust-logo-64x64.png) +* [rust-logo-blk.svg](/logos/rust-logo-blk.svg) + +# Politica di attribuzione + +I nomi e loghi di Rust e Cargo permettono di individuare ció che é ufficialmente +parte della comunitá di Rust e cosa non ne fa parte. +Siamo quindi attenti su dove permettiamo che essi appaiano. +Allo stesso tempo, vogliamo permettere il massimo utilizzo creativo +possibile per questi marchi. +La politica illustrata qui spiega come ottenere questo bilanciamento. +Se vuoi utilizzare questi nomi o marchi, specialmente se a fini di lucro, +leggi questa pagina o [contattaci](mailto:trademark@rust-lang.org) per parlarcene! + +**Troppo Lungo; Non lo leggo**: +La maggior parte degli utilizzi non commerciali dei nomi e loghi Rust/Cargo +sono ammessi e non richiedono autorizzazione; la maggior parte degli utilizzi commerciali +richiede autorizzazione. In entrambi i casi, la regola piú importante é che l'utilizzo di loghi e marchi +non deve apparire come ufficiale o come un supporto da parte del progetto Rust. + +## Attribuzione di Rust + +Il Linguaggio di programmazione Rust é un progetto open source della comunitá governato da un team di sviluppo. +Il progetto é anche sponsorizzato dalla Mozilla Foundation("Mozilla"), che possiede +e protegge l'attribuzione dei nomi e marchi di Rust e Cargo("I marchi di Rust"). +Questo documento fornisce informazioni inerenti l'utilizzo dei marchi di Rust specifici +al linguaggio di programmazione, includendo anche esempi di utilizzi comuni che le persone +potrebbero voler fare di questi marchi, con spiegazioni su come questi usi siano +autorizzati o no oppure se essi richiedono autorizzazioni specifiche. +Questo documento integra la [politica di attribuzione dei marchi ufficiale di Mozilla](https://www.mozilla.org/foundation/trademarks/policy/) +che regola l'utilizzo di tutti i marchi Mozilla. + +La registrazione del marchio di Rust include due lemmi e due loghi: + +* Rust +* Cargo +* +* + +I marchi registrati sono nomi o design che dicono al mondo l'origine di un bene o servizio. +Proteggere il marchio di un progetto open source é particolarmente importante. +Tutti possono modificare il codice sorgente e generare un prodotto da quel codice, +risulta quindi importante che solo il progetto originale o le sue variazioni autorizzate +possano usufruire dei marchi registrati. +Limitando attivamente l'utilizzo dei marchi di Rust, Mozilla e il progetto Rust +possono aiutare utenti e sviluppatori a sapere se stanno avendo accesso a un +prodotto facente parte del progetto Rust e non la versione modificata da qualcuno. +Il marchio registrato assicura gli utenti e gli sviluppatori della qualitá +e sicurezza del prodotto che stanno usando. + +## Utilizzo di marchi e loghi + +### Apparire ufficiali, affiliati o sostenuti + +La regola base é che i marchi di Rust non possono essere utilizzati in modo +che appaiano(a un osservatore medio) ufficiali, affiliati o sponsorizzati dal +progetto Rust o da Mozilla, almenoché non vi sia autorizzazione ufficiale da +parte del team di sviluppo. +Questo é il modo fondamentale in cui proteggiamo utenti e sviluppatori dalla confusione. + +Essendo questa regola inerente la gestione di percezioni é soggettiva e abbastanza +complessa da individuare concretamente. Ci sono alcuni modi ovvi per evitare +problemi come ad esempio includere la dicitura "non ufficiale" in modo evidente ma +se sei ancora dubbioso, saremo piú che felici di aiutarti; scrivici a +[trademark@rust-lang.org](mailto:trademark@rust-lang.org). + +### Le basi: parlare di Rust o Cargo + +Come con ogni marchio, Rust e Cargo possono essere utilizzati senza problemi +per riferirsi al linguaggio di programmazione, al gestore di pacchetti +e al registro pacchetti. + +Non possono essere utilizzati: + +- per riferirsi ad altri linguaggi di programmazione; +- in modo fuorviante o che possa implicare associazione con moduli esterni, + strumenti, documentazione o altre risorse del linguaggio di programmazione Rust; +- in modi che confondono la comunitá sul fatto che il linguaggio di programmazione Rust + sia o meno open source e libero da utilizzare. + +### Utilizzi che non richiedono esplicita approvazione + +Esistono una varietá di utilizzi che non richiedono esplicita autorizzazione. **Ad ogni modo, in tutti i casi sotto elencati, devi assicurarti che l'utilizzo dei marchi di Rust non appaia ufficiale, come illustrato sopra.** + +* É concesso indicare accuratamente che un programma é stato scritto nel linguaggio di programmazione Rust, +la sua compatibilitá con il linguaggio Rust o che contiene Rust stesso. +In questi casi, puoi utilizzare i marchi di Rust per indicare questo, senza +autorizzazione pregressa. Questo si applica sia agli utilizzi non commerciali che +a quelli con fini di lucro. + +* Utilizzare i marchi di Rust in nomi di prodotti non commerciali come RustPostgres, Rustymine +o nei nomi di repository di codice sorgente su ad esempio GitHub é concesso in riferimento +all'utilizzo o all'idoneitá del linguaggio di programmazione Rust. +Alcuni utilizzi potrebbero anche includere il logo di Rust, anche in forma modificata. +Nel caso di progetti commerciali(includendo il crowdfunding o progetti sponsorizzati), +per favore controlla con [trademark@rust-lang.org](mailto:trademark@rust-lang.org) per assicurarti +che il tuo utilizzo non appaia come ufficiale. + +* Utilizzare il marchio di Rust su magliette, cappelli e/o altri manufatti o merchandising, +anche se in forma modificata, é concesso per il tuo utilizzo personale o per l'utilizzo +da parte di un piccolo gruppo di membri della comunitá, a condizione che gli oggetti non siano in vendita. +Se vuoi distribuire del merchandise con i loghi di Rust a eventi affiliati al linguaggio +per favore contattaci per l'autorizzazione a [trademark@rust-lang.org](mailto:trademark@rust-lang.org). + +* Utilizzare i marchi di Rust(anche in forma modificata) per eventi sociali come +incontri, tutorial e simili é concesso per eventi per cui é gratuita la partecipazione. +Per eventi commerciali (inclusi quelli sponsorizzati), per favore controlla con [trademark@rust-lang.org](mailto:trademark@rust-lang.org). Ad ogni modo, le parole "RustCamp", "RustCon" o +"RustConf" non possono essere utilizzate senza esplicita autorizzazione. +In combinazione con le restrizioni precedenti **l'evento non deve risultare come ufficialmente supportato o organizzato dal progetto Rust** in assenza di autorizzazione scritta. + +* L'utilizzo del marchio di Rust in libri e pubblicazioni come "Il giornale di Rust" +"Manuale di Rust" é concesso. + +* L'utilizzo della parola "Rust" su siti web, brochure, documentazione, tesi di ricerca, +libri e confezioni di prodotti, se in riferimento al linguaggio di programmazione é concesso. + +### Utilizzi che richiedono esplicita approvazione + +* Distribuire una versione modificata del linguaggio di programmazione Rust, del +gestore di pacchetti Cargo e chiamarli Rust o Cargo richiede autorizzazione esplicita scritta da +parte del team di Rust. +Generalmente consentiamo questi utilizzi finché le modifiche apportate sono +(1) relativamente piccole e (2) molto ben comunicate agli utenti finali. + +* Vendere magliette, cappelli e/o altri manufatti o merchandising, +richiede un esplicito permesso scritto da parte del team di Rust. +Generalmente permettiamo questi utilizzi se (1) é indicato chiaramente +che il merchandising non fa parte in alcun modo del progetto Rust e se (2) +é chiaramente comunicato se i profitti possono essere a beneficio del +progetto Rust. + +* Utilizzare i marchi di Rust all'interno di un altro marchio registrato richiede +il permesso scritto dal Team di sviluppo di Rust eccetto i casi delineati sopra. + +## Note + +Se hai dubbi su come il tuo utilizzo inteso dei marchi di Rust +richieda autorizzazione, contattaci per favore a +[trademark@rust-lang.org](mailto:trademark@rust-lang.org). + +Questo documento é in parte derivato dalla +[Politica di utilizzo dei marchi della Python Software Foundation](https://www.python.org/psf/trademarks/). + +Questo documento non é una stesura ufficiale della politica dei marchi di Mozilla +ma é utile a chiarire la politica di attribuzione di Mozilla per quanto concerne Rust. + +## Aiutarci + +Come membreo della comunitá di Rust, per favore sii vigile nei confronti di utilizzi +discutibili del logo di Rust e del lemma "Rust". +Puoi segnalare abusi a +[trademark@rust-lang.org](mailto:trademark@rust-lang.org). Analizzeremo ciascun +caso e agiremo in modo opportuno. + +Per favore non notificare direttamente gli utilizzatori dei marchi con un reclamo. +I reclami dovrebbero essere gestiti da Mozilla e i suoi rappresentanti. + +Grazie! + +## Licenza + +Chi fosse interessato puó adattare questo documento in conformitá con la +[licenza Creative Commons CC0](https://creativecommons.org/publicdomain/zero/1.0/). diff --git a/it-IT/other-installers.md b/it-IT/other-installers.md new file mode 100644 index 000000000..3b97dcdb2 --- /dev/null +++ b/it-IT/other-installers.md @@ -0,0 +1,189 @@ +--- +layout: it-IT/default +title: Altri metodi di installazione · Linguaggio di programmazione Rust +--- + +# Altri metodi di installazione di Rust + +- [Quale installatore dovrei usare?](#which) +- [Altri modi per installare `rustup`](#more-rustup) +- [Installatori indipendenti](#standalone) +- [Codice sorgente](#source) + +## Quale installatore dovrei usare? + + +Rust funziona su molte piattaforme e ci sono molti modi per installare Rust. +Se vuoi installare Rust nel modo piú semplice e consigliato, segui le istruzioni +della [pagina di installazione principale][installation page]. + +Quella pagina descrive l'installazione tramite [`rustup`], uno strumento che +gestisce compilatori di rust multipli in modo stabile per tutte le piattaforme +supportate da Rust. +Perché quindi uno dovrebbe desiderare di _non_ utilizzarlo? +- Installazione offline. `rustup` scarica componenti dalla rete su richiesta. + se hai bisogno di installare Rust senza una connessione a internet, `rustup` + non é adatto. +- Preferenza per il gestore di pacchetti di sistema. Su Linux in particolare may + anche su macOS con [Homebrew] e in Windows con [Chocolatey], gli sviluppatori + a volte preferiscono installare Rust con il gestore di pacchetti del loro + sistema operativo. +- Astio contro `curl | sh`. Sugli Unix, installiamo `rustup` eseguendo + uno script scaricato da `curl`. Alcuni non si fidano di questa operazione + e preferiscono scaricare e installare Rust in autonomia. +- Verifica firme. Anche se `rustup` effettua download tramite HTTPS, + l'unico modo ad oggi possibile per verificare le firme digitali é + l'installazione manuale. +- Installazione da interfaccia grafica e integrazione con "Aggiungi/Rimuovi Programmi" + su Windows. `rustup` funziona da riga di comando e non registra le sue installazioni + nel menu di Windows come gli altri programmi. Se preferisci un'installazione piú + tipica su Windows sono disponibili gli installatori indipendenti `.msi`. + In futuro `rustup` includerá un'interfaccia grafica su Windows. + +Il supporto di Rust alle piattaforme é definito in [tre fasce][three tiers], che +corrispondono strettamente con il metodo di installazione disponibile: in generale, +Rust fornisce eseguibili per tutte le piattaforme di prima e seconda fascia, +rendendoli disponibili anche allo strumento `rustup`. +Alcune piattaforme di seconda fascia ad ogni modo hanno solo la libreria standard, +non il compilatore, possono quindi essere usate solo per la compilazione incrociata +da un'altra piattaforma. Queste piattaforme sono installabili con il comando +`rustup target add`. + +## Altri modi per installare `rustup` + + +Il modo per installare `rustup` differisce tra le piattaforme: + +* Sugli Unix, esegui `curl https://sh.rustup.rs -sSf | sh` nella tua riga di comando. + Questo scarica e esegue [`rustup-init.sh`], che a sua volta + scarica e esegue la versione di `rustup-init` piú + adatta alla piattaforma corrente. +* Su Windows, scarica e installa [`rustup-init.exe`]. + +`rustup-init` puó essere configurato interattivamente, tutte le operazioni +possono inoltre essere comandate da degli argomenti da riga di comando da +fornire allo script di installazione. Passando `--help` a `rustup-init` +fará mostrare gli argomenti disponibili: + +``` +curl https://sh.rustup.rs -sSf | sh -s -- --help +``` + +Se preferisci non usare lo script, puoi scaricare direttamente `rustup-init` +per una piattaforma a tua scelta: + +
+ {% for column in site.data.platforms.rustup %} +
+ {% for target in column %} + {% if target contains 'windows' %} + + {{ target }} + + {% else %} + + {{ target }} + + {% endif %} + {% endfor %} +
+ {% endfor %} +
+ +## Installatori indipendenti + + +L'installatore indipendente di Rust contiene una versione singola di rust e +permettono l'installazione in assenza di connessione a internet. +Sono disponibili in tre forme: pacchetti compressi tar(estensione `.tar.gz`), +funzionanti in ambienti Unix, installatori Windows(`.msi`) e pacchetti applicativi +Mac (`.pkg`), questi installatori contengono `rustc`, `cargo`, `rustdoc`, la libreria +standard e la documentazione standard ma non forniscono le possibilitá di compilazione +incrociata offerte da `rustup`. + +Le ragioni piú comuni per utilizzarli sono: + +- Installazione in assenza di rete +- Preferenza per un installatore grafico, piú integrato con Windows + +Ciascuno di questi eseguibili sono firmati digitalmente con la [firma digitale di Rust][Rust signing key] +disponibile su [keybase.io], rilasciata dall'infrastruttura di rilascio di Rust, +tramite [GPG]. +Nelle tabelle sottostanti, i file `.asc` sono i file di firma digitale. + + +Le versioni passate si possono trovare negli [archivi][the archives]. + +{% for channel in site.channels %} + +### {{ channel.name | capitalize }} ({{ channel.vers }}) + + +
+ {% for column in site.data.platforms[channel.name] %} +
+ {% for target in column %} +
+ {{ target }} + .tar.gz + .asc +
+ {% if target contains 'windows' %} +
+ {{ target }} + .msi + .asc +
+ {% elsif target contains 'darwin' %} +
+ {{ target }} + .pkg + .asc +
+ {% endif %} + {% endfor %} +
+ {% endfor %} +
+ +{% endfor %} + +## Codice sorgente + + +
+
+
+ Stabile + .tar.gz + .asc +
+
+
+
+ Beta + .tar.gz + .asc +
+
+
+
+ Nightly + .tar.gz + .asc +
+
+
+ +[installation page]: install.html +[`rustup`]: https://github.com/rust-lang-nursery/rustup.rs +[other-rustup]: https://github.com/rust-lang-nursery/rustup.rs#other-installation-methods +[`rustup-init.exe`]: https://static.rust-lang.org/rustup/dist/i686-pc-windows-gnu/rustup-init.exe +[`rustup-init.sh`]: https://static.rust-lang.org/rustup/rustup-init.sh +[Homebrew]: http://brew.sh/ +[Chocolatey]: http://chocolatey.org/ +[three tiers]: https://forge.rust-lang.org/platform-support.html +[Rust signing key]: https://static.rust-lang.org/rust-key.gpg.ascii +[GPG]: https://gnupg.org/ +[available on keybase.io]: https://keybase.io/rust +[the archives]: https://static.rust-lang.org/dist/index.html diff --git a/it-IT/security.html b/it-IT/security.html new file mode 100644 index 000000000..024e742aa --- /dev/null +++ b/it-IT/security.html @@ -0,0 +1,98 @@ +--- +layout: it-IT/default +title: Politica di sicurezza di Rust · Linguaggio di programmazione Rust +--- + +

Politica di sicurezza di Rust

+ +

Segnalare un problema

+ +

La sicurezza é uno dei principi fondamentali di Rust e con tale proposito + vorremmo assicurarci che Rust abbia un'implementazione sicura. + Ti ringraziamo per aver preso del tempo per comunicare responsabilmente + ogni problematica da te trovata.

+ +

Tutti i problemi di sicurezza in Rust devono essere riportati per email a +security@rust-lang.org. Questo indirizzo +consegna il messaggio a un piccolo team di sicurezza. La tua email sará visionata entro 24 +ore e riceverai una mail di risposta piú dettagliata entro 48 ore +indicante i passi successivi per la gestione della tua segnalazione. Se preferisci, puoi +criptare la segnalazione usando la nostra chiave pubblica. +Disponibile anche sul server delle chiavi del mit + e su questa pagina. + +

Questo indirizzo email riceve molto spam, quindi assicurati di inserire +nell'oggetto informazioni descrittive per evitare che la segnalazione finisca ignorata. +Dopo la risposta iniziale, il team di sicurezza ti terrá aggiornato sui progressi +fatti verso la risoluzione del problema e il suo annuncio al pubblico. +Come raccomandato da RFPolicy, +questi aggiornamenti verranno mandati almeno ogni cinque giorni. +In realtá é piú probabile che sia ogni 24-48 ore.

+ +

Se non hai ancora ricevuto risposta alla tua email dopo 48 ore o il team + di sicurezza non si é fatto sentire per almeno cinque giorni, ecco alcune + cose che puoi fare:

+ + + +

Nota bene che i forum di discussione e il canale IRC #rust-internals + sono aree pubbliche. Annunciando pubblicamente evita per favore di discutere + direttamente della problematica ma piuttosto indica di stare cercando un contatto + con il team di sicurezza.

+ +

Politica di diffusione

+ +

La politica di diffusione del progetto Rust si compone di 5 fasi:

+ +
    +
  1. Il rapporto di sicurezza é ricevuto e assegnato a un amministratore. + Questa persona coordinerá il processo di risoluzione e rilascio.
  2. + +
  3. Il problema viene confermato e viene stilata una lista di tutte le versioni vulnerabili.
  4. + +
  5. Viene ispezionato il codice alla ricerca di problematiche associate.
  6. + +
  7. Vengono preparate modifiche per tutte le versioni in stato di manutenzione attiva + queste modifiche non sono condivise pubblicamente ma mantenute in locale in attesa + dell'annuncio.
  8. + +
  9. Alla data di fine della non divulgazione, nella +mailing list di sicurezza del progetto Rust é spedita una copia dell'annuncio. I cambiamenti +sono inoltrati al repository pubblico e le nuove versioni sono pubblicate su rust-lang.org. +Entro 6 ore della notifica alla mailing list, una copia dell'annuncio verrá pubblicata +sul blog ufficiale di Rust.
+ +

Questo processo puó richiedere un po' di tempo, specialmente quando é richiesta coordinazione + con gli sviluppatori di altri progetti. Verrá fatto ogni sforzo possibile per gestire la problematica + in maniera celere, ad ogni modo é importante seguire il processo evidenziato sopra + per assicurare una gestione coerente.

+ +

Ricevere aggiornamenti di sicurezza

+ +

Il miglior modo per ricevere gli aggiornamenti di sicurezza é iscriversi alla mailing list di sicurezza del progetto Rust. +La mailing list non é molto attiva e riceve le notifiche pubbliche nel momento +in cui la non divulgazione termina.

+ +

Notifiche in anticipo

+ +

Annunceremo 72 ore prima della fine della non divulgazione a +distros@openwall, +in modo che le distribuzioni Linux possano aggiornare i loro pacchetti.

+ +

Commenti a questa politica

+ +

Se hai suggerimenti su come migliorare questa politica, manda una mail a +security@rust-lang.org.

+ +

Chiave PGP in chiaro

+ +
{% include rust-security-team-key.gpg.ascii %}
diff --git a/it-IT/team.md b/it-IT/team.md new file mode 100644 index 000000000..5efa2b03b --- /dev/null +++ b/it-IT/team.md @@ -0,0 +1,123 @@ +--- +layout: it-IT/default +title: Il team di Rust · Linguaggio di programmazione Rust + +localized-teams: + Core team: + name: Team principale + responsibility: "dirigono il progetto e i sottogruppi, lavorano su problematiche condivise" + Language design team: + name: Team di design del linguaggio + responsibility: "progettano gli sviluppi del linguaggio" + Library team: + name: Team della libreria + responsibility: "la libreria standard di rust, i *pacchetti* rust-lang e le convenzioni" + Compiler team: + name: Team del compilatore + responsibility: "si occupano del compilatore e della sua ottimizzazione" + Tooling and infrastructure: + name: Utilitá e infrastrutture + responsibility: "lavorano agli strumenti (rustup, Cargo), alla piattaforma di controllo automatico, etc..." + Community team: + name: Team della comunitá + responsibility: "coordinano gli eventi, la riuscita, i rapporti con gli utenti commerciali e il materiale didattico" + Documentation team: + name: Team della documentazione + responsibility: "assicurano che Rust abbia una documentazione fantastica" + Moderation team: + name: Team della moderazione + responsibility: "assicurano il rispetto codice di comportamento" + Style team: + name: Team dello stile + responsibility: "gruppo di azione temporaneo che delibera sulla forma del linguaggio e sullo strumento rustfmt" + Rust team alumni: + name: Team degli anziani + responsibility: "si godono un meritato riposo" +--- + + + +# Il team di rust + +Il progetto Rust é +[amministrato](https://github.com/rust-lang/rfcs/blob/master/text/1068-rust-governance.md) +da un numero di team, ciascuno focalizzato in una specifica area di competenza. +Sotto vi é una lista, in ordine alfabetico. + +Per contattare un team, invia la tua domanda o commenta nel [Forum Sviluppo](https://internals.rust-lang.org/) +e tagga il tuo post con la categoria corrispondente al nome del team. +Nota che le vulnerabilitá sono soggette al [processo di annuncio vulnerabilitá](security.html). + +{% for team in site.data.team.teams %} +
+

{{ page.localized-teams[team.name].name | default: team.name }}

+ +Responsabilitá: {{ page.localized-teams[team.name].responsibility | default: team.responsibility }} + +
+ +{% if team.email %} + Contatto: + {{ team.email }} +{% endif %} + + +
+{% endfor %} \ No newline at end of file diff --git a/it-IT/user-groups.md b/it-IT/user-groups.md new file mode 100644 index 000000000..2ac2df191 --- /dev/null +++ b/it-IT/user-groups.md @@ -0,0 +1,224 @@ +--- +layout: it-IT/default +title: Gruppi Utenti Rust · Linguaggio di programmazione Rust +--- + +# Gruppi Utenti Rust +Ci sono oltre 50 [Gruppi Utenti Rust][user_group] nel mondo fra oltre 20 +countries che contano oltre 7,000 membri. +I Rustacchiani si incontrano periodicamente +nei Gruppi Utenti Rust. +Un ottimo modo per entrare nella comunitá, per imparare e per socializzare +con persone che hanno interessi simili. Gli incontri sono tenuti su base mensile +e sono molto informali. Gli incontri sono aperti a tutti. + +Se hai fondato un nuovo gruppo utanti e vorresti aggiungerlo a questa lista per favore contatta il [Team comunitá Rust](./team.html#Community) o +ancora meglio, apri una pull request a [questo sito](https://github.com/rust-lang/rust-www/blob/master/en-US/user-groups.md). + +## Australia + +[Rust Melbourne](https://www.meetup.com/Rust-Melbourne/), Melbourne. + +[Rust Sydney](https://www.meetup.com/Rust-Sydney/), Sydney. + +## Austria + +[Klagenfurt Rust Programmers](https://www.meetup.com/Klagenfurt-Rust/), Klagenfurt. + +## Bolivia + +[Rust Bolivia](http://www.mozillabolivia.org/rust/), Santa Cruz, Bolivia. + +## Brasile + +[Rust São Paulo](https://www.meetup.com/Rust-Sao-Paulo-Meetup/), São Paulo. + +## Canada + +[Montréal Rust Language Meetup](https://www.meetup.com/Montreal-Rust-Language-Meetup/), Montréal, QC. + +[Rust Toronto](https://www.meetup.com/Rust-Toronto/), Toronto. + +## Francia + +[Lille Rust Meetup](https://www.meetup.com/rust-lille/), Lille. + +[Rust Paris](https://www.meetup.com/Rust-Paris/), Paris. + +## Germania + +[Rust Cologne/Bonn User Group](https://www.meetup.com/Rust-Cologne-Bonn/), Köln. + +[Rust Berlin](https://www.meetup.com/Rust-Berlin/), Berlin. + +[Rust Meetup Hamburg](https://www.meetup.com/Rust-Meetup-Hamburg/), Hamburg. + +[Rust - Modern Systems Programming Leipzig](https://www.meetup.com/de-DE/Rust-Modern-Systems-Programming-in-Leipzig/), Leipzig. + +[Rust Munich](https://www.meetup.com/rust-munich/), München. + +## Giappone + +[Tokyo Rust](https://www.meetup.com/Tokyo-Rust-Meetup/), Tokyo. + +[Rust Of Us](https://rust-of-us.doorkeeper.jp/), Akihabara, Tokyo. + +[Rust Mokumoku Kai](https://rust.doorkeeper.jp/), Roppongi, Tokyo. + +[Akasaka Rust](https://akasaka-rust.doorkeeper.jp/), Akasaka, Tokyo. + +## India + +[Hyderabad Rust Meetup](https://www.meetup.com/Hyderabad-Rust-Meetup/), Hyderabad. + +[Rust Group Bangalore](https://www.facebook.com/groups/RustBLR/1579069959026339/), Bangalore. + +[Rust Group Coimbatore](https://github.com/dvigneshwer/Rust_Group_Coimbatore), Coimbatore. + +## Indonesia + +[Lambda Jakarta](https://www.meetup.com/Lambda-Jakarta/), Jakarta. + +## Irlanda + +[Rust Dublin](https://www.meetup.com/Rust-Dublin/), Dublin. + +## Italia + +[Rust lang Milano](https://www.meetup.com/Rust-lang-Milano/), Milano. + +## Messico + +[Rust Lang Comunidad Mexico](https://www.meetup.com/rustlangmx/), Guadalajara. + +[Rust MX](https://www.meetup.com/Rust-MX/), Mexico city. + +## Paesi Bassi + +[Rust Amsterdam](https://www.meetup.com/Rust-Amsterdam/), Amsterdam. + +## Nuova Zelanda + +[Wellington Rust Meetup](https://www.meetup.com/Wellington-Rust-Meetup/), Wellington. + +## Norvegia + +[Rust Oslo](https://www.meetup.com/Rust-Oslo/), Oslo. + +## Filippine + +[Rust Philippines](http://www.rustph.tech), Manila. + +[Cebu Rust Camp](https://www.meetup.com/Cebu-Rust-Camp/), Cebu. + +## Polonia + +[Rust Warsaw](https://www.meetup.com/Rust-Warsaw/), Warsaw. + +## Russia + +[Rust in Moscow](https://www.meetup.com/Rust-%D0%B2-%D0%9C%D0%BE%D1%81%D0%BA%D0%B2%D0%B5/), Moscow. + +## Singapore + +[Singapore Rust Meetup](https://www.meetup.com/Singapore-Rust-Meetup/), Singapore. + +## Spagna + +[Rust Madrid](https://www.meetup.com/Rust-Madrid/), Madrid. + +[Rust Barcelona](https://www.meetup.com/Rust-Barcelona/), Barcelona. + +## Corea del sud + +[Rust Seoul](https://www.meetup.com/Rust-Seoul/), Seoul. + +## Svezia + +[Rust Skåne](https://www.meetup.com/rust-skane/), Lund. + +## Svizzera + +[Rust Romandie](https://www.meetup.com/rust-romandie/), Genève. + +[Rust Zurich](https://www.meetup.com/Rust-Zurich/), Zürich. + +## Taiwan + +[RUST.TW](https://www.meetup.com/RUST-TW/), Taipei + +## Regno Unito + +[Rust London User Group](https://www.meetup.com/Rust-London-User-Group/), London. + +[Rust Belfast User Group](https://www.meetup.com/Rust-Belfast-Meetup/), Belfast. + +## Uruguay + +[Rust Montevideo](https://www.meetup.com/Rust-Montevideo/), Montevideo. + +## USA + +### Arizona + +[Desert Rust](https://www.meetup.com/Desert-Rustaceans/), Phoenix, AZ. + +### California + +[Rust Bay Area](https://www.meetup.com/Rust-Bay-Area/), San Francisco, CA. + +[Rust Learning Group](https://www.meetup.com/Rust-Learning-Group/), Oakland, CA. + +[Rust Los Angeles](https://www.meetup.com/Rust-Los-Angeles/), Los Angeles, CA. + +[San Diego Rust](https://www.meetup.com/San-Diego-Rust/), San Diego, CA. + +### Colorado + +[Rust Boulder/Denver](https://www.meetup.com/Rust-Boulder-Denver/), Boulder, CO. + +### Florida + +[Rust Tampa](https://www.meetup.com/Rust-Tampa/), Tampa, FL. + +[South Florida Rust](https://www.meetup.com/South-Florida-Rust-Meetup/), Fort Lauderdale, FL. + +### Illinois + +[Chicago Rust Meetup](https://www.meetup.com/Chicago-Rust-Meetup/), Chicago, IL. + +### Massachussets + +[Rust Boston](https://www.meetup.com/Boston-Rust-Meetup-25317522aNpHwZdw/), Boston, MA. + +### Michigan + +[Rust Detroit](https://www.meetup.com/rust-detroit/), Detroit, MI. + +### Minnesota + +[Rust Twin Cities](https://www.meetup.com/Rust-TC/), Minneapolis, MN. + +### New York + +[Rust NYC](https://www.meetup.com/Rust-NYC/), New York, NY + +### Ohio + +[Columbus Rust Society](https://www.meetup.com/columbus-rs/), Columbus, OH. + +### Oregon + +[PDXRust](https://www.meetup.com/PDXRust/), Portland, OR. + +### Pennsylvania + +[Pittsburgh Rust Coffee](https://www.meetup.com/Pittsburgh-Rust-Coffee/), Pittsburgh, PA. + +### Texas + +[The Austin Rust Meetup](https://www.meetup.com/Austin-Rust-Meetup/), Austin, TX. + +### Washington + +[Seattle Rust Meetup](https://www.meetup.com/Seattle-Rust-Meetup/), Seattle, WA.