summaryrefslogtreecommitdiffhomepage
path: root/it-it/rust-it.html.markdown
diff options
context:
space:
mode:
Diffstat (limited to 'it-it/rust-it.html.markdown')
-rw-r--r--it-it/rust-it.html.markdown321
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).