Translated into Italian

1 files changed, 321 insertions, 0 deletions

diff --git a/it-it/rust-it.html.markdown b/it-it/rust-it.html.markdown
new file mode 100644
index 00000000..39dbb944
--- /dev/null
+++ b/it-it/rust-it.html.markdown
@@ -0,0 +1,321 @@
+---
+language: rust
+contributors:
+    - ["Carlo Milanesi", "http://github.com/carlomilanesi"]
+filename: rust-it.html.markdown
+---
+
+Rust è un linguaggio di programmazione sviluppato da Mozilla Research.
+Rust combina il controllo a basso livello sulle prestazioni con alcune comodità
+ad alto livello e stringenti garanzie di sicurezza.
+
+Rust raggiunge questi obiettivi senza richiedere la garbage collection né una grossa
+libreria di supporto run-time, rendendo così possibile l'uso di librerie scritte in Rust
+come rimpiazzo di librerie scritte in C.
+
+La prima versione pubblica di Rust, la 0.1, è stata rilasciata nel gennaio 2012, e per 3 anni
+lo sviluppo è proceduto così rapidamente che l'utilizzo delle versioni
+stabili veniva scoraggiato, e piuttosto si consigliava di utilizzare le versioni notturne
+(nightly build).
+
+Il 15 maggio 2015, la versione 1.0 di Rust è stata rilasciata con la garanzia
+che nelle successive versioni 1.x non ci sarebbero state modifiche che avrebbero reso
+incompatibile il codice scritto per tale versione.
+Nelle nightly build sono attualmente disponibili migliorie al tempo di compilazione
+e ad altri aspetti del compilatore. Rust ha adottato un modello di rilascio a scaglioni
+con rilasci regolari ogni sei settimane. Per esempio, la versione 1.1 beta è stata resa
+disponibile contestualmente al rilascio della versione stabile 1.0.
+
+Sebbene Rust sia un linguaggio di livello relativamente basso, Rust ha alcuni concetti
+di programmazione funzionale che solitamente si trovano solo nei linguaggi di livello più alto.
+Ciò rende Rust non solo veloce, ma anche facile ed comodo da usare.
+
+```rust
+// I commenti che stanno su una sola riga sono fatti così...
+/* ...mentre così sono fatti
+i commenti che richiedono
+più righe */
+
+///////////////////
+// 1. Fondamenti //
+///////////////////
+
+// Funzioni
+// `i32` è il tipo per gli interi a 32-bit con segno
+fn add2(x: i32, y: i32) -> i32 {
+    // return implicito (senza punto-e-virgola)
+    x + y
+}
+
+// Funzione "main"
+fn main() {
+    // Numeri //
+
+    // Binding (ossia "variabili") immutabili
+    let x: i32 = 1;
+
+    // Suffissi intero/virgola mobile
+    let y: i32 = 13i32;
+    let f: f64 = 1.3f64;
+
+    // Inferenza di tipo
+    // La maggior parte delle volte, il compilatore Rust può inferire
+    // di quale tipo sia l'espressione usata per inizializzare un binding,
+    // e quindi non è necessario specificare esplicitamente il tipo.
+    // In tutto questo tutorial, i tipi vengono specificati esplicitamente in molti posti,
+    // ma solo a scopo dimostrativo. La maggior parte delle volte se ne potrebbe
+    // fare a meno, grazie all'inferenza di tipo.
+    let implicito_x = 1;
+    let implicito_f = 1.3;
+
+    // Aritmetica
+    let somma = x + y + 13;
+
+    // Variabile mutevole
+    let mut mutevole = 1;
+    mutevole = 4;
+    mutevole += 2;
+
+    // Stringhe //
+
+    // Letterali di stringa
+    let x: &str = "Ciao mondo!";
+
+    // Stampa
+    println!("{} {}", f, x); // 1.3 Ciao mondo!
+
+    // Una `String` – una stringa allocata nello heap
+    let s: String = "Ciao mondo".to_string();
+
+    // Uno slice (fetta) di stringa – una vista immutabile
+    // all'interno di un'altra stringa.
+    // Uno slice è una coppia immutabile di puntatori al buffer contenuto
+    // nella stringa - non contiene dei caratteri, solo dei puntatori a
+    // un buffer statico o a un buffer contenuto in un altro oggetto (in questo caso, `s`)
+    let s_slice: &str = &s;
+
+    println!("{} - {}", s, s_slice); // Ciao mondo - Ciao mondo
+
+    // Vettori/array //
+
+    // Un array di lunghezza fissa
+    let quattro_int: [i32; 4] = [1, 2, 3, 4];
+
+    // Un array dinamico (vettore)
+    let mut vettore: Vec<i32> = vec![1, 2, 3, 4];
+    vettore.push(5);
+
+    // Uno slice – una vista immutabile all'interno di un vettore o di un array
+    // E' molto simile a uno slice di stringa, ma per i vettori
+    let slice: &[i32] = &vettore;
+
+    // Usa `{:?}` per stampare qualcosa a scopo di debugging
+    println!("{:?} {:?}", vettore, slice); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
+
+    // Tuple //
+
+    // Una tupla è un insieme ordinato di dimensione fissa di valori aventi tipi eventualmente diversi
+    let x: (i32, &str, f64) = (1, "ciao", 3.4);
+
+    // Il `let` che destruttura
+    let (a, b, c) = x;
+    println!("{} {} {}", a, b, c); // 1 ciao 3.4
+
+    // Indicizzazione
+    println!("{}", x.1); // ciao
+
+    /////////////
+    // 2. Tipi //
+    /////////////
+
+    // Strutture
+    struct Point {
+        x: i32,
+        y: i32,
+    }
+
+    let origine: Punto = Punto { x: 0, y: 0 };
+
+    // Ana struct con campi senza nome, chiamata ‘tuple struct’
+    struct Punto2(i32, i32);
+
+    let origine2 = Punto2(0, 0);
+
+    // Enum basilare, analoga a quelle del linguaggio C
+    enum Direzione {
+        Sinistra,
+        Destra,
+        Su,
+        Giu,
+    }
+
+    let su = Direzione::Su;
+
+    // Enum con campi
+    enum OpzionaleI32 {
+        UnI32(i32),
+        Niente,
+    }
+
+    let due: OpzionaleI32 = OpzionaleI32::UnI32(2);
+    let niente = OpzionaleI32::Niente;
+
+    // Generici //
+
+    struct Foo<T> { bar: T }
+
+    // Questo è definito nella libreria standard come `Option`
+    enum Opzionale<T> {
+        QualcheValore(T),
+        NessunValore,
+    }
+
+    // Metodi //
+
+    impl<T> Foo<T> {
+        // I metodi di oggetto prendono un parametro `self` esplicito
+        fn get_bar(self) -> T {
+            self.bar
+        }
+    }
+
+    let a_foo = Foo { bar: 1 };
+    println!("{}", a_foo.get_bar()); // 1
+
+    // I trait (tratti), noti come "interfacce" o "mixin" in altri linguaggi
+
+    trait Maneggiamento<T> {
+        fn maneggia(self) -> Option<T>;
+    }
+
+    impl<T> Maneggiamento<T> for Foo<T> {
+        fn maneggia(self) -> Option<T> {
+            Some(self.bar)
+        }
+    }
+
+    let altro_foo = Foo { bar: 1 };
+    println!("{:?}", altro_foo.maneggia()); // Some(1)
+
+    /////////////////////////
+    // 3. Pattern matching //
+    /////////////////////////
+
+    let foo = OpzionaleI32::UnI32(1);
+    match foo {
+        OpzionaleI32::UnI32(n) => println!("E' un i32: {}", n),
+        OpzionaleI32::Niente  => println!("Non vale niente!"),
+    }
+
+    // Pattern matching avanzato
+    struct FooBar { x: i32, y: OpzionaleI32 }
+    let bar = FooBar { x: 15, y: OpzionaleI32::UnI32(32) };
+
+    match bar {
+        FooBar { x: 0, y: OpzionaleI32::UnI32(0) } =>
+            println!("I numeri valgono zero!"),
+        FooBar { x: n, y: OpzionaleI32::UnI32(m) } if n == m =>
+            println!("I numeri sono identici"),
+        FooBar { x: n, y: OpzionaleI32::UnI32(m) } =>
+            println!("Numeri diversi: {} {}", n, m),
+        FooBar { x: _, y: OpzionaleI32::Niente } =>
+            println!("Il secondo numbero non vale niente!"),
+    }
+
+    ///////////////////////////////////////////
+    // 4. Flusso di controllo (Control flow) //
+    ///////////////////////////////////////////
+
+    // cicli/iterazione con `for`
+    let array = [1, 2, 3];
+    for i in array.iter() {
+        println!("{}", i);
+    }
+
+    // Range
+    for i in 0u32..10 {
+        print!("{} ", i);
+    }
+    println!("");
+    // prints `0 1 2 3 4 5 6 7 8 9 `
+
+    // `if`
+    if 1 == 1 {
+        println!("La matematica funziona!");
+    } else {
+        println!("Oh no...");
+    }
+
+    // `if` come espressione
+    let value = if true {
+        "bene"
+    } else {
+        "male"
+    };
+
+    // ciclo `while`
+    while 1 == 1 {
+        println!("L'universo sta funzionando regolarmente.");
+    }
+
+    // Ciclo infinito
+    loop {
+        println!("Ciao!");
+    }
+
+    /////////////////////////////////////////////////
+    // 5. La sicurezza della memoria e i puntatori //
+    /////////////////////////////////////////////////
+
+    // Puntatore posseduto (owned) – solamente una cosa sola per volta può ‘possedere’ questo puntatore
+    // Ciò significa che quando il `Box` abbandona il suo scope, verrà automaticamente deallocato in sicurezza.
+    let mut mio: Box<i32> = Box::new(3);
+    *mio = 5; // dereference
+    // Qui, `adesso_e_mio` acquisisce la proprietà di `mio`. In altre parole, `mio` viene spostato.
+    let mut adesso_e_mio = mio;
+    *adesso_e_mio += 2;
+
+    println!("{}", adesso_e_mio); // 7
+    // println!("{}", mio); // questo non compilerebbe perché `adesso_e_mio` adesso possiede il puntatore
+
+    // Riferimento (reference) – un puntatore immutabile che si riferisce ad altri dati
+    // Quando un riferimento viene preso a un valore, diciamo che quel valore
+    // è stato ‘preso in prestito’ (borrowed).
+    // Mentre un valore è preso in prestito immutabilmente, non può venire mutato né spostato.
+    // Un prestito dura fino alla fine dello scope in cui è stato creato.
+    let mut var = 4;
+    var = 3;
+    let ref_var: &i32 = &var;
+
+    println!("{}", var); // Diversamente da `box`, `var` può ancora essere usato
+    println!("{}", *ref_var);
+    // var = 5; // questo non compilerebbe, perché `var` è stato preso in prestito
+    // *ref_var = 6; // neanche questo, perché `ref_var` è un riferimento immutabile
+
+    // Riferimento immutabile
+    // Mentre un valore è preso in presto mutevolmente, non può essere acceduto in nessun modo.
+    let mut var2 = 4;
+    let ref_var2: &mut i32 = &mut var2;
+    *ref_var2 += 2;         // '*' serve a puntare al binding var2, preso in presto mutevolmente
+
+    println!("{}", *ref_var2); // 6
+    // var2 non compilerebbe. ref_var2 è di tipo &mut i32, e quindi 
+    // immagazzina un riferimento a un i32, e non il valore stesso.
+    // var2 = 2; // questo non compilerebbe, perché `var2` è stato preso in prestito
+}
+```
+
+## Ulteriori letture
+
+C'è molto di più in Rust — questi sono solo i fondamenti di Rust, che servono a capire
+le cose più importanti.
+
+Purtroppo c'è pochissima documentazione in italiano, tra cui:
+(https://www.mozillaitalia.org/home/2015/05/30/primi-passi-con-rust/)
+
+Però ce n'è parecchia in inglese. Per saperne di più, leggi [The Rust Programming
+Language](http://doc.rust-lang.org/book/index.html) e tieni d'occhio l'area di interesse di Reddit (subreddit)
+[/r/rust](http://reddit.com/r/rust).
+
+Puoi anche provare a programmare in varie versioni di Rust usando il compilatore online al sito ufficiale
+[Rust playpen](http://play.rust-lang.org).