diff --git a/po/es.po b/po/es.po index de81fcd692d2..2e89dee01515 100644 --- a/po/es.po +++ b/po/es.po @@ -1938,7 +1938,6 @@ msgid "" msgstr "" #: src/cargo/running-locally.md:17 -#, fuzzy msgid "" "With this in place, follow these steps to build a Rust binary from one of " "the examples in this training:" @@ -1959,18 +1958,16 @@ msgstr "" "código:" #: src/cargo/running-locally.md:24 -#, fuzzy msgid "" "```shell\n" "$ cargo new exercise\n" " Created binary (application) `exercise` package\n" "```" msgstr "" -"```\n" "```shell\n" "$ cargo new ejercicio\n" " Created binary (application) `ejercicio` package\n" -"```\n" +"" "```" #: src/cargo/running-locally.md:29 @@ -1981,7 +1978,6 @@ msgstr "" "binarios:" #: src/cargo/running-locally.md:31 -#, fuzzy msgid "" "```shell\n" "$ cd exercise\n" @@ -1992,7 +1988,6 @@ msgid "" "Hello, world!\n" "```" msgstr "" -"```\n" "```shell\n" "$ cd ejercicio\n" "$ cargo run\n" @@ -2000,7 +1995,7 @@ msgstr "" " Finished dev [unoptimized + debuginfo] target(s) in 0.75s\n" " Running `target/debug/exercise`\n" "Hola Mundo!\n" -"```\n" +"" "```" #: src/cargo/running-locally.md:40 @@ -2013,7 +2008,6 @@ msgstr "" "como" #: src/cargo/running-locally.md:43 -#, fuzzy msgid "" "```rust\n" "fn main() {\n" @@ -2021,12 +2015,11 @@ msgid "" "}\n" "```" msgstr "" -"```\n" "```rust\n" "fn main() {\n" " println!(\"Modifícame!\");\n" "}\n" -"```\n" +"" "```" #: src/cargo/running-locally.md:49 @@ -2034,7 +2027,6 @@ msgid "Use `cargo run` to build and run your updated binary:" msgstr "Usa `cargo run` para hacer build y ejecutar tu binario actualizado:" #: src/cargo/running-locally.md:51 -#, fuzzy msgid "" "```shell\n" "$ cargo run\n" @@ -2044,14 +2036,14 @@ msgid "" "Edit me!\n" "```" msgstr "" -"```\n" +"" "```shell\n" "$ cargo run\n" " Compiling ejercicio v0.1.0 (/home/mgeisler/tmp/ejercicio)\n" " Finished dev [unoptimized + debuginfo] target(s) in 0.24s\n" " Running `target/debug/ejercicio`\n" "Modifícame!\n" -"```\n" +"" "```" #: src/cargo/running-locally.md:59 @@ -2088,7 +2080,7 @@ msgstr "" #: src/welcome-day-1.md:1 msgid "Welcome to Day 1" -msgstr "Bienvenido al Día 1" +msgstr "Te damos la bienvenida al Día 1" #: src/welcome-day-1.md:3 #, fuzzy @@ -2096,15 +2088,14 @@ msgid "" "This is the first day of Rust Fundamentals. We will cover a lot of ground " "today:" msgstr "" -"Este es el primer día de Comprehensive Rust. Cubririemos un montón de " -"contenido:" +"Este es el primer día de Comprehensive Rust. Hoy trataremos muchos temas:" #: src/welcome-day-1.md:6 msgid "" "Basic Rust syntax: variables, scalar and compound types, enums, structs, " "references, functions, and methods." msgstr "" -"sintaxis básica Rust: variables, scalar y tipos compuestos, enums, structs, " +"Sintaxis básica Rust: variables, scalar y tipos compuestos, enums, structs, " "references, funciones, y métodos." #: src/welcome-day-1.md:9 @@ -2112,6 +2103,8 @@ msgid "" "Control flow constructs: `if`, `if let`, `while`, `while let`, `break`, and " "`continue`." msgstr "" +"Control de flujo: `if`, `if let`, `while`, `while let`, `break`, y " +"`continue`." #: src/welcome-day-1.md:12 msgid "Pattern matching: destructuring enums, structs, and arrays." @@ -2119,7 +2112,7 @@ msgstr "" #: src/welcome-day-1.md:16 msgid "Please remind the students that:" -msgstr "Por favor recuerda a los estudiantes que:" +msgstr "Recuerda a los alumnos lo siguiente:" #: src/welcome-day-1.md:18 msgid "" @@ -2132,11 +2125,10 @@ msgid "" "The class is meant to be interactive and discussions are very much " "encouraged!" msgstr "" -"La clase tiene la intención de ser interactiva y también para abrir espacios " -"de debate." +"El curso está pensado para ser muy interactivo, por lo que te recomendamos " +"que dejes que las preguntas guíen el aprendizaje de Rust." #: src/welcome-day-1.md:20 -#, fuzzy msgid "" "As an instructor, you should try to keep the discussions relevant, i.e., " "keep the discussions related to how Rust does things vs some other " @@ -2171,18 +2163,19 @@ msgid "" "speak about the famous borrow checker. The way Rust handles memory is a " "major feature and we should show students this right away." msgstr "" -"La idea del primer día es mostar _solo lo necesario_ de Rust para permitir " -"hablar sobre el famoso borrow checker. La manera que Rust maneja la memoria " -"es la principal característica y debemos mostrar a los estudiantes la manera " -"correcta." +"La idea del primer día es mostrar _lo suficiente_ de Rustcomo para poder " +"hablar del famoso _borrow checker_. La forma en que Rust gestiona la memoria " +"es una característica importante y debemos mostrarla a los estudiantes desde " +"el principio." #: src/welcome-day-1.md:33 msgid "" "If you're teaching this in a classroom, this is a good place to go over the " "schedule. We suggest splitting the day into two parts (following the slides):" msgstr "" -"Si estás enseñando esto en una clase, es un buen lugar para repasar el " -"horario. Sugerimos dividir el día en dos partes (guiándose por los slides):" +"Si estás impartiendo el curso en un aula, este es un buen lugar para repasar " +"el calendario. Te recomendamos que dividas el día en dos partes (siguiendo " +"las diapositivas):" #: src/welcome-day-1.md:36 msgid "Morning: 9:00 to 12:00," @@ -2190,23 +2183,23 @@ msgstr "Mañana: 9:00 to 12:00," #: src/welcome-day-1.md:37 msgid "Afternoon: 13:00 to 16:00." -msgstr "Tarde: 13:00 to 16:00." +msgstr "Tarde: de 13:00 a 16:00." #: src/welcome-day-1.md:39 msgid "" "You can of course adjust this as necessary. Please make sure to include " "breaks, we recommend a break every hour!" msgstr "" -"Claro que puedes modificarlo si es necesario. Por favor asegúrate de incluir " -"breaks, Recomendamos un break cada hora!" +"Por supuesto, puedes ajustar las horas según lo necesites. No olvides " +"incluir pausas, recomendamos hacer un descanso cada hora." #: src/welcome-day-1/what-is-rust.md:3 msgid "" "Rust is a new programming language which had its [1.0 release in 2015]" "(https://blog.rust-lang.org/2015/05/15/Rust-1.0.html):" msgstr "" -"Rust es un nuevo lenguaje que tiene su [release 1.0 en 2015](https://blog." -"rust-lang.org/2015/05/15/Rust-1.0.html):" +"Rust es un nuevo lenguaje de programación que lanzó su versión [1.0 en el " +"2015](https://blog.rust-lang.org/2015/05/15/Rust-1.0.html):" #: src/welcome-day-1/what-is-rust.md:5 msgid "Rust is a statically compiled language in a similar role as C++" @@ -2221,75 +2214,76 @@ msgid "" "Rust supports many [platforms and architectures](https://doc.rust-lang.org/" "nightly/rustc/platform-support.html):" msgstr "" -"Rust soporta muchas [platformas y arquitecturas](https://doc.rust-lang.org/" -"nightly/rustc/platform-support.html):" +"Rust es compatible con muchas [plataformas y arquitecturas](https://doc.rust-" +"lang.org/nightly/rustc/platform-support.html):" #: src/welcome-day-1/what-is-rust.md:9 msgid "x86, ARM, WebAssembly, ..." -msgstr "x86, ARM, WebAssembly, …" +msgstr "x86, ARM, WebAssembly, ..." #: src/welcome-day-1/what-is-rust.md:10 msgid "Linux, Mac, Windows, ..." -msgstr "Linux, Mac, Windows, …" +msgstr "Linux, Mac, Windows, ..." #: src/welcome-day-1/what-is-rust.md:11 msgid "Rust is used for a wide range of devices:" -msgstr "Rust es usado en muchos dispositivos:" +msgstr "Rust se utiliza en una gran variedad de dispositivos:" #: src/welcome-day-1/what-is-rust.md:12 msgid "firmware and boot loaders," -msgstr "firmware y boot loaders," +msgstr "firmware y cargadores de inicio," #: src/welcome-day-1/what-is-rust.md:13 msgid "smart displays," -msgstr "smart displays," +msgstr "pantallas inteligentes," #: src/welcome-day-1/what-is-rust.md:14 msgid "mobile phones," -msgstr "mobile phones," +msgstr "teléfonos móviles," #: src/welcome-day-1/what-is-rust.md:15 msgid "desktops," -msgstr "desktops," +msgstr "ordenadores," #: src/welcome-day-1/what-is-rust.md:16 msgid "servers." -msgstr "servers." +msgstr "servidores." #: src/welcome-day-1/what-is-rust.md:21 msgid "Rust fits in the same area as C++:" -msgstr "Rust encaja en el mismo área de C++:" +msgstr "Rust satisface las mismas necesidades que C++:" #: src/welcome-day-1/what-is-rust.md:23 msgid "High flexibility." -msgstr "Alta flexibilidad." +msgstr "Gran flexibilidad." #: src/welcome-day-1/what-is-rust.md:24 msgid "High level of control." -msgstr "Alto nivel de control." +msgstr "Nivel alto de control." #: src/welcome-day-1/what-is-rust.md:25 -#, fuzzy msgid "" "Can be scaled down to very constrained devices such as microcontrollers." -msgstr "Puede usarse en dispositivos limitados como teléfonos celulares" +msgstr "" +"Se puede reducir verticalmente a dispositivos muy limitados, como los " +"microcontroladores." #: src/welcome-day-1/what-is-rust.md:26 msgid "Has no runtime or garbage collection." -msgstr "No tiene runtime o garbage colector." +msgstr "No tiene _runtime_ ni _garbage collection_." #: src/welcome-day-1/what-is-rust.md:27 msgid "Focuses on reliability and safety without sacrificing performance." -msgstr "Se enfoca en la confiabilidad y seguridad sin sacrificar performance." +msgstr "" +"Se centra en la fiabilidad y la seguridad sin sacrificar el rendimiento." #: src/hello-world.md:3 msgid "" "Let us jump into the simplest possible Rust program, a classic Hello World " "program:" -msgstr "Vayamos al ejemplo de programa Rust más simple, un clásico Hola Mundo:" +msgstr "Vamos a hablar del programa Rust más simple, un clásico Hola Mundo:" #: src/hello-world.md:6 -#, fuzzy msgid "" "```rust,editable\n" "fn main() {\n" @@ -2297,7 +2291,7 @@ msgid "" "}\n" "```" msgstr "" -"```rust\n" +"```rust,editable\n" "fn main() {\n" " println!(\"Hola 🌍!\");\n" "}\n" @@ -2305,62 +2299,60 @@ msgstr "" #: src/hello-world.md:12 msgid "What you see:" -msgstr "Qué ves:" +msgstr "Lo que ves:" #: src/hello-world.md:14 msgid "Functions are introduced with `fn`." -msgstr "Funciones agregadas con `fn`." +msgstr "Las funciones se introducen con `fn`." #: src/hello-world.md:15 msgid "Blocks are delimited by curly braces like in C and C++." -msgstr "Bloques delimitados por llaves como en C y C++." +msgstr "Los bloques se delimitan con llaves, como en C y C++." #: src/hello-world.md:16 msgid "The `main` function is the entry point of the program." -msgstr "La función `main` que es el punto de entrada al programa." +msgstr "La función `main` es el punto de entrada del programa." #: src/hello-world.md:17 msgid "Rust has hygienic macros, `println!` is an example of this." -msgstr "Rust tiene macros limpios, `println!` es un ejemplo de esto." +msgstr "Rust tiene macros higiénicas, como por ejemplo `println!`." #: src/hello-world.md:18 msgid "Rust strings are UTF-8 encoded and can contain any Unicode character." msgstr "" -"Strings Rust son codificados UTF-8 y pueden contener cualquier carácter " +"Las cadenas de Rust están codificadas en UTF-8 y pueden contener caracteres " "Unicode." #: src/hello-world.md:22 -#, fuzzy msgid "" "This slide tries to make the students comfortable with Rust code. They will " "see a ton of it over the next three days so we start small with something " "familiar." msgstr "" -"Este slide intenta que los estudiantes se sientan cómodos con código Rust. " -"Verán mucho de esto los siguientes cuatro días ase que empezaremos con algo " -"rápido y familiar." +"Con esta diapositiva se intenta que los alumnos se sientan cómodos con el " +"código de Rust. En los próximos tres días lo verán mucho, así que " +"empezaremos con algo que ya conocemos." #: src/hello-world.md:27 -#, fuzzy msgid "" "Rust is very much like other languages in the C/C++/Java tradition. It is " "imperative and it doesn't try to reinvent things unless absolutely necessary." msgstr "" -"Rust es similar a otros lenguajes tradicionales como C/C++/Java. Es " -"imperativo (no funcional) y no trata de reinventar cosas a menos que sea " -"absolutamente necesario." +"Rust es muy similar a otros lenguajes, como C, C++ o Java. Es imperativo y " +"no intenta reinventar las cosas a menos que sea absolutamente necesario." #: src/hello-world.md:31 msgid "Rust is modern with full support for things like Unicode." -msgstr "\\*Rust es moderno con soporte completo para cosas como Unicode." +msgstr "Rust es moderno y totalmente compatible con sistemas como Unicode." #: src/hello-world.md:33 msgid "" "Rust uses macros for situations where you want to have a variable number of " "arguments (no function [overloading](basic-syntax/functions-interlude.md))." msgstr "" -"Rust usa macros para situaciones donde quieres tener una variable number o " -"arguments (no funciones [overloading](basic-syntax/functions-interlude.md))." +"Rust utiliza macros en situaciones en las que se desea tener un número " +"variable de argumentos (sin [sobrecarga](basic-syntax/functions-interlude." +"md) de funciones)." #: src/hello-world.md:36 msgid "" @@ -2369,6 +2361,10 @@ msgid "" "hygienic](https://veykril.github.io/tlborm/decl-macros/minutiae/hygiene." "html)." msgstr "" +"Que las macros sean 'higiénicas' significa que no capturan " +"accidentalmenteidentificadores del ámbito en el que se utilizan. En " +"realidad, las macros de Rust solo son [parcialmente higiénicas](https://" +"veykril.github.io/tlborm/decl-macros/minutiae/hygiene.html)." #: src/hello-world.md:40 msgid "" @@ -2377,10 +2373,15 @@ msgid "" "while it is not a functional language, it includes a range of [functional " "concepts](https://doc.rust-lang.org/book/ch13-00-functional-features.html)." msgstr "" +"Rust es un lenguaje multiparadigma. Por ejemplo, cuenta con [funciones de " +"programación orientadas a objetos](https://doc.rust-lang.org/book/ch17-00-" +"oop.html) y, aunque no es un lenguaje funcional, incluye una serie de " +"[conceptos funcionales](https://doc.rust-lang.org/book/ch13-00-functional-" +"features.html)." #: src/hello-world/small-example.md:3 msgid "Here is a small example program in Rust:" -msgstr "Aquí tenemos un ejemplo de un programa Rust:" +msgstr "A continuación, se muestra un pequeño programa de ejemplo de Rust:" #: src/hello-world/small-example.md:5 msgid "" @@ -2422,9 +2423,9 @@ msgid "" "will always end, but this is not yet proved. Edit the code and play with " "different inputs." msgstr "" -"El código implementa la conjetura de Collatz: que dice que un bucle siempre " -"termina, pero no siempre se prueba. Modifica el código y prueba diferentes " -"inputs." +"El código implementa la conjetura de Collatz: se cree que el bucle terminará " +"siempre, pero aún no se ha demostrado. Edita el código y prueba con " +"diferentes entradas." #: src/hello-world/small-example.md:29 msgid "" @@ -2432,29 +2433,29 @@ msgid "" "trigger type inference. Try with `i8` instead and trigger a runtime integer " "overflow." msgstr "" -"Explica que todas las variables son de tipo estáticas. Prueba removiendo " -"`i32` para que se dispare la inferencia de tipos. Intenta con `i8` y ejecuta " -"un overflow de integer." +"Explica que todas las variables están tipadas estáticamente. Prueba a quitar " +"`i32` para activar la inferencia de tipos. Prueba con `i8` y provoca un " +"desbordamiento de enteros en _runtime_." #: src/hello-world/small-example.md:32 msgid "Change `let mut x` to `let x`, discuss the compiler error." -msgstr "Cambia `let mut x` a `let x`, debatan sobre el error de compilación." +msgstr "Cambia `let mut x` por `let x` y discute el error del compilador." #: src/hello-world/small-example.md:34 msgid "" "Show how `print!` gives a compilation error if the arguments don't match the " "format string." msgstr "" -"Muestra como `print!` da un error de compilación si el argumento no es el " -"mismo del formato del string." +"Muestra cómo `print!` da un error de compilación si los argumentos no " +"coinciden con la cadena de formato." #: src/hello-world/small-example.md:37 msgid "" "Show how you need to use `{}` as a placeholder if you want to print an " "expression which is more complex than just a single variable." msgstr "" -"Muestra como necesitas usar `{}` como placeholder si quieres imprimir una " -"expresión la cual es más compleja que una simple variable." +"Muestra cómo se debe usar `{}` como marcador de posición para poder imprimir " +"una expresión más compleja que una sola variable." #: src/hello-world/small-example.md:40 msgid "" @@ -2462,32 +2463,33 @@ msgid "" "fmt` which has the rules of the formatting mini-language. It's important " "that the students become familiar with searching in the standard library." msgstr "" -"Muestra a los estudiantes la librería estándar, muestra como buscar con " -"`std::fmt` la cual quiene reglas de un mini-lenguaje de formato. Es " -"importante que los estudiantes se familiaricen con las búsquedas en la " -"librería estándar." +"Muestra a los alumnos la biblioteca estándar y cómo buscar `std::fmt`, que " +"tiene las reglas del mini-lenguaje de formato. Es importante que los alumnos " +"se familiaricen con la búsqueda en la biblioteca estándar." #: src/hello-world/small-example.md:44 msgid "" "In a shell `rustup doc std::fmt` will open a browser on the local std::fmt " "documentation" msgstr "" +"En un shell, `rustup doc std::fmt` abrirá un navegador en la documentación " +"local de std::fmt." #: src/why-rust.md:3 msgid "Some unique selling points of Rust:" -msgstr "Algunas características únicas de Rust:" +msgstr "Estas son algunas de las ventajas competitivas de Rust:" #: src/why-rust.md:5 msgid "Compile time memory safety." -msgstr "Tiempo de compilación Garantizado." +msgstr "Seguridad de la memoria en tiempo de compilación." #: src/why-rust.md:6 msgid "Lack of undefined runtime behavior." -msgstr "Garantía en Tiempo de Ejecución." +msgstr "Ausencia de comportamientos indefinidos en _runtime_." #: src/why-rust.md:7 msgid "Modern language features." -msgstr "Características Modernas." +msgstr "Características de lenguajes modernos." #: src/why-rust.md:11 msgid "" @@ -2505,11 +2507,11 @@ msgid "" "have the memory unsafety issues. In addition, you get a modern language with " "constructs like pattern matching and built-in dependency management." msgstr "" -"Experiencia con C o C++: Rust elimina todos los _runtime erorrs_ vía el " -"_borrow checker_. Puedes obtener misma performance de C y C++, pero no " -"tienes errores con manejo de memoria no seguro. Además, tienes un lenguaje " -"moderno con con constructores como patera matching y manejo de dependencias " -"integrado." +"Experiencia con C o C++: Rust elimina una clase completa de _errores de " +"runtime_ mediante el _borrow checker_. Obtienes un rendimiento similar al de " +"C y C++, pero no tienes problemas de seguridad en la memoria. Además, " +"obtienes un lenguaje moderno con elementos como la coincidencia de patrones " +"y la gestión de dependencias integrado." #: src/why-rust.md:19 msgid "" @@ -2518,64 +2520,64 @@ msgid "" "addition you get fast and predictable performance like C and C++ (no garbage " "collector) as well as access to low-level hardware (should you need it)" msgstr "" -"Experiencia con Java, Go, Python, JavaScript…: Tienes el mismo manejo de " -"memoria seguro en esos lenguajes, más una sensación de performance similar a " -"un lenguaje de alto nivel. Además tienes la performance de C y C++ (sin " -"garaje colector) Así como acceso de bajo nivel a hardware (podrías " -"necesitarlo)" +"Experiencia con Java, Go, Python, JavaScript, etc.: Consigues la misma " +"seguridad en la memoria que en éstos lenguajes, además de una sensación " +"similar a la de un lenguaje de alto nivel. También consigues un rendimiento " +"rápido y predecible como en C y C++ (sin recolector de memoria residual), " +"así como acceso a hardware de bajo nivel (si lo necesitas)." #: src/why-rust/compile-time.md:3 msgid "Static memory management at compile time:" -msgstr "Manejo de memoria estático en tiempo de compilación:" +msgstr "Gestión estática de la memoria en tiempo de compilación:" #: src/why-rust/compile-time.md:5 msgid "No uninitialized variables." -msgstr "No hay variables sin inicializar." +msgstr "No hay variables no inicializadas." #: src/why-rust/compile-time.md:6 msgid "No memory leaks (_mostly_, see notes)." -msgstr "No hay memory leaks (_casi siempre_, ver notas)." +msgstr "No hay pérdidas de memoria (_casi siempre_, consulta las notas)." #: src/why-rust/compile-time.md:7 msgid "No double-frees." -msgstr "No hay double-frees." +msgstr "No hay errores double free." #: src/why-rust/compile-time.md:8 msgid "No use-after-free." -msgstr "No use-after-free." +msgstr "No hay errores use-after-free." #: src/why-rust/compile-time.md:9 msgid "No `NULL` pointers." -msgstr "No `NULL` pointers." +msgstr "No hay punteros `NULL`." #: src/why-rust/compile-time.md:10 msgid "No forgotten locked mutexes." -msgstr "No puedes olvidar mutexes bloqueados." +msgstr "No se olvidan las exclusiones mutuas bloqueadas." #: src/why-rust/compile-time.md:11 msgid "No data races between threads." -msgstr "No hay race-conditions por datos entre hilos." +msgstr "No hay condiciones de carrera de datos entre hilos." #: src/why-rust/compile-time.md:12 msgid "No iterator invalidation." -msgstr "No hay iteradores inválidos." +msgstr "No se invalidan los iteradores." #: src/why-rust/compile-time.md:16 msgid "" "It is possible to produce memory leaks in (safe) Rust. Some examples are:" -msgstr "Es posible hacer memory learks en Rust (seguro). Algunos ejemplos son:" +msgstr "" +"Es posible producir pérdidas de memoria en (_safe_) Rust. Estos son algunos " +"ejemplos:" #: src/why-rust/compile-time.md:19 -#, fuzzy msgid "" "You can use [`Box::leak`](https://doc.rust-lang.org/std/boxed/struct.Box." "html#method.leak) to leak a pointer. A use of this could be to get runtime-" "initialized and runtime-sized static variables" msgstr "" "Puedes usar [`Box::leak`](https://doc.rust-lang.org/std/boxed/struct.Box." -"html#method.leak) para hacer un leak de un puntero. El uso de de esto puede " -"ser para obtener variables inicializadas en tiempo de ejecución o " -"modificando su tamaño." +"html#method.leak) para perder un puntero. Esto podría usarse para obtener " +"variables estáticas iniciadas y medidas en _runtime_." #: src/why-rust/compile-time.md:21 msgid "" @@ -2584,15 +2586,15 @@ msgid "" "is never run)." msgstr "" "Puedes usar [`std::mem::forget`](https://doc.rust-lang.org/std/mem/fn.forget." -"html) para hacer que el compilador \"olvide\" un valor (así no se corre el " -"destructor)." +"html) para que el compilador \"olvide\" un valor (lo que significa que el " +"destructor nunca se ejecuta)." #: src/why-rust/compile-time.md:23 msgid "" "You can also accidentally create a [reference cycle](https://doc.rust-lang." "org/book/ch15-06-reference-cycles.html) with `Rc` or `Arc`." msgstr "" -"También accidentalmente puedes crear un [ciclo de referencia](https://doc." +"También puedes crear por accidente una [referencia circular](https://doc." "rust-lang.org/book/ch15-06-reference-cycles.html) con `Rc` o `Arc`." #: src/why-rust/compile-time.md:25 @@ -2600,32 +2602,30 @@ msgid "" "In fact, some will consider infinitely populating a collection a memory leak " "and Rust does not protect from those." msgstr "" -"De hecho, algunos considerarán cargar datos infinitamente una colección un " -"desbordamiento de memoria que Rust no protegerá." +"De hecho, algunos consideran que poblar de forma infinita una colección es " +"una fuga de memoria y Rust no protege de ellas." #: src/why-rust/compile-time.md:28 msgid "" "For the purpose of this course, \"No memory leaks\" should be understood as " "\"Pretty much no _accidental_ memory leaks\"." msgstr "" -"Para el propósito de este curso, \"No memory leak\" debe entenderse como " -"\"Ningún tipo de memory leak _accidental_\"." +"En este curso, \"sin pérdidas de memoria\" debe entenderse como\n" +" \"casi ninguna pérdida de memoria _accidental_\"." #: src/why-rust/runtime.md:3 msgid "No undefined behavior at runtime:" -msgstr "Sin estados indefinidos en runtime:" +msgstr "No hay comportamientos indefinidos en _runtime_:" #: src/why-rust/runtime.md:5 msgid "Array access is bounds checked." -msgstr "Se verifican los límites de acceso a un Array." +msgstr "Se comprueban los límites de acceso a los arrays." #: src/why-rust/runtime.md:6 -#, fuzzy msgid "Integer overflow is defined (panic or wrap-around)." -msgstr "Se define el overflow de Integer." +msgstr "Se define el desbordamiento de enteros (_panic_ o _wrap-around_)." #: src/why-rust/runtime.md:12 -#, fuzzy msgid "" "Integer overflow is defined via the [`overflow-checks`](https://doc.rust-" "lang.org/rustc/codegen-options/index.html#overflow-checks) compile-time " @@ -2634,10 +2634,13 @@ msgid "" "panics in debug mode (`cargo build`) and wrap-around in release mode (`cargo " "build --release`)." msgstr "" -"El overflow en Integer es definido vía un flan en tiempo de compilación. Las " -"opciones son alertas panic (un crash controlado del programa) o una " -"semántica que lo envuelve. Por defecto, obtienes el alerta en modo " -"depuración (`cargo build`) y envolviéndolo en el modo release (`cargo build —" +"El desbordamiento de enteros se define mediante la bandera de tiempo\n" +"de compilación [`overflow-checks`](https://doc.rust-lang.org/rustc/codegen-" +"options/index.html#overflow-checks). Si se habilita, el programa entrará en " +"_panic_ (un fallo controlado del programa). De lo contrario, se obtendrá " +"semántica de _wrap-around_. De forma predeterminada, se obtienen _panics_ en " +"el modo de depuración (`cargo build`) (\"versión de compilación\") y " +"semántica de _wrap-around_ en el modo de liberación (`cargo build --" "release`)." #: src/why-rust/runtime.md:18 @@ -2647,15 +2650,16 @@ msgid "" "call functions such as `slice::get_unchecked` which does not do bounds " "checking." msgstr "" -"El chequeo de límites no puede ser desactivado con el flag de compilador. " -"Tampoco puede deshabilitarse directamente usando `unsafe`. Sin embargo, " -"`unsafe` permite que llames a la función como `slice::get_unchecked` que no " -"brinda chequeos de límites." +"La comprobación de límites no se puede deshabilitar con una bandera de " +"compilador. Tampoco se puede inhabilitar directamente con la palabra clave " +"`unsafe`. Sin embargo, `unsafe` te permite llamar a funciones como `slice::" +"get_unchecked`, que no realiza comprobaciones de límites." #: src/why-rust/modern.md:3 -#, fuzzy msgid "Rust is built with all the experience gained in the last decades." -msgstr "Rust está hecho con toda la experiencia ganada en 40 años." +msgstr "" +"Rust se ha creado a partir de toda la experiencia obtenida en las últimas " +"décadas." #: src/why-rust/modern.md:5 msgid "Language Features" @@ -2663,19 +2667,19 @@ msgstr "Características del Lenguaje" #: src/why-rust/modern.md:7 msgid "Enums and pattern matching." -msgstr "Enums y pattern matching." +msgstr "Enumeraciones (_Enums_) y coincidencia de patrones." #: src/why-rust/modern.md:8 msgid "Generics." -msgstr "Genericos." +msgstr "Genéricos" #: src/why-rust/modern.md:9 msgid "No overhead FFI." -msgstr "No overhead FFI." +msgstr "Sin _overhead_ de FFI." #: src/why-rust/modern.md:10 msgid "Zero-cost abstractions." -msgstr "Abstracciones Zero-cost." +msgstr "Abstracciones sin coste." #: src/why-rust/modern.md:12 msgid "Tooling" @@ -2683,19 +2687,19 @@ msgstr "Herramientas" #: src/why-rust/modern.md:14 msgid "Great compiler errors." -msgstr "Gran compilador de errores." +msgstr "Excelentes errores de compilación." #: src/why-rust/modern.md:15 msgid "Built-in dependency manager." -msgstr "Manejador de Dependencias integrado." +msgstr "Gestor de dependencias integrado." #: src/why-rust/modern.md:16 msgid "Built-in support for testing." -msgstr "Soporte de testing integrado." +msgstr "Asistencia integrada para pruebas." #: src/why-rust/modern.md:17 msgid "Excellent Language Server Protocol support." -msgstr "Excelente soporte al Protocolo de Lenguaje de Servidor." +msgstr "Compatibilidad excelente con el protocolo del servidor de lenguaje." #: src/why-rust/modern.md:23 msgid "" @@ -2704,10 +2708,11 @@ msgid "" "writing a loop using `for` should result in roughly the same low level " "instructions as using the `.iter().fold()` construct." msgstr "" -"Sin costo en abstracciones, similar a C++, quiere decir que no tienes que " -"‘pagar’ por tener un un lenguaje de alto nivel con memoria o CPU. Por " -"ejemplo, escribiendo un loop usando `for` debe resultar a bajo nivel en una " -"instrucción que usa `.iter().fold()`." +"Las abstracciones sin coste, similares a las de C++, significan que no " +"tienes que 'pagar' por construcciones de programación de alto nivel con " +"memoria o CPU. Por ejemplo, escribir un bucle utilizando `for` debería dar " +"como resultado prácticamente las mismas instrucciones de bajo nivel que con " +"la construcción `.iter().fold()`." #: src/why-rust/modern.md:28 msgid "" @@ -2715,9 +2720,9 @@ msgid "" "known as 'sum types', which allow the type system to express things like " "`Option` and `Result`." msgstr "" -"Cabe mencionar que los enums de Rust son ‘Tipos de Datos Algebraicos’, " -"también conocidos como ‘tipos sumados’, los cuales permiten el tipo de " -"sistema para expresas cosas como `Option` y `Result`." +"Merece la pena mencionar que los enums de Rust son tipos de datos " +"algebraicos, también denominados 'tipos suma', que permiten al sistema de " +"tipos expresar cosas como `Option` y `Result`." #: src/why-rust/modern.md:32 msgid "" @@ -2726,10 +2731,11 @@ msgid "" "talkative than other compilers. It will often provide you with _actionable_ " "feedback, ready to copy-paste into your code." msgstr "" -"Recuerda a las personas de leer los errores --- muchos programadores olvidan " -"leer la salida del compilador. El compilador de Rust es significativamente " -"más descriptivo que otros compiladores. Y frecuentemente provee un feedback " -"_para tomar acción_, con código listo para copiar y pegar." +"Recuerda a los alumnos que lean los errores, ya que muchos desarrolladores " +"se han acostumbrado a ignorar los largos resultados del compilador. El " +"compilador de Rust es mucho más comunicativo que otros. A menudo, te " +"proporcionará sugerencias _prácticas_, que puedes copiar y pegar en tu " +"código." #: src/why-rust/modern.md:37 msgid "" @@ -2737,40 +2743,40 @@ msgid "" "and Go. Rust does not come with several things you might consider standard " "and essential:" msgstr "" -"La librería estándar de Rust es pequeña comparada a otros lenguajes como " -"Java, Python y Go. Rust no viene con varias cosas que puedes considerar " -"estándar y esencial:" +"La biblioteca estándar de Rust es pequeña en comparación con la de lenguajes " +"como Java, Python o Go. Rust no incluye elementos que se podrían considerar " +"estándar o esenciales:" #: src/why-rust/modern.md:41 msgid "a random number generator, but see [rand](https://docs.rs/rand/)." msgstr "" -"un generador de número random, pero mira [rand](https://docs.rs/rand/)." +"un generador de números aleatorios, pero consulta [rand](https://docs.rs/" +"rand/)." #: src/why-rust/modern.md:42 msgid "support for SSL or TLS, but see [rusttls](https://docs.rs/rustls/)." -msgstr "soporte para SSL o TLS, pero mira [rusttls](https://docs.rs/rustls/)." +msgstr "" +"compatibilidad con SSL o TLS, pero consulta [rusttls](https://docs.rs/" +"rustls/)." #: src/why-rust/modern.md:43 msgid "support for JSON, but see [serde_json](https://docs.rs/serde_json/)." msgstr "" -"soporte para JSON, pero mira [serde_json](https://docs.rs/serde_json/)." +"Compatibilidad con JSON, pero consulta [serde_json](https://docs.rs/" +"serde_json/)." #: src/why-rust/modern.md:45 -#, fuzzy msgid "" "The reasoning behind this is that functionality in the standard library " "cannot go away, so it has to be very stable. For the examples above, the " "Rust community is still working on finding the best solution --- and perhaps " "there isn't a single \"best solution\" for some of these things." msgstr "" -"```\n" -"Las razones detrás de esta funcionalidad es la librería estándar que no " -"puede\n" -"```\n" -"\n" -"separarse, porque este tiene que ser muy estable. Para ejemplos de arriba, " -"la comunidad Rust sigue trabajando en encontrar la mejor solución --- y por " -"ejemplo no hay una única \"mejor solución\" para alguna de esas cosas." +"La razón es que la funcionalidad de la biblioteca estándar no puede " +"desaparecer, por lo que tiene que ser muy estable. En los ejemplos " +"anteriores, la comunidad de Rust todavía está trabajando para encontrar la " +"mejor solución, y puede que no exista una única \"mejor solución\" para " +"algunas de estas cuestiones." #: src/why-rust/modern.md:50 msgid "" @@ -2778,9 +2784,9 @@ msgid "" "makes it trivial to download and compile third-party crates. A consequence " "of this is that the standard library can be smaller." msgstr "" -"Rust trae incluido un package manager en la forma de Cargo y hace trivial " -"descargar y compilador cosas autocontenidas. Como consecuencia la librería " -"estándar puede ser pequeña." +"Rust incluye un gestor de paquetes integrado con la forma de Cargo, lo que " +"hace que resulte sencillo descargar y compilar crates de terceros. Como " +"consecuencia, la biblioteca estándar puede ser más pequeña." #: src/why-rust/modern.md:54 msgid "" @@ -2788,54 +2794,56 @@ msgid "" "lib.rs/> help with this by letting you compare health metrics for crates to " "find a good and trusted one." msgstr "" -"Descubrir paquetes de terceros puede ser un problema. Sitios como ayudará con esto permitiéndote comparar calidad de paquetes para " -"encontrar uno bueno y seguro." +"Encontrar buenos crates de terceros puede ser un problema. Sitios como " +" te ayudan a comparar métricas de salud de crates para " +"encontrar uno bueno y fiable." #: src/why-rust/modern.md:58 msgid "" "[rust-analyzer](https://rust-analyzer.github.io/) is a well supported LSP " "implementation used in major IDEs and text editors." msgstr "" -"\\[rust-analizer\\] es un LSP bien soportado e implementado usado en los " -"principales IDEs y editores." +"[rust-analyzer](https://rust-analyzer.github.io/) es una implementación de " +"LSP bien respaldada y utilizada en los principales IDE y editores de texto." #: src/basic-syntax.md:3 msgid "Much of the Rust syntax will be familiar to you from C, C++ or Java:" -msgstr "Mucho de la sintaxis de Rust es parecido a C, C++ o Java:" +msgstr "" +"Gran parte de la sintaxis de Rust te resultará familiar de C, C++ o Java:" #: src/basic-syntax.md:5 msgid "Blocks and scopes are delimited by curly braces." -msgstr "Bloques y ámbitos delimitados por llaves." +msgstr "Los bloques y ámbitos están delimitados por llaves." #: src/basic-syntax.md:6 msgid "" "Line comments are started with `//`, block comments are delimited by `/* ... " "*/`." msgstr "" -"Comentarios de línea que comienzan con `//`, bloques de comentarios " -"delimitados por `/*… */`." +"Los comentarios de línea empiezan por `//`, mientras que los comentarios de " +"bloque están delimitados por `/* ... */`." #: src/basic-syntax.md:8 msgid "Keywords like `if` and `while` work the same." -msgstr "Palabras claves como `if` y `while` funcionan igual." +msgstr "Palabras clave como `if` y `while` funcionan igual." #: src/basic-syntax.md:9 msgid "Variable assignment is done with `=`, comparison is done with `==`." -msgstr "Asignación de variables hechas con `=`, comparaciones con `==`." +msgstr "" +"La asignación de variables se realiza con `=` y la comparación con `==`." #: src/basic-syntax/scalar-types.md:3 src/basic-syntax/compound-types.md:3 #: src/exercises/day-3/safe-ffi-wrapper.md:16 msgid "Types" -msgstr "" +msgstr "Tipos" #: src/basic-syntax/scalar-types.md:3 src/basic-syntax/compound-types.md:3 msgid "Literals" -msgstr "" +msgstr "Literales" #: src/basic-syntax/scalar-types.md:5 msgid "Signed integers" -msgstr "" +msgstr "Enteros con signo" #: src/basic-syntax/scalar-types.md:5 msgid "`i8`, `i16`, `i32`, `i64`, `i128`, `isize`" @@ -2847,7 +2855,7 @@ msgstr "" #: src/basic-syntax/scalar-types.md:6 msgid "Unsigned integers" -msgstr "" +msgstr "Enteros sin signo" #: src/basic-syntax/scalar-types.md:6 msgid "`u8`, `u16`, `u32`, `u64`, `u128`, `usize`" @@ -2859,7 +2867,7 @@ msgstr "" #: src/basic-syntax/scalar-types.md:7 msgid "Floating point numbers" -msgstr "" +msgstr "Números de coma flotante" #: src/basic-syntax/scalar-types.md:7 msgid "`f32`, `f64`" @@ -2871,7 +2879,7 @@ msgstr "" #: src/basic-syntax/scalar-types.md:8 msgid "Strings" -msgstr "" +msgstr "Cadenas de texto (_Strings_)" #: src/basic-syntax/scalar-types.md:8 msgid "`&str`" @@ -2883,7 +2891,7 @@ msgstr "" #: src/basic-syntax/scalar-types.md:9 msgid "Unicode scalar values" -msgstr "" +msgstr "Valores escalares Unicode" #: src/basic-syntax/scalar-types.md:9 msgid "`char`" @@ -2895,7 +2903,7 @@ msgstr "" #: src/basic-syntax/scalar-types.md:10 msgid "Booleans" -msgstr "" +msgstr "Booleanos" #: src/basic-syntax/scalar-types.md:10 msgid "`bool`" @@ -2907,7 +2915,7 @@ msgstr "" #: src/basic-syntax/scalar-types.md:12 msgid "The types have widths as follows:" -msgstr "Los tipos tienen una capacidad así:" +msgstr "Los tipos tienen la siguiente anchura:" #: src/basic-syntax/scalar-types.md:14 msgid "`iN`, `uN`, and `fN` are _N_ bits wide," @@ -2915,21 +2923,19 @@ msgstr "`iN`, `uN`, and `fN` son _N_ bits de capacidad," #: src/basic-syntax/scalar-types.md:15 msgid "`isize` and `usize` are the width of a pointer," -msgstr "`isize` y `usize` tienen el tamaño de un puntero," +msgstr "`isize` y `usize` tienen el ancho de un puntero," #: src/basic-syntax/scalar-types.md:16 -#, fuzzy msgid "`char` is 32 bits wide," -msgstr "`char` es 32 bit de grande," +msgstr "`char` tiene un tamaño de 32 bits," #: src/basic-syntax/scalar-types.md:17 -#, fuzzy msgid "`bool` is 8 bits wide." -msgstr "`bool` es 8 bit de grande." +msgstr "`bool` tiene 8 bits de ancho." #: src/basic-syntax/scalar-types.md:21 msgid "There are a few syntaxes which are not shown above:" -msgstr "" +msgstr "Hay algunas sintaxis que no se han mostrado anteriormente:" #: src/basic-syntax/scalar-types.md:23 msgid "" @@ -2937,6 +2943,9 @@ msgid "" "`r\"\\n\" == \"\\\\n\"`. You can embed double-quotes by using an equal " "amount of `#` on either side of the quotes:" msgstr "" +"Las cadenas sin formato te permiten crear un valor `&str` con los escapes " +"inhabilitados: `r\"\\n\" == \"\\\\n\"`. Puedes insertar comillas dobles con " +"la misma cantidad de `#` a cada lado de ellas:" #: src/basic-syntax/scalar-types.md:27 msgid "" @@ -2950,10 +2959,9 @@ msgstr "" #: src/basic-syntax/scalar-types.md:34 msgid "Byte strings allow you to create a `&[u8]` value directly:" -msgstr "" +msgstr "Las cadenas de bytes te permiten crear un valor `&[u8]` directamente:" #: src/basic-syntax/scalar-types.md:36 -#, fuzzy msgid "" "```rust,editable\n" "fn main() {\n" @@ -2962,11 +2970,6 @@ msgid "" "}\n" "```" msgstr "" -"```rust,editable\n" -"fn main() {\n" -" println!(\"Modifícame!\");\n" -"}\n" -"```" #: src/basic-syntax/scalar-types.md:43 msgid "" @@ -2974,10 +2977,13 @@ msgid "" "`1_000` can be written as `1000` (or `10_00`), and `123_i64` can be written " "as `123i64`." msgstr "" +"Todos guiones bajos en los números pueden no utilizarse, ya que solo sirven " +"para facilitar la lectura. Por lo tanto, `1_000` se puede escribir como " +"`1000` (o `10_00`), y `123_i64` se puede escribir como `123i64`." #: src/basic-syntax/compound-types.md:5 msgid "Arrays" -msgstr "" +msgstr "Arrays" #: src/basic-syntax/compound-types.md:5 msgid "`[T; N]`" @@ -2989,7 +2995,7 @@ msgstr "" #: src/basic-syntax/compound-types.md:6 msgid "Tuples" -msgstr "" +msgstr "Tuplas" #: src/basic-syntax/compound-types.md:6 msgid "`()`, `(T,)`, `(T1, T2)`, ..." @@ -3001,7 +3007,7 @@ msgstr "" #: src/basic-syntax/compound-types.md:8 msgid "Array assignment and access:" -msgstr "Asignación y acceso a los Arrays:" +msgstr "Asignación y acceso a arrays:" #: src/basic-syntax/compound-types.md:10 msgid "" @@ -3016,7 +3022,7 @@ msgstr "" #: src/basic-syntax/compound-types.md:18 msgid "Tuple assignment and access:" -msgstr "Asignación y acceso a Tuplas:" +msgstr "Asignación y acceso a tuplas:" #: src/basic-syntax/compound-types.md:20 msgid "" @@ -3031,24 +3037,23 @@ msgstr "" #: src/basic-syntax/compound-types.md:32 msgid "Arrays:" -msgstr "" +msgstr "Arrays:" #: src/basic-syntax/compound-types.md:34 -#, fuzzy msgid "" "A value of the array type `[T; N]` holds `N` (a compile-time constant) " "elements of the same type `T`. Note that the length of the array is _part of " "its type_, which means that `[u8; 3]` and `[u8; 4]` are considered two " "different types." msgstr "" -"Los Arrays tienen elementos del mismo tipo, `T`, y tamaño, `N` que es " -"constante en compilación. Nota que el tamaño del array es _parte del tipo_, " -"lo que quiere decir que `[u8; 3]` y `[u8; 4]`son considerados dos tipos " -"diferentes." +"Un valor del tipo array `[T; N]` contiene `N` (una constante en tiempo de " +"compilación) elementos del mismo tipo `T`. Ten en cuenta que la longitud del " +"array es *parte de su tipo*, lo que significa que `[u8; 3]` y `[u8; 4]` se " +"consideran dos tipos diferentes." #: src/basic-syntax/compound-types.md:38 msgid "We can use literals to assign values to arrays." -msgstr "Podemos usar literales para asignar valores a arreglos." +msgstr "Podemos usar literales para asignar valores a arrays." #: src/basic-syntax/compound-types.md:40 msgid "" @@ -3057,18 +3062,19 @@ msgid "" "the debug output. We could also have used `{a}` and `{a:?}` without " "specifying the value after the format string." msgstr "" -"En la función main, la palabra print pregunta por la implementación de debug " -"con `?` para el formato de parámetro: `{}` que da una salida estándar, `{:?}" -"`. También podemos usar `{a}` y \\`{a:?} sin especificar los valores luego " -"del formato string." +"En la función _main_, la instrucción de impresión solicita la implementación " +"de depuración con el parámetro de formato `?`: `{}` ofrece la salida " +"predeterminada y `{:?}` ofrece la salida de depuración. También se podría " +"haber usado `{a}` y `{a:?}` sin especificar el valor después de la cadena de " +"formato." #: src/basic-syntax/compound-types.md:45 msgid "" "Adding `#`, eg `{a:#?}`, invokes a \"pretty printing\" format, which can be " "easier to read." msgstr "" -"Agregar `#`, por ejemplo `{a:#?}` invoca un formato para imprimir más lindo, " -"más fácil de leer." +"Si se añade `#`, por ejemplo `{a:#?}`, se da formato al texto para facilitar " +"la lectura." #: src/basic-syntax/compound-types.md:47 msgid "Tuples:" @@ -3076,21 +3082,19 @@ msgstr "Tuplas:" #: src/basic-syntax/compound-types.md:49 msgid "Like arrays, tuples have a fixed length." -msgstr "Como los array, las duplas tienen un tamaño fijo." +msgstr "Al igual que los arrays, las tuplas tienen una longitud fija." #: src/basic-syntax/compound-types.md:51 msgid "Tuples group together values of different types into a compound type." -msgstr "" -"Las Tuplas es un grupo de valores con diferentes tipos formando un tipo " -"compuesto." +msgstr "Las tuplas agrupan valores de diferentes tipos en un tipo compuesto." #: src/basic-syntax/compound-types.md:53 msgid "" "Fields of a tuple can be accessed by the period and the index of the value, " "e.g. `t.0`, `t.1`." msgstr "" -"Los campos de una Tuplas se acceden con un punto y el índice del valor, por " -"ejemplo: `t.0`, `t.1`." +"Se puede acceder a los campos de una tupla por el punto y el índice del " +"valor, por ejemplo, `t.0`, `t.1`." #: src/basic-syntax/compound-types.md:55 msgid "" @@ -3099,22 +3103,23 @@ msgid "" "value are expressed as `()`. It is used to indicate, for example, that a " "function or expression has no return value, as we'll see in a future slide. " msgstr "" -"A una Tupla vacía `()` se la conoce también como \"unit type\". Ambos son " -"tipos, y la única manera válida de valor de ese tipo es nombrar ambos tipos " -"y sus valores que son expresados como `()`. Se usa para indicar, por " -"ejemplo, que la función o expresión no devuelve valor, como veremos más " -"adelante." +"La tupla vacía `()` también se conoce como \"tipo unitario\". Es a la vez un " +"tipo y el único valor válido de ese tipo, es decir, tanto el tipo como su " +"valor se expresan como `()`. Se usa para indicar, por ejemplo, que una " +"función o expresión no tiene valor de retorno, como veremos en una " +"diapositiva posterior." #: src/basic-syntax/compound-types.md:59 msgid "" "You can think of it as `void` that can be familiar to you from other " "programming languages." msgstr "" -"Puedes pensar en este como un `void` de otros lenguajes de programación." +"Podríamos pensar en ello como `void`, que quizá resulte familiar de otros " +"lenguajes de programación." #: src/basic-syntax/references.md:3 msgid "Like C++, Rust has references:" -msgstr "Como C++, Rust tiene referencias:" +msgstr "Al igual que C++, Rust tiene referencias:" #: src/basic-syntax/references.md:5 msgid "" @@ -3130,29 +3135,31 @@ msgstr "" #: src/basic-syntax/references.md:14 msgid "Some notes:" -msgstr "Algunos comentarios:" +msgstr "Algunas notas:" #: src/basic-syntax/references.md:16 msgid "" "We must dereference `ref_x` when assigning to it, similar to C and C++ " "pointers." msgstr "" -"Debemos referencias `ref_x` cuando lo asignamos, similar a los punteros de C " -"o C++." +"Debemos desreferenciar `ref_x` al asignarle un valor, de forma similar a los " +"punteros de C y C++." #: src/basic-syntax/references.md:17 msgid "" "Rust will auto-dereference in some cases, in particular when invoking " "methods (try `ref_x.count_ones()`)." msgstr "" -"Rust puede auto-referencias en algunos casos, en particular cuando hace " -"invoca métodos (intenta `ref_x.count_ones()`)." +"Rust realizará una desreferencia automática en algunos casos, en especial al " +"invocar métodos (prueba `ref_x.count_ones()`)." #: src/basic-syntax/references.md:19 msgid "" "References that are declared as `mut` can be bound to different values over " "their lifetime." -msgstr "Las referencias se declaran como `mut` y pueden cambiar de valor." +msgstr "" +"Las referencias que se declaran como `mut` se pueden vincular a distintos " +"valores durante su tiempo de vida." #: src/basic-syntax/references.md:25 msgid "" @@ -3161,14 +3168,14 @@ msgid "" "to different values, while the second represents a reference to a mutable " "value." msgstr "" -"Asegúrate de poder diferenciar entre `let mut ref_x: &i32` y `let ref_x: " -"&mut i32`. El primero representa una referencia mutable que puede cambiar " -"de valor, mientras que el segundo representa una referencia con un valor que " -"puede cambiar." +"Ten en cuenta la diferencia entre `let mut ref_x: &i32` y `let ref_x: &mut " +"i32`. La primera representa una referencia mutable que se puede vincular a " +"distintos valores, mientras que la segunda representa una referencia a un " +"valor mutable." #: src/basic-syntax/references-dangling.md:3 msgid "Rust will statically forbid dangling references:" -msgstr "Rust estáticamente olvidará las referencias colgantes:" +msgstr "Rust prohibirá estáticamente las referencias colgantes:" #: src/basic-syntax/references-dangling.md:5 msgid "" @@ -3187,26 +3194,27 @@ msgstr "" #: src/basic-syntax/references-dangling.md:16 msgid "A reference is said to \"borrow\" the value it refers to." msgstr "" -"Se dice que una referencia \"toma prestado\" el valor al que se refiere." +"Se dice que una referencia \"toma prestado\" el valor al que hace referencia." #: src/basic-syntax/references-dangling.md:17 msgid "" "Rust is tracking the lifetimes of all references to ensure they live long " "enough." msgstr "" -"Rust registra la vida de todas las referencias para asegurar que perduran lo " -"necesario." +"Rust hace un seguimiento del tiempo de vida de todas las referencias para " +"asegurarse de que duran lo suficiente." #: src/basic-syntax/references-dangling.md:19 msgid "We will talk more about borrowing when we get to ownership." -msgstr "Hablaremos más de esto cuando veamos _ownership_." +msgstr "" +"Más adelante hablaremos de los préstamos cuando lleguemos a la parte de " +"propiedad." #: src/basic-syntax/slices.md:3 msgid "A slice gives you a view into a larger collection:" -msgstr "Un _slice_ nos da la visión a una colección:" +msgstr "Un _slice_ ofrece una visión de una colección más amplia:" #: src/basic-syntax/slices.md:5 -#, fuzzy msgid "" "```rust,editable\n" "fn main() {\n" @@ -3219,32 +3227,23 @@ msgid "" "}\n" "```" msgstr "" -"```rust,editable\n" -"fn main() {\n" -" let array = [10, 20, 30];\n" -" print!(\"Iterando sobre el array:\");\n" -" for n in array {\n" -" print!(\" {n}\");\n" -" }\n" -" println!();\n" -"```" #: src/basic-syntax/slices.md:16 msgid "Slices borrow data from the sliced type." -msgstr "Slice toma prestado datos de un tipo _slice_." +msgstr "Los slices toman prestados datos del tipo slice." #: src/basic-syntax/slices.md:17 -#, fuzzy msgid "Question: What happens if you modify `a[3]` right before printing `s`?" -msgstr "Pregunta: ¿Qué pasa si modificas `a[3]`?" +msgstr "" +"Pregunta: ¿Qué ocurre si se modifica `a[3]` justo antes de imprimir `s`?" #: src/basic-syntax/slices.md:21 msgid "" "We create a slice by borrowing `a` and specifying the starting and ending " "indexes in brackets." msgstr "" -"Creamos un slice prestando `a` y especificando el comienzo y final de los " -"índices entre corchetes." +"Creamos un slice tomando prestado `a` y especificando entre paréntesis los " +"índices de inicio y de fin." #: src/basic-syntax/slices.md:23 msgid "" @@ -3252,23 +3251,23 @@ msgid "" "starting index, meaning that `&a[0..a.len()]` and `&a[..a.len()]` are " "identical." msgstr "" -"Si el slice empieza con índice 0, la sintaxis de rango de Rust nos permite " -"borrar el índice del comienzo, generando que `&a[0..a.len()]` y `&a[..a." -"len()]` sean idénticos." +"Si el slice comienza en el índice 0, la sintaxis de intervalo de Rust nos " +"permite eliminar el índice inicial, lo que significa que `&a[0..a.len()]` y " +"`&a[..a.len()]` son idénticos." #: src/basic-syntax/slices.md:25 msgid "" "The same is true for the last index, so `&a[2..a.len()]` and `&a[2..]` are " "identical." msgstr "" -"Lo mismo es para el último índice, así que `&a[2..a.len()]` y `&a[2..]` son " -"lo mismo." +"Lo mismo ocurre con el último índice, por lo que `&a[2..a.len()]` y " +"`&a[2..]` son idénticos." #: src/basic-syntax/slices.md:27 msgid "" "To easily create a slice of the full array, we can therefore use `&a[..]`." msgstr "" -"Para crear fácil un slice de un array completo, podemos usar &a\\[..\\]." +"Para crear fácilmente un slice del array completo, podemos usar `&a[..]`." #: src/basic-syntax/slices.md:29 msgid "" @@ -3276,21 +3275,20 @@ msgid "" "(`&[i32]`) no longer mentions the array length. This allows us to perform " "computation on slices of different sizes." msgstr "" -"`s` es una referencia a un slice de `i32`s. Tener en cuenta que en el tipo " -"de `s` (`&[i32]`) no se menciona el tamaño del array. Esto permite realizar " -"cálculos en silces de diferentes tamaños." +"`s` es una referencia a un slice de `i32`s. Ten en cuenta que el tipo de `s` " +"(`&[i32]`) ya no menciona la longitud del array. Esto nos permite realizar " +"cálculos en slices de diferentes tamaños." #: src/basic-syntax/slices.md:31 msgid "" "Slices always borrow from another object. In this example, `a` has to remain " "'alive' (in scope) for at least as long as our slice. " msgstr "" -"Los silbes siempre se prestan de otro objeto. En este ejemplo, `a` tiene que " -"permanecer \"viva\" (en el scope) durante, al menos, el tiempo que dure " -"nuestro segmento." +"Los slices siempre tienen préstamos de otros objetos. En este ejemplo, `a` " +"tiene que permanecer \"con vida\" (en el ámbito) al menos durante el tiempo " +"que dure el slice. " #: src/basic-syntax/slices.md:33 -#, fuzzy msgid "" "The question about modifying `a[3]` can spark an interesting discussion, but " "the answer is that for memory safety reasons you cannot do it through `a` at " @@ -3299,22 +3297,22 @@ msgid "" "`println`, when the slice is no longer used. More details will be explained " "in the borrow checker section." msgstr "" -"La pregunta sobre modificar `a[3]` puede darnos un punto para una " -"interesante discusión, pero la respuesta es que por razones de memoria " -"segura no puedes hacerlo a través de `a` luego de crear un slice, pero " -"puedes leer los datos para ambos de `a` y `s` de forma segura. Se verá en " -"más detalle en la sección de chequeo de préstamos." +"La cuestión sobre la modificación de `a[3]` puede suscitar un debate " +"interesante, pero la respuesta es que, por razones de seguridad de memoria, " +"no se puede hacer mediante `a` en este punto de la ejecución, pero sí se " +"pueden leer los datos de `a` y `s` de forma segura. Funciona antes de crear " +"el slice y después de `println`, cuando el slice ya no se utiliza. En la " +"sección que trata sobre el _borrow checker_ se dará más información." #: src/basic-syntax/string-slices.md:1 msgid "`String` vs `str`" -msgstr "" +msgstr "`String` o `str`" #: src/basic-syntax/string-slices.md:3 msgid "We can now understand the two string types in Rust:" -msgstr "Ahora podemos entender los dos tipos de string en Rust:" +msgstr "Ahora podemos entender los dos tipos de cadenas de Rust:" #: src/basic-syntax/string-slices.md:5 -#, fuzzy msgid "" "```rust,editable\n" "fn main() {\n" @@ -3331,27 +3329,18 @@ msgid "" "}\n" "```" msgstr "" -"```\n" -"let mut s2: String = String::from(\"Hola \");\n" -"println!(\"s2: {s2}\");\n" -"s2.push_str(s1);\n" -"println!(\"s2: {s2}\");\n" -"\n" -"let s3: &str = &s2[6..];\n" -"println!(\"s3: {s3}\");\n" -"```" #: src/basic-syntax/string-slices.md:20 msgid "Rust terminology:" -msgstr "Terminología Rust:" +msgstr "Terminología de Rust:" #: src/basic-syntax/string-slices.md:22 msgid "`&str` an immutable reference to a string slice." -msgstr "`&str` es una referencia inmutable a un slice string." +msgstr "`&str` es una referencia inmutable a un slice de una cadena." #: src/basic-syntax/string-slices.md:23 msgid "`String` a mutable string buffer." -msgstr "`String` es un buffer de string mutable." +msgstr "`String` es un búfer de cadena mutable." #: src/basic-syntax/string-slices.md:27 msgid "" @@ -3359,17 +3348,18 @@ msgid "" "encoded string data stored in a block of memory. String literals " "(`”Hello”`), are stored in the program’s binary." msgstr "" -"`&str` pone un string slice, que es una referencia inmutable a codificada " -"con datos string UTF-8 guardados en un bloque de memoria. El literal String " -"(`\"Hola\"`), se guarda en el binario del programa." +"`&str` introduce un slice de cadena, que es una referencia inmutable a los " +"datos de cadena codificados en UTF-8 y almacenados en un bloque de memoria. " +"Los literales de cadena (`\"Hello\"`) se almacenan en el binario del " +"programa." #: src/basic-syntax/string-slices.md:30 msgid "" "Rust’s `String` type is a wrapper around a vector of bytes. As with a " "`Vec`, it is owned." msgstr "" -"El tipo `String` de Rust es un wrapper para un vector de bytes. Como con un " -"`Vec`, tiene dueño." +"El tipo `String` de Rust es un envoltorio que rodea a un vector de bytes. " +"Como sucede con `Vec`, tiene propiedad." #: src/basic-syntax/string-slices.md:32 msgid "" @@ -3377,26 +3367,27 @@ msgid "" "literal; `String::new()` creates a new empty string, to which string data " "can be added using the `push()` and `push_str()` methods." msgstr "" -"Como con otros tipos `String::from()` crea un string desde un string " -"literal; `String::new()` crea un string vacío, con datos que pueden usarse " -"con métodos `push()` y `push_str()`." +"Al igual que ocurre con muchos otros tipos, `String::from()` crea una cadena " +"a partir de un literal de cadena. `String::new()` crea una cadena vacía a la " +"que se pueden añadir los datos de la cadena mediante los métodos `push()` y " +"`push_str()`." #: src/basic-syntax/string-slices.md:35 msgid "" "The `format!()` macro is a convenient way to generate an owned string from " "dynamic values. It accepts the same format specification as `println!()`." msgstr "" -"El macro `format!()` es una manera conveniente de generar un string con " -"dueño desde un valor dinámico. Esto acepta los mismos formateo especificados " -"como `println!()`." +"La macro `format!()` es una forma práctica de generar una cadena propia a " +"partir de valores dinámicos. Acepta la misma especificación de formato que " +"`println!()`." #: src/basic-syntax/string-slices.md:38 msgid "" "You can borrow `&str` slices from `String` via `&` and optionally range " "selection." msgstr "" -"Puedes prestar silces `&str` de `String` con `&` y opcionalmente un rango " -"seleccionado." +"Puedes tomar prestados slices `&str` desde `String` mediante `&` y, si " +"quieres, puedes seleccionar intervalos." #: src/basic-syntax/string-slices.md:40 msgid "" @@ -3405,19 +3396,19 @@ msgid "" "equivalent of `std::string` from C++ (main difference: it can only contain " "UTF-8 encoded bytes and will never use a small-string optimization)." msgstr "" -"Para programadores C++: piensa en `&str` como `const char` de C++, pero de " -"una forma que los punteros siempre son string válidos en memoria. El " -"`String` Rust es un equivalente tosco a `std::string` de C++ (La principal " -"diferencia: solo puede contener bytes codificados UTF-8 y nunca usar " -"optimización de small-string)." +"Para los programadores de C++: piensa en `&str` como el `const char*` de C+" +"+, pero el que siempre apunta a una cadena válida en la memoria. `String` de " +"Rust es parecido a `std::string` de C++ (la diferencia principal es que " +"solo puede contener bytes codificados en UTF-8 y nunca utilizará una " +"optimización de cadena pequeña)." #: src/basic-syntax/functions.md:3 msgid "" "A Rust version of the famous [FizzBuzz](https://en.wikipedia.org/wiki/" "Fizz_buzz) interview question:" msgstr "" -"Una versión Rust de la famosa pregunta para entrevistas con [FizzBuzz]" -"(https://en.wikipedia.org/wiki/Fizz_buzz):" +"Una versión de Rust de la famosa pregunta de la entrevista de [FizzBuzz]" +"(https://es.wikipedia.org/wiki/Fizz_buzz):" #: src/basic-syntax/functions.md:5 msgid "" @@ -3455,49 +3446,51 @@ msgid "" "We refer in `main` to a function written below. Neither forward declarations " "nor headers are necessary. " msgstr "" -"En `main` invocamos a una función escrita debajo. No es necesario hacer " -"declaraciones para referenciar." +"En `main` hacemos referencia a una función escrita más abajo. No se " +"necesitan declaraciones de redirección ni encabezados. " #: src/basic-syntax/functions.md:36 msgid "" "Declaration parameters are followed by a type (the reverse of some " "programming languages), then a return type." msgstr "" -"La declaración de parámetros es por tipo (lo contrario a otros lenguajes), y " -"devuelven tipo." +"Los parámetros de declaración van seguidos de un tipo (al contrario que en " +"algunos lenguajes de programación) y, a continuación, de un tipo de " +"resultado devuelto." #: src/basic-syntax/functions.md:37 msgid "" "The last expression in a function body (or any block) becomes the return " "value. Simply omit the `;` at the end of the expression." msgstr "" -"La última expresión en una función (u otro bloque) es el tipo que devuelve. " -"Y omite el `;` al final." +"La última expresión del cuerpo de una función (o de cualquier bloque) se " +"convierte en el valor devuelto. Basta con omitir el carácter `;` al final de " +"la expresión." #: src/basic-syntax/functions.md:38 msgid "" "Some functions have no return value, and return the 'unit type', `()`. The " "compiler will infer this if the `-> ()` return type is omitted." msgstr "" -"Algunas funciones no devuelven valor y devuelven el `tipo unit`, `()`. El " -"compilador va a inferir `->()` si es tipo a devolver es omitido." +"Algunas funciones no devuelven ningún valor, devuelven el \"tipo unitario\", " +"`()`. El compilador deducirá esto si se omite el tipo de retorno `-> ()`." #: src/basic-syntax/functions.md:39 -#, fuzzy msgid "" "The range expression in the `for` loop in `print_fizzbuzz_to()` contains " "`=n`, which causes it to include the upper bound." msgstr "" -"Las expresiones `for` en `fizzbuzz_to()` contienen `=n`, que incluye el " -"límite superior." +"La expresión de intervalo del bucle `for` en `print_fizzbuzz_to()` contiene " +"`=n`, lo que hace que incluya el límite superior." #: src/basic-syntax/rustdoc.md:3 msgid "" "All language items in Rust can be documented using special `///` syntax." msgstr "" +"Todos los elementos del lenguaje de Rust se pueden documentar con la " +"sintaxis especial `///`." #: src/basic-syntax/rustdoc.md:5 -#, fuzzy msgid "" "```rust,editable\n" "/// Determine whether the first argument is divisible by the second " @@ -3513,9 +3506,6 @@ msgid "" "}\n" "```" msgstr "" -"fn is_divisible_by(lhs: u32, rhs: u32) -> bool { if rhs == 0 { return " -"false; // Un caso extremo, vuelve rápido } lhs % rhs == 0 // La última " -"expreción en el bloque es la que devuelve valor }" #: src/basic-syntax/rustdoc.md:17 msgid "" @@ -3524,24 +3514,36 @@ msgid "" "(https://doc.rust-lang.org/rustdoc/what-is-rustdoc.html) tool. It is " "idiomatic to document all public items in an API using this pattern." msgstr "" +"El contenido se trata como Markdown. Todos los crates de la biblioteca de " +"Rust publicados se documentan automáticamente\n" +" en [`docs.rs`](https://docs.rs) mediante la herramienta \n" +"[rustdoc](https://doc.rust-lang.org/rustdoc/what-is-rustdoc.html). Es " +"propio\n" +"documentar todos los elementos públicos de una API usando este patrón." #: src/basic-syntax/rustdoc.md:24 msgid "" "Show students the generated docs for the `rand` crate at [`docs.rs/rand`]" "(https://docs.rs/rand)." msgstr "" +"Muestra a los alumnos los documentos generados para el crate `rand` en " +"[`docs.rs/rand`](https://docs.rs/rand)." #: src/basic-syntax/rustdoc.md:27 msgid "" "This course does not include rustdoc on slides, just to save space, but in " "real code they should be present." msgstr "" +"Este curso no incluye diapositivas sobre rustdoc para ahorrar espacio, pero " +"deben aparecer en el código real." #: src/basic-syntax/rustdoc.md:30 msgid "" "Inner doc comments are discussed later (in the page on modules) and need not " "be addressed here." msgstr "" +"Los comentarios internos de los documentos se tratarán más adelante (en la " +"página de módulos), no es necesario tratarlos aquí." #: src/basic-syntax/rustdoc.md:33 msgid "" @@ -3549,16 +3551,17 @@ msgid "" "`cargo test`. We will discuss these tests in the [Testing section](../" "testing/doc-tests.html)." msgstr "" +"Los comentarios de rustdoc pueden contener fragmentos de código que podemos " +"ejecutar y probar utilizando `cargo test`. Hablaremos de esto en la [sección " +"de pruebas](../testing/doc-tests.html)." #: src/basic-syntax/methods.md:3 -#, fuzzy msgid "" "Methods are functions associated with a type. The `self` argument of a " "method is an instance of the type it is associated with:" msgstr "" -"Rust tiene métodos, pero simplemente son funciones que están asociadas a un " -"tipo particular. El primer argumento de un método es una instancia de un " -"tipo asociado con:" +"Los métodos son funciones asociadas a un tipo. El argumento `self` de un " +"método es una instancia del tipo al que está asociada:" #: src/basic-syntax/methods.md:6 msgid "" @@ -3592,11 +3595,13 @@ msgid "" "We will look much more at methods in today's exercise and in tomorrow's " "class." msgstr "" -"Observaremos mucho más acerca de métodos en la clase de hoy a la tarde." +"Abordaremos en mayor profundidad los métodos en el ejercicio de hoy y en la " +"clase de mañana." #: src/basic-syntax/methods.md:34 msgid "Add a static method called `Rectangle::new` and call this from `main`:" msgstr "" +"Añade un método estático denominado `Rectangle::new` y llámalo desde `main`:" #: src/basic-syntax/methods.md:36 msgid "" @@ -3606,6 +3611,11 @@ msgid "" "}\n" "```" msgstr "" +"```rust,editable,compile_fail\n" +"fn new(width: u32, height: u32) -> Rectangle {\n" +" Rectangle { width, height }\n" +"}\n" +"```" #: src/basic-syntax/methods.md:42 msgid "" @@ -3614,51 +3624,57 @@ msgid "" "constructor, `Rectangle { width, height }`, could be called directly. See " "the [Rustnomicon](https://doc.rust-lang.org/nomicon/constructors.html)." msgstr "" +"Aunque _técnicamente_ Rust no tiene constructores personalizados, los " +"métodos estáticos se utilizan habitualmente para inicializar estructuras, " +"pero no es obligatorio. El constructor real, `Rectangle { width, height }`, " +"podría llamarse directamente. Consulta el [Rustnomicon](https://doc.rust-" +"lang.org/nomicon/constructors.html)." #: src/basic-syntax/methods.md:45 msgid "" "Add a `Rectangle::square(width: u32)` constructor to illustrate that such " "static methods can take arbitrary parameters." msgstr "" +"Añade un constructor `Rectangle::square(width: u32)` para mostrar que esos " +"métodos estáticos puede utilizar parámetros arbitrarios." #: src/basic-syntax/functions-interlude.md:1 msgid "Function Overloading" -msgstr "Sobrecarga de Funciones" +msgstr "Sobrecarga de funciones" #: src/basic-syntax/functions-interlude.md:3 msgid "Overloading is not supported:" -msgstr "La Sobrecarga no es soportada:" +msgstr "No se admite la sobrecarga:" #: src/basic-syntax/functions-interlude.md:5 msgid "Each function has a single implementation:" -msgstr "Cada función tiene una implementación simple:" +msgstr "Cada función tiene una única implementación:" #: src/basic-syntax/functions-interlude.md:6 msgid "Always takes a fixed number of parameters." -msgstr "Siempre tiene un número fijo de parámetros." +msgstr "Siempre se utiliza un número fijo de parámetros." #: src/basic-syntax/functions-interlude.md:7 msgid "Always takes a single set of parameter types." -msgstr "Siempre tiene un único conjunto de tipos de parámetros." +msgstr "Siempre se utiliza un único conjunto de tipos de parámetros." #: src/basic-syntax/functions-interlude.md:8 msgid "Default values are not supported:" -msgstr "Los valores por defecto no están soportados:" +msgstr "No se admiten valores predeterminados:" #: src/basic-syntax/functions-interlude.md:9 msgid "All call sites have the same number of arguments." -msgstr "Todas las llamadas tienen el mismo tipo de parámetro." +msgstr "Todos los sitios de llamada tienen el mismo número de argumentos." #: src/basic-syntax/functions-interlude.md:10 msgid "Macros are sometimes used as an alternative." -msgstr "Algunas veces como alternativa se usan macros." +msgstr "A veces, se utilizan macros como alternativa." #: src/basic-syntax/functions-interlude.md:12 msgid "However, function parameters can be generic:" -msgstr "Sin embargo, los parámetros de funciones pueden ser _generics_:" +msgstr "Sin embargo, los parámetros de función pueden ser genéricos:" #: src/basic-syntax/functions-interlude.md:14 -#, fuzzy msgid "" "```rust,editable\n" "fn pick_one(a: T, b: T) -> T {\n" @@ -3671,8 +3687,6 @@ msgid "" "}\n" "```" msgstr "" -"fn main() { println!(\"arrojar la moneda: {}\", elegir_uno(\"cara\", " -"\"cruz\")); println!(\"premio: {}\", elegir_uno(500, 1000)); }" #: src/basic-syntax/functions-interlude.md:27 msgid "" @@ -3680,16 +3694,17 @@ msgid "" "limited polymorphism on argument types. We will see more details in a later " "section." msgstr "" -"Cuando usas genéricos, la librería estándar `Into` puede dar un limitado " -"polimorfismo con tipo de parámetro. Lo veremos en detalle más adelante." +"Cuando se utilizan genéricos, el `Into` de la biblioteca estándar puede " +"proporcionar una especie de polimorfismo limitado en los tipos de " +"argumentos. Veremos más información al respecto en una sección posterior." #: src/exercises/day-1/morning.md:1 msgid "Day 1: Morning Exercises" -msgstr "Día 1: Ejercicios de la Mañana" +msgstr "Día 1: ejercicios de la mañana" #: src/exercises/day-1/morning.md:3 msgid "In these exercises, we will explore two parts of Rust:" -msgstr "En estos ejercicios, exploraremos dos partes de Rust:" +msgstr "En estos ejercicios, estudiaremos dos partes de Rust:" #: src/exercises/day-1/morning.md:5 msgid "Implicit conversions between types." @@ -3697,11 +3712,11 @@ msgstr "Conversiones implícitas entre tipos." #: src/exercises/day-1/morning.md:7 msgid "Arrays and `for` loops." -msgstr "Arrays y loops `for`." +msgstr "Arrays y bucles `for`." #: src/exercises/day-1/morning.md:11 msgid "A few things to consider while solving the exercises:" -msgstr "Algunas cosas a considerar mientras resolvemos los ejercicios:" +msgstr "Ten en cuenta lo siguiente a la hora de resolver los ejercicios:" #: src/exercises/day-1/morning.md:13 msgid "" @@ -3709,31 +3724,31 @@ msgid "" "completion in your editor. See the page about [Using Cargo](../../cargo.md) " "for details on installing Rust." msgstr "" -"Usar una instalación de Rust local, si es posible. De esta manera puedes " -"tener auto-complete en el editor. Puedes ver la página [Usando Cargo](../../" -"cargo.md) para más detalles en la instalación de Rust." +"Si es posible, utiliza una instalación local de Rust. De esta forma, podrás " +"autocompletar datos en tu editor. Consulta la página sobre \\[cómo usar " +"Cargo\\] para obtener más información sobre cómo instalar Rust." #: src/exercises/day-1/morning.md:17 msgid "Alternatively, use the Rust Playground." -msgstr "Como alternativa, puedes usar el Rust embebido." +msgstr "También puedes usar el playground de Rust." #: src/exercises/day-1/morning.md:19 msgid "" "The code snippets are not editable on purpose: the inline code snippets lose " "their state if you navigate away from the page." msgstr "" -"Los scnippets de código no son editables a propósito: el código de snippets " -"inline pierden su estado si navegas fuera de la página." +"Los fragmentos de código no son editables a propósito: los que están " +"insertados pierden su estado si se sale de la página." #: src/exercises/day-1/morning.md:22 src/exercises/day-2/morning.md:11 #: src/exercises/day-3/morning.md:9 src/exercises/bare-metal/morning.md:7 #: src/exercises/concurrency/morning.md:12 -#, fuzzy msgid "" "After looking at the exercises, you can look at the [solutions](solutions-" "morning.md) provided." msgstr "" -"Luego de ver los ejercicios, puedes ver las \\[soluciones\\] que se brindan." +"Después de realizar los ejercicios, puedes consultar las [soluciones]" +"(solutions-morning.md) correspondientes." #: src/exercises/day-1/implicit-conversions.md:3 msgid "" @@ -3741,9 +3756,10 @@ msgid "" "([unlike C++](https://en.cppreference.com/w/cpp/language/" "implicit_conversion)). You can see this in a program like this:" msgstr "" -"Rust no aplicará automáticamente _conversiones implícitas_ entre tipos " -"([como C++](https://en.cppreference.com/w/cpp/language/" -"implicit_conversion)). Puedes ver esto en programas como este:" +"Rust no aplicará automáticamente _conversiones implícitas_ entre tipos ([a " +"diferencia de C++](https://en.cppreference.com/w/cpp/language/" +"implicit_conversion)). Puedes ver un ejemplo de esto en el siguiente " +"programa:" #: src/exercises/day-1/implicit-conversions.md:6 msgid "" @@ -3770,12 +3786,13 @@ msgid "" "trait has a single `into()` method. Implementing these traits is how a type " "expresses that it can be converted into another type." msgstr "" -"El tipo integer de Rust implementa el [`From`](https://doc.rust-lang.org/" -"std/convert/trait.From.html) y [`Into`](https://doc.rust-lang.org/std/" -"convert/trait.Into.html) y trata de dejarnos para dejarnos convertir entre " -"ellos. El `From` se trata como un simple método `from()` y similar, el " -"`Into` se trata como un simple método `into()`. Implementando esto es " -"como expresamos un tipo que puede convertirse a otro." +"Todos los tipos de enteros de Rust implementan los traits [`From`]" +"(https://doc.rust-lang.org/std/convert/trait.From.html) y [`Into`]" +"(https://doc.rust-lang.org/std/convert/trait.Into.html) para permitirnos " +"realizar conversiones entre ellos. El trait `From` tiene un único método " +"`from()` y, del mismo modo, el trait `Into` tiene un único método " +"`into()`. Un tipo expresa que se puede convertir en otro tipo implementando " +"estos traits." #: src/exercises/day-1/implicit-conversions.md:25 msgid "" @@ -3785,11 +3802,11 @@ msgid "" "i16` implementation automatically create an implementation of `Into for " "i8`." msgstr "" -"La librería estándar tiene una implementación de `From para i16`, que " -"significa Que podemos convertir la variable `x`de tipo `i8` a una `i16` " -"llamando `i16::from(x)`. O, más simple, con `x.into()`, porque la " -"implementación `From para i16` crea automáticamente una implementación " -"de `Into para i8`." +"La biblioteca estándar implementa `From for i16`, lo que significa que " +"podemos convertir una variable `x` del tipo `i8` a `i16` llamando a `i16::" +"from(x)`. O, más sencillo, con `x.into()`, ya que la implementación de " +"`From for i16` crea automáticamente una implementación de `Into for " +"i8`." #: src/exercises/day-1/implicit-conversions.md:30 msgid "" @@ -3797,18 +3814,18 @@ msgid "" "it is sufficient to only implement `From` to get a respective `Into` " "implementation automatically." msgstr "" -"Lo mismo aplica para tu propia implementación `From` para tus propios tipos, " -"así es suficiente solo implementar `From` para obtener la respectiva " -"implementación automática `Into`." +"Lo mismo se aplica a tus implementaciones `From` para tus propios tipos, por " +"lo que basta con implementar `From` para obtener la respectiva " +"implementación `Into` de forma automática." #: src/exercises/day-1/implicit-conversions.md:33 msgid "Execute the above program and look at the compiler error." -msgstr "Ejecuta el programa de arriba y mira el error de compilación." +msgstr "Ejecuta el programa anterior y observa el error del compilador." #: src/exercises/day-1/implicit-conversions.md:35 msgid "Update the code above to use `into()` to do the conversion." msgstr "" -"Actualiza el código de arriba usando `into()` para hacer la conversión." +"Actualiza el código anterior para usar `into()` y realizar la conversión." #: src/exercises/day-1/implicit-conversions.md:37 msgid "" @@ -3818,20 +3835,20 @@ msgid "" "[standard library documentation](https://doc.rust-lang.org/std/convert/trait." "From.html) to see if `From` is implemented for the pairs you check." msgstr "" -"Cambia los tipos de `x` e `y` para otras cosas (como con `f32`, `bool`, " -"`i128`) para ver qué tipos puedes convertir a otros tipos. Intenta " -"convirtiendo tipos pequeños a grandes y a otros tipos disponibles. Revisa la " -"[documentación de la librería estándar](https://doc.rust-lang.org/std/" -"convert/trait.From.html) para ver si `From` se puede implementar." +"Cambia los tipos de `x` e `y` a otros elementos (por ejemplo, `f32`, `bool`, " +"`i128`) para ver qué tipos puedes convertir. Prueba a convertir tipos " +"pequeños en tipos grandes y viceversa. Consulta la [documentación de la " +"biblioteca estándar](https://doc.rust-lang.org/std/convert/trait.From.html) " +"para comprobar si se ha implementado `From` en los pares que elijas." #: src/exercises/day-1/for-loops.md:1 #: src/exercises/day-1/solutions-morning.md:3 msgid "Arrays and `for` Loops" -msgstr "Arrays y Loops `for`" +msgstr "Arrays y bucles`for`" #: src/exercises/day-1/for-loops.md:3 msgid "We saw that an array can be declared like this:" -msgstr "Vimos que un array puede ser declarado así:" +msgstr "Hemos visto que un array se puede declarar de la siguiente manera:" #: src/exercises/day-1/for-loops.md:5 msgid "" @@ -3844,7 +3861,9 @@ msgstr "" msgid "" "You can print such an array by asking for its debug representation with `{:?}" "`:" -msgstr "Puedes imprimirlo para verlo y depurar código con `{:?}`:" +msgstr "" +"Puedes imprimir dicho array solicitando su representación de depuración con " +"`{:?}`:" #: src/exercises/day-1/for-loops.md:11 msgid "" @@ -3860,16 +3879,17 @@ msgstr "" msgid "" "Rust lets you iterate over things like arrays and ranges using the `for` " "keyword:" -msgstr "Rust permite iterar sobre cosas como array y arreglos usando `for`:" +msgstr "" +"Rust te permite iterar sobre elementos como arrays e intervalos usando la " +"palabra clave `for`:" #: src/exercises/day-1/for-loops.md:21 -#, fuzzy msgid "" "```rust,editable\n" "fn main() {\n" " let array = [10, 20, 30];\n" " print!(\"Iterating over array:\");\n" -" for n in &array {\n" +" for n in array {\n" " print!(\" {n}\");\n" " }\n" " println!();\n" @@ -3882,15 +3902,6 @@ msgid "" "}\n" "```" msgstr "" -"```rust,editable\n" -"fn main() {\n" -" let array = [10, 20, 30];\n" -" print!(\"Iterando sobre el array:\");\n" -" for n in array {\n" -" print!(\" {n}\");\n" -" }\n" -" println!();\n" -"```" #: src/exercises/day-1/for-loops.md:38 msgid "" @@ -3898,9 +3909,9 @@ msgid "" "and a function `transpose` which will transpose a matrix (turn rows into " "columns):" msgstr "" -"Usa lo de arriba para escribir la función `linda_impresion` que es una " -"matriz y una función `trasponer` que trasponerá una matriz (cambia filas a " -"columnas):" +"Usa el método anterior para escribir una función `pretty_print` que sirva " +"para dar formato al texto de la matriz y una función `transpose` que " +"transponga una matriz (convertir filas en columnas):" #: src/exercises/day-1/for-loops.md:41 msgid "" @@ -3913,15 +3924,15 @@ msgstr "" #: src/exercises/day-1/for-loops.md:47 msgid "Hard-code both functions to operate on 3 × 3 matrices." -msgstr "Hardcodea ambas funciones para operar con matrices 3 x 3." +msgstr "Codifica ambas funciones para que operen con matrices de 3 × 3." #: src/exercises/day-1/for-loops.md:49 msgid "" "Copy the code below to and implement the " "functions:" msgstr "" -"Copia el código debajo para e implementa las " -"funciones:" +"Copia el siguiente fragmento de código en e " +"implementa las funciones:" #: src/exercises/day-1/for-loops.md:52 msgid "" @@ -3956,7 +3967,7 @@ msgstr "" #: src/exercises/day-1/for-loops.md:80 msgid "Bonus Question" -msgstr "Preguntas Bonus" +msgstr "Pregunta Extra" #: src/exercises/day-1/for-loops.md:82 msgid "" @@ -3964,35 +3975,39 @@ msgid "" "argument and return types? Something like `&[&[i32]]` for a two-dimensional " "slice-of-slices. Why or why not?" msgstr "" -"Puedes usar silbes `&[i32]` en vez de hardcodear matrices 3 x 3 para tus " -"parámetros y devolver tipos? Cosas como `&[&[i32]]` para dos dimensiones, " -"slices de slices. Por qué sí o por qué no?" +"¿Se podrían usar slices `&[i32]` en lugar de matrices de 3 × 3 predefinidas " +"en el código para tus argumentos y tipos de resultados devueltos? Por " +"ejemplo, \\``&\\[&\\[i32\\]\\]\\` para un slice de slices de dos " +"dimensiones. ¿Por qué? ¿Por qué no?" #: src/exercises/day-1/for-loops.md:87 msgid "" "See the [`ndarray` crate](https://docs.rs/ndarray/) for a production quality " "implementation." msgstr "" -"Mira el [ crates `ndarray`](https://docs.rs/ndarray/) para implementación " -"con calidad de producción de calidad." +"Consulta el [crate `ndarray`](https://docs.rs/ndarray/) para obtener una " +"implementación con calidad de producción." #: src/exercises/day-1/for-loops.md:92 msgid "" "The solution and the answer to the bonus section are available in the " "[Solution](solutions-morning.md#arrays-and-for-loops) section." msgstr "" -"Las soluciones y respuestas a la sección bonus están disponibles en la " -"sección [Solución](solutions-morning.md#arrays-and-for-loops)." +"La solución y la respuesta a la pregunta extra están disponibles en la " +"sección [soluciones](solutions-morning.md#arrays-and-for-loops)." #: src/exercises/day-1/for-loops.md:95 msgid "" "The use of the reference `&array` within `for n in &array` is a subtle " "preview of issues of ownership that will come later in the afternoon." msgstr "" +"El uso de la referencia `&array` dentro de `for n in &array` es una vista " +"previa sutil de los problemas de propiedad que se tratarán más tarde por la " +"tarde." #: src/exercises/day-1/for-loops.md:98 msgid "Without the `&`..." -msgstr "" +msgstr "Sin el `&`..." #: src/exercises/day-1/for-loops.md:99 msgid "" @@ -4000,12 +4015,17 @@ msgid "" "[introduced in the 2021 Edition](https://doc.rust-lang.org/edition-guide/" "rust-2021/IntoIterator-for-arrays.html)." msgstr "" +"El bucle habría sido uno que consume el array. Este es un cambio " +"[introducido en la edición de 2021](https://doc.rust-lang.org/edition-guide/" +"rust-2021/IntoIterator-for-arrays.html)." #: src/exercises/day-1/for-loops.md:102 msgid "" "An implicit array copy would have occured. Since `i32` is a copy type, then " "`[i32; 3]` is also a copy type." msgstr "" +"Se habría producido una copia implícita del array. Dado que `i32` es un tipo " +"de copia, `[i32; 3]` también es un tipo de copia." #: src/control-flow.md:3 msgid "" @@ -6778,7 +6798,7 @@ msgid "" "RVO did not happen, Rust will always perform a simple and efficient `memcpy` " "copy." msgstr "" -"```\n" +"" "* El compilador de Rust puede devolver optimización de valor (RVO).\n" "* En C++, la copia elisión tiene que estar definida en la especificación " "porque los contructores pueden tener efectos secundarios. En Rust, esto para " @@ -6977,7 +6997,7 @@ msgstr "" #, fuzzy msgid "Note how this does not compile since `p3` outlives `p2`." msgstr "" -"```\n" +"" "Nota como no compila desde que `p3` persiste `p2`.\n" "```"