diff --git a/po/pt-BR.po b/po/pt-BR.po index 11c10eb6..9ca741f1 100644 --- a/po/pt-BR.po +++ b/po/pt-BR.po @@ -157,7 +157,7 @@ msgstr "Inferência de Tipo" #: src/SUMMARY.md:45 msgid "static & const" -msgstr "static & const" +msgstr "Variáveis Estáticas e Constantes" #: src/SUMMARY.md:46 msgid "Scopes and Shadowing" @@ -217,7 +217,7 @@ msgstr "Move em Chamadas de Função" #: src/SUMMARY.md:60 msgid "Copying and Cloning" -msgstr "Copiar e Clonar" +msgstr "Copia e Clonagem" #: src/SUMMARY.md:61 msgid "Borrowing" @@ -3222,7 +3222,7 @@ msgstr "# Rustdoc" #: src/basic-syntax/rustdoc.md:3 msgid "All language items in Rust can be documented using special `///` syntax." -msgstr "" +msgstr "Todos os itens da linguagem podem ser documentados com a sintaxe especial `///`." #: src/basic-syntax/rustdoc.md:5 msgid "" @@ -3246,7 +3246,7 @@ msgstr "" " if rhs == 0 {\n" " return false; // Caso excepcional, retorne antes\n" " }\n" -" lhs % rhs == 0 // A última expressão do bloco é utilizada como valor de retorno\n" +" lhs % rhs == 0 // A última expressão do bloco é o valor de retorno\n" "}\n" "```" @@ -3257,6 +3257,10 @@ msgid "" "[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 "" +"O conteúdio é tratado como _Markdown_. Todos os _crates_ publicados na biblioteca Rust são\n" +"documentados automaticamente em [`docs.rs`](https://docs.rs) utilizando a\n" +"ferramenta [rustdoc](https://doc.rust-lang.org/rustdoc/what-is-rustdoc.html). É idiomático\n" +"documentar todos os itens públicos em uma API usando este padrão." #: src/basic-syntax/rustdoc.md:24 msgid "" @@ -3269,6 +3273,14 @@ msgid "" "* Inner doc comments are discussed later (in the page on modules) and need not\n" " be addressed here." msgstr "" +"* Mostre aos alunos os documentos gerados para o crate `rand` em\n" +" [`docs.rs/rand`](https://docs.rs/rand).\n" +"\n" +"* Este curso não inclui o rustdoc nos slides, apenas para economizar espaço, mas em\n" +" código real eles devem estar presentes.\n" +"\n" +"* Os comentários internos do documento são discutidos posteriormente (na página sobre módulos) e não precisam ser\n" +" ser abordados aqui." #: src/basic-syntax/methods.md:1 src/methods.md:1 msgid "# Methods" @@ -3309,26 +3321,26 @@ msgid "" "```" msgstr "" "```rust,editable\n" -"struct Rectangle {\n" -" width: u32,\n" -" height: u32,\n" +"struct Retangulo {\n" +" largura: u32,\n" +" altura: u32,\n" "}\n" "\n" -"impl Rectangle {\n" +"impl Retangulo {\n" " fn area(&self) -> u32 {\n" -" self.width * self.height\n" +" self.largura * self.altura\n" " }\n" "\n" -" fn inc_width(&mut self, delta: u32) {\n" -" self.width += delta;\n" +" fn aum_largura(&mut self, delta: u32) {\n" +" self.largura += delta;\n" " }\n" "}\n" "\n" "fn main() {\n" -" let mut rect = Rectangle { width: 10, height: 5 };\n" -" println!(\"area antiga: {}\", rect.area());\n" -" rect.inc_width(5);\n" -" println!(\"nova area: {}\", rect.area());\n" +" let mut ret = Retangulo { largura: 10, altura: 5 };\n" +" println!(\"area antiga: {}\", ret.area());\n" +" ret.aum_largura(5);\n" +" println!(\"nova area: {}\", ret.area());\n" "}\n" "```" @@ -3349,14 +3361,24 @@ msgid "" "- Add a `Rectangle::new_square(width: u32)` constructor to illustrate that\n" " constructors can take arbitrary parameters." msgstr "" +"- Adicione um construtor `Retangulo::new` e o chame a partir de `main`:\n" +"\n" +" ```rust,editable,compile_fail\n" +" fn new(largura: u32, altura: u32) -> Retangulo {\n" +" Retangulo { largura, altura }\n" +" }\n" +" ```\n" +"\n" +"- Adicione um construtor `Rectangle::novo_quadrado(largura: u32)` para ilustrar que\n" +" construtores podem ter parâmetros arbitrários." #: src/basic-syntax/functions-interlude.md:1 msgid "# Function Overloading" -msgstr "# Sobrecarga de funções" +msgstr "# Sobrecarga de Funções" #: src/basic-syntax/functions-interlude.md:3 msgid "Overloading is not supported:" -msgstr "A sobrecarga não é suportada:" +msgstr "Sobrecarga não é suportada:" #: src/basic-syntax/functions-interlude.md:5 msgid "" @@ -3372,11 +3394,11 @@ msgstr "" " * Sempre usa um único conjunto de tipos de parâmetros.\n" "* Valores padrão não são suportados:\n" " * Todos as chamadas têm o mesmo número de argumentos.\n" -" * Às vezes macros são usadas como alternativa." +" * Às vezes macros são utilizadas como alternativa." #: src/basic-syntax/functions-interlude.md:12 msgid "However, function parameters can be generic:" -msgstr "No entanto, os parâmetros da função podem ser genéricos:" +msgstr "No entanto, os parâmetros da função podem ser tipos genéricos:" #: src/basic-syntax/functions-interlude.md:14 msgid "" @@ -3392,13 +3414,13 @@ msgid "" "```" msgstr "" "```rust,editable\n" -"fn pick_one(a: T, b: T) -> T {\n" +"fn escolha_um(a: T, b: T) -> T {\n" " if std::process::id() % 2 == 0 { a } else { b }\n" "}\n" "\n" "fn main() {\n" -" println!(\"lance da moeda: {}\", pick_one(\"cara\", \"coroa\"));\n" -" println!(\"prêmio em dinheiro: {}\", pick_one(500, 1000));\n" +" println!(\"lance da moeda: {}\", escolha_um(\"cara\", \"coroa\"));\n" +" println!(\"prêmio em dinheiro: {}\", escolha_um(500, 1000));\n" "}\n" "```" @@ -3407,16 +3429,16 @@ msgid "" "* When using generics, the standard library's `Into` can provide a kind of limited\n" " polymorphism on argument types. We will see more details in a later section." 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." +"* Ao usar tipos genéricos, o `Into` da biblioteca padrão pode fornecer um tipo de polimorfismo\n" +" limitado nos tipos de argumento. Veremos mais detalhes em uma seção posterior." #: src/exercises/day-1/morning.md:1 msgid "# Day 1: Morning Exercises" -msgstr "# Dia 1: Exercícios matinais" +msgstr "# Dia 1: Exercícios Matinais" #: src/exercises/day-1/morning.md:3 msgid "In these exercises, we will explore two parts of Rust:" -msgstr "Nestes exercícios, exploraremos duas partes do Rust:" +msgstr "Nestes exercícios, vamos explorar duas partes do Rust:" #: src/exercises/day-1/morning.md:5 msgid "" @@ -3426,7 +3448,7 @@ msgid "" msgstr "" "* Conversões implícitas entre tipos.\n" "\n" -"* Vetores e loops `for`." +"* Matrizes (_Arrays_) e laços (loops) `for`." #: src/exercises/day-1/morning.md:11 msgid "A few things to consider while solving the exercises:" @@ -3441,10 +3463,10 @@ msgid "" "* 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" +" preenchimento automático em seu editor. Veja a página sobre [Utilização do Cargo][Using Cargo] para detalhes\n" " sobre instalação do Rust.\n" "\n" -"* Alternativamente, utilizar o Rust Playground." +"* Alternativamente, utilize o Rust Playground." #: src/exercises/day-1/morning.md:19 msgid "" @@ -3460,11 +3482,11 @@ msgstr "" #: 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." +msgstr "Depois de ver os exercícios, você pode ver as [soluções][solutions] fornecidas." #: src/exercises/day-1/implicit-conversions.md:1 msgid "# Implicit Conversions" -msgstr "# Conversões implícitas" +msgstr "# Conversões Implícitas" #: src/exercises/day-1/implicit-conversions.md:3 msgid "" @@ -3472,7 +3494,7 @@ msgid "" "C++][3]). You can see this in a program like this:" msgstr "" "Rust não aplicará automaticamente _conversões implícitas_ entre os tipos ([ao contrário\n" -"De C++][3]). Você pode ver isso em um programa como este:" +"de C++][3]). Você pode ver isso em um programa como este:" #: src/exercises/day-1/implicit-conversions.md:6 msgid "" @@ -3490,7 +3512,7 @@ msgid "" "```" msgstr "" "```rust,editable,compile_fail\n" -"fn multiply(x: i16, y: i16) -> i16 {\n" +"fn multiplicar(x: i16, y: i16) -> i16 {\n" " x * y\n" "}\n" "\n" @@ -3498,7 +3520,7 @@ msgstr "" " let x: i8 = 15;\n" " let y: i16 = 1000;\n" "\n" -" println!(\"{x} * {y} = {}\", multiply(x, y));\n" +" println!(\"{x} * {y} = {}\", multiplicar(x, y));\n" "}\n" "```" @@ -3510,10 +3532,10 @@ msgid "" "Implementing these traits is how a type expresses that it can be converted into\n" "another type." msgstr "" -"Todos os tipos inteiros do Rust implementam os traits [`From`][1] e [`Into`][2]\n" -"para nos deixar converter entre eles. Os traits `From` tem um único `from()`\n" +"Todos os tipos inteiros do Rust implementam os _traits_ [`From`][1] e [`Into`][2]\n" +"para nos deixar converter entre eles. O trait `From` tem um único método `from()`\n" "e da mesma forma, o trait `Into` tem um único método `into()`.\n" -"A implementação dessas características é como um tipo expressa que pode ser convertido em\n" +"A implementação desses traits é como um tipo expressa que pode ser convertido em\n" "outro tipo." #: src/exercises/day-1/implicit-conversions.md:25 @@ -3533,9 +3555,8 @@ msgid "" "The same applies for your own `From` implementations for your own types, so it is\n" "sufficient to only implement `From` to get a respective `Into` implementation automatically." msgstr "" -"O mesmo se aplica a suas próprias implementações de `From` para seus tipos, então é\n" -"suficiente implementar apenas `From` para obter uma respectiva implementação `Into` " -"automaticamente." +"O mesmo se aplica às suas próprias implementações de `From` para seus próprios tipos, logo é\n" +"suficiente implementar apenas `From` para obter uma respectiva implementação `Into` automaticamente." #: src/exercises/day-1/implicit-conversions.md:33 msgid "" @@ -3551,21 +3572,21 @@ msgid "" msgstr "" "1. Execute o programa acima e observe o erro de compilação.\n" "\n" -"2. Atualize o código para utilizar `into()` para fazer a conversão.\n" +"2. Atualize o código acima para utilizar `into()` para fazer a conversão.\n" "\n" "3. Mude os tipos de `x` e `y` para outros tipos (como `f32`, `bool`,\n" " `i128`) para ver quais tipos você pode converter para quais outros tipos. Experimente\n" " converter tipos pequenos em tipos grandes e vice-versa. Verifique a\n" " [documentação da biblioteca padrão][1] para ver se `From` está implementado para\n" -" os pares que você verifica." +" os pares que você verificar." #: src/exercises/day-1/for-loops.md:1 msgid "# Arrays and `for` Loops" -msgstr "# Vetores e laços `for`" +msgstr "# Matrizes (Arrays) e Laços (Loops) `for`" #: src/exercises/day-1/for-loops.md:3 msgid "We saw that an array can be declared like this:" -msgstr "Vimos que um vetor pode ser declarado assim:" +msgstr "Vimos que uma matriz pode ser declarada assim:" #: src/exercises/day-1/for-loops.md:5 msgid "" @@ -3574,12 +3595,12 @@ msgid "" "```" msgstr "" "```rust\n" -"let vetor = [10, 20, 30];\n" +"let matriz = [10, 20, 30];\n" "```" #: src/exercises/day-1/for-loops.md:9 msgid "You can print such an array by asking for its debug representation with `{:?}`:" -msgstr "Você pode imprimir tal vetor solicitando sua representação de depuração com `{:?}`:" +msgstr "Você pode imprimir tal matriz solicitando sua representação de depuração com `{:?}`:" #: src/exercises/day-1/for-loops.md:11 msgid "" @@ -3592,8 +3613,8 @@ msgid "" msgstr "" "```rust,editable\n" "fn main() {\n" -" let vetor = [10, 20, 30];\n" -" println!(\"Vetor: {vetor:?}\");\n" +" let matriz = [10, 20, 30];\n" +" println!(\"matriz: {matriz:?}\");\n" "}\n" "```" @@ -3602,8 +3623,8 @@ msgid "" "Rust lets you iterate over things like arrays and ranges using the `for`\n" "keyword:" msgstr "" -"Rust permite iterar em coisas como vetores e intervalos usando um laço `for`\n" -":" +"Rust permite iterar em coisas como matrizes e _ranges_ (faixas ou intervalos) usando\n" +"a palavra-chave `for`:" #: src/exercises/day-1/for-loops.md:21 msgid "" @@ -3626,16 +3647,16 @@ msgid "" msgstr "" "```rust,editable\n" "fn main() {\n" -" let array = [10, 20, 30];\n" -" print!(\"Iterando sobre o vetor:\");\n" -" for n in array {\n" +" let matriz = [10, 20, 30];\n" +" print!(\"Iterando sobre a matriz:\");\n" +" for n in matriz {\n" " print!(\" {n}\");\n" " }\n" " println!();\n" "\n" -" print!(\"Iterando sobre um intervalo:\");\n" +" print!(\"Iterando sobre um range:\");\n" " for i in 0..3 {\n" -" print!(\" {}\", array[i]);\n" +" print!(\" {}\", matriz[i]);\n" " }\n" " println!();\n" "}\n" @@ -3700,6 +3721,33 @@ msgid "" "}\n" "```" msgstr "" +"```rust,should_panic\n" +"// TODO: remova isto quando você terminar sua implementação .\n" +"#![allow(unused_variables, dead_code)]\n" +"\n" +"fn transpose(matriz: [[i32; 3]; 3]) -> [[i32; 3]; 3] {\n" +" unimplemented!()\n" +"}\n" +"\n" +"fn pretty_print(matriz: &[[i32; 3]; 3]) {\n" +" unimplemented!()\n" +"}\n" +"\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" +" ];\n" +"\n" +" println!(\"matriz:\");\n" +" pretty_print(&matriz);\n" +"\n" +" let transposed = transpose(matriz);\n" +" println!(\"transposta:\");\n" +" pretty_print(&transposed);\n" +"}\n" +"```" #: src/exercises/day-1/for-loops.md:80 msgid "## Bonus Question" @@ -3711,17 +3759,17 @@ msgid "" "argument and return types? Something like `&[&[i32]]` for a two-dimensional\n" "slice-of-slices. Why or why not?" msgstr "" -"Você poderia usar slices `&[i32]` em vez de matrizes 3 × 3 estáticos para o seu\n" -"argumentos e tipos de retorno? Algo como `&[&[i32]]` para um slice-de-slices\n" -"bidimensional. Por que ou por que não?" +"Você poderia usar slices `&[i32]` em vez de matrizes 3 × 3 fixas no código para o seu\n" +"argumento e tipos de retorno? Algo como `&[&[i32]]` para um slice-de-slices\n" +"bidimensional. Por que sim ou por que não?" #: src/exercises/day-1/for-loops.md:87 msgid "" "See the [`ndarray` crate](https://docs.rs/ndarray/) for a production quality\n" "implementation." msgstr "" -"Veja o crate [`ndarray`](https://docs.rs/ndarray/) para uma implementação de produção\n" -"." +"Veja o crate [`ndarray`](https://docs.rs/ndarray/) para uma implementação de \n" +"produção." #: src/exercises/day-1/for-loops.md:92 msgid "" @@ -3769,7 +3817,7 @@ msgstr "" #: src/basic-syntax/type-inference.md:1 msgid "# Type Inference" -msgstr "# Inferência do tipo" +msgstr "# Inferência do Tipo" #: src/basic-syntax/type-inference.md:3 msgid "Rust will look at how the variable is _used_ to determine the type:" @@ -3796,12 +3844,32 @@ msgid "" "}\n" "```" msgstr "" +"```rust,editable\n" +"fn recebe_u32(x: u32) {\n" +" println!(\"u32: {x}\");\n" +"}\n" +"\n" +"fn recebe_i8(y: i8) {\n" +" println!(\"i8: {y}\");\n" +"}\n" +"\n" +"fn main() {\n" +" let x = 10;\n" +" let y = 20;\n" +"\n" +" recebe_u32(x);\n" +" recebe_i8(y);\n" +" // recebe_u32(y);\n" +"}\n" +"```" #: src/basic-syntax/type-inference.md:26 msgid "" "This slide demonstrates how the Rust compiler infers types based on constraints given by variable " "declarations and usages." msgstr "" +"Este slide demonstra como o compilador Rust infere tipos com base em restrições dadas por " +"declarações e usos de variáveis." #: src/basic-syntax/type-inference.md:28 msgid "" @@ -3811,9 +3879,6 @@ msgid "" "declaration of a type.\n" "The compiler does the job for us and helps us write more concise code." msgstr "" -"Este slide demonstra como o compilador Rust infere tipos com base em restrições dadas por " -"declarações e usos de variáveis.\n" -" \n" "É muito importante enfatizar que variáveis declaradas assim não são de um tipo dinâmico \"qualquer " "tipo\" que possa\n" "armazenar quaisquer dados. O código de máquina gerado por tal declaração é idêntico à declaração " @@ -3826,10 +3891,9 @@ msgid "" "ever explicitly specifying the contained type, using `_` as a placeholder:" msgstr "" "O código a seguir informa ao compilador para copiar para um determinado contêiner genérico sem que " -"o código especifique explicitamente o tipo contido, usando `_` como placeholder:" +"o código especifique explicitamente o tipo contido, usando `_` como _placeholder_:" #: src/basic-syntax/type-inference.md:34 -#, fuzzy msgid "" "```rust,editable\n" "fn main() {\n" @@ -3845,12 +3909,13 @@ msgid "" 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" +" let mut v = Vec::new();\n" +" v.push((10, false));\n" +" v.push((20, true));\n" +" println!(\"v: {v:?}\");\n" +"\n" +" let vv = v.iter().collect::>();\n" +" println!(\"vv: {vv:?}\");\n" "}\n" "```" @@ -3861,12 +3926,12 @@ msgid "" "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) " +"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" -msgstr "# Variáveis estáticas e constantes" +msgstr "# Variáveis Estáticas e Constantes" #: src/basic-syntax/static-and-const.md:3 msgid "Global state is managed with static and constant variables." @@ -3878,7 +3943,7 @@ msgstr "## `const`" #: src/basic-syntax/static-and-const.md:7 msgid "You can declare compile-time constants:" -msgstr "Você pode declarar constantes de tempo de compilação:" +msgstr "Você pode declarar constantes em tempo de compilação:" #: src/basic-syntax/static-and-const.md:9 msgid "" @@ -3900,12 +3965,27 @@ msgid "" "}\n" "```" msgstr "" +"```rust,editable\n" +"const TAMANHO_RESUMO: usize = 3;\n" +"const ZERO: Option = Some(42);\n" +"\n" +"fn computar_resumo(texto: &str) -> [u8; TAMANHO_RESUMO] {\n" +" let mut resumo = [ZERO.unwrap_or(0); TAMANHO_RESUMO];\n" +" for (idx, &b) in texto.as_bytes().iter().enumerate() {\n" +" resumo[idx % TAMANHO_RESUMO] = resumo[idx % TAMANHO_RESUMO].wrapping_add(b);\n" +" }\n" +" resumo\n" +"}\n" +"\n" +"fn main() {\n" +" let resumo = computar_resumo(\"Olá\");\n" +" println!(\"Resumo: {resumo:?}\");\n" +"}\n" +"```" #: src/basic-syntax/static-and-const.md:27 -#, 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." +msgstr "De acordo com o [Rust RFC Book][1], eles são expandidos no próprio local (_inline_) quando utilizados." #: src/basic-syntax/static-and-const.md:29 msgid "## `static`" @@ -3916,7 +3996,6 @@ 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\";\n" @@ -3926,8 +4005,13 @@ msgid "" "}\n" "```" msgstr "" -"```rust, editable\n" -"static BANNER: &str = \"Bem-vindo ao RustOS 3.14\";" +"```rust,editable\n" +"static BANNER: &str = \"Bem-vindo ao RustOS 3.14\";\n" +"\n" +"fn main() {\n" +" println!(\"{BANNER}\");\n" +"}\n" +"```" #: src/basic-syntax/static-and-const.md:41 msgid "" @@ -3935,13 +4019,13 @@ msgid "" "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 " +"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 (_unsafe_) 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)." -msgstr "Veremos a mutação de dados estáticos no [capítulo sobre Unsafe Rust](../unsafe.md)." +msgstr "Veremos a mutação de dados estáticos no [capítulo sobre Rust Inseguro (_Unsafe_)](../unsafe.md)." #: src/basic-syntax/static-and-const.md:48 msgid "" @@ -3952,25 +4036,23 @@ msgid "" "safer than using a static." 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" +"* `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/scopes-shadowing.md:1 msgid "# Scopes and Shadowing" -msgstr "# Escopos e sobreposição" +msgstr "# Escopos e _Shadowing_ (Sobreposição)" #: src/basic-syntax/scopes-shadowing.md:3 msgid "" "You can shadow variables, both those from outer scopes and variables from the\n" "same scope:" msgstr "" -"Você pode sobrepor (shadow) variáveis, tanto aquelas de escopos externos quanto variáveis do\n" +"Você pode sobrepor (_shadow_) variáveis, tanto aquelas de escopos externos quanto de variáveis do\n" "mesmo escopo:" #: src/basic-syntax/scopes-shadowing.md:6 -#, fuzzy msgid "" "```rust,editable\n" "fn main() {\n" @@ -3989,22 +4071,20 @@ msgid "" "}\n" "```" msgstr "" -"```rust, editable\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" +" let a = 10;\n" +" println!(\"antes: {a}\");\n" +"\n" +" {\n" +" let a = \"olá\";\n" +" println!(\"escopo interno: {a}\");\n" +"\n" +" let a = true;\n" +" println!(\"sobreposto no escopo interno: {a}\");\n" +" }\n" +"\n" +" println!(\"depois: {a}\");\n" "}\n" "```" @@ -4018,12 +4098,11 @@ msgid "" "* 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: _Shadowing_ é diferente da mutação, porque após a sobreposição (_shadowing_), os locais de " +"memória de ambas as variáveis existem ao mesmo tempo. Ambas estão disponíveis com o mesmo nome, " +"dependendo de onde você as 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" +"* 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." @@ -4041,7 +4120,7 @@ msgstr "" #: src/memory-management.md:1 msgid "# Memory Management" -msgstr "# Gerenciamento de memória" +msgstr "# Gerenciamento de Memória" #: src/memory-management.md:3 msgid "Traditionally, languages have fallen into two broad categories:" @@ -4053,35 +4132,33 @@ msgid "" "* Full safety via automatic memory management at runtime: Java, Python, Go, Haskell, ..." msgstr "" "* Controle total através do gerenciamento manual de memória: C, C++, Pascal, ...\n" -"* Segurança total através do gerenciamento automático de memória em tempo de execução: Java, " -"Python, Go, Haskell, ..." +"* Segurança total através do gerenciamento automático de memória em tempo de execução: Java, Python, Go, Haskell, ..." #: src/memory-management.md:8 msgid "Rust offers a new mix:" -msgstr "Rust oferece uma nova mistura:" +msgstr "Rust oferece uma nova combinação:" #: src/memory-management.md:10 msgid "" "> Full control *and* safety via compile time enforcement of correct memory\n" "> management." msgstr "" -"> Controle total *e* segurança por imposição do correto gerenciamento de memória em tempo de\n" +"> Controle total **_e_** segurança por imposição do correto gerenciamento de memória em tempo de\n" "> compilação." #: src/memory-management.md:13 msgid "It does this with an explicit ownership concept." -msgstr "Ele faz isso com um conceito de ownership explícito." +msgstr "Ele faz isso com um conceito de _ownership_ (posse) explícito." #: src/memory-management.md:15 msgid "First, let's refresh how memory management works." -msgstr "Primeiro, vamos rever como o gerenciamento de memória funciona." +msgstr "Primeiro, vamos rever como funciona o gerenciamento de memória." #: src/memory-management/stack-vs-heap.md:1 msgid "# The Stack vs The Heap" -msgstr "# Stack (pilha) vs Heap" +msgstr "# A Pilha (_Stack_) vs O _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" @@ -4094,23 +4171,27 @@ msgid "" " * 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" +"* Pilha: Área contínua de memória para variáveis locais.\n" " * Os valores têm tamanhos fixos conhecidos em tempo de compilação.\n" -" * Extremamente rápido: basta mover um ponteiro do stack.\n" +" * Extremamente rápida: basta mover um ponteiro de pilha.\n" " * Fácil de gerenciar: segue chamadas de função.\n" -" * Ótima localização na memória." +" * Ótima localidade de memória." +"\n" +"* Heap: Armazenamento de valores fora das chamadas de função.\n" +" * Valores possuem tamanhos dinâmicos determinados em tempo de execução.\n" +" * Ligeiramente mais devagar que a pilha: é necessário um pouco de gerenciamento.\n" +" * Sem garantias de localidade de memória." #: src/memory-management/stack.md:1 msgid "# Stack Memory" -msgstr "# Memória de pilha (stack Memory)" +msgstr "# Memória de Pilha (_Stack Memory_)" #: src/memory-management/stack.md:3 msgid "" "Creating a `String` puts fixed-sized data on the stack and dynamically sized\n" "data on the heap:" msgstr "" -"A criação de uma `String` coloca dados de tamanho fixo no stack e dados dimensionados " -"dinamicamente\n" +"A criação de uma `String` coloca dados de tamanho fixo na pilha e dados dimensionados dinamicamente\n" "no heap:" #: src/memory-management/stack.md:6 @@ -4121,9 +4202,13 @@ msgid "" "}\n" "```" msgstr "" +"```rust,editable\n" +"fn main() {\n" +" let s1 = String::from(\"Hello\");\n" +"}\n" +"```" #: src/memory-management/stack.md:12 -#, fuzzy msgid "" "```bob\n" " Stack Heap\n" @@ -4140,21 +4225,20 @@ msgid "" "```" msgstr "" "```bob\n" -" Stack Heap\n" -".- - - - - - - - - - - - - -. .- - - - - - - - - - - - - - - -.\n" -": : : :\n" -": s1 : : :\n" -": +-----------+-------+ : : +----+----+----+----+----+ :\n" -": | ptr | o---+---+-----+-->| H | e | l | l | o | :\n" -": | len | 5 | : : +----+----+----+----+----+ :\n" -": | capacity | 5 | : : :\n" -": +-----------+-------+ : : :\n" -": : `- - - - - - - - - - - - - - - -'\n" -"`- - - - - - - - - - - - - -'\n" +" Pilha Heap\n" +".- - - - - - - - - - - - - - -. .- - - - - - - - - - - - - - - -.\n" +": : : :\n" +": : : :\n" +": +------------+-------+ : : +----+----+----+----+----+ :\n" +": | ptr | o---+----+-----+-->| H | e | l | l | o | :\n" +": | tamanho | 5 | : : +----+----+----+----+----+ :\n" +": | capacidade | 5 | : : :\n" +": +------------+-------+ : : :\n" +": : `- - - - - - - - - - - - - - - -'\n" +"`- - - - - - - - - - - - - - -'\n" "```" #: 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.\n" @@ -4180,13 +4264,22 @@ msgid "" " }\n" " ```" msgstr "" +"* Mencione que uma `String` é suportada por um `Vec`, portanto ela tem um tamanho e capacidade e pode crescer se " +"for mutável por meio de realocação no heap.\n" +"\n" +"* Se os alunos perguntarem sobre isso, você pode mencionar que a memória subjacente é alocada no heap usando o " +"_[System Allocator]_ e os alocadores personalizados podem ser implementados usando a _[API Allocator][Allocator API]_.\n" +"\n" +"* Podemos inspecionar o layout da memória com código inseguro (`unsafe`). No entanto, você deve apontar que isso é " +"legitimamente inseguro!\n" +"\n" "```rust,editable\n" "fn main() {\n" " let mut s1 = String::from(\"Olá\");\n" " s1.push(' ');\n" " s1.push_str(\"mundo\");\n" " // NÃO FAÇA ISSO EM CASA! Somente com propósito educacional.\n" -" // String não provém nenhuma garantia sobre o seu layout, então isso pode levar\n" +" // String não fornece nenhuma garantia sobre o seu layout, então isso pode levar\n" " // a um comportamento indefinido.\n" " unsafe {\n" " let (capacity, ptr, len): (usize, usize, usize) = std::mem::transmute(s1);\n" @@ -4197,7 +4290,7 @@ msgstr "" #: src/memory-management/manual.md:1 msgid "# Manual Memory Management" -msgstr "# Gerenciamento manual de memória" +msgstr "# Gerenciamento Manual de Memória" #: src/memory-management/manual.md:3 msgid "You allocate and deallocate heap memory yourself." @@ -4207,8 +4300,7 @@ msgstr "Você mesmo aloca e desaloca memória no heap." 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." +"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" @@ -4222,7 +4314,7 @@ msgstr "Você deve chamar `free` em cada ponteiro que alocar com `malloc`:" msgid "" "```c\n" "void foo(size_t n) {\n" -" int* int_array = (int*)malloc(n * sizeof(int));\n" +" int* int_array = malloc(n * sizeof(int));\n" " //\n" " // ... lots of code\n" " //\n" @@ -4230,18 +4322,27 @@ msgid "" "}\n" "```" msgstr "" +"```c\n" +"void foo(size_t n) {\n" +" int* int_matriz = (int*)malloc(n * sizeof(int));\n" +" //\n" +" // ... várias linhas de código\n" +" //\n" +" free(int_matriz);\n" +"}\n" +"```" #: src/memory-management/manual.md:21 msgid "" "Memory is leaked if the function returns early between `malloc` and `free`: the\n" "pointer is lost and we cannot deallocate the memory." msgstr "" -"A memória vaza se a função retornar mais cedo entre `malloc` e `free`: o\n" +"Memória é vazada se a função retornar mais cedo entre `malloc` e `free`: o\n" "ponteiro é perdido e não podemos desalocar a memória." #: src/memory-management/scope-based.md:1 msgid "# Scope-Based Memory Management" -msgstr "# Gerenciamento de memória baseado em escopo" +msgstr "# Gerenciamento de Memória Baseado em Escopo" #: src/memory-management/scope-based.md:3 msgid "Constructors and destructors let you hook into the lifetime of an object." @@ -4255,16 +4356,15 @@ msgid "" msgstr "" "Ao envolver um ponteiro em um objeto, você pode liberar memória quando o objeto é\n" "destruído. O compilador garante que isso aconteça, mesmo que uma exceção seja\n" -"criada." +"lançada." #: src/memory-management/scope-based.md:9 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" -"ponteiros inteligentes." +"Isso geralmente é chamado de _aquisição de recursos é inicialização_ (_Resource Acquisition Is Initialization_, RAII) e fornece\n" +"ponteiros inteligentes (_smart pointers_)." #: src/memory-management/scope-based.md:12 msgid "## C++ Example" @@ -4279,8 +4379,8 @@ msgid "" "```" msgstr "" "```c++\n" -"void say_hello(std::unique_ptr person) {\n" -" std::cout << \"Olá \" << person->name << std::endl;\n" +"void diga_ola(std::unique_ptr pessoa) {\n" +" std::cout << \"Olá \" << pessoa->nome << std::endl;\n" "}\n" "```" @@ -4291,15 +4391,14 @@ msgid "" "* At the end of `say_hello`, the `std::unique_ptr` destructor will run.\n" "* The destructor frees the `Person` object it points to." msgstr "" -"* O objeto `std::unique_ptr` é alocado no stack e aponta para\n" +"* O objeto `std::unique_ptr` é alocado na pilha e aponta para\n" " memória alocada no heap.\n" -"* No final de `say_hello`, o destrutor `std::unique_ptr` será executado.\n" -"* O destrutor libera o objeto `Person` para o qual ele aponta." +"* No final de `diga_ola`, o destrutor `std::unique_ptr` será executado.\n" +"* O destrutor libera o objeto `Pessoa` para o qual ele aponta." #: src/memory-management/scope-based.md:25 msgid "Special move constructors are used when passing ownership to a function:" -msgstr "" -"Construtores especiais de movimento (move) são usados ao passar a \"ownership\" para uma função:" +msgstr "Construtores especiais de movimento (_move_) são usados ao passar o _\"ownership\"_ para uma função:" #: src/memory-management/scope-based.md:27 msgid "" @@ -4308,18 +4407,21 @@ msgid "" "say_hello(std::move(person));\n" "```" msgstr "" +"```c++\n" +"std::unique_ptr pessoa = encontrar_pessoa(\"Carla\");\n" +"diga_ola(std::move(pessoa));\n" +"```" #: src/memory-management/garbage-collection.md:1 msgid "# Automatic Memory Management" -msgstr "# Gerenciamento automático de memória" +msgstr "# Gerenciamento Automático de Memória" #: src/memory-management/garbage-collection.md:3 msgid "" "An alternative to manual and scope-based memory management is automatic memory\n" "management:" msgstr "" -"Uma alternativa ao gerenciamento de memória manual e baseado em escopo é o gerenciamento " -"automático\n" +"Uma alternativa ao gerenciamento de memória manual e baseado em escopo é o gerenciamento automático\n" "de memória:" #: src/memory-management/garbage-collection.md:6 @@ -4328,8 +4430,7 @@ msgid "" "* A garbage collector finds unused memory and deallocates it for the programmer." msgstr "" "* O programador nunca aloca ou desaloca memória explicitamente.\n" -"* Um \"coletor de lixo\" (garbage collector) encontra memória não utilizada e a desaloca para o " -"programador." +"* Um \"coletor de lixo\" (_garbage collector_) encontra memória não utilizada e a desaloca para o programador." #: src/memory-management/garbage-collection.md:9 msgid "## Java Example" @@ -4337,7 +4438,7 @@ msgstr "## Exemplo em Java" #: src/memory-management/garbage-collection.md:11 msgid "The `person` object is not deallocated after `sayHello` returns:" -msgstr "O objeto `person` não é desalocado depois que `sayHello` retorna:" +msgstr "O objeto `pessoa` não é desalocado depois que `digaOla` retorna:" #: src/memory-management/garbage-collection.md:13 msgid "" @@ -4348,18 +4449,18 @@ msgid "" "```" msgstr "" "```java\n" -"void sayHello(Person person) {\n" -" System.out.println(\"Olá \" + person.getName());\n" +"void digaOla(Pessoa pessoa) {\n" +" System.out.println(\"Olá \" + pessoa.obterNome());\n" "}\n" "```" #: src/memory-management/rust.md:1 msgid "# Memory Management in Rust" -msgstr "# Gerenciamento de memória do Rust" +msgstr "# Gerenciamento de Memória no Rust" #: src/memory-management/rust.md:3 msgid "Memory management in Rust is a mix:" -msgstr "O gerenciamento de memória no Rust é uma mistura:" +msgstr "O gerenciamento de memória no Rust é uma combinação:" #: src/memory-management/rust.md:5 msgid "" @@ -4370,7 +4471,7 @@ msgid "" "* 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" +"* Seguro e correto como Java, mas sem um 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" "* Baseado em escopo como C++, mas o compilador impõe adesão total.\n" @@ -4378,12 +4479,10 @@ msgstr "" "tempo de execução como C." #: src/memory-management/rust.md:10 -#, fuzzy msgid "Rust achieves this by modeling _ownership_ explicitly." -msgstr "Ele consegue isso modelando a propriedade (_ownership_) explicitamente." +msgstr "O Rust 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 " @@ -4392,8 +4491,10 @@ msgid "" "* 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." +"_wrappers_ (invólucros) RAII tais como [Box], [Vec], [Rc] ou [Arc]. Eles encapsulam a propriedade (ownership) e a " +"alocação de memória por vários meios e previnem os erros possíveis em C." +"\n" +"* Aqui você pode ser perguntado sobre destrutores, o _trait_ [Drop] é o equivalente em Rust." #: src/memory-management/comparison.md:1 msgid "# Comparison" @@ -4405,7 +4506,7 @@ msgstr "Aqui está uma comparação aproximada das técnicas de gerenciamento de #: src/memory-management/comparison.md:5 msgid "## Pros of Different Memory Management Techniques" -msgstr "## Vantagens de diferentes técnicas de gerenciamento de memória" +msgstr "## Vantagens de Diferentes Técnicas de Gerenciamento de Memória" #: src/memory-management/comparison.md:7 msgid "" @@ -4429,15 +4530,15 @@ msgstr "" " * Seguro e correto.\n" "* Baseado em escopo como C++:\n" " * Parcialmente automático.\n" -" * Nenhuma sobrecargo de tempo de execução.\n" -"* Baseado em escopo aplicado pelo compilador como Rust:\n" -" * Aplicado pelo compilador.\n" +" * Nenhuma sobrecarga em tempo de execução.\n" +"* Baseado em escopo imposto pelo compilador como Rust:\n" +" * Imposto pelo compilador.\n" " * Nenhuma sobrecarga em tempo de execução.\n" " * Seguro e correto." #: src/memory-management/comparison.md:20 msgid "## Cons of Different Memory Management Techniques" -msgstr "## Desvantagens de diferentes técnicas de gerenciamento de memória" +msgstr "## Desvantagens de Diferentes Técnicas de Gerenciamento de Memória" #: src/memory-management/comparison.md:22 msgid "" @@ -4456,22 +4557,22 @@ msgid "" " * Can reject valid programs." msgstr "" "* Manual como C:\n" -" * Uso após a liberação (use-after-free).\n" -" * Liberações duplas (double-free).\n" -" * Vazamento de memória.\n" +" * Uso após a liberação (_use-after-free_).\n" +" * Liberações duplas (_double-frees_).\n" +" * Vazamentos de memória.\n" "* Automático como Java:\n" -" * Pausa para coleta de lixo.\n" +" * Pausas para coleta de lixo.\n" " * Atrasos na execução de destrutores.\n" "* Baseado em escopo como C++:\n" " * Complexo, o programador deve optar em utilizá-las.\n" -" * Potencial para uso após a liberação (user-after-free).\n" -"* Obrigado pelo compilador e baseado em escopo como Rust:\n" +" * Potencial para uso após a liberação (_use-after-free_).\n" +"* Imposto pelo compilador e baseado em escopo como Rust:\n" " * Alguma complexidade inicial.\n" " * Pode rejeitar programas válidos." #: src/ownership.md:1 msgid "# Ownership" -msgstr "# Ownership" +msgstr "# Ownership (_\"Posse\"_)" #: src/ownership.md:3 msgid "" @@ -4482,7 +4583,6 @@ msgstr "" "usar uma variável fora de seu escopo:" #: src/ownership.md:6 -#, fuzzy msgid "" "```rust,editable,compile_fail\n" "struct Point(i32, i32);\n" @@ -4496,6 +4596,7 @@ msgid "" "}\n" "```" msgstr "" +"```rust,editable,compile_fail\n" "fn main() {\n" " {\n" " let p = Ponto(3, 4);\n" @@ -4511,17 +4612,17 @@ msgid "" "* A destructor can run here to free up resources.\n" "* We say that the variable _owns_ the value." msgstr "" -"* No final do escopo, a variável é _dropada_ e os dados são liberados.\n" +"* No final do escopo, a variável é eliminada (_\"dropada\"_) e os dados são liberados.\n" "* Um destrutor pode ser executado aqui para liberar recursos.\n" -"* Dizemos que a variável _possui_ (é dona) o valor." +"* Dizemos que a variável _possui_ (_owns_) o valor." #: src/ownership/move-semantics.md:1 msgid "# Move Semantics" -msgstr "# Semântica do `move` (mover)" +msgstr "# Semântica do `Move` (Mover)" #: src/ownership/move-semantics.md:3 msgid "An assignment will transfer ownership between variables:" -msgstr "Uma atribuição transferirá a propriedade (ownership) entre variáveis:" +msgstr "Uma atribuição transferirá a _ownership_ entre variáveis:" #: src/ownership/move-semantics.md:5 msgid "" @@ -4551,26 +4652,27 @@ msgid "" "* When `s2` goes out of scope, the string data is freed.\n" "* There is always _exactly_ one variable binding which owns a value." msgstr "" -"* A atribuição de `s1` a `s2` transfere a ownership.\n" -"* Os dados foram _movidos_ de `s1` e `s1` não estão mais acessíveis.\n" -"* Quando `s1` sai do escopo, nada acontece: ele não tem ownership.\n" +"* A atribuição de `s1` a `s2` transfere a _ownership_.\n" +"* Os dados foram _movidos_ de `s1` e `s1` não está mais acessível.\n" +"* Quando `s1` sai do escopo, nada acontece: ele não tem _ownership_.\n" "* Quando `s2` sai do escopo, os dados da string são liberados.\n" -"* Há sempre _exatamente_ uma associação de variável que possui um valor." +"* Há sempre _exatamente_ uma associação de variável que possui (owns) 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!).\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!)." +"* Mencione que isso é o oposto dos _defaults_ (padrões) em C++, que copia por valor, a menos que você use " +"`std::move` (e o construtor `move` esteja definido!)." +"\n" +"* No Rust, clones são explícitos (utilizando-se `clone`)." #: src/ownership/moved-strings-rust.md:1 msgid "# Moved Strings in Rust" -msgstr "# Strings movidas em Rust" +msgstr "# Strings Movidas em Rust" #: src/ownership/moved-strings-rust.md:3 msgid "" @@ -4595,7 +4697,6 @@ msgid "Before move to `s2`:" msgstr "Antes de mover para `s2`:" #: src/ownership/moved-strings-rust.md:15 -#, fuzzy msgid "" "```bob\n" " Stack Heap\n" @@ -4613,15 +4714,15 @@ msgid "" "```" msgstr "" "```bob\n" -" Stack Heap\n" +" Pilha Heap\n" ".- - - - - - - - - - - - - -. .- - - - - - - - - - - - - -.\n" ": : : :\n" ": s1 : : :\n" -": +-----------+-------+ : : +----+----+----+----+ :\n" -": | ptr | o---+---+-----+-->| R | u | s | t | :\n" -": | len | 4 | : : +----+----+----+----+ :\n" -": | capacity | 4 | : : :\n" -": +-----------+-------+ : : :\n" +": +------------+------+ : : +----+----+----+----+ :\n" +": | ponteiro | o---+---+-----+-->| R | u | s | t | :\n" +": | tamanho | 4 | : : +----+----+----+----+ :\n" +": | capacidade | 4 | : : :\n" +": +------------+------+ : : :\n" ": : `- - - - - - - - - - - - - -'\n" ": :\n" "`- - - - - - - - - - - - - -'\n" @@ -4632,7 +4733,6 @@ 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" @@ -4656,10 +4756,10 @@ msgid "" "```" msgstr "" "```bob\n" -" Stack Heap\n" +" Pilha Heap\n" ".- - - - - - - - - - - - - -. .- - - - - - - - - - - - - -.\n" ": : : :\n" -": s1 \"(inacessível)\" : : :\n" +": s1 \"(inacessível)\" : : :\n" ": +------------+------+ : : +----+----+----+----+ :\n" ": | ponteiro | o---+---+--+--+-->| R | u | s | t | :\n" ": | tamanho | 4 | : | : +----+----+----+----+ :\n" @@ -4678,7 +4778,7 @@ msgstr "" #: src/ownership/double-free-modern-cpp.md:1 msgid "# Double Frees in Modern C++" -msgstr "# Liberações duplas (double-free) em C++ moderno" +msgstr "# Liberações Duplas (_Double Frees_) em C++ Moderno" #: src/ownership/double-free-modern-cpp.md:3 msgid "Modern C++ solves this differently:" @@ -4702,11 +4802,11 @@ msgid "" "* When `s1` and `s2` go out of scope, they each free their own memory." msgstr "" "* Os dados de `s1` no heap são duplicados e `s2` obtém sua própria cópia independente.\n" -"* Quando `s1` e `s2` saem do escopo, cada um libera sua própria memória." +"* Quando `s1` e `s2` saem de escopo, cada um libera sua própria memória." #: src/ownership/double-free-modern-cpp.md:13 msgid "Before copy-assignment:" -msgstr "Antes da atribuição por cópias:" +msgstr "Antes da atribuição por cópia:" #: src/ownership/double-free-modern-cpp.md:16 msgid "" @@ -4724,6 +4824,19 @@ msgid "" "`- - - - - - - - - - - - - -'\n" "```" msgstr "" +"```bob\n" +" Pilha Heap\n" +".- - - - - - - - - - - - - -. .- - - - - - - - - - - -.\n" +": : : :\n" +": s1 : : :\n" +": +-----------+-------+ : : +----+----+----+ :\n" +": | ptr | o---+---+--+--+-->| C | p | p | :\n" +": | tam | 3 | : : +----+----+----+ :\n" +": | capac | 3 | : : :\n" +": +-----------+-------+ : : :\n" +": : `- - - - - - - - - - - -'\n" +"`- - - - - - - - - - - - - -'\n" +"```" #: src/ownership/double-free-modern-cpp.md:30 msgid "After copy-assignment:" @@ -4752,10 +4865,30 @@ msgid "" "`- - - - - - - - - - - - - -'\n" "```" msgstr "" +"```bob\n" +" Pilha Heap\n" +".- - - - - - - - - - - - - -. .- - - - - - - - - - - -.\n" +": : : :\n" +": s1 : : :\n" +": +-----------+-------+ : : +----+----+----+ :\n" +": | ptr | o---+---+--+--+-->| C | p | p | :\n" +": | tam | 3 | : : +----+----+----+ :\n" +": | capac | 3 | : : :\n" +": +-----------+-------+ : : :\n" +": : : :\n" +": s2 : : :\n" +": +-----------+-------+ : : +----+----+----+ :\n" +": | ptr | o---+---+-----+-->| C | p | p | :\n" +": | tam | 3 | : : +----+----+----+ :\n" +": | capac | 3 | : : :\n" +": +-----------+-------+ : : :\n" +": : `- - - - - - - - - - - -'\n" +"`- - - - - - - - - - - - - -'\n" +"```" #: src/ownership/moves-function-calls.md:1 msgid "# Moves in Function Calls" -msgstr "# Move (mover) em chamadas de Função" +msgstr "# _Moves_ (Movimentos) em Chamadas de Função" #: src/ownership/moves-function-calls.md:3 msgid "" @@ -4763,10 +4896,9 @@ msgid "" "parameter. This transfers ownership:" msgstr "" "Quando você passa um valor para uma função, o valor é atribuído ao parâmetro\n" -"da função. Isso transfere a ownership:" +"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" @@ -4780,10 +4912,15 @@ msgid "" "}\n" "```" msgstr "" +"```rust,editable\n" +"fn diga_ola(nome: String) {\n" +" println!(\"Olá {nome}\")\n" +"}\n" +"\n" "fn main() {\n" " let nome = String::from(\"Alice\");\n" -" diz_ola(nome);\n" -" // diz_ola(nome);\n" +" diga_ola(nome);\n" +" // diga_ola(nome);\n" "}\n" "```" @@ -4798,18 +4935,18 @@ msgid "" "* Rust makes it harder than C++ to inadvertently create copies by making move semantics the " "default, and by forcing programmers to make clones explicit." msgstr "" -"* 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` " +"* Com a primeira chamada para `diga_ola`, `main` desiste da ownership de `nome`. Depois disso, " +"`nome` não pode mais ser usado dentro de `main`.\n" +"* A memória do heap alocada para `nome` será liberada no final da função `diga_ola`.\n" +"* `main` pode manter a ownership se passar `nome` como uma referência (`&nome`) e se `diga_ola` " "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." +"* Alternativamente, `main` pode passar um clone de `nome` na primeira chamada (`nome.clone()`).\n" +"* Rust torna mais difícil a criação de cópias inadvertidamente do que o C++, tornando padrão a semântica " +"de movimento e forçando os programadores a tornar os clones explícitos." #: src/ownership/copy-clone.md:1 msgid "# Copying and Cloning" -msgstr "# Copiar e clonar" +msgstr "# Copia e Clonagem" #: src/ownership/copy-clone.md:3 msgid "While move semantics are the default, certain types are copied by default:" @@ -4826,7 +4963,7 @@ msgid "" "}\n" "```" msgstr "" -"```rust, editable\n" +"```rust,editable\n" "fn main() {\n" " let x = 42;\n" " let y = x;\n" @@ -4837,14 +4974,13 @@ msgstr "" #: src/ownership/copy-clone.md:14 msgid "These types implement the `Copy` trait." -msgstr "Esses tipos implementam o recurso `Copy`." +msgstr "Esses tipos implementam o _trait_ `Copy`." #: src/ownership/copy-clone.md:16 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:" +msgstr "Você pode habilitar 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" @@ -4858,6 +4994,10 @@ msgid "" "}\n" "```" msgstr "" +"```rust,editable\n" +"#[derive(Copy, Clone, Debug)]\n" +"struct Ponto(i32, i32);\n" +"\n" "fn main() {\n" " let p1 = Ponto(3, 4);\n" " let p2 = p1;\n" @@ -4872,11 +5012,11 @@ msgid "" "* We can also use `p1.clone()` to explicitly copy the data." msgstr "" "* Após a atribuição, tanto `p1` quanto `p2` possuem seus próprios dados.\n" -"* Também podemos usar `p1.clone()` para copiar explicitamente os dados." +"* Também podemos usar `p1.clone()` para copiar os dados explicitamente." #: src/ownership/copy-clone.md:35 msgid "Copying and cloning are not the same thing:" -msgstr "Copiar e clonar não são a mesma coisa:" +msgstr "Copia e clonagem não são a mesma coisa:" #: src/ownership/copy-clone.md:37 msgid "" @@ -4886,12 +5026,11 @@ msgid "" "`Clone` trait.\n" "* Copying does not work on types that implement the `Drop` trait." msgstr "" -"* A cópia refere-se a cópias bit a bit de regiões de memória e não funciona em objetos " -"arbitrários.\n" -"* A cópia não permite lógica personalizada (ao contrário dos construtores de cópia em C++).\n" -"* A clonagem é uma operação mais geral e também permite um comportamento personalizado " -"implementando a trait `Clone`.\n" -"* A cópia não funciona em tipos que implementam a característica `Drop`." +"* Cópia refere-se a cópias bit a bit de regiões de memória e não funciona em objetos arbitrários.\n" +"* Cópia não permite lógica personalizada (ao contrário dos construtores de cópia em C++).\n" +"* Clonagem é uma operação mais geral e também permite um comportamento personalizado através da " +"implementação do trait `Clone`.\n" +"* Cópia não funciona em tipos que implementam o trait `Drop`." #: src/ownership/copy-clone.md:42 src/ownership/lifetimes-function-calls.md:29 msgid "In the above example, try the following:" @@ -4905,28 +5044,25 @@ msgid "" "`p1`.\n" "* Show that it works if you clone `p1` instead." msgstr "" -"* Adicione um campo `String` ao `struct Point`. Não irá compilar porque `String` não é um tipo " +"* Adicione um campo `String` ao `struct Ponto`. Ele não irá compilar porque `String` não é um tipo " "`Copy`.\n" "* Remova `Copy` do atributo `derive`. O erro do compilador agora está no `println!` para `p1`.\n" -"* Mostre que funciona se você clonar `p1` em vez disso." +"* Mostre que ele funciona se ao invés disso você clonar `p1`." #: 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." msgstr "" -"Se os alunos perguntarem sobre `derive`, basta dizer que esta é uma forma de gerar código em Rust\n" +"Se os alunos perguntarem sobre `derive`, basta dizer que isto é 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" -" \n" -"" +"geradas." #: src/ownership/borrowing.md:1 msgid "# Borrowing" -msgstr "# Empréstimo (Borrowing)" +msgstr "# _Borrowing_ (Empréstimo)" #: src/ownership/borrowing.md:3 msgid "" @@ -4937,7 +5073,6 @@ msgstr "" "função _empreste_ o valor:" #: src/ownership/borrowing.md:6 -#, fuzzy msgid "" "```rust,editable\n" "#[derive(Debug)]\n" @@ -4955,6 +5090,14 @@ msgid "" "}\n" "```" msgstr "" +"```rust,editable\n" +"#[derive(Debug)]\n" +"struct Ponto(i32, i32);\n" +"\n" +"fn somar(p1: &Ponto, p2: &Ponto) -> Ponto {\n" +" Ponto(p1.0 + p2.0, p1.1 + p2.1)\n" +"}\n" +"\n" "fn main() {\n" " let p1 = Ponto(3, 4);\n" " let p2 = Ponto(10, 20);\n" @@ -4968,15 +5111,14 @@ msgid "" "* The `add` function _borrows_ two points and returns a new point.\n" "* The caller retains ownership of the inputs." msgstr "" -"* A função `somar` _pega emprestado_ (_borrowing_) dois Pontos e retorna um novo Ponto.\n" +"* A função `somar` _pega emprestado_ (_borrows_) dois pontos e retorna um novo ponto.\n" "* O chamador mantém a _ownership_ das entradas." #: src/ownership/borrowing.md:27 msgid "Notes on stack returns:" -msgstr "" +msgstr "Notas sobre os retornos da pilha:" #: 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 " @@ -5006,6 +5148,19 @@ msgid "" "have side effects. In Rust, this is not an issue at all. If RVO did not happen, Rust will always " "perform a simple and efficient `memcpy` copy." msgstr "" +"* Demonstre que o retorno de `somar` é barato porque o compilador pode eliminar a operação de cópia. " +"Modifique o código acima para imprimir endereços da pilha e execute-o no [Playground]. No " +"nível de otimização \"DEBUG\", os endereços devem mudar, enquanto eles permanecem os mesmos quando a configuração " +"é alterada para \"RELEASE\":\n" +"\n" +"```rust,editable\n" +"#[derive(Debug)]\n" +"struct Ponto(i32, i32);\n" +"\n" +"fn somar(p1: &Ponto, p2: &Ponto) -> Ponto {\n" +" Ponto(p1.0 + p2.0, p1.1 + p2.1)\n" +"}\n" +"\n" " fn main() {\n" " let p1 = Ponto(3, 4);\n" " let p2 = Ponto(10, 20);\n" @@ -5014,14 +5169,14 @@ msgstr "" " println!(\"{p1:?} + {p2:?} = {p3:?}\");\n" " }\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 " +"* O compilador Rust pode fazer otimização de valor de retorno (_Return Value Operation_ - RVO).\n" +"* Em C++, a elisão (omissã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" -msgstr "# Empréstimos compartilhados e exclusivos" +msgstr "# Empréstimos (_Borrows_) Compartilhados e Exclusivos" #: src/ownership/shared-unique-borrows.md:3 msgid "Rust puts constraints on the ways you can borrow values:" @@ -5036,7 +5191,6 @@ 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" @@ -5053,12 +5207,18 @@ msgid "" "}\n" "```" msgstr "" -"```rust, editable\n" +"```rust,editable,compile_fail\n" "fn main() {\n" -" let x = 42;\n" -" let y = x;\n" -" println!(\"x: {x}\");\n" -" println!(\"y: {y}\");\n" +" let mut a: i32 = 10;\n" +" let b: &i32 = &a;\n" +"\n" +" {\n" +" let c: &mut i32 = &mut a;\n" +" *c = 20;\n" +" }\n" +"\n" +" println!(\"a: {a}\");\n" +" println!(\"b: {b}\");\n" "}\n" "```" @@ -5077,50 +5237,54 @@ msgstr "" "* 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\"." +"`a` através de `c`. Este é um recurso do verificador de empréstimo (_borrow checker_) chamado \"tempos de vida não lexicais\"." #: src/ownership/lifetimes.md:1 msgid "# Lifetimes" -msgstr "# Tempos de vida" +msgstr "# Tempos de Vida (_Lifetimes_)" #: src/ownership/lifetimes.md:3 msgid "A borrowed value has a _lifetime_:" -msgstr "Um valor emprestado tem um tempo de vida (_lifetime_):" +msgstr "Um valor emprestado tem um _tempo de vida_ (_lifetime_):" #: src/ownership/lifetimes.md:5 -#, fuzzy msgid "" "* 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" +"* 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" +" * Lifetime annotations create constraints; the compiler verifies that " +"there is\n" " a valid solution.\n" -"* Lifetimes for function arguments and return values must be fully specified,\n" -" but Rust allows these to be elided in most cases with [a few simple\n" +"* Lifetimes for function arguments and return values must be fully " +"specified,\n" +" but Rust allows lifetimes to be elided 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" -"* Leia `&'a Point` como \"um `Point` emprestado que é válido por pelo menos o\n" +"* O tempo de vida pode ser implícito: `somar(p1: &Ponto, p2: &Ponto) -> Ponto`.\n" +"* Tempos de vida também podem ser explícitos: `&'a Ponto`, `&'documento str`.\n" +"* Leia `&'a Ponto` como \"um `Ponto` emprestado que é válido por pelo menos o\n" " tempo de vida `a`\".\n" -"* Os tempos de vida são sempre inferidos pelo compilador: você não pode atribuir um tempo de vida\n" +"* Tempos de vida são sempre inferidos pelo compilador: você não pode atribuir um tempo de vida\n" " você mesmo.\n" -" * As anotações vitalícias criam restrições; o compilador verifica se há\n" -" uma solução válida." +" * Anotações de tempo de vida criam restrições; o compilador verifica se há\n" +" uma solução válida.\n" +"* Tempos de vida para argumentos de função e valores de retorno precisam ser completamente especificados,\n" +" mas o Rust permite que eles sejam omitidos na maioria das vezes com [algumas regras\n" +" simples](https://doc.rust-lang.org/nomicon/lifetime-elision.html)." #: src/ownership/lifetimes-function-calls.md:1 msgid "# Lifetimes in Function Calls" -msgstr "# Tempos de vida em chamadas de função" +msgstr "# Tempos de Vida (_Lifetimes_) em Chamadas de Função" #: src/ownership/lifetimes-function-calls.md:3 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:5 -#, fuzzy msgid "" "```rust,editable\n" "#[derive(Debug)]\n" @@ -5138,6 +5302,14 @@ msgid "" "}\n" "```" msgstr "" +"```rust,editable\n" +"#[derive(Debug)]\n" +"struct Ponto(i32, i32);\n" +"\n" +"fn mais_a_esquerda<'a>(p1: &'a Ponto, p2: &'a Ponto) -> &'a Ponto {\n" +" if p1.0 < p2.0 { p1 } else { p2 }\n" +"}\n" +"\n" "fn main() {\n" " let p1: Ponto = Ponto(10, 10);\n" " let p2: Ponto = Ponto(20, 20);\n" @@ -5154,14 +5326,13 @@ msgid "" " lifetime `a`\".\n" " * The _at least_ part is important when parameters are in different scopes." msgstr "" -"* `'a` é um parâmetro genérico, é inferido pelo compilador.\n" +"* `'a` é um parâmetro genérico, ele é inferido pelo compilador.\n" "* Os tempos de vida começam com `'` e `'a` é um name padrão típico.\n" "* Leia `&'a Ponto` como \"um `Ponto` emprestado que é válido por pelo menos o\n" " tempo de vida `a`\".\n" " * 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 new scope (`{ ... }`), resulting in the following code:\n" " ```rust,ignore\n" @@ -5194,27 +5365,46 @@ msgid "" " * Which one is it? The compiler needs 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" +"* 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);\n" +"\n" +" fn mais_a_esquerda<'a>(p1: &'a Ponto, p2: &'a Ponto) -> &'a Ponto {\n" +" if p1.0 < p2.0 { p1 } else { p2 }\n" +" }\n" +"\n" +" 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" +" Note como isto não compila uma vez que `p3` vive mais que `p2`.\n" +"\n" +"* Reinicie 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" -" * Deve ter vindo de uma dessas duas entradas (ou de uma variável global).\n" -" * Qual é? O compilador precisa saber, portanto, no local da chamada, a referência retornada não " -"é usada\n" +" * Ela deve ter vindo de uma dessas duas entradas (ou de uma variável global).\n" +" * De qual? O compilador precisa saber, de forma que no local da chamada a referência retornada não seja usada\n" " por mais tempo do que uma variável de onde veio a referência." #: src/ownership/lifetimes-data-structures.md:1 msgid "# Lifetimes in Data Structures" -msgstr "# Tempos de vida em estruturas de dados" +msgstr "# Tempos de Vida (_Lifetimes_) em Estruturas de Dados" #: src/ownership/lifetimes-data-structures.md:3 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" @@ -5234,10 +5424,18 @@ msgid "" "}\n" "```" msgstr "" +"```rust,editable\n" +"#[derive(Debug)]\n" +"struct Destaque<'doc>(&'doc str);\n" +"\n" +"fn apagar(texto: String) {\n" +" println!(\"Até logo {texto}!\");\n" +"}\n" +"\n" "fn main() {\n" -" let texto = String::from(\"A esperta raposa marrom pula sobre o cachorro preguiçoso.\");\n" -" let raposa = Destaque(&texto[2..23]);\n" -" let cachorro = Destaque(&texto[37..57]);\n" +" let texto = String::from(\"A raposa marrom ágil pula sobre o cachorro preguiçoso.\");\n" +" let raposa = Destaque(&texto[2..21]);\n" +" let cachorro = Destaque(&texto[35..53]);\n" " // apagar(texto);\n" " println!(\"{raposa:?}\");\n" " println!(\"{cachorro:?}\");\n" @@ -5245,7 +5443,6 @@ 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" @@ -5259,17 +5456,16 @@ msgid "" "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" +"vivam pelo menos tanto quanto qualquer instância de `Destaque` que use 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" -"" +"* Quando possível, faça com que as estruturas de dados possuam (_own_) seus dados diretamente.\n" +"* Algumas _structs_ com múltiplas referências internas podem ter mais de uma anotação de tempo de vida. Isso " +"pode ser necessário se houver a necessidade de descrever-se relacionamentos de tempo de vida entre as " +"próprias referências, além do tempo de vida da própria _struct_. Esses são casos de uso bastante " +"avançados." #: src/exercises/day-1/afternoon.md:1 msgid "# Day 1: Afternoon Exercises"