Finito "box syntax and patterns"

Author: carlomilanesi

box-syntax-and-patterns.md

@@ -1,9 +1,10 @@
-%  Box Syntax and Patterns
+%  La sintassi e i pattern di Box
 
-Currently the only stable way to create a `Box` is via the `Box::new` method.
-Also it is not possible in stable Rust to destructure a `Box` in a match
-pattern. The unstable `box` keyword can be used to both create and destructure
-a `Box`. An example usage would be:
+Attualmente, l'unico modo stabile di creare un `Box` è tramite il metodo
+`Box::new`. Inoltre, nella versione stabile di Rust, non è possibile
+destrutturare un `Box` in un pattern di `match`. La parola-chiave instabile
+`box` si può usare sia per creare che per destrutturare un `Box`.
+Un esempio di utilizzo sarebbe:
 
 ```rust
 #![feature(box_syntax, box_patterns)]
@@ -12,89 +13,92 @@ fn main() {
     let b = Some(box 5);
     match b {
         Some(box n) if n < 0 => {
-            println!("Box contains negative number {}", n);
+            println!("Il box contiene il numero negativo {}", n);
         },
         Some(box n) if n >= 0 => {
-            println!("Box contains non-negative number {}", n);
+            println!("Il box contiene il numero non negativo {}", n);
         },
         None => {
-            println!("No box");
+            println!("Nessun box");
         },
         _ => unreachable!()
     }
 }
 ```
 
-Note that these features are currently hidden behind the `box_syntax` (box
-creation) and `box_patterns` (destructuring and pattern matching) gates
-because the syntax may still change in the future.
+Si noti che queste caratteristiche sono attualmente nascoste dietro i gate
+`box_syntax` (per la creazione dei box) e `box_patterns`
+(per la destrutturazione e il pattern matching), perché la sintassi
+può ancora cambiare in futuro.
 
-# Returning Pointers
+# Restituire puntatori
 
-In many languages with pointers, you'd return a pointer from a function
-so as to avoid copying a large data structure. For example:
+In molti linguaggi dotati di puntatori, si restituirebbe un puntatore
+da una funzione per evitare di copiare una grande struttura dati. Per esempio:
 
 ```rust
-struct BigStruct {
-    one: i32,
-    two: i32,
-    // etc
-    one_hundred: i32,
+struct GrossaStruct {
+    uno: i32,
+    due: i32,
+    // ecc
+    cento: i32,
 }
 
-fn foo(x: Box<BigStruct>) -> Box<BigStruct> {
+fn foo(x: Box<GrossaStruct>) -> Box<GrossaStruct> {
     Box::new(*x)
 }
 
 fn main() {
-    let x = Box::new(BigStruct {
-        one: 1,
-        two: 2,
-        one_hundred: 100,
+    let x = Box::new(GrossaStruct {
+        uno: 1,
+        due: 2,
+        cento: 100,
     });
 
     let y = foo(x);
 }
 ```
 
-The idea is that by passing around a box, you're only copying a pointer, rather
-than the hundred `i32`s that make up the `BigStruct`.
+L'idea è che passando un box, sia sta solo copiando un puntatore, invece
+dei cento `i32` che costituiscono la `GrossaStruct`.
 
-This is an antipattern in Rust. Instead, write this:
+Questo in Rust è un antipattern. Invece, si scrive così:
 
 ```rust
 #![feature(box_syntax)]
 
-struct BigStruct {
-    one: i32,
-    two: i32,
-    // etc
-    one_hundred: i32,
+struct GrossaStruct {
+    uno: i32,
+    due: i32,
+    // ecc
+    cento: i32,
 }
 
-fn foo(x: Box<BigStruct>) -> BigStruct {
+fn foo(x: Box<GrossaStruct>) -> GrossaStruct {
     *x
 }
 
 fn main() {
-    let x = Box::new(BigStruct {
-        one: 1,
-        two: 2,
-        one_hundred: 100,
+    let x = Box::new(GrossaStruct {
+        uno: 1,
+        due: 2,
+        cento: 100,
     });
 
-    let y: Box<BigStruct> = box foo(x);
+    let y: Box<GrossaStruct> = box foo(x);
 }
 ```
 
-This gives you flexibility without sacrificing performance.
+Ciò fornisce flessibilità senza sacrificare le prestazioni.
 
-You may think that this gives us terrible performance: return a value and then
-immediately box it up ?! Isn't this pattern the worst of both worlds? Rust is
-smarter than that. There is no copy in this code. `main` allocates enough room
-for the `box`, passes a pointer to that memory into `foo` as `x`, and then
-`foo` writes the value straight into the `Box<T>`.
+Si potrebbe pensare che così si otterrebbero prestazioni terribili:
+restituire un valore e poi inscatolarlo immediatamente?! Questo pattern
+non è il peggio di entrambi i mondi? Ma Rust è più scaltro.
+In questo codice non si fanno copie. `main` alloca abbastanza spazio
+per il `box`, passa a `foo`, col nome di `x`, l'indirizzo di tale spazio,
+e poi `foo` scrive il valore direttamente nel `Box<T>`.
 
-This is important enough that it bears repeating: pointers are not for
-optimizing returning values from your code. Allow the caller to choose how they
-want to use your output.
+Ciò è abbastanza importante che vale la pena ripeterlo: i puntatori
+non sono da usare per ottimizzare la restituzione di valori
+dal proprio codice. Si consenta al chiamante di scegliere come vuole usare
+l'output della funzione.