Corregidas algunas faltas y tildes

examples/apuntadores/apuntadores.go

@@ -18,7 +18,7 @@ func zeroval(ival int) {
 // `zeroptr` recibe un parametro `*int`, lo que significa
 // que recibe un apuntador a un valor `int`. El código `*iptr` en el
 // cuerpo de la función _dereferencía_ el apuntador de su dirección de
-// memoria a el valor actual de esa dirección.
+// memoria al valor actual de esa dirección.
 // Si asignamos un valor a un apuntador dereferenciado se cambia el valor
 // que se está almacenando en dicha dirección de memoria.
 func zeroptr(iptr *int) {

examples/funciones-variadicas/funciones-variadicas.go

@@ -6,7 +6,7 @@ package main
 
 import "fmt"
 
-// Aquí declaramos una función que va a recibir un numero
+// Aquí declaramos una función que va a recibir un número
 // arbitrario de valores tipo `int` como argumentos.
 func sum(nums ...int) {
     fmt.Print(nums, " ")

examples/funciones/funciones.go

@@ -1,15 +1,15 @@
 // Las _Funciones_ son una parte escencial de Go. Veamos algunos
-// ejemplos para entender como se utilizan.
+// ejemplos para entender cómo se utilizan.
 
 package main
 
 import "fmt"
 
-// Aquí tenemos una funcion que recibe dos valores `int`
+// Aquí tenemos una función que recibe dos valores `int`
 // y regresa la suma de los mismos como `int`.
 func plus(a int, b int) int {
 
-    // Go requiere retornos de valor explicitos, i.e. no regresa
+    // Go requiere retornos de valor explícitos, i.e. no regresa
     // automáticamente el valor de la última expresión.
     return a + b
 }

examples/mapas/mapas.go

@@ -11,42 +11,36 @@ func main() {
     // `make(map[key-type]val-type)`.
     m := make(map[string]int)
 
-    // Se pueden establecer los pares de llaves/valores utilizando
+    // Se pueden establecer los pares de clave/valor utilizando
     // la sintaxis típica `name[key] = val`.
     m["k1"] = 7
     m["k2"] = 13
 
     // Si se presenta el mapa con e.g. `Println` se muestran
-    // todos sus pares de llaves/valores.
+    // todos sus pares de clave/valor.
     fmt.Println("map:", m)
 
-    // Se obtiene el valor de una llave con la sintaxis `name[key]`.
+    // Se obtiene el valor de una clave con la sintaxis `name[key]`.
     v1 := m["k1"]
     fmt.Println("v1: ", v1)
 
-    // La función `len` regresa el número de pares llave/valor cuando
+    // La función `len` regresa el número de pares clave/valor cuando
     // se utiliza con un mapa.
     fmt.Println("len:", len(m))
 
-    // La función `delete` elimina pares llave/valor de un mapa.
+    // La función `delete` elimina pares clave/valor de un mapa.
     delete(m, "k2")
     fmt.Println("map:", m)
-
-    // The optional second return value when getting a
-    // value from a map indicates if the key was present
-    // in the map. This can be used to disambiguate
-    // between missing keys and keys with zero values
-    // like `0` or `""`.
-
+
     // El segundo valor de regreso (opcional) cuando obtienes un valor de
-    // el mapa indica si la llave etaba presente. Este valor puede
-    // ser usado para separar valores de llaves que no existen y
-    // valores de llaves con valor cero, como `0` o `""`.
+    // el mapa indica si la clave estaba presente. Este valor puede
+    // ser usado para separar valores de claves que no existen y
+    // valores de claves con valor cero, como `0` o `""`.
     _, prs := m["k2"]
     fmt.Println("prs:", prs)
 
     // También puedes declarar e inicializar un mapa nuevo
-    // en una sola línea con la sintaxis:
+    // en una única línea con la sintaxis:
     n := map[string]int{"foo": 1, "bar": 2}
     fmt.Println("map:", n)
 }

examples/multiples-valores-de-retorno/multiples-valores-de-retorno.go

@@ -21,7 +21,7 @@ func main() {
     fmt.Println(a)
     fmt.Println(b)
 
-    // Si solo quieres utilizar uno de los valores que regresa la
+    // Si sólo quieres utilizar uno de los valores que regresa la
     // función, puedes utilizar el identificador vacío `_`.
     _, c := vals()
     fmt.Println(c)

examples/range/range.go

@@ -8,7 +8,7 @@ import "fmt"
 
 func main() {
 
-    // Aquí utilizamos `range` para sumar los numeros de un slice.
+    // Aquí utilizamos `range` para sumar los números de un slice.
     // En los arreglos funciona de manera similar.
     nums := []int{2, 3, 4}
     sum := 0
@@ -20,24 +20,24 @@ func main() {
     // Cuando se usa `range` en un arreglo o slice, se obtiene
     // el valor del elemento y el índice donde se encuentra.
     // En el ejemplo anterior no utilizamos el índice, así que
-    // lo ignoramos asignandolo a un _identificador vacío_, `_`.
-    // Sin embargo, en algunas ocasiones si vamos a necesitar los índices.
+    // lo ignoramos asignándolo a un _identificador vacío_, `_`.
+    // Sin embargo, en algunas ocasiones sí vamos a necesitar los índices.
     for i, num := range nums {
         if num == 3 {
             fmt.Println("index:", i)
         }
     }
 
     // Al utilizar `range` en un mapa, este itera por
-    // los pares llave/valor.
+    // los pares clave/valor.
     kvs := map[string]string{"a": "apple", "b": "banana"}
     for k, v := range kvs {
         fmt.Printf("%s -> %s\n", k, v)
     }
 
     // Si se utiliza `range` en una cadena, se itera por los
     // caracteres Unicode de la misma. El primer valor es
-    // el índice del byte inicial de el primer símbolo y el
+    // el índice del byte inicial del primer símbolo y el
     // símbolo mismo.
     for i, c := range "go" {
         fmt.Println(i, c)

examples/recursion/recursion.go

@@ -4,7 +4,7 @@
 
 package main
 
-// Esta función `fact` se llama a si misma hasta que llega a la
+// Esta función `fact` se llama a sí misma hasta que llega a la
 // base de `fact(0)`.
 func fact(n int) int {
     if n == 0 {

examples/slices/slices.go

@@ -26,9 +26,9 @@ func main() {
     fmt.Println("len:", len(s))
 
     // Aparte de estas operaciones básicas, los slices
-    // soportan muchas mas que los hacen más funcionales
+    // soportan muchas más que los hacen más funcionales
     // que los arreglos. Una de ellas es `append`, la que
-    // regresa un slice que contiene uno o mas valores nuevos.
+    // regresa un slice que contiene uno o más valores nuevos.
     // Nota que necesitamos asignar el valor de regreso de
     // append tal como lo haríamos con el valor de un slice nuevo.
     s = append(s, "d")

examples/structs/structs.go

@@ -16,7 +16,7 @@ func main() {
     // Esta sintaxis crea una instancia de un struct.
     fmt.Println(persona{"Bob", 20})
 
-    // Puedes nombrear los campos cuando inicializas un struct.
+    // Puedes settear los campos cuando inicializas un struct.
     fmt.Println(persona{name: "Alice", age: 30})
 
     // Los campos omitidos serán de valor cero.
@@ -34,7 +34,7 @@ func main() {
     sp := &s
     fmt.Println(sp.age)
 
-    // los Structs son inmutables.
+    // Los Structs son inmutables.
     sp.age = 51
     fmt.Println(sp.age)
 }