Translate the standard website into italian; make the build system actually work.

Author: thehowl

examples/arrays/arrays.go

@@ -7,37 +7,37 @@ import "fmt"
 
 func main() {
 
-	// Qui creaiamo un array chiamato `a` che conterrà esattamente
-	// 5 elementi di tipo `int`. Il tipo degli elementi e la lunghezza
-	// sono entrambi parti integranti del tipo dell'array. Per default
-	// gli array vengono inizializzati allo _zero value_, che per gli
-	// elementi di tipo `int` significa essere inizializzati a `0`.
-	var a [5]int
-	fmt.Println("emp:", a)
-
-	// Possiamo assegnare un valore ad uno specifico indice utilizzando
-	// la classica sintassi:
-	// `array[indice] = valore` , e possiamo ottenere il valore con
-	// `array[indice]`.
-	a[4] = 100
-	fmt.Println("set:", a)
-	fmt.Println("get:", a[4])
-
-	// La funzione builtin `len` ritorna la lunghezza dell'array.
-	fmt.Println("len:", len(a))
-
-	// Utilizza questa sintassi per dichiarare ed inizializzare
-	// un array nella stessa linea.
-	b := [5]int{1, 2, 3, 4, 5}
-	fmt.Println("dcl:", b)
-
-	// Gli array sono di base monodimensionali, ma possono essere composti
-	// per costruire strutture di dati multidimensionali
-	var twoD [2][3]int
-	for i := 0; i < 2; i++ {
-		for j := 0; j < 3; j++ {
-			twoD[i][j] = i + j
-		}
-	}
-	fmt.Println("2d: ", twoD)
+    // Qui creaiamo un array chiamato `a` che conterrà esattamente
+    // 5 elementi di tipo `int`. Il tipo degli elementi e la lunghezza
+    // sono entrambi parti integranti del tipo dell'array. Per default
+    // gli array vengono inizializzati allo _zero value_, che per gli
+    // elementi di tipo `int` significa essere inizializzati a `0`.
+    var a [5]int
+    fmt.Println("emp:", a)
+
+    // Possiamo assegnare un valore ad uno specifico indice utilizzando
+    // la classica sintassi:
+    // `array[indice] = valore` , e possiamo ottenere il valore con
+    // `array[indice]`.
+    a[4] = 100
+    fmt.Println("set:", a)
+    fmt.Println("get:", a[4])
+
+    // La funzione builtin `len` ritorna la lunghezza dell'array.
+    fmt.Println("len:", len(a))
+
+    // Utilizza questa sintassi per dichiarare ed inizializzare
+    // un array nella stessa linea.
+    b := [5]int{1, 2, 3, 4, 5}
+    fmt.Println("dcl:", b)
+
+    // Gli array sono di base monodimensionali, ma possono essere composti
+    // per costruire strutture di dati multidimensionali
+    var twoD [2][3]int
+    for i := 0; i < 2; i++ {
+        for j := 0; j < 3; j++ {
+            twoD[i][j] = i + j
+        }
+    }
+    fmt.Println("2d: ", twoD)
 }

examples/arrays/arrays.hash

@@ -1,2 +1,2 @@
-305975d13d24223181d13f042b290906d86c1a0e
-l-A8eBnwio
+ad10350067d67bf69efcafd074204dcf8e812cf8
+-K1RJBQ8T7

examples/arrays/arrays.sh

@@ -1,5 +1,6 @@
-# Nota che gli array vengono visualizzati nella forma `[v1 v2 v3 ...]`
-# se stampati con la funzione `fmt.Println`.
+# Nota che gli array vengono visualizzati nella forma
+# [v1 v2 v3 ...] se stampati con la funzione
+# `fmt.Println`.
 $ go run arrays.go
 emp: [0 0 0 0 0]
 set: [0 0 0 0 100]
@@ -8,5 +9,6 @@ len: 5
 dcl: [1 2 3 4 5]
 2d:  [[0 1 2] [1 2 3]]
 
-# Noterai che gli _slice_ vengono utilizzati molto più spesso degli
-# array in Go. Vedremo gli slices nel prossimo esempio
+# Noterai che gli _slice_ vengono utilizzati molto più
+# spesso degli array in Go. Vedremo gli slices nel
+# prossimo esempio.

examples/constants/constants.go

@@ -10,24 +10,24 @@ import "math"
 const s string = "constant"
 
 func main() {
-	fmt.Println(s)
-
-	// La keyword `const` può essere utilizzata ovunuque
-	// la keyword `var` è ammessa
-	const n = 500000000
-
-	// Le espressioni costanti vengono calcolate in aritmetica
-	// a precisione arbitraria
-	const d = 3e20 / n
-	fmt.Println(d)
-
-	// Una costante numerica non ha un tipo fin quando non gli
-	// viene assegnato esplicitamente, ad esempio tramite un cast.
-	fmt.Println(int64(d))
-
-	// Per assegnare un tipo ad una costante di tipo numerico
-	// si può anche utilizzare la constante in un contesto che richiede
-	// un tipo, quali un assegnamento od una chiamata di funzione.
-	// In questo caso `math.Sin` si aspetta un valore di tipo `float64`.
-	fmt.Println(math.Sin(n))
+    fmt.Println(s)
+
+    // La keyword `const` può essere utilizzata ovunuque
+    // la keyword `var` è ammessa
+    const n = 500000000
+
+    // Le espressioni costanti vengono calcolate in aritmetica
+    // a precisione arbitraria
+    const d = 3e20 / n
+    fmt.Println(d)
+
+    // Una costante numerica non ha un tipo fin quando non gli
+    // viene assegnato esplicitamente, ad esempio tramite un cast.
+    fmt.Println(int64(d))
+
+    // Per assegnare un tipo ad una costante di tipo numerico
+    // si può anche utilizzare la constante in un contesto che richiede
+    // un tipo, quali un assegnamento od una chiamata di funzione.
+    // In questo caso `math.Sin` si aspetta un valore di tipo `float64`.
+    fmt.Println(math.Sin(n))
 }

examples/constants/constants.hash

@@ -1,2 +1,2 @@
-3de4f16f1ed032378268411b2173b95e8000305d
-T5sj0eINnp
+28981147447a890a1fe7483a6a1ed9362927fc8a
+dNE4cVVj4x

examples/for/for.go

@@ -8,24 +8,24 @@ import "fmt"
 
 func main() {
 
-	// Il ciclo più semplice, con una singola condizione.
-	// (simile al while degli altri linguaggi)
-	i := 1
-	for i <= 3 {
-		fmt.Println(i)
-		i = i + 1
-	}
+    // Il ciclo più semplice, con una singola condizione.
+    // (simile al while degli altri linguaggi)
+    i := 1
+    for i <= 3 {
+        fmt.Println(i)
+        i = i + 1
+    }
 
-	// Un classico ciclo `for` inizializzazione/test/incremento.
-	for j := 7; j <= 9; j++ {
-		fmt.Println(j)
-	}
+    // Un classico ciclo `for` inizializzazione/test/incremento.
+    for j := 7; j <= 9; j++ {
+        fmt.Println(j)
+    }
 
-	// Un `for` senza condizioni si ripeterà sempre finché
-	// non esci dal ciclo con un `break` oppure fai
-	// un `return` per la funzione che lo racchiude.
-	for {
-		fmt.Println("loop")
-		break
-	}
+    // Un `for` senza condizioni si ripeterà sempre finché
+    // non esci dal ciclo con un `break` oppure fai
+    // un `return` per la funzione che lo racchiude.
+    for {
+        fmt.Println("loop")
+        break
+    }
 }

examples/for/for.hash

@@ -1,2 +1,2 @@
-e7dbd5f44ea79a3eb41e4535575197b9eadc0e03
-mGqqcBZ0jv
+d51670c5d3e3a78c63580f36f374a4d00905fa44
+G1nXIp3MzQ

examples/functions/functions.go

@@ -9,27 +9,27 @@ import "fmt"
 // di tipo `int` e ritorna la loro somma (sempre di tipo `int`).
 func plus(a int, b int) int {
 
-	// Go non ritornerà il valore dell'ultima espressione: se
-	// bisogna ritornare un valore, lo si deve ritornare
-	// esplicitamente con il comando `return`
-	return a + b
+    // Go non ritornerà il valore dell'ultima espressione: se
+    // bisogna ritornare un valore, lo si deve ritornare
+    // esplicitamente con il comando `return`
+    return a + b
 }
 
 // Nelle funzioni con parametri multipli dello stesso tipo
 // si può omettere il tipo per i parametri consecutivi che
 // hanno lo stesso tipo, e indicare il tipo solo per
 // l'ultimo parametro.
 func plusPlus(a, b, c int) int {
-	return a + b + c
+    return a + b + c
 }
 
 func main() {
 
-	// Puoi chiamare una funzione con la classica
-	// sintassi `nomefunzione(parametri)`.
-	res := plus(1, 2)
-	fmt.Println("1+2 =", res)
+    // Puoi chiamare una funzione con la classica
+    // sintassi `nomefunzione(parametri)`.
+    res := plus(1, 2)
+    fmt.Println("1+2 =", res)
 
-	res = plusPlus(1, 2, 3)
-	fmt.Println("1+2+3 =", res)
+    res = plusPlus(1, 2, 3)
+    fmt.Println("1+2+3 =", res)
 }

examples/functions/functions.hash

@@ -1,2 +1,2 @@
-ae669923c20e5ebf4a7b4b11b8fdf2972accf9e2
-9Nky-Dn49f
+9992bf279fefda377c0146971ef9433084626574
+dkBVJR0L1s

examples/functions/functions.sh

@@ -3,5 +3,5 @@ $ go run functions.go
 1+2+3 = 6
 
 # Go possiede svariate features legate alle funzioni.
-# Una di queste è la possibilità di ritornare valori multipli,
-# come vedremo nel prossimo esempio.
+# Una di queste è la possibilità di ritornare valori
+# multipli, come vedremo nel prossimo esempio.

examples/goroutines/goroutines.go

@@ -6,33 +6,33 @@ package main
 import "fmt"
 
 func f(from string) {
-	for i := 0; i < 3; i++ {
-		fmt.Println(from, ":", i)
-	}
+    for i := 0; i < 3; i++ {
+        fmt.Println(from, ":", i)
+    }
 }
 
 func main() {
 
-	// Supponiamo di avere una chiamata di funzione `f(s)`.
-	// Questo è il modo classico di invocarla, che la eseguirà
-	// in modo sincrono.
-	f("direct")
-
-	// Per invocare questa funzione in una goroutine, utilizza
-	// `go f(s)`. Questa nuova goroutine eseguirà in parallelo alla
-	// goroutine dove è stata invocata.
-	go f("goroutine")
-
-	// È possibile far partire una goroutine anche con una funzione anonima.
-	go func(msg string) {
-		fmt.Println(msg)
-	}("going")
-
-	// Le nostre due chiamte di funzione stanno eseguendo in modo asincrono,
-	// su due goroutine separate. La funzione `Scanln` richiede che si prema un tasto,
-	// prima di far terminare l'esecuzione della goroutine principale
-	// (che terminerà tutte le altre goroutine).
-	var input string
-	fmt.Scanln(&input)
-	fmt.Println("done")
+    // Supponiamo di avere una chiamata di funzione `f(s)`.
+    // Questo è il modo classico di invocarla, che la eseguirà
+    // in modo sincrono.
+    f("direct")
+
+    // Per invocare questa funzione in una goroutine, utilizza
+    // `go f(s)`. Questa nuova goroutine eseguirà in parallelo alla
+    // goroutine dove è stata invocata.
+    go f("goroutine")
+
+    // È possibile far partire una goroutine anche con una funzione anonima.
+    go func(msg string) {
+        fmt.Println(msg)
+    }("going")
+
+    // Le nostre due chiamte di funzione stanno eseguendo in modo asincrono,
+    // su due goroutine separate. La funzione `Scanln` richiede che si prema un tasto,
+    // prima di far terminare l'esecuzione della goroutine principale
+    // (che terminerà tutte le altre goroutine).
+    var input string
+    fmt.Scanln(&input)
+    fmt.Println("done")
 }

examples/goroutines/goroutines.hash

@@ -1,2 +1,2 @@
-a847131d7f112172f9d5509fd3cf31aefb6d710e
-RW_RSAHfj-
+d8c7882cb48f91489b474e0a788a0ca97b0fe159
+i5lg3HGV9C

examples/goroutines/goroutines.sh

@@ -1,8 +1,9 @@
-# Quando si esegue questo programma si può notare prima l'output
-# delle chiamate bloccanti. Successivamente si nota come le due 
-# goroutine lanciate producano dell'output "disordinato".
-# Questo disordine riflette l'esecuzione concorrente delle 
-# goroutine da parte del runtime di Go.
+# Quando si esegue questo programma si può notare prima
+# l'output delle chiamate bloccanti. Successivamente si
+# nota come le due goroutine lanciate producano
+# dell'output "disordinato". Questo disordine riflette
+# l'esecuzione concorrente delle goroutine da parte del
+# runtime di Go.
 $ go run goroutines.go
 direct : 0
 direct : 1
@@ -14,5 +15,5 @@ goroutine : 2
 <enter>
 done
 
-# Adesso siamo pronti per analizzare la struttura complementare alle
-# goroutine in Go: i channel.
+# Adesso siamo pronti per analizzare la struttura
+# complementare alle goroutine in Go: i channel.

examples/hello-world/hello-world.go

@@ -6,5 +6,5 @@ package main
 import "fmt"
 
 func main() {
-	fmt.Println("hello world")
+    fmt.Println("hello world")
 }

examples/hello-world/hello-world.hash

@@ -1,2 +1,2 @@
-c98395a44701add5bf84e2f3a63e300fc1bc4bfe
-2C7wwJ6nxG
+ac5d271b330cec751059b00b812a73830d902888
+npMQdX5XAE

examples/if-else/if-else.go

@@ -7,28 +7,28 @@ import "fmt"
 
 func main() {
 
-	// Questo è un esempio base
-	if 7%2 == 0 {
-		fmt.Println("7 è pari")
-	} else {
-		fmt.Println("7 è dispari")
-	}
+    // Questo è un esempio base
+    if 7%2 == 0 {
+        fmt.Println("7 è pari")
+    } else {
+        fmt.Println("7 è dispari")
+    }
 
-	// È possibile avere un comando `if` senza il ramo `else`
-	if 8%4 == 0 {
-		fmt.Println("8 è divisibile per 4")
-	}
+    // È possibile avere un comando `if` senza il ramo `else`
+    if 8%4 == 0 {
+        fmt.Println("8 è divisibile per 4")
+    }
 
-	// Un comando può precedere il test del comando `if`.
-	// Qualsiasi variabile dichiarata in questo comando
-	// è visibile all'interno di tutti i rami del comando `if`
-	if num := 9; num < 0 {
-		fmt.Println(num, "è negativo")
-	} else if num < 10 {
-		fmt.Println(num, "ha una cifra")
-	} else {
-		fmt.Println(num, "ha più di una cifra")
-	}
+    // Un comando può precedere il test del comando `if`.
+    // Qualsiasi variabile dichiarata in questo comando
+    // è visibile all'interno di tutti i rami del comando `if`
+    if num := 9; num < 0 {
+        fmt.Println(num, "è negativo")
+    } else if num < 10 {
+        fmt.Println(num, "ha una cifra")
+    } else {
+        fmt.Println(num, "ha più di una cifra")
+    }
 }
 
 // Nota che non sono necessarie le parentesi intorno alle condizioni

examples/if-else/if-else.hash

@@ -1,2 +1,2 @@
-89b78f3378e1a574ddfd0260a0404a962852eff8
-g-aqMz0Ivf
+f3770b68198cdf80f23b4c668ec56a8f8432153b
+1ieiuzFwGl