\n"
-"Key points:"
-msgstr ""
-"(a: T, b: T) -> T {\n"
" if std::process::id() % 2 == 0 { a } else { b }\n"
-"}"
-msgstr ""
-"```rust,editable\n"
-"fn escolha_um(a: T, b: T) -> T {\n"
-" if std::process::id() % 2 == 0 { a } else { b }\n"
-"}"
-
-#: src/basic-syntax/functions-interlude.md:19
-msgid ""
+"}\n"
+"\n"
"fn main() {\n"
" println!(\"coin toss: {}\", pick_one(\"heads\", \"tails\"));\n"
" println!(\"cash prize: {}\", pick_one(500, 1000));\n"
@@ -2942,10 +3075,6 @@ msgstr ""
"* Ao usar generics, o `Into` da biblioteca padrão pode fornecer um tipo polimórfico\n"
" limitado nos tipos do argumento. Veremos mais detalhes em uma seção posterior."
-#: src/basic-syntax/functions-interlude.md:30
-msgid ""
-msgstr ""
-
#: src/exercises/day-1/morning.md:1
msgid "# Day 1: Morning Exercises"
msgstr "# Dia 1: Exercícios matinais"
@@ -2955,31 +3084,30 @@ msgid "In these exercises, we will explore two parts of Rust:"
msgstr "Nestes exercícios, exploraremos duas partes do Rust:"
#: src/exercises/day-1/morning.md:5
-msgid "* Implicit conversions between types."
+#, fuzzy
+msgid ""
+"* Implicit conversions between types.\n"
+"\n"
+"* Arrays and `for` loops."
msgstr "* Conversões implícitas entre tipos."
-#: src/exercises/day-1/morning.md:7
-msgid "* Arrays and `for` loops."
-msgstr "* Vetores e laços `for`."
-
#: src/exercises/day-1/morning.md:11
msgid "A few things to consider while solving the exercises:"
msgstr "Algumas coisas a considerar ao resolver os exercícios:"
#: src/exercises/day-1/morning.md:13
+#, fuzzy
msgid ""
"* Use a local Rust installation, if possible. This way you can get\n"
" auto-completion in your editor. See the page about [Using Cargo] for details\n"
-" on installing Rust."
+" on installing Rust.\n"
+"\n"
+"* Alternatively, use the Rust Playground."
msgstr ""
"* Se possível, use uma instalação local do Rust. Desta forma, você pode obter\n"
" preenchimento automático em seu editor. Veja a página sobre [Utilização do Cargo] para detalhes\n"
" sobre instalação do Rust."
-#: src/exercises/day-1/morning.md:17
-msgid "* Alternatively, use the Rust Playground."
-msgstr "* Como alternativa, use o Rust Playground."
-
#: src/exercises/day-1/morning.md:19
msgid ""
"The code snippets are not editable on purpose: the inline code snippets lose\n"
@@ -2988,20 +3116,15 @@ msgstr ""
"Os trechos de código não são editáveis de propósito: os trechos de código embutidos perdem\n"
"seu estado se você sair da página."
-#: src/exercises/day-1/morning.md:22 src/exercises/day-1/afternoon.md:11 src/exercises/day-2/morning.md:11
-#: src/exercises/day-2/afternoon.md:7 src/exercises/day-3/morning.md:7 src/exercises/day-4/morning.md:12
+#: src/exercises/day-1/morning.md:22 src/exercises/day-1/afternoon.md:11
+#: src/exercises/day-2/morning.md:11 src/exercises/day-2/afternoon.md:7
+#: src/exercises/day-3/morning.md:7 src/exercises/bare-metal/morning.md:7
+#: src/exercises/bare-metal/afternoon.md:7
+#: src/exercises/concurrency/morning.md:12
+#: src/exercises/concurrency/afternoon.md:13
msgid "After looking at the exercises, you can look at the [solutions] provided."
msgstr "Depois de ver os exercícios, você pode ver as [soluções] fornecidas."
-#: src/exercises/day-1/morning.md:24 src/exercises/day-2/morning.md:13 src/exercises/day-3/morning.md:9
-#: src/exercises/day-4/morning.md:14
-msgid "[solutions]: solutions-morning.md"
-msgstr "[soluções]: solutions-morning.md"
-
-#: src/exercises/day-1/morning.md:26
-msgid "[Using Cargo]: ../../cargo.md"
-msgstr "[Utilização do Cargo]: ../../cargo.md"
-
#: src/exercises/day-1/implicit-conversions.md:1
msgid "# Implicit Conversions"
msgstr "# Conversões implícitas"
@@ -3015,26 +3138,29 @@ msgstr ""
"De C++][3]). Você pode ver isso em um programa como este:"
#: src/exercises/day-1/implicit-conversions.md:6
+#, fuzzy
msgid ""
"```rust,editable,compile_fail\n"
"fn multiply(x: i16, y: i16) -> i16 {\n"
" x * y\n"
-"}"
-msgstr ""
-
-#: src/exercises/day-1/implicit-conversions.md:11
-msgid ""
+"}\n"
+"\n"
"fn main() {\n"
" let x: i8 = 15;\n"
-" let y: i16 = 1000;"
-msgstr ""
-
-#: src/exercises/day-1/implicit-conversions.md:15
-msgid ""
+" let y: i16 = 1000;\n"
+"\n"
" println!(\"{x} * {y} = {}\", multiply(x, y));\n"
"}\n"
"```"
msgstr ""
+"```rust, editable\n"
+"fn main() {\n"
+" let x = 42;\n"
+" let y = x;\n"
+" println!(\"x: {x}\");\n"
+" println!(\"y: {y}\");\n"
+"}\n"
+"```"
#: src/exercises/day-1/implicit-conversions.md:19
msgid ""
@@ -3071,15 +3197,12 @@ msgstr ""
"suficiente implementar apenas `From` para obter uma respectiva implementação `Into` automaticamente."
#: src/exercises/day-1/implicit-conversions.md:33
-msgid "1. Execute the above program and look at the compiler error."
-msgstr "1. Execute o programa acima e observe o erro do compilador."
-
-#: src/exercises/day-1/implicit-conversions.md:35
-msgid "2. Update the code above to use `into()` to do the conversion."
-msgstr "2. Atualize o código acima para usar `into()` para fazer a conversão."
-
-#: src/exercises/day-1/implicit-conversions.md:37
+#, fuzzy
msgid ""
+"1. Execute the above program and look at the compiler error.\n"
+"\n"
+"2. Update the code above to use `into()` to do the conversion.\n"
+"\n"
"3. Change the types of `x` and `y` to other things (such as `f32`, `bool`,\n"
" `i128`) to see which types you can convert to which other types. Try\n"
" converting small types to big types and the other way around. Check the\n"
@@ -3092,16 +3215,6 @@ msgstr ""
" [documentação da biblioteca padrão][1] para ver se `From` está implementado para\n"
" os pares que você verifica."
-#: src/exercises/day-1/implicit-conversions.md:43
-msgid ""
-"[1]: https://doc.rust-lang.org/std/convert/trait.From.html\n"
-"[2]: https://doc.rust-lang.org/std/convert/trait.Into.html\n"
-"[3]: https://en.cppreference.com/w/cpp/language/implicit_conversion"
-msgstr ""
-"[1]: https://doc.rust-lang.org/std/convert/trait.From.html\n"
-"[2]: https://doc.rust-lang.org/std/convert/trait.Into.html\n"
-"[3]: https://en.cppreference.com/w/cpp/language/implicit_conversion"
-
#: src/exercises/day-1/for-loops.md:1
msgid "# Arrays and `for` Loops"
msgstr "# Vetores e laços `for`"
@@ -3149,6 +3262,7 @@ msgstr ""
":"
#: src/exercises/day-1/for-loops.md:21
+#, fuzzy
msgid ""
"```rust,editable\n"
"fn main() {\n"
@@ -3157,7 +3271,15 @@ msgid ""
" for n in array {\n"
" print!(\" {n}\");\n"
" }\n"
-" println!();"
+" println!();\n"
+"\n"
+" print!(\"Iterating over range:\");\n"
+" for i in 0..3 {\n"
+" print!(\" {}\", array[i]);\n"
+" }\n"
+" println!();\n"
+"}\n"
+"```"
msgstr ""
"```rust,editable\n"
"fn main() {\n"
@@ -3168,24 +3290,6 @@ msgstr ""
" }\n"
" println!();"
-#: src/exercises/day-1/for-loops.md:30
-msgid ""
-" print!(\"Iterating over range:\");\n"
-" for i in 0..3 {\n"
-" print!(\" {}\", array[i]);\n"
-" }\n"
-" println!();\n"
-"}\n"
-"```"
-msgstr ""
-" print!(\"Interagindo sobre uma faixa:\");\n"
-" for i in 0..3 {\n"
-" print!(\" {}\", vetor[i]);\n"
-" }\n"
-" println!();\n"
-"}\n"
-"```"
-
#: src/exercises/day-1/for-loops.md:38
msgid ""
"Use the above to write a function `pretty_print` which pretty-print a matrix and\n"
@@ -3197,9 +3301,9 @@ msgstr ""
#: src/exercises/day-1/for-loops.md:41
msgid ""
"```bob\n"
-" ⎛⎡1 2 3⎤⎞ ⎡1 4 7⎤\n"
-"\"transpose\" ⎜⎢4 5 6⎥⎟ \"==\" ⎢2 5 8⎥\n"
-" ⎝⎣7 8 9⎦⎠ ⎣3 6 9⎦\n"
+" ⎛⎡1 2 3⎤⎞ ⎡1 4 7⎤\n"
+"\"transpose\"⎜⎢4 5 6⎥⎟ \"==\"⎢2 5 8⎥\n"
+" ⎝⎣7 8 9⎦⎠ ⎣3 6 9⎦\n"
"```"
msgstr ""
@@ -3215,70 +3319,36 @@ msgstr ""
"Copie o código abaixo para >();\n"
" println!(\"vv: {vv:?}\");\n"
"}\n"
"```"
msgstr ""
+"```rust, editable\n"
+"fn main() {\n"
+" let mut vetor = vec![10, 20];\n"
+" vetor.push(30);\n"
+" println!(\"valor do meio: {}\", vetor[vetor.len() / 2]);\n"
+" for item in vetor.iter() {\n"
+" println!(\"item: {item}\");\n"
+" }\n"
+"}\n"
+"```"
#: src/basic-syntax/type-inference.md:46
-msgid ""
-"[`collect`](https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.collect) relies on `FromIterator`, which "
-"[`HashSet`](https://doc.rust-lang.org/std/iter/trait.FromIterator.html) implements."
-msgstr ""
-"[`collect`](https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.collect) depende de `FromIterator`, que "
-"[`HashSet`](https:/ /doc.rust-lang.org/std/iter/trait.FromIterator.html) implementa."
+msgid "[`collect`](https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.collect) relies on `FromIterator`, which [`HashSet`](https://doc.rust-lang.org/std/iter/trait.FromIterator.html) implements."
+msgstr "[`collect`](https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.collect) depende de `FromIterator`, que [`HashSet`](https:/ /doc.rust-lang.org/std/iter/trait.FromIterator.html) implementa."
#: src/basic-syntax/static-and-const.md:1
msgid "# Static and Constant Variables"
@@ -3463,22 +3513,16 @@ msgstr "Você pode declarar constantes de tempo de compilação:"
msgid ""
"```rust,editable\n"
"const DIGEST_SIZE: usize = 3;\n"
-"const ZERO: Option = Some(42);"
-msgstr ""
-
-#: src/basic-syntax/static-and-const.md:13
-msgid ""
+"const ZERO: Option = Some(42);\n"
+"\n"
"fn compute_digest(text: &str) -> [u8; DIGEST_SIZE] {\n"
" let mut digest = [ZERO.unwrap_or(0); DIGEST_SIZE];\n"
" for (idx, &b) in text.as_bytes().iter().enumerate() {\n"
" digest[idx % DIGEST_SIZE] = digest[idx % DIGEST_SIZE].wrapping_add(b);\n"
" }\n"
" digest\n"
-"}"
-msgstr ""
-
-#: src/basic-syntax/static-and-const.md:21
-msgid ""
+"}\n"
+"\n"
"fn main() {\n"
" let digest = compute_digest(\"Hello\");\n"
" println!(\"Digest: {digest:?}\");\n"
@@ -3487,7 +3531,8 @@ msgid ""
msgstr ""
#: src/basic-syntax/static-and-const.md:27
-msgid "According the the [Rust RFC Book][1] these are inlined upon use."
+#, fuzzy
+msgid "According to the [Rust RFC Book][1] these are inlined upon use."
msgstr "De acordo com o [Rust RFC Book][1], eles são expandidos no próprio local (inline) após o uso."
#: src/basic-syntax/static-and-const.md:29
@@ -3499,29 +3544,22 @@ msgid "You can also declare static variables:"
msgstr "Você também pode declarar variáveis estáticas:"
#: src/basic-syntax/static-and-const.md:33
+#, fuzzy
msgid ""
"```rust,editable\n"
-"static BANNER: &str = \"Welcome to RustOS 3.14\";"
-msgstr ""
-"```rust, editable\n"
-"static BANNER: &str = \"Bem-vindo ao RustOS 3.14\";"
-
-#: src/basic-syntax/static-and-const.md:36
-msgid ""
+"static BANNER: &str = \"Welcome to RustOS 3.14\";\n"
+"\n"
"fn main() {\n"
" println!(\"{BANNER}\");\n"
"}\n"
"```"
msgstr ""
+"```rust, editable\n"
+"static BANNER: &str = \"Bem-vindo ao RustOS 3.14\";"
#: src/basic-syntax/static-and-const.md:41
-msgid ""
-"As noted in the [Rust RFC Book][1], these are not inlined upon use and have an actual associated memory location. This is "
-"useful for unsafe and embedded code, and the variable lives through the entirety of the program execution."
-msgstr ""
-"Conforme observado no [Rust RFC Book][1], `static` e `const` não são expandidos em linha (inlined) quando utilizados e "
-"possuem um local de memória real associado. Isso é útil para código inseguro e embarcado, e a variável sobrevive durante "
-"toda a execução do programa."
+msgid "As noted in the [Rust RFC Book][1], these are not inlined upon use and have an actual associated memory location. This is useful for unsafe and embedded code, and the variable lives through the entirety of the program execution."
+msgstr "Conforme observado no [Rust RFC Book][1], `static` e `const` não são expandidos em linha (inlined) quando utilizados e possuem um local de memória real associado. Isso é útil para código inseguro e embarcado, e a variável sobrevive durante toda a execução do programa."
#: src/basic-syntax/static-and-const.md:44
msgid "We will look at mutating static data in the [chapter on Unsafe Rust](../unsafe.md)."
@@ -3535,12 +3573,7 @@ msgid ""
msgstr ""
"* Mencione que `const` se comporta semanticamente similar ao `constexpr` de C++.\n"
"* `static`, por outro lado, é muito mais parecido com um `const` ou variável global mutável em C++.\n"
-"* Não é muito comum que alguém precise de uma constante avaliada em tempo de execução, mas é útil e mais seguro do que usar "
-"uma estática."
-
-#: src/basic-syntax/static-and-const.md:54
-msgid "[1]: https://rust-lang.github.io/rfcs/0246-const-vs-static.html"
-msgstr "[1]: https://rust-lang.github.io/rfcs/0246-const-vs-static.html"
+"* Não é muito comum que alguém precise de uma constante avaliada em tempo de execução, mas é útil e mais seguro do que usar uma estática."
#: src/basic-syntax/scopes-shadowing.md:1
msgid "# Scopes and Shadowing"
@@ -3555,62 +3588,55 @@ msgstr ""
"mesmo escopo:"
#: src/basic-syntax/scopes-shadowing.md:6
+#, fuzzy
msgid ""
"```rust,editable\n"
"fn main() {\n"
" let a = 10;\n"
-" println!(\"before: {a}\");"
-msgstr ""
-"```rust,editable\n"
-"fn main() {\n"
-" let a = 10;\n"
-" println!(\"Antes: {a}\");"
-
-#: src/basic-syntax/scopes-shadowing.md:11
-msgid ""
+" println!(\"before: {a}\");\n"
+"\n"
" {\n"
" let a = \"hello\";\n"
-" println!(\"inner scope: {a}\");"
-msgstr ""
-" {\n"
-" let a = \"Olá\";\n"
-" println!(\"Escopo interno: {a}\");"
-
-#: src/basic-syntax/scopes-shadowing.md:15
-msgid ""
+" println!(\"inner scope: {a}\");\n"
+"\n"
" let a = true;\n"
" println!(\"shadowed in inner scope: {a}\");\n"
-" }"
-msgstr ""
-" let a = true;\n"
-" println!(\"Sobreposição no escopo interno: {a}\");\n"
-" }"
-
-#: src/basic-syntax/scopes-shadowing.md:19
-msgid ""
+" }\n"
+"\n"
" println!(\"after: {a}\");\n"
"}\n"
"```"
msgstr ""
-" println!(\"Depois: {a}\");\n"
+"```rust, editable\n"
+"fn main() {\n"
+" let x = {\n"
+" let y = 10;\n"
+" println!(\"y: {y}\");\n"
+" let z = {\n"
+" let w = {\n"
+" 3 + 4\n"
+" };\n"
+" println!(\"w: {w}\");\n"
+" y * w\n"
+" };\n"
+" println!(\"z: {z}\");\n"
+" z - y\n"
+" };\n"
+" println!(\"x: {x}\");\n"
"}\n"
"```"
#: src/basic-syntax/scopes-shadowing.md:25
msgid ""
-"* Definition: Shadowing is different from mutation, because after shadowing both variable's memory locations exist at the "
-"same time. Both are available under the same name, depending where you use it in the code. \n"
+"* Definition: Shadowing is different from mutation, because after shadowing both variable's memory locations exist at the same time. Both are available under the same name, depending where you use it in the code. \n"
"* A shadowing variable can have a different type. \n"
"* Shadowing looks obscure at first, but is convenient for holding on to values after `.unwrap()`.\n"
-"* The following code demonstrates why the compiler can't simply reuse memory locations when shadowing an immutable variable "
-"in a scope, even if the type does not change."
+"* The following code demonstrates why the compiler can't simply reuse memory locations when shadowing an immutable variable in a scope, even if the type does not change."
msgstr ""
-"* Definição: A sobreposição é diferente da mutação, porque após a sobreposição, os locais de memória de ambas as variáveis "
-"existem ao mesmo tempo. Ambos estão disponíveis com o mesmo nome, dependendo de onde você os usa no código.\n"
+"* Definição: A sobreposição é diferente da mutação, porque após a sobreposição, os locais de memória de ambas as variáveis existem ao mesmo tempo. Ambos estão disponíveis com o mesmo nome, dependendo de onde você os usa no código.\n"
"* Uma variável sobreposta pode ter um tipo diferente.\n"
"* A sobreposição parece obscura a princípio, mas é conveniente para manter os valores após `.unwrap()`.\n"
-"* O código a seguir demonstra por que o compilador não pode simplesmente reutilizar locais de memória ao sobrepor uma "
-"variável imutável em um escopo, mesmo que o tipo não seja alterado."
+"* O código a seguir demonstra por que o compilador não pode simplesmente reutilizar locais de memória ao sobrepor uma variável imutável em um escopo, mesmo que o tipo não seja alterado."
#: src/basic-syntax/scopes-shadowing.md:30
msgid ""
@@ -3665,12 +3691,18 @@ msgid "# The Stack vs The Heap"
msgstr "# Stack (pilha) vs Heap"
#: src/memory-management/stack-vs-heap.md:3
+#, fuzzy
msgid ""
"* Stack: Continuous area of memory for local variables.\n"
" * Values have fixed sizes known at compile time.\n"
" * Extremely fast: just move a stack pointer.\n"
" * Easy to manage: follows function calls.\n"
-" * Great memory locality."
+" * Great memory locality.\n"
+"\n"
+"* Heap: Storage of values outside of function calls.\n"
+" * Values have dynamic sizes determined at runtime.\n"
+" * Slightly slower than the stack: some book-keeping needed.\n"
+" * No guarantee of memory locality."
msgstr ""
"* Stack: Área contínua de memória para variáveis locais.\n"
" * Os valores têm tamanhos fixos conhecidos em tempo de compilação.\n"
@@ -3678,18 +3710,6 @@ msgstr ""
" * Fácil de gerenciar: segue chamadas de função.\n"
" * Ótima localização na memória."
-#: src/memory-management/stack-vs-heap.md:9
-msgid ""
-"* Heap: Storage of values outside of function calls.\n"
-" * Values have dynamic sizes determined at runtime.\n"
-" * Slightly slower than the stack: some book-keeping needed.\n"
-" * No guarantee of memory locality."
-msgstr ""
-"* Heap: Armazenamento de valores fora das chamadas de função.\n"
-" * Os valores têm tamanhos dinâmicos determinados em tempo de execução.\n"
-" * Ligeiramente mais lento que o stack: é necessária alguma contabilidade.\n"
-" * Sem garantia de localização na memória."
-
#: src/memory-management/stack.md:1
msgid "# Stack Memory"
msgstr "# Memória de pilha (stack Memory)"
@@ -3712,9 +3732,10 @@ msgid ""
msgstr ""
#: src/memory-management/stack.md:12
+#, fuzzy
msgid ""
"```bob\n"
-" Stack Heap\n"
+" Stack Heap\n"
".- - - - - - - - - - - - - -. .- - - - - - - - - - - - - - - -.\n"
": : : :\n"
": s1 : : :\n"
@@ -3742,41 +3763,28 @@ msgstr ""
"```"
#: src/memory-management/stack.md:28
+#, fuzzy
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 ""
-"* Mencione que um `String` é baseada em um `Vec`, então ele tem capacidade e comprimento e pode crescer se for mutável por "
-"meio de realocação no heap."
-
-#: src/memory-management/stack.md:30
-msgid ""
-"* If students ask about it, you can mention that the underlying memory is heap allocated using the [System Allocator] and "
-"custom allocators can be implemented using the [Allocator API]"
-msgstr ""
-"* Se os alunos perguntarem sobre isso, você pode mencionar que a memória do heap é alocada usando o [System Allocator] e "
-"alocadores personalizados podem ser implementados usando a [Allocator API]"
-
-#: 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 "* Pode-se inspecionar o layout de memória com código `unsafe`. Entretanto, deve-se salientar que isto é inseguro!"
-
-#: src/memory-management/stack.md:34
-msgid ""
-"```rust,editable\n"
-"fn main() {\n"
-" let mut s1 = String::from(\"Hello\");\n"
-" s1.push(' ');\n"
-" s1.push_str(\"world\");\n"
-" // DON'T DO THIS AT HOME! For educational purposes only.\n"
-" // String provides no guarantees about its layout, so this could lead to\n"
-" // undefined behavior.\n"
-" unsafe {\n"
-" let (capacity, ptr, len): (usize, usize, usize) = std::mem::transmute(s1);\n"
-" println!(\"ptr = {ptr:#x}, len = {len}, capacity = {capacity}\");\n"
+"* 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.\n"
+"\n"
+"* If students ask about it, you can mention that the underlying memory is heap allocated using the [System Allocator] and custom allocators can be implemented using the [Allocator API]\n"
+"\n"
+"* We can inspect the memory layout with `unsafe` code. However, you should point out that this is rightfully unsafe!\n"
+"\n"
+" ```rust,editable\n"
+" fn main() {\n"
+" let mut s1 = String::from(\"Hello\");\n"
+" s1.push(' ');\n"
+" s1.push_str(\"world\");\n"
+" // DON'T DO THIS AT HOME! For educational purposes only.\n"
+" // String provides no guarantees about its layout, so this could lead to\n"
+" // undefined behavior.\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"
-"}\n"
-"```"
+" ```"
msgstr ""
"```rust,editable\n"
"fn main() {\n"
@@ -3793,14 +3801,6 @@ msgstr ""
"}\n"
"```"
-#: src/memory-management/stack.md:51
-msgid ""
-"[System Allocator]: https://doc.rust-lang.org/std/alloc/struct.System.html\n"
-"[Allocator API]: https://doc.rust-lang.org/std/alloc/index.html"
-msgstr ""
-"[System Allocator]: https://doc.rust-lang.org/std/alloc/struct.System.html\n"
-"[Allocator API]: https://doc.rust-lang.org/std/alloc/index.html"
-
#: src/memory-management/manual.md:1
msgid "# Manual Memory Management"
msgstr "# Gerenciamento manual de memória"
@@ -3811,8 +3811,7 @@ msgstr "Você mesmo aloca e desaloca memória no 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 ""
-"Se não for feito com cuidado, isso pode levar a travamentos, bugs, vulnerabilidades de segurança e vazamentos de memória."
+msgstr "Se não for feito com cuidado, isso pode levar a travamentos, bugs, vulnerabilidades de segurança e vazamentos de memória."
#: src/memory-management/manual.md:7
msgid "## C Example"
@@ -3866,8 +3865,7 @@ msgid ""
"This is often called _resource acquisition is initialization_ (RAII) and gives\n"
"you smart pointers."
msgstr ""
-"Isso geralmente é chamado de _aquisição de recursos é inicialização_ (resource acquisition is initialization, RAII) e "
-"fornece\n"
+"Isso geralmente é chamado de _aquisição de recursos é inicialização_ (resource acquisition is initialization, RAII) e fornece\n"
"ponteiros inteligentes."
#: src/memory-management/scope-based.md:12
@@ -3965,14 +3963,12 @@ msgstr "O gerenciamento de memória no Rust é uma mistura:"
#: src/memory-management/rust.md:5
msgid ""
"* Safe and correct like Java, but without a garbage collector.\n"
-"* Depending on which abstraction (or combination of abstractions) you choose, can be a single unique pointer, reference "
-"counted, or atomically reference counted.\n"
+"* Depending on which abstraction (or combination of abstractions) you choose, can be a single unique pointer, reference counted, or atomically reference counted.\n"
"* Scope-based like C++, but the compiler enforces full adherence.\n"
"* A Rust user can choose the right abstraction for the situation, some even have no cost at runtime like C."
msgstr ""
"* Seguro e correto como Java, mas sem coletor de lixo.\n"
-"* Dependendo de qual abstração (ou combinação de abstrações) você escolher, pode ser um simples ponteiro único, referência "
-"contada ou referência atomicamente contada.\n"
+"* Dependendo de qual abstração (ou combinação de abstrações) você escolher, pode ser um simples ponteiro único, referência contada ou referência atomicamente contada.\n"
"* Baseado em escopo como C++, mas o compilador impõe adesão total.\n"
"* Um usuário do Rust pode escolher a abstração certa para a situação, algumas até sem custo em tempo de execução como C."
@@ -3981,31 +3977,12 @@ msgid "It achieves this by modeling _ownership_ explicitly."
msgstr "Ele consegue isso modelando a propriedade (_ownership_) explicitamente."
#: src/memory-management/rust.md:14
+#, fuzzy
msgid ""
-"* If asked how at this point, you can mention that in Rust this is usually handled by RAII wrapper types such as [Box], "
-"[Vec], [Rc], or [Arc]. These encapsulate ownership and memory allocation via various means, and prevent the potential "
-"errors in C."
-msgstr ""
-"* Neste ponto, se perguntado como, você pode mencionar que em Rust isso geralmente é tratado por wrappers RAII como [Box], "
-"[Vec], [Rc] ou [Arc]. Eles encapsulam a propriedade (ownership) e a alocação de memória por vários meios e evitam possíveis erros em C."
-
-#: src/memory-management/rust.md:16
-msgid "* You may be asked about destructors here, the [Drop] trait is the Rust equivalent."
-msgstr "* Você pode ser questionado sobre destrutores aqui, o trait [Drop] é o equivalente em Rust."
-
-#: src/memory-management/rust.md:20
-msgid ""
-"[Box]: https://doc.rust-lang.org/std/boxed/struct.Box.html\n"
-"[Vec]: https://doc.rust-lang.org/std/vec/struct.Vec.html\n"
-"[Rc]: https://doc.rust-lang.org/std/rc/struct.Rc.html\n"
-"[Arc]: https://doc.rust-lang.org/std/sync/struct.Arc.html\n"
-"[Drop]: https://doc.rust-lang.org/std/ops/trait.Drop.html"
-msgstr ""
-"[Box]: https://doc.rust-lang.org/std/boxed/struct.Box.html\n"
-"[Vec]: https://doc.rust-lang.org/std/vec/struct.Vec.html\n"
-"[Rc]: https://doc.rust-lang.org/std/rc/struct.Rc.html\n"
-"[Arc]: https://doc.rust-lang.org/std/sync/struct.Arc.html\n"
-"[Drop]: https://doc.rust-lang.org/std/ops/trait.Drop.html"
+"* If asked how at this point, you can mention that in Rust this is usually handled by RAII wrapper types such as [Box], [Vec], [Rc], or [Arc]. These encapsulate ownership and memory allocation via various means, and prevent the potential errors in C.\n"
+"\n"
+"* You may be asked about destructors here, the [Drop] trait is the Rust equivalent."
+msgstr "* Neste ponto, se perguntado como, você pode mencionar que em Rust isso geralmente é tratado por wrappers RAII como [Box], [Vec], [Rc] ou [Arc]. Eles encapsulam a propriedade (ownership) e a alocação de memória por vários meios e evitam possíveis erros em C."
#: src/memory-management/comparison.md:1
msgid "# Comparison"
@@ -4094,15 +4071,11 @@ msgstr ""
"usar uma variável fora de seu escopo:"
#: src/ownership.md:6
+#, fuzzy
msgid ""
"```rust,editable,compile_fail\n"
-"struct Point(i32, i32);"
-msgstr ""
-"```rust,editable,compile_fail\n"
-"struct Ponto(i32, i32);"
-
-#: src/ownership.md:9
-msgid ""
+"struct Point(i32, i32);\n"
+"\n"
"fn main() {\n"
" {\n"
" let p = Point(3, 4);\n"
@@ -4174,16 +4147,12 @@ msgstr ""
"* Há sempre _exatamente_ uma associação de variável que possui um valor."
#: src/ownership/move-semantics.md:22
+#, fuzzy
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 ""
-"* Mencione que isso é o oposto dos padrões em C++, que copia por valor, a menos que você use `std::move` (e o construtor de "
-"movimento esteja definido!)."
-
-#: src/ownership/move-semantics.md:24
-msgid "* In Rust, you clones are explicit (by using `clone`)."
-msgstr "* No Rust, clones são explícitos (usando `clone`)."
+"* 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!).\n"
+"\n"
+"* In Rust, clones are explicit (by using `clone`)."
+msgstr "* Mencione que isso é o oposto dos padrões em C++, que copia por valor, a menos que você use `std::move` (e o construtor de movimento esteja definido!)."
#: src/ownership/moved-strings-rust.md:1
msgid "# Moved Strings in Rust"
@@ -4249,12 +4218,13 @@ msgid "After move to `s2`:"
msgstr "Depois de mover para `s2`:"
#: src/ownership/moved-strings-rust.md:32
+#, fuzzy
msgid ""
"```bob\n"
" Stack Heap\n"
".- - - - - - - - - - - - - -. .- - - - - - - - - - - - - -.\n"
": : : :\n"
-": s1 \"(inaccessible)\" : : :\n"
+": s1 \"(inaccessible)\" : : :\n"
": +-----------+-------+ : : +----+----+----+----+ :\n"
": | ptr | o---+---+--+--+-->| R | u | s | t | :\n"
": | len | 4 | : | : +----+----+----+----+ :\n"
@@ -4325,7 +4295,6 @@ msgid "Before copy-assignment:"
msgstr "Antes da atribuição por cópias:"
#: src/ownership/double-free-modern-cpp.md:16
-#, fuzzy
msgid ""
"```bob\n"
" Stack Heap\n"
@@ -4347,7 +4316,6 @@ msgid "After copy-assignment:"
msgstr "Após atribuição por cópia:"
#: src/ownership/double-free-modern-cpp.md:32
-#, fuzzy
msgid ""
"```bob\n"
" Stack Heap\n"
@@ -4384,19 +4352,13 @@ msgstr ""
"da função. Isso transfere a ownership:"
#: src/ownership/moves-function-calls.md:6
+#, fuzzy
msgid ""
"```rust,editable\n"
"fn say_hello(name: String) {\n"
" println!(\"Hello {name}\")\n"
-"}"
-msgstr ""
-"```rust,editable\n"
-"fn diz_ola(nome: String) {\n"
-" println!(\"Olá {nome}\")\n"
-"}"
-
-#: src/ownership/moves-function-calls.md:11
-msgid ""
+"}\n"
+"\n"
"fn main() {\n"
" let name = String::from(\"Alice\");\n"
" say_hello(name);\n"
@@ -4413,23 +4375,17 @@ msgstr ""
#: src/ownership/moves-function-calls.md:20
msgid ""
-"* With the first call to `say_hello`, `main` gives up ownership of `name`. Afterwards, `name` cannot be used anymore within "
-"`main`.\n"
+"* With the first call to `say_hello`, `main` gives up ownership of `name`. Afterwards, `name` cannot be used anymore within `main`.\n"
"* The heap memory allocated for `name` will be freed at the end of the `say_hello` function.\n"
-"* `main` can retain ownership if it passes `name` as a reference (`&name`) and if `say_hello` accepts a reference as a "
-"parameter.\n"
+"* `main` can retain ownership if it passes `name` as a reference (`&name`) and if `say_hello` accepts a reference as a parameter.\n"
"* Alternatively, `main` can pass a clone of `name` in the first call (`name.clone()`).\n"
-"* Rust makes it harder than C++ to inadvertently create copies by making move semantics the default, and by forcing "
-"programmers to make clones explicit."
+"* 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 ""
-"* Com a primeira chamada para `say_hello`, `main` desiste da ownership de `name`. Depois disso, `name` não pode mais ser "
-"usado dentro de `main`.\n"
+"* Com a primeira chamada para `say_hello`, `main` desiste da ownership de `name`. Depois disso, `name` não pode mais ser usado dentro de `main`.\n"
"* A memória heap alocada para `name` será liberada no final da função `say_hello`.\n"
-"* `main` pode manter a ownership se passar `name` como uma referência (`&name`) e se `say_hello` aceitar uma referência "
-"como um parâmetro.\n"
+"* `main` pode manter a ownership se passar `name` como uma referência (`&name`) e se `say_hello` aceitar uma referência como um parâmetro.\n"
"* Alternativamente, `main` pode passar um clone de `name` na primeira chamada (`name.clone()`).\n"
-"* Rust torna mais difícil do que o C++ a criação de cópias inadvertidamente, tornando a semântica de movimento o padrão e forçando "
-"os programadores a tornar os clones explícitos."
+"* Rust torna mais difícil do que o C++ a criação de cópias inadvertidamente, tornando a semântica de movimento o padrão e forçando os programadores a tornar os clones explícitos."
#: src/ownership/copy-clone.md:1
msgid "# Copying and Cloning"
@@ -4468,17 +4424,12 @@ msgid "You can opt-in your own types to use copy semantics:"
msgstr "Você pode ativar seus próprios tipos para usar a semântica de cópia:"
#: src/ownership/copy-clone.md:18
+#, fuzzy
msgid ""
"```rust,editable\n"
"#[derive(Copy, Clone, Debug)]\n"
-"struct Point(i32, i32);"
-msgstr ""
-"```rust, editable\n"
-"#[derive(Copy, Clone, Debug)]\n"
-"struct Ponto(i32, i32);"
-
-#: src/ownership/copy-clone.md:22
-msgid ""
+"struct Point(i32, i32);\n"
+"\n"
"fn main() {\n"
" let p1 = Point(3, 4);\n"
" let p2 = p1;\n"
@@ -4534,11 +4485,10 @@ msgstr ""
"* Mostre que funciona se você clonar `p1` em vez disso."
#: src/ownership/copy-clone.md:48
+#, fuzzy
msgid ""
"If students ask about `derive`, it is sufficient to say that this is a way to generate code in Rust\n"
-"at compile time. In this case the default implementations of `Copy` and `Clone` traits are generated.\n"
-" \n"
-"
"
+"at compile time. In this case the default implementations of `Copy` and `Clone` traits are generated."
msgstr ""
"Se os alunos perguntarem sobre `derive`, basta dizer que esta é uma forma de gerar código em Rust\n"
"em tempo de compilação. Nesse caso, as implementações padrão dos traits `Copy` e `Clone` são geradas.\n"
@@ -4557,28 +4507,17 @@ msgstr ""
"Em vez de transferir a ownership ao chamar uma função, você pode permitir que uma\n"
"função _empreste_ o valor:"
-#: src/ownership/borrowing.md:6 src/ownership/lifetimes-function-calls.md:5
+#: src/ownership/borrowing.md:6
+#, fuzzy
msgid ""
"```rust,editable\n"
"#[derive(Debug)]\n"
-"struct Point(i32, i32);"
-msgstr ""
-"```rust, editable\n"
-"#[derive(Debug)]\n"
-"struct Ponto(i32, i32);"
-
-#: src/ownership/borrowing.md:10
-msgid ""
+"struct Point(i32, i32);\n"
+"\n"
"fn add(p1: &Point, p2: &Point) -> Point {\n"
" Point(p1.0 + p2.0, p1.1 + p2.1)\n"
-"}"
-msgstr ""
-"fn somar(p1: &Ponto, p2: &Ponto) -> Ponto {\n"
-" Ponto(p1.0 + p2.0, p1.1 + p2.1)\n"
-"}"
-
-#: src/ownership/borrowing.md:14
-msgid ""
+"}\n"
+"\n"
"fn main() {\n"
" let p1 = Point(3, 4);\n"
" let p2 = Point(10, 20);\n"
@@ -4604,43 +4543,24 @@ msgstr ""
"* O chamador mantém a _ownership_ das entradas."
#: src/ownership/borrowing.md:27
-msgid ""
-"Notes on stack returns:\n"
-"* Demonstrate that the return from `add` is cheap because the compiler can eliminate the copy operation. Change the above "
-"code to print stack addresses and run it on the [Playground]. In the \"DEBUG\" optimization level, the addresses should "
-"change, while the stay the same when changing to the \"RELEASE\" setting:"
+msgid "Notes on stack returns:"
msgstr ""
-"Notas sobre retornos de pilha:\n"
-"* Demonstre que o retorno de `somar` é barato porque o compilador pode eliminar a operação de cópia. Altere o código acima "
-"para imprimir endereços de pilha e execute-o no [Playground]. No nível de otimização \"DEBUG\", os endereços devem mudar, "
-"enquanto permanecem os mesmos ao mudar para a configuração \"RELEASE\":"
-#: src/ownership/borrowing.md:30
+#: 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 and run it on the [Playground]. In the \"DEBUG\" optimization level, the addresses should change, while they stay the same when changing to the \"RELEASE\" setting:\n"
+"\n"
" ```rust,editable\n"
" #[derive(Debug)]\n"
-" struct Point(i32, i32);"
-msgstr ""
-" ```rust, editable\n"
-" #[derive(Debug)]\n"
-" struct Ponto(i32, i32);"
-
-#: src/ownership/borrowing.md:34
-msgid ""
+" struct Point(i32, i32);\n"
+"\n"
" fn add(p1: &Point, p2: &Point) -> Point {\n"
" let p = Point(p1.0 + p2.0, p1.1 + p2.1);\n"
" println!(\"&p.0: {:p}\", &p.0);\n"
" p\n"
-" }"
-msgstr ""
-" fn somar(p1: &Ponto, p2: &Ponto) -> Ponto {\n"
-" let p = Ponto(p1.0 + p2.0, p1.1 + p2.1);\n"
-" println!(\"&p.0: {:p}\", &p.0);\n"
-" p\n"
-" }"
-
-#: src/ownership/borrowing.md:40
-msgid ""
+" }\n"
+"\n"
" fn main() {\n"
" let p1 = Point(3, 4);\n"
" let p2 = Point(10, 20);\n"
@@ -4650,8 +4570,7 @@ msgid ""
" }\n"
" ```\n"
"* The Rust compiler can do return value optimization (RVO).\n"
-"* 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 performs a simple and efficient `memcpy` copy."
+"* 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 performs a simple and efficient `memcpy` copy."
msgstr ""
" fn main() {\n"
" let p1 = Ponto(3, 4);\n"
@@ -4662,13 +4581,7 @@ msgstr ""
" }\n"
" ```\n"
"* O compilador Rust pode fazer otimização de valor de retorno (RVO).\n"
-"* Em C++, a elisão de cópia deve ser definida na especificação da linguagem porque os construtores podem ter efeitos "
-"colaterais. Em Rust, isso não é um problema. Se o RVO não aconteceu, o Rust sempre executará uma cópia `memcpy` simples e "
-"eficiente."
-
-#: src/ownership/borrowing.md:53
-msgid "[Playground]: https://play.rust-lang.org/"
-msgstr "[Playground]: https://play.rust-lang.org/"
+"* Em C++, a elisão de cópia deve ser definida na especificação da linguagem porque os construtores podem ter efeitos colaterais. Em Rust, isso não é um problema. Se o RVO não aconteceu, o Rust sempre executará uma cópia `memcpy` simples e eficiente."
#: src/ownership/shared-unique-borrows.md:1
msgid "# Shared and Unique Borrows"
@@ -4687,54 +4600,41 @@ msgstr ""
"* Você pode ter exatamente um valor `&mut T`."
#: src/ownership/shared-unique-borrows.md:8
+#, fuzzy
msgid ""
"```rust,editable,compile_fail\n"
"fn main() {\n"
" let mut a: i32 = 10;\n"
-" let b: &i32 = &a;"
-msgstr ""
-"```rust,editable,compile_fail\n"
-"fn main() {\n"
-" let mut a: i32 = 10;\n"
-" let b: &i32 = &a;"
-
-#: src/ownership/shared-unique-borrows.md:13
-msgid ""
+" let b: &i32 = &a;\n"
+"\n"
" {\n"
" let c: &mut i32 = &mut a;\n"
" *c = 20;\n"
-" }"
-msgstr ""
-" {\n"
-" let c: &mut i32 = &mut a;\n"
-" *c = 20;\n"
-" }"
-
-#: src/ownership/shared-unique-borrows.md:18 src/std/rc.md:13
-msgid ""
+" }\n"
+"\n"
" println!(\"a: {a}\");\n"
" println!(\"b: {b}\");\n"
"}\n"
"```"
msgstr ""
-" println!(\"a: {a}\");\n"
-" println!(\"b: {b}\");\n"
+"```rust, editable\n"
+"fn main() {\n"
+" let x = 42;\n"
+" let y = x;\n"
+" println!(\"x: {x}\");\n"
+" println!(\"y: {y}\");\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.\n"
+"* The above code does not compile because `a` is borrowed as mutable (through `c`) and as immutable (through `b`) at the same time.\n"
"* Move the `println!` statement for `b` before the scope that introduces `c` to make the code compile.\n"
-"* After that change, the compiler realizes that `b` is only ever used before the new mutable borrow of `a` through `c`. "
-"This is a feature of the borrow checker called \"non-lexical lifetimes\"."
+"* After that change, the compiler realizes that `b` is only ever used before the new mutable borrow of `a` through `c`. This is a feature of the borrow checker called \"non-lexical lifetimes\"."
msgstr ""
-"* O código acima não compila porque `a` é emprestado como mutável (através de `c`) e como imutável (através de `b`) ao "
-"mesmo tempo.\n"
+"* O código acima não compila porque `a` é emprestado como mutável (através de `c`) e como imutável (através de `b`) ao mesmo tempo.\n"
"* Mova a instrução `println!` para `b` antes do escopo que introduz `c` para fazer o código compilar.\n"
-"* Após essa alteração, o compilador percebe que `b` só é usado antes do novo empréstimo mutável de `a` a `c`. Este é um "
-"recurso do verificador de empréstimo chamado \"tempo de vida não lexical\"."
+"* Após essa alteração, o compilador percebe que `b` só é usado antes do novo empréstimo mutável de `a` a `c`. Este é um recurso do verificador de empréstimo chamado \"tempo de vida não lexical\"."
#: src/ownership/lifetimes.md:1
msgid "# Lifetimes"
@@ -4745,15 +4645,19 @@ msgid "A borrowed value has a _lifetime_:"
msgstr "Um valor emprestado tem um tempo de vida (_lifetime_):"
#: src/ownership/lifetimes.md:5
+#, fuzzy
msgid ""
-"* The lifetime can be elided: `add(p1: &Point, p2: &Point) -> Point`.\n"
+"* The lifetime can be implicit: `add(p1: &Point, p2: &Point) -> Point`.\n"
"* Lifetimes can also be explicit: `&'a Point`, `&'document str`.\n"
"* Read `&'a Point` as \"a borrowed `Point` which is valid for at least the\n"
" lifetime `a`\".\n"
"* Lifetimes are always inferred by the compiler: you cannot assign a lifetime\n"
" yourself.\n"
" * Lifetime annotations create constraints; the compiler verifies that there is\n"
-" a valid solution."
+" a valid solution.\n"
+"* Lifetimes for function arguments and return values must be fully specified,\n"
+" but Rust allows these to be elidied in most cases with [a few simple\n"
+" rules](https://doc.rust-lang.org/nomicon/lifetime-elision.html)."
msgstr ""
"* O tempo de vida pode ser omitido: `add(p1: &Point, p2: &Point) -> Point`.\n"
"* Tempos de vida também podem ser explícitos: `&'a Point`, `&'document str`.\n"
@@ -4772,18 +4676,17 @@ msgstr "# Tempos de vida em chamadas de função"
msgid "In addition to borrowing its arguments, a function can return a borrowed value:"
msgstr "Além de emprestar seus argumentos, uma função pode retornar um valor emprestado:"
-#: src/ownership/lifetimes-function-calls.md:9
+#: src/ownership/lifetimes-function-calls.md:5
+#, fuzzy
msgid ""
+"```rust,editable\n"
+"#[derive(Debug)]\n"
+"struct Point(i32, i32);\n"
+"\n"
"fn left_most<'a>(p1: &'a Point, p2: &'a Point) -> &'a Point {\n"
" if p1.0 < p2.0 { p1 } else { p2 }\n"
-"}"
-msgstr ""
-"fn mais_a_esquerda<'a>(p1: &'a Ponto, p2: &'a Ponto) -> &'a Ponto{\n"
-" if p1.0 < p2.0 { p1 } else { p2 }\n"
-"}"
-
-#: src/ownership/lifetimes-function-calls.md:13
-msgid ""
+"}\n"
+"\n"
"fn main() {\n"
" let p1: Point = Point(10, 10);\n"
" let p2: Point = Point(20, 20);\n"
@@ -4815,29 +4718,17 @@ msgstr ""
" * A parte _pelo menos_ é importante quando os parâmetros estão em escopos diferentes."
#: src/ownership/lifetimes-function-calls.md:31
+#, fuzzy
msgid ""
"* Move the declaration of `p2` and `p3` into a a new scope (`{ ... }`), resulting in the following code:\n"
" ```rust,ignore\n"
" #[derive(Debug)]\n"
-" struct Point(i32, i32);"
-msgstr ""
-"* Mova a declaração de `p2` e `p3` para um novo escopo (`{ ... }`), resultando no seguinte código:\n"
-" ```rust, ignore\n"
-" #[derive(Debug)]\n"
-" struct Ponto(i32, i32);"
-
-#: src/ownership/lifetimes-function-calls.md:36
-msgid ""
+" struct Point(i32, i32);\n"
+"\n"
" fn left_most<'a>(p1: &'a Point, p2: &'a Point) -> &'a Point {\n"
" if p1.0 < p2.0 { p1 } else { p2 }\n"
-" }"
-msgstr ""
-" fn mais_a_esquerda<'a>(p1: &'a Ponto, p2: &'a Ponto) -> &'a Ponto {\n"
-" if p1.0 < p2.0 { p1 } else { p2 }\n"
-" }"
-
-#: src/ownership/lifetimes-function-calls.md:40
-msgid ""
+" }\n"
+"\n"
" fn main() {\n"
" let p1: Point = Point(10, 10);\n"
" let p3: &Point;\n"
@@ -4848,24 +4739,9 @@ msgid ""
" println!(\"left-most point: {:?}\", p3);\n"
" }\n"
" ```\n"
-" Note how this does not compile since `p3` outlives `p2`."
-msgstr ""
-" fn main() {\n"
-" let p1: Ponto = Ponto(10, 10);\n"
-" let p3: &Ponto;\n"
-" {\n"
-" let p2: Ponto = Ponto(20, 20);\n"
-" p3 = mais_a_esquerda(&p1, &p2);\n"
-" }\n"
-" println!(\"Ponto mais à esquerda: {:?}\", p3);\n"
-" }\n"
-" ```\n"
-" Observe como isso não compila, pois `p3` sobrevive a `p2`."
-
-#: src/ownership/lifetimes-function-calls.md:52
-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.\n"
+" Note how this does not compile since `p3` outlives `p2`.\n"
+"\n"
+"* 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.\n"
"* Another way to explain it:\n"
" * Two references to two values are borrowed by a function and the function returns\n"
" another reference.\n"
@@ -4873,8 +4749,7 @@ msgid ""
" * Which one is it? The compiler needs to to know, so at the call site the returned reference is not used\n"
" for longer than a variable from where the reference came from."
msgstr ""
-"* Redefina o espaço de trabalho e altere a assinatura da função para `fn mais_a_esquerda<'a, 'b>(p1: &'a Ponto, p2: &'a Ponto) -> "
-"&'b Ponto`. Isso não será compilado porque a relação entre os tempos de vida `'a` e `'b` não é clara.\n"
+"* Redefina o espaço de trabalho e altere a assinatura da função para `fn mais_a_esquerda<'a, 'b>(p1: &'a Ponto, p2: &'a Ponto) -> &'b Ponto`. Isso não será compilado porque a relação entre os tempos de vida `'a` e `'b` não é clara.\n"
"* Outra forma de explicar:\n"
" * Duas referências a dois valores são emprestadas por uma função e a função retorna\n"
" outra referência.\n"
@@ -4891,27 +4766,16 @@ msgid "If a data type stores borrowed data, it must be annotated with a lifetime
msgstr "Se um tipo de dados armazena dados emprestados, ele deve ser anotado com um tempo de vida:"
#: src/ownership/lifetimes-data-structures.md:5
+#, fuzzy
msgid ""
"```rust,editable\n"
"#[derive(Debug)]\n"
-"struct Highlight<'doc>(&'doc str);"
-msgstr ""
-"```rust, editable\n"
-"#[derive(Debug)]\n"
-"struct Destaque<'doc>(&'doc str);"
-
-#: src/ownership/lifetimes-data-structures.md:9
-msgid ""
+"struct Highlight<'doc>(&'doc str);\n"
+"\n"
"fn erase(text: String) {\n"
" println!(\"Bye {text}!\");\n"
-"}"
-msgstr ""
-"fn apagar(texto: String) {\n"
-" println!(\"Tchau {texto}!\");\n"
-"}"
-
-#: src/ownership/lifetimes-data-structures.md:13
-msgid ""
+"}\n"
+"\n"
"fn main() {\n"
" let text = String::from(\"The quick brown fox jumps over the lazy dog.\");\n"
" let fox = Highlight(&text[4..19]);\n"
@@ -4933,28 +4797,19 @@ msgstr ""
"```"
#: src/ownership/lifetimes-data-structures.md:25
+#, fuzzy
msgid ""
-"* In the above example, the annotation on `Highlight` enforces that the data underlying the contained `&str` lives at least "
-"as long as any instance of `Highlight` that uses that data.\n"
+"* In the above example, the annotation on `Highlight` enforces that the data underlying the contained `&str` lives at least as long as any instance of `Highlight` that uses that data.\n"
"* If `text` is consumed before the end of the lifetime of `fox` (or `dog`), the borrow checker throws an error.\n"
-"* Types with borrowed data force users to hold on to the original data. This can be useful for creating lightweight views, "
-"but it generally makes them somewhat harder to use.\n"
+"* Types with borrowed data force users to hold on to the original data. This can be useful for creating lightweight views, but it generally makes them somewhat harder to use.\n"
"* When possible, make data structures own their data directly.\n"
-"* Some structs with multiple references inside can have more than one lifetime annotation. This can be necessary if there "
-"is a need to describe lifetime relationships between the references themselves, in addition to the lifetime of the struct "
-"itself. Those are very advanced use cases.\n"
-""
+"* Some structs with multiple references inside can have more than one lifetime annotation. This can be necessary if there is a need to describe lifetime relationships between the references themselves, in addition to the lifetime of the struct itself. Those are very advanced use cases."
msgstr ""
-"* No exemplo acima, a anotação em `Destaque` impõe que os dados subjacentes ao `&str` contido vivam pelo menos tanto "
-"quanto qualquer instância de `Destaque` que usa esses dados.\n"
-"* Se `texto` for consumido antes do final do tempo de vida de `raposa` (ou `cachorro`), o verificador de empréstimo lançará um "
-"erro.\n"
-"* Tipos com dados emprestados forçam os usuários a manter os dados originais. Isso pode ser útil para criar exibições "
-"leves, mas geralmente as tornam um pouco mais difíceis de usar.\n"
+"* No exemplo acima, a anotação em `Destaque` impõe que os dados subjacentes ao `&str` contido vivam pelo menos tanto quanto qualquer instância de `Destaque` que usa esses dados.\n"
+"* Se `texto` for consumido antes do final do tempo de vida de `raposa` (ou `cachorro`), o verificador de empréstimo lançará um erro.\n"
+"* Tipos com dados emprestados forçam os usuários a manter os dados originais. Isso pode ser útil para criar exibições leves, mas geralmente as tornam um pouco mais difíceis de usar.\n"
"* Quando possível, faça com que as _Structs_ de dados possuam seus dados diretamente.\n"
-"* Algumas _Structs_ com várias referências internas podem ter mais de uma anotação vitalícia. Isso pode ser necessário se "
-"houver necessidade de descrever relacionamentos de tempo de vida entre as próprias referências, além do tempo de vida da "
-"própria estrutura. Esses são casos de uso muito avançados.\n"
+"* Algumas _Structs_ com várias referências internas podem ter mais de uma anotação vitalícia. Isso pode ser necessário se houver necessidade de descrever relacionamentos de tempo de vida entre as próprias referências, além do tempo de vida da própria estrutura. Esses são casos de uso muito avançados.\n"
""
#: src/exercises/day-1/afternoon.md:1
@@ -4966,17 +4821,13 @@ msgid "We will look at two things:"
msgstr "Veremos duas coisas:"
#: src/exercises/day-1/afternoon.md:5
-msgid "* A small book library,"
-msgstr "* Uma pequena biblioteca de livros,"
-
-#: src/exercises/day-1/afternoon.md:7
-msgid "* Iterators and ownership (hard)."
+#, fuzzy
+msgid ""
+"* A small book library,\n"
+"\n"
+"* Iterators and ownership (hard)."
msgstr "* Iteradores e ownership (difícil)."
-#: src/exercises/day-1/afternoon.md:13 src/exercises/day-2/afternoon.md:9
-msgid "[solutions]: solutions-afternoon.md"
-msgstr "[soluções]: solutions-afternoon.md"
-
#: src/exercises/day-1/book-library.md:1
msgid "# Designing a Library"
msgstr "# Projetando uma biblioteca"
@@ -4990,13 +4841,15 @@ msgstr ""
"você só precisa conhecer parte de sua API:"
#: src/exercises/day-1/book-library.md:6
+#, fuzzy
msgid ""
"```rust,editable\n"
"fn main() {\n"
" let mut vec = vec![10, 20];\n"
" vec.push(30);\n"
-" println!(\"middle value: {}\", vec[vec.len() / 2]);\n"
-" for item in vec.iter() {\n"
+" let midpoint = vec.len() / 2;\n"
+" println!(\"middle value: {}\", vec[midpoint]);\n"
+" for item in &vec {\n"
" println!(\"item: {item}\");\n"
" }\n"
"}\n"
@@ -5013,7 +4866,7 @@ msgstr ""
"}\n"
"```"
-#: src/exercises/day-1/book-library.md:17
+#: src/exercises/day-1/book-library.md:18
msgid ""
"Use this to create a library application. Copy the code below to\n"
"\n"
-"Pontos chave:"
-
-#: src/basic-syntax/references.md:24
+#: src/basic-syntax/references.md:25
msgid ""
"* Be sure to note the difference between `let mut ref_x: &i32` and `let ref_x:\n"
" &mut i32`. The first one represents a mutable reference which can be bound to\n"
@@ -2531,20 +2711,26 @@ msgid "A slice gives you a view into a larger collection:"
msgstr "Uma slice oferece uma visão de uma coleção maior:"
#: src/basic-syntax/slices.md:5
+#, fuzzy
msgid ""
"```rust,editable\n"
"fn main() {\n"
" let a: [i32; 6] = [10, 20, 30, 40, 50, 60];\n"
-" println!(\"a: {a:?}\");"
-msgstr ""
-
-#: src/basic-syntax/slices.md:10
-msgid ""
+" println!(\"a: {a:?}\");\n"
+"\n"
" let s: &[i32] = &a[2..4];\n"
" println!(\"s: {s:?}\");\n"
"}\n"
"```"
msgstr ""
+"```rust, editable\n"
+"fn main() {\n"
+" let x = 42;\n"
+" let y = x;\n"
+" println!(\"x: {x}\");\n"
+" println!(\"y: {y}\");\n"
+"}\n"
+"```"
#: src/basic-syntax/slices.md:15
msgid ""
@@ -2555,46 +2741,29 @@ msgstr ""
"* Pergunta: O que acontece se você modificar `a[3]`?"
#: src/basic-syntax/slices.md:20
-msgid "* We create a slice by borrowing `a` and specifying the starting and ending indexes in brackets."
-msgstr "* Criamos uma slice pegando emprestado `a` e especificando os índices inicial e final entre colchetes."
-
-#: src/basic-syntax/slices.md:22
+#, fuzzy
msgid ""
-"* If the slice starts at index 0, Rust's range syntax allows us to drop the starting index, meaning that `&a[0..a.len()]` "
-"and `&a[..a.len()]` are identical.\n"
+"* We create a slice by borrowing `a` and specifying the starting and ending indexes in brackets.\n"
+"\n"
+"* If the slice starts at index 0, Rust’s range syntax allows us to drop the starting index, meaning that `&a[0..a.len()]` and `&a[..a.len()]` are identical.\n"
" \n"
-"* The same is true for the last index, so `&a[2..a.len()]` and `&a[2..]` are identical."
-msgstr ""
-"* Se a slice começa no índice 0, a sintaxe de intervalo do Rust nos permite descartar o índice inicial, o que significa que "
-"`&a[0..a.len()]` e `&a[..a.len()]` são idênticos .\n"
-" \n"
-"* O mesmo vale para o último índice, então `&a[2..a.len()]` e `&a[2..]` são idênticos."
-
-#: src/basic-syntax/slices.md:26
-msgid "* To easily create a slice of the full array, we can therefore use `&a[..]`."
-msgstr "* Para criar facilmente uma slice do vetor completo, podemos usar `&a[..]`."
-
-#: src/basic-syntax/slices.md:28
-msgid ""
-"* `s` is a reference to a slice of `i32`s. Notice that the type of `s` (`&[i32]`) no longer mentions the array length. This "
-"allows us to perform computation on slices of different sizes.\n"
+"* The same is true for the last index, so `&a[2..a.len()]` and `&a[2..]` are identical.\n"
+"\n"
+"* To easily create a slice of the full array, we can therefore use `&a[..]`.\n"
+"\n"
+"* `s` is a reference to a slice of `i32`s. Notice that the type of `s` (`&[i32]`) no longer mentions the array length. This allows us to perform computation on slices of different sizes.\n"
" \n"
-"* Slices always borrow from another object. In this example, `a` has to remain 'alive' (in scope) for at least as long as "
-"our slice. \n"
+"* Slices always borrow from another object. In this example, `a` has to remain 'alive' (in scope) for at least as long as our slice. \n"
" \n"
-"* The question about modifying `a[3]` can spark an interesting discussion, but the answer is that for memory safety "
-"reasons\n"
+"* The question about modifying `a[3]` can spark an interesting discussion, but the answer is that for memory safety reasons\n"
" you cannot do it through `a` after you created a slice, but you can read the data from both `a` and `s` safely. \n"
" More details will be explained in the borrow checker section."
msgstr ""
-"* `s` é uma referência a uma slice de `i32`. Observe que o tipo de `s` (`&[i32]`) não menciona mais o tamanho do vetor. "
-"Isso nos permite realizar cálculos em slices de tamanhos diferentes.\n"
+"* `s` é uma referência a uma slice de `i32`. Observe que o tipo de `s` (`&[i32]`) não menciona mais o tamanho do vetor. Isso nos permite realizar cálculos em slices de tamanhos diferentes.\n"
" \n"
-"* As slices sempre pegam emprestado de outro objeto. Neste exemplo, `a` deve permanecer 'vivo' (no escopo) por pelo menos "
-"tanto tempo quanto nossa slice.\n"
+"* As slices sempre pegam emprestado de outro objeto. Neste exemplo, `a` deve permanecer 'vivo' (no escopo) por pelo menos tanto tempo quanto nossa slice.\n"
" \n"
-"* A questão sobre a modificação de `a[3]` pode gerar uma discussão interessante, mas a resposta é por motivos de segurança "
-"de memória\n"
+"* A questão sobre a modificação de `a[3]` pode gerar uma discussão interessante, mas a resposta é por motivos de segurança de memória\n"
" você não pode fazer isso por meio de `a` depois de criar uma slice, mas pode ler os dados de `a` e `s` com segurança.\n"
" Mais detalhes serão explicados na seção do verificador de empréstimo."
@@ -2607,19 +2776,13 @@ msgid "We can now understand the two string types in Rust:"
msgstr "Agora podemos entender os dois tipos de strings em Rust:"
#: src/basic-syntax/string-slices.md:5
+#, fuzzy
msgid ""
"```rust,editable\n"
"fn main() {\n"
" let s1: &str = \"World\";\n"
-" println!(\"s1: {s1}\");"
-msgstr ""
-"```rust,editable\n"
-"fn main() {\n"
-" let s1: &str = \"Mundo\";\n"
-" println!(\"s1: {s1}\");"
-
-#: src/basic-syntax/string-slices.md:10
-msgid ""
+" println!(\"s1: {s1}\");\n"
+"\n"
" let mut s2: String = String::from(\"Hello \");\n"
" println!(\"s2: {s2}\");\n"
" s2.push_str(s1);\n"
@@ -2653,27 +2816,16 @@ msgstr ""
"* `String` é um buffer de string mutável."
#: src/basic-syntax/string-slices.md:27
+#, fuzzy
msgid ""
"* `&str` introduces a string slice, which is an immutable reference to UTF-8 encoded string data \n"
-" stored in a block of memory. String literals (`\"Hello\"`), are stored in the program's binary."
-msgstr ""
-"* `&str` introduz uma slice de string, que é uma referência imutável para dados de string codificados em UTF-8\n"
-" armazenados em um bloco de memória. String literais (`\"Hello\"`), são armazenados no binário do 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.\n"
+" stored in a block of memory. String literals (`”Hello”`), are stored in the program’s binary.\n"
+"\n"
+"* Rust’s `String` type is a wrapper around a vector of bytes. As with a `Vec`, it is owned.\n"
" \n"
"* As with many other types `String::from()` creates a string from a string literal; `String::new()` \n"
-" creates a new empty string, to which string data can be added using the `push()` and `push_str()` methods."
-msgstr ""
-"* O tipo `String` do Rust é um wrapper em torno de um vetor de bytes. Tal como acontece com um `Vec`, ele é um valor.\n"
-" \n"
-"* Assim como muitos outros tipos, `String::from()` cria uma string a partir de uma string literal; `String::new()`\n"
-" cria uma nova string vazia, na qual os dados da string podem ser adicionados usando os métodos `push()` e `push_str()`."
-
-#: src/basic-syntax/string-slices.md:35
-msgid ""
+" creates a new empty string, to which string data can be added using the `push()` and `push_str()` methods.\n"
+"\n"
"* The `format!()` macro is a convenient way to generate an owned string from dynamic values. It \n"
" accepts the same format specification as `println!()`.\n"
" \n"
@@ -2682,8 +2834,7 @@ msgid ""
"* For C++ programmers: think of `&str` as `const char*` from C++, but the one that always points \n"
" to a valid string in memory. Rust `String` is a rough equivalent of `std::string` from C++ \n"
" (main difference: it can only contain UTF-8 encoded bytes and will never use a small-string optimization).\n"
-" \n"
-"
"
+" "
msgstr ""
"* A macro `format!()` é uma maneira conveniente de gerar uma string a partir de valores dinâmicos. Ela\n"
" aceita os mesmos formatadores que `println!()`.\n"
@@ -2708,22 +2859,72 @@ msgstr "Uma versão em Rust da famosa pergunta de entrevistas [FizzBuzz](https:/
msgid ""
"```rust,editable\n"
"fn main() {\n"
-" fizzbuzz_to(20); // Defined below, no forward declaration needed\n"
-"}"
+" print_fizzbuzz_to(20);\n"
+"}\n"
+"\n"
+"fn is_divisible(n: u32, divisor: u32) -> bool {\n"
+" if divisor == 0 {\n"
+" return false;\n"
+" }\n"
+" n % divisor == 0\n"
+"}\n"
+"\n"
+"fn fizzbuzz(n: u32) -> String {\n"
+" let fizz = if is_divisible(n, 3) { \"fizz\" } else { \"\" };\n"
+" let buzz = if is_divisible(n, 5) { \"buzz\" } else { \"\" };\n"
+" if fizz.is_empty() && buzz.is_empty() {\n"
+" return format!(\"{n}\");\n"
+" }\n"
+" format!(\"{fizz}{buzz}\")\n"
+"}\n"
+"\n"
+"fn print_fizzbuzz_to(n: u32) {\n"
+" for i in 1..=n {\n"
+" println!(\"{}\", fizzbuzz(i));\n"
+" }\n"
+"}\n"
+"```"
msgstr ""
-"```rust, editable\n"
-"fn main() {\n"
-" fizzbuzz_to(20); // Definido abaixo, nenhuma declaração prévia é necessária\n"
-"}"
-#: src/basic-syntax/functions.md:10
+#: src/basic-syntax/functions.md:35
+#, fuzzy
msgid ""
+"* We refer in `main` to a function written below. Neither forward declarations nor headers are necessary. \n"
+"* Declaration parameters are followed by a type (the reverse of some programming languages), then a return type.\n"
+"* The last expression in a function body (or any block) becomes the return value. Simply omit the `;` at the end of the expression.\n"
+"* Some functions have no return value, and return the 'unit type', `()`. The compiler will infer this if the `-> ()` return type is omitted.\n"
+"* The range expression in the `for` loop in `print_fizzbuzz_to()` contains `=n`, which causes it to include the upper bound."
+msgstr ""
+"* Nos referimos em `main` a uma função escrita abaixo. Nem declarações prévias e nem cabeçalhos são necessários.\n"
+"* Os parâmetros de declaração são seguidos por um tipo (o inverso de algumas linguagens de programação) e, em seguida, um tipo de retorno.\n"
+"* A última expressão em um corpo de uma função (ou qualquer bloco) torna-se o valor de retorno. Simplesmente omita o `;` no final da expressão.\n"
+"* Algumas funções não têm valor de retorno e retornam o 'tipo unitário', `()`. O compilador inferirá isso se o tipo de retorno `-> ()` for omitido.\n"
+"* A expressão de intervalo no loop `for` em `fizzbuzz_to()` contém `=n`, o que faz com que inclua o limite superior.\n"
+"* A expressão `match` em `fizzbuzz()` faz muita coisa. Ela será expandida abaixo para mostrar o que está acontecendo."
+
+#: src/basic-syntax/rustdoc.md:1
+#, fuzzy
+msgid "# Rustdoc"
+msgstr "# Por que Rust?"
+
+#: src/basic-syntax/rustdoc.md:3
+msgid "All language items in Rust can be documented using special `///` syntax."
+msgstr ""
+
+#: src/basic-syntax/rustdoc.md:5
+#, fuzzy
+msgid ""
+"```rust,editable\n"
+"/// Determine whether the first argument is divisible by the second argument.\n"
+"///\n"
+"/// If the second argument is zero, the result is false.\n"
"fn is_divisible_by(lhs: u32, rhs: u32) -> bool {\n"
" if rhs == 0 {\n"
" return false; // Corner case, early return\n"
" }\n"
" lhs % rhs == 0 // The last expression in a block is the return value\n"
-"}"
+"}\n"
+"```"
msgstr ""
"fn is_divisible_by(lhs: u32, rhs: u32) -> bool {\n"
" if rhs == 0 {\n"
@@ -2732,80 +2933,24 @@ msgstr ""
" lhs % rhs == 0 // A última expressão em um bloco é o valor de retorno\n"
"}"
-#: src/basic-syntax/functions.md:17
+#: src/basic-syntax/rustdoc.md:17
msgid ""
-"fn fizzbuzz(n: u32) -> () { // No return value means returning the unit type `()`\n"
-" match (is_divisible_by(n, 3), is_divisible_by(n, 5)) {\n"
-" (true, true) => println!(\"fizzbuzz\"),\n"
-" (true, false) => println!(\"fizz\"),\n"
-" (false, true) => println!(\"buzz\"),\n"
-" (false, false) => println!(\"{n}\"),\n"
-" }\n"
-"}"
-msgstr ""
-"fn fizzbuzz(n: u32) -> () { // // Nenhum valor de retorno significa retornar o tipo unitário `()`\n"
-" match (is_divisible_by(n, 3), is_divisible_by(n, 5)) {\n"
-" (true, true) => println!(\"fizzbuzz\"),\n"
-" (true, false) => println!(\"fizz\"),\n"
-" (false, true) => println!(\"buzz\"),\n"
-" (false, false) => println!(\"{n}\"),\n"
-" }\n"
-"}"
-
-#: src/basic-syntax/functions.md:26
-msgid ""
-"fn fizzbuzz_to(n: u32) { // `-> ()` is normally omitted\n"
-" for i in 1..=n {\n"
-" fizzbuzz(i);\n"
-" }\n"
-"}\n"
-"```"
-msgstr ""
-"fn fizzbuzz_to(n: u32) { // `-> ()` normalmente é omitido\n"
-" for i in 1..=n {\n"
-" fizzbuzz(i);\n"
-" }\n"
-"}\n"
-"```"
-
-#: src/basic-syntax/functions.md:35
-msgid ""
-"* We refer in `main` to a function written below. Neither forward declarations nor headers are necessary. \n"
-"* Declaration parameters are followed by a type (the reverse of some programming languages), then a return type.\n"
-"* The last expression in a function body (or any block) becomes the return value. Simply omit the `;` at the end of the "
-"expression.\n"
-"* Some functions have no return value, and return the 'unit type', `()`. The compiler will infer this if the `-> ()` return "
-"type is omitted.\n"
-"* The range expression in the `for` loop in `fizzbuzz_to()` contains `=n`, which causes it to include the upper bound.\n"
-"* The `match` expression in `fizzbuzz()` is doing a lot of work. It is expanded below to show what is happening."
-msgstr ""
-"* Nos referimos em `main` a uma função escrita abaixo. Nem declarações prévias e nem cabeçalhos são necessários.\n"
-"* Os parâmetros de declaração são seguidos por um tipo (o inverso de algumas linguagens de programação) e, em seguida, um "
-"tipo de retorno.\n"
-"* A última expressão em um corpo de uma função (ou qualquer bloco) torna-se o valor de retorno. Simplesmente omita o `;` no "
-"final da expressão.\n"
-"* Algumas funções não têm valor de retorno e retornam o 'tipo unitário', `()`. O compilador inferirá isso se o tipo de "
-"retorno `-> ()` for omitido.\n"
-"* A expressão de intervalo no loop `for` em `fizzbuzz_to()` contém `=n`, o que faz com que inclua o limite superior.\n"
-"* A expressão `match` em `fizzbuzz()` faz muita coisa. Ela será expandida abaixo para mostrar o que está acontecendo."
-
-#: src/basic-syntax/functions.md:42
-msgid " (Type annotations added for clarity, but they can be elided.)"
-msgstr " (As anotações de tipo foram adicionadas para maior clareza, mas podem ser omitidas.)"
-
-#: src/basic-syntax/functions.md:44
-msgid ""
-" ```rust,ignore\n"
-" let by_3: bool = is_divisible_by(n, 3);\n"
-" let by_5: bool = is_divisible_by(n, 5);\n"
-" let by_35: (bool, bool) = (by_3, by_5);\n"
-" match by_35 {\n"
-" // ...\n"
-" ```"
+"The contents are treated as Markdown. All published Rust library crates are\n"
+"automatically documented at [`docs.rs`](https://docs.rs) using the\n"
+"[rustdoc](https://doc.rust-lang.org/rustdoc/what-is-rustdoc.html) tool. It is\n"
+"idiomatic to document all public items in an API using this pattern."
msgstr ""
-#: src/basic-syntax/functions.md:52
-msgid " "
+#: src/basic-syntax/rustdoc.md:24
+msgid ""
+"* Show students the generated docs for the `rand` crate at\n"
+" [`docs.rs/rand`](https://docs.rs/rand).\n"
+"\n"
+"* This course does not include rustdoc on slides, just to save space, but in\n"
+" real code they should be present.\n"
+"\n"
+"* Inner doc comments are discussed later (in the page on modules) and need not\n"
+" be addressed here."
msgstr ""
#: src/basic-syntax/methods.md:1 src/methods.md:1
@@ -2813,53 +2958,33 @@ msgid "# Methods"
msgstr "# Métodos"
#: src/basic-syntax/methods.md:3
+#, fuzzy
msgid ""
-"Rust has methods, they are simply functions that are associated with a particular type. The\n"
-"first argument of a method is an instance of the type it is associated with:"
+"Methods are functions associated with a type. The `self` argument of a method is\n"
+"an instance of the type it is associated with:"
msgstr ""
"Rust tem métodos, eles são simplesmente funções associadas a um tipo específico. O\n"
"primeiro argumento de um método é uma instância do tipo ao qual está associado:"
#: src/basic-syntax/methods.md:6
+#, fuzzy
msgid ""
"```rust,editable\n"
"struct Rectangle {\n"
" width: u32,\n"
" height: u32,\n"
-"}"
-msgstr ""
-"```rust,editable\n"
-"struct Retangulo {\n"
-" largura: u32,\n"
-" altura: u32,\n"
-"}"
-
-#: src/basic-syntax/methods.md:12
-msgid ""
+"}\n"
+"\n"
"impl Rectangle {\n"
" fn area(&self) -> u32 {\n"
" self.width * self.height\n"
-" }"
-msgstr ""
-"impl Retangulo {\n"
-" fn area(&self) -> u32 {\n"
-" self.largura * self.altura\n"
-" }"
-
-#: src/basic-syntax/methods.md:17
-msgid ""
+" }\n"
+"\n"
" fn inc_width(&mut self, delta: u32) {\n"
" self.width += delta;\n"
" }\n"
-"}"
-msgstr ""
-" fn aumenta_largura(&mut self, delta: u32) {\n"
-" self.largura += delta;\n"
-" }\n"
-"}"
-
-#: src/basic-syntax/methods.md:22
-msgid ""
+"}\n"
+"\n"
"fn main() {\n"
" let mut rect = Rectangle { width: 10, height: 5 };\n"
" println!(\"old area: {}\", rect.area());\n"
@@ -2880,6 +3005,20 @@ msgstr ""
msgid "* We will look much more at methods in today's exercise and in tomorrow's class."
msgstr "* Veremos muito mais sobre métodos no exercício de hoje e na aula de amanhã."
+#: src/basic-syntax/methods.md:34
+msgid ""
+"- Add a `Rectangle::new` constructor and call this from `main`:\n"
+"\n"
+" ```rust,editable,compile_fail\n"
+" fn new(width: u32, height: u32) -> Rectangle {\n"
+" Rectangle { width, height }\n"
+" }\n"
+" ```\n"
+"\n"
+"- Add a `Rectangle::new_square(width: u32)` constructor to illustrate that\n"
+" constructors can take arbitrary parameters."
+msgstr ""
+
#: src/basic-syntax/functions-interlude.md:1
msgid "# Function Overloading"
msgstr "# Sobrecarga de funções"
@@ -2909,19 +3048,13 @@ msgid "However, function parameters can be generic:"
msgstr "No entanto, os parâmetros da função podem ser genéricos:"
#: src/basic-syntax/functions-interlude.md:14
+#, fuzzy
msgid ""
"```rust,editable\n"
"fn pick_one\n"
-" \n"
-"[Solution](solutions-afternoon.md#designing-a-library)"
+#: src/exercises/day-1/book-library.md:102
+#, fuzzy
+msgid "[Solution](solutions-afternoon.md#designing-a-library)"
msgstr ""
"
"
#: src/enums.md:1
msgid "# Enums"
@@ -5774,33 +5463,19 @@ msgstr ""
"variações diferentes:"
#: src/enums.md:6
+#, fuzzy
msgid ""
"```rust,editable\n"
"fn generate_random_number() -> i32 {\n"
" 4 // Chosen by fair dice roll. Guaranteed to be random.\n"
-"}"
-msgstr ""
-"```rust, editable\n"
-"fn gerador_numero_aleatorio() -> i32 {\n"
-" 4 // Escolhido por jogada de dados justa. Garantido para ser aleatório.\n"
-"}"
-
-#: src/enums.md:11
-msgid ""
+"}\n"
+"\n"
"#[derive(Debug)]\n"
"enum CoinFlip {\n"
" Heads,\n"
" Tails,\n"
-"}"
-msgstr ""
-"#[derive(Debug)]\n"
-"enum CaraCoroa {\n"
-" Cara,\n"
-" Coroa,\n"
-"}"
-
-#: src/enums.md:17
-msgid ""
+"}\n"
+"\n"
"fn flip_coin() -> CoinFlip {\n"
" let random_number = generate_random_number();\n"
" if random_number % 2 == 0 {\n"
@@ -5808,7 +5483,12 @@ msgid ""
" } else {\n"
" return CoinFlip::Tails;\n"
" }\n"
-"}"
+"}\n"
+"\n"
+"fn main() {\n"
+" println!(\"You got: {:?}\", flip_coin());\n"
+"}\n"
+"```"
msgstr ""
"fn jogar_moeda() -> CaraCoroa {\n"
" let numero_aleatorio = gerador_numero_aleatorio();\n"
@@ -5819,50 +5499,22 @@ msgstr ""
" }\n"
"}"
-#: src/enums.md:26
-msgid ""
-"fn main() {\n"
-" println!(\"You got: {:?}\", flip_coin());\n"
-"}\n"
-"```"
-msgstr ""
-"fn main() {\n"
-" println!(\"Você tem: {:?}\", jogar_moeda());\n"
-"}\n"
-"```"
-
-#: src/enums.md:31
-msgid ""
-"\n"
" \n"
@@ -5253,19 +5012,13 @@ msgid "You use this trait like this:"
msgstr "Você usa esse trait assim:"
#: src/exercises/day-1/iterators-and-ownership.md:22
+#, fuzzy
msgid ""
"```rust,editable\n"
"fn main() {\n"
" let v: Vec = vec![10, 20, 30];\n"
-" let mut iter = v.iter();"
-msgstr ""
-"```rust, editable\n"
-"fn main() {\n"
-" let v: Vec = vec![10, 20, 30];\n"
-" let mut iter = v.iter();"
-
-#: src/exercises/day-1/iterators-and-ownership.md:27
-msgid ""
+" let mut iter = v.iter();\n"
+"\n"
" println!(\"v[0]: {:?}\", iter.next());\n"
" println!(\"v[1]: {:?}\", iter.next());\n"
" println!(\"v[2]: {:?}\", iter.next());\n"
@@ -5285,28 +5038,22 @@ msgid "What is the type returned by the iterator? Test your answer here:"
msgstr "Qual é o tipo retornado pelo iterador? Teste sua resposta aqui:"
#: src/exercises/day-1/iterators-and-ownership.md:36
+#, fuzzy
msgid ""
"```rust,editable,compile_fail\n"
"fn main() {\n"
" let v: Vec = vec![10, 20, 30];\n"
-" let mut iter = v.iter();"
-msgstr ""
-"```rust,editable,compile_fail\n"
-"fn main() {\n"
-" let v: Vec = vec![10, 20, 30];\n"
-" let mut iter = v.iter();"
-
-#: src/exercises/day-1/iterators-and-ownership.md:41 src/exercises/day-1/iterators-and-ownership.md:78
-msgid ""
+" let mut iter = v.iter();\n"
+"\n"
" let v0: Option<..> = iter.next();\n"
" println!(\"v0: {v0:?}\");\n"
"}\n"
"```"
msgstr ""
-" let v0: Option<..> = iter.next();\n"
-" println!(\"v0: {v0:?}\");\n"
-"}\n"
-"```"
+"```rust,editable,compile_fail\n"
+"fn main() {\n"
+" let v: Vec = vec![10, 20, 30];\n"
+" let mut iter = v.iter();"
#: src/exercises/day-1/iterators-and-ownership.md:46
msgid "Why is this type used?"
@@ -5325,27 +5072,22 @@ msgstr ""
"iterador. A característica relacionada `IntoIterator` informa como criar o iterador:"
#: src/exercises/day-1/iterators-and-ownership.md:53
+#, fuzzy
msgid ""
"```rust\n"
"pub trait IntoIterator {\n"
" type Item;\n"
-" type IntoIter: Iterator- ;"
+" type IntoIter: Iterator
- ;\n"
+"\n"
+" fn into_iter(self) -> Self::IntoIter;\n"
+"}\n"
+"```"
msgstr ""
"```rust\n"
"pub trait IntoIterator {\n"
" type Item;\n"
" type IntoIter: Iterator
- ;"
-#: src/exercises/day-1/iterators-and-ownership.md:58
-msgid ""
-" fn into_iter(self) -> Self::IntoIter;\n"
-"}\n"
-"```"
-msgstr ""
-" fn into_iter(self) -> Self::IntoIter;\n"
-"}\n"
-"```"
-
#: src/exercises/day-1/iterators-and-ownership.md:62
msgid ""
"The syntax here means that every implementation of `IntoIterator` must\n"
@@ -5375,11 +5117,17 @@ msgid "Like before, what is the type returned by the iterator?"
msgstr "Como antes, qual é o tipo retornado pelo iterador?"
#: src/exercises/day-1/iterators-and-ownership.md:73
+#, fuzzy
msgid ""
"```rust,editable,compile_fail\n"
"fn main() {\n"
" let v: Vec
= vec![String::from(\"foo\"), String::from(\"bar\")];\n"
-" let mut iter = v.into_iter();"
+" let mut iter = v.into_iter();\n"
+"\n"
+" let v0: Option<..> = iter.next();\n"
+" println!(\"v0: {v0:?}\");\n"
+"}\n"
+"```"
msgstr ""
"```rust,editable,compile_fail\n"
"fn main() {\n"
@@ -5401,36 +5149,28 @@ msgstr ""
"iterador:"
#: src/exercises/day-1/iterators-and-ownership.md:89
+#, fuzzy
msgid ""
"```rust,editable\n"
"fn main() {\n"
-" let v: Vec = vec![String::from(\"foo\"), String::from(\"bar\")];"
-msgstr ""
-"```rust, editable\n"
-"fn main() {\n"
-" let v: Vec = vec![String::from(\"foo\"), String::from(\"bar\")];"
-
-#: src/exercises/day-1/iterators-and-ownership.md:93
-msgid ""
+" let v: Vec = vec![String::from(\"foo\"), String::from(\"bar\")];\n"
+"\n"
" for word in &v {\n"
" println!(\"word: {word}\");\n"
-" }"
-msgstr ""
-" for palavra in &v {\n"
-" println!(\"Palavra: {palavra}\");\n"
-" }"
-
-#: src/exercises/day-1/iterators-and-ownership.md:97
-msgid ""
+" }\n"
+"\n"
" for word in v {\n"
" println!(\"word: {word}\");\n"
" }\n"
"}\n"
"```"
msgstr ""
-" for palavra in v {\n"
-" println!(\"Palavra: {palavra}\");\n"
-" }\n"
+"```rust,editable\n"
+"fn main() {\n"
+" let s1: String = String::from(\"Olá!\");\n"
+" let s2: String = s1;\n"
+" println!(\"s2: {s2}\");\n"
+" // println!(\"s1: {s1}\");\n"
"}\n"
"```"
@@ -5463,32 +5203,19 @@ msgid "Now that we have seen a fair amount of Rust, we will continue with:"
msgstr "Agora que vimos uma boa quantidade de Rust, continuaremos com:"
#: src/welcome-day-2.md:5
-msgid "* Structs, enums, methods."
-msgstr "* Estruturas (`structs`), enumerações (`enums`) e métodos."
-
-#: src/welcome-day-2.md:7
-msgid "* Pattern matching: destructuring enums, structs, and arrays."
-msgstr "* Correspondência de padrões: desestruturando enumerações, estruturas e vetores."
-
-#: src/welcome-day-2.md:9
msgid ""
+"* Structs, enums, methods.\n"
+"\n"
+"* Pattern matching: destructuring enums, structs, and arrays.\n"
+"\n"
"* Control flow constructs: `if`, `if let`, `while`, `while let`, `break`, and\n"
-" `continue`."
-msgstr ""
-"* Construções de fluxo de controle: `if`, `if let`, `while`, `while let`, `break` e\n"
-" `continue`."
-
-#: src/welcome-day-2.md:12
-msgid ""
+" `continue`.\n"
+"\n"
"* The Standard Library: `String`, `Option` and `Result`, `Vec`, `HashMap`, `Rc`\n"
-" and `Arc`."
+" and `Arc`.\n"
+"\n"
+"* Modules: visibility, paths, and filesystem hierarchy."
msgstr ""
-"* A Biblioteca Padrão: `String`, `Option` e `Result`, `Vec`, `HashMap`, `Rc`\n"
-" e 'Arc'."
-
-#: src/welcome-day-2.md:15
-msgid "* Modules: visibility, paths, and filesystem hierarchy."
-msgstr "* Módulos: visibilidade, caminhos e hierarquia do sistema de arquivos."
#: src/structs.md:1
msgid "# Structs"
@@ -5499,21 +5226,14 @@ msgid "Like C and C++, Rust has support for custom structs:"
msgstr "Como C e C++, Rust tem suporte para `structs` personalizadas:"
#: src/structs.md:5
+#, fuzzy
msgid ""
"```rust,editable\n"
"struct Person {\n"
" name: String,\n"
" age: u8,\n"
-"}"
-msgstr ""
-"```rust, editable\n"
-"struct Pessoa {\n"
-" nome: String,\n"
-" idade: u8,\n"
-"}"
-
-#: src/structs.md:11
-msgid ""
+"}\n"
+"\n"
"fn main() {\n"
" let mut peter = Person {\n"
" name: String::from(\"Peter\"),\n"
@@ -5550,27 +5270,24 @@ msgstr ""
"}\n"
"```"
-#: src/structs.md:29
-msgid ""
-"
"
+"* The `new` function could be written using `Self` as a type, as it is interchangeable with the struct type name\n"
+"\n"
+" ```rust,editable\n"
+" #[derive(Debug)]\n"
+" struct Person {\n"
+" name: String,\n"
+" age: u8,\n"
+" }\n"
+" impl Person {\n"
+" fn new(name: String, age: u8) -> Self {\n"
+" Self { name, age }\n"
+" }\n"
+" }\n"
+" ``` \n"
+"* Implement the `Default` trait for the struct. Define some fields and use the default values for the other fields.\n"
+"\n"
+" ```rust,editable\n"
+" #[derive(Debug)]\n"
+" struct Person {\n"
+" name: String,\n"
+" age: u8,\n"
+" }\n"
+" impl Default for Person {\n"
+" fn default() -> Person {\n"
+" Person {\n"
+" name: \"Bot\".to_string(),\n"
+" age: 0,\n"
+" }\n"
+" }\n"
+" }\n"
+" fn create_default() {\n"
+" let tmp = Person {\n"
+" ..Default::default()\n"
+" };\n"
+" let tmp = Person {\n"
+" name: \"Sam\".to_string(),\n"
+" ..Default::default()\n"
+" };\n"
+" }\n"
+" ```\n"
+"\n"
+"* Methods are defined in the `impl` block.\n"
+"* Use struct update syntax to define a new structure using `peter`. Note that the variable `peter` will no longer be accessible afterwards.\n"
+"* Use `{:#?}` when printing structs to request the `Debug` representation."
msgstr ""
-"```rust, ignore\n"
-"impl Pessoa {\n"
-" fn new(nome: String, idade: u8) -> Self {\n"
-" Self { nome, idade }\n"
-" }\n"
-"}\n"
-"```\n"
-" \n"
-"\n"
-"Key Points: "
-msgstr ""
-"
"
@@ -5691,75 +5380,75 @@ msgstr ""
"Se você já tiver variáveis com os nomes corretos, poderá criar o\n"
"struct usando uma abreviação:"
-#: src/structs/field-shorthand.md:6 src/methods.md:6
+#: src/structs/field-shorthand.md:6
msgid ""
"```rust,editable\n"
"#[derive(Debug)]\n"
"struct Person {\n"
" name: String,\n"
" age: u8,\n"
-"}"
-msgstr ""
-"```rust, editable\n"
-"#[derive(Debug)]\n"
-"struct Pessoa {\n"
-" nome: String,\n"
-" idade: u8,\n"
-"}"
-
-#: src/structs/field-shorthand.md:13
-msgid ""
+"}\n"
+"\n"
"impl Person {\n"
" fn new(name: String, age: u8) -> Person {\n"
" Person { name, age }\n"
" }\n"
-"}"
-msgstr ""
-"impl Pessoa {\n"
-" fn new(nome: String, idade: u8) -> Pessoa {\n"
-" Pessoa { nome, idade }\n"
-" }\n"
-"}"
-
-#: src/structs/field-shorthand.md:19
-msgid ""
+"}\n"
+"\n"
"fn main() {\n"
" let peter = Person::new(String::from(\"Peter\"), 27);\n"
" println!(\"{peter:?}\");\n"
"}\n"
"```"
msgstr ""
-"fn main() {\n"
-" let pedro = Pessoa::new(String::from(\"Pedro\"), 27);\n"
-" println!(\"{pedro:?}\");\n"
-"}\n"
-"```"
#: src/structs/field-shorthand.md:27
-msgid "The `new` function could be written using `Self` as a type, as it is interchangeable with the struct type name"
-msgstr "A função `new` pode ser escrita usando `Self` como um tipo, já que é intercambiável com o name do tipo _struct_"
-
-#: src/structs/field-shorthand.md:29
msgid ""
-"```rust,ignore\n"
-"impl Person {\n"
-" fn new(name: String, age: u8) -> Self {\n"
-" Self { name, age }\n"
-" }\n"
-"}\n"
-"```\n"
-" \n"
-"\n"
-"Pontos chave:"
+#: src/structs.md:31 src/enums.md:33 src/enums/sizes.md:29 src/methods.md:30
+#: src/methods/example.md:46 src/pattern-matching.md:25
+#: src/pattern-matching/match-guards.md:22 src/control-flow/blocks.md:42
+#, fuzzy
+msgid "Key Points:"
+msgstr "Pontos chave:"
-#: src/structs.md:32
+#: src/structs.md:33
+#, fuzzy
msgid ""
"* Structs work like in C or C++.\n"
" * Like in C++, and unlike in C, no typedef is needed to define a type.\n"
" * Unlike in C++, there is no inheritance between structs.\n"
"* Methods are defined in an `impl` block, which we will see in following slides.\n"
"* This may be a good time to let people know there are different types of structs. \n"
-" * Zero-sized structs `e.g., struct Foo;` might be used when implementing a trait on some type but don't have any data "
-"that you want to store in the value itself. \n"
+" * Zero-sized structs `e.g., struct Foo;` might be used when implementing a trait on some type but don’t have any data that you want to store in the value itself. \n"
" * The next slide will introduce Tuple structs, used when the field names are not important.\n"
-"* The syntax `..peter` allows us to copy the majority of the fields from the old struct without having to explicitly type "
-"it all out. It must always be the last element."
-
+"* The syntax `..peter` allows us to copy the majority of the fields from the old struct without having to explicitly type it all out. It must always be the last element."
msgstr ""
"* Structs funcionam como em C ou C++.\n"
" * Como em C++, e ao contrário de C, nenhum typedef é necessário para definir um tipo.\n"
@@ -5592,15 +5309,11 @@ msgid "If the field names are unimportant, you can use a tuple struct:"
msgstr "Se os nomes dos campos não forem importantes, você pode usar uma estrutura de tupla:"
#: src/structs/tuple-structs.md:5
+#, fuzzy
msgid ""
"```rust,editable\n"
-"struct Point(i32, i32);"
-msgstr ""
-"```rust, editable\n"
-"struct Ponto(i32, i32);"
-
-#: src/structs/tuple-structs.md:8
-msgid ""
+"struct Point(i32, i32);\n"
+"\n"
"fn main() {\n"
" let p = Point(17, 23);\n"
" println!(\"({}, {})\", p.0, p.1);\n"
@@ -5620,62 +5333,38 @@ msgstr "Isso geralmente é usado para wrappers de campo único (chamados newtype
#: src/structs/tuple-structs.md:16
msgid ""
"```rust,editable,compile_fail\n"
-"struct PoundOfForce(f64);\n"
-"struct Newtons(f64);"
-msgstr ""
-"```rust,editable,compile_fail\n"
-"struct PoundOfForce(f64);\n"
-"struct Newtons(f64);"
-
-#: src/structs/tuple-structs.md:20
-msgid ""
-"fn compute_thruster_force() -> PoundOfForce {\n"
+"struct PoundsOfForce(f64);\n"
+"struct Newtons(f64);\n"
+"\n"
+"fn compute_thruster_force() -> PoundsOfForce {\n"
" todo!(\"Ask a rocket scientist at NASA\")\n"
-"}"
-msgstr ""
-"fn compute_thruster_force() -> PoundOfForce {\n"
-" todo!(\"Pergunte a um cientista de foguetes da NASA\")\n"
-"}"
-
-#: src/structs/tuple-structs.md:24
-msgid ""
+"}\n"
+"\n"
"fn set_thruster_force(force: Newtons) {\n"
" // ...\n"
-"}"
-msgstr ""
-"fn set_thruster_force(force: Newtons) {\n"
-" // ...\n"
-"}"
-
-#: src/structs/tuple-structs.md:28
-msgid ""
+"}\n"
+"\n"
"fn main() {\n"
" let force = compute_thruster_force();\n"
" set_thruster_force(force);\n"
-"}"
+"}\n"
+"\n"
+"```"
msgstr ""
-"fn main() {\n"
-" let force = compute_thruster_force();\n"
-" set_thruster_force(force);\n"
-"}"
-
-#: src/structs/tuple-structs.md:33 src/traits/default.md:36 src/generics/trait-objects.md:86
-msgid "```"
-msgstr "```"
#: src/structs/tuple-structs.md:37
+#, fuzzy
msgid ""
-"Newtypes are a great way to encode additional information about the value in a primitive type, for example:\n"
+"* Newtypes are a great way to encode additional information about the value in a primitive type, for example:\n"
" * The number is measured in some units: `Newtons` in the example above.\n"
-" * 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)`.\n"
-" \n"
-"
"
+" * 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)`.\n"
+"* Demonstrate how to add a `f64` value to a `Newtons` type by accessing the single field in the newtype.\n"
+" * Rust generally doesn’t like inexplicit things, like automatic unwrapping or for instance using booleans as integers.\n"
+" * Operator overloading is discussed on Day 3 (generics). "
msgstr ""
"Newtypes são uma ótima maneira de codificar informações adicionais sobre o valor em um tipo primitivo, por exemplo:\n"
" * O número é medido em algumas unidades: `Newtons` no exemplo acima.\n"
-" * O valor passou por alguma validação quando foi criado, então você não precisa mais validá-lo novamente a cada uso: "
-" `PhoneNumber(String)` ou `OddNumber(u32)`.\n"
+" * O valor passou por alguma validação quando foi criado, então você não precisa mais validá-lo novamente a cada uso: `PhoneNumber(String)` ou `OddNumber(u32)`.\n"
" \n"
"\n"
-" \n"
-"Key Points:"
-msgstr ""
-"
"
#: src/enums/variant-payloads.md:1
@@ -5884,17 +5536,8 @@ msgid ""
" PageLoad, // Variant without payload\n"
" KeyPress(char), // Tuple struct variant\n"
" Click { x: i64, y: i64 }, // Full struct variant\n"
-"}"
-msgstr ""
-"```rust, editable\n"
-"enum WebEvent {\n"
-" PageLoad, // Variante sem payload\n"
-" KeyPress(char), // Variante da estrutura da tupla\n"
-" Click { x: i64, y: i64 }, // Variante de struct completa\n"
-"}"
-
-#: src/enums/variant-payloads.md:13
-msgid ""
+"}\n"
+"\n"
"#[rustfmt::skip]\n"
"fn inspect(event: WebEvent) {\n"
" match event {\n"
@@ -5902,60 +5545,39 @@ msgid ""
" WebEvent::KeyPress(c) => println!(\"pressed '{c}'\"),\n"
" WebEvent::Click { x, y } => println!(\"clicked at x={x}, y={y}\"),\n"
" }\n"
-"}"
-msgstr ""
-"#[rustfmt::skip]\n"
-"fn inspect(event: WebEvent) {\n"
-" match event{\n"
-" WebEvent::PageLoad => println!(\"página carregada\"),\n"
-" WebEvent::KeyPress(c) => println!(\"pressionou '{c}'\"),\n"
-" WebEvent::Click { x, y } => println!(\"clicou em x={x}, y={y}\"),\n"
-" }\n"
-"}"
-
-#: src/enums/variant-payloads.md:22
-msgid ""
+"}\n"
+"\n"
"fn main() {\n"
" let load = WebEvent::PageLoad;\n"
" let press = WebEvent::KeyPress('x');\n"
-" let click = WebEvent::Click { x: 20, y: 80 };"
-msgstr ""
-"fn main() {\n"
-" let load = WebEvent::PageLoad;\n"
-" let press = WebEvent::KeyPress('x');\n"
-" let click = WebEvent::Click { x: 20, y: 80 };"
-
-#: src/enums/variant-payloads.md:27
-msgid ""
+" let click = WebEvent::Click { x: 20, y: 80 };\n"
+"\n"
" inspect(load);\n"
" inspect(press);\n"
" inspect(click);\n"
"}\n"
"```"
msgstr ""
-" inspect(load);\n"
-" inspect(press);\n"
-" inspect(click);\n"
-"}\n"
-"```"
#: src/enums/variant-payloads.md:35
+#, fuzzy
msgid ""
-"* In the above example, accessing the `char` in `KeyPress`, or `x` and `y` in `Click` only works within a `match` or an `if "
-"let` statement.\n"
-"* `match` and `if let` inspect a hidden discriminant field in the `enum`.\n"
+"* The values in the enum variants can only be accessed after being pattern matched. The pattern binds references to the fields in the \"match arm\" after the `=>`.\n"
+" * The expression is matched against the patterns from top to bottom. There is no fall-through like in C or C++.\n"
+" * The match expression has a value. The value is the last expression in the match arm which was executed.\n"
+" * Starting from the top we look for what pattern matches the value then run the code following the arrow. Once we find a match, we stop. \n"
+"* Demonstrate what happens when the search is inexhaustive. Note the advantage the Rust compiler provides by confirming when all cases are handled. \n"
+"* `match` inspects a hidden discriminant field in the `enum`.\n"
"* It is possible to retrieve the discriminant by calling `std::mem::discriminant()`\n"
-" * This is useful, for example, if implementing `PartialEq` for structs where comparing field values doesn't affect "
-"equality.\n"
-"* `WebEvent::Click { ... }` is not exactly the same as `WebEvent::Click(Click)` with a top level `struct Click { ... }`. "
-"The inlined version cannot implement traits, for example."
+" * This is useful, for example, if implementing `PartialEq` for structs where comparing field values doesn't affect equality.\n"
+"* `WebEvent::Click { ... }` is not exactly the same as `WebEvent::Click(Click)` with a top level `struct Click { ... }`. The inlined version cannot implement traits, for example. \n"
+" "
msgstr ""
"* No exemplo acima, acessar o `char` em `KeyPress`, ou `x` e `y` em `Click` só funciona dentro de uma instrução `match`\n"
" ou em uma expressão `if let`.\n"
"* `match` inspeciona um campo discriminante oculto no `enum`.\n"
"* É possível recuperar o campo discriminante chamando `std::mem::discriminant()`.\n"
-"* `WebEvent::Click { ... }` não é exatamente o mesmo que `WebEvent::Click(Click)` com um `struct Click { ... }` de nível "
-"superior. A versão embutida não pode implementar traits, por exemplo."
+"* `WebEvent::Click { ... }` não é exatamente o mesmo que `WebEvent::Click(Click)` com um `struct Click { ... }` de nível superior. A versão embutida não pode implementar traits, por exemplo."
#: src/enums/sizes.md:1
msgid "# Enum Sizes"
@@ -5966,19 +5588,27 @@ msgid "Rust enums are packed tightly, taking constraints due to alignment into a
msgstr "Enums, em Rust, são empacotados firmemente, levando em consideração as restrições devido ao alinhamento:"
#: src/enums/sizes.md:5
+#, fuzzy
msgid ""
"```rust,editable\n"
-"use std::mem::{align_of, size_of};"
-msgstr ""
-
-#: src/enums/sizes.md:8
-msgid ""
+"use std::mem::{align_of, size_of};\n"
+"\n"
"macro_rules! dbg_size {\n"
" ($t:ty) => {\n"
" println!(\"{}: size {} bytes, align: {} bytes\",\n"
" stringify!($t), size_of::<$t>(), align_of::<$t>());\n"
" };\n"
-"}"
+"}\n"
+"\n"
+"enum Foo {\n"
+" A,\n"
+" B,\n"
+"}\n"
+"\n"
+"fn main() {\n"
+" dbg_size!(Foo);\n"
+"}\n"
+"```"
msgstr ""
"macro_rules! dbg_size {\n"
" ($t:ty) => {\n"
@@ -5987,254 +5617,136 @@ msgstr ""
" };\n"
"}"
-#: src/enums/sizes.md:15
-msgid ""
-"enum Foo {\n"
-" A,\n"
-" B,\n"
-"}"
-msgstr ""
-"enum Foo {\n"
-" A,\n"
-" B,\n"
-"}"
-
-#: src/enums/sizes.md:20
-msgid ""
-"#[repr(u32)]\n"
-"enum Bar {\n"
-" A, // 0\n"
-" B = 10000,\n"
-" C, // 10001\n"
-"}"
-msgstr ""
-
-#: src/enums/sizes.md:27
-msgid ""
-"fn main() {\n"
-" dbg_size!(Foo);\n"
-" dbg_size!(Bar);\n"
-" dbg_size!(bool);\n"
-" dbg_size!(Option\n"
-" \n"
-"Pontos chave:"
-
#: src/enums.md:35
+#, fuzzy
msgid ""
"* Enumerations allow you to collect a set of values under one type\n"
-"* This page offers an enum type `CoinFlip` with two variants `Heads` and `Tail`. You might note the namespace when using "
-"variants.\n"
+"* This page offers an enum type `CoinFlip` with two variants `Heads` and `Tail`. You might note the namespace when using variants.\n"
"* This might be a good time to compare Structs and Enums:\n"
-" * In both, you can have a simple version without fields (unit struct) or one with different types of fields (variant "
-"payloads). \n"
+" * In both, you can have a simple version without fields (unit struct) or one with different types of fields (variant payloads). \n"
" * In both, associated functions are defined within an `impl` block.\n"
-" * You could even implement the different variants of an enum with separate structs but then they wouldn't be the same "
-"type as they would if they were all defined in an enum. \n"
-"
"
+" * You could even implement the different variants of an enum with separate structs but then they wouldn’t be the same type as they would if they were all defined in an enum. "
msgstr ""
"* As enumerações permitem que você colete um conjunto de valores em um tipo\n"
-"* Esta página oferece um tipo de Enum `CoinFlip` com duas variantes `Heads` e `Tail`. Você pode observar o namespace ao "
-"usar variantes.\n"
+"* Esta página oferece um tipo de Enum `CoinFlip` com duas variantes `Heads` e `Tail`. Você pode observar o namespace ao usar variantes.\n"
"* Este pode ser um bom momento para comparar Structs e Enums:\n"
-" * Em ambos, você pode ter uma versão simples sem campos (unit struct) ou uma com diferentes tipos de campos (variant "
-"payloads).\n"
+" * Em ambos, você pode ter uma versão simples sem campos (unit struct) ou uma com diferentes tipos de campos (variant payloads).\n"
" * Em ambos, as funções associadas são definidas dentro de um bloco `impl`.\n"
-" * Você pode até mesmo implementar as diferentes variantes de uma Enum com Structs separadas, mas elas não seriam do mesmo "
-"tipo que seriam se todas fossem definidas em uma Enum.\n"
+" * Você pode até mesmo implementar as diferentes variantes de uma Enum com Structs separadas, mas elas não seriam do mesmo tipo que seriam se todas fossem definidas em uma Enum.\n"
"\n"
-" \n"
-"Key Points: \n"
" * Internally Rust is using a field (discriminant) to keep track of the enum variant.\n"
-" * `Bar` enum demonstrates that there is a way to control the discriminant value and type. If `repr` is removed, the "
-"discriminant type takes 2 bytes, becuase 10001 fits 2 bytes.\n"
-" * As a niche optimization an enum discriminant is merged with the pointer so that `Option<&Foo>` is the same size as "
-"`&Foo`.\n"
-" * `Option` is another example of tight packing.\n"
-" * For [some types](https://doc.rust-lang.org/std/option/#representation), Rust guarantees that `size_of::()` equals "
-"`size_of::>()`.\n"
-" * Zero-sized types allow for efficient implementation of `HashSet` using `HashMap` with `()` as the value."
+"\n"
+" * You can control the discriminant if needed (e.g., for compatibility with C):\n"
+" \n"
+" ```rust,editable\n"
+" #[repr(u32)]\n"
+" enum Bar {\n"
+" A, // 0\n"
+" B = 10000,\n"
+" C, // 10001\n"
+" }\n"
+" \n"
+" fn main() {\n"
+" println!(\"A: {}\", Bar::A as u32);\n"
+" println!(\"B: {}\", Bar::B as u32);\n"
+" println!(\"C: {}\", Bar::C as u32);\n"
+" }\n"
+" ```\n"
+"\n"
+" Without `repr`, the discriminant type takes 2 bytes, because 10001 fits 2\n"
+" bytes.\n"
+"\n"
+"\n"
+" * Try out other types such as\n"
+" \n"
+" * `dbg_size!(bool)`: size 1 bytes, align: 1 bytes,\n"
+" * `dbg_size!(Option)`: size 1 bytes, align: 1 bytes (niche optimization, see below),\n"
+" * `dbg_size!(&i32)`: size 8 bytes, align: 8 bytes (on a 64-bit machine),\n"
+" * `dbg_size!(Option<&i32>)`: size 8 bytes, align: 8 bytes (null pointer optimization, see below).\n"
+"\n"
+" * Niche optimization: Rust will merge use unused bit patterns for the enum\n"
+" discriminant.\n"
+"\n"
+" * Null pointer optimization: For [some\n"
+" types](https://doc.rust-lang.org/std/option/#representation), Rust guarantees\n"
+" that `size_of::()` equals `size_of::>()`.\n"
+"\n"
+" Example code if you want to show how the bitwise representation *may* look like in practice.\n"
+" It's important to note that the compiler provides no guarantees regarding this representation, therefore this is totally unsafe.\n"
+"\n"
+" ```rust,editable\n"
+" use std::mem::transmute;\n"
+"\n"
+" macro_rules! dbg_bits {\n"
+" ($e:expr, $bit_type:ty) => {\n"
+" println!(\"- {}: {:#x}\", stringify!($e), transmute::<_, $bit_type>($e));\n"
+" };\n"
+" }\n"
+"\n"
+" fn main() {\n"
+" // TOTALLY UNSAFE. Rust provides no guarantees about the bitwise\n"
+" // representation of types.\n"
+" unsafe {\n"
+" println!(\"Bitwise representation of bool\");\n"
+" dbg_bits!(false, u8);\n"
+" dbg_bits!(true, u8);\n"
+"\n"
+" println!(\"Bitwise representation of Option\");\n"
+" dbg_bits!(None::, u8);\n"
+" dbg_bits!(Some(false), u8);\n"
+" dbg_bits!(Some(true), u8);\n"
+"\n"
+" println!(\"Bitwise representation of Option>\");\n"
+" dbg_bits!(Some(Some(false)), u8);\n"
+" dbg_bits!(Some(Some(true)), u8);\n"
+" dbg_bits!(Some(None::), u8);\n"
+" dbg_bits!(None::>, u8);\n"
+"\n"
+" println!(\"Bitwise representation of Option<&i32>\");\n"
+" dbg_bits!(None::<&i32>, usize);\n"
+" dbg_bits!(Some(&0i32), usize);\n"
+" }\n"
+" }\n"
+" ```\n"
+"\n"
+" More complex example if you want to discuss what happens when we chain more than 256 `Option`s together.\n"
+"\n"
+" ```rust,editable\n"
+" #![recursion_limit = \"1000\"]\n"
+"\n"
+" use std::mem::transmute;\n"
+" \n"
+" macro_rules! dbg_bits {\n"
+" ($e:expr, $bit_type:ty) => {\n"
+" println!(\"- {}: {:#x}\", stringify!($e), transmute::<_, $bit_type>($e));\n"
+" };\n"
+" }\n"
+"\n"
+" // Macro to wrap a value in 2^n Some() where n is the number of \"@\" signs.\n"
+" // Increasing the recursion limit is required to evaluate this macro.\n"
+" macro_rules! many_options {\n"
+" ($value:expr) => { Some($value) };\n"
+" ($value:expr, @) => {\n"
+" Some(Some($value))\n"
+" };\n"
+" ($value:expr, @ $($more:tt)+) => {\n"
+" many_options!(many_options!($value, $($more)+), $($more)+)\n"
+" };\n"
+" }\n"
+"\n"
+" fn main() {\n"
+" // TOTALLY UNSAFE. Rust provides no guarantees about the bitwise\n"
+" // representation of types.\n"
+" unsafe {\n"
+" assert_eq!(many_options!(false), Some(false));\n"
+" assert_eq!(many_options!(false, @), Some(Some(false)));\n"
+" assert_eq!(many_options!(false, @@), Some(Some(Some(Some(false)))));\n"
+"\n"
+" println!(\"Bitwise representation of a chain of 128 Option's.\");\n"
+" dbg_bits!(many_options!(false, @@@@@@@), u8);\n"
+" dbg_bits!(many_options!(true, @@@@@@@), u8);\n"
+"\n"
+" println!(\"Bitwise representation of a chain of 256 Option's.\");\n"
+" dbg_bits!(many_options!(false, @@@@@@@@), u16);\n"
+" dbg_bits!(many_options!(true, @@@@@@@@), u16);\n"
+"\n"
+" println!(\"Bitwise representation of a chain of 257 Option's.\");\n"
+" dbg_bits!(many_options!(Some(false), @@@@@@@@), u16);\n"
+" dbg_bits!(many_options!(Some(true), @@@@@@@@), u16);\n"
+" dbg_bits!(many_options!(None::, @@@@@@@@), u16);\n"
+" }\n"
+" }\n"
+" ```"
msgstr ""
-"
"
@@ -6327,6 +5821,7 @@ msgstr ""
"outros receptores possíveis para um método:"
#: src/methods/receiver.md:6
+#, fuzzy
msgid ""
"* `&self`: borrows the object from the caller using a shared and immutable\n"
" reference. The object can be used again afterwards.\n"
@@ -6335,9 +5830,8 @@ msgid ""
"* `self`: takes ownership of the object and moves it away from the caller. The\n"
" method becomes the owner of the object. The object will be dropped (deallocated)\n"
" when the method returns, unless its ownership is explicitly\n"
-" transmitted.\n"
-"* `mut self`: same as above, but while the method owns the object, it can\n"
-" mutate it too. Complete ownership does not automatically mean mutability.\n"
+" transmitted. Complete ownership does not automatically mean mutability.\n"
+"* `mut self`: same as above, but the method can mutate the object. \n"
"* No receiver: this becomes a static method on the struct. Typically used to\n"
" create constructors which are called `new` by convention."
msgstr ""
@@ -6354,7 +5848,7 @@ msgstr ""
"* Sem receptor: isso se torna um método static na estrutura. Normalmente usado para\n"
" criar construtores que, por convenção, são chamados `new`."
-#: src/methods/receiver.md:19
+#: src/methods/receiver.md:18
msgid ""
"Beyond variants on `self`, there are also\n"
"[special wrapper types](https://doc.rust-lang.org/reference/special-types-and-traits.html)\n"
@@ -6364,15 +5858,12 @@ msgstr ""
"[tipos especiais de wrapper](https://doc.rust-lang.org/reference/special-types-and-traits.html)\n"
"que podem ser tipos de receptores, como `Box\n"
-" \n"
-"Pontos chave:\n"
-" * Internamente Rust está usando um campo (discriminante) para acompanhar a variante da enum.\n"
-" * A Enum `Bar` demonstra que existe uma maneira de controlar o valor e o tipo discriminante. Se `repr` for removido, o "
-"tipo discriminante ocupa 2 bytes, porque 10001 cabe 2 bytes.\n"
-" * Como uma otimização de nicho, um discriminante de Enum é mesclado com o ponteiro para que `Option<&Foo>` seja do mesmo "
-"tamanho que `&Foo`.\n"
-" * `Option` é outro exemplo de empacotamento compacto.\n"
-" * Para [alguns tipos](https://doc.rust-lang.org/std/option/#representation), Rust garante que o `size_of::()` é igual a "
-"`size_of:: >()`.\n"
-" * Tipos de tamanho zero permitem a implementação eficiente de `HashSet` usando `HashMap` com `()` como valor."
-
-#: src/enums/sizes.md:49
-msgid ""
-"Example code if you want to show how the bitwise representation *may* look like in practice.\n"
-"It's important to note that the compiler provides no guarantees regarding this representation, therefore this is totally "
-"unsafe."
-msgstr "Código de exemplo se você quiser mostrar como a representação bit a bit *pode* parecer na prática.\n"
-" É importante observar que o compilador não oferece garantias quanto a essa representação, portanto, isso é totalmente "
-"inseguro."
-
-#: src/enums/sizes.md:52
-msgid ""
-"```rust,editable\n"
-"use std::mem::transmute;"
-msgstr ""
-
-#: src/enums/sizes.md:55 src/enums/sizes.md:94
-msgid ""
-"macro_rules! dbg_bits {\n"
-" ($e:expr, $bit_type:ty) => {\n"
-" println!(\"- {}: {:#x}\", stringify!($e), transmute::<_, $bit_type>($e));\n"
-" };\n"
-"}"
-msgstr ""
-
-#: src/enums/sizes.md:61
-msgid ""
-"fn main() {\n"
-" // TOTALLY UNSAFE. Rust provides no guarantees about the bitwise\n"
-" // representation of types.\n"
-" unsafe {\n"
-" println!(\"Bitwise representation of bool\");\n"
-" dbg_bits!(false, u8);\n"
-" dbg_bits!(true, u8);"
-msgstr ""
-"fn main() {\n"
-" // TOTALMENTE INSEGURO. Rust não oferece nenhuma garantia sobre a\n"
-" // representação bit a bit de tipos.\n"
-" unsafe {\n"
-" println!(\"Representação bit a bit do tipo bool\");\n"
-" dbg_bits!(false, u8);\n"
-" dbg_bits!(true, u8);"
-
-#: src/enums/sizes.md:69
-msgid ""
-" println!(\"Bitwise representation of Option\");\n"
-" dbg_bits!(None::, u8);\n"
-" dbg_bits!(Some(false), u8);\n"
-" dbg_bits!(Some(true), u8);"
-msgstr ""
-" println!(\"Representação bit a bit do tipo Option\");\n"
-" dbg_bits!(None::, u8);\n"
-" dbg_bits!(Some(false), u8);\n"
-" dbg_bits!(Some(true), u8);"
-
-#: src/enums/sizes.md:74
-msgid ""
-" println!(\"Bitwise representation of Option>\");\n"
-" dbg_bits!(Some(Some(false)), u8);\n"
-" dbg_bits!(Some(Some(true)), u8);\n"
-" dbg_bits!(Some(None::), u8);\n"
-" dbg_bits!(None::>, u8);"
-msgstr ""
-" println!(\"Representação bit a bit do tipo Option>\");\n"
-" dbg_bits!(Some(Some(false)), u8);\n"
-" dbg_bits!(Some(Some(true)), u8);\n"
-" dbg_bits!(Some(None::), u8);\n"
-" dbg_bits!(None::>, u8);"
-
-#: src/enums/sizes.md:80
-msgid ""
-" println!(\"Bitwise representation of Option<&i32>\");\n"
-" dbg_bits!(None::<&i32>, usize);\n"
-" dbg_bits!(Some(&0i32), usize);\n"
-" }\n"
-"}\n"
-"```"
-msgstr ""
-" println!(\"Representação bit a bit do tipo Option<&i32>\");\n"
-" dbg_bits!(None::<&i32>, usize);\n"
-" dbg_bits!(Some(&0i32), usize);\n"
-" }\n"
-"}\n"
-"```"
-
-#: src/enums/sizes.md:87
-msgid "More complex example if you want to discuss what happens when we chain more than 256 `Option`s together."
-msgstr "Exemplo mais complexo se você quiser discutir o que acontece quando encadeamos mais de 256 `Option` juntas."
-
-#: src/enums/sizes.md:89
-msgid ""
-"```rust,editable\n"
-"#![recursion_limit = \"1000\"]"
-msgstr ""
-"```rust,editable\n"
-"#![recursion_limit = \"1000\"]"
-
-#: src/enums/sizes.md:92
-msgid "use std::mem::transmute;"
-msgstr "use std::mem::transmute;"
-
-#: src/enums/sizes.md:100
-msgid ""
-"// Macro to wrap a value in 2^n Some() where n is the number of \"@\" signs.\n"
-"// Increasing the recursion limit is required to evaluate this macro.\n"
-"macro_rules! many_options {\n"
-" ($value:expr) => { Some($value) };\n"
-" ($value:expr, @) => {\n"
-" Some(Some($value))\n"
-" };\n"
-" ($value:expr, @ $($more:tt)+) => {\n"
-" many_options!(many_options!($value, $($more)+), $($more)+)\n"
-" };\n"
-"}"
-msgstr ""
-"// Macro para envolver um valor com Some() 2^n vezes onde n é o número de simbolos \"@\"\n"
-"// É necessário aumentar o limite de recursão para utilizar essa macro.\n"
-"macro_rules! many_options {\n"
-" ($value:expr) => { Some($value) };\n"
-" ($value:expr, @) => {\n"
-" Some(Some($value))\n"
-" };\n"
-" ($value:expr, @ $($more:tt)+) => {\n"
-" many_options!(many_options!($value, $($more)+), $($more)+)\n"
-" };\n"
-"}"
-
-#: src/enums/sizes.md:112
-msgid ""
-"fn main() {\n"
-" // TOTALLY UNSAFE. Rust provides no guarantees about the bitwise\n"
-" // representation of types.\n"
-" unsafe {\n"
-" assert_eq!(many_options!(false), Some(false));\n"
-" assert_eq!(many_options!(false, @), Some(Some(false)));\n"
-" assert_eq!(many_options!(false, @@), Some(Some(Some(Some(false)))));"
-msgstr ""
-"fn main() {\n"
-" // TOTALMENTE INSEGURO. Rust não oferece nenhuma garantia sobre a\n"
-" // representação bit a bit de tipos.\n"
-" unsafe {\n"
-" assert_eq!(many_options!(false), Some(false));\n"
-" assert_eq!(many_options!(false, @), Some(Some(false)));\n"
-" assert_eq!(many_options!(false, @@), Some(Some(Some(Some(false)))));"
-
-#: src/enums/sizes.md:120
-msgid ""
-" println!(\"Bitwise representation of a chain of 128 Option's.\");\n"
-" dbg_bits!(many_options!(false, @@@@@@@), u8);\n"
-" dbg_bits!(many_options!(true, @@@@@@@), u8);"
-msgstr ""
-" println!(\"Representação bit a bit de uma cadeia de 128 Option's.\");\n"
-" dbg_bits!(many_options!(false, @@@@@@@), u8);\n"
-" dbg_bits!(many_options!(true, @@@@@@@), u8);"
-
-#: src/enums/sizes.md:124
-msgid ""
-" println!(\"Bitwise representation of a chain of 256 Option's.\");\n"
-" dbg_bits!(many_options!(false, @@@@@@@@), u16);\n"
-" dbg_bits!(many_options!(true, @@@@@@@@), u16);"
-msgstr ""
-" println!(\"Representação bit a bit de uma cadeia de 256 Option's.\");\n"
-" dbg_bits!(many_options!(false, @@@@@@@@), u16);\n"
-" dbg_bits!(many_options!(true, @@@@@@@@), u16);"
-
-#: src/enums/sizes.md:128
-msgid ""
-" println!(\"Bitwise representation of a chain of 257 Option's.\");\n"
-" dbg_bits!(many_options!(Some(false), @@@@@@@@), u16);\n"
-" dbg_bits!(many_options!(Some(true), @@@@@@@@), u16);\n"
-" dbg_bits!(many_options!(None::, @@@@@@@@), u16);\n"
-" }\n"
-"}\n"
-"```"
-msgstr ""
-" println!(\"Representação bit a bit de uma cadeia de 257 Option's.\");\n"
-" dbg_bits!(many_options!(Some(false), @@@@@@@@), u16);\n"
-" dbg_bits!(many_options!(Some(true), @@@@@@@@), u16);\n"
-" dbg_bits!(many_options!(None::, @@@@@@@@), u16);\n"
-" }\n"
-"}\n"
-"```"
#: src/methods.md:3
msgid ""
@@ -6244,22 +5756,21 @@ msgstr ""
"Rust permite que você associe funções aos seus novos tipos. Você faz isso com um\n"
"bloco `impl`:"
-#: src/methods.md:13
+#: src/methods.md:6
msgid ""
+"```rust,editable\n"
+"#[derive(Debug)]\n"
+"struct Person {\n"
+" name: String,\n"
+" age: u8,\n"
+"}\n"
+"\n"
"impl Person {\n"
" fn say_hello(&self) {\n"
" println!(\"Hello, my name is {}\", self.name);\n"
" }\n"
-"}"
-msgstr ""
-"impl Pessoa {\n"
-" fn diz_ola(&self) {\n"
-" println!(\"Olá, meu nome é {}\", self.nome);\n"
-" }\n"
-"}"
-
-#: src/methods.md:19
-msgid ""
+"}\n"
+"\n"
"fn main() {\n"
" let peter = Person {\n"
" name: String::from(\"Peter\"),\n"
@@ -6269,47 +5780,30 @@ msgid ""
"}\n"
"```"
msgstr ""
-"fn main() {\n"
-" let pedro = Pessoa {\n"
-" nome: String::from(\"Pedro\"),\n"
-" idade: 27,\n"
-" };\n"
-" pedro.diz_ola();\n"
-"}\n"
-"```"
-#: src/methods.md:30
+#: src/methods.md:31
+#, fuzzy
msgid ""
-"Key Points:\n"
"* It can be helpful to introduce methods by comparing them to functions.\n"
-" * Methods are called on an instance of a type (such as a struct or enum), the first parameter represents the instance as "
-"`self`.\n"
-" * Developers may choose to use methods to take advantage of method receiver syntax and to help keep them more organized. "
-"By using methods we can keep all the implementation code in one predictable place.\n"
+" * Methods are called on an instance of a type (such as a struct or enum), the first parameter represents the instance as `self`.\n"
+" * Developers may choose to use methods to take advantage of method receiver syntax and to help keep them more organized. By using methods we can keep all the implementation code in one predictable place.\n"
"* Point out the use of the keyword `self`, a method receiver. \n"
" * Show that it is an abbreviated term for `self:&Self` and perhaps show how the struct name could also be used. \n"
" * Explain that `Self` is a type alias for the type the `impl` block is in and can be used elsewhere in the block.\n"
" * Note how `self` is used like other structs and dot notation can be used to refer to individual fields.\n"
-" * 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. \n"
+" * 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. \n"
"* We describe the distinction between method receivers next.\n"
-" \n"
-"
"
+" "
msgstr ""
"Pontos chave:\n"
"* Pode ser útil introduzir métodos comparando-os com funções.\n"
-" * Métodos são chamados em uma instância de um tipo (como struct ou enum), o primeiro parâmetro representa a instância "
-"como `self`.\n"
-" * Os desenvolvedores podem optar por usar métodos para aproveitar a sintaxe do receptor do método e ajudar a mantê-los "
-"mais organizados. Usando métodos, podemos manter todo o código de implementação em um local previsível.\n"
+" * Métodos são chamados em uma instância de um tipo (como struct ou enum), o primeiro parâmetro representa a instância como `self`.\n"
+" * Os desenvolvedores podem optar por usar métodos para aproveitar a sintaxe do receptor do método e ajudar a mantê-los mais organizados. Usando métodos, podemos manter todo o código de implementação em um local previsível.\n"
"* Destaque o uso da palavra-chave `self`, um receptor de método.\n"
" * Mostre que é um termo abreviado para `self:&Self` e talvez mostre como o nome da struct também poderia ser usado.\n"
-" * Explique que `Self` é um apelido de tipo para o tipo em que o bloco `impl` está e pode ser usado em qualquer outro lugar no "
-"bloco.\n"
-" * Observe como _self_ é usado com outras _Structs_ e a notação de _ponto_ pode ser usada para se referir a campos "
-"individuais.\n"
-" * Este pode ser um bom momento para demonstrar como `&self` difere de `self` modificando o código e tentando executar "
-"`diz_ola` duas vezes.\n"
+" * Explique que `Self` é um apelido de tipo para o tipo em que o bloco `impl` está e pode ser usado em qualquer outro lugar no bloco.\n"
+" * Observe como _self_ é usado com outras _Structs_ e a notação de _ponto_ pode ser usada para se referir a campos individuais.\n"
+" * Este pode ser um bom momento para demonstrar como `&self` difere de `self` modificando o código e tentando executar `diz_ola` duas vezes.\n"
"* Descreveremos a distinção entre os receptores de método a seguir.\n"
" \n"
"\n"
-" \n"
-"Consider emphasizing on \"shared and immutable\" and \"unique and mutable\". These constraints always come\n"
-"together in Rust due to borrow checker rules, and `self` is no exception. It won't be possible to\n"
-"reference a struct from multiple locations and call a mutating (`&mut self`) method on it.\n"
-" \n"
-"
"
+"Consider emphasizing \"shared and immutable\" and \"unique and mutable\". These constraints always come\n"
+"together in Rust due to borrow checker rules, and `self` is no exception. It isn't possible to\n"
+"reference a struct from multiple locations and call a mutating (`&mut self`) method on it."
msgstr ""
"\n"
" \n"
@@ -6393,69 +5884,30 @@ msgid ""
"struct Race {\n"
" name: String,\n"
" laps: Vec,\n"
-"}"
-msgstr ""
-"```rust, editable\n"
-"#[derive(Debug)]\n"
-"struct Corrida {\n"
-" nome: String,\n"
-" voltas: Vec,\n"
-"}"
-
-#: src/methods/example.md:10
-msgid ""
+"}\n"
+"\n"
"impl Race {\n"
" fn new(name: &str) -> Race { // No receiver, a static method\n"
" Race { name: String::from(name), laps: Vec::new() }\n"
-" }"
-msgstr ""
-"impl Corrida {\n"
-" fn new(nome: &str) -> Corrida { // Um método estático, sem a definição de um receptor.\n"
-" Corrida { nome: String::from(nome), voltas: Vec::new() }\n"
-" }"
-
-#: src/methods/example.md:15
-msgid ""
+" }\n"
+"\n"
" fn add_lap(&mut self, lap: i32) { // Exclusive borrowed read-write access to self\n"
" self.laps.push(lap);\n"
-" }"
-msgstr ""
-" fn adiciona_volta(&mut self, volta: i32) { // Acesso emprestado de leitura e gravação exclusivo para self\n"
-" self.voltas.push(volta);\n"
-" }"
-
-#: src/methods/example.md:19
-msgid ""
+" }\n"
+"\n"
" fn print_laps(&self) { // Shared and read-only borrowed access to self\n"
" println!(\"Recorded {} laps for {}:\", self.laps.len(), self.name);\n"
" for (idx, lap) in self.laps.iter().enumerate() {\n"
" println!(\"Lap {idx}: {lap} sec\");\n"
" }\n"
-" }"
-msgstr ""
-" fn imprime_voltas(&self) { // Acesso emprestado compartilhado e somente leitura para self\n"
-" println!(\"Gravadas {} voltas para {}:\", self.voltas.len(), self.nome);\n"
-" for (idx, volta) in self.voltas.iter().enumerate() {\n"
-" println!(\"Volta {idx}: {volta} seg.\");\n"
-" }\n"
-" }"
-
-#: src/methods/example.md:26
-msgid ""
+" }\n"
+"\n"
" fn finish(self) { // Exclusive ownership of self\n"
" let total = self.laps.iter().sum::();\n"
" println!(\"Race {} is finished, total lap time: {}\", self.name, total);\n"
" }\n"
-"}"
-msgstr ""
-" fn finaliza(self) { // ownership exclusiva de self\n"
-" let total = self.voltas.iter().sum::();\n"
-" println!(\"A corrida {} terminou, tempo total da volta: {}\", self.nome, total);\n"
-" }\n"
-"}"
-
-#: src/methods/example.md:32
-msgid ""
+"}\n"
+"\n"
"fn main() {\n"
" let mut race = Race::new(\"Monaco Grand Prix\");\n"
" race.add_lap(70);\n"
@@ -6468,43 +5920,23 @@ msgid ""
"}\n"
"```"
msgstr ""
-"fn main() {\n"
-" let mut corrida = Corrida::new(\"Grande Prêmio de Mônaco\");\n"
-" corrida.adiciona_volta(70);\n"
-" corrida.adiciona_volta(68);\n"
-" corrida.imprime_voltas();\n"
-" corrida.adiciona_volta(71);\n"
-" corrida.imprime_voltas();\n"
-" corrida.finaliza();\n"
-" // corrida.adiciona_volta(42);\n"
-"}\n"
-"```"
-#: src/methods/example.md:44
+#: src/methods/example.md:47
+#, fuzzy
msgid ""
-"
"
+"* The condition defined in the guard applies to every expression in a pattern with an `|`."
msgstr ""
"Pontos chave:\n"
"* Guardas de correspondência, como um recurso de sintaxe separado, são importantes e necessários.\n"
"Permitem expressar ideias mais complexas do que somente o padrão permitiria.\n"
-"* Eles não são iguais à expressão `if` separada dentro do bloco de correspondência. Uma expressão `if` dentro do bloco de "
-"ramificação (depois de `=>`) acontece depois que a correspondência é selecionada. A falha na condição `if` dentro "
-"desse bloco não resultará em outras verificações de correspondência\n"
+"* Eles não são iguais à expressão `if` separada dentro do bloco de correspondência. Uma expressão `if` dentro do bloco de ramificação (depois de `=>`) acontece depois que a correspondência é selecionada. A falha na condição `if` dentro desse bloco não resultará em outras verificações de correspondência\n"
"da expressão `match` original serem consideradas.\n"
"* Você pode usar as variáveis definidas no padrão em sua expressão `if`.\n"
"* A condição definida na guarda se aplica a todas as expressões em um padrão com um `|`.\n"
@@ -6887,11 +6273,11 @@ msgid "We will look at implementing methods in two contexts:"
msgstr "Veremos a implementação de métodos em dois contextos:"
#: src/exercises/day-2/morning.md:5
-msgid "* Simple struct which tracks health statistics."
-msgstr "* Estrutura simples que rastreia as estatísticas de saúde."
-
-#: src/exercises/day-2/morning.md:7
-msgid "* Multiple structs and enums for a drawing library."
+#, fuzzy
+msgid ""
+"* Simple struct which tracks health statistics.\n"
+"\n"
+"* Multiple structs and enums for a drawing library."
msgstr "* Várias estruturas e enumerações para uma biblioteca de desenho."
#: src/exercises/day-2/health-statistics.md:1
@@ -6920,115 +6306,57 @@ msgstr ""
msgid ""
"Copy the code below to \n"
-" \n"
-"Key Points:\n"
"* All four methods here use a different method receiver.\n"
-" * 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`.\n"
+" * 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`.\n"
" * You can showcase the error that appears when trying to call `finish` twice.\n"
-"* Note, that although the method receivers are different, the non-static functions are called the same way in the main "
-"body. Rust enables automatic referencing and dereferencing when calling methods. Rust automatically adds in the `&`, `*`, "
-"`muts` so that that object matches the method signature.\n"
-"* You might point out that `print_laps` is using a vector that is iterated over. We describe vectors in more detail in the "
-"afternoon. "
+"* Note that although the method receivers are different, the non-static functions are called the same way in the main body. Rust enables automatic referencing and dereferencing when calling methods. Rust automatically adds in the `&`, `*`, `muts` so that that object matches the method signature.\n"
+"* 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 ""
"
"
+"* Destructuring of slices of unknown length also works with patterns of fixed length.\n"
+"\n"
+"\n"
+" ```rust,editable\n"
+" fn main() {\n"
+" inspect(&[0, -2, 3]);\n"
+" inspect(&[0, -2, 3, 4]);\n"
+" }\n"
+"\n"
+" #[rustfmt::skip]\n"
+" fn inspect(slice: &[i32]) {\n"
+" println!(\"Tell me about {slice:?}\");\n"
+" match slice {\n"
+" &[0, y, z] => println!(\"First is 0, y = {y}, and z = {z}\"),\n"
+" &[1, ..] => println!(\"First is 1 and the rest were ignored\"),\n"
+" _ => println!(\"All elements were ignored\"),\n"
+" }\n"
+" }\n"
+" ```\n"
+" \n"
+"* Create a new pattern using `_` to represent an element. \n"
+"* Add more values to the array.\n"
+"* Point out that how `..` will expand to account for different number of elements.\n"
+"* Show matching against the tail with patterns `[.., b]` and `[a@..,b]`"
msgstr ""
"#[rustfmt::skip]\n"
"fn inspect(slice: &[i32]) {\n"
@@ -6854,25 +6246,19 @@ msgstr ""
"}\n"
"```"
-#: src/pattern-matching/match-guards.md:22
+#: src/pattern-matching/match-guards.md:23
+#, fuzzy
msgid ""
-"Key Points:\n"
-"* Match guards as a separate syntax feature are important and necessary when we wish to concisely express more complex "
-"ideas than patterns alone would allow.\n"
-"* They are not the same as separate `if` expression inside of the match arm. An `if` expression inside of the branch block "
-"(after `=>`) happens after the match arm is selected. Failing the `if` condition inside of that block won't result in other "
-"arms\n"
+"* Match guards as a separate syntax feature are important and necessary when we wish to concisely express more complex ideas than patterns alone would allow.\n"
+"* They are not the same as separate `if` expression inside of the match arm. An `if` expression inside of the branch block (after `=>`) happens after the match arm is selected. Failing the `if` condition inside of that block won't result in other arms\n"
"of the original `match` expression being considered. \n"
"* You can use the variables defined in the pattern in your if expression.\n"
-"* The condition defined in the guard applies to every expression in a pattern with an `|`.\n"
-"\n"
" \n"
"Pontos chave:\n"
"* Todos os quatro métodos aqui usam um receptor de método diferente.\n"
-" * Você pode apontar como isso muda o que a função pode fazer com os valores das variáveis e se/como ela pode ser usada "
-"novamente em `main`.\n"
+" * Você pode apontar como isso muda o que a função pode fazer com os valores das variáveis e se/como ela pode ser usada novamente em `main`.\n"
" * Você pode mostrar o erro que aparece ao tentar chamar `finish` duas vezes.\n"
-"* Observe que, embora os receptores do método sejam diferentes, as funções não estáticas são chamadas da mesma maneira no "
-"corpo principal. Rust permite referenciar e desreferenciar automaticamente ao chamar métodos. Rust adiciona automaticamente "
-"`&`, `*`, `muts` para que esse objeto corresponda à assinatura do método.\n"
+"* Observe que, embora os receptores do método sejam diferentes, as funções não estáticas são chamadas da mesma maneira no corpo principal. Rust permite referenciar e desreferenciar automaticamente ao chamar métodos. Rust adiciona automaticamente `&`, `*`, `muts` para que esse objeto corresponda à assinatura do método.\n"
"* Você pode apontar que `print_laps` está usando um vetor iterado. Descreveremos os vetores com mais\n"
"detalhes à tarde."
@@ -6525,17 +5957,12 @@ msgid "The patterns can be simple values, similarly to `switch` in C and C++:"
msgstr "Os padrões podem ser valores simples, similarmente a `switch` em C e C++:"
#: src/pattern-matching.md:8
+#, fuzzy
msgid ""
"```rust,editable\n"
"fn main() {\n"
-" let input = 'x';"
-msgstr ""
-"```rust, editable\n"
-"fn main() {\n"
-" let input = 'x';"
-
-#: src/pattern-matching.md:12
-msgid ""
+" let input = 'x';\n"
+"\n"
" match input {\n"
" 'q' => println!(\"Quitting\"),\n"
" 'a' | 's' | 'w' | 'd' => println!(\"Moving around\"),\n"
@@ -6558,22 +5985,18 @@ msgstr ""
msgid "The `_` pattern is a wildcard pattern which matches any value."
msgstr "O padrão `_` é um padrão curinga que corresponde a qualquer valor."
-#: src/pattern-matching.md:23
+#: src/pattern-matching.md:26
+#, fuzzy
msgid ""
-"
"
#: src/pattern-matching/destructuring-arrays.md:1
msgid "# Destructuring Arrays"
@@ -6771,33 +6163,33 @@ msgstr ""
"}\n"
"```"
-#: src/pattern-matching/destructuring-arrays.md:20
-msgid "* Destructuring of slices of unknown length also works with patterns of fixed length."
-msgstr "* Desestruturar slices de tamanho desconhecido também funciona com padrões de tamanho fixo."
-
-#: src/pattern-matching/destructuring-arrays.md:22
+#: src/pattern-matching/destructuring-arrays.md:21
+#, fuzzy
msgid ""
-"```rust,editable\n"
-"fn main() {\n"
-" inspect(&[0, -2, 3]);\n"
-" inspect(&[0, -2, 3, 4]);\n"
-"}"
-msgstr ""
-
-#: src/pattern-matching/destructuring-arrays.md:28
-msgid ""
-"#[rustfmt::skip]\n"
-"fn inspect(slice: &[i32]) {\n"
-" println!(\"Tell me about {slice:?}\");\n"
-" match slice {\n"
-" &[0, y, z] => println!(\"First is 0, y = {y}, and z = {z}\"),\n"
-" &[1, ..] => println!(\"First is 1 and the rest were ignored\"),\n"
-" _ => println!(\"All elements were ignored\"),\n"
-" }\n"
-"}\n"
-"```\n"
-"* Show matching against the tail with patterns `[.., b]` and `[a@..,b]`\n"
-"\n"
-" \n"
-"Key Points:\n"
"* You might point out how some specific characters are being used when in a pattern\n"
" * `|` as an `or`\n"
" * `..` can expand as much as it needs to be\n"
" * `1..=5` represents an inclusive range\n"
" * `_` is a wild card\n"
-"* It can be useful to show how binding works, by for instance replacing a wildcard character with a variable, or removing "
-"the quotes around `q`.\n"
+"* It can be useful to show how binding works, by for instance replacing a wildcard character with a variable, or removing the quotes around `q`.\n"
"* You can demonstrate matching on a reference.\n"
"* This might be a good time to bring up the concept of irrefutable patterns, as the term can show up in error messages.\n"
-" \n"
-"
"
+" "
msgstr ""
"\n"
" \n"
@@ -6583,11 +6006,9 @@ msgstr ""
" * `..` pode expandir o quanto for necessário\n"
" * `1..=5` representa um intervalo inclusivo\n"
" * `_` é um curinga\n"
-"* Pode ser útil mostrar como funciona a vinculação, por exemplo, substituindo um caractere curinga por uma variável ou "
-"removendo as aspas ao redor de `q`.\n"
+"* Pode ser útil mostrar como funciona a vinculação, por exemplo, substituindo um caractere curinga por uma variável ou removendo as aspas ao redor de `q`.\n"
"* Você pode demonstrar correspondência em uma referência.\n"
-"* Este pode ser um bom momento para trazer à tona o conceito de padrões irrefutáveis, já que o termo pode aparecer em "
-"mensagens de erro.\n"
+"* Este pode ser um bom momento para trazer à tona o conceito de padrões irrefutáveis, já que o termo pode aparecer em mensagens de erro.\n"
" \n"
"
"
@@ -6604,39 +6025,22 @@ msgstr ""
"que você inspeciona a estrutura de seus tipos. Vamos começar com um tipo `enum` simples:"
#: src/pattern-matching/destructuring-enums.md:6
+#, fuzzy
msgid ""
"```rust,editable\n"
"enum Result {\n"
" Ok(i32),\n"
" Err(String),\n"
-"}"
-msgstr ""
-"```rust,editable\n"
-"enum Result {\n"
-" Ok(i32),\n"
-" Err(String),\n"
-"}"
-
-#: src/pattern-matching/destructuring-enums.md:12
-msgid ""
+"}\n"
+"\n"
"fn divide_in_two(n: i32) -> Result {\n"
" if n % 2 == 0 {\n"
" Result::Ok(n / 2)\n"
" } else {\n"
" Result::Err(format!(\"cannot divide {n} into two equal parts\"))\n"
" }\n"
-"}"
-msgstr ""
-"fn divide_por_dois(n: i32) -> Result {\n"
-" if n % 2 == 0 {\n"
-" Result::Ok(n/2)\n"
-" } else {\n"
-" Result::Err(format!(\"Não é possível dividir {} em duas partes iguais\", n))\n"
-" }\n"
-"}"
-
-#: src/pattern-matching/destructuring-enums.md:20
-msgid ""
+"}\n"
+"\n"
"fn main() {\n"
" let n = 100;\n"
" match divide_in_two(n) {\n"
@@ -6665,17 +6069,15 @@ msgstr ""
"verificação de correspondência, `metade` está vinculado ao valor dentro da variante `Ok`. Na segunda,\n"
"`msg` está vinculado à mensagem de erro."
-#: src/pattern-matching/destructuring-enums.md:35
+#: src/pattern-matching/destructuring-enums.md:36
+#, fuzzy
msgid ""
-"Key points:\n"
"* The `if`/`else` expression is returning an enum that is later unpacked with a `match`.\n"
-"* You can try adding a third variant to the enum definition and displaying the errors when running the code. Point out the "
-"places where your code is now inexhaustive and how the compiler tries to give you hints."
+"* You can try adding a third variant to the enum definition and displaying the errors when running the code. Point out the places where your code is now inexhaustive and how the compiler tries to give you hints."
msgstr ""
"Pontos chave:\n"
"* A expressão `if`/`else` está retornando um enum que é posteriormente descompactado com um `match`.\n"
-"* Você pode tentar adicionar uma terceira variante à definição de Enum e exibir os erros ao executar o código. Aponte os "
-"lugares onde seu código agora é \"não exaustivo\" e como o compilador tenta lhe dar dicas."
+"* Você pode tentar adicionar uma terceira variante à definição de Enum e exibir os erros ao executar o código. Aponte os lugares onde seu código agora é \"não exaustivo\" e como o compilador tenta lhe dar dicas."
#: src/pattern-matching/destructuring-structs.md:1
msgid "# Destructuring Structs"
@@ -6686,21 +6088,14 @@ msgid "You can also destructure `structs`:"
msgstr "Você também pode desestruturar `structs`:"
#: src/pattern-matching/destructuring-structs.md:5
+#, fuzzy
msgid ""
"```rust,editable\n"
"struct Foo {\n"
" x: (u32, u32),\n"
" y: u32,\n"
-"}"
-msgstr ""
-"```rust, editable\n"
-"struct Foo {\n"
-" x: (u32, u32),\n"
-" y: u32,\n"
-"}"
-
-#: src/pattern-matching/destructuring-structs.md:11
-msgid ""
+"}\n"
+"\n"
"#[rustfmt::skip]\n"
"fn main() {\n"
" let foo = Foo { x: (1, 2), y: 3 };\n"
@@ -6710,8 +6105,7 @@ msgid ""
" Foo { y, .. } => println!(\"y = {y}, other fields were ignored\"),\n"
" }\n"
"}\n"
-"```\n"
-""
+"```"
msgstr ""
"#[rustfmt::skip]\n"
"fn main() {\n"
@@ -6728,12 +6122,10 @@ msgstr ""
msgid ""
"* Change the literal values in `foo` to match with the other patterns.\n"
"* Add a new field to `Foo` and make changes to the pattern as needed.\n"
-"
"
+"* The distinction between a capture and a constant expression can be hard to\n"
+" spot. Try changing the `2` in the second arm to a variable, and see that it subtly\n"
+" doesn't work. Change it to a `const` and see it working again."
msgstr ""
-"* Altere os valores literais em `foo` para corresponderem com outros padrões.\n"
-"* Adicione um novo campo em `Foo` e faça as alterações no padrão"
-" conforme necessário.\n"
-"\n"
-" \n"
"* Index iteration is not a special syntax in Rust for just that case.\n"
"* `(0..10)` is a range that implements an `Iterator` trait. \n"
"* `step_by` is a method that returns another `Iterator` that skips every other element. \n"
-"* Modify the elements in the vector and explain the compiler errors. Change vector `v` to be mutable and the for loop to "
-"`for x in v.iter_mut()`."
+"* Modify the elements in the vector and explain the compiler errors. Change vector `v` to be mutable and the for loop to `for x in v.iter_mut()`."
msgstr ""
">>,\n"
" children: Vec>>,\n"
-"}"
-msgstr ""
-"#[derive(Debug)]\n"
-"struct No {\n"
-" valor: i64,\n"
-" pai: Option>>,\n"
-" filhos: Vec>>,\n"
-"}"
-
-#: src/std/rc.md:49
-msgid ""
+"}\n"
+"\n"
"fn main() {\n"
" let mut root = Rc::new(RefCell::new(Node {\n"
" value: 42,\n"
@@ -8649,7 +7684,11 @@ msgid ""
" children: vec![],\n"
" parent: Some(Rc::downgrade(&root))\n"
" }));\n"
-" root.borrow_mut().children.push(child);"
+" root.borrow_mut().children.push(child);\n"
+"\n"
+" println!(\"graph: {root:#?}\");\n"
+"}\n"
+"```"
msgstr ""
"fn main() {\n"
" let mut raiz = Rc::new(RefCell::new(No {\n"
@@ -8664,16 +7703,6 @@ msgstr ""
" }));\n"
" raiz.borrow_mut().filhos.push(filho);"
-#: src/std/rc.md:62
-msgid ""
-" println!(\"graph: {root:#?}\");\n"
-"}\n"
-"```"
-msgstr ""
-" println!(\"grafo: {raiz:#?}\");\n"
-"}\n"
-"```"
-
#: src/modules.md:1
msgid "# Modules"
msgstr "# Módulos"
@@ -8693,48 +7722,27 @@ msgid ""
" pub fn do_something() {\n"
" println!(\"In the foo module\");\n"
" }\n"
-"}"
-msgstr ""
-"```rust, editable\n"
-"mod foo {\n"
-" pub fn qualquer_coisa() {\n"
-" println!(\"Qualquer coisa no módulo foo\");\n"
-" }\n"
-"}"
-
-#: src/modules.md:14
-msgid ""
+"}\n"
+"\n"
"mod bar {\n"
" pub fn do_something() {\n"
" println!(\"In the bar module\");\n"
" }\n"
-"}"
-msgstr ""
-"mod bar {\n"
-" pub fn qualquer_coisa() {\n"
-" println!(\"Qualquer coisa no modulo bar\");\n"
-" }\n"
-"}"
-
-#: src/modules.md:20
-msgid ""
+"}\n"
+"\n"
"fn main() {\n"
" foo::do_something();\n"
" bar::do_something();\n"
"}\n"
"```"
msgstr ""
-"fn main() {\n"
-" foo::qualquer_coisa();\n"
-" bar::qualquer_coisa();\n"
-"}\n"
-"```"
#: src/modules.md:28
+#, fuzzy
msgid ""
"* Packages provide functionality and include a `Cargo.toml` file that describes how to build a bundle of 1+ crates.\n"
"* Crates are a tree of modules, where a binary crate creates an executable and a library crate compiles to a library.\n"
-"* Modules define organization, scope, and is the focus of this section."
+"* Modules define organization, scope, and are the focus of this section."
msgstr ""
"* Pacotes (packages) forneces funcionalidades e incluem o arquivo `Cargo.toml` que descreve como gerar o pacote com um ou mais _crates_.\n"
"* _Crates_ são arvores de módulos onde um _crate_ birário cria um executável e um _crate_ de biblioteca compila uma biblioteca.\n"
@@ -8764,83 +7772,50 @@ msgid ""
"mod outer {\n"
" fn private() {\n"
" println!(\"outer::private\");\n"
-" }"
-msgstr ""
-"```rust, editable\n"
-"mod exterior {\n"
-" fn privado() {\n"
-" println!(\"externo::privado\");\n"
-" }"
-
-#: src/modules/visibility.md:16
-msgid ""
+" }\n"
+"\n"
" pub fn public() {\n"
" println!(\"outer::public\");\n"
-" }"
-msgstr ""
-" pub fn public() {\n"
-" println!(\"externo::público\");\n"
-" }"
-
-#: src/modules/visibility.md:20
-msgid ""
+" }\n"
+"\n"
" mod inner {\n"
" fn private() {\n"
" println!(\"outer::inner::private\");\n"
-" }"
-msgstr ""
-" mod interior {\n"
-" fn privado() {\n"
-" println!(\"externo::interno::privado\");\n"
-" }"
-
-#: src/modules/visibility.md:25
-msgid ""
+" }\n"
+"\n"
" pub fn public() {\n"
" println!(\"outer::inner::public\");\n"
" super::private();\n"
" }\n"
" }\n"
-"}"
-msgstr ""
-" pub fn public() {\n"
-" println!(\"externo::interno::público\");\n"
-" super::privado();\n"
-" }\n"
-" }\n"
-"}"
-
-#: src/modules/visibility.md:32
-msgid ""
+"}\n"
+"\n"
"fn main() {\n"
" outer::public();\n"
"}\n"
"```"
msgstr ""
-"fn main() {\n"
-" exterior::public();\n"
-"}\n"
-"```"
#: src/modules/visibility.md:39
-msgid "* Use the `pub` keyword to make mods public."
+#, fuzzy
+msgid "* Use the `pub` keyword to make modules public."
msgstr "* Use a palavra reservada `pub` para tornar um módulo público."
#: src/modules/visibility.md:41
msgid "Additionally, there are advanced `pub(...)` specifiers to restrict the scope of public visibility."
-msgstr "Adicionamente, existem especificadores `pub(...)` avançados para restringir o\n"
+msgstr ""
+"Adicionamente, existem especificadores `pub(...)` avançados para restringir o\n"
"escopo da visibilidade pública."
#: src/modules/visibility.md:43
+#, fuzzy
msgid ""
-"* See the [Rust Reference](https://doc.rust-lang.org/reference/visibility-and-privacy.html#pubin-path-pubcrate-pubsuper-and-"
-"pubself)).\n"
+"* See the [Rust Reference](https://doc.rust-lang.org/reference/visibility-and-privacy.html#pubin-path-pubcrate-pubsuper-and-pubself).\n"
"* Configuring `pub(crate)` visibility is a common pattern.\n"
"* Less commonly, you can give visibility to a specific path.\n"
"* In any case, visibility must be granted to an ancestor module (and all of its descendants)."
msgstr ""
-"* Veja a [Referência Rust](https://doc.rust-lang.org/reference/visibility-and-privacy.html#pubin-path-pubcrate-pubsuper-and-"
-"pubself).\n"
+"* Veja a [Referência Rust](https://doc.rust-lang.org/reference/visibility-and-privacy.html#pubin-path-pubcrate-pubsuper-and-pubself).\n"
"* `pub(crate)` é a configuração padrão de visibilidade.\n"
"* Menos comum, você pode dar visibilidade para um caminho específico.\n"
"* Em todo caso, a visibilidade deve ser concedida ao módulo ancestral (e a todos os seus descendentes)."
@@ -8854,17 +7829,12 @@ msgid "Paths are resolved as follows:"
msgstr "Os caminhos são resolvidos da seguinte forma:"
#: src/modules/paths.md:5
+#, fuzzy
msgid ""
"1. As a relative path:\n"
" * `foo` or `self::foo` refers to `foo` in the current module,\n"
-" * `super::foo` refers to `foo` in the parent module."
-msgstr ""
-"1. Como caminho relativo:\n"
-" * `foo` ou `self::foo` refere-se a `foo` no módulo atual,\n"
-" * `super::foo` refere-se a `foo` no módulo pai."
-
-#: src/modules/paths.md:9
-msgid ""
+" * `super::foo` refers to `foo` in the parent module.\n"
+"\n"
"2. As an absolute path:\n"
" * `crate::foo` refers to `foo` in the root of the current crate,\n"
" * `bar::foo` refers to `foo` in the `bar` crate."
@@ -8873,6 +7843,23 @@ msgstr ""
" * `crate::foo` refere-se a `foo` na raiz do _crate_ atual,\n"
" * `bar::foo` refere-se a `foo` no _crate_ `bar`."
+#: src/modules/paths.md:13
+msgid ""
+"A module can bring symbols from another module into scope with `use`.\n"
+"You will typically see something like this at the top of each module:"
+msgstr ""
+
+#: src/modules/paths.md:16
+#, fuzzy
+msgid ""
+"```rust,editable\n"
+"use std::collections::HashSet;\n"
+"use std::mem::transmute;\n"
+"```"
+msgstr ""
+"```rust,editable\n"
+"use std::collections::HashMap;"
+
#: src/modules/filesystem.md:1
msgid "# Filesystem Hierarchy"
msgstr "# Hierarquia do sistema de arquivos"
@@ -8927,6 +7914,60 @@ msgstr ""
"* `src/lib.rs` (para um _crate_ de biblioteca)\n"
"* `src/main.rs` (para um _crate_ binário)"
+#: src/modules/filesystem.md:24
+msgid ""
+"Modules defined in files can be documented, too, using \"inner doc comments\".\n"
+"These document the item that contains them -- in this case, a module."
+msgstr ""
+
+#: src/modules/filesystem.md:27
+msgid ""
+"```rust,editable,compile_fail\n"
+"//! This module implements the garden, including a highly performant germination\n"
+"//! implementation.\n"
+"\n"
+"// Re-export types from this module.\n"
+"pub use seeds::SeedPacket;\n"
+"pub use garden::Garden;\n"
+"\n"
+"/// Sow the given seed packets.\n"
+"pub fn sow(seeds: Vec) { todo!() }\n"
+"\n"
+"/// Harvest the produce in the garden that is ready.\n"
+"pub fn harvest(garden: &mut Garden) { todo!() }\n"
+"```"
+msgstr ""
+
+#: src/modules/filesystem.md:44
+msgid ""
+"* The change from `module/mod.rs` to `module.rs` doesn't preclude the use of submodules in Rust 2018.\n"
+" (It was mandatory in Rust 2015.)\n"
+"\n"
+" The following is valid:\n"
+"\n"
+" ```ignore\n"
+" src/\n"
+" ├── main.rs\n"
+" ├── top_module.rs\n"
+" └── top_module/\n"
+" └── sub_module.rs\n"
+" ```\n"
+"\n"
+"* The main reason for the change is to prevent many files named `mod.rs`, which can be hard\n"
+" to distinguish in IDEs.\n"
+"\n"
+"* Rust will look for modules in `modulename/mod.rs` and `modulename.rs`, but this can be changed\n"
+" with a compiler directive:\n"
+"\n"
+" ```rust,ignore\n"
+" #[path = \"some/path.rs\"]\n"
+" mod some_module { }\n"
+" ```\n"
+"\n"
+" This is useful, for example, if you would like to place tests for a module in a file named\n"
+" `some_module_test.rs`, similar to the convention in Go."
+msgstr ""
+
#: src/exercises/day-2/afternoon.md:1
msgid "# Day 2: Afternoon Exercises"
msgstr "# Dia 2: Exercícios da Tarde"
@@ -8950,32 +7991,19 @@ msgstr ""
"seguinte para validar o número do cartão de crédito:"
#: src/exercises/day-2/luhn.md:7
-msgid "* Ignore all spaces. Reject number with less than two digits."
-msgstr "* Ignora todos os espaços. Rejeita números com menos de dois dígitos."
-
-#: src/exercises/day-2/luhn.md:9
msgid ""
+"* Ignore all spaces. Reject number with less than two digits.\n"
+"\n"
"* Moving from right to left, double every second digit: for the number `1234`,\n"
-" we double `3` and `1`."
-msgstr ""
-"* Movendo-se da direita para a esquerda, dobra cada segundo dígito: para o número `1234`,\n"
-" dobra os números `3` e `1`."
-
-#: src/exercises/day-2/luhn.md:12
-msgid ""
+" we double `3` and `1`.\n"
+"\n"
"* After doubling a digit, sum the digits. So doubling `7` becomes `14` which\n"
-" becomes `5`."
+" becomes `5`.\n"
+"\n"
+"* Sum all the undoubled and doubled digits.\n"
+"\n"
+"* The credit card number is valid if the sum ends with `0`."
msgstr ""
-"* Depois de dobrar um dígito, soma os dígitos. Assim, duplicar `7` resulta em `14` que\n"
-" resulta em `5`."
-
-#: src/exercises/day-2/luhn.md:15
-msgid "* Sum all the undoubled and doubled digits."
-msgstr "* Soma todos os dígitos não duplicados e duplicados."
-
-#: src/exercises/day-2/luhn.md:17
-msgid "* The credit card number is valid if the sum ends with `0`."
-msgstr "* O número do cartão de crédito é válido se a soma terminar em `0`."
#: src/exercises/day-2/luhn.md:19
msgid ""
@@ -8985,101 +8013,57 @@ msgstr ""
"Copie o seguinte código para {\n"
+" x: T,\n"
+" y: T,\n"
+"}\n"
+"\n"
+"fn main() {\n"
+" let integer = Point { x: 5, y: 10 };\n"
+" let float = Point { x: 1.0, y: 4.0 };\n"
+" println!(\"{integer:?} and {float:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+"fn main() {\n"
+" let inteiro = Ponto { x: 5, y: 10 };\n"
+" let real = Ponto { x: 1.0, y: 4.0 };\n"
+" println!(\"{inteiro:?} e {real:?}\");\n"
+"}\n"
+"```"
+
+#: src/generics/data-types.md:21
+msgid ""
+"* Try declaring a new variable `let p = Point { x: 5, y: 10.0 };`.\n"
+"\n"
+"* Fix the code to allow points that have elements of different types."
+msgstr ""
+
+#: src/generics/methods.md:1
+msgid "# Generic Methods"
+msgstr "# Métodos Genéricos"
+
+#: src/generics/methods.md:3
+msgid "You can declare a generic type on your `impl` block:"
+msgstr "Você pode declarar um tipo genérico em seu bloco `impl`:"
+
+#: src/generics/methods.md:5
+msgid ""
+"```rust,editable\n"
+"#[derive(Debug)]\n"
+"struct Point(T, T);\n"
+"\n"
+"impl Point {\n"
+" fn x(&self) -> &T {\n"
+" &self.0 // + 10\n"
+" }\n"
+"\n"
+" // fn set_x(&mut self, x: T)\n"
+"}\n"
+"\n"
+"fn main() {\n"
+" let p = Point(5, 10);\n"
+" println!(\"p.x = {}\", p.x());\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/generics/methods.md:25
+msgid ""
+"* *Q:* Why `T` is specified twice in `impl Point {}`? Isn't that redundant?\n"
+" * This is because it is a generic implementation section for generic type. They are independently generic.\n"
+" * It means these methods are defined for any `T`.\n"
+" * It is possible to write `impl Point { .. }`. \n"
+" * `Point` is still generic and you can use `Point`, but methods in this block will only be available for `Point`."
+msgstr ""
+"* *Pergunta:* Por que `T` é especificado duas vezes em `impl Ponto {}`? Isso não é redundante?\n"
+" * Isso ocorre porque é uma seção de implementação genérica para tipo genérico. Eles são genéricos de forma independente.\n"
+" * Significa que esses métodos são definidos para qualquer `T`.\n"
+" * É possível escrever `Impl Ponto { .. }`.\n"
+" * `Ponto` ainda é genérico e você pode usar `Ponto`, mas os métodos neste bloco só estarão disponíveis para `Ponto`."
+
+#: src/generics/monomorphization.md:1
+msgid "# Monomorphization"
+msgstr "# Monomorfização"
+
+#: src/generics/monomorphization.md:3
+msgid "Generic code is turned into non-generic code based on the call sites:"
+msgstr "O código _genérico_ é transformado em código _não genérico_ de acordo com os tipos usados:"
+
+#: src/generics/monomorphization.md:5
+msgid ""
+"```rust,editable\n"
+"fn main() {\n"
+" let integer = Some(5);\n"
+" let float = Some(5.0);\n"
+"}\n"
+"```"
+msgstr ""
+"```rust, editable\n"
+"fn main() {\n"
+" let inteiro = Some(5);\n"
+" let real = Some(5.0);\n"
+"}\n"
+"```"
+
+#: src/generics/monomorphization.md:12
+msgid "behaves as if you wrote"
+msgstr "se comporta como se você tivesse escrito"
+
+#: src/generics/monomorphization.md:14
+#, fuzzy
+msgid ""
+"```rust,editable\n"
+"enum Option_i32 {\n"
+" Some(i32),\n"
+" None,\n"
+"}\n"
+"\n"
+"enum Option_f64 {\n"
+" Some(f64),\n"
+" None,\n"
+"}\n"
+"\n"
+"fn main() {\n"
+" let integer = Option_i32::Some(5);\n"
+" let float = Option_f64::Some(5.0);\n"
+"}\n"
+"```"
+msgstr ""
+"fn main() {\n"
+" let inteiro = Option_i32::Some(5);\n"
+" let real = Option_f64::Some(5.0);\n"
+"}\n"
+"```"
+
+#: src/generics/monomorphization.md:31
+msgid ""
+"This is a zero-cost abstraction: you get exactly the same result as if you had\n"
+"hand-coded the data structures without the abstraction."
+msgstr ""
+"Esta é uma abstração de custo zero: você obtém exatamente o mesmo resultado como se tivesse\n"
+"codificado manualmente as estruturas de dados sem utilizar a abstração."
#: src/traits.md:1
msgid "# Traits"
@@ -9240,118 +8325,169 @@ msgstr "Rust permite abstrair características dos tipos usando `trait`. Eles s
#: src/traits.md:5
msgid ""
"```rust,editable\n"
-"trait Greet {\n"
-" fn say_hello(&self);\n"
-"}"
-msgstr ""
-"```rust,editable\n"
-"trait Saudar {\n"
-" fn diz_ola(&self);\n"
-"}"
-
-#: src/traits.md:10
-msgid ""
+"trait Pet {\n"
+" fn name(&self) -> String;\n"
+"}\n"
+"\n"
"struct Dog {\n"
" name: String,\n"
-"}"
-msgstr ""
-"struct Cachorro {\n"
-" nome: String,\n"
-"}"
-
-#: src/traits.md:14
-msgid "struct Cat; // No name, cats won't respond to it anyway."
-msgstr "struct Gato; // Sem nome, os gatos não vão responder de qualquer maneira."
-
-#: src/traits.md:16
-msgid ""
-"impl Greet for Dog {\n"
-" fn say_hello(&self) {\n"
-" println!(\"Wuf, my name is {}!\", self.name);\n"
+"}\n"
+"\n"
+"struct Cat;\n"
+"\n"
+"impl Pet for Dog {\n"
+" fn name(&self) -> String {\n"
+" self.name.clone()\n"
" }\n"
-"}"
-msgstr ""
-"impl Saudar for Cachorro {\n"
-" fn diz_ola(&self) {\n"
-" println!(\"Wuf, meu nome é {}!\", self.nome);\n"
+"}\n"
+"\n"
+"impl Pet for Cat {\n"
+" fn name(&self) -> String {\n"
+" String::from(\"The cat\") // No name, cats won't respond to it anyway.\n"
" }\n"
-"}"
-
-#: src/traits.md:22
-msgid ""
-"impl Greet for Cat {\n"
-" fn say_hello(&self) {\n"
-" println!(\"Miau!\");\n"
-" }\n"
-"}"
-msgstr ""
-"impl Saudar for Gato {\n"
-" fn diz_ola(&self) {\n"
-" println!(\"Miau!\");\n"
-" }\n"
-"}"
-
-#: src/traits.md:28
-msgid ""
+"}\n"
+"\n"
+"fn greet(pet: &P) {\n"
+" println!(\"Who's a cutie? {} is!\", pet.name());\n"
+"}\n"
+"\n"
"fn main() {\n"
-" let pets: Vec> = vec![\n"
-" Box::new(Dog { name: String::from(\"Fido\") }),\n"
+" let fido = Dog { name: \"Fido\".into() };\n"
+" greet(&fido);\n"
+"\n"
+" let captain_floof = Cat;\n"
+" greet(&captain_floof);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/traits/trait-objects.md:1
+msgid "# Trait Objects"
+msgstr "# Objetos `trait`"
+
+#: src/traits/trait-objects.md:3
+msgid "Trait objects allow for values of different types, for instance in a collection:"
+msgstr ""
+
+#: src/traits/trait-objects.md:5
+msgid ""
+"```rust,editable\n"
+"trait Pet {\n"
+" fn name(&self) -> String;\n"
+"}\n"
+"\n"
+"struct Dog {\n"
+" name: String,\n"
+"}\n"
+"\n"
+"struct Cat;\n"
+"\n"
+"impl Pet for Dog {\n"
+" fn name(&self) -> String {\n"
+" self.name.clone()\n"
+" }\n"
+"}\n"
+"\n"
+"impl Pet for Cat {\n"
+" fn name(&self) -> String {\n"
+" String::from(\"The cat\") // No name, cats won't respond to it anyway.\n"
+" }\n"
+"}\n"
+"\n"
+"fn main() {\n"
+" let pets: Vec> = vec![\n"
" Box::new(Cat),\n"
+" Box::new(Dog { name: String::from(\"Fido\") }),\n"
" ];\n"
" for pet in pets {\n"
-" pet.say_hello();\n"
+" println!(\"Hello {}!\", pet.name());\n"
" }\n"
"}\n"
"```"
msgstr ""
-"fn main() {\n"
-" let pets: Vec> = vec![\n"
-" Box::new(Cachorro{ nome: String::from(\"Fido\") }),\n"
-" Box::new(Gato),\n"
-" ];\n"
-" for pet in pets {\n"
-" pet.diz_ola();\n"
-" }\n"
-"}\n"
+
+#: src/traits/trait-objects.md:40
+#, fuzzy
+msgid "Memory layout after allocating `pets`:"
+msgstr "Layout da memória após alocar `xs`:"
+
+#: src/traits/trait-objects.md:42
+#, fuzzy
+msgid ""
+"```bob\n"
+" Stack Heap\n"
+".- - - - - - - - - - - - - -. .- - - - - - - - - - - - - - - - - - - - - - -.\n"
+": : : :\n"
+": pets : : :\n"
+": +-----------+-------+ : : +-----+-----+ :\n"
+": | ptr | o---+---+-----+-->| o o | o o | :\n"
+": | len | 2 | : : +-|-|-+-|-|-+ :\n"
+": | capacity | 2 | : : | | | | +---------------+ :\n"
+": +-----------+-------+ : : | | | '-->| name: \"Fido\" | :\n"
+": : : | | | +---------------+ :\n"
+"`- - - - - - - - - - - - - -' : | | | :\n"
+" : | | | +----------------------+ : \n"
+" : | | '---->| \"::name\" | :\n"
+" : | | +----------------------+ : \n"
+" : | | : \n"
+" : | | +-+ : \n"
+" : | '-->|\\| : \n"
+" : | +-+ : \n"
+" : | : \n"
+" : | +----------------------+ : \n"
+" : '---->| \"::name\" | : \n"
+" : +----------------------+ :\n"
+" : :\n"
+" '- - - - - - - - - - - - - - - - - - - - - - -'\n"
+"\n"
+"```"
+msgstr ""
+"```bob\n"
+" Stack Heap\n"
+".- - - - - - - - - - - - - -. .- - - - - - - - - - - - - - - - - - - - - - - -.\n"
+": : : :\n"
+": xs : : :\n"
+": +------------+-------+ : : +-----+-----+ :\n"
+": | ponteir | o---+--+-----+-->| o o | o o | :\n"
+": | tamanho | 2 | : : +-|-|-+-|-|-+ :\n"
+": | capacidade | 2 | : : | | | | +----+----+----+ :\n"
+": +------------+-------+ : : | | | '-->| O | l | á | :\n"
+": : : | | | +----+----+----+ :\n"
+"`- - - - - - - - - - - - - -' : | | | :\n"
+" : | | | +-------------------------+ :\n"
+" : | | '---->|\"::fmt\"| :\n"
+" : | | +-------------------------+ :\n"
+" : | | :\n"
+" : | | +----+----+----+----+ :\n"
+" : | '-->| 7b | 00 | 00 | 00 | :\n"
+" : | +----+----+----+----+ :\n"
+" : | :\n"
+" : | +-------------------------+ :\n"
+" : '---->|\"::fmt\"| :\n"
+" : +-------------------------+ :\n"
+" : :\n"
+" : :\n"
+" '- - - - - - - - - - - - - - - - - - - - - - - -'\n"
"```"
-#: src/traits.md:41
+#: src/traits/trait-objects.md:72
+#, fuzzy
msgid ""
-"* Traits may specify pre-implemented (default) methods and methods that users are required to implement themselves. Methods "
-"with default implementations can rely on required methods.\n"
-"* Types that implement a given trait may be of different sizes. This makes it impossible to have things like `Vec` "
-"in the example above.\n"
-"* `dyn Greet` is a way to tell the compiler about a dynamically sized type that implements `Greet`.\n"
-"* In the example, `pets` holds Fat Pointers to objects that implement `Greet`. The Fat Pointer consists of two components, "
-"a pointer to the actual object and a pointer to the virtual method table for the `Greet` implementation of that particular "
-"object."
+"* Types that implement a given trait may be of different sizes. This makes it impossible to have things like `Vec` in the example above.\n"
+"* `dyn Pet` is a way to tell the compiler about a dynamically sized type that implements `Pet`.\n"
+"* In the example, `pets` holds *fat pointers* to objects that implement `Pet`. The fat pointer consists of two components, a pointer to the actual object and a pointer to the virtual method table for the `Pet` implementation of that particular object.\n"
+"* Compare these outputs in the above example:\n"
+" ```rust,ignore\n"
+" println!(\"{} {}\", std::mem::size_of::(), std::mem::size_of::());\n"
+" println!(\"{} {}\", std::mem::size_of::<&Dog>(), std::mem::size_of::<&Cat>());\n"
+" println!(\"{}\", std::mem::size_of::<&dyn Pet>());\n"
+" println!(\"{}\", std::mem::size_of::>());\n"
+" ```"
msgstr ""
-"* _Traits_ podem especificar métodos pré-implementados (padrão) e métodos que os usuários devem implementar por conta "
-"própria. Os métodos com implementações padrão podem contar com os métodos necessários.\n"
-"* Os tipos que implementam uma determinada característica podem ser de tamanhos diferentes. Isso torna impossível ter "
-"coisas como `Vec` no exemplo acima.\n"
+"* _Traits_ podem especificar métodos pré-implementados (padrão) e métodos que os usuários devem implementar por conta própria. Os métodos com implementações padrão podem contar com os métodos necessários.\n"
+"* Os tipos que implementam uma determinada característica podem ser de tamanhos diferentes. Isso torna impossível ter coisas como `Vec` no exemplo acima.\n"
"* `dyn Greet` é uma maneira de dizer ao compilador sobre um tipo de tamanho dinâmico que implementa `Greet`.\n"
-"* No exemplo, `pets` mantém _Fat Pointers_ para objetos que implementam `Greet`. O _Fat Pointer_ consiste em dois componentes, "
-"um ponteiro para o objeto real e um ponteiro para a tabela de métodos virtuais para a implementação de `Greet` desse objeto em "
-"particular."
-
-#: src/traits.md:46
-msgid ""
-"Compare these outputs in the above example:\n"
-"```rust,ignore\n"
-" println!(\"{} {}\", std::mem::size_of::(), std::mem::size_of::());\n"
-" println!(\"{} {}\", std::mem::size_of::<&Dog>(), std::mem::size_of::<&Cat>());\n"
-" println!(\"{}\", std::mem::size_of::<&dyn Greet>());\n"
-" println!(\"{}\", std::mem::size_of::>());\n"
-"```"
-msgstr ""
-"Compare essas saídas no exemplo acima:\n"
-"```rust, ignore\n"
-" println!(\"{} {}\", std::mem::size_of::(), std::mem::size_of::());\n"
-" println!(\"{} {}\", std::mem::size_of::<&Dog>(), std::mem::size_of::<&Cat>());\n"
-" println!(\"{}\", std::mem::size_of::<&dyn Greet>());\n"
-" println!(\"{}\", std::mem::size_of::>());\n"
-"```"
+"* No exemplo, `pets` mantém _Fat Pointers_ para objetos que implementam `Greet`. O _Fat Pointer_ consiste em dois componentes, um ponteiro para o objeto real e um ponteiro para a tabela de métodos virtuais para a implementação de `Greet` desse objeto em particular."
#: src/traits/deriving-traits.md:1
msgid "# Deriving Traits"
@@ -9362,6 +8498,7 @@ msgid "You can let the compiler derive a number of traits:"
msgstr "Você pode deixar o compilador derivar uma série de traits:"
#: src/traits/deriving-traits.md:5
+#, fuzzy
msgid ""
"```rust,editable\n"
"#[derive(Debug, Clone, PartialEq, Eq, Default)]\n"
@@ -9369,18 +8506,8 @@ msgid ""
" name: String,\n"
" strength: u8,\n"
" hit_points: u8,\n"
-"}"
-msgstr ""
-"```rust,editable\n"
-"#[derive(Debug, Clone, PartialEq, Eq, Default)]\n"
-"struct Jogador {\n"
-" nome: String,\n"
-" forca: u8,\n"
-" pontos_vida: u8,\n"
-"}"
-
-#: src/traits/deriving-traits.md:13
-msgid ""
+"}\n"
+"\n"
"fn main() {\n"
" let p1 = Player::default();\n"
" let p2 = p1.clone();\n"
@@ -9413,40 +8540,17 @@ msgid ""
" fn not_equal(&self, other: &Self) -> bool {\n"
" !self.equal(other)\n"
" }\n"
-"}"
-msgstr ""
-"```rust,editable\n"
-"trait Iguais {\n"
-" fn igual(&self, outro: &Self) -> bool;\n"
-" fn diferente(&self, outro: &Self) -> bool {\n"
-" !self.igual(outro)\n"
-" }\n"
-"}"
-
-#: src/traits/default-methods.md:13
-msgid ""
+"}\n"
+"\n"
"#[derive(Debug)]\n"
-"struct Centimeter(i16);"
-msgstr ""
-"#[derive(Debug)]\n"
-"struct Centimetro(i16);"
-
-#: src/traits/default-methods.md:16
-msgid ""
+"struct Centimeter(i16);\n"
+"\n"
"impl Equals for Centimeter {\n"
" fn equal(&self, other: &Centimeter) -> bool {\n"
" self.0 == other.0\n"
" }\n"
-"}"
-msgstr ""
-"impl Iguais for Centimetro {\n"
-" fn igual(&self, outro: &Centimetro) -> bool {\n"
-" self.0 == outro.0\n"
-" }\n"
-"}"
-
-#: src/traits/default-methods.md:22
-msgid ""
+"}\n"
+"\n"
"fn main() {\n"
" let a = Centimeter(10);\n"
" let b = Centimeter(20);\n"
@@ -9455,13 +8559,195 @@ msgid ""
"}\n"
"```"
msgstr ""
+
+#: src/traits/default-methods.md:32
+msgid ""
+"* Traits may specify pre-implemented (default) methods and methods that users are required to\n"
+" implement themselves. Methods with default implementations can rely on required methods.\n"
+"\n"
+"* Move method `not_equal` to a new trait `NotEqual`.\n"
+"\n"
+"* Make `NotEqual` a super trait for `Equal`.\n"
+" ```rust,editable,compile_fail\n"
+" trait NotEqual: Equals {\n"
+" fn not_equal(&self, other: &Self) -> bool {\n"
+" !self.equal(other)\n"
+" }\n"
+" }\n"
+" ```\n"
+"\n"
+"* Provide a blanket implementation of `NotEqual` for `Equal`.\n"
+" ```rust,editable,compile_fail\n"
+" trait NotEqual {\n"
+" fn not_equal(&self, other: &Self) -> bool;\n"
+" }\n"
+"\n"
+" impl NotEqual for T where T: Equals {\n"
+" fn not_equal(&self, other: &Self) -> bool {\n"
+" !self.equal(other)\n"
+" }\n"
+" }\n"
+" ```\n"
+" * With the blanket implementation, you no longer need `NotEqual` as a super trait for `Equal`.\n"
+" "
+msgstr ""
+
+#: src/traits/trait-bounds.md:1
+msgid "# Trait Bounds"
+msgstr "# Limites de traits"
+
+#: src/traits/trait-bounds.md:3
+msgid ""
+"When working with generics, you often want to require the types to implement\n"
+"some trait, so that you can call this trait's methods."
+msgstr ""
+"Ao trabalhar com genéricos, muitas vezes você exigir que os tipos implementem algum `trait`\n"
+" para poder utilizar os métodos do `trait`."
+
+#: src/traits/trait-bounds.md:6
+msgid "You can do this with `T: Trait` or `impl Trait`:"
+msgstr "Você consegue fazer isso com `T:Trait` ou `impl Trait`:"
+
+#: src/traits/trait-bounds.md:8
+msgid ""
+"```rust,editable\n"
+"fn duplicate(a: T) -> (T, T) {\n"
+" (a.clone(), a.clone())\n"
+"}\n"
+"\n"
+"// Syntactic sugar for:\n"
+"// fn add_42_millions>(x: T) -> i32 {\n"
+"fn add_42_millions(x: impl Into) -> i32 {\n"
+" x.into() + 42_000_000\n"
+"}\n"
+"\n"
+"// struct NotClonable;\n"
+"\n"
"fn main() {\n"
-" let a = Centimetro(10);\n"
-" let b = Centimetro(20);\n"
-" println!(\"{a:?} é igual a {b:?}: {}\", a.igual(&b));\n"
-" println!(\"{a:?} é diferente de {b:?}: {}\", a.diferente(&b));\n"
+" let foo = String::from(\"foo\");\n"
+" let pair = duplicate(foo);\n"
+" println!(\"{pair:?}\");\n"
+"\n"
+" let many = add_42_millions(42_i8);\n"
+" println!(\"{many}\");\n"
+" let many_more = add_42_millions(10_000_000);\n"
+" println!(\"{many_more}\");\n"
"}\n"
"```"
+msgstr ""
+
+#: src/traits/trait-bounds.md:35
+msgid "Show a `where` clause, students will encounter it when reading code."
+msgstr ""
+
+#: src/traits/trait-bounds.md:37
+#, fuzzy
+msgid ""
+"```rust,ignore\n"
+"fn duplicate(a: T) -> (T, T)\n"
+"where\n"
+" T: Clone,\n"
+"{\n"
+" (a.clone(), a.clone())\n"
+"}\n"
+"```"
+msgstr ""
+"```rust, editable\n"
+"fn duplicar(a: T) -> (T, T) {\n"
+" (a.clone(), a.clone())\n"
+"}"
+
+#: src/traits/trait-bounds.md:46
+#, fuzzy
+msgid ""
+"* It declutters the function signature if you have many parameters.\n"
+"* It has additional features making it more powerful.\n"
+" * If someone asks, the extra feature is that the type on the left of \":\" can be arbitrary, like `Option`.\n"
+" "
+msgstr ""
+"* Organiza a assinatura da função se você tiver muitos parâmetros.\n"
+"* Possui recursos adicionais tornando-o mais poderoso.\n"
+" * Se alguém perguntar, o recurso extra é que o tipo à esquerda de \":\" pode ser arbitrário, como `Option`.\n"
+" \n"
+"
"
+
+#: src/traits/impl-trait.md:1
+msgid "# `impl Trait`"
+msgstr "# Trait `impl`"
+
+#: src/traits/impl-trait.md:3
+msgid ""
+"Similar to trait bounds, an `impl Trait` syntax can be used in function\n"
+"arguments and return values:"
+msgstr ""
+"Semelhante aos limites do _trait_, a sintaxe do _trait_ `impl` pode ser usada em argumentos de funções\n"
+"e em valores de retorno:"
+
+#: src/traits/impl-trait.md:6
+msgid ""
+"```rust,editable\n"
+"use std::fmt::Display;\n"
+"\n"
+"fn get_x(name: impl Display) -> impl Display {\n"
+" format!(\"Hello {name}\")\n"
+"}\n"
+"\n"
+"fn main() {\n"
+" let x = get_x(\"foo\");\n"
+" println!(\"{x}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/traits/impl-trait.md:19
+#, fuzzy
+msgid "* `impl Trait` allows you to work with types which you cannot name."
+msgstr ""
+"* `impl Trait` não pode ser usado com a sintaxe turbo fish `::<>`.\n"
+"* `impl Trait` permite que você trabalhe com tipos que você não pode nomear."
+
+#: src/traits/impl-trait.md:23
+msgid "The meaning of `impl Trait` is a bit different in the different positions."
+msgstr "O significado do _trait_ `impl` é um pouco difere de acordo com sua posição."
+
+#: src/traits/impl-trait.md:25
+#, fuzzy
+msgid ""
+"* For a parameter, `impl Trait` is like an anonymous generic parameter with a trait bound.\n"
+"\n"
+"* For a return type, it means that the return type is some concrete type that implements the trait,\n"
+" without naming the type. This can be useful when you don't want to expose the concrete type in a\n"
+" public API.\n"
+"\n"
+" Inference is hard in return position. A function returning `impl Foo` picks\n"
+" the concrete type it returns, without writing it out in the source. A function\n"
+" returning a generic type like `collect() -> B` can return any type\n"
+" satisfying `B`, and the caller may need to choose one, such as with `let x:\n"
+" Vec<_> = foo.collect()` or with the turbofish, `foo.collect::\n"
" \n"
@@ -7759,13 +6931,18 @@ msgstr "# Expressões de laço (`loop`)"
#: src/control-flow/loop-expressions.md:3
msgid ""
-"Finally, there is a `loop` keyword which creates an endless loop. Here you must\n"
-"either `break` or `return` to stop the loop:"
+"Finally, there is a [`loop` keyword](https://doc.rust-lang.org/reference/expressions/loop-expr.html#infinite-loops)\n"
+"which creates an endless loop."
+msgstr ""
+
+#: src/control-flow/loop-expressions.md:6
+#, fuzzy
+msgid "Here you must either `break` or `return` to stop the loop:"
msgstr ""
"Finalmente, há uma palavra-chave `loop` que cria um laço infinito. Aqui você deve\n"
"usar `break` ou `return` para parar o laço:"
-#: src/control-flow/loop-expressions.md:6
+#: src/control-flow/loop-expressions.md:8
msgid ""
"```rust,editable\n"
"fn main() {\n"
@@ -7785,29 +6962,29 @@ msgid ""
"```"
msgstr ""
-#: src/control-flow/loop-expressions.md:23
+#: src/control-flow/loop-expressions.md:27
msgid ""
-" {\n"
" Cons(T, Box>),\n"
" Nil,\n"
-"}"
-msgstr ""
-"```rust,editable\n"
-"#[derive(Debug)]\n"
-"enum List {\n"
-" Cons(T, Box>),\n"
-" Nil,\n"
-"}"
-
-#: src/std/box-recursive.md:12 src/std/box-niche.md:10
-msgid ""
+"}\n"
+"\n"
"fn main() {\n"
" let list: List = List::Cons(1, Box::new(List::Cons(2, Box::new(List::Nil))));\n"
" println!(\"{list:?}\");\n"
@@ -8436,47 +7498,46 @@ msgstr ""
"```"
#: src/std/box-recursive.md:18
+#, fuzzy
msgid ""
"```bob\n"
" Stack Heap\n"
".- - - - - - - - - - - - -. .- - - - - - - - - - - - - - - - - - - - - - - -.\n"
": : : :\n"
": list : : :\n"
-": +--------+-------+ : : +--------+--------+ +--------+------+ :\n"
-": | Tag | Cons | : : .->| Tag | Cons | .->| Tag | Nil | :\n"
-": | 0 | 1 | : : | | 0 | 2 | | | ////// | //// | :\n"
-": | 1 | o-----+----+-----+-' | 1 | o------+-' | ////// | //// | :\n"
-": +--------+-------+ : : +--------+--------+ +--------+------+ :\n"
+": +------+----+----+ : : +------+----+----+ +------+----+----+ :\n"
+": | Cons | 1 | o--+----+-----+--->| Cons | 2 | o--+--->| Nil | // | // | :\n"
+": +------+----+----+ : : +------+----+----+ +------+----+----+ :\n"
": : : :\n"
": : : :\n"
-"`- - - - - - - - - - - - -' '- - - - - - - - - - - - - - - - - - - - - - - -'\n"
+"'- - - - - - - - - - - - -' '- - - - - - - - - - - - - - - - - - - - - - - -'\n"
"```"
msgstr ""
"```bob\n"
" Stack Heap\n"
-".- - - - - - - - - - - - -. .- - - - - - - - - - - - - - - - - - - - - - - -.\n"
-": : : :\n"
-": lista : : :\n"
-": +--------+-------+ : : +--------+--------+ +--------+------+ :\n"
-": | Tag | Cons | : : .->| Tag | Cons | .->| Tag | Nil | :\n"
-": | 0 | 1 | : : | | 0 | 2 | | | ////// | //// | :\n"
-": | 1 | o-----+----+-----+-' | 1 | o------+-' | ////// | //// | :\n"
-": +--------+-------+ : : +--------+--------+ +--------+------+ :\n"
-": : : :\n"
-": : : :\n"
-"`- - - - - - - - - - - - -' '- - - - - - - - - - - - - - - - - - - - - - - -'\n"
+".- - - - - - - - - - - - -. .- - - - - - - - - - - - - - - - - - - - - - - - - -.\n"
+": : : :\n"
+": lista : : :\n"
+": +----------+-------+ : : +----------+--------+ +----------+------+ :\n"
+": | 0 | 1 | : : .->| 0 | 2 | .->| ////// | //// | :\n"
+": | \"1/Tag\"| o-----+--+-----+-' | \"1/Tag\"| o-----+-' | \"1/Tag\"| null | :\n"
+": +----------+-------+ : : +----------+--------+ +----------+------+ :\n"
+": : : :\n"
+": : : :\n"
+"`- - - - - - - - - - - - -' '- - - - - - - - - - - - - - - - - - - - - - - - - -'\n"
"```"
#: src/std/box-recursive.md:33
+#, fuzzy
msgid ""
-"
"
-
#: src/std/box-niche.md:1
msgid "# Niche Optimization"
msgstr "# Otimização de Nicho"
@@ -8511,19 +7562,19 @@ msgstr ""
"permite que o compilador otimize o layout da memória:"
#: src/std/box-niche.md:19
+#, fuzzy
msgid ""
"```bob\n"
" Stack Heap\n"
-".- - - - - - - - - - - - -. .- - - - - - - - - - - - - - - - - - - - - - - - - -.\n"
-": : : :\n"
-": list : : :\n"
-": +----------+-------+ : : +----------+--------+ +----------+------+ :\n"
-": | 0 | 1 | : : .->| 0 | 2 | .->| ////// | //// | :\n"
-": | \"1/Tag\"| o-----+--+-----+-' | \"1/Tag\"| o-----+-' | \"1/Tag\"| null | :\n"
-": +----------+-------+ : : +----------+--------+ +----------+------+ :\n"
-": : : :\n"
-": : : :\n"
-"`- - - - - - - - - - - - -' '- - - - - - - - - - - - - - - - - - - - - - - - - -'\n"
+".- - - - - - - - - - - - -. .- - - - - - - - - - - - - - - - - - - - - - -.\n"
+": : : :\n"
+": list : : :\n"
+": +----+----+ : : +----+----+ +----+------+ :\n"
+": | 1 | o--+-----------+-----+--->| 2 | o--+--->| // | null | :\n"
+": +----+----+ : : +----+----+ +----+------+ :\n"
+": : : :\n"
+": : : :\n"
+"`- - - - - - - - - - - - -' '- - - - - - - - - - - - - - - - - - - - - - -'\n"
"```"
msgstr ""
"```bob\n"
@@ -8553,22 +7604,28 @@ msgstr ""
"os mesmos dados a partir de vários locais:"
#: src/std/rc.md:6
+#, fuzzy
msgid ""
"```rust,editable\n"
-"use std::rc::Rc;"
-msgstr ""
-"```rust,editable\n"
-"use std::rc::Rc;"
-
-#: src/std/rc.md:9
-msgid ""
+"use std::rc::Rc;\n"
+"\n"
"fn main() {\n"
" let mut a = Rc::new(10);\n"
-" let mut b = a.clone();"
+" let mut b = Rc::clone(&a);\n"
+"\n"
+" println!(\"a: {a}\");\n"
+" println!(\"b: {b}\");\n"
+"}\n"
+"```"
msgstr ""
+"```rust, editable\n"
"fn main() {\n"
-" let mut a = Rc::new(10);\n"
-" let mut b = a.clone();"
+" let x = 42;\n"
+" let y = x;\n"
+" println!(\"x: {x}\");\n"
+" println!(\"y: {y}\");\n"
+"}\n"
+"```"
#: src/std/rc.md:18
msgid ""
@@ -8583,24 +7640,16 @@ msgstr ""
"Você pode regredir um ponteiro compartilhado dentro de um ponteiro [`Weak`][4] para criar ciclos\n"
"que serão descartados."
-#: src/std/rc.md:24
-msgid ""
-"[1]: https://doc.rust-lang.org/std/rc/struct.Rc.html\n"
-"[2]: https://doc.rust-lang.org/std/cell/index.html\n"
-"[3]: ../concurrency/shared_state/arc.md\n"
-"[4]: https://doc.rust-lang.org/std/rc/struct.Weak.html"
-msgstr ""
-"[1]: https://doc.rust-lang.org/std/rc/struct.Rc.html\n"
-"[2]: https://doc.rust-lang.org/std/cell/index.html\n"
-"[3]: ../concurrency/shared_state/arc.md\n"
-"[4]: https://doc.rust-lang.org/std/rc/struct.Weak.html"
-
#: src/std/rc.md:31
+#, fuzzy
msgid ""
+"* `Rc`'s count ensures that its contained value is valid for as long as there are references.\n"
"* Like C++'s `std::shared_ptr`.\n"
-"* `clone` is cheap: creates a pointer to the same allocation and increases the reference count.\n"
+"* `Rc::clone` is cheap: it creates a pointer to the same allocation and increases the reference count. Does not make a deep clone and can generally be ignored when looking for performance issues in code.\n"
"* `make_mut` actually clones the inner value if necessary (\"clone-on-write\") and returns a mutable reference.\n"
-"* You can `downgrade()` a `Rc` into a *weakly reference-counted* object to\n"
+"* Use `Rc::strong_count` to check the reference count.\n"
+"* Compare the different datatypes mentioned. `Box` enables (im)mutable borrows that are enforced at compile time. `RefCell` enables (im)mutable borrows that are enforced at run time and will panic if it fails at runtime.\n"
+"* `Rc::downgrade` gives you a *weakly reference-counted* object to\n"
" create cycles that will be dropped properly (likely in combination with\n"
" `RefCell`)."
msgstr ""
@@ -8610,34 +7659,20 @@ msgstr ""
"* Você pode invocar `downgrade()` em um `Rc` para obter um objeto contador de referências `Weak` para criar\n"
"ciclos que podem ser apropriadamente descartados (provavelmente combinados com `RefCell`)."
-#: src/std/rc.md:38
+#: src/std/rc.md:41
+#, fuzzy
msgid ""
"```rust,editable\n"
"use std::rc::{Rc, Weak};\n"
-"use std::cell::RefCell;"
-msgstr ""
-"```rust,editable\n"
-"use std::rc::{Rc, Weak};\n"
-"use std::cell::RefCell;"
-
-#: src/std/rc.md:42
-msgid ""
+"use std::cell::RefCell;\n"
+"\n"
"#[derive(Debug)]\n"
"struct Node {\n"
" value: i64,\n"
" parent: Option\n"
-" \n"
-"* Break the `loop` with a value (e.g. `break 8`) and print it out."
+"* Break the `loop` with a value (e.g. `break 8`) and print it out.\n"
+"* Note that `loop` is the only looping construct which returns a non-trivial\n"
+" value. This is because it's guaranteed to be entered at least once (unlike\n"
+" `while` and `for` loops)."
msgstr ""
-"
"
#: src/std/box-recursive.md:1
msgid "# Box with Recursive Data Structures"
@@ -8406,23 +7476,15 @@ msgid "Recursive data types or data types with dynamic sizes need to use a `Box`
msgstr "Tipos de dados recursivos ou tipos de dados com tamanhos dinâmicos precisam usar uma `Box`:"
#: src/std/box-recursive.md:5 src/std/box-niche.md:3
+#, fuzzy
msgid ""
"```rust,editable\n"
"#[derive(Debug)]\n"
"enum List\n"
-" \n"
-"* Break o `loop` com um valor (ex. `break 8`) e mostre-o."
#: src/control-flow/match-expressions.md:1
msgid "# `match` expressions"
msgstr "# Expressões de correspondência (`match`)"
#: src/control-flow/match-expressions.md:3
+#, fuzzy
msgid ""
-"The `match` keyword is used to match a value against one or more patterns. In\n"
-"that sense, it works like a series of `if let` expressions:"
+"The [`match` keyword](https://doc.rust-lang.org/reference/expressions/match-expr.html)\n"
+"is used to match a value against one or more patterns. In that sense, it works\n"
+"like a series of `if let` expressions:"
msgstr ""
"A palavra-chave `match` é usada para corresponder um valor a um ou mais padrões. Nesse\n"
"sentido, funciona como uma série de expressões `if let`:"
-#: src/control-flow/match-expressions.md:6
+#: src/control-flow/match-expressions.md:7
msgid ""
"```rust,editable\n"
"fn main() {\n"
@@ -7835,7 +7012,7 @@ msgstr ""
"}\n"
"```"
-#: src/control-flow/match-expressions.md:19
+#: src/control-flow/match-expressions.md:20
msgid ""
"Like `if let`, each match arm must have the same type. The type is the last\n"
"expression of the block, if any. In the example above, the type is `()`."
@@ -7843,25 +7020,21 @@ msgstr ""
"Como `if let`, cada braço de correspondência deve ter o mesmo tipo. O tipo é a última\n"
"expressão do bloco, se houver. No exemplo acima, o tipo é `()`."
-#: src/control-flow/match-expressions.md:25
+#: src/control-flow/match-expressions.md:28
+#, fuzzy
msgid ""
-"`, but we cannot match against `String`.\n"
+" * `as_deref()` transforms an `Option` to `Option<&T::Target>`. In our case, this turns `Option` into `Option<&str>`.\n"
+" * We can now use pattern matching to match against the `&str` inside `Option`."
msgstr ""
"
"
+"os dados são armazenados usando uma `Box` na _heap_ e apenas o ponteiro é movido.\n"
-" \n"
"* Save the match expression to a variable and print it out.\n"
"* Remove `.as_deref()` and explain the error.\n"
-" * `std::env::Agrs().next` returns an `Option<&String>`, but we cannot match against `String`.\n"
-" * `as_deref()` transforms an `Option` to `Option`. In our case, this turns `Option<&String>` into "
-"`Option<&str>`.\n"
-" * We can now use pattern matching to match against the `&str` inside `Option`.\n"
-"
"
+" * `std::env::args().next()` returns an `Option\n"
" \n"
"* Salve o resultado de uma expressão de correspondência `match` em uma variável e imprima-a.\n"
"* Remova `.as_deref()` e explique o erro gerado.\n"
" * `std::env::Agrs().next()` returns an `Option<&String>`, porém `match` não funciona com o tipo `String`.\n"
-" * `as_deref()` transforma um tipo `Option` em `Option`. Nesse caso, transforma um `Option<&String>` em "
-"`Option<&str>`.\n"
+" * `as_deref()` transforma um tipo `Option` em `Option`. Nesse caso, transforma um `Option<&String>` em `Option<&str>`.\n"
" * Agora podemos usar a correspondência de padrões em um `&str` dentro de um `Option`.\n"
"
"
@@ -7871,15 +7044,22 @@ msgstr "# Interromper (`break`) e Continuar (`continue`)"
#: src/control-flow/break-continue.md:3
msgid ""
-"If you want to exit a loop early, use `break`, if you want to immediately start\n"
-"the next iteration use `continue`. Both `continue` and `break` can optionally\n"
-"take a label argument which is used to break out of nested loops:"
+"- If you want to exit a loop early, use [`break`](https://doc.rust-lang.org/reference/expressions/loop-expr.html#break-expressions),\n"
+"- If you want to immediately start\n"
+"the next iteration use [`continue`](https://doc.rust-lang.org/reference/expressions/loop-expr.html#continue-expressions)."
+msgstr ""
+
+#: src/control-flow/break-continue.md:7
+#, fuzzy
+msgid ""
+"Both `continue` and `break` can optionally take a label argument which is used\n"
+"to break out of nested loops:"
msgstr ""
"Se você quiser sair de um laços mais cedo, use `break`, se quiser iniciar imediatamente\n"
"a próxima iteração use `continue`. Ambos `continue` e `break` podem opcionalmente\n"
"receber um rótulo como argumento que é usado para sair de laços aninhados:"
-#: src/control-flow/break-continue.md:7
+#: src/control-flow/break-continue.md:10
msgid ""
"```rust,editable\n"
"fn main() {\n"
@@ -7917,7 +7097,7 @@ msgstr ""
"}\n"
"```"
-#: src/control-flow/break-continue.md:25
+#: src/control-flow/break-continue.md:28
msgid "In this case we break the outer loop after 3 iterations of the inner loop."
msgstr "Neste caso, quebramos o laço externo após 3 iterações do laço interno."
@@ -7942,38 +7122,23 @@ msgstr "As palavras reservadas de tipo comuns incluem:"
#: src/std.md:9
msgid ""
"* [`Option` and `Result`](std/option-result.md) types: used for optional values\n"
-" and [error handling](error-handling.md)."
-msgstr ""
-"* Tipos [`Option` e `Result`](std/option-result.md): usados para valores opcionais\n"
-" e [manipulação de erros](error-handling.md)."
-
-#: src/std.md:12
-msgid "* [`String`](std/string.md): the default string type used for owned data."
-msgstr "* [`String`](std/string.md): o tipo de cadeia de caracteres padrão extensível usado para dados."
-
-#: src/std.md:14
-msgid "* [`Vec`](std/vec.md): a standard extensible vector."
-msgstr "* [`Vec`](std/vec.md): um vetor extensível padrão."
-
-#: src/std.md:16
-msgid ""
+" and [error handling](error-handling.md).\n"
+"\n"
+"* [`String`](std/string.md): the default string type used for owned data.\n"
+"\n"
+"* [`Vec`](std/vec.md): a standard extensible vector.\n"
+"\n"
"* [`HashMap`](std/hashmap.md): a hash map type with a configurable hashing\n"
-" algorithm."
+" algorithm.\n"
+"\n"
+"* [`Box`](std/box.md): an owned pointer for heap-allocated data.\n"
+"\n"
+"* [`Rc`](std/rc.md): a shared reference-counted pointer for heap-allocated data."
msgstr ""
-"* [`HashMap`](std/hashmap.md): um tipo de mapa hash com o algoritmo de hashing configurável."
-#: src/std.md:19
-msgid "* [`Box`](std/box.md): an owned pointer for heap-allocated data."
-msgstr "* [`Box`](std/box.md): um ponteiro próprio para dados alocados em heap."
-
-#: src/std.md:21
-msgid "* [`Rc`](std/rc.md): a shared reference-counted pointer for heap-allocated data."
-msgstr "* [`Rc`](std/rc.md): um ponteiro de contagem de referência compartilhado para dados alocados em heap."
-
-#: src/std.md:23
+#: src/std.md:25
+#, fuzzy
msgid ""
-"\n"
-" \n"
" * In fact, Rust contains several layers of the Standard Library: `core`, `alloc` and `std`. \n"
" * `core` includes the most basic types and functions that don't depend on `libc`, allocator or\n"
" even the presence of an operating system. \n"
@@ -7997,12 +7162,18 @@ msgid "The types represent optional data:"
msgstr "Os tipos representam dados opcionais:"
#: src/std/option-result.md:5
+#, fuzzy
msgid ""
"```rust,editable\n"
"fn main() {\n"
" let numbers = vec![10, 20, 30];\n"
" let first: Option<&i8> = numbers.first();\n"
-" println!(\"first: {first:?}\");"
+" println!(\"first: {first:?}\");\n"
+"\n"
+" let idx: Result = numbers.binary_search(&10);\n"
+" println!(\"idx: {idx:?}\");\n"
+"}\n"
+"```"
msgstr ""
"```rust, editable\n"
"fn main() {\n"
@@ -8010,18 +7181,6 @@ msgstr ""
" let primeiro: Option<&i8> = numeros.first();\n"
" println!(\"Primeiro: {primeiro:?}\");"
-#: src/std/option-result.md:11
-msgid ""
-" let idx: Result = numbers.binary_search(&10);\n"
-" println!(\"idx: {idx:?}\");\n"
-"}\n"
-"```"
-msgstr ""
-" let idx: Result = numeros.binary_search(&10);\n"
-" println!(\"Indice: {idx:?}\");\n"
-"}\n"
-"```"
-
#: src/std/option-result.md:18
msgid ""
"* `Option` and `Result` are widely used not just in the standard library.\n"
@@ -8052,39 +7211,19 @@ msgid ""
"fn main() {\n"
" let mut s1 = String::new();\n"
" s1.push_str(\"Hello\");\n"
-" println!(\"s1: len = {}, capacity = {}\", s1.len(), s1.capacity());"
-msgstr ""
-"```rust, editable\n"
-"fn main() {\n"
-" let mut s1 = String::new();\n"
-" s1.push_str(\"Olá\");\n"
-" println!(\"s1: tamanho = {}, capacidade = {}\", s1.len(), s1.capacity());"
-
-#: src/std/string.md:11
-msgid ""
+" println!(\"s1: len = {}, capacity = {}\", s1.len(), s1.capacity());\n"
+"\n"
" let mut s2 = String::with_capacity(s1.len() + 1);\n"
" s2.push_str(&s1);\n"
" s2.push('!');\n"
-" println!(\"s2: len = {}, capacity = {}\", s2.len(), s2.capacity());"
-msgstr ""
-" let mut s2 = String::with_capacity(s1.len() + 1);\n"
-" s2.push_str(&s1);\n"
-" s2.push('!');\n"
-" println!(\"s2: tamanho = {}, capacidade = {}\", s2.len(), s2.capacity());"
-
-#: src/std/string.md:16
-msgid ""
+" println!(\"s2: len = {}, capacity = {}\", s2.len(), s2.capacity());\n"
+"\n"
" let s3 = String::from(\"🇨🇭\");\n"
" println!(\"s3: len = {}, number of chars = {}\", s3.len(),\n"
" s3.chars().count());\n"
"}\n"
"```"
msgstr ""
-" let s3 = String::from(\"🇨🇭\");\n"
-" println!(\"s3: tamanho = {}, número de caracteres = {}\", s3.len(),\n"
-" s3.chars().count());\n"
-"}\n"
-"```"
#: src/std/string.md:22
msgid ""
@@ -8094,23 +7233,20 @@ msgstr ""
"`String` implementa [`Deref`][2], o que significa que você pode chamar todos\n"
"os métodos contidos em `str` em uma `String`."
-#: src/std/string.md:25
-msgid ""
-"[1]: https://doc.rust-lang.org/std/string/struct.String.html\n"
-"[2]: https://doc.rust-lang.org/std/string/struct.String.html#deref-methods-str"
-msgstr ""
-"[1]: https://doc.rust-lang.org/std/string/struct.String.html\n"
-"[2]: https://doc.rust-lang.org/std/string/struct.String.html#deref-methods-str"
-
#: src/std/string.md:30
msgid ""
-"* `len` returns the size of the `String` in bytes, not its length in characters.\n"
-"* `chars` returns an iterator over the actual characters.\n"
-"* `String` implements `Deref` which transparently gives it access to `str`'s methods."
+"* `String::new` returns a new empty string, use `String::with_capacity` when you know how much data you want to push to the string.\n"
+"* `String::len` returns the size of the `String` in bytes (which can be different from its length in characters).\n"
+"* `String::chars` returns an iterator over the actual characters. Note that a `char` can be different from what a human will consider a \"character\" due to [grapheme clusters](https://docs.rs/unicode-segmentation/latest/unicode_segmentation/struct.Graphemes.html).\n"
+"* When people refer to strings they could either be talking about `&str` or `String`. \n"
+"* When a type implements `Deref`, the compiler will let you transparently call methods from `T`.\n"
+" * `String` implements `Deref` which transparently gives it access to `str`'s methods.\n"
+" * Write and compare `let s3 = s1.deref();` and `let s3 = &*s1`;.\n"
+"* `String` is implemented as a wrapper around a vector of bytes, many of the operations you see supported on vectors are also supported on `String`, but with some extra guarantees.\n"
+"* Compare the different ways to index a `String`:\n"
+" * To a character by using `s3.chars().nth(i).unwrap()` where `i` is in-bound, out-of-bounds.\n"
+" * To a substring by using `s3[0..4]`, where that slice is on character boundaries or not."
msgstr ""
-"* `len` retorna o tamanho da `String` em bytes, não seu comprimento em caracteres.\n"
-"* `chars` retorna um iterador sobre os caracteres reais.\n"
-"* `String` implementa `Deref` que dá acesso transparente aos métodos de `str`."
#: src/std/vec.md:1
msgid "# `Vec`"
@@ -8126,59 +7262,26 @@ msgid ""
"fn main() {\n"
" let mut v1 = Vec::new();\n"
" v1.push(42);\n"
-" println!(\"v1: len = {}, capacity = {}\", v1.len(), v1.capacity());"
-msgstr ""
-"```rust, editable\n"
-"fn main() {\n"
-" let mut v1 = Vec::new();\n"
-" v1.push(42);\n"
-" println!(\"v1: tamanho = {}, capacidade = {}\", v1.len(), v1.capacity());"
-
-#: src/std/vec.md:11
-msgid ""
+" println!(\"v1: len = {}, capacity = {}\", v1.len(), v1.capacity());\n"
+"\n"
" let mut v2 = Vec::with_capacity(v1.len() + 1);\n"
" v2.extend(v1.iter());\n"
" v2.push(9999);\n"
-" println!(\"v2: len = {}, capacity = {}\", v2.len(), v2.capacity());"
-msgstr ""
-" let mut v2 = Vec::with_capacity(v1.len() + 1);\n"
-" v2.extend(v1.iter());\n"
-" v2.push(9999);\n"
-" println!(\"v2: tamanho = {}, capacidade = {}\", v2.len(), v2.capacity());\n"
-"}\n"
-"```"
-
-#: src/std/vec.md:16
-msgid ""
+" println!(\"v2: len = {}, capacity = {}\", v2.len(), v2.capacity());\n"
+"\n"
" // Canonical macro to initialize a vector with elements.\n"
-" let mut v3 = vec![0, 0, 1, 2, 3, 4];"
-msgstr ""
-" // Macro canônica para inicializar um vetor com elementos.\n"
-" let mut v3 = vec![0, 0, 1, 2, 3, 4];"
-
-#: src/std/vec.md:19
-msgid ""
+" let mut v3 = vec![0, 0, 1, 2, 3, 4];\n"
+"\n"
" // Retain only the even elements.\n"
" v3.retain(|x| x % 2 == 0);\n"
-" println!(\"{v3:?}\");"
-msgstr ""
-" // Retém somente os elementos pares.\n"
-" v3.retain(|x| x % 2 == 0);\n"
-" println!(\"{v3:?}\");"
-
-#: src/std/vec.md:23
-msgid ""
+" println!(\"{v3:?}\");\n"
+"\n"
" // Remove consecutive duplicates.\n"
" v3.dedup();\n"
" println!(\"{v3:?}\");\n"
"}\n"
"```"
msgstr ""
-" // Remove valores duplicados consecutivos.\n"
-" v3.dedup();\n"
-" println!(\"{v3:?}\");\n"
-"}\n"
-"```"
#: src/std/vec.md:29
msgid ""
@@ -8188,14 +7291,6 @@ msgstr ""
"`Vec` implementa [`Deref`][2], o que significa que você pode chamar métodos de slice\n"
"em um `Vec`."
-#: src/std/vec.md:32
-msgid ""
-"[1]: https://doc.rust-lang.org/std/vec/struct.Vec.html\n"
-"[2]: https://doc.rust-lang.org/std/vec/struct.Vec.html#deref-methods-[T]"
-msgstr ""
-"[1]: https://doc.rust-lang.org/std/vec/struct.Vec.html\n"
-"[2]: https://doc.rust-lang.org/std/vec/struct.Vec.html#deref-methods-[T]"
-
#: src/std/vec.md:37
msgid ""
"* `Vec` is a type of collection, along with `String` and `HashMap`. The data it contains is stored\n"
@@ -8236,80 +7331,65 @@ msgstr "Mapa de _hash_ padrão com proteção contra ataques HashDoS:"
#: src/std/hashmap.md:5
msgid ""
"```rust,editable\n"
-"use std::collections::HashMap;"
-msgstr ""
-"```rust,editable\n"
-"use std::collections::HashMap;"
-
-#: src/std/hashmap.md:8
-msgid ""
+"use std::collections::HashMap;\n"
+"\n"
"fn main() {\n"
" let mut page_counts = HashMap::new();\n"
" page_counts.insert(\"Adventures of Huckleberry Finn\".to_string(), 207);\n"
" page_counts.insert(\"Grimms' Fairy Tales\".to_string(), 751);\n"
-" page_counts.insert(\"Pride and Prejudice\".to_string(), 303);"
-msgstr ""
-"fn main() {\n"
-" let mut meus_livros = HashMap::new();\n"
-" meus_livros.insert(\"Aventuras de Huckleberry Finn\".to_string(), 207);\n"
-" meus_livros.insert(\"Contos de Fadas dos Grimms\".to_string(), 751);\n"
-" meus_livros.insert(\"Orgulho e Preconceito\".to_string(), 303);"
-
-#: src/std/hashmap.md:14
-msgid ""
+" page_counts.insert(\"Pride and Prejudice\".to_string(), 303);\n"
+"\n"
" if !page_counts.contains_key(\"Les Misérables\") {\n"
" println!(\"We know about {} books, but not Les Misérables.\",\n"
" page_counts.len());\n"
-" }"
-msgstr ""
-" if !meus_livros.contains_key(\"Os Miseráveis\") {\n"
-" println!(\"Tenho {} livros, mas não Os Miseráveis.\",\n"
-" meus_livros.len());\n"
-" }"
-
-#: src/std/hashmap.md:19
-msgid ""
+" }\n"
+"\n"
" for book in [\"Pride and Prejudice\", \"Alice's Adventure in Wonderland\"] {\n"
" match page_counts.get(book) {\n"
" Some(count) => println!(\"{book}: {count} pages\"),\n"
" None => println!(\"{book} is unknown.\")\n"
" }\n"
-" }"
-msgstr ""
-" for livro in [\"Orgulho e Preconceito\", \"Alice no País das Maravilhas\"] {\n"
-" match meus_livros.get(livro) {\n"
-" Some(paginas) => println!(\"{livro}: {paginas} páginas\"),\n"
-" None => println!(\"{livro} é desconhecido.\")\n"
-" }\n"
-" }"
-
-#: src/std/hashmap.md:26
-msgid ""
+" }\n"
+"\n"
" // Use the .entry() method to insert a value if nothing is found.\n"
" for book in [\"Pride and Prejudice\", \"Alice's Adventure in Wonderland\"] {\n"
" let page_count: &mut i32 = page_counts.entry(book.to_string()).or_insert(0);\n"
" *page_count += 1;\n"
-" }"
-msgstr ""
-" // Use o método .entry() para inserir um valor, caso este não seja encontrado.\n"
-" for livro in [\"Pride and Prejudice\", \"Alice's Adventure in Wonderland\"] {\n"
-" let meu_livro: &mut i32 = meus_livros.entry(livro.to_string()).or_insert(0);\n"
-" *meu_livro += 1;\n"
-" }"
-
-#: src/std/hashmap.md:32
-msgid ""
+" }\n"
+"\n"
" println!(\"{page_counts:#?}\");\n"
"}\n"
"```"
msgstr ""
-" println!(\"{meus_livros:#?}\");\n"
-"}\n"
-"```"
#: src/std/hashmap.md:38
-msgid "* Unlike `vec!`, there is unfortunately no standard `hashmap!` macro."
-msgstr "* Diferente de `vec!`, infelizmente não há uma macro padrão `hashmap!`."
+msgid ""
+"* `HashMap` is not defined in the prelude and needs to be brought into scope.\n"
+"* Try the following lines of code. The first line will see if a book is in the hashmap and if not return an alternative value. The second line will insert the alternative value in the hashmap if the book is not found.\n"
+"\n"
+" ```rust,ignore\n"
+" let pc1 = page_counts\n"
+" .get(\"Harry Potter and the Sorcerer's Stone \")\n"
+" .unwrap_or(&336);\n"
+" let pc2 = page_counts\n"
+" .entry(\"The Hunger Games\".to_string())\n"
+" .or_insert(374);\n"
+" ```\n"
+"* Unlike `vec!`, there is unfortunately no standard `hashmap!` macro.\n"
+" * Although, since Rust 1.56, HashMap implements [`From<[(K, V); N]>`][1], which allows us to easily initialize a hash map from a literal array:\n"
+"\n"
+" ```rust,ignore\n"
+" let page_counts = HashMap::from([\n"
+" (\"Harry Potter and the Sorcerer's Stone\".to_string(), 336),\n"
+" (\"The Hunger Games\".to_string(), 374),\n"
+" ]);\n"
+" ```\n"
+"\n"
+" * Alternatively HashMap can be built from any `Iterator` which yields key-value tuples.\n"
+"* We are showing `HashMap`, and avoid using `&str` as key to make examples easier. Using references in collections can, of course, be done,\n"
+" but it can lead into complications with the borrow checker.\n"
+" * Try removing `to_string()` from the example above and see if it still compiles. Where do you think we might run into issues?"
+msgstr ""
#: src/std/box.md:1
msgid "# `Box`"
@@ -8371,31 +7451,21 @@ msgstr ""
"`Box` implementa `Deref`, o que significa que você pode [chamar métodos\n"
"de `T` diretamente em um `Box`][2]."
-#: src/std/box.md:29
-msgid ""
-"[1]: https://doc.rust-lang.org/std/boxed/struct.Box.html\n"
-"[2]: https://doc.rust-lang.org/std/ops/trait.Deref.html#more-on-deref-coercion"
-msgstr ""
-"[1]: https://doc.rust-lang.org/std/boxed/struct.Box.html\n"
-"[2]: https://doc.rust-lang.org/std/ops/trait.Deref.html#more-on-deref-coercion"
-
#: src/std/box.md:34
+#, fuzzy
msgid ""
-"* `Box` is like `std::unique_ptr` in C++. \n"
+"* `Box` is like `std::unique_ptr` in C++, except that it's guaranteed to be not null. \n"
"* In the above example, you can even leave out the `*` in the `println!` statement thanks to `Deref`. \n"
"* A `Box` can be useful when you:\n"
" * have a type whose size that can't be known at compile time, but the Rust compiler wants to know an exact size.\n"
-" * want to transfer ownership of a large amount of data. To avoid copying large amounts of data on the stack, instead "
-"store the data on the heap in a `Box` so only the pointer is moved.\n"
-"
"
+" * want to transfer ownership of a large amount of data. To avoid copying large amounts of data on the stack, instead store the data on the heap in a `Box` so only the pointer is moved."
msgstr ""
"* `Box` é parecido com `std::unique_ptr` em C++. \n"
"* No exemplo acima, você pode remover o `*` na instrução `println!` graças ao `Deref`. \n"
"* Uma `Box` é útil quando você:\n"
" * Tem um tipo cujo tamanho não está disponível em tempo de compilação, mas o compilador Rust precisa saber o tamanho exato.\n"
" * Precisa transferir a propriedade de um dado grande. Ao invés de copiar grandes volumes de dados na pilha (`stack`),\n"
-"os dados são armazenados usando uma `Box` na _heap_ e apenas o ponteiro é movido."
-"\n"
-" \n"
"* If the `Box` was not used here and we attempted to embed a `List` directly into the `List`,\n"
"the compiler would not compute a fixed size of the struct in memory, it would look infinite.\n"
-" \n"
+"\n"
"* `Box` solves this problem as it has the same size as a regular pointer and just points at the next\n"
-"element of the `List` in the heap. "
-
+"element of the `List` in the heap.\n"
+"\n"
+"* Remove the `Box` in the List definition and show the compiler error. \"Recursive with indirection\" is a hint you might want to use a Box or reference of some kind, instead of storing a value directly. \n"
+" "
msgstr ""
"
"
-msgstr ""
-"* Remova a `Box` da definição da `List` e veja o erro apresentado pelo compilador. `Recursive with indirection` é o aviso que você vai receber."
-"\n"
" \n"
@@ -8488,16 +7549,6 @@ msgstr ""
" \n"
"
"
-#: src/std/box-recursive.md:41
-msgid ""
-"* Remove the `Box` in the List definition and show the compiler error. `Recursive with indirection` is a hint you might "
-"want to use a Box or reference of some kind, instead of storing a value directly. \n"
-" \n"
-"\n"
-" \n"
"* That's why it is common to only implement `From`, as your type will get `Into` implementation too.\n"
-"* When declaring a function argument input type like \"anything that can be converted into a `String`\", the rule is "
-"opposite, you should use `Into`.\n"
+"* When declaring a function argument input type like \"anything that can be converted into a `String`\", the rule is opposite, you should use `Into`.\n"
" Your function will accept types that implement `From` and those that _only_ implement `Into`.\n"
-" \n"
-"
"
+" "
msgstr ""
"\n"
" \n"
"* É por isso que é comum implementar apenas `From`, já que seu tipo também receberá a implementação de `Into`.\n"
-"* Ao declarar um tipo de entrada de argumento de função como \"qualquer coisa que possa ser convertida em `String`\", a "
-"regra é oposta, você deve usar `Into`.\n"
+"* Ao declarar um tipo de entrada de argumento de função como \"qualquer coisa que possa ser convertida em `String`\", a regra é oposta, você deve usar `Into`.\n"
" Sua função aceitará tipos que implementam `From` e aqueles que _apenas_ implementam `Into`.\n"
" \n"
"
"
-#: src/traits/from-into.md:35
-msgid ""
-"[1]: https://doc.rust-lang.org/std/convert/trait.From.html\n"
-"[2]: https://doc.rust-lang.org/std/convert/trait.Into.html"
-msgstr ""
-"[1]: https://doc.rust-lang.org/std/convert/trait.From.html\n"
-"[2]: https://doc.rust-lang.org/std/convert/trait.Into.html"
-
#: src/traits/read-write.md:1
msgid "# `Read` and `Write`"
msgstr "# `Read` e `Write`"
@@ -9715,67 +8948,39 @@ msgstr "Usando `Read` e `BufRead`, você pode abstrair a leitura de conteúdos d
#: src/traits/read-write.md:5
msgid ""
"```rust,editable\n"
-"use std::io::{BufRead, BufReader, Read, Result};"
-msgstr ""
-
-#: src/traits/read-write.md:8
-msgid ""
+"use std::io::{BufRead, BufReader, Read, Result};\n"
+"\n"
"fn count_lines\n"
-" \n"
-"* The reason for that is that when the `thread::scope` function completes, all the threads are guaranteed to be joined, so "
-"they can return borrowed data.\n"
-"* Normal Rust borrowing rules apply: you can either borrow mutably by one thread, or immutably by any number of threads.\n"
-" \n"
-"
"
-msgstr ""
-"\n"
-" \n"
-"* A razão para isso é que, quando a função `thread::scope` for concluída, todas as _threads_ serão unidas, para que possam "
-"retornar dados emprestados.\n"
-"* Aplicam-se as regras normais de empréstimo do Rust: o empréstimo pode ser mutável, para uma `thread` ou imutável para\n"
-"qualquer número de _threads_.\n"
-" \n"
-"
"
-
-#: src/concurrency/channels.md:1
-msgid "# Channels"
-msgstr "# Channels (Canais)"
-
-#: src/concurrency/channels.md:3
-msgid ""
-"Rust channels have two parts: a `Sender\n"
-" \n"
-"* `Mutex` in Rust looks like a collection with just one element - the protected data.\n"
-" * It is not possible to forget to acquire the mutex before accessing the protected data.\n"
-"* You can get an `&mut T` from an `&Mutex` by taking the lock. The `MutexGuard` ensures that the\n"
-" `&mut T` doesn't outlive the lock being held.\n"
-"* `Mutex` implements both `Send` and `Sync` iff `T` implements `Send`.\n"
-"* A read-write lock counterpart - `RwLock`.\n"
-"* Why does `lock()` return a `Result`? \n"
-" * If the thread that held the `Mutex` panicked, the `Mutex` becomes \"poisoned\" to signal that\n"
-" the data it protected might be in an inconsistent state. Calling `lock()` on a poisoned mutex\n"
-" fails with a [`PoisonError`]. You can call `into_inner()` on the error to recover the data\n"
-" regardless."
-msgstr ""
-"
"
-
-#: src/concurrency/shared_state/example.md:3
-msgid "Let us see `Arc` and `Mutex` in action:"
-msgstr "Vamos ver `Arc` e `Mutex` em ação:"
-
-#: src/concurrency/shared_state/example.md:5
-msgid ""
-"```rust,editable,compile_fail\n"
-"use std::thread;\n"
-"// use std::sync::{Arc, Mutex};"
-msgstr ""
-"```rust,editable,compile_fail\n"
-"use std::thread;\n"
-"// use std::sync::{Arc, Mutex};"
-
-#: src/concurrency/shared_state/example.md:9
-msgid ""
-"fn main() {\n"
-" let mut v = vec![10, 20, 30];\n"
-" let handle = thread::spawn(|| {\n"
-" v.push(10);\n"
-" });\n"
-" v.push(1000);"
-msgstr ""
-"fn main() {\n"
-" let mut v = vec![10, 20, 30];\n"
-" let handle = thread::spawn(|| {\n"
-" v.push(10);\n"
-" });\n"
-" v.push(1000);"
-
-#: src/concurrency/shared_state/example.md:16
-msgid ""
-" handle.join().unwrap();\n"
-" println!(\"v: {v:?}\");\n"
-"}\n"
-"```"
-msgstr ""
-" handle.join().unwrap();\n"
-" println!(\"v: {v:?}\");\n"
-"}\n"
-"```"
-
-#: src/concurrency/shared_state/example.md:23
-msgid ""
-"Possible solution:\n"
-" \n"
-"```rust,editable\n"
-"use std::sync::{Arc, Mutex};\n"
-"use std::thread;"
-msgstr ""
-"Solução possível:\n"
-" \n"
-"```rust, editable\n"
-"use std::sync::{Arc, Mutex};\n"
-"use std::thread;"
-
-#: src/concurrency/shared_state/example.md:29
-msgid ""
-"fn main() {\n"
-" let v = Arc::new(Mutex::new(vec![10, 20, 30]));"
-msgstr ""
-"fn main() {\n"
-" let v = Arc::new(Mutex::new(vec![10, 20, 30]));"
-
-#: src/concurrency/shared_state/example.md:32
-msgid ""
-" let v2 = v.clone();\n"
-" let handle = thread::spawn(move || {\n"
-" let mut v2 = v2.lock().unwrap();\n"
-" v2.push(10);\n"
-" });"
-msgstr ""
-" let v2 = v.clone();\n"
-" let handle = thread::spawn(move || {\n"
-" let mut v2 = v2.lock().unwrap();\n"
-" v2.push(10);\n"
-" });"
-
-#: src/concurrency/shared_state/example.md:38
-msgid ""
-" {\n"
-" let mut v = v.lock().unwrap();\n"
-" v.push(1000);\n"
-" }"
-msgstr ""
-" {\n"
-" let mut v = v.lock().unwrap();\n"
-" v.push(1000);\n"
-" }"
-
-#: src/concurrency/shared_state/example.md:43
-msgid " handle.join().unwrap();"
-msgstr " handle.join().unwrap();"
-
-#: src/concurrency/shared_state/example.md:45
-msgid ""
-" {\n"
-" let v = v.lock().unwrap();\n"
-" println!(\"v: {v:?}\");\n"
-" }\n"
-"}\n"
-"```\n"
-" \n"
-"Notable parts:"
-msgstr ""
-" {\n"
-" let v = v.lock().unwrap();\n"
-" println!(\"v: {v:?}\");\n"
-" }\n"
-"}\n"
-"```\n"
-" \n"
-"Partes importantes:"
-
-#: src/concurrency/shared_state/example.md:54
-msgid ""
-"* `v` is wrapped in both `Arc` and `Mutex`, because their concerns are orthogonal.\n"
-" * Wrapping a `Mutex` in an `Arc` is a common pattern to share mutable state between threads.\n"
-"* `v: Arc<_>` needs to be cloned as `v2` before it can be moved into another thread. Note `move` was added to the lambda "
-"signature.\n"
-"* Blocks are introduced to narrow the scope of the `LockGuard` as much as possible.\n"
-"* We still need to acquire the `Mutex` to print our `Vec`."
-msgstr ""
-"* `v` é agrupado em ambos `Arc` e `Mutex`, porque seus interesses são ortogonais.\n"
-" * Envolver um `Mutex` em um `Arc` é um padrão comum para compartilhar o estado mutável entre threads.\n"
-"* `v: Arc<_>` precisa ser clonado como `v2` antes que possa ser movido para outro thread. Note que `move` foi adicionado à "
-"assinatura lambda.\n"
-"* Os blocos são introduzidos para restringir o escopo do `LockGuard` tanto quanto possível.\n"
-"* Ainda precisamos adquirir o `Mutex` para imprimir nosso `Vec`."
-
-#: src/concurrency/send-sync.md:1
-msgid "# `Send` and `Sync`"
-msgstr "# `Send` e `Sync`"
-
-#: src/concurrency/send-sync.md:3
-msgid "How does Rust know to forbid shared access across thread? The answer is in two traits:"
-msgstr "Como o Rust sabe proibir o acesso compartilhado entre threads? A resposta está em duas características:"
-
-#: src/concurrency/send-sync.md:5
-msgid ""
-"* [`Send`][1]: a type `T` is `Send` if it is safe to move a `T` across a thread\n"
-" boundary.\n"
-"* [`Sync`][2]: a type `T` is `Sync` if it is safe to move a `&T` across a thread\n"
-" boundary."
-msgstr ""
-"* [`Send`][1]: um tipo `T` é `Send` se for seguro mover um `T` entre _threads_\n"
-"* [`Sync`][2]: um tipo `T` é `Sync` se for seguro mover um `&T` entre _threads_"
-
-#: src/concurrency/send-sync.md:10
-msgid ""
-"`Send` and `Sync` are [unsafe traits][3]. The compiler will automatically derive them for your types\n"
-"as long as they only contain `Send` and `Sync` types. You can also implement them manually when you\n"
-"know it is valid."
-msgstr ""
-"`Send` e `Sync` são [`unsafe traits`][3]. O compilador os derivará automaticamente para seus tipos\n"
-"desde que contenham apenas os tipos `Send` e `Sync`. Você também pode implementá-los manualmente quando\n"
-"souber que são válidos."
-
-#: src/concurrency/send-sync.md:14
-msgid ""
-"[1]: https://doc.rust-lang.org/std/marker/trait.Send.html\n"
-"[2]: https://doc.rust-lang.org/std/marker/trait.Sync.html\n"
-"[3]: ../unsafe/unsafe-traits.md"
-msgstr ""
-"[1]: https://doc.rust-lang.org/std/marker/trait.Send.html\n"
-"[2]: https://doc.rust-lang.org/std/marker/trait.Sync.html\n"
-"[3]: ../unsafe/unsafe-traits.md"
-
-#: src/concurrency/send-sync.md:20
-msgid ""
-"* One can think of these traits as markers that the type has certain thread-safety properties.\n"
-"* They can be used in the generic constraints as normal traits.\n"
-" \n"
-""
-msgstr ""
-"* Pode-se pensar nesses _traits_ como marcadores de que o tipo possui certas propriedades de segurança de "
-"_threads_.\n"
-"* Eles podem ser usados nas restrições genéricas como _traits_ normais.\n"
-" \n"
-""
-
-#: src/concurrency/send-sync/send.md:1
-msgid "# `Send`"
-msgstr "# `Send`"
-
-#: src/concurrency/send-sync/send.md:3
-msgid "> A type `T` is [`Send`][1] if it is safe to move a `T` value to another thread."
-msgstr "> Um tipo `T` é [`Send`][1] se for seguro mover um valor `T` para outro _thread_."
-
-#: src/concurrency/send-sync/send.md:5
-msgid ""
-"The effect of moving ownership to another thread is that _destructors_ will run\n"
-"in that thread. So the question is when you can allocate a value in one thread\n"
-"and deallocate it in another."
-msgstr ""
-"O efeito de mover a propriedade (ownership) para outro _thread_ é que os _destructors_ serão executados\n"
-"nessa _thread_. Então a questão é: quando você pode alocar um valor em um _thread_\n"
-"e desalocá-lo em outro?"
-
-#: src/concurrency/send-sync/send.md:9
-msgid "[1]: https://doc.rust-lang.org/std/marker/trait.Send.html"
-msgstr "[1]: https://doc.rust-lang.org/std/marker/trait.Send.html"
-
-#: src/concurrency/send-sync/sync.md:1
-msgid "# `Sync`"
-msgstr "# `Sync`"
-
-#: src/concurrency/send-sync/sync.md:3
-msgid ""
-"> A type `T` is [`Sync`][1] if it is safe to access a `T` value from multiple\n"
-"> threads at the same time."
-msgstr ""
-"> Um tipo `T` é [`Sync`][1] se for seguro acessar um valor `T` de várias\n"
-"> threads ao mesmo tempo."
-
-#: src/concurrency/send-sync/sync.md:6
-msgid "More precisely, the definition is:"
-msgstr "Mais precisamente, a definição é:"
-
-#: src/concurrency/send-sync/sync.md:8
-msgid "> `T` is `Sync` if and only if `&T` is `Send`"
-msgstr "> `T` é `Sync` se e somente se `&T` é `Send`"
-
-#: src/concurrency/send-sync/sync.md:10
-msgid "[1]: https://doc.rust-lang.org/std/marker/trait.Sync.html"
-msgstr "[1]: https://doc.rust-lang.org/std/marker/trait.Sync.html"
-
-#: src/concurrency/send-sync/sync.md:14
-msgid ""
-"This statement is essentially a shorthand way of saying that if a type is thread-safe for shared use, it is also thread-"
-"safe to pass references of it across threads."
-msgstr ""
-"Essa instrução é essencialmente uma maneira abreviada de dizer que, se um tipo é _thread-safe_ para uso compartilhado, também "
-"é _thread-safe_ passar referências a ele entre _threads_."
-
-#: src/concurrency/send-sync/sync.md:16
-msgid ""
-"This is because if a type is Sync it means that it can be shared across multiple threads without the risk of data races or "
-"other synchronization issues, so it is safe to move it to another thread. A reference to the type is also safe to move to "
-"another thread, because the data it references can be accessed from any thread safely."
-msgstr ""
-"Isso ocorre porque, se um tipo for `Sync`, significa que ele pode ser compartilhado entre vários _threads_ sem o risco de "
-"corridas de dados ou outros problemas de sincronização, portanto, é seguro movê-lo para outro _thread_. Uma referência "
-"ao tipo também é segura para mover para outro _thread_, porque os dados a que ela faz referência podem ser acessados de "
-"qualquer _thread_ com segurança."
-
-#: src/concurrency/send-sync/examples.md:1
-msgid "# Examples"
-msgstr "# Exemplos"
-
-#: src/concurrency/send-sync/examples.md:3
-msgid "## `Send + Sync`"
-msgstr "## `Send + Sync`"
-
-#: src/concurrency/send-sync/examples.md:5
-msgid "Most types you come across are `Send + Sync`:"
-msgstr "A maioria dos tipos que você encontra são `Send + Sync`:"
-
-#: src/concurrency/send-sync/examples.md:7
-msgid ""
-"* `i8`, `f32`, `bool`, `char`, `&str`, ...\n"
-"* `(T1, T2)`, `[T; N]`, `&[T]`, `struct { x: T }`, ...\n"
-"* `String`, `Option\n"
-" \n"
-"* `Mutex` em Rust parece uma coleção com apenas um elemento - os dados protegidos.\n"
-" * Não é possível esquecer de adquirir o mutex antes de acessar os dados protegidos.\n"
-"* Você pode obter um `&mut T` de um `&Mutex` obtendo um bloqueio (_lock_). O `MutexGuard` garante que o\n"
-" `&mut T` não sobrevive além do bloqueio (_lock_).\n"
-"* `Mutex` implementa `Send` e `Sync` se `T` implementa `Send`.\n"
-"* O bloqueio para leitura e gravação - `RwLock`.\n"
-"* Por que `lock()` retorna um `Result`?\n"
-" * Se o thread que manteve o `Mutex` entrou em pânico, o `Mutex` torna-se \"envenenado\" para sinalizar que\n"
-" os dados protegidos podem estar em um estado inconsistente. Ao chamar `lock()` em um mutex envenenado\n"
-" o retorno é uma falha com um [`PoisonError`]. Você pode chamar `into_inner()` no erro para recuperar os dados\n"
-" independentemente."
-
-#: src/concurrency/shared_state/mutex.md:44
-msgid ""
-"[`PoisonError`]: https://doc.rust-lang.org/std/sync/struct.PoisonError.html \n"
-" \n"
-"
"
-msgstr ""
-"[`PoisonError`]: https://doc.rust-lang.org/std/sync/struct.PoisonError.html\n"
-" \n"
-"![](\"cpp/overview.svg\")
"
msgid "See the [CXX tutorial][2] for an full example of using this."
msgstr "Veja o [tutorial CXX][2] para um exemplo completo de como usá-lo."
-#: src/android/interoperability/cpp.md:12
-msgid ""
-"[1]: https://cxx.rs/\n"
-"[2]: https://cxx.rs/tutorial.html"
-msgstr ""
-"[1]: https://cxx.rs/\n"
-"[2]: https://cxx.rs/tutorial.html"
-
#: src/android/interoperability/java.md:1
msgid "# Interoperability with Java"
msgstr "# Interoperabilidade com Java"
@@ -15682,25 +12282,15 @@ msgid "_interoperability/java/src/lib.rs_:"
msgstr "_interoperability/java/src/lib.rs_:"
#: src/android/interoperability/java.md:11
+#, fuzzy
msgid ""
"```rust,compile_fail\n"
-"//! Rust <-> Java FFI demo."
-msgstr ""
-"```rust,compile_fail\n"
-"//! Demonstração FFI Rust <-> Java."
-
-#: src/android/interoperability/java.md:14
-msgid ""
+"//! Rust <-> Java FFI demo.\n"
+"\n"
"use jni::objects::{JClass, JString};\n"
"use jni::sys::jstring;\n"
-"use jni::JNIEnv;"
-msgstr ""
-"use jni::objects::{JClass, JString};\n"
-"use jni::sys::jstring;\n"
-"use jni::JNIEnv;"
-
-#: src/android/interoperability/java.md:18
-msgid ""
+"use jni::JNIEnv;\n"
+"\n"
"/// HelloWorld::hello method implementation.\n"
"#[no_mangle]\n"
"pub extern \"system\" fn Java_HelloWorld_hello(\n"
@@ -15729,7 +12319,8 @@ msgstr ""
"}\n"
"```"
-#: src/android/interoperability/java.md:32 src/android/interoperability/java.md:62
+#: src/android/interoperability/java.md:32
+#: src/android/interoperability/java.md:62
msgid "_interoperability/java/Android.bp_:"
msgstr "_interoperability/java/Android.bp_:"
@@ -15762,27 +12353,16 @@ msgid "_interoperability/java/HelloWorld.java_:"
msgstr "_interoperability/java/HelloWorld.java_:"
#: src/android/interoperability/java.md:47
+#, fuzzy
msgid ""
"```java\n"
"class HelloWorld {\n"
-" private static native String hello(String name);"
-msgstr ""
-"```java\n"
-"classe HelloWorld{\n"
-" private static native String hello(String name);"
-
-#: src/android/interoperability/java.md:51
-msgid ""
+" private static native String hello(String name);\n"
+"\n"
" static {\n"
" System.loadLibrary(\"hello_jni\");\n"
-" }"
-msgstr ""
-" static {\n"
-" System.loadLibrary(\"hello_jni\");\n"
-" }"
-
-#: src/android/interoperability/java.md:55
-msgid ""
+" }\n"
+"\n"
" public static void main(String[] args) {\n"
" String output = HelloWorld.hello(\"Alice\");\n"
" System.out.println(output);\n"
@@ -15835,23 +12415,31 @@ msgstr ""
"$ adb shell /system/bin/helloworld_jni\n"
"```"
-#: src/exercises/day-4/afternoon.md:3
+#: src/exercises/android/morning.md:1 src/exercises/bare-metal/morning.md:1
+#: src/exercises/bare-metal/afternoon.md:1
+#: src/exercises/concurrency/morning.md:1
+#: src/exercises/concurrency/afternoon.md:1
+msgid "# Exercises"
+msgstr "# Exercícios"
+
+#: src/exercises/android/morning.md:3
+#, fuzzy
msgid ""
-"For the last exercise, we will look at one of the projects you work with. Let us\n"
-"group up and do this together. Some suggestions:"
+"This is a group exercise: We will look at one of the projects you work with and\n"
+"try to integrate some Rust into it. Some suggestions:"
msgstr ""
"No último exercício, veremos um dos projetos com os quais você trabalha. Chamem-nos\n"
"agrupem-se e façam isso juntos. Algumas sugestões:"
-#: src/exercises/day-4/afternoon.md:6
-msgid "* Call your AIDL service with a client written in Rust."
-msgstr "* Chame seu serviço AIDL com um cliente escrito em Rust."
-
-#: src/exercises/day-4/afternoon.md:8
-msgid "* Move a function from your project to Rust and call it."
+#: src/exercises/android/morning.md:6
+#, fuzzy
+msgid ""
+"* Call your AIDL service with a client written in Rust.\n"
+"\n"
+"* Move a function from your project to Rust and call it."
msgstr "* Mova uma função do seu projeto para o Rust e chame-a."
-#: src/exercises/day-4/afternoon.md:12
+#: src/exercises/android/morning.md:12
msgid ""
"No solution is provided here since this is open-ended: it relies on someone in\n"
"the class having a piece of code which you can turn in to Rust on the fly."
@@ -15859,6 +12447,5209 @@ msgstr ""
"Nenhuma solução é fornecida aqui, pois isso é aberto: depende de você ter\n"
"uma classe tendo um pedaço de código que você pode transformar em Rust em tempo real."
+#: src/bare-metal.md:1
+#, fuzzy
+msgid "# Welcome to Bare Metal Rust"
+msgstr "# Bem-vindo ao Comprehensive Rust 🦀"
+
+#: src/bare-metal.md:3
+msgid ""
+"This is a standalone one-day course about bare-metal Rust, aimed at people who are familiar with the\n"
+"basics of Rust (perhaps from completing the Comprehensive Rust course), and ideally also have some\n"
+"experience with bare-metal programming in some other language such as C."
+msgstr ""
+
+#: src/bare-metal.md:7
+msgid ""
+"Today we will talk about 'bare-metal' Rust: running Rust code without an OS underneath us. This will\n"
+"be divided into several parts:"
+msgstr ""
+
+#: src/bare-metal.md:10
+msgid ""
+"- What is `no_std` Rust?\n"
+"- Writing firmware for microcontrollers.\n"
+"- Writing bootloader / kernel code for application processors.\n"
+"- Some useful crates for bare-metal Rust development."
+msgstr ""
+
+#: src/bare-metal.md:15
+msgid ""
+"For the microcontroller part of the course we will use the [BBC micro:bit](https://microbit.org/) v2\n"
+"as an example. It's a [development board](https://tech.microbit.org/hardware/) based on the Nordic\n"
+"nRF51822 microcontroller with some LEDs and buttons, an I2C-connected accelerometer and compass, and\n"
+"an on-board SWD debugger."
+msgstr ""
+
+#: src/bare-metal.md:20
+msgid "To get started, install some tools we'll need later. On gLinux or Debian:"
+msgstr ""
+
+#: src/bare-metal.md:22
+msgid ""
+"```bash\n"
+"sudo apt install gcc-aarch64-linux-gnu gdb-multiarch libudev-dev picocom pkg-config qemu-system-arm\n"
+"rustup update\n"
+"rustup target add aarch64-unknown-none thumbv7em-none-eabihf\n"
+"rustup component add llvm-tools-preview\n"
+"cargo install cargo-binutils cargo-embed\n"
+"```"
+msgstr ""
+
+#: src/bare-metal.md:30
+msgid "And give users in the `plugdev` group access to the micro:bit programmer:"
+msgstr ""
+
+#: src/bare-metal.md:32
+msgid ""
+"```bash\n"
+"echo 'SUBSYSTEM==\"usb\", ATTR{idVendor}==\"0d28\", MODE=\"0664\", GROUP=\"plugdev\"' |\\\n"
+" sudo tee /etc/udev/rules.d/50-microbit.rules\n"
+"sudo udevadm control --reload-rules\n"
+"```"
+msgstr ""
+
+#: src/bare-metal.md:38
+msgid "On MacOS:"
+msgstr ""
+
+#: src/bare-metal.md:40
+msgid ""
+"```bash\n"
+"xcode-select --install\n"
+"brew install gdb picocom qemu\n"
+"brew install --cask gcc-aarch64-embedded\n"
+"rustup update\n"
+"rustup target add aarch64-unknown-none thumbv7em-none-eabihf\n"
+"rustup component add llvm-tools-preview\n"
+"cargo install cargo-binutils cargo-embed\n"
+"```"
+msgstr ""
+
+#: src/bare-metal/no_std.md:1
+msgid "# `no_std`"
+msgstr ""
+
+#: src/bare-metal/no_std.md:3
+msgid ""
+"| " +msgstr "" + +#: src/bare-metal/no_std.md:7 +msgid "`core`" +msgstr "" + +#: src/bare-metal/no_std.md:9 src/bare-metal/no_std.md:14 +msgid "" +" | \n" +"" +msgstr "" + +#: src/bare-metal/no_std.md:12 +msgid "`alloc`" +msgstr "" + +#: src/bare-metal/no_std.md:17 +msgid "`std`" +msgstr "" + +#: src/bare-metal/no_std.md:19 +msgid "" +" | \n" +"
|---|---|
| " +msgstr "" + +#: src/bare-metal/no_std.md:24 +msgid "" +"* Slices, `&str`, `CStr`\n" +"* `NonZeroU8`...\n" +"* `Option`, `Result`\n" +"* `Display`, `Debug`, `write!`...\n" +"* `Iterator`\n" +"* `panic!`, `assert_eq!`...\n" +"* `NonNull` and all the usual pointer-related functions\n" +"* `Future` and `async`/`await`\n" +"* `fence`, `AtomicBool`, `AtomicPtr`, `AtomicU32`...\n" +"* `Duration`" +msgstr "" + +#: src/bare-metal/no_std.md:35 src/bare-metal/no_std.md:42 +msgid "" +" | \n" +"" +msgstr "" + +#: src/bare-metal/no_std.md:38 +msgid "" +"* `Box`, `Cow`, `Arc`, `Rc`\n" +"* `Vec`, `BinaryHeap`, `BtreeMap`, `LinkedList`, `VecDeque`\n" +"* `String`, `CString`, `format!`" +msgstr "" + +#: src/bare-metal/no_std.md:45 +msgid "" +"* `Error`\n" +"* `HashMap`\n" +"* `Mutex`, `Condvar`, `Barrier`, `Once`, `RwLock`, `mpsc`\n" +"* `File` and the rest of `fs`\n" +"* `println!`, `Read`, `Write`, `Stdin`, `Stdout` and the rest of `io`\n" +"* `Path`, `OsString`\n" +"* `net`\n" +"* `Command`, `Child`, `ExitCode`\n" +"* `spawn`, `sleep` and the rest of `thread`\n" +"* `SystemTime`, `Instant`" +msgstr "" + +#: src/bare-metal/no_std.md:56 +msgid "" +" | \n" +"
"
+msgstr ""
+
+#: src/bare-metal/no_std.md:62
+msgid ""
+"* `HashMap` depends on RNG.\n"
+"* `std` re-exports the contents of both `core` and `alloc`."
+msgstr ""
+
+#: src/bare-metal/minimal.md:1
+msgid "# A minimal `no_std` program"
+msgstr ""
+
+#: src/bare-metal/minimal.md:3
+msgid ""
+"```rust,editable,compile_fail\n"
+"#![no_main]\n"
+"#![no_std]\n"
+"\n"
+"use core::panic::PanicInfo;\n"
+"\n"
+"#[panic_handler]\n"
+"fn panic(_panic: &PanicInfo) -> ! {\n"
+" loop {}\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/bare-metal/minimal.md:17
+msgid ""
+"* This will compile to an empty binary.\n"
+"* `std` provides a panic handler; without it we must provide our own.\n"
+"* It can also be provided by another crate, such as `panic-halt`.\n"
+"* Depending on the target, you may need to compile with `panic = \"abort\"` to avoid an error about\n"
+" `eh_personality`.\n"
+"* Note that there is no `main` or any other entry point; it's up to you to define your own entry\n"
+" point. This will typically involve a linker script and some assembly code to set things up ready\n"
+" for Rust code to run."
+msgstr ""
+
+#: src/bare-metal/alloc.md:1
+msgid "# `alloc`"
+msgstr ""
+
+#: src/bare-metal/alloc.md:3
+msgid ""
+"To use `alloc` you must implement a\n"
+"[global (heap) allocator](https://doc.rust-lang.org/stable/std/alloc/trait.GlobalAlloc.html)."
+msgstr ""
+
+#: src/bare-metal/alloc.md:6
+msgid ""
+"```rust,editable,compile_fail\n"
+"#![no_main]\n"
+"#![no_std]\n"
+"\n"
+"extern crate alloc;\n"
+"extern crate panic_halt as _;\n"
+"\n"
+"use alloc::string::ToString;\n"
+"use alloc::vec::Vec;\n"
+"use buddy_system_allocator::LockedHeap;\n"
+"\n"
+"#[global_allocator]\n"
+"static HEAP_ALLOCATOR: LockedHeap<32> = LockedHeap::<32>::new();\n"
+"\n"
+"static mut HEAP: [u8; 65536] = [0; 65536];\n"
+"\n"
+"pub fn entry() {\n"
+" // Safe because `HEAP` is only used here and `entry` is only called once.\n"
+" unsafe {\n"
+" // Give the allocator some memory to allocate.\n"
+" HEAP_ALLOCATOR\n"
+" .lock()\n"
+" .init(HEAP.as_mut_ptr() as usize, HEAP.len());\n"
+" }\n"
+"\n"
+" // Now we can do things that require heap allocation.\n"
+" let mut v = Vec::new();\n"
+" v.push(\"A string\".to_string());\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/bare-metal/alloc.md:39
+msgid ""
+"* `buddy_system_allocator` is a third-party crate implementing a basic buddy system allocator. Other\n"
+" crates are available, or you can write your own or hook into your existing allocator.\n"
+"* The const parameter of `LockedHeap` is the max order of the allocator; i.e. in this case it can\n"
+" allocate regions of up to 2**32 bytes.\n"
+"* If any crate in your dependency tree depends on `alloc` then you must have exactly one global\n"
+" allocator defined in your binary. Usually this is done in the top-level binary crate.\n"
+"* `extern crate panic_halt as _` is necessary to ensure that the `panic_halt` crate is linked in so\n"
+" we get its panic handler.\n"
+"* This example will build but not run, as it doesn't have an entry point."
+msgstr ""
+
+#: src/bare-metal/microcontrollers.md:1
+msgid "# Microcontrollers"
+msgstr ""
+
+#: src/bare-metal/microcontrollers.md:3
+msgid "The `cortex_m_rt` crate provides (among other things) a reset handler for Cortex M microcontrollers."
+msgstr ""
+
+#: src/bare-metal/microcontrollers.md:5
+msgid ""
+"```rust,editable,compile_fail\n"
+"#![no_main]\n"
+"#![no_std]\n"
+"\n"
+"extern crate panic_halt as _;\n"
+"\n"
+"mod interrupts;\n"
+"\n"
+"use cortex_m_rt::entry;\n"
+"\n"
+"#[entry]\n"
+"fn main() -> ! {\n"
+" loop {}\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/bare-metal/microcontrollers.md:21
+msgid "Next we'll look at how to access peripherals, with increasing levels of abstraction."
+msgstr ""
+
+#: src/bare-metal/microcontrollers.md:25
+msgid ""
+"* The `cortex_m_rt::entry` macro requires that the function have type `fn() -> !`, because returning\n"
+" to the reset handler doesn't make sense.\n"
+"* Run the example with `cargo embed --bin minimal`"
+msgstr ""
+
+#: src/bare-metal/microcontrollers/mmio.md:1
+msgid "# Raw MMIO"
+msgstr ""
+
+#: src/bare-metal/microcontrollers/mmio.md:3
+msgid ""
+"Most microcontrollers access peripherals via memory-mapped IO. Let's try turning on an LED on our\n"
+"micro:bit:"
+msgstr ""
+
+#: src/bare-metal/microcontrollers/mmio.md:6
+msgid ""
+"```rust,editable,compile_fail\n"
+"#![no_main]\n"
+"#![no_std]\n"
+"\n"
+"extern crate panic_halt as _;\n"
+"\n"
+"mod interrupts;\n"
+"\n"
+"use core::mem::size_of;\n"
+"use cortex_m_rt::entry;\n"
+"\n"
+"/// GPIO port 0 peripheral address\n"
+"const GPIO_P0: usize = 0x5000_0000;\n"
+"\n"
+"// GPIO peripheral offsets\n"
+"const PIN_CNF: usize = 0x700;\n"
+"const OUTSET: usize = 0x508;\n"
+"const OUTCLR: usize = 0x50c;\n"
+"\n"
+"// PIN_CNF fields\n"
+"const DIR_OUTPUT: u32 = 0x1;\n"
+"const INPUT_DISCONNECT: u32 = 0x1 << 1;\n"
+"const PULL_DISABLED: u32 = 0x0 << 2;\n"
+"const DRIVE_S0S1: u32 = 0x0 << 8;\n"
+"const SENSE_DISABLED: u32 = 0x0 << 16;\n"
+"\n"
+"#[entry]\n"
+"fn main() -> ! {\n"
+" // Configure GPIO 0 pins 21 and 28 as push-pull outputs.\n"
+" let pin_cnf_21 = (GPIO_P0 + PIN_CNF + 21 * size_of::()) as *mut u32;\n"
+" let pin_cnf_28 = (GPIO_P0 + PIN_CNF + 28 * size_of::()) as *mut u32;\n"
+" // Safe because the pointers are to valid peripheral control registers, and\n"
+" // no aliases exist.\n"
+" unsafe {\n"
+" pin_cnf_21.write_volatile(\n"
+" DIR_OUTPUT | INPUT_DISCONNECT | PULL_DISABLED | DRIVE_S0S1 | SENSE_DISABLED,\n"
+" );\n"
+" pin_cnf_28.write_volatile(\n"
+" DIR_OUTPUT | INPUT_DISCONNECT | PULL_DISABLED | DRIVE_S0S1 | SENSE_DISABLED,\n"
+" );\n"
+" }\n"
+"\n"
+" // Set pin 28 low and pin 21 high to turn the LED on.\n"
+" let gpio0_outset = (GPIO_P0 + OUTSET) as *mut u32;\n"
+" let gpio0_outclr = (GPIO_P0 + OUTCLR) as *mut u32;\n"
+" // Safe because the pointers are to valid peripheral control registers, and\n"
+" // no aliases exist.\n"
+" unsafe {\n"
+" gpio0_outclr.write_volatile(1 << 28);\n"
+" gpio0_outset.write_volatile(1 << 21);\n"
+" }\n"
+"\n"
+" loop {}\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/bare-metal/microcontrollers/mmio.md:64
+msgid "* GPIO 0 pin 21 is connected to the first column of the LED matrix, and pin 28 to the first row."
+msgstr ""
+
+#: src/bare-metal/microcontrollers/mmio.md:66
+#: src/bare-metal/microcontrollers/pacs.md:59
+#: src/bare-metal/microcontrollers/hals.md:43
+#: src/bare-metal/microcontrollers/board-support.md:34
+msgid "Run the example with:"
+msgstr ""
+
+#: src/bare-metal/microcontrollers/mmio.md:68
+#, fuzzy
+msgid ""
+"```sh\n"
+"cargo embed --bin mmio\n"
+"```"
+msgstr ""
+"```shell\n"
+"$ cargo run\n"
+"```"
+
+#: src/bare-metal/microcontrollers/pacs.md:1
+msgid "# Peripheral Access Crates"
+msgstr ""
+
+#: src/bare-metal/microcontrollers/pacs.md:3
+msgid ""
+"[`svd2rust`](https://crates.io/crates/svd2rust) generates mostly-safe Rust wrappers for\n"
+"memory-mapped peripherals from [CMSIS-SVD](https://www.keil.com/pack/doc/CMSIS/SVD/html/index.html)\n"
+"files."
+msgstr ""
+
+#: src/bare-metal/microcontrollers/pacs.md:7
+msgid ""
+"```rust,editable,compile_fail\n"
+"#![no_main]\n"
+"#![no_std]\n"
+"\n"
+"extern crate panic_halt as _;\n"
+"\n"
+"use cortex_m_rt::entry;\n"
+"use nrf52833_pac::Peripherals;\n"
+"\n"
+"#[entry]\n"
+"fn main() -> ! {\n"
+" let p = Peripherals::take().unwrap();\n"
+" let gpio0 = p.P0;\n"
+"\n"
+" // Configure GPIO 0 pins 21 and 28 as push-pull outputs.\n"
+" gpio0.pin_cnf[21].write(|w| {\n"
+" w.dir().output();\n"
+" w.input().disconnect();\n"
+" w.pull().disabled();\n"
+" w.drive().s0s1();\n"
+" w.sense().disabled();\n"
+" w\n"
+" });\n"
+" gpio0.pin_cnf[28].write(|w| {\n"
+" w.dir().output();\n"
+" w.input().disconnect();\n"
+" w.pull().disabled();\n"
+" w.drive().s0s1();\n"
+" w.sense().disabled();\n"
+" w\n"
+" });\n"
+"\n"
+" // Set pin 28 low and pin 21 high to turn the LED on.\n"
+" gpio0.outclr.write(|w| w.pin28().clear());\n"
+" gpio0.outset.write(|w| w.pin21().set());\n"
+"\n"
+" loop {}\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/bare-metal/microcontrollers/pacs.md:49
+msgid ""
+"* SVD (System View Description) files are XML files typically provided by silicon vendors which\n"
+" describe the memory map of the device.\n"
+" * They are organised by peripheral, register, field and value, with names, descriptions, addresses\n"
+" and so on.\n"
+" * SVD files are often buggy and incomplete, so there are various projects which patch the\n"
+" mistakes, add missing details, and publish the generated crates.\n"
+"* `cortex-m-rt` provides the vector table, among other things.\n"
+"* If you `cargo install cargo-binutils` then you can run\n"
+" `cargo objdump --bin pac -- -d --no-show-raw-insn` to see the resulting binary."
+msgstr ""
+
+#: src/bare-metal/microcontrollers/pacs.md:61
+#, fuzzy
+msgid ""
+"```sh\n"
+"cargo embed --bin pac\n"
+"```"
+msgstr ""
+"```shell\n"
+"$ cargo run\n"
+"```"
+
+#: src/bare-metal/microcontrollers/hals.md:1
+msgid "# HAL crates"
+msgstr ""
+
+#: src/bare-metal/microcontrollers/hals.md:3
+msgid ""
+"[HAL crates](https://github.com/rust-embedded/awesome-embedded-rust#hal-implementation-crates) for\n"
+"many microcontrollers provide wrappers around various peripherals. These generally implement traits\n"
+"from [`embedded-hal`](https://crates.io/crates/embedded-hal)."
+msgstr ""
+
+#: src/bare-metal/microcontrollers/hals.md:7
+msgid ""
+"```rust,editable,compile_fail\n"
+"#![no_main]\n"
+"#![no_std]\n"
+"\n"
+"extern crate panic_halt as _;\n"
+"\n"
+"use cortex_m_rt::entry;\n"
+"use nrf52833_hal::gpio::{p0, Level};\n"
+"use nrf52833_hal::pac::Peripherals;\n"
+"use nrf52833_hal::prelude::*;\n"
+"\n"
+"#[entry]\n"
+"fn main() -> ! {\n"
+" let p = Peripherals::take().unwrap();\n"
+"\n"
+" // Create HAL wrapper for GPIO port 0.\n"
+" let gpio0 = p0::Parts::new(p.P0);\n"
+"\n"
+" // Configure GPIO 0 pins 21 and 28 as push-pull outputs.\n"
+" let mut col1 = gpio0.p0_28.into_push_pull_output(Level::High);\n"
+" let mut row1 = gpio0.p0_21.into_push_pull_output(Level::Low);\n"
+"\n"
+" // Set pin 28 low and pin 21 high to turn the LED on.\n"
+" col1.set_low().unwrap();\n"
+" row1.set_high().unwrap();\n"
+"\n"
+" loop {}\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/bare-metal/microcontrollers/hals.md:39
+msgid ""
+" * `set_low` and `set_high` are methods on the `embedded_hal` `OutputPin` trait.\n"
+" * HAL crates exist for many Cortex-M and RISC-V devices, including various STM32, GD32, nRF, NXP,\n"
+" MSP430, AVR and PIC microcontrollers."
+msgstr ""
+
+#: src/bare-metal/microcontrollers/hals.md:45
+#, fuzzy
+msgid ""
+"```sh\n"
+"cargo embed --bin hal\n"
+"```"
+msgstr ""
+"```shell\n"
+"$ cargo run\n"
+"```"
+
+#: src/bare-metal/microcontrollers/board-support.md:1
+#, fuzzy
+msgid "# Board support crates"
+msgstr "# Atalhos do teclado"
+
+#: src/bare-metal/microcontrollers/board-support.md:3
+msgid "Board support crates provide a further level of wrapping for a specific board for convenience."
+msgstr ""
+
+#: src/bare-metal/microcontrollers/board-support.md:5
+msgid ""
+"```rust,editable,compile_fail\n"
+"#![no_main]\n"
+"#![no_std]\n"
+"\n"
+"extern crate panic_halt as _;\n"
+"\n"
+"use cortex_m_rt::entry;\n"
+"use microbit::hal::prelude::*;\n"
+"use microbit::Board;\n"
+"\n"
+"#[entry]\n"
+"fn main() -> ! {\n"
+" let mut board = Board::take().unwrap();\n"
+"\n"
+" board.display_pins.col1.set_low().unwrap();\n"
+" board.display_pins.row1.set_high().unwrap();\n"
+"\n"
+" loop {}\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/bare-metal/microcontrollers/board-support.md:28
+msgid ""
+" * In this case the board support crate is just providing more useful names, and a bit of\n"
+" initialisation.\n"
+" * The crate may also include drivers for some on-board devices outside of the microcontroller\n"
+" itself.\n"
+" * `microbit-v2` includes a simple driver for the LED matrix."
+msgstr ""
+
+#: src/bare-metal/microcontrollers/board-support.md:36
+msgid ""
+"```sh\n"
+"cargo embed --bin board_support\n"
+"```"
+msgstr ""
+
+#: src/bare-metal/microcontrollers/type-state.md:1
+msgid "# The type state pattern"
+msgstr ""
+
+#: src/bare-metal/microcontrollers/type-state.md:3
+msgid ""
+"```rust,editable,compile_fail\n"
+"#[entry]\n"
+"fn main() -> ! {\n"
+" let p = Peripherals::take().unwrap();\n"
+" let gpio0 = p0::Parts::new(p.P0);\n"
+"\n"
+" let pin: P0_01 = gpio0.p0_01;\n"
+"\n"
+" // let gpio0_01_again = gpio0.p0_01; // Error, moved.\n"
+" let pin_input: P0_01> = pin.into_floating_input();\n"
+" if pin_input.is_high().unwrap() {\n"
+" // ...\n"
+" }\n"
+" let mut pin_output: P0_01> = pin_input\n"
+" .into_open_drain_output(OpenDrainConfig::Disconnect0Standard1, Level::Low);\n"
+" pin_output.set_high().unwrap();\n"
+" // pin_input.is_high(); // Error, moved.\n"
+"\n"
+" let _pin2: P0_02> = gpio0\n"
+" .p0_02\n"
+" .into_open_drain_output(OpenDrainConfig::Disconnect0Standard1, Level::Low);\n"
+" let _pin3: P0_03> = gpio0.p0_03.into_push_pull_output(Level::Low);\n"
+"\n"
+" loop {}\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/bare-metal/microcontrollers/type-state.md:32
+msgid ""
+" * Pins don't implement `Copy` or `Clone`, so only one instance of each can exist. Once a pin is\n"
+" moved out of the port struct nobody else can take it.\n"
+" * Changing the configuration of a pin consumes the old pin instance, so you can’t keep use the old\n"
+" instance afterwards.\n"
+" * The type of a value indicates the state that it is in: e.g. in this case, the configuration state\n"
+" of a GPIO pin. This encodes the state machine into the type system, and ensures that you don't\n"
+" try to use a pin in a certain way without properly configuring it first. Illegal state\n"
+" transitions are caught at compile time.\n"
+" * You can call `is_high` on an input pin and `set_high` on an output pin, but not vice-versa.\n"
+" * Many HAL crates follow this pattern."
+msgstr ""
+
+#: src/bare-metal/microcontrollers/embedded-hal.md:1
+msgid "# `embedded-hal`"
+msgstr ""
+
+#: src/bare-metal/microcontrollers/embedded-hal.md:3
+msgid ""
+"The [`embedded-hal`](https://crates.io/crates/embedded-hal) crate provides a number of traits\n"
+"covering common microcontroller peripherals."
+msgstr ""
+
+#: src/bare-metal/microcontrollers/embedded-hal.md:6
+msgid ""
+" * GPIO\n"
+" * ADC\n"
+" * I2C, SPI, UART, CAN\n"
+" * RNG\n"
+" * Timers\n"
+" * Watchdogs"
+msgstr ""
+
+#: src/bare-metal/microcontrollers/embedded-hal.md:13
+msgid ""
+"Other crates then implement\n"
+"[drivers](https://github.com/rust-embedded/awesome-embedded-rust#driver-crates) in terms of these\n"
+"traits, e.g. an accelerometer driver might need an I2C or SPI bus implementation."
+msgstr ""
+
+#: src/bare-metal/microcontrollers/embedded-hal.md:19
+msgid ""
+" * There are implementations for many microcontrollers, as well as other platforms such as Linux on\n"
+"Raspberry Pi.\n"
+" * There is work in progress on an `async` version of `embedded-hal`, but it isn't stable yet."
+msgstr ""
+
+#: src/bare-metal/microcontrollers/probe-rs.md:1
+msgid "# `probe-rs`, `cargo-embed`"
+msgstr ""
+
+#: src/bare-metal/microcontrollers/probe-rs.md:3
+msgid ""
+"[probe-rs](https://probe.rs/) is a handy toolset for embedded debugging, like OpenOCD but better\n"
+"integrated."
+msgstr ""
+
+#: src/bare-metal/microcontrollers/probe-rs.md:6
+msgid ""
+"* SWD and JTAG via CMSIS-DAP, ST-Link and J-Link probes\n"
+"* GDB stub and Microsoft DAP server\n"
+"* Cargo integration"
+msgstr ""
+
+#: src/bare-metal/microcontrollers/probe-rs.md:10
+msgid ""
+"`cargo-embed` is a cargo subcommand to build and flash binaries, log\n"
+"RTT output and connect GDB. It's configured by an\n"
+"`Embed.toml` file in your project directory."
+msgstr ""
+
+#: src/bare-metal/microcontrollers/probe-rs.md:16
+msgid ""
+"* [CMSIS-DAP](https://arm-software.github.io/CMSIS_5/DAP/html/index.html) is an Arm standard\n"
+" protocol over USB for an in-circuit debugger to access the CoreSight Debug Access Port of various\n"
+" Arm Cortex processors. It's what the on-board debugger on the BBC micro:bit uses.\n"
+"* ST-Link is a range of in-circuit debuggers from ST Microelectronics, J-Link is a range from\n"
+" SEGGER.\n"
+"* The Debug Access Port is usually either a 5-pin JTAG interface or 2-pin Serial Wire Debug.\n"
+"* probe-rs is a library which you can integrate into your own tools if you want to.\n"
+"* The [Microsoft Debug Adapter Protocol](https://microsoft.github.io/debug-adapter-protocol/) lets\n"
+" VSCode and other IDEs debug code running on any supported microcontroller.\n"
+"* cargo-embed is a binary built using the probe-rs library.\n"
+"* RTT (Real Time Transfers) is a mechanism to transfer data between the debug host and the target\n"
+" through a number of ringbuffers."
+msgstr ""
+
+#: src/bare-metal/microcontrollers/debugging.md:1
+#, fuzzy
+msgid "# Debugging"
+msgstr "# Gerando registros (Log)"
+
+#: src/bare-metal/microcontrollers/debugging.md:3
+msgid "Embed.toml:"
+msgstr ""
+
+#: src/bare-metal/microcontrollers/debugging.md:5
+msgid ""
+"```toml\n"
+"[default.general]\n"
+"chip = \"nrf52833_xxAA\"\n"
+"\n"
+"[debug.gdb]\n"
+"enabled = true\n"
+"```"
+msgstr ""
+
+#: src/bare-metal/microcontrollers/debugging.md:13
+msgid "In one terminal under `src/bare-metal/microcontrollers/examples/`:"
+msgstr ""
+
+#: src/bare-metal/microcontrollers/debugging.md:15
+msgid ""
+"```sh\n"
+"cargo embed --bin board_support debug\n"
+"```"
+msgstr ""
+
+#: src/bare-metal/microcontrollers/debugging.md:19
+#, fuzzy
+msgid "In another terminal in the same directory:"
+msgstr "Em outro terminal, verifique se o serviço é executado:"
+
+#: src/bare-metal/microcontrollers/debugging.md:21
+msgid ""
+"```sh\n"
+"gdb-multiarch target/thumbv7em-none-eabihf/debug/board_support --eval-command=\"target remote :1337\"\n"
+"```"
+msgstr ""
+
+#: src/bare-metal/microcontrollers/debugging.md:27
+msgid "In GDB, try running:"
+msgstr ""
+
+#: src/bare-metal/microcontrollers/debugging.md:29
+msgid ""
+"```gdb\n"
+"b src/bin/board_support.rs:29\n"
+"b src/bin/board_support.rs:30\n"
+"b src/bin/board_support.rs:32\n"
+"c\n"
+"c\n"
+"c\n"
+"```"
+msgstr ""
+
+#: src/bare-metal/microcontrollers/other-projects.md:1
+#: src/bare-metal/aps/other-projects.md:1
+msgid "# Other projects"
+msgstr ""
+
+#: src/bare-metal/microcontrollers/other-projects.md:3
+msgid ""
+" * [RTIC](https://rtic.rs/)\n"
+" * \"Real-Time Interrupt-driven Concurrency\"\n"
+" * Shared resource management, message passing, task scheduling, timer queue\n"
+" * [Embassy](https://embassy.dev/)\n"
+" * `async` executors with priorities, timers, networking, USB\n"
+" * [TockOS](https://www.tockos.org/documentation/getting-started)\n"
+" * Security-focused RTOS with preemptive scheduling and Memory Protection Unit support\n"
+" * [Hubris](https://hubris.oxide.computer/)\n"
+" * Microkernel RTOS from Oxide Computer Company with memory protection, unprivileged drivers, IPC\n"
+" * [Bindings for FreeRTOS](https://github.com/lobaro/FreeRTOS-rust)\n"
+" * Some platforms have `std` implementations, e.g.\n"
+" [esp-idf](https://esp-rs.github.io/book/overview/using-the-standard-library.html)."
+msgstr ""
+
+#: src/bare-metal/microcontrollers/other-projects.md:18
+msgid ""
+" * RTIC can be considered either an RTOS or a concurrency framework.\n"
+" * It doesn't include any HALs.\n"
+" * It uses the Cortex-M NVIC (Nested Virtual Interrupt Controller) for scheduling rather than a\n"
+" proper kernel.\n"
+" * Cortex-M only.\n"
+" * Google uses TockOS on the Haven microcontroller for Titan security keys.\n"
+" * FreeRTOS is mostly written in C, but there are Rust bindings for writing applications."
+msgstr ""
+
+#: src/exercises/bare-metal/morning.md:3
+msgid "We will read the direction from an I2C compass, and log the readings to a serial port."
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:1
+#, fuzzy
+msgid "# Compass"
+msgstr "# Comparação"
+
+#: src/exercises/bare-metal/compass.md:3
+msgid ""
+"We will read the direction from an I2C compass, and log the readings to a serial port. If you have\n"
+"time, try displaying it on the LEDs somehow too, or use the buttons somehow."
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:6
+msgid "Hints:"
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:8
+msgid ""
+"- Check the documentation for the [`lsm303agr`](https://docs.rs/lsm303agr/latest/lsm303agr/) and\n"
+" [`microbit-v2`](https://docs.rs/microbit-v2/latest/microbit/) crates, as well as the\n"
+" [micro:bit hardware](https://tech.microbit.org/hardware/).\n"
+"- The LSM303AGR Inertial Measurement Unit is connected to the internal I2C bus.\n"
+"- TWI is another name for I2C, so the I2C master peripheral is called TWIM.\n"
+"- The LSM303AGR driver needs something implementing the `embedded_hal::blocking::i2c::WriteRead`\n"
+" trait. The\n"
+" [`microbit::hal::Twim`](https://docs.rs/microbit-v2/latest/microbit/hal/struct.Twim.html) struct\n"
+" implements this.\n"
+"- You have a [`microbit::Board`](https://docs.rs/microbit-v2/latest/microbit/struct.Board.html)\n"
+" struct with fields for the various pins and peripherals.\n"
+"- You can also look at the\n"
+" [nRF52833 datasheet](https://infocenter.nordicsemi.com/pdf/nRF52833_PS_v1.5.pdf) if you want, but\n"
+" it shouldn't be necessary for this exercise."
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:23
+msgid ""
+"Download the [exercise template](../../comprehensive-rust-exercises.zip) and look in the `compass`\n"
+"directory for the following files."
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:26 src/exercises/bare-metal/rtc.md:19
+#, fuzzy
+msgid "`src/main.rs`:"
+msgstr "_hello_rust/src/main.rs_:"
+
+#: src/exercises/bare-metal/compass.md:28 src/exercises/bare-metal/rtc.md:21
+#: src/exercises/concurrency/dining-philosophers.md:17
+#: src/exercises/concurrency/link-checker.md:55
+#: src/exercises/concurrency/dining-philosophers-async.md:11
+msgid ""
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:30
+msgid ""
+"```rust,compile_fail\n"
+"#![no_main]\n"
+"#![no_std]\n"
+"\n"
+"extern crate panic_halt as _;\n"
+"\n"
+"use core::fmt::Write;\n"
+"use cortex_m_rt::entry;\n"
+"use microbit::{hal::uarte::{Baudrate, Parity, Uarte}, Board};\n"
+"\n"
+"#[entry]\n"
+"fn main() -> ! {\n"
+" let board = Board::take().unwrap();\n"
+"\n"
+" // Configure serial port.\n"
+" let mut serial = Uarte::new(\n"
+" board.UARTE0,\n"
+" board.uart.into(),\n"
+" Parity::EXCLUDED,\n"
+" Baudrate::BAUD115200,\n"
+" );\n"
+"\n"
+" // Set up the I2C controller and Inertial Measurement Unit.\n"
+" // TODO\n"
+"\n"
+" writeln!(serial, \"Ready.\").unwrap();\n"
+"\n"
+" loop {\n"
+" // Read compass data and log it to the serial port.\n"
+" // TODO\n"
+" }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:64 src/exercises/bare-metal/rtc.md:385
+msgid "`Cargo.toml` (you shouldn't need to change this):"
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:66 src/exercises/bare-metal/rtc.md:387
+#: src/exercises/concurrency/dining-philosophers.md:63
+#: src/exercises/concurrency/link-checker.md:35
+#: src/exercises/concurrency/dining-philosophers-async.md:60
+#: src/exercises/concurrency/chat-app.md:17
+msgid ""
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:68
+msgid ""
+"```toml\n"
+"[workspace]\n"
+"\n"
+"[package]\n"
+"name = \"compass\"\n"
+"version = \"0.1.0\"\n"
+"edition = \"2021\"\n"
+"publish = false\n"
+"\n"
+"[dependencies]\n"
+"cortex-m-rt = \"0.7.3\"\n"
+"embedded-hal = \"0.2.6\"\n"
+"lsm303agr = \"0.2.2\"\n"
+"microbit-v2 = \"0.13.0\"\n"
+"panic-halt = \"0.2.0\"\n"
+"```"
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:85
+msgid "`Embed.toml` (you shouldn't need to change this):"
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:87
+msgid ""
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:89
+msgid ""
+"```toml\n"
+"[default.general]\n"
+"chip = \"nrf52833_xxAA\"\n"
+"\n"
+"[debug.gdb]\n"
+"enabled = true\n"
+"\n"
+"[debug.reset]\n"
+"halt_afterwards = true\n"
+"```"
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:100 src/exercises/bare-metal/rtc.md:985
+msgid "`.cargo/config.toml` (you shouldn't need to change this):"
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:102 src/exercises/bare-metal/rtc.md:987
+msgid ""
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:104
+msgid ""
+"```toml\n"
+"[build]\n"
+"target = \"thumbv7em-none-eabihf\" # Cortex-M4F\n"
+"\n"
+"[target.'cfg(all(target_arch = \"arm\", target_os = \"none\"))']\n"
+"rustflags = [\"-C\", \"link-arg=-Tlink.x\"]\n"
+"```"
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:112
+msgid "See the serial output on Linux with:"
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:114
+msgid ""
+"```sh\n"
+"picocom --baud 115200 --imap lfcrlf /dev/ttyACM0\n"
+"```"
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:118
+msgid "Or on Mac OS something like (the device name may be slightly different):"
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:120
+msgid ""
+"```sh\n"
+"picocom --baud 115200 --imap lfcrlf /dev/tty.usbmodem14502\n"
+"```"
+msgstr ""
+
+#: src/exercises/bare-metal/compass.md:124
+msgid "Use Ctrl+A Ctrl+Q to quit picocom."
+msgstr ""
+
+#: src/bare-metal/aps.md:1
+msgid "# Application processors"
+msgstr ""
+
+#: src/bare-metal/aps.md:3
+msgid ""
+"So far we've talked about microcontrollers, such as the Arm Cortex-M series. Now let's try writing\n"
+"something for Cortex-A. For simplicity we'll just work with QEMU's aarch64\n"
+"['virt'](https://qemu-project.gitlab.io/qemu/system/arm/virt.html) board."
+msgstr ""
+
+#: src/bare-metal/aps.md:9
+msgid ""
+"* Broadly speaking, microcontrollers don't have an MMU or multiple levels of privilege (exception\n"
+" levels on Arm CPUs, rings on x86), while application processors do.\n"
+"* QEMU supports emulating various different machines or board models for each architecture. The\n"
+" 'virt' board doesn't correspond to any particular real hardware, but is designed purely for\n"
+" virtual machines."
+msgstr ""
+
+#: src/bare-metal/aps/inline-assembly.md:1
+msgid "# Inline assembly"
+msgstr ""
+
+#: src/bare-metal/aps/inline-assembly.md:3
+msgid ""
+"Sometimes we need to use assembly to do things that aren't possible with Rust code. For example,\n"
+"to make an HVC to tell the firmware to power off the system:"
+msgstr ""
+
+#: src/bare-metal/aps/inline-assembly.md:6
+msgid ""
+"```rust,editable,compile_fail\n"
+"#![no_main]\n"
+"#![no_std]\n"
+"\n"
+"use core::arch::asm;\n"
+"use core::panic::PanicInfo;\n"
+"\n"
+"mod exceptions;\n"
+"\n"
+"const PSCI_SYSTEM_OFF: u32 = 0x84000008;\n"
+"\n"
+"#[no_mangle]\n"
+"extern \"C\" fn main(_x0: u64, _x1: u64, _x2: u64, _x3: u64) {\n"
+" // Safe because this only uses the declared registers and doesn't do\n"
+" // anything with memory.\n"
+" unsafe {\n"
+" asm!(\"hvc #0\",\n"
+" inout(\"w0\") PSCI_SYSTEM_OFF => _,\n"
+" inout(\"w1\") 0 => _,\n"
+" inout(\"w2\") 0 => _,\n"
+" inout(\"w3\") 0 => _,\n"
+" inout(\"w4\") 0 => _,\n"
+" inout(\"w5\") 0 => _,\n"
+" inout(\"w6\") 0 => _,\n"
+" inout(\"w7\") 0 => _,\n"
+" options(nomem, nostack)\n"
+" );\n"
+" }\n"
+"\n"
+" loop {}\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/bare-metal/aps/inline-assembly.md:39
+msgid "(If you actually want to do this, use the [`smccc`][1] crate which has wrappers for all these functions.)"
+msgstr ""
+
+#: src/bare-metal/aps/inline-assembly.md:43
+msgid ""
+"* PSCI is the Arm Power State Coordination Interface, a standard set of functions to manage system\n"
+" and CPU power states, among other things. It is implemented by EL3 firmware and hypervisors on\n"
+" many systems.\n"
+"* The `0 => _` syntax means initialise the register to 0 before running the inline assembly code,\n"
+" and ignore its contents afterwards. We need to use `inout` rather than `in` because the call could\n"
+" potentially clobber the contents of the registers.\n"
+"* This `main` function needs to be `#[no_mangle]` and `extern \"C\"` because it is called from our\n"
+" entry point in `entry.S`.\n"
+"* `_x0`–`_x3` are the values of registers `x0`–`x3`, which are conventionally used by the bootloader\n"
+" to pass things like a pointer to the device tree. According to the standard aarch64 calling\n"
+" convention (which is what `extern \"C\"` specifies to use), registers `x0`–`x7` are used for the\n"
+" first 8 arguments passed to a function, so `entry.S` doesn't need to do anything special except\n"
+" make sure it doesn't change these registers.\n"
+"* Run the example in QEMU with `make qemu_psci` under `src/bare-metal/aps/examples`."
+msgstr ""
+
+#: src/bare-metal/aps/mmio.md:1
+msgid "# Volatile memory access for MMIO"
+msgstr ""
+
+#: src/bare-metal/aps/mmio.md:3
+msgid ""
+" * Use `pointer::read_volatile` and `pointer::write_volatile`.\n"
+" * Never hold a reference.\n"
+" * `addr_of!` lets you get fields of structs without creating an intermediate reference."
+msgstr ""
+
+#: src/bare-metal/aps/mmio.md:9
+msgid ""
+" * Volatile access: read or write operations may have side-effects, so prevent the compiler or\n"
+" hardware from reordering, duplicating or eliding them.\n"
+" * Usually if you write and then read, e.g. via a mutable reference, the compiler may assume that\n"
+" the value read is the same as the value just written, and not bother actually reading memory.\n"
+" * Some existing crates for volatile access to hardware do hold references, but this is unsound.\n"
+" Whenever a reference exist, the compiler may choose to dereference it.\n"
+" * Use the `addr_of!` macro to get struct field pointers from a pointer to the struct."
+msgstr ""
+
+#: src/bare-metal/aps/uart.md:1
+msgid "# Let's write a UART driver"
+msgstr ""
+
+#: src/bare-metal/aps/uart.md:3
+msgid "The QEMU 'virt' machine has a [PL011][1] UART, so let's write a driver for that."
+msgstr ""
+
+#: src/bare-metal/aps/uart.md:5
+msgid ""
+"```rust,editable\n"
+"const FLAG_REGISTER_OFFSET: usize = 0x18;\n"
+"const FR_BUSY: u8 = 1 << 3;\n"
+"const FR_TXFF: u8 = 1 << 5;\n"
+"\n"
+"/// Minimal driver for a PL011 UART.\n"
+"#[derive(Debug)]\n"
+"pub struct Uart {\n"
+" base_address: *mut u8,\n"
+"}\n"
+"\n"
+"impl Uart {\n"
+" /// Constructs a new instance of the UART driver for a PL011 device at the\n"
+" /// given base address.\n"
+" ///\n"
+" /// # Safety\n"
+" ///\n"
+" /// The given base address must point to the 8 MMIO control registers of a\n"
+" /// PL011 device, which must be mapped into the address space of the process\n"
+" /// as device memory and not have any other aliases.\n"
+" pub unsafe fn new(base_address: *mut u8) -> Self {\n"
+" Self { base_address }\n"
+" }\n"
+"\n"
+" /// Writes a single byte to the UART.\n"
+" pub fn write_byte(&self, byte: u8) {\n"
+" // Wait until there is room in the TX buffer.\n"
+" while self.read_flag_register() & FR_TXFF != 0 {}\n"
+"\n"
+" // Safe because we know that the base address points to the control\n"
+" // registers of a PL011 device which is appropriately mapped.\n"
+" unsafe {\n"
+" // Write to the TX buffer.\n"
+" self.base_address.write_volatile(byte);\n"
+" }\n"
+"\n"
+" // Wait until the UART is no longer busy.\n"
+" while self.read_flag_register() & FR_BUSY != 0 {}\n"
+" }\n"
+"\n"
+" fn read_flag_register(&self) -> u8 {\n"
+" // Safe because we know that the base address points to the control\n"
+" // registers of a PL011 device which is appropriately mapped.\n"
+" unsafe { self.base_address.add(FLAG_REGISTER_OFFSET).read_volatile() }\n"
+" }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/bare-metal/aps/uart.md:55
+msgid ""
+"* Note that `Uart::new` is unsafe while the other methods are safe. This is because as long as the\n"
+" caller of `Uart::new` guarantees that its safety requirements are met (i.e. that there is only\n"
+" ever one instance of the driver for a given UART, and nothing else aliasing its address space),\n"
+" then it is always safe to call `write_byte` later because we can assume the necessary\n"
+" preconditions.\n"
+"* We could have done it the other way around (making `new` safe but `write_byte` unsafe), but that\n"
+" would be much less convenient to use as every place that calls `write_byte` would need to reason\n"
+" about the safety\n"
+"* This is a common pattern for writing safe wrappers of unsafe code: moving the burden of proof for\n"
+" soundness from a large number of places to a smaller number of places."
+msgstr ""
+
+#: src/bare-metal/aps/uart.md:66
+#, fuzzy
+msgid ""
+msgstr "
"
+
+#: src/bare-metal/aps/uart/traits.md:1
+#, fuzzy
+msgid "# More traits"
+msgstr "# Traits (Características)"
+
+#: src/bare-metal/aps/uart/traits.md:3
+msgid "We derived the `Debug` trait. It would be useful to implement a few more traits too."
+msgstr ""
+
+#: src/bare-metal/aps/uart/traits.md:5
+msgid ""
+"```rust,editable,compile_fail\n"
+"use core::fmt::{self, Write};\n"
+"\n"
+"impl Write for Uart {\n"
+" fn write_str(&mut self, s: &str) -> fmt::Result {\n"
+" for c in s.as_bytes() {\n"
+" self.write_byte(*c);\n"
+" }\n"
+" Ok(())\n"
+" }\n"
+"}\n"
+"\n"
+"// Safe because it just contains a pointer to device memory, which can be\n"
+"// accessed from any context.\n"
+"unsafe impl Send for Uart {}\n"
+"```"
+msgstr ""
+
+#: src/bare-metal/aps/uart/traits.md:24
+msgid ""
+"* Implementing `Write` lets us use the `write!` and `writeln!` macros with our `Uart` type.\n"
+"* Run the example in QEMU with `make qemu_minimal` under `src/bare-metal/aps/examples`."
+msgstr ""
+
+#: src/bare-metal/aps/better-uart.md:1
+msgid "# A better UART driver"
+msgstr ""
+
+#: src/bare-metal/aps/better-uart.md:3
+msgid ""
+"The PL011 actually has [a bunch more registers][1], and adding offsets to construct pointers to access\n"
+"them is error-prone and hard to read. Plus, some of them are bit fields which would be nice to\n"
+"access in a structured way."
+msgstr ""
+
+#: src/bare-metal/aps/better-uart.md:7
+msgid ""
+"| Offset | Register name | Width |\n"
+"| ------ | ------------- | ----- |\n"
+"| 0x00 | DR | 12 |\n"
+"| 0x04 | RSR | 4 |\n"
+"| 0x18 | FR | 9 |\n"
+"| 0x20 | ILPR | 8 |\n"
+"| 0x24 | IBRD | 16 |\n"
+"| 0x28 | FBRD | 6 |\n"
+"| 0x2c | LCR_H | 8 |\n"
+"| 0x30 | CR | 16 |\n"
+"| 0x34 | IFLS | 6 |\n"
+"| 0x38 | IMSC | 11 |\n"
+"| 0x3c | RIS | 11 |\n"
+"| 0x40 | MIS | 11 |\n"
+"| 0x44 | ICR | 11 |\n"
+"| 0x48 | DMACR | 3 |"
+msgstr ""
+
+#: src/bare-metal/aps/better-uart.md:26
+msgid "- There are also some ID registers which have been omitted for brevity."
+msgstr ""
+
+#: src/bare-metal/aps/better-uart/bitflags.md:1
+msgid "# Bitflags"
+msgstr ""
+
+#: src/bare-metal/aps/better-uart/bitflags.md:3
+msgid "The [`bitflags`](https://crates.io/crates/bitflags) crate is useful for working with bitflags."
+msgstr ""
+
+#: src/bare-metal/aps/better-uart/bitflags.md:5
+msgid ""
+"```rust,editable,compile_fail\n"
+"use bitflags::bitflags;\n"
+"\n"
+"bitflags! {\n"
+" /// Flags from the UART flag register.\n"
+" #[repr(transparent)]\n"
+" #[derive(Copy, Clone, Debug, Eq, PartialEq)]\n"
+" struct Flags: u16 {\n"
+" /// Clear to send.\n"
+" const CTS = 1 << 0;\n"
+" /// Data set ready.\n"
+" const DSR = 1 << 1;\n"
+" /// Data carrier detect.\n"
+" const DCD = 1 << 2;\n"
+" /// UART busy transmitting data.\n"
+" const BUSY = 1 << 3;\n"
+" /// Receive FIFO is empty.\n"
+" const RXFE = 1 << 4;\n"
+" /// Transmit FIFO is full.\n"
+" const TXFF = 1 << 5;\n"
+" /// Receive FIFO is full.\n"
+" const RXFF = 1 << 6;\n"
+" /// Transmit FIFO is empty.\n"
+" const TXFE = 1 << 7;\n"
+" /// Ring indicator.\n"
+" const RI = 1 << 8;\n"
+" }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/bare-metal/aps/better-uart/bitflags.md:37
+msgid ""
+"* The `bitflags!` macro creates a newtype something like `Flags(u16)`, along with a bunch of method\n"
+" implementations to get and set flags."
+msgstr ""
+
+#: src/bare-metal/aps/better-uart/registers.md:1
+msgid "# Multiple registers"
+msgstr ""
+
+#: src/bare-metal/aps/better-uart/registers.md:3
+msgid "We can use a struct to represent the memory layout of the UART's registers."
+msgstr ""
+
+#: src/bare-metal/aps/better-uart/registers.md:5
+msgid ""
+"```rust,editable,compile_fail\n"
+"#[repr(C, align(4))]\n"
+"struct Registers {\n"
+" dr: u16,\n"
+" _reserved0: [u8; 2],\n"
+" rsr: ReceiveStatus,\n"
+" _reserved1: [u8; 19],\n"
+" fr: Flags,\n"
+" _reserved2: [u8; 6],\n"
+" ilpr: u8,\n"
+" _reserved3: [u8; 3],\n"
+" ibrd: u16,\n"
+" _reserved4: [u8; 2],\n"
+" fbrd: u8,\n"
+" _reserved5: [u8; 3],\n"
+" lcr_h: u8,\n"
+" _reserved6: [u8; 3],\n"
+" cr: u16,\n"
+" _reserved7: [u8; 3],\n"
+" ifls: u8,\n"
+" _reserved8: [u8; 3],\n"
+" imsc: u16,\n"
+" _reserved9: [u8; 2],\n"
+" ris: u16,\n"
+" _reserved10: [u8; 2],\n"
+" mis: u16,\n"
+" _reserved11: [u8; 2],\n"
+" icr: u16,\n"
+" _reserved12: [u8; 2],\n"
+" dmacr: u8,\n"
+" _reserved13: [u8; 3],\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/bare-metal/aps/better-uart/registers.md:41
+msgid ""
+"* [`#[repr(C)]`](https://doc.rust-lang.org/reference/type-layout.html#the-c-representation) tells\n"
+" the compiler to lay the struct fields out in order, following the same rules as C. This is\n"
+" necessary for our struct to have a predictable layout, as default Rust representation allows the\n"
+" compiler to (among other things) reorder fields however it sees fit."
+msgstr ""
+
+#: src/bare-metal/aps/better-uart/driver.md:1
+msgid "# Driver"
+msgstr ""
+
+#: src/bare-metal/aps/better-uart/driver.md:3
+msgid "Now let's use the new `Registers` struct in our driver."
+msgstr ""
+
+#: src/bare-metal/aps/better-uart/driver.md:5
+msgid ""
+"```rust,editable,compile_fail\n"
+"/// Driver for a PL011 UART.\n"
+"#[derive(Debug)]\n"
+"pub struct Uart {\n"
+" registers: *mut Registers,\n"
+"}\n"
+"\n"
+"impl Uart {\n"
+" /// Constructs a new instance of the UART driver for a PL011 device at the\n"
+" /// given base address.\n"
+" ///\n"
+" /// # Safety\n"
+" ///\n"
+" /// The given base address must point to the 8 MMIO control registers of a\n"
+" /// PL011 device, which must be mapped into the address space of the process\n"
+" /// as device memory and not have any other aliases.\n"
+" pub unsafe fn new(base_address: *mut u32) -> Self {\n"
+" Self {\n"
+" registers: base_address as *mut Registers,\n"
+" }\n"
+" }\n"
+"\n"
+" /// Writes a single byte to the UART.\n"
+" pub fn write_byte(&self, byte: u8) {\n"
+" // Wait until there is room in the TX buffer.\n"
+" while self.read_flag_register().contains(Flags::TXFF) {}\n"
+"\n"
+" // Safe because we know that self.registers points to the control\n"
+" // registers of a PL011 device which is appropriately mapped.\n"
+" unsafe {\n"
+" // Write to the TX buffer.\n"
+" addr_of_mut!((*self.registers).dr).write_volatile(byte.into());\n"
+" }\n"
+"\n"
+" // Wait until the UART is no longer busy.\n"
+" while self.read_flag_register().contains(Flags::BUSY) {}\n"
+" }\n"
+"\n"
+" /// Reads and returns a pending byte, or `None` if nothing has been received.\n"
+" pub fn read_byte(&self) -> Option\n"
+" \n"
+"* A razão para isso é que, quando a função `thread::scope` for concluída, todas as _threads_ serão unidas, para que possam retornar dados emprestados.\n"
+"* Aplicam-se as regras normais de empréstimo do Rust: o empréstimo pode ser mutável, para uma `thread` ou imutável para\n"
+"qualquer número de _threads_.\n"
+" \n"
+"
"
+
+#: src/concurrency/channels.md:1
+msgid "# Channels"
+msgstr "# Channels (Canais)"
+
+#: src/concurrency/channels.md:3
+msgid ""
+"Rust channels have two parts: a `Sender\n"
+" \n"
+"* `Mutex` em Rust parece uma coleção com apenas um elemento - os dados protegidos.\n"
+" * Não é possível esquecer de adquirir o mutex antes de acessar os dados protegidos.\n"
+"* Você pode obter um `&mut T` de um `&Mutex` obtendo um bloqueio (_lock_). O `MutexGuard` garante que o\n"
+" `&mut T` não sobrevive além do bloqueio (_lock_).\n"
+"* `Mutex` implementa `Send` e `Sync` se `T` implementa `Send`.\n"
+"* O bloqueio para leitura e gravação - `RwLock`.\n"
+"* Por que `lock()` retorna um `Result`?\n"
+" * Se o thread que manteve o `Mutex` entrou em pânico, o `Mutex` torna-se \"envenenado\" para sinalizar que\n"
+" os dados protegidos podem estar em um estado inconsistente. Ao chamar `lock()` em um mutex envenenado\n"
+" o retorno é uma falha com um [`PoisonError`]. Você pode chamar `into_inner()` no erro para recuperar os dados\n"
+" independentemente."
+
+#: src/concurrency/shared_state/example.md:3
+msgid "Let us see `Arc` and `Mutex` in action:"
+msgstr "Vamos ver `Arc` e `Mutex` em ação:"
+
+#: src/concurrency/shared_state/example.md:5
+#, fuzzy
+msgid ""
+"```rust,editable,compile_fail\n"
+"use std::thread;\n"
+"// use std::sync::{Arc, Mutex};\n"
+"\n"
+"fn main() {\n"
+" let v = vec![10, 20, 30];\n"
+" let handle = thread::spawn(|| {\n"
+" v.push(10);\n"
+" });\n"
+" v.push(1000);\n"
+"\n"
+" handle.join().unwrap();\n"
+" println!(\"v: {v:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+"fn main() {\n"
+" let mut v = vec![10, 20, 30];\n"
+" let handle = thread::spawn(|| {\n"
+" v.push(10);\n"
+" });\n"
+" v.push(1000);"
+
+#: src/concurrency/shared_state/example.md:23
+msgid "Possible solution:"
+msgstr ""
+
+#: src/concurrency/shared_state/example.md:25
+msgid ""
+"```rust,editable\n"
+"use std::sync::{Arc, Mutex};\n"
+"use std::thread;\n"
+"\n"
+"fn main() {\n"
+" let v = Arc::new(Mutex::new(vec![10, 20, 30]));\n"
+"\n"
+" let v2 = Arc::clone(&v);\n"
+" let handle = thread::spawn(move || {\n"
+" let mut v2 = v2.lock().unwrap();\n"
+" v2.push(10);\n"
+" });\n"
+"\n"
+" {\n"
+" let mut v = v.lock().unwrap();\n"
+" v.push(1000);\n"
+" }\n"
+"\n"
+" handle.join().unwrap();\n"
+"\n"
+" println!(\"v: {v:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/concurrency/shared_state/example.md:49
+msgid "Notable parts:"
+msgstr ""
+
+#: src/concurrency/shared_state/example.md:51
+#, fuzzy
+msgid ""
+"* `v` is wrapped in both `Arc` and `Mutex`, because their concerns are orthogonal.\n"
+" * Wrapping a `Mutex` in an `Arc` is a common pattern to share mutable state between threads.\n"
+"* `v: Arc<_>` needs to be cloned as `v2` before it can be moved into another thread. Note `move` was added to the lambda signature.\n"
+"* Blocks are introduced to narrow the scope of the `LockGuard` as much as possible."
+msgstr ""
+"* `v` é agrupado em ambos `Arc` e `Mutex`, porque seus interesses são ortogonais.\n"
+" * Envolver um `Mutex` em um `Arc` é um padrão comum para compartilhar o estado mutável entre threads.\n"
+"* `v: Arc<_>` precisa ser clonado como `v2` antes que possa ser movido para outro thread. Note que `move` foi adicionado à assinatura lambda.\n"
+"* Os blocos são introduzidos para restringir o escopo do `LockGuard` tanto quanto possível.\n"
+"* Ainda precisamos adquirir o `Mutex` para imprimir nosso `Vec`."
+
+#: src/exercises/concurrency/morning.md:3
+msgid "Let us practice our new concurrency skills with"
+msgstr "Vamos praticar nossas novas habilidades de concorrência com:"
+
+#: src/exercises/concurrency/morning.md:5
+#, fuzzy
+msgid ""
+"* Dining philosophers: a classic problem in concurrency.\n"
+"\n"
+"* Multi-threaded link checker: a larger project where you'll use Cargo to\n"
+" download dependencies and then check links in parallel."
+msgstr ""
+"* Verificador de link _multi-threads_: um projeto maior no qual você usará o Cargo para\n"
+" baixar as dependências e também verificar os links em paralelo."
+
+#: src/exercises/concurrency/dining-philosophers.md:1
+msgid "# Dining Philosophers"
+msgstr "# Filósofos jantando"
+
+#: src/exercises/concurrency/dining-philosophers.md:3
+msgid "The dining philosophers problem is a classic problem in concurrency:"
+msgstr "O problema dos filósofos jantando é um problema clássico em concorrência:"
+
+#: src/exercises/concurrency/dining-philosophers.md:5
+msgid ""
+"> Five philosophers dine together at the same table. Each philosopher has their\n"
+"> own place at the table. There is a fork between each plate. The dish served is\n"
+"> a kind of spaghetti which has to be eaten with two forks. Each philosopher can\n"
+"> only alternately think and eat. Moreover, a philosopher can only eat their\n"
+"> spaghetti when they have both a left and right fork. Thus two forks will only\n"
+"> be available when their two nearest neighbors are thinking, not eating. After\n"
+"> an individual philosopher finishes eating, they will put down both forks."
+msgstr ""
+"> Cinco filósofos jantam juntos na mesma mesa. Cada folósofo tem seu\n"
+"> próprio lugar à mesa. Há um garfo entre cada prato. O prato servido é\n"
+"> uma espécie de espaguete que se come com dois garfos. Cada filósofo pode\n"
+"> somente pensar ou comer, alternadamente. Além disso, um filósofo só pode comer seu\n"
+"> espaguete quando ele têm garfo esquerdo e direito. Assim, dois garfos só\n"
+"> estarão disponíveis quando seus dois vizinhos mais próximos estiverem pensando, não comendo. Depois de\n"
+"> um filósofo individual termina de comer, ele abaixa os dois garfos."
+
+#: src/exercises/concurrency/dining-philosophers.md:13
+#, fuzzy
+msgid ""
+"You will need a local [Cargo installation](../../cargo/running-locally.md) for\n"
+"this exercise. Copy the code below to a file called `src/main.rs`, fill out the\n"
+"blanks, and test that `cargo run` does not deadlock:"
+msgstr ""
+"Você precisará de uma [instalação do Cargo][../../cargo/running-locally.md] local para\n"
+"esse exercício. Copie o código abaixo para o arquivo `src/main.rs`, preencha os espaços em branco,\n"
+"e teste se `cargo run` não trava:"
+
+#: src/exercises/concurrency/dining-philosophers.md:19
+msgid ""
+"```rust,compile_fail\n"
+"use std::sync::{mpsc, Arc, Mutex};\n"
+"use std::thread;\n"
+"use std::time::Duration;\n"
+"\n"
+"struct Fork;\n"
+"\n"
+"struct Philosopher {\n"
+" name: String,\n"
+" // left_fork: ...\n"
+" // right_fork: ...\n"
+" // thoughts: ...\n"
+"}\n"
+"\n"
+"impl Philosopher {\n"
+" fn think(&self) {\n"
+" self.thoughts\n"
+" .send(format!(\"Eureka! {} has a new idea!\", &self.name))\n"
+" .unwrap();\n"
+" }\n"
+"\n"
+" fn eat(&self) {\n"
+" // Pick up forks...\n"
+" println!(\"{} is eating...\", &self.name);\n"
+" thread::sleep(Duration::from_millis(10));\n"
+" }\n"
+"}\n"
+"\n"
+"static PHILOSOPHERS: &[&str] =\n"
+" &[\"Socrates\", \"Plato\", \"Aristotle\", \"Thales\", \"Pythagoras\"];\n"
+"\n"
+"fn main() {\n"
+" // Create forks\n"
+"\n"
+" // Create philosophers\n"
+"\n"
+" // Make them think and eat\n"
+"\n"
+" // Output their thoughts\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/concurrency/dining-philosophers.md:61
+msgid "You can use the following `Cargo.toml`:"
+msgstr ""
+
+#: src/exercises/concurrency/dining-philosophers.md:65
+msgid ""
+"```toml\n"
+"[package]\n"
+"name = \"dining-philosophers\"\n"
+"version = \"0.1.0\"\n"
+"edition = \"2021\"\n"
+"```"
+msgstr ""
+
+#: src/exercises/concurrency/link-checker.md:1
+msgid "# Multi-threaded Link Checker"
+msgstr "# Verificador de links _multi-threads_"
+
+#: src/exercises/concurrency/link-checker.md:3
+msgid ""
+"Let us use our new knowledge to create a multi-threaded link checker. It should\n"
+"start at a webpage and check that links on the page are valid. It should\n"
+"recursively check other pages on the same domain and keep doing this until all\n"
+"pages have been validated."
+msgstr ""
+"Vamos usar nosso novo conhecimento para criar um verificador de links _multi-threads_. \n"
+"Comece em uma página da web e verifique se os links na página são válidos. \n"
+"Verifique recursivamente outras páginas no mesmo domínio e continue fazendo isso até que todas\n"
+"as páginas tenham sido validadas."
+
+#: src/exercises/concurrency/link-checker.md:8
+msgid ""
+"For this, you will need an HTTP client such as [`reqwest`][1]. Create a new\n"
+"Cargo project and `reqwest` it as a dependency with:"
+msgstr ""
+"Para isso, você precisará de um cliente HTTP como [`reqwest`][1]. Crie um novo\n"
+"Project com o Cargo e adicione `reqwest` como uma dependência:"
+
+#: src/exercises/concurrency/link-checker.md:11
+msgid ""
+"```shell\n"
+"$ cargo new link-checker\n"
+"$ cd link-checker\n"
+"$ cargo add --features blocking,rustls-tls reqwest\n"
+"```"
+msgstr ""
+"```shell\n"
+"$ cargo new link-checker\n"
+"$ cd link-checker\n"
+"$ cargo add --features blocking,rustls-tls reqwest\n"
+"```"
+
+#: src/exercises/concurrency/link-checker.md:17
+msgid ""
+"> If `cargo add` fails with `error: no such subcommand`, then please edit the\n"
+"> `Cargo.toml` file by hand. Add the dependencies listed below."
+msgstr ""
+"> Se `cargo add` falhar com `error: no such subcommand`, edite o\n"
+"> arquivo `Cargo.toml` à mão. Adicione as dependências listadas abaixo."
+
+#: src/exercises/concurrency/link-checker.md:20
+msgid "You will also need a way to find links. We can use [`scraper`][2] for that:"
+msgstr "Você também precisará de uma maneira de encontrar links. Podemos usar [`scraper`][2] para isso:"
+
+#: src/exercises/concurrency/link-checker.md:22
+msgid ""
+"```shell\n"
+"$ cargo add scraper\n"
+"```"
+msgstr ""
+"```shell\n"
+"$ cargo add scraper\n"
+"```"
+
+#: src/exercises/concurrency/link-checker.md:26
+msgid ""
+"Finally, we'll need some way of handling errors. We use [`thiserror`][3] for\n"
+"that:"
+msgstr ""
+"Por fim, precisaremos de alguma forma de lidar com os erros. Usamos [`thiserror`][3] para\n"
+"isso:"
+
+#: src/exercises/concurrency/link-checker.md:29
+msgid ""
+"```shell\n"
+"$ cargo add thiserror\n"
+"```"
+msgstr ""
+"```shell\n"
+"$ cargo add thiserror\n"
+"```"
+
+#: src/exercises/concurrency/link-checker.md:33
+msgid "The `cargo add` calls will update the `Cargo.toml` file to look like this:"
+msgstr "As chamadas `cargo add` irão atualizar o arquivo `Cargo.toml` para ficar assim:"
+
+#: src/exercises/concurrency/link-checker.md:37
+#, fuzzy
+msgid ""
+"```toml\n"
+"[package]\n"
+"name = \"link-checker\"\n"
+"version = \"0.1.0\"\n"
+"edition = \"2021\"\n"
+"publish = false\n"
+"\n"
+"[dependencies]\n"
+"reqwest = { version = \"0.11.12\", features = [\"blocking\", \"rustls-tls\"] }\n"
+"scraper = \"0.13.0\"\n"
+"thiserror = \"1.0.37\"\n"
+"```"
+msgstr ""
+"```toml\n"
+"[dependências]\n"
+"reqwest = { version = \"0.11.12\", features = [\"blocking\", \"rustls-tls\"] }\n"
+"scraper = \"0.13.0\"\n"
+"thiserror = \"1.0.37\"\n"
+"```"
+
+#: src/exercises/concurrency/link-checker.md:50
+msgid ""
+"You can now download the start page. Try with a small site such as\n"
+"`https://www.google.org/`."
+msgstr ""
+"Agora você pode baixar a página inicial. Tente com um pequeno site como\n"
+"`https://www.google.org/`."
+
+#: src/exercises/concurrency/link-checker.md:53
+msgid "Your `src/main.rs` file should look something like this:"
+msgstr "Seu arquivo `src/main.rs` deve se parecer com isto:"
+
+#: src/exercises/concurrency/link-checker.md:57
+msgid ""
+"```rust,compile_fail\n"
+"use reqwest::blocking::{get, Response};\n"
+"use reqwest::Url;\n"
+"use scraper::{Html, Selector};\n"
+"use thiserror::Error;\n"
+"\n"
+"#[derive(Error, Debug)]\n"
+"enum Error {\n"
+" #[error(\"request error: {0}\")]\n"
+" ReqwestError(#[from] reqwest::Error),\n"
+"}\n"
+"\n"
+"fn extract_links(response: Response) -> Result, Error> {\n"
+" let base_url = response.url().to_owned();\n"
+" let document = response.text()?;\n"
+" let html = Html::parse_document(&document);\n"
+" let selector = Selector::parse(\"a\").unwrap();\n"
+"\n"
+" let mut valid_urls = Vec::new();\n"
+" for element in html.select(&selector) {\n"
+" if let Some(href) = element.value().attr(\"href\") {\n"
+" match base_url.join(href) {\n"
+" Ok(url) => valid_urls.push(url),\n"
+" Err(err) => {\n"
+" println!(\"On {base_url}: could not parse {href:?}: {err} (ignored)\",);\n"
+" }\n"
+" }\n"
+" }\n"
+" }\n"
+"\n"
+" Ok(valid_urls)\n"
+"}\n"
+"\n"
+"fn main() {\n"
+" let start_url = Url::parse(\"https://www.google.org\").unwrap();\n"
+" let response = get(start_url).unwrap();\n"
+" match extract_links(response) {\n"
+" Ok(links) => println!(\"Links: {links:#?}\"),\n"
+" Err(err) => println!(\"Could not extract links: {err:#}\"),\n"
+" }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/concurrency/link-checker.md:100
+msgid "Run the code in `src/main.rs` with"
+msgstr "Execute o código em `src/main.rs` com"
+
+#: src/exercises/concurrency/link-checker.md:102
+msgid ""
+"```shell\n"
+"$ cargo run\n"
+"```"
+msgstr ""
+"```shell\n"
+"$ cargo run\n"
+"```"
+
+#: src/exercises/concurrency/link-checker.md:106
+#: src/exercises/concurrency/chat-app.md:140
+msgid "## Tasks"
+msgstr "## Tarefas"
+
+#: src/exercises/concurrency/link-checker.md:108
+msgid ""
+"* Use threads to check the links in parallel: send the URLs to be checked to a\n"
+" channel and let a few threads check the URLs in parallel.\n"
+"* Extend this to recursively extract links from all pages on the\n"
+" `www.google.org` domain. Put an upper limit of 100 pages or so so that you\n"
+" don't end up being blocked by the site."
+msgstr ""
+"* Use _threads_ para verificar os links em paralelo: envie as URLs a serem verificadas para um\n"
+" _channel_ e deixe alguns _threads_ verificarem as URLs em paralelo.\n"
+"* Estenda isso para extrair recursivamente links de todas as páginas no\n"
+" domínio `www.google.org`. Coloque um limite máximo de 100 páginas ou menos para que você\n"
+" não acabe sendo bloqueado pelo site."
+
+#: src/async.md:1
+#, fuzzy
+msgid "# Async Rust"
+msgstr "# Por que Rust?"
+
+#: src/async.md:3
+msgid ""
+"\"Async\" is a concurrency model where multiple tasks are executed concurrently by\n"
+"executing each task until it would block, then switching to another task that is\n"
+"ready to make progress. The model allows running a larger number of tasks on a\n"
+"limited number of threads. This is because the per-task overhead is typically\n"
+"very low and operating systems provide primitives for efficiently identifying\n"
+"I/O that is able to proceed."
+msgstr ""
+
+#: src/async.md:10
+msgid ""
+"Rust's asynchronous operation is based on \"futures\", which represent work that\n"
+"may be completed in the future. Futures are \"polled\" until they signal that\n"
+"they are complete."
+msgstr ""
+
+#: src/async.md:14
+msgid ""
+"Futures are polled by an async runtime, and several different runtimes are\n"
+"available."
+msgstr ""
+
+#: src/async.md:17
+#, fuzzy
+msgid "## Comparisons"
+msgstr "# Comparação"
+
+#: src/async.md:19
+msgid ""
+" * Python has a similar model in its `asyncio`. However, its `Future` type is\n"
+" callback-based, and not polled. Async Python programs require a \"loop\",\n"
+" similar to a runtime in Rust.\n"
+"\n"
+" * JavaScript's `Promise` is similar, but again callback-based. The language\n"
+" runtime implements the event loop, so many of the details of Promise\n"
+" resolution are hidden."
+msgstr ""
+
+#: src/async/async-await.md:1
+msgid "# `async`/`await`"
+msgstr ""
+
+#: src/async/async-await.md:3
+msgid "At a high level, async Rust code looks very much like \"normal\" sequential code:"
+msgstr ""
+
+#: src/async/async-await.md:5
+msgid ""
+"```rust,editable,compile_fail\n"
+"use futures::executor::block_on;\n"
+"\n"
+"async fn count_to(count: i32) {\n"
+" for i in 1..=count {\n"
+" println!(\"Count is: {i}!\");\n"
+" }\n"
+"}\n"
+"\n"
+"async fn async_main(count: i32) {\n"
+" count_to(count).await;\n"
+"}\n"
+"\n"
+"fn main() {\n"
+" block_on(async_main(10));\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/async/async-await.md:27
+msgid ""
+"* Note that this is a simplified example to show the syntax. There is no long\n"
+" running operation or any real concurrency in it!\n"
+"\n"
+"* What is the return type of an async call?\n"
+" * Use `let future: () = async_main(10);` in `main` to see the type.\n"
+"\n"
+"* The \"async\" keyword is syntactic sugar. The compiler replaces the return type\n"
+" with a future. \n"
+"\n"
+"* You cannot make `main` async, without additional instructions to the compiler\n"
+" on how to use the returned future.\n"
+"\n"
+"* You need an executor to run async code. `block_on` blocks the current thread\n"
+" until the provided future has run to completion. \n"
+"\n"
+"* `.await` asynchronously waits for the completion of another operation. Unlike\n"
+" `block_on`, `.await` doesn't block the current thread.\n"
+"\n"
+"* `.await` can only be used inside an `async` function (or block; these are\n"
+" introduced later). "
+msgstr ""
+
+#: src/async/futures.md:1
+#, fuzzy
+msgid "# Futures"
+msgstr "# Closures"
+
+#: src/async/futures.md:3
+msgid ""
+"[`Future`](https://doc.rust-lang.org/std/future/trait.Future.html)\n"
+"is a trait, implemented by objects that represent an operation that may not be\n"
+"complete yet. A future can be polled, and `poll` returns a\n"
+"[`Poll`](https://doc.rust-lang.org/std/task/enum.Poll.html)."
+msgstr ""
+
+#: src/async/futures.md:8
+msgid ""
+"```rust\n"
+"use std::pin::Pin;\n"
+"use std::task::Context;\n"
+"\n"
+"pub trait Future {\n"
+" type Output;\n"
+" fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll;\n"
+"}\n"
+"\n"
+"pub enum Poll {\n"
+" Ready(T),\n"
+" Pending,\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/async/futures.md:23
+msgid ""
+"An async function returns an `impl Future`. It's also possible (but uncommon) to\n"
+"implement `Future` for your own types. For example, the `JoinHandle` returned\n"
+"from `tokio::spawn` implements `Future` to allow joining to it."
+msgstr ""
+
+#: src/async/futures.md:27
+msgid ""
+"The `.await` keyword, applied to a Future, causes the current async function to\n"
+"pause until that Future is ready, and then evaluates to its output."
+msgstr ""
+
+#: src/async/futures.md:32
+msgid ""
+"* The `Future` and `Poll` types are implemented exactly as shown; click the\n"
+" links to show the implementations in the docs.\n"
+"\n"
+"* We will not get to `Pin` and `Context`, as we will focus on writing async\n"
+" code, rather than building new async primitives. Briefly:\n"
+"\n"
+" * `Context` allows a Future to schedule itself to be polled again when an\n"
+" event occurs.\n"
+"\n"
+" * `Pin` ensures that the Future isn't moved in memory, so that pointers into\n"
+" that future remain valid. This is required to allow references to remain\n"
+" valid after an `.await`."
+msgstr ""
+
+#: src/async/runtimes.md:1
+#, fuzzy
+msgid "# Runtimes"
+msgstr "# Garantias de tempo de execução"
+
+#: src/async/runtimes.md:3
+msgid ""
+"A *runtime* provides support for performing operations asynchronously (a\n"
+"*reactor*) and is responsible for executing futures (an *executor*). Rust does not have a\n"
+"\"built-in\" runtime, but several options are available:"
+msgstr ""
+
+#: src/async/runtimes.md:7
+msgid ""
+" * [Tokio](https://tokio.rs/) - performant, with a well-developed ecosystem of\n"
+" functionality like [Hyper](https://hyper.rs/) for HTTP or\n"
+" [Tonic](https://github.com/hyperium/tonic) for gRPC.\n"
+" * [async-std](https://async.rs/) - aims to be a \"std for async\", and includes a\n"
+" basic runtime in `async::task`.\n"
+" * [smol](https://docs.rs/smol/latest/smol/) - simple and lightweight"
+msgstr ""
+
+#: src/async/runtimes.md:14
+msgid ""
+"Several larger applications have their own runtimes. For example,\n"
+"[Fuchsia](https://fuchsia.googlesource.com/fuchsia/+/refs/heads/main/src/lib/fuchsia-async/src/lib.rs)\n"
+"already has one."
+msgstr ""
+
+#: src/async/runtimes.md:20
+msgid ""
+"* Note that of the listed runtimes, only Tokio is supported in the Rust\n"
+" playground. The playground also does not permit any I/O, so most interesting\n"
+" async things can't run in the playground.\n"
+"\n"
+"* Futures are \"inert\" in that they do not do anything (not even start an I/O\n"
+" operation) unless there is an executor polling them. This differs from JS\n"
+" Promises, for example, which will run to completion even if they are never\n"
+" used."
+msgstr ""
+
+#: src/async/runtimes/tokio.md:1
+msgid "# Tokio"
+msgstr ""
+
+#: src/async/runtimes/tokio.md:4
+msgid "Tokio provides: "
+msgstr ""
+
+#: src/async/runtimes/tokio.md:6
+msgid ""
+"* A multi-threaded runtime for executing asynchronous code.\n"
+"* An asynchronous version of the standard library.\n"
+"* A large ecosystem of libraries."
+msgstr ""
+
+#: src/async/runtimes/tokio.md:10
+msgid ""
+"```rust,editable,compile_fail\n"
+"use tokio::time;\n"
+"\n"
+"async fn count_to(count: i32) {\n"
+" for i in 1..=count {\n"
+" println!(\"Count in task: {i}!\");\n"
+" time::sleep(time::Duration::from_millis(5)).await;\n"
+" }\n"
+"}\n"
+"\n"
+"#[tokio::main]\n"
+"async fn main() {\n"
+" tokio::spawn(count_to(10));\n"
+"\n"
+" for i in 1..5 {\n"
+" println!(\"Main task: {i}\");\n"
+" time::sleep(time::Duration::from_millis(5)).await;\n"
+" }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/async/runtimes/tokio.md:33
+msgid ""
+"* With the `tokio::main` macro we can now make `main` async.\n"
+"\n"
+"* The `spawn` function creates a new, concurrent \"task\".\n"
+"\n"
+"* Note: `spawn` takes a `Future`, you don't call `.await` on `count_to`."
+msgstr ""
+
+#: src/async/runtimes/tokio.md:39
+msgid "**Further exploration:**"
+msgstr ""
+
+#: src/async/runtimes/tokio.md:41
+msgid ""
+"* Why does `count_to` not (usually) get to 10? This is an example of async\n"
+" cancellation. `tokio::spawn` returns a handle which can be awaited to wait\n"
+" until it finishes.\n"
+"\n"
+"* Try `count_to(10).await` instead of spawning.\n"
+"\n"
+"* Try awaiting the task returned from `tokio::spawn`."
+msgstr ""
+
+#: src/async/tasks.md:1
+#, fuzzy
+msgid "# Tasks"
+msgstr "## Tarefas"
+
+#: src/async/tasks.md:3
+msgid ""
+"Runtimes have the concept of a \"task\", similar to a thread but much\n"
+"less resource-intensive."
+msgstr ""
+
+#: src/async/tasks.md:6
+msgid ""
+"A task has a single top-level future which the executor polls to make progress.\n"
+"That future may have one or more nested futures that its `poll` method polls,\n"
+"corresponding loosely to a call stack. Concurrency within a task is possible by\n"
+"polling multiple child futures, such as racing a timer and an I/O operation."
+msgstr ""
+
+#: src/async/tasks.md:11
+msgid ""
+"```rust,compile_fail\n"
+"use tokio::io::{self, AsyncReadExt, AsyncWriteExt};\n"
+"use tokio::net::TcpListener;\n"
+"\n"
+"#[tokio::main]\n"
+"async fn main() -> io::Result<()> {\n"
+" let listener = TcpListener::bind(\"127.0.0.1:6142\").await?;\n"
+"\tprintln!(\"listening on port 6142\");\n"
+"\n"
+" loop {\n"
+" let (mut socket, addr) = listener.accept().await?;\n"
+"\n"
+" println!(\"connection from {addr:?}\");\n"
+"\n"
+" tokio::spawn(async move {\n"
+" if let Err(e) = socket.write_all(b\"Who are you?\\n\").await {\n"
+" println!(\"socket error: {e:?}\");\n"
+" return;\n"
+" }\n"
+"\n"
+" let mut buf = vec![0; 1024];\n"
+" let reply = match socket.read(&mut buf).await {\n"
+" Ok(n) => {\n"
+" let name = std::str::from_utf8(&buf[..n]).unwrap().trim();\n"
+" format!(\"Thanks for dialing in, {name}!\\n\")\n"
+" }\n"
+" Err(e) => {\n"
+" println!(\"socket error: {e:?}\");\n"
+" return;\n"
+" }\n"
+" };\n"
+"\n"
+" if let Err(e) = socket.write_all(reply.as_bytes()).await {\n"
+" println!(\"socket error: {e:?}\");\n"
+" }\n"
+" });\n"
+" }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/async/tasks.md:53 src/async/control-flow/join.md:36
+msgid "Copy this example into your prepared `src/main.rs` and run it from there."
+msgstr ""
+
+#: src/async/tasks.md:55
+msgid ""
+"* Ask students to visualize what the state of the example server would be with a\n"
+" few connected clients. What tasks exist? What are their Futures?\n"
+"\n"
+"* This is the first time we've seen an `async` block. This is similar to a\n"
+" closure, but does not take any arguments. Its return value is a Future,\n"
+" similar to an `async fn`. \n"
+"\n"
+"* Refactor the async block into a function, and improve the error handling using `?`."
+msgstr ""
+
+#: src/async/channels.md:1
+#, fuzzy
+msgid "# Async Channels"
+msgstr "# Channels (Canais)"
+
+#: src/async/channels.md:3
+msgid "Several crates have support for `async`/`await`. For instance `tokio` channels:"
+msgstr ""
+
+#: src/async/channels.md:5
+msgid ""
+"```rust,editable,compile_fail\n"
+"use tokio::sync::mpsc::{self, Receiver};\n"
+"\n"
+"async fn ping_handler(mut input: Receiver<()>) {\n"
+" let mut count: usize = 0;\n"
+"\n"
+" while let Some(_) = input.recv().await {\n"
+" count += 1;\n"
+" println!(\"Received {count} pings so far.\");\n"
+" }\n"
+"\n"
+" println!(\"ping_handler complete\");\n"
+"}\n"
+"\n"
+"#[tokio::main]\n"
+"async fn main() {\n"
+" let (sender, receiver) = mpsc::channel(32);\n"
+" let ping_handler_task = tokio::spawn(ping_handler(receiver));\n"
+" for i in 0..10 {\n"
+" sender.send(()).await.expect(\"Failed to send ping.\");\n"
+" println!(\"Sent {} pings so far.\", i + 1);\n"
+" }\n"
+"\n"
+" std::mem::drop(sender);\n"
+" ping_handler_task.await.expect(\"Something went wrong in ping handler task.\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/async/channels.md:35
+msgid ""
+"* Change the channel size to `3` and see how it affects the execution.\n"
+"\n"
+"* Overall, the interface is similar to the `sync` channels as seen in the\n"
+" [morning class](concurrency/channels.md).\n"
+"\n"
+"* Try removing the `std::mem::drop` call. What happens? Why?\n"
+"\n"
+"* The [Flume](https://docs.rs/flume/latest/flume/) crate has channels that\n"
+" implement both `sync` and `async` `send` and `recv`. This can be convenient\n"
+" for complex applications with both IO and heavy CPU processing tasks.\n"
+"\n"
+"* What makes working with `async` channels preferable is the ability to combine\n"
+" them with other `future`s to combine them and create complex control flow."
+msgstr ""
+
+#: src/async/control-flow.md:1
+#, fuzzy
+msgid "# Futures Control Flow"
+msgstr "# Controle de fluxo"
+
+#: src/async/control-flow.md:3
+msgid ""
+"Futures can be combined together to produce concurrent compute flow graphs. We\n"
+"have already seen tasks, that function as independent threads of execution."
+msgstr ""
+
+#: src/async/control-flow.md:6
+msgid ""
+"- [Join](control-flow/join.md)\n"
+"- [Select](control-flow/select.md)"
+msgstr ""
+
+#: src/async/control-flow/join.md:1
+msgid "# Join"
+msgstr ""
+
+#: src/async/control-flow/join.md:3
+msgid ""
+"A join operation waits until all of a set of futures are ready, and\n"
+"returns a collection of their results. This is similar to `Promise.all` in\n"
+"JavaScript or `asyncio.gather` in Python."
+msgstr ""
+
+#: src/async/control-flow/join.md:7
+msgid ""
+"```rust,editable,compile_fail\n"
+"use anyhow::Result;\n"
+"use futures::future;\n"
+"use reqwest;\n"
+"use std::collections::HashMap;\n"
+"\n"
+"async fn size_of_page(url: &str) -> Result {\n"
+" let resp = reqwest::get(url).await?;\n"
+" Ok(resp.text().await?.len())\n"
+"}\n"
+"\n"
+"#[tokio::main]\n"
+"async fn main() {\n"
+" let urls: [&str; 4] = [\n"
+" \"https://google.com\",\n"
+" \"https://httpbin.org/ip\",\n"
+" \"https://play.rust-lang.org/\",\n"
+" \"BAD_URL\",\n"
+" ];\n"
+" let futures_iter = urls.into_iter().map(size_of_page);\n"
+" let results = future::join_all(futures_iter).await;\n"
+" let page_sizes_dict: HashMap<&str, Result> =\n"
+" urls.into_iter().zip(results.into_iter()).collect();\n"
+" println!(\"{:?}\", page_sizes_dict);\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/async/control-flow/join.md:38
+msgid ""
+"* For multiple futures of disjoint types, you can use `std::future::join!` but\n"
+" you must know how many futures you will have at compile time. This is\n"
+" currently in the `futures` crate, soon to be stabilised in `std::future`.\n"
+"\n"
+"* The risk of `join` is that one of the futures may never resolve, this would\n"
+" cause your program to stall. \n"
+"\n"
+"* You can also combine `join_all` with `join!` for instance to join all requests\n"
+" to an http service as well as a database query. Try adding a\n"
+" `tokio::time::sleep` to the future, using `futures::join!`. This is not a\n"
+" timeout (that requires `select!`, explained in the next chapter), but demonstrates `join!`."
+msgstr ""
+
+#: src/async/control-flow/select.md:1
+#, fuzzy
+msgid "# Select"
+msgstr "# Configurar"
+
+#: src/async/control-flow/select.md:3
+msgid ""
+"A select operation waits until any of a set of futures is ready, and responds to\n"
+"that future's result. In JavaScript, this is similar to `Promise.race`. In\n"
+"Python, it compares to `asyncio.wait(task_set,\n"
+"return_when=asyncio.FIRST_COMPLETED)`."
+msgstr ""
+
+#: src/async/control-flow/select.md:8
+msgid ""
+"This is usually a macro, similar to match, with each arm of the form `pattern =\n"
+"future => statement`. When the future is ready, the statement is executed with the\n"
+"variable bound to the future's result."
+msgstr ""
+
+#: src/async/control-flow/select.md:12
+msgid ""
+"```rust,editable,compile_fail\n"
+"use tokio::sync::mpsc::{self, Receiver};\n"
+"use tokio::time::{sleep, Duration};\n"
+"\n"
+"#[derive(Debug, PartialEq)]\n"
+"enum Animal {\n"
+" Cat { name: String },\n"
+" Dog { name: String },\n"
+"}\n"
+"\n"
+"async fn first_animal_to_finish_race(\n"
+" mut cat_rcv: Receiver,\n"
+" mut dog_rcv: Receiver,\n"
+") -> Option {\n"
+" tokio::select! {\n"
+" cat_name = cat_rcv.recv() => Some(Animal::Cat { name: cat_name? }),\n"
+" dog_name = dog_rcv.recv() => Some(Animal::Dog { name: dog_name? })\n"
+" }\n"
+"}\n"
+"\n"
+"#[tokio::main]\n"
+"async fn main() {\n"
+" let (cat_sender, cat_receiver) = mpsc::channel(32);\n"
+" let (dog_sender, dog_receiver) = mpsc::channel(32);\n"
+" tokio::spawn(async move {\n"
+" sleep(Duration::from_millis(500)).await;\n"
+" cat_sender\n"
+" .send(String::from(\"Felix\"))\n"
+" .await\n"
+" .expect(\"Failed to send cat.\");\n"
+" });\n"
+" tokio::spawn(async move {\n"
+" sleep(Duration::from_millis(50)).await;\n"
+" dog_sender\n"
+" .send(String::from(\"Rex\"))\n"
+" .await\n"
+" .expect(\"Failed to send dog.\");\n"
+" });\n"
+"\n"
+" let winner = first_animal_to_finish_race(cat_receiver, dog_receiver)\n"
+" .await\n"
+" .expect(\"Failed to receive winner\");\n"
+"\n"
+" println!(\"Winner is {winner:?}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/async/control-flow/select.md:61
+msgid ""
+"* In this example, we have a race between a cat and a dog.\n"
+" `first_animal_to_finish_race` listens to both channels and will pick whichever\n"
+" arrives first. Since the dog takes 50ms, it wins against the cat that\n"
+" take 500ms seconds.\n"
+"\n"
+"* You can use `oneshot` channels in this example as the channels are supposed to\n"
+" receive only one `send`.\n"
+"\n"
+"* Try adding a deadline to the race, demonstrating selecting different sorts of\n"
+" futures.\n"
+"\n"
+"* Note that `select!` moves the values it is given. It is easiest to use\n"
+" when every execution of `select!` creates new futures. An alternative is to\n"
+" pass `&mut future` instead of the future itself, but this can lead to\n"
+" issues, further discussed in the pinning slide."
+msgstr ""
+
+#: src/async/pitfalls.md:1
+msgid "# Pitfalls of async/await"
+msgstr ""
+
+#: src/async/pitfalls.md:3
+msgid "Async / await provides convenient and efficient abstraction for concurrent asynchronous programming. However, the async/await model in Rust also comes with its share of pitfalls and footguns. We illustrate some of them in this chapter:"
+msgstr ""
+
+#: src/async/pitfalls.md:5
+msgid ""
+"- [Blocking the Executor](pitfalls/blocking-executor.md)\n"
+"- [Pin](pitfalls/pin.md)\n"
+"- [Async Traits](pitfall/async-traits.md)"
+msgstr ""
+
+#: src/async/pitfalls/blocking-executor.md:1
+msgid "# Blocking the executor"
+msgstr ""
+
+#: src/async/pitfalls/blocking-executor.md:3
+msgid ""
+"Most async runtimes only allow IO tasks to run concurrently.\n"
+"This means that CPU blocking tasks will block the executor and prevent other tasks from being executed.\n"
+"An easy workaround is to use async equivalent methods where possible."
+msgstr ""
+
+#: src/async/pitfalls/blocking-executor.md:7
+msgid ""
+"```rust,editable,compile_fail\n"
+"use futures::future::join_all;\n"
+"use std::time::Instant;\n"
+"\n"
+"async fn sleep_ms(start: &Instant, id: u64, duration_ms: u64) {\n"
+" std::thread::sleep(std::time::Duration::from_millis(duration_ms));\n"
+" println!(\n"
+" \"future {id} slept for {duration_ms}ms, finished after {}ms\",\n"
+" start.elapsed().as_millis()\n"
+" );\n"
+"}\n"
+"\n"
+"#[tokio::main(flavor = \"current_thread\")]\n"
+"async fn main() {\n"
+" let start = Instant::now();\n"
+" let sleep_futures = (1..=10).map(|t| sleep_ms(&start, t, t * 10));\n"
+" join_all(sleep_futures).await;\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/async/pitfalls/blocking-executor.md:29
+msgid ""
+"* Run the code and see that the sleeps happen consecutively rather than\n"
+" concurrently.\n"
+"\n"
+"* The `\"current_thread\"` flavor puts all tasks on a single thread. This makes the\n"
+" effect more obvious, but the bug is still present in the multi-threaded\n"
+" flavor.\n"
+"\n"
+"* Switch the `std::thread::sleep` to `tokio::time::sleep` and await its result.\n"
+"\n"
+"* Another fix would be to `tokio::task::spawn_blocking` which spawns an actual\n"
+" thread and transforms its handle into a future without blocking the executor.\n"
+"\n"
+"* You should not think of tasks as OS threads. They do not map 1 to 1 and most\n"
+" executors will allow many tasks to run on a single OS thread. This is\n"
+" particularly problematic when interacting with other libraries via FFI, where\n"
+" that library might depend on thread-local storage or map to specific OS\n"
+" threads (e.g., CUDA). Prefer `tokio::task::spawn_blocking` in such situations.\n"
+"\n"
+"* Use sync mutexes with care. Holding a mutex over an `.await` may cause another\n"
+" task to block, and that task may be running on the same thread."
+msgstr ""
+
+#: src/async/pitfalls/pin.md:1
+msgid "# Pin"
+msgstr ""
+
+#: src/async/pitfalls/pin.md:3
+msgid ""
+"When you await a future, all local variables (that would ordinarily be stored on\n"
+"a stack frame) are instead stored in the Future for the current async block. If your\n"
+"future has pointers to data on the stack, those pointers might get invalidated.\n"
+"This is unsafe."
+msgstr ""
+
+#: src/async/pitfalls/pin.md:8
+msgid ""
+"Therefore, you must guarantee that the addresses your future points to don't\n"
+"change. That is why we need to `pin` futures. Using the same future repeatedly\n"
+"in a `select!` often leads to issues with pinned values."
+msgstr ""
+
+#: src/async/pitfalls/pin.md:12
+msgid ""
+"```rust,editable,compile_fail\n"
+"use tokio::sync::{mpsc, oneshot};\n"
+"use tokio::task::spawn;\n"
+"use tokio::time::{sleep, Duration};\n"
+"\n"
+"// A work item. In this case, just sleep for the given time and respond\n"
+"// with a message on the `respond_on` channel.\n"
+"#[derive(Debug)]\n"
+"struct Work {\n"
+" input: u32,\n"
+" respond_on: oneshot::Sender,\n"
+"}\n"
+"\n"
+"// A worker which listens for work on a queue and performs it.\n"
+"async fn worker(mut work_queue: mpsc::Receiver) {\n"
+" let mut iterations = 0;\n"
+" loop {\n"
+" tokio::select! {\n"
+" Some(work) = work_queue.recv() => {\n"
+" sleep(Duration::from_millis(10)).await; // Pretend to work.\n"
+" work.respond_on\n"
+" .send(work.input * 1000)\n"
+" .expect(\"failed to send response\");\n"
+" iterations += 1;\n"
+" }\n"
+" // TODO: report number of iterations every 100ms\n"
+" }\n"
+" }\n"
+"}\n"
+"\n"
+"// A requester which requests work and waits for it to complete.\n"
+"async fn do_work(work_queue: &mpsc::Sender, input: u32) -> u32 {\n"
+" let (tx, rx) = oneshot::channel();\n"
+" work_queue\n"
+" .send(Work {\n"
+" input,\n"
+" respond_on: tx,\n"
+" })\n"
+" .await\n"
+" .expect(\"failed to send on work queue\");\n"
+" rx.await.expect(\"failed waiting for response\")\n"
+"}\n"
+"\n"
+"#[tokio::main]\n"
+"async fn main() {\n"
+" let (tx, rx) = mpsc::channel(10);\n"
+" spawn(worker(rx));\n"
+" for i in 0..100 {\n"
+" let resp = do_work(&tx, i).await;\n"
+" println!(\"work result for iteration {i}: {resp}\");\n"
+" }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/async/pitfalls/pin.md:68
+msgid ""
+"* You may recognize this as an example of the actor pattern. Actors\n"
+" typically call `select!` in a loop.\n"
+"\n"
+"* This serves as a summation of a few of the previous lessons, so take your time\n"
+" with it.\n"
+"\n"
+" * Naively add a `_ = sleep(Duration::from_millis(100)) => { println!(..) }`\n"
+" to the `select!`. This will never execute. Why?\n"
+"\n"
+" * Instead, add a `timeout_fut` containing that future outside of the `loop`:\n"
+"\n"
+" ```rust,compile_fail\n"
+" let mut timeout_fut = sleep(Duration::from_millis(100));\n"
+" loop {\n"
+" select! {\n"
+" ..,\n"
+" _ = timeout_fut => { println!(..); },\n"
+" }\n"
+" }\n"
+" ```\n"
+" * This still doesn't work. Follow the compiler errors, adding `&mut` to the\n"
+" `timeout_fut` in the `select!` to work around the move, then using\n"
+" `Box::pin`:\n"
+"\n"
+" ```rust,compile_fail\n"
+" let mut timeout_fut = Box::pin(sleep(Duration::from_millis(100)));\n"
+" loop {\n"
+" select! {\n"
+" ..,\n"
+" _ = &mut timeout_fut => { println!(..); },\n"
+" }\n"
+" }\n"
+" ```\n"
+"\n"
+" * This compiles, but once the timeout expires it is `Poll::Ready` on every\n"
+" iteration (a fused future would help with this). Update to reset\n"
+" `timeout_fut` every time it expires.\n"
+"\n"
+"* Box allocates on the heap. In some cases, `std::pin::pin!` (only recently\n"
+" stabilized, with older code often using `tokio::pin!`) is also an option, but\n"
+" that is difficult to use for a future that is reassigned.\n"
+"\n"
+"* Another alternative is to not use `pin` at all but spawn another task that will send to a `oneshot` channel every 100ms."
+msgstr ""
+
+#: src/async/pitfalls/async-traits.md:1
+#, fuzzy
+msgid "# Async Traits"
+msgstr "# Traits (Características)"
+
+#: src/async/pitfalls/async-traits.md:3
+msgid "Async methods in traits are not yet supported in the stable channel ([An experimental feature exists in nightly and should be stabilized in the mid term.](https://blog.rust-lang.org/inside-rust/2022/11/17/async-fn-in-trait-nightly.html))"
+msgstr ""
+
+#: src/async/pitfalls/async-traits.md:5
+msgid "The crate [async_trait](https://docs.rs/async-trait/latest/async_trait/) provides a workaround through a macro:"
+msgstr ""
+
+#: src/async/pitfalls/async-traits.md:7
+msgid ""
+"```rust,editable,compile_fail\n"
+"use async_trait::async_trait;\n"
+"use std::time::Instant;\n"
+"use tokio::time::{sleep, Duration};\n"
+"\n"
+"#[async_trait]\n"
+"trait Sleeper {\n"
+" async fn sleep(&self);\n"
+"}\n"
+"\n"
+"struct FixedSleeper {\n"
+" sleep_ms: u64,\n"
+"}\n"
+"\n"
+"#[async_trait]\n"
+"impl Sleeper for FixedSleeper {\n"
+" async fn sleep(&self) {\n"
+" sleep(Duration::from_millis(self.sleep_ms)).await;\n"
+" }\n"
+"}\n"
+"\n"
+"async fn run_all_sleepers_multiple_times(sleepers: Vec>, n_times: usize) {\n"
+" for _ in 0..n_times {\n"
+" println!(\"running all sleepers..\");\n"
+" for sleeper in &sleepers {\n"
+" let start = Instant::now();\n"
+" sleeper.sleep().await;\n"
+" println!(\"slept for {}ms\", start.elapsed().as_millis());\n"
+" }\n"
+" }\n"
+"}\n"
+"\n"
+"#[tokio::main]\n"
+"async fn main() {\n"
+" let sleepers: Vec> = vec![\n"
+" Box::new(FixedSleeper { sleep_ms: 50 }),\n"
+" Box::new(FixedSleeper { sleep_ms: 100 }),\n"
+" ];\n"
+" run_all_sleepers_multiple_times(sleepers, 5).await;\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/async/pitfalls/async-traits.md:49
+#, fuzzy
+msgid "
"
+msgstr "
"
+
+#: src/async/pitfalls/async-traits.md:51
+msgid ""
+"* `async_trait` is easy to use, but note that it's using heap allocations to\n"
+" achieve this. This heap allocation has performance overhead.\n"
+"\n"
+"* The challenges in language support for `async trait` are deep Rust and\n"
+" probably not worth describing in-depth. Niko Matsakis did a good job of\n"
+" explaining them in [this\n"
+" post](https://smallcultfollowing.com/babysteps/blog/2019/10/26/async-fn-in-traits-are-hard/)\n"
+" if you are interested in digging deeper.\n"
+"\n"
+"* Try creating a new sleeper struct that will sleep for a random amount of time\n"
+" and adding it to the Vec."
+msgstr ""
+
+#: src/exercises/concurrency/afternoon.md:3
+msgid "To practice your Async Rust skills, we have again two exercises for you:"
+msgstr ""
+
+#: src/exercises/concurrency/afternoon.md:5
+msgid ""
+"* Dining philosophers: we already saw this problem in the morning. This time\n"
+" you are going to implement it with Async Rust.\n"
+"\n"
+"* A Broadcast Chat Application: this is a larger project that allows you\n"
+" experiment with more advanced Async Rust features."
+msgstr ""
+
+#: src/exercises/concurrency/dining-philosophers-async.md:1
+#, fuzzy
+msgid "# Dining Philosophers - Async"
+msgstr "# Filósofos jantando"
+
+#: src/exercises/concurrency/dining-philosophers-async.md:3
+msgid ""
+"See [dining philosophers](dining-philosophers.md) for a description of the\n"
+"problem."
+msgstr ""
+
+#: src/exercises/concurrency/dining-philosophers-async.md:6
+#, fuzzy
+msgid ""
+"As before, you will need a local\n"
+"[Cargo installation](../../cargo/running-locally.md) for this exercise. Copy\n"
+"the code below to a file called `src/main.rs`, fill out the blanks, and test\n"
+"that `cargo run` does not deadlock:"
+msgstr ""
+"Você precisará de uma [instalação do Cargo][../../cargo/running-locally.md] local para\n"
+"esse exercício. Copie o código abaixo para o arquivo `src/main.rs`, preencha os espaços em branco,\n"
+"e teste se `cargo run` não trava:"
+
+#: src/exercises/concurrency/dining-philosophers-async.md:13
+msgid ""
+"```rust,compile_fail\n"
+"use std::sync::Arc;\n"
+"use tokio::time;\n"
+"use tokio::sync::mpsc::{self, Sender};\n"
+"use tokio::sync::Mutex;\n"
+"\n"
+"struct Fork;\n"
+"\n"
+"struct Philosopher {\n"
+" name: String,\n"
+" // left_fork: ...\n"
+" // right_fork: ...\n"
+" // thoughts: ...\n"
+"}\n"
+"\n"
+"impl Philosopher {\n"
+" async fn think(&self) {\n"
+" self.thoughts\n"
+" .send(format!(\"Eureka! {} has a new idea!\", &self.name)).await\n"
+" .unwrap();\n"
+" }\n"
+"\n"
+" async fn eat(&self) {\n"
+" // Pick up forks...\n"
+" println!(\"{} is eating...\", &self.name);\n"
+" time::sleep(time::Duration::from_millis(5)).await;\n"
+" }\n"
+"}\n"
+"\n"
+"static PHILOSOPHERS: &[&str] =\n"
+" &[\"Socrates\", \"Plato\", \"Aristotle\", \"Thales\", \"Pythagoras\"];\n"
+"\n"
+"#[tokio::main]\n"
+"async fn main() {\n"
+" // Create forks\n"
+"\n"
+" // Create philosophers\n"
+"\n"
+" // Make them think and eat\n"
+"\n"
+" // Output their thoughts\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/concurrency/dining-philosophers-async.md:57
+msgid ""
+"Since this time you are using Async Rust, you'll need a `tokio` dependency.\n"
+"You can use the following `Cargo.toml`:"
+msgstr ""
+
+#: src/exercises/concurrency/dining-philosophers-async.md:62
+msgid ""
+"```toml\n"
+"[package]\n"
+"name = \"dining-philosophers-async-dine\"\n"
+"version = \"0.1.0\"\n"
+"edition = \"2021\"\n"
+"\n"
+"[dependencies]\n"
+"tokio = {version = \"1.26.0\", features = [\"sync\", \"time\", \"macros\", \"rt-multi-thread\"]}\n"
+"```"
+msgstr ""
+
+#: src/exercises/concurrency/dining-philosophers-async.md:72
+msgid ""
+"Also note that this time you have to use the `Mutex` and the `mpsc` module\n"
+"from the `tokio` crate."
+msgstr ""
+
+#: src/exercises/concurrency/dining-philosophers-async.md:77
+msgid "* Can you make your implementation single-threaded? "
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:1
+msgid "# Broadcast Chat Application"
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:3
+msgid ""
+"In this exercise, we want to use our new knowledge to implement a broadcast\n"
+"chat application. We have a chat server that the clients connect to and publish\n"
+"their messages. The client reads user messages from the standard input, and\n"
+"sends them to the server. The chat server broadcasts each message that it\n"
+"receives to all the clients."
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:9
+msgid ""
+"For this, we use [a broadcast channel][1] on the server, and\n"
+"[`tokio_websockets`][2] for the communication between the client and the\n"
+"server."
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:13
+msgid "Create a new Cargo project and add the following dependencies:"
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:15
+msgid "`Cargo.toml`:"
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:19
+msgid ""
+"```toml\n"
+"[package]\n"
+"name = \"chat-async\"\n"
+"version = \"0.1.0\"\n"
+"edition = \"2021\"\n"
+"\n"
+"[dependencies]\n"
+"futures-util = \"0.3.28\"\n"
+"http = \"0.2.9\"\n"
+"tokio = { version = \"1.28.1\", features = [\"full\"] }\n"
+"tokio-websockets = \"0.3.2\"\n"
+"```"
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:32
+msgid "## The required APIs"
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:33
+msgid ""
+"You are going to need the following functions from `tokio` and\n"
+"[`tokio_websockets`][2]. Spend a few minutes to familiarize yourself with the\n"
+"API. "
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:37
+msgid ""
+"- [WebsocketStream::next()][3]: for asynchronously reading messages from a\n"
+" Websocket Stream.\n"
+"- [SinkExt::send()][4] implemented by `WebsocketStream`: for asynchronously\n"
+" sending messages on a Websocket Stream.\n"
+"- [BufReader::read_line()][5]: for asynchronously reading user messages\n"
+" from the standard input.\n"
+"- [Sender::subscribe()][6]: for subscribing to a broadcast channel."
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:46
+#, fuzzy
+msgid "## Two binaries"
+msgstr "# Binários Rust"
+
+#: src/exercises/concurrency/chat-app.md:48
+msgid ""
+"Normally in a Cargo project, you can have only one binary, and one\n"
+"`src/main.rs` file. In this project, we need two binaries. One for the client,\n"
+"and one for the server. You could potentially make them two separate Cargo\n"
+"projects, but we are going to put them in a single Cargo project with two\n"
+"binaries. For this to work, the client and the server code should go under\n"
+"`src/bin` (see the [documentation][7]). "
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:55
+msgid ""
+"Copy the following server and client code into `src/bin/server.rs` and\n"
+"`src/bin/client.rs`, respectively. Your task is to complete these files as\n"
+"described below. "
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:59
+#: src/exercises/concurrency/solutions-afternoon.md:117
+msgid "`src/bin/server.rs`:"
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:61
+msgid ""
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:63
+msgid ""
+"```rust,compile_fail\n"
+"use futures_util::sink::SinkExt;\n"
+"use std::error::Error;\n"
+"use std::net::SocketAddr;\n"
+"use tokio::net::{TcpListener, TcpStream};\n"
+"use tokio::sync::broadcast::{channel, Sender};\n"
+"use tokio_websockets::{Message, ServerBuilder, WebsocketStream};\n"
+"\n"
+"async fn handle_connection(\n"
+" addr: SocketAddr,\n"
+" mut ws_stream: WebsocketStream,\n"
+" bcast_tx: Sender,\n"
+") -> Result<(), Box> {\n"
+"\n"
+" // TODO: For a hint, see the description of the task below.\n"
+"\n"
+"}\n"
+"\n"
+"#[tokio::main]\n"
+"async fn main() -> Result<(), Box> {\n"
+" let (bcast_tx, _) = channel(16);\n"
+"\n"
+" let listener = TcpListener::bind(\"127.0.0.1:2000\").await?;\n"
+" println!(\"listening on port 2000\");\n"
+"\n"
+" loop {\n"
+" let (socket, addr) = listener.accept().await?;\n"
+" println!(\"New connection from {addr:?}\");\n"
+" let bcast_tx = bcast_tx.clone();\n"
+" tokio::spawn(async move {\n"
+" // Wrap the raw TCP stream into a websocket.\n"
+" let ws_stream = ServerBuilder::new().accept(socket).await?;\n"
+"\n"
+" handle_connection(addr, ws_stream, bcast_tx).await\n"
+" });\n"
+" }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:102
+#: src/exercises/concurrency/solutions-afternoon.md:202
+msgid "`src/bin/client.rs`:"
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:104
+msgid ""
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:106
+msgid ""
+"```rust,compile_fail\n"
+"use futures_util::SinkExt;\n"
+"use http::Uri;\n"
+"use tokio::io::{AsyncBufReadExt, BufReader};\n"
+"use tokio_websockets::{ClientBuilder, Message};\n"
+"\n"
+"#[tokio::main]\n"
+"async fn main() -> Result<(), tokio_websockets::Error> {\n"
+" let mut ws_stream = ClientBuilder::from_uri(Uri::from_static(\"ws://127.0.0.1:2000\"))\n"
+" .connect()\n"
+" .await?;\n"
+"\n"
+" let stdin = tokio::io::stdin();\n"
+" let mut stdin = BufReader::new(stdin);\n"
+"\n"
+"\n"
+" // TODO: For a hint, see the description of the task below.\n"
+"\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:127
+#, fuzzy
+msgid "## Running the binaries"
+msgstr "# Executando o curso"
+
+#: src/exercises/concurrency/chat-app.md:128
+msgid "Run the server with:"
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:130
+#, fuzzy
+msgid ""
+"```shell\n"
+"$ cargo run --bin server\n"
+"```"
+msgstr ""
+"```shell\n"
+"$ cargo run\n"
+"```"
+
+#: src/exercises/concurrency/chat-app.md:134
+msgid "and the client with:"
+msgstr ""
+
+#: src/exercises/concurrency/chat-app.md:136
+#, fuzzy
+msgid ""
+"```shell\n"
+"$ cargo run --bin client\n"
+"```"
+msgstr ""
+"```shell\n"
+"$ cargo run\n"
+"```"
+
+#: src/exercises/concurrency/chat-app.md:142
+msgid ""
+"* Implement the `handle_connection` function in `src/bin/server.rs`.\n"
+" * Hint: Use `tokio::select!` for concurrently performing two tasks in a\n"
+" continuous loop. One task receives messages from the client and broadcasts\n"
+" them. The other sends messages received by the server to the client.\n"
+"* Complete the main function in `src/bin/client.rs`.\n"
+" * Hint: As before, use `tokio::select!` in a continuous loop for concurrently\n"
+" performing two tasks: (1) reading user messages from standard input and\n"
+" sending them to the server, and (2) receiving messages from the server, and\n"
+" displaying them for the user.\n"
+"* Optional: Once you are done, change the code to broadcast messages to all\n"
+" clients, but the sender of the message."
+msgstr ""
+
#: src/thanks.md:1
msgid "# Thanks!"
msgstr "# Obrigado!"
@@ -15964,6 +17755,7 @@ msgid "A small selection of other guides and tutorial for Rust:"
msgstr "Uma pequena seleção de outros guias e tutoriais para Rust:"
#: src/other-resources.md:37
+#, fuzzy
msgid ""
"* [Learn Rust the Dangerous Way](http://cliffle.com/p/dangerust/): covers Rust\n"
" from the perspective of low-level C programmers.\n"
@@ -15985,7 +17777,11 @@ msgid ""
" [Take your first steps with\n"
" Rust](https://docs.microsoft.com/en-us/learn/paths/rust-first-steps/): two\n"
" Rust guides aimed at new developers. The first is a set of 35 videos and the\n"
-" second is a set of 11 modules which covers Rust syntax and basic constructs."
+" second is a set of 11 modules which covers Rust syntax and basic constructs.\n"
+"* [Learn Rust With Entirely Too Many Linked\n"
+" Lists](https://rust-unofficial.github.io/too-many-lists/): in-depth\n"
+" exploration of Rust's memory management rules, through implementing a few\n"
+" different types of list structures."
msgstr ""
"* [Aprenda Rust da maneira perigosa](http://cliffle.com/p/dangerust/): cobre Rust\n"
" da perspectiva de programadores C de baixo nível.\n"
@@ -16008,7 +17804,7 @@ msgstr ""
" guias Rust voltados para novos desenvolvedores. O primeiro é um conjunto de 35 vídeos e o\n"
" o segundo é um conjunto de 11 módulos que cobrem a sintaxe Rust e as construções básicas."
-#: src/other-resources.md:59
+#: src/other-resources.md:63
msgid ""
"Please see the [Little Book of Rust Books](https://lborb.github.io/book/) for\n"
"even more Rust books."
@@ -16124,10 +17920,7 @@ msgstr "## Vetores e laços `for`"
msgid "([back to exercise](for-loops.md))"
msgstr "([voltar ao exercício](for-loops.md))"
-#: src/exercises/day-1/solutions-morning.md:7 src/exercises/day-1/solutions-afternoon.md:7
-#: src/exercises/day-2/solutions-morning.md:7 src/exercises/day-2/solutions-afternoon.md:7
-#: src/exercises/day-2/solutions-afternoon.md:102 src/exercises/day-3/solutions-morning.md:7
-#: src/exercises/day-3/solutions-afternoon.md:7 src/exercises/day-4/solutions-morning.md:7
+#: src/exercises/day-1/solutions-morning.md:7
msgid ""
"```rust\n"
"// Copyright 2022 Google LLC\n"
@@ -16142,25 +17935,8 @@ msgid ""
"// distributed under the License is distributed on an \"AS IS\" BASIS,\n"
"// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n"
"// See the License for the specific language governing permissions and\n"
-"// limitations under the License."
-msgstr ""
-"```rust\n"
-"// Copyright 2022 Google LLC\n"
-"//\n"
-"// Licensed under the Apache License, Version 2.0 (the \"License\");\n"
-"// you may not use this file except in compliance with the License.\n"
-"// You may obtain a copy of the License at\n"
-"//\n"
-"// http://www.apache.org/licenses/LICENSE-2.0\n"
-"//\n"
-"// Unless required by applicable law or agreed to in writing, software\n"
-"// distributed under the License is distributed on an \"AS IS\" BASIS,\n"
-"// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n"
-"// See the License for the specific language governing permissions and\n"
-"// limitations under the License."
-
-#: src/exercises/day-1/solutions-morning.md:22
-msgid ""
+"// limitations under the License.\n"
+"\n"
"// ANCHOR: transpose\n"
"fn transpose(matrix: [[i32; 3]; 3]) -> [[i32; 3]; 3] {\n"
" // ANCHOR_END: transpose\n"
@@ -16171,40 +17947,16 @@ msgid ""
" }\n"
" }\n"
" return result;\n"
-"}"
-msgstr ""
-"// ANCHOR: transpose\n"
-"fn transposta(matriz: [[i32; 3]; 3]) -> [[i32; 3]; 3] {\n"
-" // ANCHOR_END: transpose\n"
-" let mut resultado = [[0; 3]; 3];\n"
-" for i in 0..3 {\n"
-" for j in 0..3 {\n"
-" resultado[j][i] = matriz[i][j];\n"
-" }\n"
-" }\n"
-" return resultado;\n"
-"}"
-
-#: src/exercises/day-1/solutions-morning.md:34
-msgid ""
+"}\n"
+"\n"
"// ANCHOR: pretty_print\n"
"fn pretty_print(matrix: &[[i32; 3]; 3]) {\n"
" // ANCHOR_END: pretty_print\n"
" for row in matrix {\n"
" println!(\"{row:?}\");\n"
" }\n"
-"}"
-msgstr ""
-"// ANCHOR: pretty_print\n"
-"fn impressao_formatada(matriz: &[[i32; 3]; 3]) {\n"
-" // ANCHOR_END: pretty_print\n"
-" for linha in matriz {\n"
-" println!(\"{linha:?}\");\n"
-" }\n"
-"}"
-
-#: src/exercises/day-1/solutions-morning.md:42
-msgid ""
+"}\n"
+"\n"
"// ANCHOR: tests\n"
"#[test]\n"
"fn test_transpose() {\n"
@@ -16223,100 +17975,52 @@ msgid ""
" ]\n"
" );\n"
"}\n"
-"// ANCHOR_END: tests"
-msgstr ""
-"// ANCHOR: tests\n"
-"#[test]\n"
-"fn test_transposta() {\n"
-" let matriz = [\n"
-" [101, 102, 103], //\n"
-" [201, 202, 203],\n"
-" [301, 302, 303],\n"
-" ];\n"
-" let matriz_transposta = transposta(matriz);\n"
-" assert_eq!(\n"
-" matriz_transposta,\n"
-" [\n"
-" [101, 201, 301], //\n"
-" [102, 202, 302],\n"
-" [103, 203, 303],\n"
-" ]\n"
-" );\n"
-"}\n"
-"// ANCHOR_END: tests"
-
-#: src/exercises/day-1/solutions-morning.md:62
-msgid ""
+"// ANCHOR_END: tests\n"
+"\n"
"// ANCHOR: main\n"
"fn main() {\n"
" let matrix = [\n"
" [101, 102, 103], // <-- the comment makes rustfmt add a newline\n"
" [201, 202, 203],\n"
" [301, 302, 303],\n"
-" ];"
-msgstr ""
-"// ANCHOR: main\n"
-"fn main() {\n"
-" let matriz = [\n"
-" [101, 102, 103], // <-- o comentário faz com que o rustfmt adicione uma nova linha\n"
-" [201, 202, 203],\n"
-" [301, 302, 303],\n"
-" ];"
-
-#: src/exercises/day-1/solutions-morning.md:73
-msgid ""
+" ];\n"
+"\n"
+" println!(\"matrix:\");\n"
+" pretty_print(&matrix);\n"
+"\n"
" let transposed = transpose(matrix);\n"
" println!(\"transposed:\");\n"
" pretty_print(&transposed);\n"
"}\n"
-"```\n"
-"### Bonus question"
+"```"
msgstr ""
-" let matriz_transposta = transposta(matriz);\n"
-" println!(\"Transposta:\");\n"
-" impressao_formatada(&matriz_transposta);\n"
-"}\n"
-"```\n"
-"### Pergunta bônus"
+
+#: src/exercises/day-1/solutions-morning.md:78
+#, fuzzy
+msgid "### Bonus question"
+msgstr "## Pergunta Bônus"
#: src/exercises/day-1/solutions-morning.md:80
-msgid ""
-"It requires more advanced concepts. It might seem that we could use a slice-of-slices (`&[&[i32]]`) as the input type to "
-"transpose and thus make our function handle any size of matrix. However, this quickly breaks down: the return type cannot "
-"be `&[&[i32]]` since it needs to own the data you return."
-msgstr ""
-"Isso necessita a utilização de conceitos mais avançados. Pode parecer que poderíamos usar uma slice de slices (`&[&[i32]]`) como o tipo de "
-"entrada para `transposta` e, assim, fazer nossa função lidar com qualquer tamanho de matriz. No entanto, isso falha "
-"rapidamente: o tipo de retorno não pode ser `&[&[i32]]`, pois ele precisa possuir os dados que você retorna."
+msgid "It requires more advanced concepts. It might seem that we could use a slice-of-slices (`&[&[i32]]`) as the input type to transpose and thus make our function handle any size of matrix. However, this quickly breaks down: the return type cannot be `&[&[i32]]` since it needs to own the data you return."
+msgstr "Isso necessita a utilização de conceitos mais avançados. Pode parecer que poderíamos usar uma slice de slices (`&[&[i32]]`) como o tipo de entrada para `transposta` e, assim, fazer nossa função lidar com qualquer tamanho de matriz. No entanto, isso falha rapidamente: o tipo de retorno não pode ser `&[&[i32]]`, pois ele precisa possuir os dados que você retorna."
#: src/exercises/day-1/solutions-morning.md:82
-msgid ""
-"You can attempt to use something like `Vec>`, but this doesn't work out-of-the-box either: it's hard to convert "
-"from `Vec>` to `&[&[i32]]` so now you cannot easily use `pretty_print` either."
-msgstr ""
-"Você pode tentar usar algo como `Vec>`, mas isso também não funciona muito bem: é difícil converter de "
-"`Vec>` para `&[&[i32]] ` então agora você também não pode usar `impressao_formatada` facilmente."
+msgid "You can attempt to use something like `Vec>`, but this doesn't work out-of-the-box either: it's hard to convert from `Vec>` to `&[&[i32]]` so now you cannot easily use `pretty_print` either."
+msgstr "Você pode tentar usar algo como `Vec>`, mas isso também não funciona muito bem: é difícil converter de `Vec