From c76f96c435ecc56ad7e31ceea5639db7ccb13dc0 Mon Sep 17 00:00:00 2001 From: Henri Fontana Date: Fri, 8 Sep 2023 08:45:35 -0700 Subject: [PATCH] es: Translations - Day 2 Morning (#1170) Part of #284 --- po/es.po | 869 ++++++++++++++++++++++++++++++------------------------- 1 file changed, 478 insertions(+), 391 deletions(-) diff --git a/po/es.po b/po/es.po index d7c6a2b2..dee76fd1 100644 --- a/po/es.po +++ b/po/es.po @@ -4645,7 +4645,7 @@ msgstr "" #: src/basic-syntax/static-and-const.md:63 msgid "Properties table:" -msgstr "Tabla de propiedades:" +msgstr "Tabla de Propiedades:" #: src/basic-syntax/static-and-const.md:65 msgid "Property" @@ -4709,8 +4709,8 @@ msgid "" "You can shadow variables, both those from outer scopes and variables from " "the same scope:" msgstr "" -"Puedes sombrear variables, tanto las de ámbitos externos " -"como las del propio ámbito:" +"Puedes sombrear variables, tanto las de ámbitos externos como las del propio " +"ámbito:" #: src/basic-syntax/scopes-shadowing.md:6 msgid "" @@ -5923,130 +5923,135 @@ msgstr "" #: src/welcome-day-2.md:1 msgid "Welcome to Day 2" -msgstr "Bienvenido al Día 2" +msgstr "Te damos la bienvenida al día 2" #: src/welcome-day-2.md:3 msgid "Now that we have seen a fair amount of Rust, we will continue with:" msgstr "" +"Ahora que ya sabemos bastante sobre Rust, continuaremos con lo siguiente:" #: src/welcome-day-2.md:5 msgid "" "Memory management: stack vs heap, manual memory management, scope-based " "memory management, and garbage collection." msgstr "" -"Manejo de memoria: stack vs heap, manejo manual de memoria, manejo de " -"memoria scope-based, y garaje collection." +"Gestión de la memoria: _stack_ (pila) vs _heap_ (montículo), gestión manual " +"de la memoria, gestión de la memoria basada en ámbitos y _garbage collector_ " +"(recolección de memoria residual)." #: src/welcome-day-2.md:8 msgid "" "Ownership: move semantics, copying and cloning, borrowing, and lifetimes." msgstr "" -"Ownsership: manejo semántico, copiar y clonar, préstamos, y tiempo de vida." +"_Ownership_ (Propiedad): semántica de movimiento, copiar, clonar, " +"_borrowing_ (préstamos) y _lifetimes_ (tiempos de vida)." #: src/welcome-day-2.md:10 -#, fuzzy msgid "Structs and methods." -msgstr "Strings e Iteradores" +msgstr "Estructuras (_Structs_) y métodos." #: src/welcome-day-2.md:12 msgid "" "The Standard Library: `String`, `Option` and `Result`, `Vec`, `HashMap`, " "`Rc` and `Arc`." msgstr "" +"La Biblioteca Estándar (_Standard Library_): `String`, `Option` y `Result`, " +"`Vec`, `HashMap`, `Rc` y `Arc`." #: src/welcome-day-2.md:15 msgid "Modules: visibility, paths, and filesystem hierarchy." -msgstr "" +msgstr "Módulos: visibilidad, rutas y jerarquía del sistema de archivos." #: src/memory-management.md:3 msgid "Traditionally, languages have fallen into two broad categories:" -msgstr "Por lo general, los lenguajes caen en dos amplias categorías:" +msgstr "Tradicionalmente, los lenguajes se dividen en dos grandes categorías:" #: src/memory-management.md:5 msgid "Full control via manual memory management: C, C++, Pascal, ..." -msgstr "Control total manual del manejo de memoria: C, C++, Pascal, …" +msgstr "" +"Control total a través de la gestión manual de la memoria: C, C++, Pascal, " +"etc." #: src/memory-management.md:6 msgid "" "Full safety via automatic memory management at runtime: Java, Python, Go, " "Haskell, ..." msgstr "" -"Total Seguridad vía manejo automático de memoria en tiempo de ejecución: " -"Java, Python, Go, Haskell, …" +"Seguridad total mediante la gestión automática de la memoria en _runtime_: " +"Java, Python, Go, Haskell, etc." #: src/memory-management.md:8 msgid "Rust offers a new mix:" -msgstr "Rust ofrece un nuevo mix:" +msgstr "Rust ofrece una mezcla de ambas:" #: src/memory-management.md:10 msgid "" "Full control _and_ safety via compile time enforcement of correct memory " "management." msgstr "" -"Control total y seguro vía tiempo de compilación con aseguramiento del " -"correcto manejo de memoria." +"Control _y_ seguridad completa gracias a que el compilador se encarga del " +"correcto manejo de la memoria" #: src/memory-management.md:13 msgid "It does this with an explicit ownership concept." -msgstr "Esto da el concepto concepto explícito de _ownership_." +msgstr "" +"Para ello, se utiliza un concepto de _ownership_ (propiedad) explícito." #: src/memory-management.md:15 msgid "First, let's refresh how memory management works." -msgstr "Empecemos refrescando cómo funciona el manejo de memoria." +msgstr "En primer lugar, veamos cómo funciona la gestión de la memoria." #: src/memory-management/stack-vs-heap.md:1 msgid "The Stack vs The Heap" -msgstr "" +msgstr "_Stack_ (Pila) vs _Heap_ (Montículo)" #: src/memory-management/stack-vs-heap.md:3 msgid "Stack: Continuous area of memory for local variables." -msgstr "Stack: Es un área de memoria continua para variables locales." +msgstr "_Stack_: Zona de memoria continua para las variables locales." #: src/memory-management/stack-vs-heap.md:4 msgid "Values have fixed sizes known at compile time." -msgstr "Los valores son de tamaño fijo conocidos en tiempo de compilación." +msgstr "Los valores tienen tamaños fijos conocidos en tiempo de compilación." #: src/memory-management/stack-vs-heap.md:5 msgid "Extremely fast: just move a stack pointer." -msgstr "Extremadamente rápido: solo mueve un puntero de Stack." +msgstr "Muy rápida: mueve el _stack pointer_." #: src/memory-management/stack-vs-heap.md:6 msgid "Easy to manage: follows function calls." -msgstr "Fácil de manejar: sigue funciones de llamada." +msgstr "Fácil de gestionar: sigue las llamadas de funciones." #: src/memory-management/stack-vs-heap.md:7 msgid "Great memory locality." -msgstr "Mucha memoria local." +msgstr "Excelente localidad de memoria." #: src/memory-management/stack-vs-heap.md:9 msgid "Heap: Storage of values outside of function calls." -msgstr "Heap: Guardar valores fuera de llamadas de funciones." +msgstr "_Heap_: almacenamiento de valores fuera de las llamadas de funciones." #: src/memory-management/stack-vs-heap.md:10 msgid "Values have dynamic sizes determined at runtime." -msgstr "" -"Los valores tienen tamaños dinámicos determinados en tiempo de ejecución." +msgstr "Los valores tienen tamaños dinámicos determinados en _runtime_." #: src/memory-management/stack-vs-heap.md:11 msgid "Slightly slower than the stack: some book-keeping needed." -msgstr "Algo más lento que Stack: son necesarios algunos índices." +msgstr "Ligeramente más lento que el _stack_: requiere cierta trazabilidad." #: src/memory-management/stack-vs-heap.md:12 msgid "No guarantee of memory locality." -msgstr "No se garantiza memoria local." +msgstr "No se puede asegurar la localidad de la memoria." #: src/memory-management/stack.md:1 msgid "Stack and Heap Example" -msgstr "" +msgstr "Ejemplo de _Stack_ y de _Heap_" #: src/memory-management/stack.md:3 -#, fuzzy msgid "" "Creating a `String` puts fixed-sized metadata on the stack and dynamically " "sized data, the actual string, on the heap:" msgstr "" -"Crear un `String` pune datos de tamaño fijo en el stack y con tamaño dado " -"dinámicamente en el heap:" +"Al crear un `String`, los metadatos de tamaño fijo se colocan en la _stack_ " +"y los datos de tamaño dinámico (la cadena real) en el _heap_:" #: src/memory-management/stack.md:6 msgid "" @@ -6079,8 +6084,9 @@ msgid "" "Mention that a `String` is backed by a `Vec`, so it has a capacity and " "length and can grow if mutable via reallocation on the heap." msgstr "" -"Ve que un `String` es respaldado por un `Vec`, así tiene capacidad y tamaño " -"que puede incrementarse si la mutable por relocalicación en el _heap_." +"Menciona que un `String` está respaldado por un `Vec`, por lo que tiene " +"capacidad y longitud y, si es mutable, puede crecer mediante reasignación en " +"el _heap_." #: src/memory-management/stack.md:30 msgid "" @@ -6089,22 +6095,21 @@ msgid "" "struct.System.html) and custom allocators can be implemented using the " "[Allocator API](https://doc.rust-lang.org/std/alloc/index.html)" msgstr "" -"Si los estudiantes preguntan sobre esto, puedes mencionar que por debajo la " -"memoria es colocada por _heap_ usando el [Sistema de Colocación](https://doc." -"rust-lang.org/std/alloc/struct.System.html) y la colocación personalizada " -"puede ser implementada usando la [Allocator API](https://doc.rust-lang.org/" -"std/alloc/index.html)" +"Si los alumnos lo preguntan, puedes mencionar que la memoria subyacente " +"recibe una asignación de _heap_ mediante el [Asignador del Sistema](https://" +"doc.rust-lang.org/std/alloc/struct.System.html) y que se pueden implementar " +"asignadores personalizados mediante el [_Allocator API_](https://doc.rust-" +"lang.org/std/alloc/index.html)." #: src/memory-management/stack.md:32 msgid "" "We can inspect the memory layout with `unsafe` code. However, you should " "point out that this is rightfully unsafe!" msgstr "" -"Podemos inspeccionar el layout de memoria con la cláusula `unsafe`. Sin " -"embargo, debes aclarar que esto no es seguro!" +"Podemos inspeccionar la disposición de la memoria con código `unsafe`. Sin " +"embargo, debes señalar que esto no es seguro." #: src/memory-management/stack.md:34 -#, fuzzy msgid "" "```rust,editable\n" "fn main() {\n" @@ -6123,33 +6128,18 @@ msgid "" "}\n" "```" msgstr "" -"```rust,editable\n" -"fn main() {\n" -" let mut s1 = String::from(\"Hello\");\n" -" s1.push(' ');\n" -" s1.push_str(\"world\");\n" -" // NO HAGAS ESTO EN CASA! Sólo con propósitos educativos.\n" -" // El String no provee garantías en su layout, esto puede derivar en\n" -" // comportamientos no deseados.\n" -" unsafe {\n" -" let (capacity, ptr, len): (usize, usize, usize) = std::mem::" -"transmute(s1);\n" -" println!(\"ptr = {ptr:#x}, len = {len}, capacity = {capacity}\");\n" -" }\n" -"}\n" -"```" #: src/memory-management/manual.md:3 msgid "You allocate and deallocate heap memory yourself." -msgstr "Tú mismo puedes asignar o desasignar pilas (_heap_) de memoria." +msgstr "Eres tú quien asigna y desasigna la memoria del _heap_." #: src/memory-management/manual.md:5 msgid "" "If not done with care, this can lead to crashes, bugs, security " "vulnerabilities, and memory leaks." msgstr "" -"Si no lo haces con cuidado, puede derivar en crasheo, errores, " -"vulnerabilidad de seguridad, memory leaks." +"Si no lo haces con cuidado, podrían producirse fallos, errores, " +"vulnerabilidades de seguridad y pérdidas de memoria." #: src/memory-management/manual.md:7 msgid "C Example" @@ -6157,7 +6147,7 @@ msgstr "Ejemplo en C" #: src/memory-management/manual.md:9 msgid "You must call `free` on every pointer you allocate with `malloc`:" -msgstr "Debes llamar a `free` en cada puntero que pongas usando `malloc`:" +msgstr "Debes llamar a `free` en cada puntero que asignes con `malloc`:" #: src/memory-management/manual.md:11 msgid "" @@ -6173,21 +6163,23 @@ msgid "" msgstr "" #: src/memory-management/manual.md:21 -#, fuzzy msgid "" "Memory is leaked if the function returns early between `malloc` and `free`: " "the pointer is lost and we cannot deallocate the memory. Worse, freeing the " "pointer twice, or accessing a freed pointer can lead to exploitable security " "vulnerabilities." msgstr "" -"La memoria es _leaked_ si la función vuelve rápido entre `malloc` y `free`: " -"se pierde el puntero y no podemos desasignar la memoria." +"La memoria se pierde si la función devuelve un resultado antes de tiempo " +"entre `malloc` y `free`: el puntero se pierde y no podemos anular la " +"asignación de la memoria. Peor aún, si se libera el puntero dos veces o si " +"se accede a uno liberado, pueden producirse vulnerabilidades de seguridad de " +"las que otros podrían aprovecharse." #: src/memory-management/scope-based.md:3 msgid "" "Constructors and destructors let you hook into the lifetime of an object." msgstr "" -"Los constructores y destructores te permiten mantener en _lifetime_ un " +"Los constructores y destructores permiten acceder al tiempo de vida de un " "objeto." #: src/memory-management/scope-based.md:5 @@ -6196,21 +6188,21 @@ msgid "" "destroyed. The compiler guarantees that this happens, even if an exception " "is raised." msgstr "" -"Envolviendo un puntero con un objeto, puedes liberar memoria cuando el " -"objeto es destruido. El compilador garantiza que eso pase, incluso si se " -"alcanzó una excepción." +"Al envolver un puntero en un objeto, puedes liberar memoria cuando el objeto " +"se destruya. El compilador asegura que esto ocurra, aunque se genere una " +"excepción." #: src/memory-management/scope-based.md:9 msgid "" "This is often called _resource acquisition is initialization_ (RAII) and " "gives you smart pointers." msgstr "" -"A menudo se dice que la adquisición de recursos es inicializada ó, _resource " -"acquisition is initialization_ (RAII), y brinda punteros inteligentes." +"A menudo, significa que la _adquisición de recursos es la inicialización_ " +"(RAII) y te proporciona punteros inteligentes." #: src/memory-management/scope-based.md:12 msgid "C++ Example" -msgstr "Ejemplo C++" +msgstr "Ejemplo en C++" #: src/memory-management/scope-based.md:14 msgid "" @@ -6231,23 +6223,23 @@ msgid "" "The `std::unique_ptr` object is allocated on the stack, and points to memory " "allocated on the heap." msgstr "" -"El objeto `std::unique_ptr` se ubica en el stack, y los punteros a memoria " -"apuntando a el heap." +"El objeto `std::unique_ptr` se reserva en el _stack_ y apunta a la memoria " +"asignada en el _heap_." #: src/memory-management/scope-based.md:22 msgid "At the end of `say_hello`, the `std::unique_ptr` destructor will run." -msgstr "Al final de `say_hello`, correrá el destructor `std::unique_ptr`." +msgstr "Al final de `say_hello`, se ejecuta el destructor `std::unique_ptr`." #: src/memory-management/scope-based.md:23 msgid "The destructor frees the `Person` object it points to." -msgstr "El destructor libera el objeto `Person`que apunta a él." +msgstr "El destructor libera el objeto `Person` al que apunta." #: src/memory-management/scope-based.md:25 msgid "" "Special move constructors are used when passing ownership to a function:" msgstr "" -"Un movimiento especial de constructor es usado cuando se pasa la propiedad a " -"una función:" +"Los constructores de movimiento especiales se utilizan cuando se pasa el " +"_ownership_ a una función:" #: src/memory-management/scope-based.md:27 msgid "" @@ -6259,33 +6251,38 @@ msgstr "" #: src/memory-management/garbage-collection.md:1 msgid "Automatic Memory Management" -msgstr "Manejo Automático de Memoria" +msgstr "Gestión Automática de la Memoria" #: src/memory-management/garbage-collection.md:3 msgid "" "An alternative to manual and scope-based memory management is automatic " "memory management:" -msgstr "Una alternativa al manejo manual es el automático:" +msgstr "" +"Una alternativa a la gestión manual de la memoria basada en el ámbito es la " +"gestión automática de la memoria:" #: src/memory-management/garbage-collection.md:6 msgid "The programmer never allocates or deallocates memory explicitly." -msgstr "El programador nunca asigna o desasgan memoria explícitamente." +msgstr "" +"El programador nunca asigna ni desasigna la memoria de forma explícita." #: src/memory-management/garbage-collection.md:7 msgid "" "A garbage collector finds unused memory and deallocates it for the " "programmer." msgstr "" -"Un garbage collector encuentra memoria sin usar y la libera para el " -"programador." +"Un _garbage collector_ (recolector de memoria residual) encuentra la que no " +"se utiliza y la desasigna para el programador." #: src/memory-management/garbage-collection.md:9 msgid "Java Example" -msgstr "Ejemplo Java" +msgstr "Ejemplo en Java" #: src/memory-management/garbage-collection.md:11 msgid "The `person` object is not deallocated after `sayHello` returns:" -msgstr "El objeto `persona` no se libera luego que vuelva `sayHello`:" +msgstr "" +"El objeto `person` no se libera después de que `sayHello` devuelva el " +"siguiente resultado:" #: src/memory-management/garbage-collection.md:13 msgid "" @@ -6303,15 +6300,15 @@ msgstr "" #: src/memory-management/rust.md:1 msgid "Memory Management in Rust" -msgstr "Manejo de la Memoria en Rust" +msgstr "Gestión de la Memoria en Rust" #: src/memory-management/rust.md:3 msgid "Memory management in Rust is a mix:" -msgstr "El manejo de memoria en Rust es una mezcla:" +msgstr "La gestión de la memoria en Rust es una mezcla:" #: src/memory-management/rust.md:5 msgid "Safe and correct like Java, but without a garbage collector." -msgstr "Segura y correcta como en Java, pero sin un Garbage Collector." +msgstr "Segura y correcta como Java, pero sin _garbage collector_." #: src/memory-management/rust.md:6 msgid "" @@ -6319,27 +6316,27 @@ msgid "" "can be a single unique pointer, reference counted, or atomically reference " "counted." msgstr "" -"Dependiendo qué abstracción (o combinación de abstracción) eliges, puedes " -"ser un puntero simple, referencia contada, o atómicamente referencia contada." +"Dependiendo de la abstracción (o combinación de abstracciones) que elijas, " +"puede ser un solo puntero único, de referencia contada, o de referencia " +"atómica contada." #: src/memory-management/rust.md:7 msgid "Scope-based like C++, but the compiler enforces full adherence." msgstr "" -"El ámbito basado en C++, pero que el compilador fuerza a incluirlo por " -"completo." +"Está basada en el ámbito, como C++, pero el compilador cumple con todas las " +"normas." #: src/memory-management/rust.md:8 msgid "" "A Rust user can choose the right abstraction for the situation, some even " "have no cost at runtime like C." msgstr "" -"Un usuario de Rust puede elegir la abstracción correcta para la situación, " -"algunos incluso no tienen costo en runtime como C++." +"Un usuario de Rust puede elegir la abstracción adecuada para cada situación, " +"algunas ni siquiera tienen coste en _runtime_, como C." #: src/memory-management/rust.md:10 -#, fuzzy msgid "Rust achieves this by modeling _ownership_ explicitly." -msgstr "Esto se logra modelando el _ownership_ explícitamente." +msgstr "Rust lo consigue modelando explícitamente el _ownership_." #: src/memory-management/rust.md:14 msgid "" @@ -6351,129 +6348,129 @@ msgid "" "ownership and memory allocation via various means, and prevent the potential " "errors in C." msgstr "" -"Si en este punto preguntas, puedes decir que Rust usualmente es tomado por " -"tipos wrapper RAII como [Box](https://doc.rust-lang.org/std/boxed/struct.Box." -"html), [Vec](https://doc.rust-lang.org/std/vec/struct.Vec.html), [Rc]" -"(https://doc.rust-lang.org/std/rc/struct.Rc.html), or [Arc](https://doc.rust-" -"lang.org/std/sync/struct.Arc.html). Esto encapsula el _ownsership_ y la " -"ubicación de memoria con varios significados, y previene potenciales errores " -"en C." +"Si en este momento te preguntan cómo, puedes mencionar que en Rust se suele " +"gestionar con tipos de envoltorios RAII, como [Box](https://doc.rust-lang." +"org/std/boxed/struct.Box.html), [Vec]https://doc.rust-lang.org/std/vec/" +"struct.Vec.html), [Rc](https://doc.rust-lang.org/std/rc/struct.Rc.html) o " +"[Arc](https://doc.rust-lang.org/std/sync/struct.Arc.html). Estos encapsulan " +"el _ownership_ y la asignación de memoria a través de diversos medios, " +"evitando así los posibles errores en C." #: src/memory-management/rust.md:16 msgid "" "You may be asked about destructors here, the [Drop](https://doc.rust-lang." "org/std/ops/trait.Drop.html) trait is the Rust equivalent." msgstr "" -"Puedes preguntar acerca de destructores, el [Drop](https://doc.rust-lang.org/" -"std/ops/trait.Drop.html) es el equivalente de Rust." +"Puede que aquí te pregunten por los destructores, así que debes saber que el " +"trait [Drop](https://doc.rust-lang.org/std/ops/trait.Drop.html) es el " +"equivalente en Rust." #: src/memory-management/comparison.md:3 msgid "Here is a rough comparison of the memory management techniques." -msgstr "Aquí una rústica comparación de técnicas de manejo de memoria." +msgstr "" +"A continuación, se muestra una comparación aproximada de las técnicas de " +"gestión de la memoria." #: src/memory-management/comparison.md:5 msgid "Pros of Different Memory Management Techniques" -msgstr "Ventajas de las Diferentes Técnicas de Manejo de Memoria" +msgstr "Ventajas de las diferentes técnicas de gestión de la memoria" #: src/memory-management/comparison.md:7 src/memory-management/comparison.md:22 msgid "Manual like C:" -msgstr "Manual como en C:" +msgstr "Manual, como en C:" #: src/memory-management/comparison.md:8 src/memory-management/comparison.md:14 #: src/memory-management/comparison.md:17 msgid "No runtime overhead." -msgstr "No runtime overhead." +msgstr "Sin sobrecarga en _runtime_." #: src/memory-management/comparison.md:9 src/memory-management/comparison.md:26 msgid "Automatic like Java:" -msgstr "Automático como en Java:" +msgstr "Automática, como en Java:" #: src/memory-management/comparison.md:10 msgid "Fully automatic." -msgstr "Totalmente automático." +msgstr "Totalmente automática." #: src/memory-management/comparison.md:11 #: src/memory-management/comparison.md:18 msgid "Safe and correct." -msgstr "Correcto y Seguro." +msgstr "Segura y correcta." #: src/memory-management/comparison.md:12 #: src/memory-management/comparison.md:29 msgid "Scope-based like C++:" -msgstr "Scope-based como en C++:" +msgstr "Basada en el ámbito, como en C++:" #: src/memory-management/comparison.md:13 msgid "Partially automatic." -msgstr "Parcialmente automático." +msgstr "Parcialmente automática." #: src/memory-management/comparison.md:15 msgid "Compiler-enforced scope-based like Rust:" -msgstr "Compiler-enforced y scope-based como en Rust:" +msgstr "Basada en el ámbito e implementada por el compilador, como en Rust:" #: src/memory-management/comparison.md:16 msgid "Enforced by compiler." -msgstr "Asgurado por el compilador." +msgstr "Implementada por el compilador." #: src/memory-management/comparison.md:20 msgid "Cons of Different Memory Management Techniques" -msgstr "Contras de las Diferentes Técnicas de Manejo de Memoria" +msgstr "Inconvenientes de las diferentes técnicas de gestión de la memoria" #: src/memory-management/comparison.md:23 msgid "Use-after-free." -msgstr "Use-after-free." +msgstr "Errores use-after-free." #: src/memory-management/comparison.md:24 msgid "Double-frees." -msgstr "Double-frees." +msgstr "Errores double free." #: src/memory-management/comparison.md:25 msgid "Memory leaks." -msgstr "Memory leaks." +msgstr "Pérdidas de memoria." #: src/memory-management/comparison.md:27 msgid "Garbage collection pauses." -msgstr "Pausas en Garbage Colletion." +msgstr "Pausas en la recolección de memoria residual." #: src/memory-management/comparison.md:28 msgid "Destructor delays." -msgstr "Destructor delays." +msgstr "Retrasos del destructor." #: src/memory-management/comparison.md:30 -#, fuzzy msgid "Complex, opt-in by programmer (on C++)." -msgstr "Complejo, a elección del programador." +msgstr "Compleja, habilitada por el programador (en C++)." #: src/memory-management/comparison.md:31 msgid "Circular references can lead to memory leaks" -msgstr "" +msgstr "Las referencias circulares pueden provocar pérdidas de memoria." #: src/memory-management/comparison.md:32 -#, fuzzy msgid "Potential runtime overhead" -msgstr "No runtime overhead." +msgstr "Posible sobrecarga en _runtime_ " #: src/memory-management/comparison.md:33 msgid "Compiler-enforced and scope-based like Rust:" -msgstr "Compiler-enforced y scope-based como Rust:" +msgstr "Implementada por el compilador y basada en el ámbito, como en Rust:" #: src/memory-management/comparison.md:34 msgid "Some upfront complexity." -msgstr "Alguna upfront complexity." +msgstr "Cierta complejidad inicial." #: src/memory-management/comparison.md:35 msgid "Can reject valid programs." -msgstr "Puede denegar programas válidos." +msgstr "Puede rechazar programas válidos." #: src/ownership.md:3 msgid "" "All variable bindings have a _scope_ where they are valid and it is an error " "to use a variable outside its scope:" msgstr "" -"Todos los enlaces de variables tienen un _scope_ donde son válidas y es un " -"error usar la variable fuera de este _scope_:" +"Todos los enlaces a variables tienen un _ámbito_ donde son válidos y se " +"produce un error cuando se usan fuera de él:" #: src/ownership.md:6 -#, fuzzy msgid "" "```rust,editable,compile_fail\n" "struct Point(i32, i32);\n" @@ -6487,32 +6484,23 @@ msgid "" "}\n" "```" msgstr "" -"```rust,editable\n" -"fn main() {\n" -" let s1: String = String::from(\"Hola!\");\n" -" let s2: String = s1;\n" -" println!(\"s2: {s2}\");\n" -" // println!(\"s1: {s1}\");\n" -"}\n" -"```" #: src/ownership.md:18 msgid "" "At the end of the scope, the variable is _dropped_ and the data is freed." -msgstr "Al final del _scope_, se borra la variable y se liberan los datos." +msgstr "Al final del ámbito, la variable _se elimina_ y los datos se liberan." #: src/ownership.md:19 msgid "A destructor can run here to free up resources." -msgstr "Un destructor puede correr aquí y liberar los recursos." +msgstr "Se puede ejecutar un destructor para liberar recursos." #: src/ownership.md:20 msgid "We say that the variable _owns_ the value." -msgstr "Podemos decir que la variable es dueña del valor." +msgstr "Decimos que el valor _pertenece_ a la variable." #: src/ownership/move-semantics.md:3 -#, fuzzy msgid "An assignment will transfer _ownership_ between variables:" -msgstr "Una asignación transferirá su propiedad entre variables:" +msgstr "Una asignación transferirá su _ownership_ entre variables:" #: src/ownership/move-semantics.md:5 msgid "" @@ -6539,27 +6527,26 @@ msgid "The assignment of `s1` to `s2` transfers ownership." msgstr "La asignación de `s1` a `s2` transfiere el _ownership_." #: src/ownership/move-semantics.md:15 -#, fuzzy msgid "When `s1` goes out of scope, nothing happens: it does not own anything." -msgstr "Cuando `s1` sale del ámbito, no sucede nada: no tiene dueño." +msgstr "" +"Cuando `s1` queda fuera del ámbito, no ocurre nada: no le pertenece nada." #: src/ownership/move-semantics.md:16 msgid "When `s2` goes out of scope, the string data is freed." -msgstr "Cuando `s2` sale del ámbito, el dato del string es liberado." +msgstr "Cuando `s2` sale del ámbito, los datos de la cadena se liberan." #: src/ownership/move-semantics.md:17 msgid "There is always _exactly_ one variable binding which owns a value." -msgstr "" -"Allí siempre hay _exactamente_ una variable enlazada que es dueña del valor." +msgstr "Siempre hay _exactamente_ un enlace a variable que posee un valor." #: src/ownership/move-semantics.md:21 msgid "" "Mention that this is the opposite of the defaults in C++, which copies by " "value unless you use `std::move` (and the move constructor is defined!)." msgstr "" -"Hay que destacar que el contrario de los defaults en C++, que copia por " -"valor a menos que uses `std::move` (y el movimiento del constructor está " -"definido!)." +"Menciona que es lo contrario de los valores predeterminados de C++, que se " +"copian por valor, a menos que utilices `std::move` (y que el constructor de " +"movimiento esté definido)." #: src/ownership/move-semantics.md:23 msgid "" @@ -6567,15 +6554,20 @@ msgid "" "to manipulate the data itself is a matter of optimization, and such copies " "are aggressively optimized away." msgstr "" +"Es únicamente el ownership el que se mueve. Si se genera algún código " +"máquina para manipular los datos en sí, se trata de una cuestión de " +"optimización, y esas copias se optimizan de forma agresiva." #: src/ownership/move-semantics.md:25 msgid "" "Simple values (such as integers) can be marked `Copy` (see later slides)." msgstr "" +"Los valores simples (como los enteros) se pueden marcar como `Copy` " +"(consulta las diapositivas posteriores)." #: src/ownership/move-semantics.md:27 msgid "In Rust, clones are explicit (by using `clone`)." -msgstr "En Rust los clones son explícitos (usando `clone`)." +msgstr "En Rust, la clonación es explícita (usando `clone`)." #: src/ownership/moved-strings-rust.md:3 msgid "" @@ -6589,11 +6581,11 @@ msgstr "" #: src/ownership/moved-strings-rust.md:10 msgid "The heap data from `s1` is reused for `s2`." -msgstr "La pila (heap) de datos de `s1` es rehusado para `s2`." +msgstr "Los datos del _heap_ de `s1` se reutilizan en `s2`." #: src/ownership/moved-strings-rust.md:11 msgid "When `s1` goes out of scope, nothing happens (it has been moved from)." -msgstr "Cuando `s1` sale del scope, no sucede nada (se movió de)." +msgstr "Cuando `s1` sale del ámbito, no ocurre nada (ha sido movida)." #: src/ownership/moved-strings-rust.md:13 msgid "Before move to `s2`:" @@ -6619,7 +6611,7 @@ msgstr "" #: src/ownership/moved-strings-rust.md:30 msgid "After move to `s2`:" -msgstr "Luego de mover a `s2`:" +msgstr "Después de mover a `s2`:" #: src/ownership/moved-strings-rust.md:32 msgid "" @@ -6644,15 +6636,34 @@ msgid "" "`- - - - - - - - - - - - - -'\n" "```" msgstr "" +"```bob\n" +" _Stack_ _Heap_\n" +".- - - - - - - - - - - - - -. .- - - - - - - - - - - - - -.\n" +": : : :\n" +": s1 \"(inaccessible)\" : : :\n" +": +-----------+-------+ : : +----+----+----+----+ :\n" +": | ptr | o---+---+--+--+-->| R | u | s | t | :\n" +": | len | 4 | : | : +----+----+----+----+ :\n" +": | capacity | 4 | : | : :\n" +": +-----------+-------+ : | : :\n" +": : | `- - - - - - - - - - - - - -'\n" +": s2 : |\n" +": +-----------+-------+ : |\n" +": | ptr | o---+---+--'\n" +": | len | 4 | :\n" +": | capacity | 4 | :\n" +": +-----------+-------+ :\n" +": :\n" +"`- - - - - - - - - - - - - -'\n" +"```" #: src/ownership/double-free-modern-cpp.md:1 -#, fuzzy msgid "Extra Work in Modern C++" -msgstr "Frees Dobles en C++ Moderno" +msgstr "Trabajo adicional en C++ moderno" #: src/ownership/double-free-modern-cpp.md:3 msgid "Modern C++ solves this differently:" -msgstr "El C++ moderno lo resuelve diferente:" +msgstr "La versión moderna de C++ soluciona este problema de forma diferente:" #: src/ownership/double-free-modern-cpp.md:5 msgid "" @@ -6663,24 +6674,24 @@ msgid "" msgstr "" "```c++\n" "std::string s1 = \"Cpp\";\n" -"std::string s2 = s1; // Duplica los datos en s1.\n" +"std::string s2 = s1; // Duplicar datos en s1.\n" "```" #: src/ownership/double-free-modern-cpp.md:10 msgid "" "The heap data from `s1` is duplicated and `s2` gets its own independent copy." msgstr "" -"La pila de datos de `s1` duplicada en `s2` obtiene su copia de datos " +"Los datos de la _stack_ de `s1` se duplican y `s2` obtiene su propia copia " "independiente." #: src/ownership/double-free-modern-cpp.md:11 msgid "When `s1` and `s2` go out of scope, they each free their own memory." msgstr "" -"Cuando `s1` y `s2` salen del scope, cada uno liberan su propia memoria." +"Cuando `s1` y `s2` salen del ámbito, cada uno libera su propia memoria." #: src/ownership/double-free-modern-cpp.md:13 msgid "Before copy-assignment:" -msgstr "Antes de la asignación-copia:" +msgstr "Antes de la asignación de copias:" #: src/ownership/double-free-modern-cpp.md:16 msgid "" @@ -6698,10 +6709,23 @@ msgid "" "`- - - - - - - - - - - - - -'\n" "```" msgstr "" +"```bob\n" +" _Stack_ _Heap_\n" +".- - - - - - - - - - - - - -. .- - - - - - - - - - - -.\n" +": : : :\n" +": s1 : : :\n" +": +-----------+-------+ : : +----+----+----+ :\n" +": | ptr | o---+---+--+--+-->| C | p | p | :\n" +": | len | 3 | : : +----+----+----+ :\n" +": | capacity | 3 | : : :\n" +": +-----------+-------+ : : :\n" +": : `- - - - - - - - - - - -'\n" +"`- - - - - - - - - - - - - -'\n" +"```" #: src/ownership/double-free-modern-cpp.md:30 msgid "After copy-assignment:" -msgstr "Luego de la asignación-copia:" +msgstr "Después de la asignación de copia:" #: src/ownership/double-free-modern-cpp.md:32 msgid "" @@ -6726,14 +6750,34 @@ msgid "" "`- - - - - - - - - - - - - -'\n" "```" msgstr "" +"```bob\n" +" _Stack_ _Heap_\n" +".- - - - - - - - - - - - - -. .- - - - - - - - - - - -.\n" +": : : :\n" +": s1 : : :\n" +": +-----------+-------+ : : +----+----+----+ :\n" +": | ptr | o---+---+--+--+-->| C | p | p | :\n" +": | len | 3 | : : +----+----+----+ :\n" +": | capacity | 3 | : : :\n" +": +-----------+-------+ : : :\n" +": : : :\n" +": s2 : : :\n" +": +-----------+-------+ : : +----+----+----+ :\n" +": | ptr | o---+---+-----+-->| C | p | p | :\n" +": | len | 3 | : : +----+----+----+ :\n" +": | capacity | 3 | : : :\n" +": +-----------+-------+ : : :\n" +": : `- - - - - - - - - - - -'\n" +"`- - - - - - - - - - - - - -'\n" +"```" #: src/ownership/moves-function-calls.md:3 msgid "" "When you pass a value to a function, the value is assigned to the function " "parameter. This transfers ownership:" msgstr "" -"Cuando pasas un valor a una función, el valor es asignado al parámetro de la " -"función. Esto transfiere el ownership:" +"Cuando pasas un valor a una función, el valor se asigna al parámetro de la " +"función. Esta acción transfiere el _ownership_:" #: src/ownership/moves-function-calls.md:6 msgid "" @@ -6755,31 +6799,31 @@ msgid "" "With the first call to `say_hello`, `main` gives up ownership of `name`. " "Afterwards, `name` cannot be used anymore within `main`." msgstr "" -"Con la primer llamada a `say_hello`, `main` da propiedad de `name`. Después " -"de todo, `name` no puede usarse meas dentro de `main`." +"Con la primera llamada a `say_hello`, `main` deja de tener el _ownership_ de " +"`name`. Después, ya no se podrá usar `name` dentro de `main`." #: src/ownership/moves-function-calls.md:21 msgid "" "The heap memory allocated for `name` will be freed at the end of the " "`say_hello` function." msgstr "" -"La pila de memoria se asigna para `name` y será liberada al final de la " -"función `say_hello`." +"La memoria de _heap_ asignada a `name` se liberará al final de la función " +"`say_hello`." #: src/ownership/moves-function-calls.md:22 msgid "" "`main` can retain ownership if it passes `name` as a reference (`&name`) and " "if `say_hello` accepts a reference as a parameter." msgstr "" -"`main` puede mantener la propiedad si pasa `name` como referencia (`&name`) " -"y si `say_hello` acepta una referencia como un parámetro." +"main` podrá conservar el _ownership_ si pasa`name` como referencia (`&name`) " +"y si `say_hello` acepta una referencia como parámetro." #: src/ownership/moves-function-calls.md:23 msgid "" "Alternatively, `main` can pass a clone of `name` in the first call (`name." "clone()`)." msgstr "" -"Alternativamente, `main` puede pasar un clon de `name` in la primer llamada " +"Por otro lado, `main` puede pasar un clon de `name` en la primera llamada " "(`name.clone()`)." #: src/ownership/moves-function-calls.md:24 @@ -6787,16 +6831,16 @@ msgid "" "Rust makes it harder than C++ to inadvertently create copies by making move " "semantics the default, and by forcing programmers to make clones explicit." msgstr "" -"Rust hace esto más duro que C++ para crear copias automáticas mediante mover " -"semánticas por defecto, y forzando a los programadores a hacer clones " -"explícitos." +"Rust hace que resulte más difícil que en C++ crear copias por error al " +"definir la semántica de movimiento como predeterminada y al obligar a los " +"programadores a clonar sólo de forma explícita." #: src/ownership/copy-clone.md:3 msgid "" "While move semantics are the default, certain types are copied by default:" msgstr "" -"Mientras mover semántica es por defecto, en otros casos los tipos son " -"copiados:" +"Aunque la semántica de movimiento es la opción predeterminada, algunos tipos " +"se copian de forma predeterminada:" #: src/ownership/copy-clone.md:5 msgid "" @@ -6812,14 +6856,14 @@ msgstr "" #: src/ownership/copy-clone.md:14 msgid "These types implement the `Copy` trait." -msgstr "Esos tipos implementan el trato de `Copia`." +msgstr "Estos tipos implementan el trait `Copy`." #: src/ownership/copy-clone.md:16 msgid "You can opt-in your own types to use copy semantics:" -msgstr "Puedes elegir tu propio tipo para usar copias semánticas:" +msgstr "" +"Puedes habilitar tus propios tipos para que usen la semántica de copia:" #: src/ownership/copy-clone.md:18 -#, fuzzy msgid "" "```rust,editable\n" "#[derive(Copy, Clone, Debug)]\n" @@ -6833,77 +6877,72 @@ msgid "" "}\n" "```" msgstr "" -"```rust,editable\n" -"fn main() {\n" -" let s1: String = String::from(\"Hola!\");\n" -" let s2: String = s1;\n" -" println!(\"s2: {s2}\");\n" -" // println!(\"s1: {s1}\");\n" -"}\n" -"```" #: src/ownership/copy-clone.md:30 msgid "After the assignment, both `p1` and `p2` own their own data." -msgstr "Luego de la asignación, ambos `p1` y `p2` obtienen su propio dato." +msgstr "" +"Después de la asignación, tanto `p1` como `p2` tienen sus propios datos." #: src/ownership/copy-clone.md:31 msgid "We can also use `p1.clone()` to explicitly copy the data." -msgstr "También podemos usar `p1.clone()` para explícitamente copiar datos." +msgstr "" +"También podemos utilizar `p1.clone()` para copiar los datos de forma " +"explícita." #: src/ownership/copy-clone.md:35 msgid "Copying and cloning are not the same thing:" -msgstr "Copiar datos y clonar no es la misma cosa:" +msgstr "Copiar y clonar no es lo mismo:" #: src/ownership/copy-clone.md:37 msgid "" "Copying refers to bitwise copies of memory regions and does not work on " "arbitrary objects." msgstr "" -"Copiar refiere a copias bit a bit de regiones de memoria y no funciona con " -"objetos arbitrarios." +"Copiar hace referencia a las copias bit a bit de regiones de memoria y no " +"funciona en cualquier objeto." #: src/ownership/copy-clone.md:38 msgid "" "Copying does not allow for custom logic (unlike copy constructors in C++)." msgstr "" -"Copiar no permite por lógica personalizada (como copiar constructores en C+" -"+)." +"Copiar no permite lógica personalizada (a diferencia de los constructores de " +"copias de C++)." #: src/ownership/copy-clone.md:39 msgid "" "Cloning is a more general operation and also allows for custom behavior by " "implementing the `Clone` trait." msgstr "" -"Clonar es una operación más general y también permite estados personalizados " -"implementando el trato de `Clon`." +"Clonar es una operación más general y que permite un comportamiento " +"personalizado implementando el trait `Clone`." #: src/ownership/copy-clone.md:40 msgid "Copying does not work on types that implement the `Drop` trait." -msgstr "Copiar no funciona en tipos que implementan el trato `Drop`." +msgstr "Copiar no funciona en los tipos que implementan el trait `Drop`." #: src/ownership/copy-clone.md:42 src/ownership/lifetimes-function-calls.md:29 msgid "In the above example, try the following:" -msgstr "En el ejemplo de arriba, intenta lo siguiente:" +msgstr "En el ejemplo anterior, prueba lo siguiente:" #: src/ownership/copy-clone.md:44 msgid "" "Add a `String` field to `struct Point`. It will not compile because `String` " "is not a `Copy` type." msgstr "" -"Agrega el campo `String` a `struct Point`. Esto no compilará porque `String` " -"no es un tipo de `Copia`." +"Añade un campo `String` a `struct Point`. No se compilará porque `String` no " +"es de tipo `Copy`." #: src/ownership/copy-clone.md:45 msgid "" "Remove `Copy` from the `derive` attribute. The compiler error is now in the " "`println!` for `p1`." msgstr "" -"Remueve la `Copia` de el atributo `resultante`. El error del compilador es " -"ahora `println!` para `p1`." +"Elimina `Copy` del atributo `derive`. El error del compilador se encuentra " +"ahora en `println!` para `p1`." #: src/ownership/copy-clone.md:46 msgid "Show that it works if you clone `p1` instead." -msgstr "Muestra que en cambio funciona si clonas `p1`." +msgstr "Demuestra que funciona si clonas `p1`." #: src/ownership/copy-clone.md:48 msgid "" @@ -6911,17 +6950,18 @@ msgid "" "to generate code in Rust at compile time. In this case the default " "implementations of `Copy` and `Clone` traits are generated." msgstr "" -"Si un estudiante pregunta sobre `derive`, es suficiente decir que esta es la " -"forma que se genera el código en Rust en tiempo de compilación. En este caso " -"la implementación del trato por defecto de `Copiar` y `Clonar` los genera." +"Si los alumnos preguntan por `derive`, basta con decir que se trata de una " +"forma de generar código en Rust durante el tiempo de compilación. En este " +"caso, se generan las implementaciones predeterminadas de los traits `Copy` y " +"`Clone`." #: src/ownership/borrowing.md:3 msgid "" "Instead of transferring ownership when calling a function, you can let a " "function _borrow_ the value:" msgstr "" -"En vez de transferir la propiedad cuando llamamos a una función, puedes " -"_prestar_ el valor a una función:" +"En lugar de transferir el _ownership_ al llamar a una función, puedes " +"permitir que una función _tome prestado_ el valor:" #: src/ownership/borrowing.md:6 msgid "" @@ -6944,18 +6984,17 @@ msgstr "" #: src/ownership/borrowing.md:22 msgid "The `add` function _borrows_ two points and returns a new point." -msgstr "El `add` de la función presta dos puntos y devuelve uno nuevo." +msgstr "La función `add` _toma prestados_ dos puntos y devuelve uno nuevo." #: src/ownership/borrowing.md:23 msgid "The caller retains ownership of the inputs." -msgstr "El llamador mantiene la propiedad de sus inputs." +msgstr "El llamador conserva el _ownership_ de las entradas." #: src/ownership/borrowing.md:27 msgid "Notes on stack returns:" -msgstr "Notas acerca de la pila devuelta:" +msgstr "Notas sobre la devolución de resultados de la _stack_:" #: src/ownership/borrowing.md:28 -#, fuzzy msgid "" "Demonstrate that the return from `add` is cheap because the compiler can " "eliminate the copy operation. Change the above code to print stack addresses " @@ -6964,11 +7003,13 @@ msgid "" "optimization level, the addresses should change, while they stay the same " "when changing to the \"RELEASE\" setting:" msgstr "" -"Demuestra que el return de `add` es adecuado porque le compilador puede " -"eliminar la operación de copia. Cambia el código de arriba para imprimir una " -"pila de direcciones y corre esto en [Playground](https://play.rust-lang." -"org/). En nivel de optimización \"DEBUG\", las direcciones pueden cambiar, " -"mientras que se mantienen igual cuando se cambia el seteo a \"RELEASE\":" +"Demuestra que la instrucción de retorno de `add` es fácil porque el " +"compilador puede eliminar la operación de copia. Cambia el código anterior " +"para imprimir las direcciones de la _stack_ y ejecutarlas en el [Playground]" +"(https://play.rust-lang.org/) o consulta el ensamblador en [Godbolt](https://" +"rust.godbolt.org/). En el nivel de optimización \"DEBUG\", las direcciones " +"deberían cambiar. Sin embargo, deberían mantenerse igual modificar la " +"configuración \"RELEASE\":" #: src/ownership/borrowing.md:30 msgid "" @@ -6995,36 +7036,33 @@ msgstr "" #: src/ownership/borrowing.md:48 msgid "The Rust compiler can do return value optimization (RVO)." msgstr "" +"El compilador de Rust puede hacer la optimización del valor devuelto (RVO)." #: src/ownership/borrowing.md:49 -#, fuzzy msgid "" "In C++, copy elision has to be defined in the language specification because " "constructors can have side effects. In Rust, this is not an issue at all. If " "RVO did not happen, Rust will always perform a simple and efficient `memcpy` " "copy." msgstr "" -"* 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 " -"nada es un issue. Si no sucede RVO, Rust siempre hará que corre de forma " -"simple y eficiente con una copia `memcpy`.\n" -"```" +"En C++, la elisión de copia tiene que definirse en la especificación del " +"lenguaje, ya que los constructores pueden tener efectos secundarios. En " +"Rust, esto no supone ningún problema. Si no hay RVO, Rust siempre realizará " +"una copia `memcpy` simple y eficiente." #: src/ownership/shared-unique-borrows.md:3 msgid "Rust puts constraints on the ways you can borrow values:" -msgstr "Rust restringe la forma que puedes estar calores:" +msgstr "Rust limita las formas en que se pueden tomar prestados valores:" #: src/ownership/shared-unique-borrows.md:5 msgid "You can have one or more `&T` values at any given time, _or_" -msgstr "A lo largo del tiempo puedes tener diferentes valores `&T`, _o_" +msgstr "Puedes tener uno o varios valores `&T` en un momento dado, _o_" #: src/ownership/shared-unique-borrows.md:6 msgid "You can have exactly one `&mut T` value." -msgstr "Puedes tener exactamente el mismo valor `&mud T`." +msgstr "puedes tener exactamente un valor `&mut T`." #: src/ownership/shared-unique-borrows.md:8 -#, fuzzy msgid "" "```rust,editable,compile_fail\n" "fn main() {\n" @@ -7041,30 +7079,22 @@ msgid "" "}\n" "```" msgstr "" -"```rust,editable\n" -"fn main() {\n" -" let s1: String = String::from(\"Hola!\");\n" -" let s2: String = s1;\n" -" println!(\"s2: {s2}\");\n" -" // println!(\"s1: {s1}\");\n" -"}\n" -"```" #: src/ownership/shared-unique-borrows.md:25 msgid "" "The above code does not compile because `a` is borrowed as mutable (through " "`c`) and as immutable (through `b`) at the same time." msgstr "" -"El código de arriba no compila porque `a` es prestado como mutable (a través " -"de `c`) y es inmutable (a través de `b`) al mismo tiempo." +"El código anterior no se compila porque `a` se toma prestada como mutable (a " +"través de `c`) y como inmutable (a través de `b`) al mismo tiempo." #: src/ownership/shared-unique-borrows.md:26 msgid "" "Move the `println!` statement for `b` before the scope that introduces `c` " "to make the code compile." msgstr "" -"Mueve el `println!` para `b` antes del scope que dice a `c` hacer que el " -"código compile." +"Mueve la instrucción `println!` de `b` antes del ámbito que introduce `c` " +"para que el código compile." #: src/ownership/shared-unique-borrows.md:27 msgid "" @@ -7072,47 +7102,47 @@ msgid "" "the new mutable borrow of `a` through `c`. This is a feature of the borrow " "checker called \"non-lexical lifetimes\"." msgstr "" -"Luego de ese cambio, el compilados hace que `b` sea usado solo antes de un " -"préstamo mutable de `a` a través de `c`. Esta es una característica para " -"chequear los préstamos llamada \"non-lexical lifetimes\"." +"Después de ese cambio, el compilador se da cuenta de que `b` solo se usa " +"antes del nuevo préstamo mutable de `a` a través de `c`. Se trata de una " +"función del verificador de préstamos denominada \"tiempo de vida no léxico\"." #: src/ownership/lifetimes.md:3 msgid "A borrowed value has a _lifetime_:" -msgstr "Un valor prestado tiene un tiempo de vida:" +msgstr "Un valor que se toma prestado tiene un _tiempo de vida_:" #: src/ownership/lifetimes.md:5 -#, fuzzy msgid "The lifetime can be implicit: `add(p1: &Point, p2: &Point) -> Point`." msgstr "" -"El tiempo de vida puede ser otorgado: `add(p1: &Point, p2: &Point) -> Point`." +"El tiempo de vida puede ser implícito: `add(p1: &Point, p2: &Point) -> " +"Point`." #: src/ownership/lifetimes.md:6 msgid "Lifetimes can also be explicit: `&'a Point`, `&'document str`." -msgstr "El tiempo también puede ser explícito: `&’a Point`, `&’document str`." +msgstr "" +"Tiempo de vida también puede ser explícito: `&'a Point`, `&'document str`." #: src/ownership/lifetimes.md:7 src/ownership/lifetimes-function-calls.md:23 msgid "" "Read `&'a Point` as \"a borrowed `Point` which is valid for at least the " "lifetime `a`\"." msgstr "" -"Leer `&’a Point` como un \"`Point` prestado\" que es válido para al menos el " -"tiempo de `a`\"." +"Lee `&'a Point` como \"un `Point` prestado que es válido al menos durante el " +"tiempo de vida de `a`\"." #: src/ownership/lifetimes.md:9 msgid "" "Lifetimes are always inferred by the compiler: you cannot assign a lifetime " "yourself." msgstr "" -"Los tiempos de vida siempre son inferidos por el compilador: no puedes " -"asignar uno tú mismo." +"El compilador siempre infiere el tiempo de vida: no puedes asignarlos tú." #: src/ownership/lifetimes.md:11 msgid "" "Lifetime annotations create constraints; the compiler verifies that there is " "a valid solution." msgstr "" -"Las anotaciones de tiempo de vida crea dependencias; el compilador verifica " -"que allí haya una solución válida." +"Las anotaciones durante el tiempo de vida crean restricciones. El compilador " +"verifica que hay una solución válida." #: src/ownership/lifetimes.md:13 msgid "" @@ -7120,14 +7150,18 @@ msgid "" "but Rust allows lifetimes to be elided in most cases with [a few simple " "rules](https://doc.rust-lang.org/nomicon/lifetime-elision.html)." msgstr "" +"El tiempo de vida de los argumentos de las funciones y los valores devueltos " +"deben especificarse por completo, pero Rust permite que se puedan eludir en " +"la mayoría de los casos con [unas sencillas reglas](https://doc.rust-lang." +"org/nomicon/lifetime-elision.html)." #: src/ownership/lifetimes-function-calls.md:3 msgid "" "In addition to borrowing its arguments, a function can return a borrowed " "value:" msgstr "" -"Además, para prestar estos argumentos, una función puede devolver un valor " -"prestado:" +"Además de tomar prestados sus argumentos, una función puede devolver un " +"valor que se ha tomado prestado:" #: src/ownership/lifetimes-function-calls.md:5 msgid "" @@ -7150,30 +7184,30 @@ msgstr "" #: src/ownership/lifetimes-function-calls.md:21 msgid "`'a` is a generic parameter, it is inferred by the compiler." -msgstr "`’a` es un parámetro genérico, inferido por el compilador." +msgstr "`'a` es un parámetro genérico que infiere el compilador." #: src/ownership/lifetimes-function-calls.md:22 msgid "Lifetimes start with `'` and `'a` is a typical default name." msgstr "" -"Los tiempos de vida empiezan con `’` y `’a` es el nombre típico por default." +"Los tiempos de vida comienzan por `'` y `'a` suele ser un nombre " +"predeterminado habitual." #: src/ownership/lifetimes-function-calls.md:25 msgid "" "The _at least_ part is important when parameters are in different scopes." msgstr "" -"El _al menos_ es importante cuando los parámetros están en diferentes scopes." +"La parte _al menos_ es importante cuando los parámetros están en ámbitos " +"distintos." #: src/ownership/lifetimes-function-calls.md:31 -#, fuzzy msgid "" "Move the declaration of `p2` and `p3` into a new scope (`{ ... }`), " "resulting in the following code:" msgstr "" -"Mueve la declaración de `p2` y `p3` a un nuevo scope (`{ … }`), resultando " -"en este código:" +"Mueve la declaración de `p2` y `p3` a un nuevo ámbito (`{ ... }`), lo que " +"dará como resultado el siguiente código:" #: src/ownership/lifetimes-function-calls.md:32 -#, fuzzy msgid "" "```rust,ignore\n" "#[derive(Debug)]\n" @@ -7194,51 +7228,40 @@ msgid "" "}\n" "```" msgstr "" -"fn main() { let p1: Point = Point(10, 10); let p3: &Point; { let p2: Point = " -"Point(20, 20); p3 = left_most(&p1, &p2); } println!(\"left-most point: " -"{:?}\", p3); }" #: src/ownership/lifetimes-function-calls.md:50 -#, fuzzy msgid "Note how this does not compile since `p3` outlives `p2`." msgstr "" -"Nota como no compila desde que `p3` persiste `p2`.\n" -"```" +"Ten en cuenta que no se puede compilar, ya que `p3` dura más tiempo que `p2`." #: src/ownership/lifetimes-function-calls.md:52 -#, fuzzy msgid "" "Reset the workspace and change the function signature to `fn left_most<'a, " "'b>(p1: &'a Point, p2: &'a Point) -> &'b Point`. This will not compile " "because the relationship between the lifetimes `'a` and `'b` is unclear." msgstr "" -"Resetea el workspace y cambia el signo de la función a `fn left_most<‘a, " -"‘b>(p1: &’a Point, p2: &’a Point) -> &’b Point`. Esto no compilará porque la " -"relación entre los ciclos de vida `’a` y `’b` no es clara." +"Restablece el espacio de trabajo y cambia la firma de la función a `fn " +"left_most<'a, 'b>(p1: &'a Point, p2: &'a Point) -> &'b Point`. No se " +"compilará porque la relación entre los tiempos de vida de `'a` y `'b` no " +"está clara." #: src/ownership/lifetimes-function-calls.md:53 -#, fuzzy msgid "Another way to explain it:" -msgstr "" -"Otra forma de explicar esto: \\*Dos referencias para dos valores son " -"prestados por una función y la función devuelve otra referencia." +msgstr "Otra forma de explicarlo:" #: src/ownership/lifetimes-function-calls.md:54 -#, fuzzy msgid "" "Two references to two values are borrowed by a function and the function " "returns another reference." msgstr "" -"esto debe venir desde uno de esos dos inputs (o de una variable global)." +"Una función toma prestadas dos referencias a dos valores y devuelve otra " +"referencia." #: src/ownership/lifetimes-function-calls.md:56 -#, fuzzy msgid "" "It must have come from one of those two inputs (or from a global variable)." msgstr "" -"Cuál es esta? El compilador necesita saber, que la llamada para volver al " -"sitio de referencia no se usa más que como variable de donde viene la " -"referencia." +"Esta debe proceder de una de esas dos entradas (o de una variable global)." #: src/ownership/lifetimes-function-calls.md:57 msgid "" @@ -7246,12 +7269,16 @@ msgid "" "returned reference is not used for longer than a variable from where the " "reference came from." msgstr "" +"¿Cuál de ellas es? El compilador debe saberlo para que, en el sitio de la " +"llamada, la referencia devuelta no se use durante más tiempo que una " +"variable de la que procede la referencia." #: src/ownership/lifetimes-data-structures.md:3 msgid "" "If a data type stores borrowed data, it must be annotated with a lifetime:" msgstr "" -"SI un tipo de datos presta data, debe ser anotado como un ciclo de vida:" +"Si un tipo de datos almacena datos prestados, se debe anotar con tiempo de " +"vida:" #: src/ownership/lifetimes-data-structures.md:5 msgid "" @@ -7281,17 +7308,17 @@ msgid "" "underlying the contained `&str` lives at least as long as any instance of " "`Highlight` that uses that data." msgstr "" -"En el ejemplo de arriba, las anotaciones `resaltadlas` fuerzan que los datos " -"contenidos en `&str` viven al menos a lo largo de todas las instancias " -"`resaltadlas` que usan esos datos." +"En el ejemplo anterior, la anotación en `Highlight` hace que los datos " +"subyacentes a la `&str` contenida tengan al menos la misma duración que " +"cualquier instancia de `Highlight` que utilice esos datos." #: src/ownership/lifetimes-data-structures.md:26 msgid "" "If `text` is consumed before the end of the lifetime of `fox` (or `dog`), " "the borrow checker throws an error." msgstr "" -"Si el `texto` es usado antes del final del ciclo de vida de `fox` (o `dog`), " -"el chequeado de préstamos arrojará error." +"Si `text` se consume antes de que acabe el tiempo de vida de `fox` (o " +"`dog`), el _borrow checker_ (verificador de préstamos) muestra un error." #: src/ownership/lifetimes-data-structures.md:27 msgid "" @@ -7299,14 +7326,15 @@ msgid "" "can be useful for creating lightweight views, but it generally makes them " "somewhat harder to use." msgstr "" -"Los tipos que prestan datos fuerzan a los usuarios a mantener el dato " -"original. Esto puede ser útil para crear vistas ligeras, pero generalmente " -"hace que sea difícil de usar." +"Los tipos con datos prestados (_borrowed_) obligan a los usuarios a " +"conservar los datos originales. Esto puede ser útil para crear vistas " +"ligeras aunque, por lo general, hace que sean un poco más difíciles de usar." #: src/ownership/lifetimes-data-structures.md:28 msgid "When possible, make data structures own their data directly." msgstr "" -"Cuando sea posible, haz estructuras de datos tengan su dato directamente." +"Siempre que sea posible, haz que las estructuras de datos sean propietarias " +"directas de sus datos." #: src/ownership/lifetimes-data-structures.md:29 msgid "" @@ -7315,38 +7343,38 @@ msgid "" "relationships between the references themselves, in addition to the lifetime " "of the struct itself. Those are very advanced use cases." msgstr "" -"Algunas estructuras con múltiples referencias dentro pueden tener más de una " -"anotación de ciclo de vida. Esto puede ser necesario si allí quiere " -"describir un a relación de ciclo de vida entre las referencias, ademas del " -"ciclo de vida de las estructuras en sí mismo. Aquellas son casos de uso más " -"avanzado." +"Algunas estructuras con varias referencias dentro pueden tener más de una " +"anotación de tiempo de vida. Esto puede ser necesario si hay que describir " +"las relaciones de tiempo de vida entre las propias referencias, además del " +"tiempo de vida de la propia estructura. Estos son casos prácticos muy " +"avanzados." #: src/exercises/day-2/morning.md:1 msgid "Day 2: Morning Exercises" -msgstr "" +msgstr "Día 2: Ejercicios de la Mañana" #: src/exercises/day-2/morning.md:3 msgid "We will look at implementing methods in two contexts:" -msgstr "" +msgstr "Veremos la implementación de métodos en dos contextos:" #: src/exercises/day-2/morning.md:5 msgid "Simple struct which tracks health statistics." msgstr "" +"Estructura simple que hace un seguimiento de las estadísticas de salud." #: src/exercises/day-2/morning.md:7 msgid "Multiple structs and enums for a drawing library." -msgstr "" +msgstr "Varias estructuras y enumeraciones para una biblioteca de planos." #: src/exercises/day-2/book-library.md:3 msgid "" "We will learn much more about structs and the `Vec` type tomorrow. For " "now, you just need to know part of its API:" msgstr "" -"Mañana aprenderemos mucho mas acerca de estructuras y tipos `Vec`. Por " -"ahora, solo necesitas conocer parte de esta API:" +"Mañana conoceremos mucho mejor las estructuras y el tipo `Vec`. Por " +"ahora, solo debes conocer parte de su API:" #: src/exercises/day-2/book-library.md:6 -#, fuzzy msgid "" "```rust,editable\n" "fn main() {\n" @@ -7360,24 +7388,15 @@ 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-2/book-library.md:18 -#, fuzzy msgid "" "Use this to model a library's book collection. Copy the code below to " " and update the types to make it compile:" msgstr "" -"Usa esto para crear una librería de aplicación. Copia el código debajo a " -" y actualiza los tipos para hacer que compile:" +"Crea un modelo de la colección de libros de una biblioteca con esta opción. " +"Copia el código que aparece abajo en y " +"actualiza los tipos para que compile:" #: src/exercises/day-2/book-library.md:21 msgid "" @@ -7467,7 +7486,7 @@ msgstr "" #: src/exercises/day-2/book-library.md:102 msgid "[Solution](solutions-afternoon.md#designing-a-library)" -msgstr "" +msgstr "[Soluciones](solutions-afternoon.md#designing-a-library)" #: src/exercises/day-2/iterators-and-ownership.md:3 msgid "" @@ -7476,13 +7495,14 @@ msgid "" "[`IntoIterator`](https://doc.rust-lang.org/std/iter/trait.IntoIterator.html) " "traits." msgstr "" -"El modelo de propiedad de Rust afecta muchas APIs. Un ejemplo de esto es " -"[`Iterator`](https://doc.rust-lang.org/std/iter/trait.Iterator.html) y " -"[`IntoIterator`](https://doc.rust-lang.org/std/iter/trait.IntoIterator.html)." +"El modelo de _ownership_ de Rust afecta a muchas APIs. Un ejemplo serían los " +"traits [`Iterator`](https://doc.rust-lang.org/std/iter/trait.Iterator.html) " +"e [`IntoIterator`](https://doc.rust-lang.org/std/iter/trait.IntoIterator." +"html)." #: src/exercises/day-2/iterators-and-ownership.md:8 src/bare-metal/no_std.md:28 msgid "`Iterator`" -msgstr "" +msgstr "`Iterator`" #: src/exercises/day-2/iterators-and-ownership.md:10 msgid "" @@ -7490,9 +7510,9 @@ msgid "" "`Iterator` trait simply says that you can call `next` until you get `None` " "back:" msgstr "" -"Estos son como interfaces: ellas describen un estado (método) para un tipo. " -"El `Iterador` simplemente dice que puedes llamar al `siguiente` hasta que se " -"devuelve `ninguno`:" +"Los traits son como las interfaces: describen el comportamiento (métodos) de " +"un tipo. El trait `Iterator` indica que se puede llamar a `next` hasta que " +"se obtenga `None`:" #: src/exercises/day-2/iterators-and-ownership.md:13 msgid "" @@ -7506,7 +7526,7 @@ msgstr "" #: src/exercises/day-2/iterators-and-ownership.md:20 msgid "You use this trait like this:" -msgstr "Puedes usar lo siguiente:" +msgstr "Utiliza este trait de la siguiente forma:" #: src/exercises/day-2/iterators-and-ownership.md:22 msgid "" @@ -7525,10 +7545,9 @@ msgstr "" #: src/exercises/day-2/iterators-and-ownership.md:34 msgid "What is the type returned by the iterator? Test your answer here:" -msgstr "Cuál es el tipo devuelto por el iterador? Testea tu respuesta aquí:" +msgstr "¿Qué tipo devuelve el iterador? Prueba tu respuesta aquí:" #: src/exercises/day-2/iterators-and-ownership.md:36 -#, fuzzy msgid "" "```rust,editable,compile_fail\n" "fn main() {\n" @@ -7540,22 +7559,14 @@ msgid "" "}\n" "```" msgstr "" -"```rust,editable\n" -"fn main() {\n" -" let s1: String = String::from(\"Hola!\");\n" -" let s2: String = s1;\n" -" println!(\"s2: {s2}\");\n" -" // println!(\"s1: {s1}\");\n" -"}\n" -"```" #: src/exercises/day-2/iterators-and-ownership.md:46 msgid "Why is this type used?" -msgstr "Por qué es usado este tipo?" +msgstr "¿Por qué se usa este tipo?" #: src/exercises/day-2/iterators-and-ownership.md:48 msgid "`IntoIterator`" -msgstr "" +msgstr "`IntoIterator`" #: src/exercises/day-2/iterators-and-ownership.md:50 msgid "" @@ -7563,8 +7574,8 @@ msgid "" "iterator. The related trait `IntoIterator` tells you how to create the " "iterator:" msgstr "" -"El `Iterator` te dice cómo \\_iterarP una vez que creas un iterado. La " -"relación `IntoIterator` dice cómo crear un iterador:" +"El trait `Iterator` te indica cómo _iterar_ una vez que has creado un " +"iterador. El trait relacionado `IntoIterator` indica cómo crear el iterador:" #: src/exercises/day-2/iterators-and-ownership.md:53 msgid "" @@ -7583,12 +7594,12 @@ msgid "" "The syntax here means that every implementation of `IntoIterator` must " "declare two types:" msgstr "" -"La sintaxis aquí dice que cada implementación de `IntoIterator` debe " +"La sintaxis aquí significa que cada implementación de `IntoIterator` debe " "declarar dos tipos:" #: src/exercises/day-2/iterators-and-ownership.md:65 msgid "`Item`: the type we iterate over, such as `i8`," -msgstr "`Item`: el tipo que iteramos, como `i8`," +msgstr "`Item`: el tipo sobre el que iteramos, como `i8`," #: src/exercises/day-2/iterators-and-ownership.md:66 msgid "`IntoIter`: the `Iterator` type returned by the `into_iter` method." @@ -7599,15 +7610,14 @@ msgid "" "Note that `IntoIter` and `Item` are linked: the iterator must have the same " "`Item` type, which means that it returns `Option`" msgstr "" -"Nota que `IntoIter` e `Item` están linkeados: el iterado debe tener el mismo " -"tipo `Item`, que quiere decir que retorna `Option`" +"Ten en cuenta que `IntoIter` y `Item` están vinculados: el iterador debe " +"tener el mismo tipo de `Item`, lo que significa que devuelve `Option`." #: src/exercises/day-2/iterators-and-ownership.md:71 msgid "Like before, what is the type returned by the iterator?" -msgstr "Como antes, qué es el tipo devuelto por el iterador?" +msgstr "Al igual que antes, ¿qué tipo devuelve el iterador?" #: src/exercises/day-2/iterators-and-ownership.md:73 -#, fuzzy msgid "" "```rust,editable,compile_fail\n" "fn main() {\n" @@ -7620,18 +7630,10 @@ msgid "" "}\n" "```" msgstr "" -"```rust,editable\n" -"fn main() {\n" -" let s1: String = String::from(\"Hola!\");\n" -" let s2: String = s1;\n" -" println!(\"s2: {s2}\");\n" -" // println!(\"s1: {s1}\");\n" -"}\n" -"```" #: src/exercises/day-2/iterators-and-ownership.md:83 msgid "`for` Loops" -msgstr "Loops `for`" +msgstr "Bucles `for`" #: src/exercises/day-2/iterators-and-ownership.md:85 msgid "" @@ -7639,12 +7641,11 @@ msgid "" "loops. They call `into_iter()` on an expression and iterates over the " "resulting iterator:" msgstr "" -"Ahora que sabemos de ambos `Iterator` y `Intolterator`, podemos hacer loops " -"`for`. Ellos llaman `into_iter()` en una expresión e iterados sobre el " -"iterado resultante:" +"Ahora que conocemos `Iterator` e `IntoIterator`, podemos crear bucles `for`. " +"Llaman a `into_iter()` sobre una expresión e iteran sobre el iterador " +"resultante:" #: src/exercises/day-2/iterators-and-ownership.md:89 -#, fuzzy msgid "" "```rust,editable\n" "fn main() {\n" @@ -7661,21 +7662,12 @@ msgid "" "}\n" "```" msgstr "" -"```rust,editable\n" -"fn main() {\n" -" let s1: String = String::from(\"Hola!\");\n" -" let s2: String = s1;\n" -" println!(\"s2: {s2}\");\n" -" // println!(\"s1: {s1}\");\n" -"}\n" -"```" #: src/exercises/day-2/iterators-and-ownership.md:103 msgid "What is the type of `word` in each loop?" -msgstr "Qué es el tipo `word` en cada loop?" +msgstr "¿Cuál es el tipo de `word` en cada bucle?" #: src/exercises/day-2/iterators-and-ownership.md:105 -#, fuzzy msgid "" "Experiment with the code above and then consult the documentation for [`impl " "IntoIterator for &Vec`](https://doc.rust-lang.org/std/vec/struct.Vec." @@ -7683,15 +7675,15 @@ msgid "" "Vec`](https://doc.rust-lang.org/std/vec/struct.Vec.html#impl-IntoIterator-" "for-Vec%3CT,+A%3E) to check your answers." msgstr "" -"Experimenta con el código de arriba y luego consultas por [`impl " +"Experimenta con el código anterior y consulta la documentación sobre [`impl " "IntoIterator for &Vec`](https://doc.rust-lang.org/std/vec/struct.Vec." -"html#impl-IntoIterator-for-%26%27a%20Vec%3CT%2C%20A%3E) y [`impl " -"IntoIterator for Vec`](https://doc.rust-lang.org/std/vec/struct.Vec." -"html#impl-IntoIterator-for-Vec%3CT%2C%20A%3E) para verificar tus respuestas." +"html#impl-IntoIterator-for-%26'a+Vec%3CT,+A%3E) y sobre [`impl IntoIterator " +"for Vec`](https://doc.rust-lang.org/std/vec/struct.Vec.html#impl-" +"IntoIterator-for-Vec%3CT,+A%3E) para comprobar las respuestas." #: src/structs.md:3 msgid "Like C and C++, Rust has support for custom structs:" -msgstr "" +msgstr "Al igual que C y C++, Rust admite estructuras (struct) personalizadas:" #: src/structs.md:5 msgid "" @@ -7722,27 +7714,33 @@ msgstr "" #: src/structs.md:33 msgid "Structs work like in C or C++." -msgstr "" +msgstr "Las estructuras funcionan como en C o en C++." #: src/structs.md:34 msgid "Like in C++, and unlike in C, no typedef is needed to define a type." msgstr "" +"Al igual que en C++, y a diferencia de C, no se necesita typedef para " +"definir un tipo." #: src/structs.md:35 msgid "Unlike in C++, there is no inheritance between structs." -msgstr "" +msgstr "A diferencia de C++, no existe ninguna herencia entre las estructuras." #: src/structs.md:36 msgid "" "Methods are defined in an `impl` block, which we will see in following " "slides." msgstr "" +"Los métodos están definidos en un bloque `impl` que veremos en las " +"siguientes diapositivas." #: src/structs.md:37 msgid "" "This may be a good time to let people know there are different types of " "structs. " msgstr "" +"Puede que sea un buen momento para indicar a los alumnos que existen " +"diferentes tipos de estructuras. " #: src/structs.md:38 msgid "" @@ -7750,12 +7748,17 @@ msgid "" "trait on some type but don’t have any data that you want to store in the " "value itself. " msgstr "" +"Las estructuras de tamaño cero, como `struct Foo;`, se pueden utilizar al " +"implementar un trait en algún tipo, pero no tienen ningún dato que te " +"interese almacenar en el propio valor. " #: src/structs.md:39 msgid "" "The next slide will introduce Tuple structs, used when the field names are " "not important." msgstr "" +"La siguiente diapositiva presentará las estructuras de tuplas, que se " +"utilizan cuando los nombres de los campos no son importantes." #: src/structs.md:40 msgid "" @@ -7763,13 +7766,17 @@ msgid "" "old struct without having to explicitly type it all out. It must always be " "the last element." msgstr "" +"La sintaxis `..peter` nos permite copiar la mayoría de los campos de la " +"estructura anterior sin tener que escribirlos explícitamente. Siempre debe " +"ser el último elemento." #: src/structs/tuple-structs.md:3 msgid "If the field names are unimportant, you can use a tuple struct:" msgstr "" +"Si los nombres de los campos no son importantes, puedes utilizar una " +"estructura de tuplas:" #: src/structs/tuple-structs.md:5 -#, fuzzy msgid "" "```rust,editable\n" "struct Point(i32, i32);\n" @@ -7780,15 +7787,12 @@ msgid "" "}\n" "```" msgstr "" -"```rust,editable\n" -"fn main() {\n" -" let s1: &str = \"Mundo\";\n" -" println!(\"s1: {s1}\");\n" -"```" #: src/structs/tuple-structs.md:14 msgid "This is often used for single-field wrappers (called newtypes):" msgstr "" +"Esto se suele utilizar para envoltorios de campo único (denominados " +"newtypes):" #: src/structs/tuple-structs.md:16 msgid "" @@ -7817,44 +7821,58 @@ msgid "" "Newtypes are a great way to encode additional information about the value in " "a primitive type, for example:" msgstr "" +"Los newtypes son una buena forma de codificar información adicional sobre el " +"valor de un tipo primitivo, por ejemplo:" #: src/structs/tuple-structs.md:38 msgid "The number is measured in some units: `Newtons` in the example above." msgstr "" +"El número se mide en algunas unidades: `Newtons` en el ejemplo anterior." #: src/structs/tuple-structs.md:39 msgid "" "The value passed some validation when it was created, so you no longer have " "to validate it again at every use: 'PhoneNumber(String)`or`OddNumber(u32)\\`." msgstr "" +"El valor ha pasado alguna validación cuando se ha creado, por lo que ya no " +"tendrás que volver a validarlo cada vez que lo uses: `PhoneNumber(String)` u " +"`OddNumber(u32)`." #: src/structs/tuple-structs.md:40 msgid "" "Demonstrate how to add a `f64` value to a `Newtons` type by accessing the " "single field in the newtype." msgstr "" +"Demuestra cómo se añade un valor `f64` a un tipo `Newtons` accediendo al " +"campo único del newtype." #: src/structs/tuple-structs.md:41 msgid "" "Rust generally doesn’t like inexplicit things, like automatic unwrapping or " "for instance using booleans as integers." msgstr "" +"Por lo general, a Rust no le gustan los elementos no explícitos, como el " +"desenvolvimiento automático o, por ejemplo, el uso de booleanos como enteros." #: src/structs/tuple-structs.md:42 msgid "Operator overloading is discussed on Day 3 (generics)." -msgstr "" +msgstr "El día 3 (genéricos), se explicará la sobrecarga del operador." #: src/structs/tuple-structs.md:43 msgid "" "The example is a subtle reference to the [Mars Climate Orbiter](https://en." "wikipedia.org/wiki/Mars_Climate_Orbiter) failure." msgstr "" +"El ejemplo es una sutil referencia al fracaso de la sonda [Mars Climate " +"Orbiter](https://es.wikipedia.org/wiki/Mars_Climate_Orbiter)." #: src/structs/field-shorthand.md:3 msgid "" "If you already have variables with the right names, then you can create the " "struct using a shorthand:" msgstr "" +"Si ya dispones de variables con los nombres adecuados, puedes crear la " +"estructura con un método abreviado:" #: src/structs/field-shorthand.md:6 msgid "" @@ -7883,6 +7901,8 @@ msgid "" "The `new` function could be written using `Self` as a type, as it is " "interchangeable with the struct type name" msgstr "" +"La función `new` se podría escribir utilizando `Self` como tipo, ya que es " +"intercambiable con el nombre de tipo de estructura." #: src/structs/field-shorthand.md:29 msgid "" @@ -7905,6 +7925,8 @@ msgid "" "Implement the `Default` trait for the struct. Define some fields and use the " "default values for the other fields." msgstr "" +"Implementa el trait `Default` en la estructura. Define algunos campos y usa " +"los valores predeterminados para el resto de los campos." #: src/structs/field-shorthand.md:43 msgid "" @@ -7936,24 +7958,31 @@ msgstr "" #: src/structs/field-shorthand.md:68 msgid "Methods are defined in the `impl` block." -msgstr "" +msgstr "Los métodos se definen en el bloque `impl`." #: src/structs/field-shorthand.md:69 msgid "" "Use struct update syntax to define a new structure using `peter`. Note that " "the variable `peter` will no longer be accessible afterwards." msgstr "" +"Utiliza la sintaxis de actualización de estructuras para definir una " +"estructura nueva con `peter`. Ten en cuenta que, después, ya no podrás " +"acceder a la variable `peter`." #: src/structs/field-shorthand.md:70 msgid "" "Use `{:#?}` when printing structs to request the `Debug` representation." msgstr "" +"Utiliza `{:#?}` al imprimir estructuras para solicitar la representación de " +"`Debug`." #: src/methods.md:3 msgid "" "Rust allows you to associate functions with your new types. You do this with " "an `impl` block:" msgstr "" +"Rust te permite asociar funciones a los nuevos tipos. Para ello, usa un " +"bloque `impl`:" #: src/methods.md:6 msgid "" @@ -7982,13 +8011,15 @@ msgstr "" #: src/methods.md:31 msgid "It can be helpful to introduce methods by comparing them to functions." -msgstr "" +msgstr "Puede resultar útil presentar los métodos comparándolos con funciones." #: src/methods.md:32 msgid "" "Methods are called on an instance of a type (such as a struct or enum), the " "first parameter represents the instance as `self`." msgstr "" +"Se llama a los métodos en una instancia de un tipo (como un estructura o una " +"enumeración) y el primer parámetro representa la instancia como `self`." #: src/methods.md:33 msgid "" @@ -7996,56 +8027,74 @@ msgid "" "syntax and to help keep them more organized. By using methods we can keep " "all the implementation code in one predictable place." msgstr "" +"Los desarrolladores pueden optar por utilizar métodos para aprovechar la " +"sintaxis de los receptores de métodos y para ayudar a mantenerlos más " +"organizados. Mediante el uso de métodos podemos mantener todo el código de " +"implementación en un lugar predecible." #: src/methods.md:34 msgid "Point out the use of the keyword `self`, a method receiver." -msgstr "" +msgstr "Señala el uso de la palabra clave `self`, receptor de un método. " #: src/methods.md:35 msgid "" "Show that it is an abbreviated term for `self: Self` and perhaps show how " "the struct name could also be used." msgstr "" +"Indica que se trata de un término abreviado de `self:&Self` y muestra cómo " +"se podría utilizar también el nombre de la estructura. " #: src/methods.md:36 msgid "" "Explain that `Self` is a type alias for the type the `impl` block is in and " "can be used elsewhere in the block." msgstr "" +"Explica que `Self` es un tipo de alias para el tipo en el que está el bloque " +"`impl` y que se puede usar en cualquier parte del bloque." #: src/methods.md:37 msgid "" "Note how `self` is used like other structs and dot notation can be used to " "refer to individual fields." msgstr "" +"Ten en cuenta que se puede usar `self` como otras estructuras y que la " +"notación de puntos puede utilizarse para referirse a campos concretos." #: src/methods.md:38 msgid "" "This might be a good time to demonstrate how the `&self` differs from `self` " "by modifying the code and trying to run say_hello twice." msgstr "" +"Puede ser un buen momento para mostrar la diferencia entre `&self` y `self` " +"modificando el código e intentando ejecutar say_hello dos veces." #: src/methods.md:39 msgid "We describe the distinction between method receivers next." -msgstr "" +msgstr "A continuación, se describe la diferencia entre receptores de métodos." #: src/methods/receiver.md:3 msgid "" "The `&self` above indicates that the method borrows the object immutably. " "There are other possible receivers for a method:" msgstr "" +"`&self` indica que el método toma prestado el objeto de forma inmutable. Hay " +"otros posibles receptores para un método:" #: src/methods/receiver.md:6 msgid "" "`&self`: borrows the object from the caller using a shared and immutable " "reference. The object can be used again afterwards." msgstr "" +"`&self`: toma prestado el objeto del llamador utilizando una referencia " +"compartida e inmutable. El objeto se puede volver a utilizar después." #: src/methods/receiver.md:8 msgid "" "`&mut self`: borrows the object from the caller using a unique and mutable " "reference. The object can be used again afterwards." msgstr "" +"`&mut self`: toma prestado el objeto del llamador mediante una referencia " +"única y mutable. El objeto se puede volver a utilizar después." #: src/methods/receiver.md:10 msgid "" @@ -8054,16 +8103,25 @@ msgid "" "(deallocated) when the method returns, unless its ownership is explicitly " "transmitted. Complete ownership does not automatically mean mutability." msgstr "" +"`self`: asume el _ownership_ del objeto y lo aleja del llamador. El método " +"se convierte en el propietario del objeto. El objeto se eliminará (es decir, " +"se anulará la asignación) cuando el método devuelva un resultado, a menos " +"que se transmita su _ownership_ de forma explícita. El _ownership_ completa " +"no implica automáticamente una mutabilidad." #: src/methods/receiver.md:14 msgid "`mut self`: same as above, but the method can mutate the object. " msgstr "" +"`mut self`: igual que lo anterior, pero el método puede mutar el objeto. " #: src/methods/receiver.md:15 msgid "" "No receiver: this becomes a static method on the struct. Typically used to " "create constructors which are called `new` by convention." msgstr "" +"Sin receptor: se convierte en un método estático de la estructura. " +"Normalmente se utiliza para crear constructores que se suelen denominar " +"`new`." #: src/methods/receiver.md:18 msgid "" @@ -8071,6 +8129,9 @@ msgid "" "doc.rust-lang.org/reference/special-types-and-traits.html) allowed to be " "receiver types, such as `Box`." msgstr "" +"Además de las variantes `self`, también hay [tipos de envoltorios especiales]" +"(https://doc.rust-lang.org/reference/special-types-and-traits.html) que " +"pueden ser tipos de receptor, como `Box`." #: src/methods/receiver.md:24 msgid "" @@ -8079,6 +8140,11 @@ msgid "" "and `self` is no exception. It isn't possible to reference a struct from " "multiple locations and call a mutating (`&mut self`) method on it." msgstr "" +"Considera recalcar los conceptos \"compartido e inmutable\" y \"único y " +"mutable\". Estas restricciones siempre vienen juntas en Rust debido a las " +"reglas del _borrow checker_, y `self` no es una excepción. No es posible " +"referenciar una estructura desde varias ubicaciones y llamar a un método " +"mutable (`&mut self`) en ella." #: src/methods/example.md:3 msgid "" @@ -8129,17 +8195,22 @@ msgstr "" #: src/methods/example.md:47 msgid "All four methods here use a different method receiver." msgstr "" +"Cada uno de estos cuatro métodos utilizan un receptor de método distinto." #: src/methods/example.md:48 msgid "" "You can point out how that changes what the function can do with the " "variable values and if/how it can be used again in `main`." msgstr "" +"Puedes indicar cómo eso cambia lo que la función puede hacer con los valores " +"de las variables y si se puede utilizar de nuevo en `main` y, en caso " +"afirmativo, cómo." #: src/methods/example.md:49 msgid "" "You can showcase the error that appears when trying to call `finish` twice." msgstr "" +"Puedes mostrar el error que aparece al intentar llamar a `finish` dos veces." #: src/methods/example.md:50 msgid "" @@ -8148,26 +8219,37 @@ msgid "" "referencing and dereferencing when calling methods. Rust automatically adds " "in the `&`, `*`, `muts` so that that object matches the method signature." msgstr "" +"Ten en cuenta que, aunque los receptores de los métodos sean diferentes, las " +"funciones no estáticas se llaman del mismo modo en el cuerpo principal. Rust " +"habilita la referenciación y desreferenciación automáticas al llamar a los " +"métodos. Además, añade automáticamente los caracteres `&`, `*` y `muts` para " +"que el objeto coincida con la firma del método." #: src/methods/example.md:51 msgid "" "You might point out that `print_laps` is using a vector that is iterated " "over. We describe vectors in more detail in the afternoon. " msgstr "" +"Podrías mencionar que `print_laps` está usando un vector sobre el que se " +"itera. Describiremos los vectores con más detalle por la tarde. " #: src/exercises/day-2/afternoon.md:1 msgid "Day 2: Afternoon Exercises" -msgstr "" +msgstr "Día 2: ejercicios de la tarde" #: src/exercises/day-2/afternoon.md:3 msgid "The exercises for this afternoon will focus on strings and iterators." msgstr "" +"Los ejercicios de esta tarde se centrarán en las cadenas y los iteradores." #: src/exercises/day-2/health-statistics.md:3 msgid "" "You're working on implementing a health-monitoring system. As part of that, " "you need to keep track of users' health statistics." msgstr "" +"Estás trabajando en la implementación de un sistema de monitorización de " +"salud. Por ello, debes realizar un seguimiento de las estadísticas de salud " +"de los usuarios." #: src/exercises/day-2/health-statistics.md:6 msgid "" @@ -8175,12 +8257,17 @@ msgid "" "`User` struct definition. Your goal is to implement the stubbed out methods " "on the `User` `struct` defined in the `impl` block." msgstr "" +"Comenzarás con algunas funciones stub en un bloque `impl`, así como con una " +"definición de estructura `User`. Tu objetivo es implementar métodos con " +"stubs en la `struct` `User` definida en el bloque `impl`." #: src/exercises/day-2/health-statistics.md:10 msgid "" "Copy the code below to and fill in the missing " "methods:" msgstr "" +"Copia el fragmento de código que aparece más abajo en la página y rellena los métodos que faltan:" #: src/exercises/day-2/health-statistics.md:13 msgid ""