From cc6d5f49c96a15e5e8fcb867e97a9f0c001d235e Mon Sep 17 00:00:00 2001 From: Ivan Lynch Date: Mon, 26 Feb 2024 17:12:21 -0300 Subject: [PATCH 1/2] fix: merge issues (#57) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Traducción de los capítulos 14 * docs: add a new logo to the translation * docs: add the telegram group in the readme * Traducción de los capítulos 16 * Traducción de los capítulos 17 * Traducción de los capítulos 17 * Traducción de los capítulos 18 * docs: update the summary * docs: add some translations to the summary * ci: now check using the encoding utf8 * ci: add some exceptions in the dictionary * Traducción de los capítulos 19 * Traducción de los capítulos 20 * fix: solve the redirections to the original documentation * fix: remove translated paragraph * fix: some improves and add new words to the dictionary * fix: add some words to the dictionary * feat: translate the part G of the appendix * docs: translate some sections of the appendix * docs: change preludio for prelude and add a reference, besides add a better translation * docs: change the url of the repository * fix(ui): chapters 11.2 and 11.3 title translations * Traducción del capítulo 20-03 del libro * Traducción del apéndice-03 del libro * Traducción del apéndice-03 del libro * Traducción del apéndice-04 del libro * chore: add some words to skip in the dictonary * chore: add more words to skip * fix: little corrections in texts * chore: skip more words * fix: correct some misspelled words * fix: correct some misspelled words * fix: correct some misspelled words * fix: last fix! * fix: solve a bad link * fix: snart -> smart, Update ch15-02-deref.md * fix: update some links * fix: add some words alloweds * traducción literal cons list, "lista de desventajas" -> "lista enlazada" Update ch15-06-reference-cycles.md * ✏️ fix: fix typos * 🩹 fix: Arreglando error de link * ✏️ fix: fix typos * ci: sitemap workflow * fix: typos and small grammatical errors in chapter 3.1 * ci: remove sitemap.yml; no es necesario tenerlo tan granularizado por ahora [: * fix: small grammatical errors and improved readability * fix: small grammatical errors and improved readability * fix: linux command changes * fix: small grammatical errors and improved readability in chapter 3.3 * fix: small grammatical errors and improved readability in chapter 3.3 * fix: small grammatical errors and improved readability in chapter 3.5 * feat: add a initial SEO improvement * feat: add open graph image * fix: improve readability and translations * fix: improve readability and translations * fix: improve readability and translations * fix: improve readability and translations * chore: changed markdown words starting with underscore to asterisk in chapter 4.2 * chore: improved readability and traslations in chapter sections 5.2 and 5.3 * fix: improved legibility and translations in chapter 6 diff --git a/src/ch05-02-example-structs.md b/src/ch05-02-example-structs.md index 8782c9cf..775fac9b 100644 --- a/src/ch05-02-example-structs.md +++ b/src/ch05-02-example-structs.md @@ -35,7 +35,7 @@ El problema con este código es evidente en la firma de `area`: {{#rustdoc_include ../listings/ch05-using-structs-to-structure-related-data/listing-05-08/src/main.rs:here}} ``` -La función `area` está supuesta para calcular el área de un rectángulo, pero O+La función `area` está sup la función que escribimos tiene dos parámetros, y no está claro en ningún lugar de nuestro programa que los parámetros están relacionados. Sería más legible y más manejable agrupar el ancho y el alto juntos. Ya hemos discutido @@ -72,8 +72,7 @@ más fácil introducir errores. ### Refactorizando con Structs: Añadiendo Más Significado Hemos usado structs para agregar significado al etiquetar los datos. Podemos -transformar la tupla que estamos usando en un struct con un nombre para el -todo y nombres para las partes, como se muestra en la lista 5-10. +transformar la tupla que estamos usando en un struct con un nombre para la estructura y nombres para los campos, como se muestra en la lista 5-10. Filename: src/main.rs @@ -226,11 +225,10 @@ siguiente llamada. Aquí está el output de este ejemplo: {{#include ../listings/ch05-using-structs-to-structure-related-data/no-listing-05-dbg-macro/output.txt}} ``` -Podemos ver que la primera parte de la salida proviene de *src/main.rs* línea -10 donde estamos depurando la expresión `30 * scale`, y su valor resultante es -`60` (la formateo `Debug` implementado para enteros es imprimir solo su valor). -La llamada `dbg!` en la línea 14 de *src/main.rs* produce el valor de `&rect1`, -que es la estructura `Rectangle`. Esta salida usa el formateo `Debug` de la +Podemos ver que el primer bit de salida proviene de la linea 10 de *src/main.rs* donde estamos depurando la expresión `30 * scale`, y su valor resultante es +`60` (el formato de `Debug` implementado para enteros es imprimir sólo su valor). +La llamada a `dbg!` en la línea 14 de *src/main.rs* produce el valor de `&rect1`, +que es la estructura de `Rectangle`. Esta salida usa el formato `Debug` de la estructura `Rectangle`. La macro `dbg!` puede ser realmente útil cuando está tratando de averiguar qué está haciendo su código. diff --git a/src/ch05-03-method-syntax.md b/src/ch05-03-method-syntax.md index 58dec6f8..55e5814f 100644 --- a/src/ch05-03-method-syntax.md +++ b/src/ch05-03-method-syntax.md @@ -29,7 +29,7 @@ como se muestra en el Listado 5-13. Para definir la función dentro del contexto de `Rectangle`, iniciamos un bloque `impl` (implementación). Todo lo que esté dentro de este bloque `impl` estará asociado al tipo `Rectangle`. Luego movemos la función `area` dentro de las -llaves del `impl` y cambiamos el primer (y en este caso, único) parámetro para +llaves del bloque `impl` y cambiamos el primer (y en este caso, único) parámetro para ser `self` en la firma y en todas partes dentro del cuerpo. En `main`, donde llamamos a la función `area` y pasamos `rect1` como argumento, podemos en vez de eso usar la *sintaxis de método* para llamar al método `area` en nuestra @@ -42,10 +42,10 @@ En la firma para `area`, usamos `&self` en vez de `rectangle: &Rectangle`. El `impl`. Los métodos deben tener un parámetro llamado `self` de tipo `Self` para su primer parámetro, por lo que Rust nos permite abreviar esto con solo el nombre `self` en el primer parámetro. Ten en cuenta que aún necesitamos usar el -`&` antes de la abreviatura `self` para indicar que este método presta la +`&` antes de la abreviatura `self` para indicar que este método toma prestada la instancia `Self`, al igual que hicimos en `rectangle: &Rectangle`. Los métodos -pueden tomar la propiedad de `self`, prestar `self` inmutablemente, como lo -hemos hecho aquí, o prestar `self` mutably, al igual que pueden hacerlo con +pueden tomar la propiedad de `self`, tomarlo prestado de forma inmutable, como +hemos hecho aquí, o tomarlo prestado de forma mutable, al igual que pueden hacerlo con cualquier otro parámetro. Elegimos `&self` aquí por la misma razón que usamos `&Rectangle` en la versión @@ -223,8 +223,8 @@ este caso es `Rectangle`. Para llamar a esa función asociada, usamos la sintaxis `::` con el nombre de la estructura; `let sq = Rectangle::square(3);` es un ejemplo. Esta función -está en el espacio de nombres de la estructura: la sintaxis `::` se usa tanto -para las funciones asociadas como para los espacios de nombres creados por los +está dentro del namespace de la estructura. La sintaxis `::` se usa tanto +para las funciones asociadas como para los namespaces creados por los módulos. Discutiremos los módulos en el [Capítulo 7][modules]. ### Bloques `impl` múltiples * Update ch06-01-defining-an-enum.md * fix: linting * fix: improved readability and traslations in chapter 7 * fix: add words to dictionary * fix: broken links in ci (#54) fix: broken links in ci * fix: improved readability and translations in chapter 8 * fix: improved readability and translations in chapter 8 (#55) * fix: improved readability and translations in chapter 8 --------- Co-authored-by: CrawKatt Co-authored-by: CrawKatt <108593932+CrawKatt@users.noreply.github.com> Co-authored-by: Phosphorus Co-authored-by: Nimeavles Co-authored-by: carbon based lifeform <1057021+ph4un00b@users.noreply.github.com> Co-authored-by: karimdev <62192487+karimdev96@users.noreply.github.com> --- ci/dictionary.txt | 3 ++ src/appendix-06-translation.md | 18 +++++----- src/ch02-00-guessing-game-tutorial.md | 3 +- src/ch03-03-how-functions-work.md | 29 ++++++++-------- src/ch04-01-what-is-ownership.md | 4 +-- src/ch06-01-defining-an-enum.md | 20 +++++------ src/ch06-03-if-let.md | 2 +- ...referring-to-an-item-in-the-module-tree.md | 4 +-- ...g-paths-into-scope-with-the-use-keyword.md | 2 +- src/ch19-01-unsafe-rust.md | 33 ++++++++++--------- src/title-page.md | 2 +- 11 files changed, 61 insertions(+), 59 deletions(-) diff --git a/ci/dictionary.txt b/ci/dictionary.txt index 5e5109106..3548c073f 100644 --- a/ci/dictionary.txt +++ b/ci/dictionary.txt @@ -1368,6 +1368,8 @@ dereferencing DerefMut DeriveInput Dest +inglés +ningún destructor destructure destructured @@ -2088,3 +2090,4 @@ xcode xpression yyyy ZipImpl +LIFO diff --git a/src/appendix-06-translation.md b/src/appendix-06-translation.md index d26332067..1e174725f 100644 --- a/src/appendix-06-translation.md +++ b/src/appendix-06-translation.md @@ -9,18 +9,18 @@ una nueva traducción. - [Portugués (Brasil)](https://github.com/rust-br/rust-book-pt-br) (BR) - [Portugués](https://github.com/nunojesus/rust-book-pt-pt) (PT) - [Chino simplificado](https://github.com/KaiserY/trpl-zh-cn) -- [Chino tradicional](https://github.com/rust-tw/book-tw) +- [Chino tradicional (Taiwán)](https://github.com/rust-tw/book-tw) - [Ucraniano](https://github.com/pavloslav/rust-book-uk-ua) - [Español](https://github.com/thecodix/book), [alternate](https://github.com/ManRR/rust-book-es) -, [esta versión](https://github.com/RustLangES/rust-book-es) + , [esta versión](https://github.com/RustLangES/rust-book-es) - [Italiano](https://github.com/EmanueleGurini/book_it) -- [Русский](https://github.com/rust-lang-ru/book) -- [한국어](https://github.com/rinthel/rust-lang-book-ko) -- [日本語](https://github.com/rust-lang-ja/book-ja) -- [Français](https://github.com/Jimskapt/rust-book-fr) -- [Polski](https://github.com/paytchoo/book-pl) -- [Cebuano](https://github.com/agentzero1/book) -- [Tagalog](https://github.com/josephace135/book) +- [Ruso](https://github.com/rust-lang-ru/book) +- [Coreano](https://github.com/rinthel/rust-lang-book-ko) +- [Japonés](https://github.com/rust-lang-ja/book-ja) +- [Francés](https://github.com/Jimskapt/rust-book-fr) +- [Polaco](https://github.com/paytchoo/book-pl) +- [Cubano](https://github.com/agentzero1/book) +- [Tagalo](https://github.com/josephace135/book) - [Esperanto](https://github.com/psychoslave/Rust-libro) - [Griego](https://github.com/TChatzigiannakis/rust-book-greek) - [Sueco](https://github.com/sebras/book) diff --git a/src/ch02-00-guessing-game-tutorial.md b/src/ch02-00-guessing-game-tutorial.md index ec7484b5e..2d62749f9 100644 --- a/src/ch02-00-guessing-game-tutorial.md +++ b/src/ch02-00-guessing-game-tutorial.md @@ -240,8 +240,7 @@ ayudar a dividir líneas largas cuando llamas a un método con la sintaxis `.method_name()`. Ahora discutamos lo que hace esta línea. Como se mencionó anteriormente, `read_line` coloca lo que el usuario ingresa en -la cadena que le pasamos, pero también devuelve un valor `Result`. [`Result`][ -result] es una [_enumeración_][enums], a menudo +la cadena que le pasamos, pero también devuelve un valor `Result`. [`Result`][result] es una [_enumeración_][enums], a menudo llamada _enum_, que es un tipo que puede estar en uno de varios estados posibles. Llamamos a cada estado posible a una _variante_. diff --git a/src/ch03-03-how-functions-work.md b/src/ch03-03-how-functions-work.md index b3a585de2..dff957519 100644 --- a/src/ch03-03-how-functions-work.md +++ b/src/ch03-03-how-functions-work.md @@ -5,7 +5,7 @@ funciones más importantes del lenguaje: la función `main`, que es el punto de entrada de muchos programas. También has visto la palabra clave `fn`, que te permite declarar nuevas funciones. -El código en Rust usa *snake case* como estilo convencional para los nombres +El código en Rust usa _snake case_ como estilo convencional para los nombres de funciones y variables, en el que todas las letras son minúsculas y los guiones bajos separan las palabras. Aquí hay un programa que contiene un ejemplo de definición de una función: @@ -23,14 +23,14 @@ termina el cuerpo de la función. Podemos llamar a cualquier función que hayamos definido escribiendo su nombre seguido de un conjunto de paréntesis. Como `another_function` está definida en el programa, se puede llamar desde dentro de la función `main`. Ten en cuenta -que definimos `another_function` *después* de la función `main` en el código +que definimos `another_function` _después_ de la función `main` en el código fuente; también podríamos haberla definido antes. A Rust no le importa dónde definas tus funciones, sólo que estén definidas en algún lugar en un ámbito que pueda ser visto por el invocador. -Empecemos un nuevo proyecto binario llamado *functions* para explorar las +Empecemos un nuevo proyecto binario llamado _functions_ para explorar las funciones más a fondo. Coloca el ejemplo de `another_function` en -*src/main.rs* y ejecútalo. Deberías ver la siguiente salida: +_src/main.rs_ y ejecútalo. Deberías ver la siguiente salida: ```console {{#include ../listings/ch03-common-programming-concepts/no-listing-16-functions/output.txt}} @@ -42,12 +42,12 @@ se imprime su mensaje. ### Parámetros -Podemos definir funciones para que tengan *parámetros*, que son variables +Podemos definir funciones para que tengan _parámetros_, que son variables especiales que forman parte de la firma de una función. Cuando una función tiene parámetros, puedes proporcionarle valores concretos para esos -parámetros. Técnicamente, los valores concretos se llaman *argumentos*, pero coloquialmente, -la gente tiende a usar las palabras *parámetro* y -*argumento* indistintamente para las variables en la definición de una función +parámetros. Técnicamente, los valores concretos se llaman _argumentos_, pero coloquialmente, +la gente tiende a usar las palabras _parámetro_ y +_argumento_ indistintamente para las variables en la definición de una función o los valores concretos que se pasan cuando llamas a una función. En esta versión de `another_function` agregamos un parámetro: @@ -69,7 +69,7 @@ La declaración de `another_function` tiene un parámetro llamado `x`. El tipo d macro `println!` pone `5` donde estaba el par de llaves que contenía `x` en la cadena de formato. -En las firmas de las funciones, *debes* declarar el tipo de cada parámetro. Esta +En las firmas de las funciones, _debes_ declarar el tipo de cada parámetro. Esta es una decisión deliberada en el diseño de Rust: requerir anotaciones de tipo en las definiciones de las funciones significa que el compilador casi nunca necesita que las uses en otro lugar del código para averiguar a qué tipo te refieres. El @@ -90,7 +90,7 @@ llama `unit_label` y es de tipo `char`. Luego, la función imprime texto que contiene tanto el `value` como el `unit_label`. Intentemos ejecutar este código. Reemplaza el programa actual en tu -proyecto *functions* en el archivo *src/main.rs* con el ejemplo anterior y +proyecto _functions_ en el archivo _src/main.rs_ con el ejemplo anterior y ejecútalo usando `cargo run`: ```console @@ -110,9 +110,9 @@ es una distinción importante de entender. Otros lenguajes no tienen las mismas distinciones, así que veamos qué son las sentencias y las expresiones y cómo sus diferencias afectan a los cuerpos de las funciones. -* **Sentencias** son instrucciones que realizan alguna acción y no devuelven un +- **Sentencias** son instrucciones que realizan alguna acción y no devuelven un valor. -* **Expresiones** evalúan a un valor resultante. Veamos algunos ejemplos. +- **Expresiones** evalúan a un valor resultante. Veamos algunos ejemplos. Hemos usado realmente sentencias y expresiones. Crear una variable y asignarle un valor con la palabra clave `let` es una sentencia. En el Listado 3-1, @@ -130,7 +130,7 @@ Las definiciones de las funciones también son sentencias; todo el ejemplo anterior es una sentencia en sí misma. Las sentencias no devuelven valores. Por lo tanto, no puedes asignar una -sentencia `let` a otra variable, como intenta hacer el siguiente código; +sentencia `let` a otra variable, como intenta hacer el siguiente código; obtendrás un error: Nombre de archivo: src/main.rs @@ -187,8 +187,7 @@ exploras los valores de retorno de las funciones y las expresiones a continuaci Las funciones pueden devolver valores al código que las llama. No nombramos los valores de retorno, pero debemos declarar su tipo después de una flecha (`->`). En Rust, el valor de retorno de la función es sinónimo del valor de la última -expresión en el bloque del cuerpo de una función. Puedes devolver un valor antes de que la función -finalize utilizando la palabra clave`return` y especificando un valor, pero la +expresión en el bloque del cuerpo de una función. Puedes devolver un valor antes de que la función finalice utilizando la palabra clave`return` y especificando un valor, pero la mayoría de las funciones devuelven la última expresión implícitamente. Aquí hay un ejemplo de una función que devuelve un valor: diff --git a/src/ch04-01-what-is-ownership.md b/src/ch04-01-what-is-ownership.md index 25e51a52d..4aac503e5 100644 --- a/src/ch04-01-what-is-ownership.md +++ b/src/ch04-01-what-is-ownership.md @@ -30,7 +30,7 @@ datos muy común: las cadenas de caracteres. > La analogía es que el ownership es como la propiedad de un objeto, por ejemplo > si tienes un libro, el libro es tuyo. Si lo prestas a alguien, el libro sigue > siendo tuyo, pero ahora el libro esta en posesión de otra persona. Cuando -> te devuelven el libro, el libro regresa a tu posesión. +> te devuelven el libro, el libro regresa a tu posesión. > ### El Stack y el Heap > @@ -483,7 +483,7 @@ similares a las de la Lista 4-3. Lista 4-4: Transferencia de propiedad de los valores de retorno -La propiedad (ownership) de una variable sigue el mismo patrón cada vez: +La propiedad (ownership) de una variable sigue el mismo patrón cada vez: asignar un valor a otra variable lo mueve. Cuando una variable que incluye datos en el heap sale del contexto de ejecución, el valor se limpiará por `drop` a menos que la propiedad de los datos se haya movido a otra variable. diff --git a/src/ch06-01-defining-an-enum.md b/src/ch06-01-defining-an-enum.md index caca78abe..e4b2050a5 100644 --- a/src/ch06-01-defining-an-enum.md +++ b/src/ch06-01-defining-an-enum.md @@ -9,10 +9,10 @@ posibilidades como un `enum`. Vamos a ver una situación que podemos expresar en código y veremos por qué los enums son útiles y más apropiados que los structs en este caso. Digamos -que tenemos que trabajar con direcciones IP. Actualmente, existen dos estándares +que tenemos que trabajar con direcciones IP. Actualmente, existen dos estándares que se usan para direcciones IP: la versión cuatro y la versión seis. Como estos son los únicos posibles tipos de direcciones IP que nuestro -programa encontrará, podemos *enumerar* todas las variantes posibles, de +programa encontrará, podemos _enumerar_ todas las variantes posibles, de donde viene el nombre de `enum`. Cualquier dirección IP puede ser una dirección de la versión cuatro o la versión @@ -69,7 +69,7 @@ structs como se muestra en el Listing 6-1. {{#rustdoc_include ../listings/ch06-enums-and-pattern-matching/listing-06-01/src/main.rs:here}} ``` -Listing 6-1: Almacenando los datos y la variante +Listing 6-1: Almacenando los datos y la variante `IpAddrKind` de una dirección IP usando un `struct` Aquí, hemos definido un struct `IpAddr` que tiene dos campos: un campo `kind` @@ -152,15 +152,15 @@ variedad de tipos incrustados en sus variantes. {{#rustdoc_include ../listings/ch06-enums-and-pattern-matching/listing-06-02/src/main.rs:here}} ``` -Listing 6-2: Un enum `Message` cuyas variantes almacenan +Listing 6-2: Un enum `Message` cuyas variantes almacenan diferentes cantidades y tipos de valores Este `enum` tiene cuatro variantes con diferentes tipos: -* `Quit` no tiene ningún dato asociado. -* `Move` tiene campos nombrados, como lo haría un struct. -* `Write` incluye un solo `String`. -* `ChangeColor` incluye tres valores `i32`. +- `Quit` no tiene ningún dato asociado. +- `Move` tiene campos nombrados, como lo haría un struct. +- `Write` incluye un solo `String`. +- `ChangeColor` incluye tres valores `i32`. Definiendo un `enum` con variantes como las del Listing 6-2 es similar a definir diferentes tipos de definiciones de struct, excepto que el `enum` no @@ -209,7 +209,7 @@ comunes en otros lenguajes de programación. El diseño del lenguaje de programación a menudo se piensa en términos de qué características se incluyen, pero las características que se excluyen son importantes también. Rust no tiene la característica de null que muchos otros -lenguajes tienen. *Null* es un valor que significa que no hay ningún valor +lenguajes tienen. _Null_ es un valor que significa que no hay ningún valor allí. En los lenguajes con null, las variables siempre pueden estar en uno de dos estados: null o no null. @@ -311,7 +311,7 @@ Eliminar el riesgo de asumir incorrectamente un valor no null ayuda a tener más confianza en su código. Para tener un valor que posiblemente pueda ser null, debe optar explícitamente por hacer que el tipo de ese valor sea `Option`. Entonces, cuando use ese valor, se le requerirá -expresar explícitamente el caso cuando el valor es null. Siempre que un valor tenga un tipo que no sea `Option`, se *puede* +expresar explícitamente el caso cuando el valor es null. Siempre que un valor tenga un tipo que no sea `Option`, se _puede_ asumir con seguridad que el valor no es null. Esta fue una decisión deliberada del diseño de Rust para limitar la omnipresencia de nulls y aumentar la seguridad del código de Rust. diff --git a/src/ch06-03-if-let.md b/src/ch06-03-if-let.md index d0f05e887..870869120 100644 --- a/src/ch06-03-if-let.md +++ b/src/ch06-03-if-let.md @@ -37,7 +37,7 @@ valor no coincide con el patrón. Usar `if let` significa menos escritura, menos indentación y menos código repetitivo. Sin embargo, pierdes la verificación exhaustiva que hace cumplir `match`. Elegir entre `match` e `if let` depende de lo que estés haciendo en tu -situación particular y de si ser más conciso a cambio verificación exhaustiva es un intercambio adecuado. +situación particular y de si ser más conciso a cambio de la verificación exhaustiva es un intercambio adecuado. En otras palabras, puedes pensar en `if let` como una sintaxis dulce para un `match` que ejecuta código cuando el valor coincide con un patrón y luego diff --git a/src/ch07-03-paths-for-referring-to-an-item-in-the-module-tree.md b/src/ch07-03-paths-for-referring-to-an-item-in-the-module-tree.md index c59a781ad..9d3b3c7dc 100644 --- a/src/ch07-03-paths-for-referring-to-an-item-in-the-module-tree.md +++ b/src/ch07-03-paths-for-referring-to-an-item-in-the-module-tree.md @@ -21,7 +21,7 @@ root. Este es el mismo que preguntar: ¿cuál es la ruta de la función módulos y funciones removidas. Mostraremos dos formas de llamar a la función `add_to_waitlist` desde una nueva -función `eat_at_restaurant` definida en el crate de la raiz. Estas rutas son +función `eat_at_restaurant` definida en el crate de la raíz. Estas rutas son correctas, pero hay otro problema que impide que este ejemplo compile tal cual. Explicaremos por qué en un momento. @@ -81,7 +81,7 @@ error que obtenemos se muestra en el listado 7-4. código del listado 7-3 El mensaje de error dice que el módulo `hosting` es privado. En otras palabras, -tenemos las rutas corrects para el módulo `hosting` y la función +tenemos las rutas correctas para el módulo `hosting` y la función `add_to_waitlist`, pero Rust no nos deja usarlos porque no tiene acceso a las secciones privadas. En Rust, todos los items (funciones, métodos, structs, enums, módulos, y constantes) son privados a los módulos padres por defecto. Si diff --git a/src/ch07-04-bringing-paths-into-scope-with-the-use-keyword.md b/src/ch07-04-bringing-paths-into-scope-with-the-use-keyword.md index 790c49a8c..e9c951467 100644 --- a/src/ch07-04-bringing-paths-into-scope-with-the-use-keyword.md +++ b/src/ch07-04-bringing-paths-into-scope-with-the-use-keyword.md @@ -50,7 +50,7 @@ El error del compilador muestra que el acceso directo ya no se aplica dentro del ``` Observe que también hay una advertencia de que él `use` ya no se utiliza en su -ámbito. Para solucionar este problema, mueva tambien él `use` dentro del módulo +ámbito. Para solucionar este problema, mueva también él `use` dentro del módulo `customer`, o haga referencia al acceso directo en el módulo padre con `super::hosting` dentro del módulo hijo `customer`. diff --git a/src/ch19-01-unsafe-rust.md b/src/ch19-01-unsafe-rust.md index c229fcb8d..b83315d94 100644 --- a/src/ch19-01-unsafe-rust.md +++ b/src/ch19-01-unsafe-rust.md @@ -13,7 +13,7 @@ algunos programas no válidos. Aunque el código _podría_ estar bien, si el compilador de Rust no tiene suficiente información para estar seguro, rechazará el código. En estos casos, puede usar código inseguro para decirle al compilador: "Confía en mí, sé lo que estoy haciendo". Sin embargo, debes tener -cuidado, ya que el uso de Unsafe Rust conlleva riesgos: si usas código inseguro +cuidado, ya que el uso de Unsafe Rust conlleva riesgos: si usas código inseguro de manera incorrecta, pueden ocurrir problemas debido a la inseguridad de la memoria, como la desreferenciación de puntero nulo. @@ -39,7 +39,7 @@ Unsafe_. Esos superpoderes incluyen la capacidad de: - Implementar un trait inseguro - Acceder a los campos de `union`s -Es importante entender que `unsafe` no desactiva el borrow checker ni +Es importante entender que `unsafe` no desactiva el borrow checker ni deshabilita ninguna otra de las comprobaciones de seguridad de Rust: si usa una referencia en código inseguro, aún se verificará. La palabra clave `unsafe` solo le da acceso a estas cinco funciones que luego no son verificadas por el @@ -98,14 +98,14 @@ la seguridad garantizada a cambio de un mayor rendimiento o la capacidad de interactuar con otro lenguaje o hardware donde las garantías de Rust no se aplican. -El Listing 19-1 muestra cómo crear un puntero crudo inmutable y mutable a +El Listing 19-1 muestra cómo crear un puntero crudo inmutable y mutable a partir de referencias. ```rust {{#rustdoc_include ../listings/ch19-advanced-features/listing-19-01/src/main.rs:here}} ``` -Listing 19-1: Creando punteros crudos a partir de +Listing 19-1: Creando punteros crudos a partir de referencias Observa que no incluimos la palabra clave `unsafe` en este código. Podemos @@ -158,9 +158,9 @@ potencialmente creando una carrera de datos. ¡Ten cuidado! Con todos estos peligros, ¿por qué usarías punteros crudos? Un caso de uso importante es cuando se interactúa con código C, como verás en la siguiente -sección, [“Llamando a una función o método -inseguro”](#llamando-a-una-funcion-o-metodo-inseguro). Otro caso -es cuando se construyen abstracciones seguras que el borrow checker no entiende. +sección, [“Llamando a una función o método +inseguro”](#llamando-a-una-funcion-o-metodo-inseguro). Otro caso es +cuando se construyen abstracciones seguras que el borrow checker no entiende. Presentaremos funciones inseguras y luego veremos un ejemplo de una abstracción segura que usa código inseguro. @@ -215,7 +215,7 @@ el slice en el índice dado como argumento. El Listado 19-4 muestra cómo usar {{#rustdoc_include ../listings/ch19-advanced-features/listing-19-04/src/main.rs:here}} ``` -Listing 19-4: Usando la función segura +Listing 19-4: Usando la función segura `split_at_mut` No podemos implementar esta función utilizando solo Rust seguro. Un intento @@ -261,7 +261,7 @@ y algunas llamadas a funciones inseguras para hacer que la implementación de {{#rustdoc_include ../listings/ch19-advanced-features/listing-19-06/src/main.rs:here}} ``` -Listing 19-6: Usando código inseguro en la implementación +Listing 19-6: Usando código inseguro en la implementación de la función `split_at_mut` Recordemos la sección [“The Slice Type”][el-tipo-slice] del @@ -305,7 +305,7 @@ ubicación de memoria arbitraria y crea un slice de 10,000 elementos. {{#rustdoc_include ../listings/ch19-advanced-features/listing-19-07/src/main.rs:here}} ``` -Listing 19-7: Creando un slice a partir de una ubicación +Listing 19-7: Creando un slice a partir de una ubicación de memory arbitraria No somos propietarios de la memoria en esta ubicación arbitraria, y no hay @@ -358,7 +358,7 @@ valor absoluto de su argumento. > programación mangla los nombres de manera ligeramente diferente, por lo que > para que una función Rust sea nombrable por otros lenguajes, debemos > deshabilitar el mangling del compilador de Rust. -> +> > En el siguiente ejemplo, hacemos que la función `call_from_c` sea accesible > desde el código C, después de que se compile a una biblioteca compartida y > se vincule desde C: @@ -369,13 +369,14 @@ valor absoluto de su argumento. > println!("Just called a Rust function from C!"); > } > ``` +> > Este uso de `extern` no requiere `unsafe`. ### Acceder o modificar una variable estática mutable En este libro, aún no hemos hablado de _variables globales_, las cuales Rust admite, pero pueden ser problemáticas con las reglas de ownership de Rust. Si -dos hilos acceden a la misma variable global mutable, puede causar una +dos hilos acceden a la misma variable global mutable, puede causar una condición de carrera. En Rust, las variables globales son llamadas variables _static_. El Listado @@ -392,12 +393,12 @@ string slice como valor. inmutable Las static variables son similares a las constantes, que discutimos en la -sección ["Diferencias entre variables y +sección ["Diferencias entre variables y constantes"][differences-between-variables-and-constants] en el Capítulo 3. Los nombres de las variables static están en `SCREAMING_SNAKE_CASE` por convención. Las variables static solo pueden almacenar referencias con el lifetime -`'static`, lo que significa que el compilador de Rust puede calcular el -lifetime y no estamos obligados a anotarlo explícitamente. Acceder a una +`'static`, lo que significa que el compilador de Rust puede calcular el +lifetime y no estamos obligados a anotarlo explícitamente. Acceder a una variable static inmutable es seguro. Una diferencia sutil entre constantes y variables static inmutables es que los @@ -442,7 +443,7 @@ como `unsafe` también, como se muestra en el Listado 19-11. {{#rustdoc_include ../listings/ch19-advanced-features/listing-19-11/src/main.rs}} ``` -Listing 19-11: Definiendo e implementando un trait +Listing 19-11: Definiendo e implementando un trait inseguro Al utilizar `unsafe impl`, estamos prometiendo que mantendremos las invariantes diff --git a/src/title-page.md b/src/title-page.md index 8f5fce3f9..5a2797f82 100644 --- a/src/title-page.md +++ b/src/title-page.md @@ -19,7 +19,7 @@ Press][nsprust]. [install]: ch01-01-installation.html [editions]: appendix-05-editions.html [nsprust]: https://nostarch.com/rust-programming-language-2nd-edition -[translations]: appendix-06-translation.html +[traducciones]: appendix-06-translation.html > **🚨 ¿Quieres una experiencia de aprendizaje más interactiva? Prueba una > versión diferente del Libro de Rust, con: cuestionarios, resaltado, From 15ce131ac759ef62d9d256be4512e7365d2faa5a Mon Sep 17 00:00:00 2001 From: NatProgramer Date: Fri, 1 Mar 2024 19:24:15 -0500 Subject: [PATCH 2/2] Fixing error in traduction --- src/ch06-02-match.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/ch06-02-match.md b/src/ch06-02-match.md index 8ba664c5c..92ae6a7c0 100644 --- a/src/ch06-02-match.md +++ b/src/ch06-02-match.md @@ -239,7 +239,7 @@ especial que coincide con cualquier valor y no se vincula a ese valor. Esto le dice a Rust que no vamos a usar el valor, por lo que Rust no nos advertirá sobre una variable no utilizada. -Vamos a cambiar las reglas del juego. Ahora, si sacas un 3 o un 7, debes tirar +Vamos a cambiar las reglas del juego. Ahora, si sacas un número diferente de un 3 o un 7 debes tirar de nuevo. Ya no necesitamos usar el valor general, por lo que puede cambiar nuestro código para usar `_` en lugar de la variable llamada `other`: