From bd234ec62eab01eade3ce70a1a05207abaa36a87 Mon Sep 17 00:00:00 2001
From: mrg <miguelraz@ciencias.unam.mx>
Date: Sun, 2 Feb 2025 18:36:00 -0600
Subject: [PATCH 1/4] es translation to 2162

---
 po/es.po | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/po/es.po b/po/es.po
index f361b071a8..39543460fd 100644
--- a/po/es.po
+++ b/po/es.po
@@ -2149,12 +2149,18 @@ msgid ""
 "see [RGB color format & calculation](https://www.rapidtables.com/web/color/"
 "RGB_Color.html#rgb-format)."
 msgstr ""
+"La fórmula para calcular un color en el espacio de color RGB es: `RGB = "
+"(R*65536)+(G*256)+B, (cuando R es ROJO, G es VERDE y B es AZUL)`. Para más "
+"ver [Formato de color RGB y su cálculo](https://www.rapidtables.com/web/color/"
+"RGB_Color.html#rgb-format)."
 
 #: src/hello/print/fmt.md:86
 msgid ""
 "You [may need to list each color more than once](https://doc.rust-lang.org/"
 "std/fmt/#named-parameters)."
 msgstr ""
+"Puede que [necesites enumerar cada color más de una vez](https://doc.rust-lang.org/"
+"std/fmt/#named-parameters)."
 
 #: src/hello/print/fmt.md:87
 msgid ""

From d03043f7857244a1bfe2fe921220a29395f4a30f Mon Sep 17 00:00:00 2001
From: mrg <miguelraz@ciencias.unam.mx>
Date: Sun, 2 Feb 2025 19:18:07 -0600
Subject: [PATCH 2/4] es translation to :2600

---
 po/es.po | 160 ++++++++++++++++++++++++++++++++++++-------------------
 1 file changed, 106 insertions(+), 54 deletions(-)

diff --git a/po/es.po b/po/es.po
index 39543460fd..cd1bec8646 100644
--- a/po/es.po
+++ b/po/es.po
@@ -2167,6 +2167,8 @@ msgid ""
 "You can [pad with zeros to a width of 2](https://doc.rust-lang.org/std/fmt/"
 "#width) with `:0>2`."
 msgstr ""
+"Puedes [acolchonar con ceros a un ancho de 2](https://doc.rust-lang.org/std/fmt/"
+"#width) usando `:0>2`."
 
 #: src/hello/print/fmt.md:91
 msgid "[`std::fmt`](https://doc.rust-lang.org/std/fmt/)"
@@ -2176,55 +2178,61 @@ msgstr ""
 msgid ""
 "Rust provides access to a wide variety of `primitives`. A sample includes:"
 msgstr ""
+"Rust proporciona acceso a una amplia variedad de `primitivas`. Algunos ejemplos son:"
 
 #: src/primitives.md:5
 msgid "Scalar Types"
-msgstr ""
+msgstr "Tipos Escalares"
 
 #: src/primitives.md:7
 msgid ""
 "Signed integers: `i8`, `i16`, `i32`, `i64`, `i128` and `isize` (pointer size)"
 msgstr ""
+"Enteros con signo: `i8`, `i16`, `i32`, `i64`, `i128` y `isize` (el tamaño del puntero)"
 
 #: src/primitives.md:8
 msgid ""
 "Unsigned integers: `u8`, `u16`, `u32`, `u64`, `u128` and `usize` (pointer "
 "size)"
 msgstr ""
+"Enteros sin signo: `u8`, `u16`, `u32`, `u64`, `u128` y `usize` (el tamaño del puntero"
+")"
 
 #: src/primitives.md:10
 msgid "Floating point: `f32`, `f64`"
-msgstr ""
+msgstr "Punto flotante: `f32`, `f64`"
 
 #: src/primitives.md:11
 msgid "`char` Unicode scalar values like `'a'`, `'α'` and `'∞'` (4 bytes each)"
-msgstr ""
+msgstr "`char` Valores de Unicode escalares como `'a'`, `'α'` y `'∞'` (4 bytes cada uno)"
 
 #: src/primitives.md:12
 msgid "`bool` either `true` or `false`"
-msgstr ""
+msgstr "`bool` puede ser `true` o `falso`"
 
 #: src/primitives.md:13
 msgid "The unit type `()`, whose only possible value is an empty tuple: `()`"
-msgstr ""
+msgstr "El tipo unitario `()`, cuyo único posible valor es la tupla vacía: `()`"
 
 #: src/primitives.md:15
 msgid ""
 "Despite the value of a unit type being a tuple, it is not considered a "
 "compound type because it does not contain multiple values."
 msgstr ""
+"A pesar de que el valor de un tipo de unidad es una tupla, no se considera un"
+"tipo de compuesto porque no contiene múltiples valores."
 
 #: src/primitives.md:18
 msgid "Compound Types"
-msgstr ""
+msgstr "Tipos Compuestos"
 
 #: src/primitives.md:20
 msgid "Arrays like `[1, 2, 3]`"
-msgstr ""
+msgstr "Arreglos como `[1, 2, 3]`"
 
 #: src/primitives.md:21
 msgid "Tuples like `(1, true)`"
-msgstr ""
+msgstr "Tuplas como `(1, true)`"
 
 #: src/primitives.md:23
 msgid ""
@@ -2232,22 +2240,25 @@ msgid ""
 "annotated via a _suffix_ or _by default_. Integers default to `i32` and "
 "floats to `f64`. Note that Rust can also infer types from context."
 msgstr ""
+"Las variables siempre pueden llevar _anotación de tipos_. Los números también pueden ser"
+"anotados a través de un _sufijo_ o _por default_. Los enteros usan como default `i32` y "
+"los flotantes usan a `f64`. Tenga en cuenta que Rust puede también puede inferir tipos."
 
 #: src/primitives.md:29
 msgid "// Variables can be type annotated.\n"
-msgstr ""
+msgstr "// Las variables pueden llevar anotaciónes de tipo.\n"
 
 #: src/primitives.md:32
 msgid "// Regular annotation\n"
-msgstr ""
+msgstr "// Anotación regular\n"
 
 #: src/primitives.md:33
 msgid "// Suffix annotation\n"
-msgstr ""
+msgstr "// Anotación con sufijo"
 
 #: src/primitives.md:35
 msgid "// Or a default will be used.\n"
-msgstr ""
+msgstr "// O se usará un default.\n"
 
 #: src/primitives.md:36
 msgid "// `f64`\n"
@@ -2259,41 +2270,43 @@ msgstr ""
 
 #: src/primitives.md:39
 msgid "// A type can also be inferred from context.\n"
-msgstr ""
+msgstr "// Un tipo también se puede inferir por context.\n"
 
 #: src/primitives.md:40
 msgid "// Type i64 is inferred from another line.\n"
-msgstr ""
+msgstr "// El tipo i64 se puede inferir de otra línea.\n"
 
 #: src/primitives.md:43
 msgid "// A mutable variable's value can be changed.\n"
-msgstr ""
+msgstr "// Una mariable mutable puede cambiar.\n"
 
 #: src/primitives.md:44
 msgid "// Mutable `i32`\n"
-msgstr ""
+msgstr "// `i32` Mutable\n"
 
 #: src/primitives.md:47
 msgid "// Error! The type of a variable can't be changed.\n"
-msgstr ""
+msgstr "// Error! El tipo de la variable no se puede cambiar.\n"
 
 #: src/primitives.md:50
 msgid "// Variables can be overwritten with shadowing.\n"
-msgstr ""
+msgstr "// Las variables se puede sobreescribir con sombreo.\n"
 
 #: src/primitives.md:53
 msgid "/* Compound types - Array and Tuple */"
-msgstr ""
+msgstr "/* Tipos compuestos - Arreglo y Tupla */"
 
 #: src/primitives.md:55
 msgid "// Array signature consists of Type T and length as [T; length].\n"
-msgstr ""
+msgstr "// La declaración del tipo de Arreglo consiste del tipo T y la longitud como [T; longitud].\n"
 
 #: src/primitives.md:58
 msgid ""
 "// Tuple is a collection of values of different types \n"
 "    // and is constructed using parentheses ().\n"
 msgstr ""
+"// Una tupla es una colección de valores de diferentes tipos\n"
+"   // y se construye usando paréntesis ().\n"
 
 #: src/primitives.md:66
 msgid ""
@@ -2301,24 +2314,33 @@ msgid ""
 "(variable_bindings/mut.md), [`inference`](types/inference.md), and "
 "[`shadowing`](variable_bindings/scope.md)"
 msgstr ""
+"[the `std` library](https://doc.rust-lang.org/std/), [`mut`]"
+"(variable_bindings/mut.md), [`inference`](types/inference.md), y "
+"[`shadowing`](variable_bindings/scope.md)"
 
 #: src/primitives/literals.md:3
 msgid ""
 "Integers `1`, floats `1.2`, characters `'a'`, strings `\"abc\"`, booleans "
 "`true` and the unit type `()` can be expressed using literals."
 msgstr ""
+"Enteros `1`, flotantes `1.2`, caractéres `'a'`, cadenas `\"abc\"`, booleanos "
+"`true` y el tipo unitario `()` se puede expresar con literales."
 
 #: src/primitives/literals.md:6
 msgid ""
 "Integers can, alternatively, be expressed using hexadecimal, octal or binary "
 "notation using these prefixes respectively: `0x`, `0o` or `0b`."
 msgstr ""
+"Los enteros pueden, alternativamente, expresarse utilizando notación hexadecimal, octal o binaria"
+"usando estos prefijos respectivamente: `0x`, `0o` o` 0b`."
 
 #: src/primitives/literals.md:9
 msgid ""
 "Underscores can be inserted in numeric literals to improve readability, e.g. "
 "`1_000` is the same as `1000`, and `0.000_001` is the same as `0.000001`."
 msgstr ""
+"Se pueden insertar guíones bajos en literales numéricos para mejorar la legibilidad, por ejemplo,"
+"`1_000` es lo mismo que `1000`, y `0.000_001` es lo mismo que `0.000001`."
 
 #: src/primitives/literals.md:12
 msgid ""
@@ -2326,6 +2348,9 @@ msgid ""
 "Scientific_notation#E_notation), e.g. `1e6`, `7.6e-4`. The associated type "
 "is `f64`."
 msgstr ""
+"Rust también admite [notación E científica](https://en.wikipedia.org/wiki/"
+"Scientific_notation#E_notation), e.g. `1e6`, `7.6e-4`. El tipo asociado es "
+"`f64`."
 
 #: src/primitives/literals.md:15
 msgid ""
@@ -2333,6 +2358,9 @@ msgid ""
 "use the `u32` suffix to indicate that the literal is an unsigned 32-bit "
 "integer, and the `i32` suffix to indicate that it's a signed 32-bit integer."
 msgstr ""
+"Necesitamos decirle al compilador el tipo de literales que usamos. Por ahora, lo haremos"
+"usando el sufijo` u32` para indicar que el literal es un entero sin signo de 32 bits "
+", y el sufijo `i32` para indicar que es un entero con signo de 32 bits ".
 
 #: src/primitives/literals.md:19
 msgid ""
@@ -2341,10 +2369,14 @@ msgid ""
 "[C-like languages](https://en.wikipedia.org/wiki/"
 "Operator_precedence#Programming_languages)."
 msgstr ""
+"Los operadores disponibles y su precedencia [en Rust](https://doc.rust-lang."
+"org/reference/expressions.html#expression-precedence) es similar a otros "
+"[lenguajes como C](https://en.wikipedia.org/wiki/"
+"Operator_precedence#Programming_languages)."
 
 #: src/primitives/literals.md:24
 msgid "// Integer addition\n"
-msgstr ""
+msgstr "// Suma de enteros"
 
 #: src/primitives/literals.md:25
 msgid "\"1 + 2 = {}\""
@@ -2352,7 +2384,7 @@ msgstr ""
 
 #: src/primitives/literals.md:27
 msgid "// Integer subtraction\n"
-msgstr ""
+msgstr "// Resta de enteros"
 
 #: src/primitives/literals.md:28
 msgid "\"1 - 2 = {}\""
@@ -2362,62 +2394,63 @@ msgstr ""
 msgid ""
 "// TODO ^ Try changing `1i32` to `1u32` to see why the type is important\n"
 msgstr ""
+"// TAREA ^ Intenta cambiar `1i32` a `1u32` para ver por qué el tipo es importante\n"
 
 #: src/primitives/literals.md:31
 msgid "// Scientific notation\n"
-msgstr ""
+msgstr "// Notación científica"
 
 #: src/primitives/literals.md:32
 msgid "\"1e4 is {}, -2.5e-3 is {}\""
-msgstr ""
+msgstr "\"1e4 es {}, -2.5e-3 es {}\""
 
 #: src/primitives/literals.md:34
 msgid "// Short-circuiting boolean logic\n"
-msgstr ""
+msgstr "// Lógica booleana de corto circuito"
 
 #: src/primitives/literals.md:35
 msgid "\"true AND false is {}\""
-msgstr ""
+msgstr "\"true Y false es {}\""
 
 #: src/primitives/literals.md:36
 msgid "\"true OR false is {}\""
-msgstr ""
+msgstr "\"true O false es {}\""
 
 #: src/primitives/literals.md:37
 msgid "\"NOT true is {}\""
-msgstr ""
+msgstr "\"NOT true es {}\""
 
 #: src/primitives/literals.md:39
 msgid "// Bitwise operations\n"
-msgstr ""
+msgstr "// Operaciones sobre bits"
 
 #: src/primitives/literals.md:40
 msgid "\"0011 AND 0101 is {:04b}\""
-msgstr ""
+msgstr "\"0011 AND 0101 es {:04b}\""
 
 #: src/primitives/literals.md:41
 msgid "\"0011 OR 0101 is {:04b}\""
-msgstr ""
+msgstr "\"0011 OR 0101 es {:04b}\""
 
 #: src/primitives/literals.md:42
 msgid "\"0011 XOR 0101 is {:04b}\""
-msgstr ""
+msgstr "\"0011 XOR 0101 es {:04b}\""
 
 #: src/primitives/literals.md:43
 msgid "\"1 << 5 is {}\""
-msgstr ""
+msgstr "\"1 << 5 es {}\""
 
 #: src/primitives/literals.md:44
 msgid "\"0x80 >> 2 is 0x{:x}\""
-msgstr ""
+msgstr "\"0x80 >> 2 es 0x{:x}\""
 
 #: src/primitives/literals.md:46
 msgid "// Use underscores to improve readability!\n"
-msgstr ""
+msgstr "// ¡Usa guiones bajos para mejorar la legibilidad!\n"
 
 #: src/primitives/literals.md:47
 msgid "\"One million is written as {}\""
-msgstr ""
+msgstr "\" Un millón se escribe como {}\""
 
 #: src/primitives/tuples.md:3
 msgid ""
@@ -2427,22 +2460,27 @@ msgid ""
 "can use tuples to return multiple values, as tuples can hold any number of "
 "values."
 msgstr ""
+"Una tupla es una colección de valores de diferentes tipos. Se construyen tuplas"
+"usando paréntesis `()`, y cada tupla en sí es un valor con la anotación de tipo"
+"`(T1, t2, ...) `, donde `t1`, `t2` son los tipos de sus miembros. Las funciones"
+"pueden usar tuplas para devolver múltiples valores, ya que las tuplas pueden contener cualquier número de"
+"valores."
 
 #: src/primitives/tuples.md:9
 msgid "// Tuples can be used as function arguments and as return values.\n"
-msgstr ""
+msgstr "// Las tuplas se pueden como argumentos de funciones y como sus valores de retorno.\n"
 
 #: src/primitives/tuples.md:11
 msgid "// `let` can be used to bind the members of a tuple to variables.\n"
-msgstr ""
+msgstr "// `let` se puede usar para ligar los miembros de la tupla a variables.\n"
 
 #: src/primitives/tuples.md:16
 msgid "// The following struct is for the activity.\n"
-msgstr ""
+msgstr "// La siguiente `struct` es para la actividad.\n"
 
 #: src/primitives/tuples.md:22
 msgid "// A tuple with a bunch of different types.\n"
-msgstr ""
+msgstr "// Una tupla es montón de tipos diferentes.\n"
 
 #: src/primitives/tuples.md:26 src/generics.md:50 src/generics.md:55
 #: src/generics/gen_fn.md:47
@@ -2451,27 +2489,27 @@ msgstr ""
 
 #: src/primitives/tuples.md:28
 msgid "// Values can be extracted from the tuple using tuple indexing.\n"
-msgstr ""
+msgstr "// Se pueden extraer valores de la tupla indexando"
 
 #: src/primitives/tuples.md:29
 msgid "\"Long tuple first value: {}\""
-msgstr ""
+msgstr "\"Tupla grande primer valor: {}\""
 
 #: src/primitives/tuples.md:30
 msgid "\"Long tuple second value: {}\""
-msgstr ""
+msgstr "\"Tupla grande segundo valor: {}\""
 
 #: src/primitives/tuples.md:32
 msgid "// Tuples can be tuple members.\n"
-msgstr ""
+msgstr "// Tuplas con tuplas como miembros.\n"
 
 #: src/primitives/tuples.md:35
 msgid "// Tuples are printable.\n"
-msgstr ""
+msgstr "// Las tuples se pueden imprimir.\n"
 
 #: src/primitives/tuples.md:36
 msgid "\"tuple of tuples: {:?}\""
-msgstr ""
+msgstr "\"tupla de tuplas: {:?}\""
 
 #: src/primitives/tuples.md:38
 msgid ""
@@ -2480,32 +2518,38 @@ msgid ""
 "    //println!(\"Too long tuple: {:?}\", too_long_tuple);\n"
 "    // TODO ^ Uncomment the above 2 lines to see the compiler error\n"
 msgstr ""
+"// Pero no se pueden imprimir tuplas demasadio grandes (más de 12 elementos).\n"
+"   // let tupla_demasiado_grande = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);\n"
+"   // println!(\" Tupla demasiado grande: {:?} \ ", tupla_demasiado_grande);\n"
+"   // TAREA ^ Quita el comentario de las 2 líneas anteriores para ver el error del compilador\n"
 
 #: src/primitives/tuples.md:44
 msgid "\"Pair is {:?}\""
-msgstr ""
+msgstr "\"Par es {:?}\""
 
 #: src/primitives/tuples.md:46
 msgid "\"The reversed pair is {:?}\""
-msgstr ""
+msgstr "\"El par invertido es {:?}\""
 
 #: src/primitives/tuples.md:48
 msgid ""
 "// To create one element tuples, the comma is required to tell them apart\n"
 "    // from a literal surrounded by parentheses.\n"
 msgstr ""
+"// Para crear un tuplas de un sólo elemento, se requiere la coma para distinguirlas\n"
+"   // de un literal rodeado de paréntesis.\n"
 
 #: src/primitives/tuples.md:50
 msgid "\"One element tuple: {:?}\""
-msgstr ""
+msgstr "\"Una tupla de 1 elemento: {:?}\""
 
 #: src/primitives/tuples.md:51
 msgid "\"Just an integer: {:?}\""
-msgstr ""
+msgstr "\"Sólo un entero: {:?}\""
 
 #: src/primitives/tuples.md:53
 msgid "// Tuples can be destructured to create bindings.\n"
-msgstr ""
+msgstr "// Las tuplas puede desestructurar para crear variables.\n"
 
 #: src/primitives/tuples.md:54 src/conversion/from_into.md:17
 #: src/fn/closures/input_parameters.md:52 src/std_misc/fs.md:51
@@ -2522,12 +2566,17 @@ msgid ""
 "example, so that if you switch from printing the debug format `{:?}` to the "
 "display format `{}`, you see the following output:"
 msgstr ""
+"_Recapitulando_: Agrega el rasgo `fmt::Display` a `Matrix` en el ejemplo"
+"anterior, de modo que si cambias de imprimir el formato de depuración `{:?}` al"
+"formato de visualización `{}`, ves la siguiente salida:"
 
 #: src/primitives/tuples.md:75
 msgid ""
 "You may want to refer back to the example for [print display](../hello/print/"
 "print_display.md)."
 msgstr ""
+"Es posible que desee consultar el ejemplo de [impresión a pantalla](../hello/print/"
+"print_display.md)."
 
 #: src/primitives/tuples.md:76
 msgid ""
@@ -2535,18 +2584,21 @@ msgid ""
 "accepts a matrix as an argument, and returns a matrix in which two elements "
 "have been swapped. For example:"
 msgstr ""
+"Agrega una función `transpose` usando la función `reverse` como una plantilla, el cual"
+"acepta una matriz como argumento y devuelve una matriz en la que dos elementos"
+"han sido intercambiados. Por ejemplo:"
 
 #: src/primitives/tuples.md:81
 msgid "\"Matrix:\\n{}\""
-msgstr ""
+msgstr "\"Matriz:\\n{}\""
 
 #: src/primitives/tuples.md:82
 msgid "\"Transpose:\\n{}\""
-msgstr ""
+msgstr "\"Transpuesta:\\n{}""
 
 #: src/primitives/tuples.md:85
 msgid "Results in the output:"
-msgstr ""
+msgstr "Resultados en el output:"
 
 #: src/primitives/array.md:3
 msgid ""

From fc2c7e784ab2881d175fc671551a338d61887046 Mon Sep 17 00:00:00 2001
From: mrg <miguelraz@ciencias.unam.mx>
Date: Sun, 2 Feb 2025 19:25:36 -0600
Subject: [PATCH 3/4] correct syntax errors

---
 po/es.po | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/po/es.po b/po/es.po
index cd1bec8646..93a5390d7f 100644
--- a/po/es.po
+++ b/po/es.po
@@ -2254,7 +2254,7 @@ msgstr "// Anotación regular\n"
 
 #: src/primitives.md:33
 msgid "// Suffix annotation\n"
-msgstr "// Anotación con sufijo"
+msgstr "// Anotación con sufijo\n"
 
 #: src/primitives.md:35
 msgid "// Or a default will be used.\n"
@@ -2359,8 +2359,8 @@ msgid ""
 "integer, and the `i32` suffix to indicate that it's a signed 32-bit integer."
 msgstr ""
 "Necesitamos decirle al compilador el tipo de literales que usamos. Por ahora, lo haremos"
-"usando el sufijo` u32` para indicar que el literal es un entero sin signo de 32 bits "
-", y el sufijo `i32` para indicar que es un entero con signo de 32 bits ".
+"usando el sufijo `u32` para indicar que el literal es un entero sin signo de 32 bits "
+", y el sufijo `i32` para indicar que es un entero con signo de 32 bits."
 
 #: src/primitives/literals.md:19
 msgid ""
@@ -2520,7 +2520,7 @@ msgid ""
 msgstr ""
 "// Pero no se pueden imprimir tuplas demasadio grandes (más de 12 elementos).\n"
 "   // let tupla_demasiado_grande = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);\n"
-"   // println!(\" Tupla demasiado grande: {:?} \ ", tupla_demasiado_grande);\n"
+"   // println!(\"Tupla demasiado grande: {:?}\", tupla_demasiado_grande);\n"
 "   // TAREA ^ Quita el comentario de las 2 líneas anteriores para ver el error del compilador\n"
 
 #: src/primitives/tuples.md:44
@@ -2594,7 +2594,7 @@ msgstr "\"Matriz:\\n{}\""
 
 #: src/primitives/tuples.md:82
 msgid "\"Transpose:\\n{}\""
-msgstr "\"Transpuesta:\\n{}""
+msgstr "\"Transpuesta:\\n{}\""
 
 #: src/primitives/tuples.md:85
 msgid "Results in the output:"

From 612b4fd48f00c606c2de9b75b55c6ec7ec2c4f50 Mon Sep 17 00:00:00 2001
From: mrg <miguelraz@ciencias.unam.mx>
Date: Sun, 2 Feb 2025 23:49:02 -0600
Subject: [PATCH 4/4] es translation to 1:3100

---
 po/es.po | 206 +++++++++++++++++++++++++++++++++++++------------------
 1 file changed, 138 insertions(+), 68 deletions(-)

diff --git a/po/es.po b/po/es.po
index 93a5390d7f..a68b89b2e3 100644
--- a/po/es.po
+++ b/po/es.po
@@ -188,7 +188,7 @@ msgstr ""
 
 #: src/SUMMARY.md:53 src/flow_control/match/destructuring.md:1
 msgid "Destructuring"
-msgstr "Desesctructurar"
+msgstr "Destructura"
 
 #: src/SUMMARY.md:54
 #: src/flow_control/match/destructuring/destructure_tuple.md:1
@@ -2607,6 +2607,10 @@ msgid ""
 "which is known at compile time, is part of their type signature `[T; "
 "length]`."
 msgstr ""
+"Un arreglo es una colección de objetos del mismo tipo `t`, almacenado en "
+"memoria contigua. Los arreglos se crean usando corchetes cuardrados `[]`, y su longitud, "
+"que se conoce en el momento de la compilación, es parte de su anotación de tipo `[T; "
+"longitud]`."
 
 #: src/primitives/array.md:7
 msgid ""
@@ -2617,62 +2621,68 @@ msgid ""
 "x86-64. Slices can be used to borrow a section of an array and have the type "
 "signature `&[T]`."
 msgstr ""
+"Las slices son similares a los arreglos, pero su longitud no se conoce al momento de compilar."
+"En cambio, un slice es un objeto de dos 'words' del procesador; la primera palabra es un puntero a los"
+"datos, la segunda palabra es la longitud del slice. El tamaño de la palabra es el mismo"
+"que usize, el cual se determina por la arquitectura del procesador, e.g. 64 bits en "
+"x86-64. Los slices se pueden usar para tomar un `borrow` de una sección de un arreglo y tener la anotación"
+"de tipo `&[t]`."
 
 #: src/primitives/array.md:15
 msgid "// This function borrows a slice.\n"
-msgstr ""
+msgstr "// Esta funcion hace borrow a una slice.\n"
 
 #: src/primitives/array.md:18
 msgid "\"First element of the slice: {}\""
-msgstr ""
+msgstr "\" El primer elemento de un slice: {}\""
 
 #: src/primitives/array.md:19
 msgid "\"The slice has {} elements\""
-msgstr ""
+msgstr "\"El slice tiene {} elementos\""
 
 #: src/primitives/array.md:23
 msgid "// Fixed-size array (type signature is superfluous).\n"
-msgstr ""
+msgstr "// Arreglos de tamaño fijo (su anotación de tipo es superflua).\n"
 
 #: src/primitives/array.md:26
 msgid "// All elements can be initialized to the same value.\n"
-msgstr ""
+msgstr "// Todos los elementos pueden ser inicializados al mismo valor.\n"
 
 #: src/primitives/array.md:29
 msgid "// Indexing starts at 0.\n"
-msgstr ""
+msgstr "// Los índices empiezan en 0.\n"
 
 #: src/primitives/array.md:30
 msgid "\"First element of the array: {}\""
-msgstr ""
+msgstr "\"El primer elemento del arreglo: {}\""
 
 #: src/primitives/array.md:31
 msgid "\"Second element of the array: {}\""
-msgstr ""
+msgstr "\"El segundo elemento del arreglo: {}\""
 
 #: src/primitives/array.md:33
 msgid "// `len` returns the count of elements in the array.\n"
-msgstr ""
+msgstr "// `len` regresa cuántos elementos hay en el arreglo.\n"
 
 #: src/primitives/array.md:34
 msgid "\"Number of elements in array: {}\""
-msgstr ""
+msgstr "\"Número de elementos en el arreglo: {} \""
 
 #: src/primitives/array.md:36
 msgid "// Arrays are stack allocated.\n"
-msgstr ""
+msgstr "// Los arreglos se colocan en el stack.\n"
 
 #: src/primitives/array.md:37
 msgid "\"Array occupies {} bytes\""
-msgstr ""
+msgstr "\"Los arreglos ocupan {} bytes\""
 
 #: src/primitives/array.md:39
 msgid "// Arrays can be automatically borrowed as slices.\n"
-msgstr ""
+msgstr "// Los arreglos pueden ser `borrowed` como slices.\n"
 
 #: src/primitives/array.md:40
 msgid "\"Borrow the whole array as a slice.\""
-msgstr ""
+msgstr "\"Hace borrow de todo el arreglo como un slice.\""
 
 #: src/primitives/array.md:43
 msgid ""
@@ -2681,18 +2691,22 @@ msgid ""
 "    // `starting_index` is the first position in the slice.\n"
 "    // `ending_index` is one more than the last position in the slice.\n"
 msgstr ""
+"// Los slices pueden apuntar a una sección de un arreglo.\n"
+"   // Estos son de la forma [índice_inicial..índice_final].\n"
+"   // `índice_inicial` es la primera posición en el slice.\n"
+"   // `índice_final` es uno más que la última posición en la porción.\n"
 
 #: src/primitives/array.md:47
 msgid "\"Borrow a section of the array as a slice.\""
-msgstr ""
+msgstr "\"Hace Borrow de una sección del arreglo como un slice.\""
 
 #: src/primitives/array.md:50
 msgid "// Example of empty slice `&[]`:\n"
-msgstr ""
+msgstr "// Un ejemplo de un slice vacío `&[]`:\n"
 
 #: src/primitives/array.md:53
 msgid "// Same but more verbose\n"
-msgstr ""
+msgstr "// Lo mismo pero menos conciso"
 
 #: src/primitives/array.md:55
 msgid ""
@@ -2701,10 +2715,14 @@ msgid ""
 "    // `.expect()` if you would like the program to exit with a nice\n"
 "    // message instead of happily continue.\n"
 msgstr ""
+"// Se pueden acceder a las arreglos de forma segura usando `.get`, el cual devuelve un \n"
+"    // `Option'. Aquí se puede usar un match como se muestra a continuación, o en su caso con \n"
+"    // `.expect()` si desees que el programa termine con un amable\n"
+"    // mensaje en lugar de continuar felizmente.\n"
 
 #: src/primitives/array.md:59
 msgid "// Oops, one element too far!\n"
-msgstr ""
+msgstr "// ¡Oops!, un elemento de sobra.\n"
 
 #: src/primitives/array.md:61
 msgid "\"{}: {}\""
@@ -2712,7 +2730,7 @@ msgstr ""
 
 #: src/primitives/array.md:62
 msgid "\"Slow down! {} is too far!\""
-msgstr ""
+msgstr "\"¡Para! {} es demasiado lejos\""
 
 #: src/primitives/array.md:66
 msgid ""
@@ -2722,95 +2740,107 @@ msgid ""
 "    // Out of bound indexing on slice causes runtime error.\n"
 "    //println!(\"{}\", xs[..][5]);\n"
 msgstr ""
+"// Usar un índice constante que se encuentra fuera del rango válido causa un error de compilación.\n"
+"    //println!(\"{}\", xs[5]);\n"
+"    // Usar un índice fuera de rango en un slice causa un error de compilación.\n"
+"    //println!(\"{}\", xs[..][5]);\n"
 
 #: src/custom_types.md:3
 msgid "Rust custom data types are formed mainly through the two keywords:"
-msgstr ""
+msgstr "Los tipos de datos personalizados en Rust se logran principalmente con 2 palabras clave:"
 
 #: src/custom_types.md:5
 msgid "`struct`: define a structure"
-msgstr ""
+msgstr "`struct`: define una estructura"
 
 #: src/custom_types.md:6
 msgid "`enum`: define an enumeration"
-msgstr ""
+msgstr "`enum`: define una enumeración"
 
 #: src/custom_types.md:8
 msgid "Constants can also be created via the `const` and `static` keywords."
-msgstr ""
+msgstr "Las constantes se crean con las palabras clave `const` o `static`."
 
 #: src/custom_types/structs.md:3
 msgid ""
 "There are three types of structures (\"structs\") that can be created using "
 "the `struct` keyword:"
 msgstr ""
+"Hay tres tipos de estructuras (\"struct\") que se pueden crear usando"
+"la palabra clave 'struct`:"
 
 #: src/custom_types/structs.md:6
 msgid "Tuple structs, which are, basically, named tuples."
-msgstr ""
+msgstr "Estructuras de tupla, las cuales son básicamente tuplas nombradas."
 
 #: src/custom_types/structs.md:7
 msgid ""
 "The classic [C structs](https://en.wikipedia.org/wiki/"
 "Struct_(C_programming_language))"
 msgstr ""
+"Las clásicas estructuras [struct de C](https://en.wikipedia.org/wiki/"
+"Struct_(C_programming_language))"
 
 #: src/custom_types/structs.md:8
 msgid "Unit structs, which are field-less, are useful for generics."
-msgstr ""
+msgstr "Las structs unitarias, las cuales no tienen campos, y son útiles para los genéricos."
 
 #: src/custom_types/structs.md:11 src/custom_types/enum/enum_use.md:6
 #: src/custom_types/enum/c_like.md:6
 msgid "// An attribute to hide warnings for unused code.\n"
-msgstr ""
+msgstr "// Un atributo para esconder las advertencias del código no utilizado.\n"
 
 #: src/custom_types/structs.md:19
 msgid "// A unit struct\n"
-msgstr ""
+msgstr "// Una struct unitaria"
 
 #: src/custom_types/structs.md:22
 msgid "// A tuple struct\n"
-msgstr ""
+msgstr "// Una struct de tupla"
 
 #: src/custom_types/structs.md:25
 msgid "// A struct with two fields\n"
-msgstr ""
+msgstr "// Una struct de dos campos\n"
 
 #: src/custom_types/structs.md:31
 msgid "// Structs can be reused as fields of another struct\n"
-msgstr ""
+msgstr "// Las Structs pueden reutilizar los campos de otras structs\n"
 
 #: src/custom_types/structs.md:34
 msgid ""
 "// A rectangle can be specified by where the top left and bottom right\n"
 "    // corners are in space.\n"
 msgstr ""
+"// Un rectángulo se puede escpecificar por dónde las esquinas de arriba a la izquierda y abajo a la derecha"
+"    // se encuentran en el espacio.\n"
 
 #: src/custom_types/structs.md:41
 msgid "// Create struct with field init shorthand\n"
-msgstr ""
+msgstr "// Abreviación para crear un struct con un campo ya inicializado\n"
 
 #: src/custom_types/structs.md:46
 msgid "// Print debug struct\n"
-msgstr ""
+msgstr "// Imprime un struct de depuración\n"
 
 #: src/custom_types/structs.md:49
 msgid "// Instantiate a `Point`\n"
-msgstr ""
+msgstr "// Instanciar un `Point`\n"
 
 #: src/custom_types/structs.md:53
 msgid "// Access the fields of the point\n"
-msgstr ""
+msgstr "// Accesa los campos del punto\n"
 
 #: src/custom_types/structs.md:54
 msgid "\"point coordinates: ({}, {})\""
-msgstr ""
+msgstr "\"coordenadas del punto: ({}, {})\""
 
 #: src/custom_types/structs.md:56
 msgid ""
 "// Make a new point by using struct update syntax to use the fields of our\n"
 "    // other one\n"
 msgstr ""
+"// Crea un nuevo punto usando la sintáxis de update de struct para usar los campos\n"
+"    // del otro struct\n"
 
 #: src/custom_types/structs.md:60
 msgid ""
@@ -2818,44 +2848,49 @@ msgid ""
 "that field\n"
 "    // from `another_point`\n"
 msgstr ""
+"// `abajo_derecha.y` va a ser lo mismo que `otro_punto.y` por que usamos ese "
+"campo \n"
+"    // de `otro_punto`\n"
 
 #: src/custom_types/structs.md:62
 msgid "\"second point: ({}, {})\""
-msgstr ""
+msgstr "\"segundo punto: ({}, {})\""
 
 #: src/custom_types/structs.md:64
 msgid "// Destructure the point using a `let` binding\n"
-msgstr ""
+msgstr "// Destructura el punto con un enlace `let`\n"
 
 #: src/custom_types/structs.md:68
 msgid "// struct instantiation is an expression too\n"
-msgstr ""
+msgstr "// también se puede hacer la instanciación de un struct con una expresión"
 
 #: src/custom_types/structs.md:73
 msgid "// Instantiate a unit struct\n"
-msgstr ""
+msgstr "// Instacia una struct unitaria"
 
 #: src/custom_types/structs.md:76
 msgid "// Instantiate a tuple struct\n"
-msgstr ""
+msgstr "// Instancia una estructura de tupla\n"
 
 #: src/custom_types/structs.md:79
 msgid "// Access the fields of a tuple struct\n"
-msgstr ""
+msgstr "// Accesa los campos de una estructura de tupla\n"
 
 #: src/custom_types/structs.md:80 src/custom_types/structs.md:85
 msgid "\"pair contains {:?} and {:?}\""
-msgstr ""
+msgstr "\"un par contiene {:?} y {:?}\""
 
 #: src/custom_types/structs.md:82
 msgid "// Destructure a tuple struct\n"
-msgstr ""
+msgstr "// Destructura una estructura de tupla"
 
 #: src/custom_types/structs.md:91
 msgid ""
 "Add a function `rect_area` which calculates the area of a `Rectangle` (try "
 "using nested destructuring)."
 msgstr ""
+"Agregue una función `rect_area` que calcula el área de un `Rectangle` (intenta"
+"usar de la destructación anidada)."
 
 #: src/custom_types/structs.md:93
 msgid ""
@@ -2863,10 +2898,13 @@ msgid ""
 "returns a `Rectangle` with its top left corner on the point, and a width and "
 "height corresponding to the `f32`."
 msgstr ""
+"Agregue una función `square` que toma un `Punto` y un `f32` como argumentos, y "
+"devuelve un `Rectangle` con su esquina superior izquierda en el punto, y un ancho y"
+"altura correspondiente al `f32`."
 
 #: src/custom_types/structs.md:97
 msgid "See also"
-msgstr ""
+msgstr "Véase también"
 
 #: src/custom_types/structs.md:99
 msgid ""
@@ -2874,6 +2912,9 @@ msgid ""
 "raw_identifiers.md) and [destructuring](../flow_control/match/destructuring."
 "md)"
 msgstr ""
+"[`attributes`](../attribute.md), [raw identifiers](../compatibility/"
+"raw_identifiers.md) y [destructuring](../flow_control/match/destructuring."
+"md)"
 
 #: src/custom_types/enum.md:3
 msgid ""
@@ -2881,6 +2922,9 @@ msgid ""
 "different variants. Any variant which is valid as a `struct` is also valid "
 "in an `enum`."
 msgstr ""
+"La palabra clave `enum` permite la creación de un tipo que puede ser uno de unas pocas"
+"diferentes variantes. Cualquier variante que sea válida como `struct` también es válida"
+"en un `enum`."
 
 #: src/custom_types/enum.md:8
 msgid ""
@@ -2889,52 +2933,60 @@ msgid ""
 "// `PageLoad != PageUnload` and `KeyPress(char) != Paste(String)`.\n"
 "// Each is different and independent.\n"
 msgstr ""
+"// Cree un `enum` para clasificar un evento web. Tenga en cuenta cómo ambos los\n"
+"// nombres y los tipos juntos especifican la variante:\n"
+"// `PageLoad != PageUnload` y `KeyPress(char) != Paste(String)`.\n"
+"// Cada uno es diferente e independiente.\n"
 
 #: src/custom_types/enum.md:13
 msgid "// An `enum` variant may either be `unit-like`,\n"
-msgstr ""
+msgstr "// Una variante `enum` puede ser `cuasi-unitaria`,\n"
 
 #: src/custom_types/enum.md:16
 msgid "// like tuple structs,\n"
-msgstr ""
+msgstr "// como estructuras de tuplas"
 
 #: src/custom_types/enum.md:19
 msgid "// or c-like structures.\n"
-msgstr ""
+msgstr "// o estructuras estilo C.\n"
 
 #: src/custom_types/enum.md:22
 msgid ""
 "// A function which takes a `WebEvent` enum as an argument and\n"
 "// returns nothing.\n"
 msgstr ""
+"// Una función que toma un enum 'WebEvent` como argumento y \n"
+"// no devuelve nada.\n"
 
 #: src/custom_types/enum.md:27
 msgid "\"page loaded\""
-msgstr ""
+msgstr "\"página cargada\""
 
 #: src/custom_types/enum.md:28
 msgid "\"page unloaded\""
-msgstr ""
+msgstr "\"página descargada \""
 
 #: src/custom_types/enum.md:29
 msgid "// Destructure `c` from inside the `enum` variant.\n"
-msgstr ""
+msgstr "// Destructura `c` desde dentro de la variante `enum`.\n"
 
 #: src/custom_types/enum.md:30
 msgid "\"pressed '{}'.\""
-msgstr ""
+msgstr "\"presionaste '{}'.\""
 
 #: src/custom_types/enum.md:31
 msgid "\"pasted \\\"{}\\\".\""
-msgstr ""
+msgstr "\"pegaste \\\"{}\\\".\""
+
 
 #: src/custom_types/enum.md:32
 msgid "// Destructure `Click` into `x` and `y`.\n"
-msgstr ""
+msgstr "// Destructura `Click` en `x` y `y`.\n"
 
 #: src/custom_types/enum.md:34
 msgid "\"clicked at x={}, y={}.\""
-msgstr ""
+msgstr "\"click en x={}, y={}.\""
+
 
 #: src/custom_types/enum.md:40
 msgid "'x'"
@@ -2942,15 +2994,17 @@ msgstr ""
 
 #: src/custom_types/enum.md:41
 msgid "// `to_owned()` creates an owned `String` from a string slice.\n"
-msgstr ""
+msgstr "// `to_owned()` crea un `String` que es owned de slice de cadena.\n"
+
 
 #: src/custom_types/enum.md:42
 msgid "\"my text\""
-msgstr ""
+msgstr "\"mi texto\""
+
 
 #: src/custom_types/enum.md:56
 msgid "Type aliases"
-msgstr ""
+msgstr "Aliases de tipos"
 
 #: src/custom_types/enum.md:58
 msgid ""
@@ -2958,10 +3012,13 @@ msgid ""
 "This might be useful if the enum's name is too long or too generic, and you "
 "want to rename it."
 msgstr ""
+"Si usa un alias de tipo, puedes consultar cada variante de enum a través de su alias."
+"Esto podría ser útil si el nombre del enum es demasiado largo o demasiado genérico, y lo "
+"quieres renombrar."
 
 #: src/custom_types/enum.md:67
 msgid "// Creates a type alias\n"
-msgstr ""
+msgstr "// Crear un alias de tipo\n"
 
 #: src/custom_types/enum.md:72
 msgid ""
@@ -2969,12 +3026,17 @@ msgid ""
 "inconvenient\n"
 "    // name.\n"
 msgstr ""
+"// Podemos referirnos a cada variante a través de su alias, y no su largo e"
+"inconveniente \n"
+"   // nombre. \n"
 
 #: src/custom_types/enum.md:78
 msgid ""
 "The most common place you'll see this is in `impl` blocks using the `Self` "
 "alias."
 msgstr ""
+"El lugar más común que verás esto es en los bloques de `impl` usando el alias `Self` "
+"."
 
 #: src/custom_types/enum.md:96
 msgid ""
@@ -2982,6 +3044,9 @@ msgid ""
 "report](https://github.com/rust-lang/rust/pull/61682/"
 "#issuecomment-502472847) from when this feature was stabilized into Rust."
 msgstr ""
+"Para obtener más información sobre enums y alias de tipo, puedes leer el [informe "
+"estabilización](https://github.com/rust-lang/rust/pull/61682/"
+"#issuecomment-502472847) de cuando este feature se estabilizó en Rust."
 
 #: src/custom_types/enum.md:102
 msgid ""
@@ -2989,48 +3054,53 @@ msgid ""
 "str.md), [\"Type alias enum variants\" RFC](https://rust-lang.github.io/"
 "rfcs/2338-type-alias-enum-variants.html)"
 msgstr ""
+"[`match`](../flow_control/match.md), [`fn`](../fn.md), y [`String`](../std/"
+"str.md), [\"Type alias enum variants\" RFC](https://rust-lang.github.io/"
+"rfcs/2338-type-alias-enum-variants.html)"
 
 #: src/custom_types/enum/enum_use.md:3
 msgid "The `use` declaration can be used so manual scoping isn't needed:"
-msgstr ""
+msgstr "La declaración `use` se puede usar de tal manera que no se necesiten alcances manuales:"
 
 #: src/custom_types/enum/enum_use.md:20
 msgid ""
 "// Explicitly `use` each name so they are available without\n"
 "    // manual scoping.\n"
 msgstr ""
+"// Explícitamente `use` (usa) cada nombre para que estén disponibles sin \n "
+"    // alcance manual. \n"
 
 #: src/custom_types/enum/enum_use.md:23
 msgid "// Automatically `use` each name inside `Role`.\n"
-msgstr ""
+msgstr "// Hace `use` automaticamente para cada nombre dentro de `Role`.\n"
 
 #: src/custom_types/enum/enum_use.md:26
 msgid "// Equivalent to `Stage::Beginner`.\n"
-msgstr ""
+msgstr "// Equivalente a `Stage::Beginner`.\n"
 
 #: src/custom_types/enum/enum_use.md:28
 msgid "// Equivalent to `Role::Student`.\n"
-msgstr ""
+msgstr "// Equivalente a `Role::Student`.\n"
 
 #: src/custom_types/enum/enum_use.md:32
 msgid "// Note the lack of scoping because of the explicit `use` above.\n"
-msgstr ""
+msgstr "// Notamos que la falta de alcances se debe al uso explícito de `use` arriba.\n"
 
 #: src/custom_types/enum/enum_use.md:33
 msgid "\"Beginners are starting their learning journey!\""
-msgstr ""
+msgstr "\"¡Los principiantes están comenzando su aprendizaje!\""
 
 #: src/custom_types/enum/enum_use.md:34
 msgid "\"Advanced learners are mastering their subjects...\""
-msgstr ""
+msgstr "\"Los estudiantes avanzados están dominando sus materias...\""
 
 #: src/custom_types/enum/enum_use.md:38
 msgid "// Note again the lack of scoping.\n"
-msgstr ""
+msgstr "// Notamos otra vez la falta de alcances.\n"
 
 #: src/custom_types/enum/enum_use.md:39
 msgid "\"Students are acquiring knowledge!\""
-msgstr ""
+msgstr "\"¡Los estudiantes están adquiriendo conocimiento!\""
 
 #: src/custom_types/enum/enum_use.md:40
 msgid "\"Teachers are spreading knowledge!\""