diff --git a/po/pt-BR.po b/po/pt-BR.po index 72cd6dbc..ef77b5e3 100644 --- a/po/pt-BR.po +++ b/po/pt-BR.po @@ -240,12 +240,12 @@ msgid "Lifetimes in Data Structures" msgstr "Tempos de Vida em Estruturas de Dados" #: src/SUMMARY.md:67 -msgid "Designing a Library" -msgstr "Projetando uma Biblioteca" +msgid "Storing Books" +msgstr "Armazenando Livros" #: src/SUMMARY.md:68 msgid "Iterators and Ownership" -msgstr "Iteradores e Propriedade (Ownership)" +msgstr "Iteradores e Ownership (Posse)" #: src/SUMMARY.md:71 msgid "Day 2: Morning" @@ -325,31 +325,31 @@ msgstr "Blocos" #: src/SUMMARY.md:98 msgid "if expressions" -msgstr "Expressões Se (if)" +msgstr "Expressões if" #: src/SUMMARY.md:99 msgid "if let expressions" -msgstr "Expressões Se (if let)" +msgstr "Expressões if let" #: src/SUMMARY.md:100 msgid "while expressions" -msgstr "Expressões Enquanto (while)" +msgstr "Loops while" #: src/SUMMARY.md:101 msgid "while let expressions" -msgstr "Expressões Enquanto (while let)" +msgstr "Loops while let" #: src/SUMMARY.md:102 msgid "for expressions" -msgstr "Expressões Para (for)" +msgstr "Loops for" #: src/SUMMARY.md:103 msgid "loop expressions" -msgstr "Expressões de Laço (loop)" +msgstr "Expressões loop" #: src/SUMMARY.md:104 msgid "match expressions" -msgstr "Expressões de Correspondência (match)" +msgstr "Expressões match (Correspondência)" #: src/SUMMARY.md:105 msgid "break & continue" @@ -381,7 +381,7 @@ msgstr "Box" #: src/SUMMARY.md:112 msgid "Recursive Data Types" -msgstr "Tipos de Dados Recursivos" +msgstr "Box com Estruturas de Dados Recursivas" #: src/SUMMARY.md:113 msgid "Niche Optimization" @@ -1780,11 +1780,18 @@ msgstr "" " padrão. Você pode ter múltiplas versões do Rust instaladas ao mesmo tempo e `rustup`\n" " permitirá que você alterne entre elas conforme necessário." -#: src/cargo/rust-ecosystem.md:21 src/hello-world.md:25 src/hello-world/small-example.md:27 -#: src/why-rust/runtime.md:10 src/why-rust/modern.md:21 src/basic-syntax/compound-types.md:30 -#: src/basic-syntax/references.md:23 src/pattern-matching/destructuring-enums.md:35 -#: src/error-handling/try-operator.md:48 src/error-handling/converting-error-types-example.md:50 -#: src/concurrency/threads.md:30 src/async/async-await.md:25 +#: src/cargo/rust-ecosystem.md:21 +#: src/hello-world.md:25 +#: src/hello-world/small-example.md:27 +#: src/why-rust/runtime.md:10 +#: src/why-rust/modern.md:21 +#: src/basic-syntax/compound-types.md:30 +#: src/basic-syntax/references.md:23 +#: src/pattern-matching/destructuring-enums.md:35 +#: src/error-handling/try-operator.md:48 +#: src/error-handling/converting-error-types-example.md:50 +#: src/concurrency/threads.md:30 +#: src/async/async-await.md:25 msgid "Key points:" msgstr "Pontos chave:" @@ -5473,30 +5480,32 @@ msgstr "# Dia 1: Exercícios da Tarde" #: src/exercises/day-1/afternoon.md:3 msgid "We will look at two things:" -msgstr "Veremos duas coisas:" +msgstr "Nós iremos ver duas coisas:" #: src/exercises/day-1/afternoon.md:5 -#, fuzzy msgid "" "* A small book library,\n" "\n" "* Iterators and ownership (hard)." -msgstr "* Iteradores e ownership (difícil)." +msgstr "" +"* Uma pequena biblioteca literária,\n" +"\n" +"* Iteradores e _ownership_ (difícil)." #: src/exercises/day-1/book-library.md:1 -msgid "# Designing a Library" -msgstr "# Projetando uma biblioteca" +msgid "# Storing Books" +msgstr "# Armazenando Livros" #: src/exercises/day-1/book-library.md:3 msgid "" -"We will learn much more about structs and the `Vec` type tomorrow. For now,\n" +"We will learn much more about structs and the `Vec` type tomorrow. For " +"now,\n" "you just need to know part of its API:" msgstr "" -"Aprenderemos muito mais sobre structs e o tipo `Vec` amanhã. Por hora,\n" +"Nós iremos aprender muito mais sobre _structs_ e o tipo `Vec` amanhã. Por hora,\n" "você só precisa conhecer parte de sua API:" #: src/exercises/day-1/book-library.md:6 -#, fuzzy msgid "" "```rust,editable\n" "fn main() {\n" @@ -5514,7 +5523,8 @@ msgstr "" "fn main() {\n" " let mut vetor = vec![10, 20];\n" " vetor.push(30);\n" -" println!(\"valor do meio: {}\", vetor[vetor.len() / 2]);\n" +" let ponto_central = vetor.len() / 2;\n" +" println!(\"valor do meio: {}\", vetor[ponto_central]);\n" " for item in vetor.iter() {\n" " println!(\"item: {item}\");\n" " }\n" @@ -5523,10 +5533,10 @@ msgstr "" #: src/exercises/day-1/book-library.md:18 msgid "" -"Use this to create a library application. Copy the code below to\n" +"Use this to model a library's book collection. Copy the code below to\n" " and update the types to make it compile:" msgstr "" -"Use isso para criar um aplicativo de biblioteca. Copie o código abaixo para\n" +"Use isto para modelar uma coleção de livros de uma biblioteca. Copie o código abaixo para\n" " e atualize os tipos para compilar:" #: src/exercises/day-1/book-library.md:21 @@ -5575,7 +5585,8 @@ msgid "" " //}\n" "\n" " //fn print_books(self) {\n" -" // todo!(\"Iterate over `self.books` and each book's title and year\")\n" +" // todo!(\"Iterate over `self.books` and each book's title and " +"year\")\n" " //}\n" "\n" " //fn oldest_book(self) -> Option<&Book> {\n" @@ -5590,12 +5601,15 @@ msgid "" "fn main() {\n" " let library = Library::new();\n" "\n" -" //println!(\"The library is empty: {}\", library.is_empty());\n" +" //println!(\"The library is empty: library.is_empty() -> {}\", " +"library.is_empty());\n" " //\n" " //library.add_book(Book::new(\"Lord of the Rings\", 1954));\n" -" //library.add_book(Book::new(\"Alice's Adventures in Wonderland\", 1865));\n" +" //library.add_book(Book::new(\"Alice's Adventures in Wonderland\", " +"1865));\n" " //\n" -" //println!(\"The library is no longer empty: {}\", library.is_empty());\n" +" //println!(\"The library is no longer empty: library.is_empty() -> {}\", " +"library.is_empty());\n" " //\n" " //\n" " //library.print_books();\n" @@ -5610,18 +5624,96 @@ msgid "" "}\n" "```" msgstr "" +"```rust,should_panic\n" +"struct Biblioteca {\n" +" livros: Vec,\n" +"}\n" +"\n" +"struct Livro {\n" +" titulo: String,\n" +" ano: u16,\n" +"}\n" +"\n" +"impl Livro {\n" +" // Este é um construtor, utilizado abaixo.\n" +" fn new(titulo: &str, ano: u16) -> Livro {\n" +" Livro {\n" +" titulo: String::from(titulo),\n" +" ano,\n" +" }\n" +" }\n" +"}\n" +"\n" +"// Implemente os métodos abaixo. Atualize o parâmetro `self` para\n" +"// indicar o nível requerido de ownership sobre o objeto:\n" +"//\n" +"// - `&self` para acesso compartilhado de apenas leitura,\n" +"// - `&mut self` para acesso mutável exclusivo,\n" +"// - `self` para acesso exclusivo por valor.\n" +"impl Biblioteca {\n" +" fn new() -> Biblioteca {\n" +" todo!(\"Inicialize e retorne um valor `Biblioteca`\")\n" +" }\n" +"\n" +" //fn tamanho(self) -> usize {\n" +" // todo!(\"Retorne o tamanho de `self.livros`\")\n" +" //}\n" +"\n" +" //fn esta_vazia(self) -> bool {\n" +" // todo!(\"Retorne `true` se `self.livros` for vazio\")\n" +" //}\n" +"\n" +" //fn adicionar_livro(self, book: Livro) {\n" +" // todo!(\"Adicione um novo livro em `self.livros`\")\n" +" //}\n" +"\n" +" //fn imprimir_livros(self) {\n" +" // todo!(\"Itere sobre `self.livros` e sobre o título e ano de cada livro\")\n" +" //}\n" +"\n" +" //fn livro_mais_antigo(self) -> Option<&Livro> {\n" +" // todo!(\"Retorne uma referência para o livro mais antigo (se houver)\")\n" +" //}\n" +"}\n" +"\n" +"// Isto demonstra o comportamento esperado. Descomente o código abaixo e\n" +"// implemente os métodos que faltam. Você precisará atualizar as\n" +"// assinaturas dos métodos, incluindo o parâmetro \"self\"! Você talvez\n" +"// precise atualizar as atribuições de variável dentro de `main()`.\n" +"fn main() {\n" +" let biblioteca = Biblioteca::new();\n" +"\n" +" //println!(\"A biblioteca está vazia: biblioteca.esta_vazia() -> {}\", " +"biblioteca.esta_vazia());\n" +" //\n" +" //biblioteca.adicionar_livro(Livro::new(\"Lord of the Rings\", 1954));\n" +" //biblioteca.adicionar_livro(Livro::new(\"Alice's Adventures in Wonderland\", " +"1865));\n" +" //\n" +" //println!(\"The biblioteca não está mais vazia: biblioteca.esta_vazia() -> {}\", " +"biblioteca.esta_vazia());\n" +" //\n" +" //\n" +" //biblioteca.imprimir_livros();\n" +" //\n" +" //match biblioteca.livro_mais_antigo() {\n" +" // Some(livro) => println!(\"O livro mais antigo é {}\", livro.titulo),\n" +" // None => println!(\"A biblioteca está vazia!\"),\n" +" //}\n" +" //\n" +" //println!(\"The biblioteca tem {} livros\", biblioteca.tamanho());\n" +" //biblioteca.imprimir_livros();\n" +"}\n" +"```" #: src/exercises/day-1/book-library.md:102 -#, fuzzy msgid "[Solution](solutions-afternoon.md#designing-a-library)" msgstr "" -"
\n" -" \n" "[Soluções](solutions-afternoon.md#designing-a-library)" #: src/exercises/day-1/iterators-and-ownership.md:1 msgid "# Iterators and Ownership" -msgstr "# Iteradores e ownership" +msgstr "# Iteradores e _Ownership_ (Posse)" #: src/exercises/day-1/iterators-and-ownership.md:3 msgid "" @@ -5636,14 +5728,14 @@ msgstr "" #: src/exercises/day-1/iterators-and-ownership.md:8 msgid "## `Iterator`" -msgstr "## `Iterator` (iterador)" +msgstr "## `Iterator` (Iterador)" #: src/exercises/day-1/iterators-and-ownership.md:10 msgid "" "Traits are like interfaces: they describe behavior (methods) for a type. The\n" "`Iterator` trait simply says that you can call `next` until you get `None` back:" msgstr "" -"Os _traits_ são como interfaces: eles descrevem o comportamento (métodos) para um tipo. o\n" +"Os _traits_ são como interfaces: eles descrevem o comportamento (métodos) para um tipo.\n" "O _trait_ `Iterator` simplesmente diz que você pode chamar `next` até obter `None` como retorno:" #: src/exercises/day-1/iterators-and-ownership.md:13 @@ -5664,10 +5756,9 @@ msgstr "" #: src/exercises/day-1/iterators-and-ownership.md:20 msgid "You use this trait like this:" -msgstr "Você usa esse trait assim:" +msgstr "Você usa esse _trait_ da seguinte forma:" #: src/exercises/day-1/iterators-and-ownership.md:22 -#, fuzzy msgid "" "```rust,editable\n" "fn main() {\n" @@ -5681,6 +5772,11 @@ msgid "" "}\n" "```" msgstr "" +"```rust,editable\n" +"fn main() {\n" +" let v: Vec = vec![10, 20, 30];\n" +" 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" @@ -5693,7 +5789,6 @@ 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" @@ -5708,7 +5803,12 @@ msgstr "" "```rust,editable,compile_fail\n" "fn main() {\n" " let v: Vec = vec![10, 20, 30];\n" -" let mut iter = v.iter();" +" let mut iter = v.iter();\n" +"\n" +" let v0: Option<..> = iter.next();\n" +" println!(\"v0: {v0:?}\");\n" +"}\n" +"```" #: src/exercises/day-1/iterators-and-ownership.md:46 msgid "Why is this type used?" @@ -5724,10 +5824,9 @@ msgid "" "iterator. The related trait `IntoIterator` tells you how to create the iterator:" msgstr "" "O _trait_ `Iterator` informa como _iterar_ depois de criar um\n" -"iterador. A característica relacionada `IntoIterator` informa como criar o iterador:" +"iterador. O _trait_ relacionado `IntoIterator` lhe informa como criar o iterador:" #: src/exercises/day-1/iterators-and-ownership.md:53 -#, fuzzy msgid "" "```rust\n" "pub trait IntoIterator {\n" @@ -5741,7 +5840,11 @@ msgstr "" "```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" +"```" #: src/exercises/day-1/iterators-and-ownership.md:62 msgid "" @@ -5765,14 +5868,13 @@ msgid "" "`Item` type, which means that it returns `Option`" msgstr "" "Observe que `IntoIter` e `Item` estão vinculados: o iterador deve ter o mesmo\n" -"Tipo `Item`, o que significa que ele retorna `Option`" +"tipo `Item`, o que significa que ele retorna `Option`" #: src/exercises/day-1/iterators-and-ownership.md:71 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" @@ -5787,11 +5889,16 @@ msgstr "" "```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" +"```" #: src/exercises/day-1/iterators-and-ownership.md:83 msgid "## `for` Loops" -msgstr "## Laços `for`" +msgstr "## _Loops_ `for`" #: src/exercises/day-1/iterators-and-ownership.md:85 msgid "" @@ -5799,12 +5906,11 @@ msgid "" "They call `into_iter()` on an expression and iterates over the resulting\n" "iterator:" msgstr "" -"Agora que conhecemos `Iterator` e `IntoIterator`, podemos construir laços `for`.\n" -"Eles chamam `into_iter()` em uma expressão e itera sobre o resultado\n" -"iterador:" +"Agora que conhecemos `Iterator` e `IntoIterator`, podemos construir loops `for`.\n" +"Eles chamam `into_iter()` em uma expressão e itera sobre o iterador\n" +"resultante:" #: src/exercises/day-1/iterators-and-ownership.md:89 -#, fuzzy msgid "" "```rust,editable\n" "fn main() {\n" @@ -5822,10 +5928,15 @@ msgid "" msgstr "" "```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" +" let v: Vec = vec![String::from(\"foo\"), String::from(\"bar\")];\n" +"\n" +" for palavra in &v {\n" +" println!(\"palavra: {palavra}\");\n" +" }\n" +"\n" +" for palavra in v {\n" +" println!(\"palavra: {palavra}\");\n" +" }\n" "}\n" "```" @@ -5835,16 +5946,15 @@ msgstr "Qual é o tipo de `palavra` em cada laço?" #: src/exercises/day-1/iterators-and-ownership.md:105 msgid "" -"Experiment with the code above and then consult the documentation for [`impl\n" +"Experiment with the code above and then consult the documentation for " +"[`impl\n" "IntoIterator for\n" -"&Vec`](https://doc.rust-lang.org/std/vec/struct.Vec.html#impl-IntoIterator-for-" -"%26%27a%20Vec%3CT%2C%20A%3E)\n" +"&Vec`](https://doc.rust-lang.org/std/vec/struct.Vec.html#impl-IntoIterator-for-%26'a+Vec%3CT,+A%3E)\n" "and [`impl IntoIterator for\n" -"Vec`](https://doc.rust-lang.org/std/vec/struct.Vec.html#impl-IntoIterator-for-" -"Vec%3CT%2C%20A%3E)\n" +"Vec`](https://doc.rust-lang.org/std/vec/struct.Vec.html#impl-IntoIterator-for-Vec%3CT,+A%3E)\n" "to check your answers." msgstr "" -"Experimente o código acima e depois consulte a documentação para [`impl\n" +"Experimente com o código acima e depois consulte a documentação para [`impl\n" "IntoIterator para\n" "&Vec`](https://doc.rust-lang.org/std/vec/struct.Vec.html#impl-IntoIterator-for-" "%26%27a%20Vec%3CT%2C%20A%3E)\n" @@ -5940,12 +6050,16 @@ msgstr "" "}\n" "```" -#: src/structs.md:31 src/enums.md:34 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 +#: src/structs.md:31 +#: src/enums.md:34 +#: 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:43 msgid "Key Points:" -msgstr "Pontos chave:" +msgstr "Pontos Chave:" #: src/structs.md:33 msgid "" @@ -7736,7 +7850,7 @@ msgstr "" #: src/control-flow.md:1 msgid "# Control Flow" -msgstr "# Controle de fluxo" +msgstr "# Controle de Fluxo" #: src/control-flow.md:3 msgid "" @@ -7745,9 +7859,9 @@ msgid "" "the value of the `if` expression. Other control flow expressions work similarly\n" "in Rust." msgstr "" -"Como vimos, `if` é uma expressão em Rust. É usado para condicionalmente\n" -"avaliar um dos dois blocos, mas os blocos podem ter um valor que então se torna\n" -"o valor da expressão `if`. Outras expressões de fluxo de controle funcionam de forma semelhante\n" +"Como vimos, `if` é uma expressão em Rust. É usado para avaliar\n" +"condicionalmente um de dois blocos, mas os blocos podem ter um valor que então se torna\n" +"o valor da expressão `if`. Outras expressões de controle de fluxo funcionam de forma semelhante\n" "em Rust." #: src/control-flow/blocks.md:1 @@ -7756,11 +7870,13 @@ msgstr "# Blocos" #: src/control-flow/blocks.md:3 msgid "" -"A block in Rust has a value and a type: the value is the last expression of the\n" -"block:" +"A block in Rust contains a sequence of expressions.\n" +"Each block has a value and a type,\n" +"which are those of the last expression of the block:" msgstr "" -"Um bloco em Rust tem um valor e um tipo: o valor é a última expressão do\n" -"bloco:" +"Um bloco em Rust contêm uma sequência de expressões.\n" +"Cada bloco tem um valor e um tipo,\n" +"os quais são os da última expressão do bloco:" #: src/control-flow/blocks.md:6 msgid "" @@ -7802,7 +7918,15 @@ msgstr "" "}\n" "```" -#: src/control-flow/blocks.md:25 +#: src/control-flow/blocks.md:26 +msgid "" +"If the last expression ends with `;`, then the resulting value and type is " +"`()`." +msgstr "" +"Se a última expressão terminar com `;`, o valor resultante e o tipo será " +"`()`." + +#: src/control-flow/blocks.md:28 msgid "" "The same rule is used for functions: the value of the function body is the\n" "return value:" @@ -7810,8 +7934,7 @@ msgstr "" "A mesma regra é usada para funções: o valor do corpo da função é o\n" "valor de retorno:" -#: src/control-flow/blocks.md:28 -#, fuzzy +#: src/control-flow/blocks.md:31 msgid "" "```rust,editable\n" "fn double(x: i32) -> i32 {\n" @@ -7823,33 +7946,33 @@ msgid "" "}\n" "```" msgstr "" +"```rust,editable\n" +"fn dobrar(x: i32) -> i32 {\n" +" x + x\n" +"}\n" +"\n" "fn main() {\n" -" println!(\"dobro: {}\", dobro(7));\n" +" println!(\"dobrado: {}\", dobrar(7));\n" "}\n" "```" -#: src/control-flow/blocks.md:38 -msgid "However if the last expression ends with `;`, then the resulting value and type is `()`." -msgstr "No entanto, se a última expressão terminar com `;` o valor e o tipo do retorno será `()`." - -#: src/control-flow/blocks.md:43 -#, fuzzy +#: src/control-flow/blocks.md:44 msgid "" -"* The point of this slide is to show that blocks have a type and value in Rust. \n" -"* You can show how the value of the block changes by changing the last line in the block. For " -"instance, adding/removing a semicolon or using a `return`.\n" +"* The point of this slide is to show that blocks have a type and value in " +"Rust. \n" +"* You can show how the value of the block changes by changing the last line " +"in the block. For instance, adding/removing a semicolon or using a " +"`return`.\n" " " msgstr "" -"Pontos chave:\n" "* O objetivo deste slide é mostrar que os blocos têm um tipo e um valor em Rust.\n" "* Você pode mostrar como o valor do bloco muda alterando a última linha do bloco. Por exemplo, " "adicionar/remover um ponto e vírgula (`;`) ou usar um `return`.\n" -" \n" -"
" +" " #: src/control-flow/if-expressions.md:1 msgid "# `if` expressions" -msgstr "# Expressões Se (`if`)" +msgstr "# Expressões `if`" #: src/control-flow/if-expressions.md:3 msgid "" @@ -7857,6 +7980,9 @@ msgid "" "expressions](https://doc.rust-lang.org/reference/expressions/if-expr.html#if-expressions)\n" "exactly like `if` statements in other languages:" msgstr "" +"Você usa [expressões `if`\n" +"](https://doc.rust-lang.org/reference/expressions/if-expr.html#if-expressions)\n" +"exatamente como declarações `if` em outras linguagens:" #: src/control-flow/if-expressions.md:7 msgid "" @@ -7883,11 +8009,12 @@ msgstr "" "```" #: src/control-flow/if-expressions.md:18 -#, fuzzy msgid "" "In addition, you can use `if` as an expression. The last expression of each\n" "block becomes the value of the `if` expression:" -msgstr "Além disso, você pode usá-lo como uma expressão. Isso faz o mesmo que acima:" +msgstr "" +"Além disso, você pode usá-lo como uma expressão. A última expressão de cada\n" +"bloco se torna o valor da expressão `if`" #: src/control-flow/if-expressions.md:22 msgid "" @@ -7914,20 +8041,16 @@ msgstr "" "```" #: src/control-flow/if-expressions.md:35 -#, fuzzy msgid "" "Because `if` is an expression and must have a particular type, both of its branch blocks must have " "the same type. Consider showing what happens if you add `;` after `x / 2` in the second example." msgstr "" "Como `if` é uma expressão e deve ter um tipo específico, ambos os blocos de ramificação devem ter " -"o mesmo tipo. Considere mostrar o que acontece se você adicionar um `;` depois de `x / 2` no " -"segundo exemplo.\n" -" \n" -"" +"o mesmo tipo. Considere mostrar o que acontece se você adicionar um `;` depois de `x / 2` no segundo exemplo." #: src/control-flow/if-let-expressions.md:1 msgid "# `if let` expressions" -msgstr "# Expressões Se (`if let`)" +msgstr "# Expressões `if let`" #: src/control-flow/if-let-expressions.md:3 msgid "" @@ -7935,6 +8058,9 @@ msgid "" "expression](https://doc.rust-lang.org/reference/expressions/if-expr.html#if-let-expressions)\n" "lets you execute different code depending on whether a value matches a pattern:" msgstr "" +"A [expressão `if let`\n" +"](https://doc.rust-lang.org/reference/expressions/if-expr.html#if-let-expressions)\n" +"lhe permite que você execute um código diferente, dependendo se um valor corresponde a um padrão:" #: src/control-flow/if-let-expressions.md:7 msgid "" @@ -7952,33 +8078,37 @@ msgstr "" "```rust, editable\n" "fn main() {\n" " let arg = std::env::args().next();\n" -" if let Some(value) = arg {\n" -" println!(\"nome do programa: {value}\");\n" +" if let Some(valor) = arg {\n" +" println!(\"Nome do programa: {valor}\");\n" " } else {\n" " println!(\"Falta o nome?\");\n" " }\n" "}\n" "```" -#: src/control-flow/if-let-expressions.md:18 src/control-flow/while-let-expressions.md:21 +#: src/control-flow/if-let-expressions.md:18 +#: src/control-flow/while-let-expressions.md:21 #: src/control-flow/match-expressions.md:23 msgid "" -"See [pattern matching](../pattern-matching.md) for more details on patterns in\n" +"See [pattern matching](../pattern-matching.md) for more details on patterns " +"in\n" "Rust." msgstr "" -"Consulte [correspondência de padrões](../pattern-matching.md) para obter mais detalhes sobre " -"padrões em\n" +"Consulte [correspondência de padrões (_pattern matching_)](../pattern-matching.md) para obter mais detalhes sobre padrões em\n" "Rust." #: src/control-flow/if-let-expressions.md:23 msgid "" -"* Unlike `match`, `if let` does not have to cover all branches. This can make it more concise than " -"`match`.\n" +"* Unlike `match`, `if let` does not have to cover all branches. This can " +"make it more concise than `match`.\n" "* A common usage is handling `Some` values when working with `Option`.\n" -"* Unlike `match`, `if let` does not support guard clauses for pattern matching.\n" -"* Since 1.65, a similar [let-else](https://doc.rust-lang.org/rust-by-example/flow_control/let_else." -"html) construct allows to do a destructuring assignment, or if it fails, have a non-returning " -"block branch (panic/return/break/continue):\n" +"* Unlike `match`, `if let` does not support guard clauses for pattern " +"matching.\n" +"* Since 1.65, a similar " +"[let-else](https://doc.rust-lang.org/rust-by-example/flow_control/let_else.html) " +"construct allows to do a destructuring assignment, or if it fails, execute a " +"block which is required to abort normal control flow (with " +"`panic`/`return`/`break`/`continue`):\n" "\n" " ```rust,editable\n" " fn main() {\n" @@ -7993,11 +8123,30 @@ msgid "" " Some(item.to_uppercase())\n" " }" msgstr "" +"* Ao contrário de `match`, `if let` não precisa cobrir todas as ramificações. Isso pode torná-lo mais conciso do que " +"`match`.\n" +"* Um uso comum é lidar com valores `Some` ao trabalhar com `Option`.\n" +"* Ao contrário de `match`, `if let` não suporta cláusulas de guarda para correspondência de padrões.\n" +"* Desde 1.65, uma construção [let-else](https://doc.rust-lang.org/rust-by-example/flow_control/let_else) semelhante " +"permite fazer uma atribuição de desestruturação, ou se falhar, ter um bloco de ramificação " +"sem retorno (`panic`/`return`/`break`/`continue`):\n" +"\n" +" ```rust,editable\n" +" fn main() {\n" +" println!(\"{:?}\", segunda_palavra_para_maiusculas(\"foo bar\"));\n" +" }\n" +" \n" +" fn segunda_palavra_para_maiusculas(s: &str) -> Option {\n" +" let mut it = s.split(' ');\n" +" let (Some(_), Some(item)) = (it.next(), it.next()) else {\n" +" return None;\n" +" };\n" +" Some(item.to_uppercase())\n" +" }" #: src/control-flow/while-expressions.md:1 -#, fuzzy msgid "# `while` loops" -msgstr "# Expressões enquanto (`while`)" +msgstr "# _Loops_ (Laços) `while`" #: src/control-flow/while-expressions.md:3 msgid "" @@ -8005,6 +8154,9 @@ msgid "" "loops)\n" "works very similar to other languages:" msgstr "" +"A [palavra-chave `while`](https://doc.rust-lang.org/reference/expressions/loop-expr.html#predicate-" +"loops)\n" +"funciona de maneira muito similar a outras linguagens:" #: src/control-flow/while-expressions.md:6 msgid "" @@ -8037,22 +8189,20 @@ msgstr "" "```" #: src/control-flow/while-let-expressions.md:1 -#, fuzzy msgid "# `while let` loops" -msgstr "# Expressões enquanto (`while let`)" +msgstr "# _Loops_ (Laços) `while let`" #: src/control-flow/while-let-expressions.md:3 -#, fuzzy msgid "" "Like with `if let`, there is a [`while let`](https://doc.rust-lang.org/reference/expressions/loop-" "expr.html#predicate-pattern-loops)\n" "variant which repeatedly tests a value against a pattern:" msgstr "" -"Como com `if`, há uma variante `while let` que testa repetidamente se um valor\n" -"corresponde a um padrão:" +"Similar a `if let`, há uma variante [`while let`](https://doc.rust-lang.org/reference/expressions/loop-" +"expr.html#predicate-pattern-loops)\n" +"que testa repetidamente se um valor corresponde a um padrão:" #: src/control-flow/while-let-expressions.md:6 -#, fuzzy msgid "" "```rust,editable\n" "fn main() {\n" @@ -8065,10 +8215,16 @@ msgid "" "}\n" "```" msgstr "" -"```rust, editable\n" +"```rust,editable\n" "fn main() {\n" " let v = vec![10, 20, 30];\n" -" let mut iter = v.into_iter();" +" let mut iter = v.into_iter();\n" +"\n" +" while let Some(x) = iter.next() {\n" +" println!(\"x: {x}\");\n" +" }\n" +"}\n" +"```" #: src/control-flow/while-let-expressions.md:17 msgid "" @@ -8078,10 +8234,9 @@ msgid "" msgstr "" "Aqui o iterador retornado por `v.iter()` retornará uma `Option` em cada\n" "chamada para `next()`. Ele retorna `Some(x)` até que seja concluído e, em seguida, retorna \n" -"`None`. O `while let` nos permite continuar iterando por todos os itens, enquando houver." +"`None`. O `while let` nos permite continuar iterando por todos os itens." #: src/control-flow/while-let-expressions.md:26 -#, fuzzy msgid "" "* Point out that the `while let` loop will keep going as long as the value matches the pattern.\n" "* You could rewrite the `while let` loop as an infinite loop with an if statement that breaks when " @@ -8089,30 +8244,26 @@ msgid "" "above scenario.\n" " " msgstr "" -"* Saliente que o laço `while let` continuará enquanto o valor corresponder ao padrão.\n" -"* Você pode reescrever o laço `while let` como um laço infinito com uma instrução if que quebra " -"quando não há valor para desempacotar para `iter.next()`. O `while let` fornece açúcar sintático " +"* Ressalte que o loop `while let` continuará executando enquanto o valor corresponder ao padrão.\n" +"* Você pode reescrever o loop `while let` como um loop infinito com uma instrução `if` que é interrompido " +"quando não houver mais nenhum valor para desempacotar (_unwrap_) para `iter.next()`. O `while let` fornece um atalho " "para o cenário acima.\n" -" \n" -"" +" " #: src/control-flow/for-expressions.md:1 -#, fuzzy msgid "# `for` loops" -msgstr "## Laços `for`" +msgstr "# Loops (Laços) `for`" #: src/control-flow/for-expressions.md:3 -#, fuzzy msgid "" "The [`for` loop](https://doc.rust-lang.org/std/keyword.for.html) is closely\n" "related to the [`while let` loop](while-let-expressions.md). It will\n" "automatically call `into_iter()` on the expression and then iterate over it:" msgstr "" -"A expressão `for` está intimamente relacionada com a expressão `while let`. É\n" -"chamado automaticamente `into_iter()` na expressão e, em seguida, iterado sobre ela:" +"O loop `for` está intimamente relacionado com o [loop `while let`](while-let-expressions.md). Ele\n" +"chamará automaticamente `into_iter()` na expressão e, em seguida, iterará sobre ela:" #: src/control-flow/for-expressions.md:7 -#, fuzzy msgid "" "```rust,editable\n" "fn main() {\n" @@ -8128,6 +8279,10 @@ msgid "" "}\n" "```" msgstr "" +"```rust,editable\n" +"fn main() {\n" +" let v = vec![10, 20, 30];\n" +"\n" " for x in v {\n" " println!(\"x: {x}\");\n" " }\n" @@ -8140,10 +8295,9 @@ msgstr "" #: src/control-flow/for-expressions.md:21 msgid "You can use `break` and `continue` here as usual." -msgstr "Você pode usar `break` e `continue` aqui como de costume." +msgstr "Aqui você pode usar `break` e `continue` como de costume." #: src/control-flow/for-expressions.md:25 -#, fuzzy msgid "" "* 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" @@ -8151,17 +8305,15 @@ msgid "" "* 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" -" \n" "* A iteração de índice não é uma sintaxe especial no Rust apenas para esse caso.\n" -"* `(0..10)` é um intervalo que implementa uma característica `Iterator`.\n" -"* `step_by` é um método que retorna outro `Iterator` que pula todos os outros elementos.\n" -" \n" -"
" +"* `(0..10)` é um _range_ (intervalo) que implementa um trait `Iterator`.\n" +"* `step_by` é um método que retorna outro `Iterator` que pula outros elementos alternadamente.\n" +"* Modifique os elementos no vetor e explique os erros de compilação. Altere o vetor `v` para ser " +"mutável e o loop `for` para `for x in v.iter_mut()`." #: src/control-flow/loop-expressions.md:1 msgid "# `loop` expressions" -msgstr "# Expressões de laço (`loop`)" +msgstr "# Expressões `loop`" #: src/control-flow/loop-expressions.md:3 msgid "" @@ -8169,13 +8321,13 @@ msgid "" "html#infinite-loops)\n" "which creates an endless loop." msgstr "" +"Finalmente, há uma [palavra-chave `loop`](https://doc.rust-lang.org/reference/expressions/loop-expr.html#infinite-loops)\n" +"que cria um loop infinito." #: 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:" +"Aqui você deve usar `break` ou `return` para parar o loop:" #: src/control-flow/loop-expressions.md:8 msgid "" @@ -8196,6 +8348,22 @@ msgid "" "}\n" "```" msgstr "" +"```rust,editable\n" +"fn main() {\n" +" let mut x = 10;\n" +" loop {\n" +" x = if x % 2 == 0 {\n" +" x / 2\n" +" } else {\n" +" 3 * x + 1\n" +" };\n" +" if x == 1 {\n" +" break;\n" +" }\n" +" }\n" +" println!(\"X final: {x}\");\n" +"}\n" +"```" #: src/control-flow/loop-expressions.md:27 msgid "" @@ -8204,19 +8372,23 @@ msgid "" " value. This is because it's guaranteed to be entered at least once (unlike\n" " `while` and `for` loops)." msgstr "" +"* Interrompa o `loop` com um valor (por exemplo, `break 8`) e imprima-o.\n" +"* Observe que `loop` é a única construção de loop que retorna um valor não trivial\n" +" . Isso ocorre porque é garantido que ele será executado pelo menos uma vez (diferente de\n" +" loops `while` e `for`)." #: src/control-flow/match-expressions.md:1 msgid "# `match` expressions" -msgstr "# Expressões de correspondência (`match`)" +msgstr "# Expressões `match` (Correspondência)" #: src/control-flow/match-expressions.md:3 -#, fuzzy msgid "" "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" +"A [palavra-chave `match`](https://doc.rust-lang.org/reference/expressions/match-expr.html)\n" +"é 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:7 @@ -8238,11 +8410,11 @@ msgstr "" "fn main() {\n" " match std::env::args().next().as_deref() {\n" " Some(\"gato\") => println!(\"Vai fazer coisas de gato\"),\n" -" Some(\"ls\") => println!(\"Serão alguns arquivos\"),\n" -" Some(\"mv\") => println!(\"Vamos mover alguns arquivos\"),\n" -" Some(\"rm\") => println!(\"Uh, perigoso!\"),\n" -" None => println!(\"Hmm, nenhum nome de programa?\"),\n" -" _ => println!(\"Nome de programa desconhecido!\"),\n" +" Some(\"ls\") => println!(\"Vou ls alguns arquivos\"),\n" +" Some(\"mv\") => println!(\"Vamos mover alguns arquivos\"),\n" +" Some(\"rm\") => println!(\"Uh, perigoso!\"),\n" +" None => println!(\"Hmm, nenhum nome de programa?\"),\n" +" _ => println!(\"Nome de programa desconhecido!\"),\n" " }\n" "}\n" "```" @@ -8252,11 +8424,10 @@ 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 `()`." msgstr "" -"Como `if let`, cada braço de correspondência deve ter o mesmo tipo. O tipo é a última\n" +"Assim 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:28 -#, fuzzy msgid "" "* Save the match expression to a variable and print it out.\n" "* Remove `.as_deref()` and explain the error.\n" @@ -8266,20 +8437,17 @@ msgid "" "`Option` into `Option<&str>`.\n" " * We can now use pattern matching to match against the `&str` inside `Option`." msgstr "" -"
\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 " +" * `std::env::Args().next()` retorna um `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" -" * Agora podemos usar a correspondência de padrões em um `&str` dentro de um `Option`.\n" -"
" +" * `as_deref()` transforma um `Option` em `Option<&T::Target>`. Em nosso caso, isso transforma " +"um `Option` em `Option<&str>`.\n" +" * Agora podemos usar a correspondência de padrões em um `&str` dentro de `Option`." #: src/control-flow/break-continue.md:1 msgid "# `break` and `continue`" -msgstr "# Interromper (`break`) e Continuar (`continue`)" +msgstr "# `break` e `continue`" #: src/control-flow/break-continue.md:3 msgid "" @@ -8289,16 +8457,19 @@ msgid "" "the next iteration use [`continue`](https://doc.rust-lang.org/reference/expressions/loop-expr." "html#continue-expressions)." msgstr "" +"- Se você quiser sair de um loop cedo, use [`break`](https://doc.rust-lang.org/reference/expressions/" +"loop-expr.html#break-expressions).\n" +"- Se você quiser iniciar imediatamente\n" +"a próxima iteração use [`continue`](https://doc.rust-lang.org/reference/expressions/loop-expr." +"html#continue-expressions)." #: 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:" +"Ambos `continue` e `break` podem opcionalmente receber um _label_ (rótulo) como argumento\n" +"que é usado para sair de loops aninhados:" #: src/control-flow/break-continue.md:10 msgid "" @@ -8340,11 +8511,11 @@ msgstr "" #: 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." +msgstr "Neste caso, paramos o loop externo após 3 iterações do loop interno." #: src/std.md:1 msgid "# Standard Library" -msgstr "# Biblioteca padrão" +msgstr "# Biblioteca Padrão" #: src/std.md:3 msgid "" @@ -8352,13 +8523,13 @@ msgid "" "used by Rust library and programs. This way, two libraries can work together\n" "smoothly because they both use the same `String` type." msgstr "" -"Rust vem com uma biblioteca padrão que ajuda a estabelecer um conjunto de tipos comuns\n" -"usados pela biblioteca e programas Rust. Dessa forma, duas bibliotecas podem trabalhar juntas\n" -"sem problemas porque ambos usam o mesmo tipo `String`." +"Rust vem com uma biblioteca padrão (_standard library_) que ajuda a estabelecer um conjunto de tipos comuns\n" +"usados por bibliotecas e programas Rust. Dessa forma, duas bibliotecas podem trabalhar juntas\n" +"sem problemas porque ambas usam o mesmo tipo `String`." #: src/std.md:7 msgid "The common vocabulary types include:" -msgstr "As palavras reservadas de tipo comuns incluem:" +msgstr "Os tipos de vocabulário comuns incluem:" #: src/std.md:9 msgid "" @@ -8376,9 +8547,21 @@ msgid "" "\n" "* [`Rc`](std/rc.md): a shared reference-counted pointer for heap-allocated data." msgstr "" +"* [`Option` e `Result`](std/option-result.md): tipos usados para valores opcionais\n" +" e [tratamento de erro](error-handling.md).\n" +"\n" +"* [`String`](std/string.md): o tipo de string padrão usado para dados _owned_.\n" +"\n" +"* [`Vec`](std/vec.md): um vetor extensível padrão.\n" +"\n" +"* [`HashMap`](std/hashmap.md): um tipo de mapa de hash com um algoritmo de hash\n" +" configurável.\n" +"\n" +"* [`Box`](std/box.md): um ponteiro _owned_ para dados alocados em heap.\n" +"\n" +"* [`Rc`](std/rc.md): um ponteiro de contagem de referência compartilhado para dados alocados em heap." #: src/std.md:25 -#, fuzzy msgid "" " * 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" @@ -8386,9 +8569,7 @@ msgid "" " * `alloc` includes types which require a global heap allocator, such as `Vec`, `Box` and `Arc`.\n" " * Embedded Rust applications often only use `core`, and sometimes `alloc`." msgstr "" -"
\n" -" \n" -" * Na verdade, Rust contém várias camadas da Biblioteca Padrão: `core`, `alloc` e `std`.\n" +" * Na verdade, o Rust contém várias camadas de Biblioteca Padrão: `core`, `alloc` e `std`.\n" " * `core` inclui os tipos e funções mais básicos que não dependem de `libc`, alocador ou\n" " até mesmo a presença de um sistema operacional.\n" " * `alloc` inclui tipos que requerem um alocador de heap global, como `Vec`, `Box` e `Arc`.\n" @@ -8403,7 +8584,6 @@ 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" @@ -8416,11 +8596,16 @@ msgid "" "}\n" "```" msgstr "" -"```rust, editable\n" +"```rust,editable\n" "fn main() {\n" " let numeros = vec![10, 20, 30];\n" " let primeiro: Option<&i8> = numeros.first();\n" -" println!(\"Primeiro: {primeiro:?}\");" +" println!(\"primeiro: {primeiro:?}\");\n" +"\n" +" let ind: Result = numeros.binary_search(&10);\n" +" println!(\"ind: {ind:?}\");\n" +"}\n" +"```" #: src/std/option-result.md:18 msgid "" @@ -8432,8 +8617,8 @@ msgid "" " * Otherwise, `Result::Err` contains the index where such an element should be inserted." msgstr "" "* `Option` e `Result` são amplamente usados não apenas na biblioteca padrão.\n" -"* `Option<&T>` tem sobrecarga de espaço zero em comparação com `&T`.\n" -"* `Result` é o tipo padrão para implementar o tratamento de erros, como veremos no Dia 3.\n" +"* `Option<&T>` não tem nenhum custo adicional de espaço em comparação com `&T`.\n" +"* `Result` é o tipo padrão para implementar tratamento de erros, como veremos no Dia 3.\n" "* `binary_search` retorna `Result`.\n" " * Se encontrado, `Result::Ok` contém o índice onde o elemento foi encontrado.\n" " * Caso contrário, `Result::Err` contém o índice onde tal elemento deve ser inserido." @@ -8465,6 +8650,22 @@ msgid "" "}\n" "```" msgstr "" +"```rust,editable\n" +"fn main() {\n" +" let mut s1 = String::new();\n" +" s1.push_str(\"Olá\");\n" +" println!(\"s1: tam = {}, capacidade = {}\", 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: tam = {}, capacidade = {}\", s2.len(), s2.capacity());\n" +"\n" +" let s3 = String::from(\"🇧🇷\");\n" +" println!(\"s3: tam = {}, número de caracteres = {}\", s3.len(),\n" +" s3.chars().count());\n" +"}\n" +"```" #: src/std/string.md:22 msgid "" @@ -8472,7 +8673,7 @@ msgid "" "`str` methods on a `String`." msgstr "" "`String` implementa [`Deref`][2], o que significa que você pode chamar todos\n" -"os métodos contidos em `str` em uma `String`." +"os métodos de `str` em uma `String`." #: src/std/string.md:30 msgid "" @@ -8495,6 +8696,20 @@ msgid "" " * 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 "" +"* `String::new` retorna uma nova string vazia, use `String::with_capacity` quando você sabe a quantidade de dados que você deseja colocar na string.\n" +"* `String::len` retorna o tamanho da `String` em bytes (que pode ser diferente de seu comprimento em caracteres).\n" +"* `String::chars` retorna um iterador com os caracteres de fato. Observe que um `char` pode ser diferente do que um humano considerará um \"caracter\" devido a " +"[agrupamentos de grafemas (_grapheme clusters_)](https://docs.rs/unicode-segmentation/latest/unicode_segmentation/struct.Graphemes.html).\n" +"* Quando as pessoas se referem a strings, elas podem estar falando sobre `&str` ou `String`.\n" +"* Quando um tipo implementa `Deref`, o compilador permitirá que você transparentemente chame métodos " +"de `T`.\n" +" * `String` implementa `Deref` que, de forma transparente, dá acesso aos métodos de `str`.\n" +" * Escreva e compare `let s3 = s1.deref();` e `let s3 = &*s1;`.\n" +"* `String` é implementado como um wrapper em torno de um vetor de bytes, muitas das operações que você vê " +"suportados em vetores também são suportadas em `String`, mas com algumas garantias extras.\n" +"* Compare as diferentes formas de indexar uma `String`:\n" +" * Para um caracter usando `s3.chars().nth(i).unwrap()` onde `i` está dentro dos limites, fora dos limites.\n" +" * Para uma substring usando `s3[0..4]`, onde essa _slice_ está nos limites dos caracteres ou não." #: src/std/vec.md:1 msgid "# `Vec`" @@ -8530,14 +8745,36 @@ msgid "" "}\n" "```" 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());\n" +"\n" +" 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" +" // Macro canônica para inicializar um vetor com elementos.\n" +" let mut v3 = vec![0, 0, 1, 2, 3, 4];\n" +"\n" +" // Mantém apenas os elementos pares.\n" +" v3.retain(|x| x % 2 == 0);\n" +" println!(\"{v3:?}\");\n" +"\n" +" // Remove duplicatas consecutivas.\n" +" v3.dedup();\n" +" println!(\"{v3:?}\");\n" +"}\n" +"```" #: src/std/vec.md:29 msgid "" "`Vec` implements [`Deref`][2], which means that you can call slice\n" "methods on a `Vec`." msgstr "" -"`Vec` implementa [`Deref`][2], o que significa que você pode chamar métodos de " -"slice\n" +"`Vec` implementa [`Deref`][2], o que significa que você pode chamar métodos de _slice_\n" "em um `Vec`." #: src/std/vec.md:37 @@ -8557,22 +8794,17 @@ msgid "" "* Show iterating over a vector and mutating the value:\n" " `for e in &mut v { *e += 50; }`" msgstr "" -"
\n" -" \n" "* `Vec` é um tipo de coleção, como `String` e `HashMap`. Os dados que ele contém são armazenados\n" -" no heap. Isso significa que a quantidade de dados não precisa ser conhecida em tempo de " -"compilação. Pode crescer\n" +" no heap. Isso significa que a quantidade de dados não precisa ser conhecida em tempo de compilação. Ela pode crescer\n" " ou encolher em tempo de execução.\n" -"* Observe como `Vec` também é um tipo genérico, mas você não precisa especificar `T` " -"explicitamente. Como sempre,\n" -" com a inferência de tipo Rust, o `T` foi estabelecido durante a primeira chamada `push`.\n" -"* `vec![...]` é uma macro canônica para usar em vez de `Vec::new()` e suporta adicionar elementos\n" +"* Observe como `Vec` também é um tipo genérico, mas você não precisa especificar `T` explicitamente. Como sempre,\n" +" com a inferência de tipos do Rust, `T` foi estabelecido durante a primeira chamada de `push`.\n" +"* `vec![...]` é uma macro canônica para usar em vez de `Vec::new()` e suporta a adição de elementos\n" " iniciais ao vetor.\n" -"* Para indexar o vetor, você usa `[` `]`, mas uma excessão do tipo _pânico_ (`panic`) será gerada " -"se o índice estiver\n" +"* Para indexar o vetor, você usa `[` `]`, mas uma exceção do tipo _pânico_ (`panic`) será gerada se o índice estiver\n" "fora dos limites. Alternativamente, usando\n" -" `get` você obterá uma `Option`. A função `pop` removerá o último elemento.\n" -"* Mostrar iterando sobre um vetor e alterando o valor:\n" +" `get` você obterá um `Option`. A função `pop` removerá o último elemento.\n" +"* Mostre uma iteração sobre um vetor e alterando o valor:\n" " `for e in &mut v { *e += 50; }`" #: src/std/hashmap.md:1 @@ -8581,7 +8813,7 @@ msgstr "# `HashMap`" #: src/std/hashmap.md:3 msgid "Standard hash map with protection against HashDoS attacks:" -msgstr "Mapa de _hash_ padrão com proteção contra ataques HashDoS:" +msgstr "_Hash map_ (Mapa de _hash_) padrão com proteção contra ataques _HashDoS_:" #: src/std/hashmap.md:5 msgid "" @@ -8616,6 +8848,36 @@ msgid "" "}\n" "```" msgstr "" +"```rust,editable\n" +"use std::collections::HashMap;\n" +"\n" +"fn main() {\n" +" let mut contadores_paginas = HashMap::new();\n" +" contadores_paginas.insert(\"Adventures of Huckleberry Finn\".to_string(), 207);\n" +" contadores_paginas.insert(\"Grimms' Fairy Tales\".to_string(), 751);\n" +" contadores_paginas.insert(\"Pride and Prejudice\".to_string(), 303);\n" +"\n" +" if !contadores_paginas.contains_key(\"Les Misérables\") {\n" +" println!(\"Nós sabemos sobre livros {}, mas não Les Misérables.\",\n" +" contadores_paginas.len());\n" +" }\n" +"\n" +" for livro in [\"Pride and Prejudice\", \"Alice's Adventure in Wonderland\"] {\n" +" match contadores_paginas.get(livro) {\n" +" Some(paginas) => println!(\"{livro}: {paginas} páginas\"),\n" +" None => println!(\"{livro} é desconhecido.\")\n" +" }\n" +" }\n" +"\n" +" // Use o método .entry() para inserir um valor caso nada seja encontrado.\n" +" for livro in [\"Pride and Prejudice\", \"Alice's Adventure in Wonderland\"] {\n" +" let contador_paginas: &mut i32 = contadores_paginas.entry(livro.to_string()).or_insert(0);\n" +" *contador_paginas += 1;\n" +" }\n" +"\n" +" println!(\"{contadores_paginas:#?}\");\n" +"}\n" +"```" #: src/std/hashmap.md:38 msgid "" @@ -8650,6 +8912,37 @@ msgid "" " * Try removing `to_string()` from the example above and see if it still compiles. Where do you " "think we might run into issues?" msgstr "" +"* `HashMap` não está definido no prelúdio e precisa ser incluído no escopo.\n" +"* Tente as seguintes linhas de código. A primeira linha verá se um livro está no hash map e, caso não esteja, " +"retorna um valor alternativo. A segunda linha irá inserir o valor alternativo no hash map se " +"o livro não for encontrado.\n" +"\n" +"\n" +" ```rust,ignore\n" +" let pc1 = contadores_paginas\n" +" .get(\"Harry Potter and the Sorcerer's Stone \")\n" +" .unwrap_or(&336);\n" +" let pc2 = contadores_paginas\n" +" .entry(\"The Hunger Games\".to_string())\n" +" .or_insert(374);\n" +" ```\n" +"* Ao contrário de `vec!`, infelizmente não existe uma macro `hashmap!` padrão.\n" +" * Entretanto, desde o Rust 1.56, o HashMap implementa [`From<[(K, V); N]>`][1], o que nos permite " +"inicializar facilmente um hash map a partir de uma matriz literal:\n" +"\n" +" ```rust,ignore\n" +" let contadores_paginas = HashMap::from([\n" +" (\"Harry Potter and the Sorcerer's Stone\".to_string(), 336),\n" +" (\"The Hunger Games\".to_string(), 374),\n" +" ]);\n" +" ```\n" +"\n" +" * Alternativamente, o HashMap pode ser construído a partir de qualquer `Iterator` que produz tuplas de chave-valor.\n" +"* Estamos mostrando `HashMap`, e evite usar `&str` como chave para facilitar os exemplos. " +"É claro que o uso de referências em coleções pode ser feito,\n" +" mas isto pode levar a complicações com o verificador de empréstimos.\n" +" * Tente remover `to_string()` do exemplo acima e veja se ele ainda compila. Onde você " +"acha que podemos ter problemas?" #: src/std/box.md:1 msgid "# `Box`" @@ -8657,7 +8950,7 @@ msgstr "# `Box`" #: src/std/box.md:3 msgid "[`Box`][1] is an owned pointer to data on the heap:" -msgstr "[`Box`][1] é um ponteiro de propriedade para dados no heap:" +msgstr "[`Box`][1] é um ponteiro _owned_ para dados no heap:" #: src/std/box.md:5 msgid "" @@ -8691,7 +8984,7 @@ msgid "" "```" msgstr "" "```bob\n" -" Stack Heap\n" +" Pilha Heap\n" ".- - - - - - -. .- - - - - - -.\n" ": : : :\n" ": cinco : : :\n" @@ -8712,7 +9005,6 @@ msgstr "" "de `T` diretamente em um `Box`][2]." #: src/std/box.md:34 -#, fuzzy msgid "" "* `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 " @@ -8723,25 +9015,23 @@ msgid "" " * 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" +"* `Box` é parecido com `std::unique_ptr` em C++, exceto que ele é garantidamente não nulo.\n" +"* No exemplo acima, você pode até 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.
" +" * Precisa transferir o _ownership_ de um grande volume de dados. Ao invés de copiar grandes volumes de dados na pilha,\n" +"eles são armazenados usando uma `Box` no _heap_ e apenas o ponteiro é movido." #: src/std/box-recursive.md:1 msgid "# Box with Recursive Data Structures" -msgstr "# `Box` com estruturas de dados recursivas" +msgstr "# `Box` com Estruturas de Dados Recursivas" #: src/std/box-recursive.md:3 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" @@ -8756,14 +9046,20 @@ msgid "" "}\n" "```" msgstr "" +"```rust,editable\n" +"#[derive(Debug)]\n" +"enum List {\n" +" Cons(T, Box>),\n" +" Nil,\n" +"}\n" +"\n" "fn main() {\n" -" let list: List = List::Cons(1, Box::new(List::Cons(2, Box::new(List::Nil))));\n" -" println!(\"{list:?}\");\n" +" let lista: List = List::Cons(1, Box::new(List::Cons(2, Box::new(List::Nil))));\n" +" println!(\"{lista:?}\");\n" "}\n" "```" #: src/std/box-recursive.md:18 -#, fuzzy msgid "" "```bob\n" " Stack Heap\n" @@ -8779,44 +9075,45 @@ msgid "" "```" msgstr "" "```bob\n" -" Stack Heap\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" +" Pilha Heap\n" +".- - - - - - - - - - - - -. .- - - - - - - - - - - - - - - - - - - - - - - -.\n" +": : : :\n" +": lista : : :\n" +": +------+----+----+ : : +------+----+----+ +------+----+----+ :\n" +": | Cons | 1 | o--+----+-----+--->| Cons | 2 | o--+--->| Nil | // | // | :\n" +": +------+----+----+ : : +------+----+----+ +------+----+----+ :\n" +": : : :\n" +": : : :\n" +"'- - - - - - - - - - - - -' '- - - - - - - - - - - - - - - - - - - - - - - -'\n" "```" #: src/std/box-recursive.md:33 -#, fuzzy msgid "" -"* 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" +"* If `Box` was not used 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 (`List` " +"would be of infinite size).\n" "\n" -"* `Box` solves this problem as it has the same size as a regular pointer and just points at the " -"next\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.\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" +"* 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 "" -"
\n" -" \n" -"Se a `Box` não for usada aqui e tentarmos incorporar uma `List` diretamente na `List`,\n" -"o compilador não calcularia um tamanho fixo da estrutura na memória, pareceria infinito.\n" -" \n" -"`Box` resolve esse problema, pois tem o mesmo tamanho de um ponteiro normal e apenas aponta para o " +"Se a `Box` não for usada e tentarmos incorporar uma `List` diretamente na `List`,\n" +"o compilador não conseguiria calcular um tamanho fixo da _struct_ na memória (`List` teria tamanho infinito) .\n" +"\n" +"* `Box` resolve esse problema, pois tem o mesmo tamanho de um ponteiro normal e apenas aponta para o " "próximo\n" -"elemento da `List` na _heap_.\n" -" \n" -"
" +"elemento da `List` no _heap_.\n" +"\n" +"* Remova o `Box` na definição de `List` e mostre o erro de compilação. \"Recursive with " +"indirection\" (recursivo com indireção) é uma dica para que você talvez queira usar uma `Box` ou referência de alguma forma, ao invés de armazenar " +"um valor diretamente. \n" +" " #: src/std/box-niche.md:1 msgid "# Niche Optimization" @@ -8827,11 +9124,10 @@ msgid "" "A `Box` cannot be empty, so the pointer is always valid and non-`null`. This\n" "allows the compiler to optimize the memory layout:" msgstr "" -"Uma `Box` não pode estar vazia, então o ponteiro é sempre válido e não `nulo`. Isto\n" +"Uma `Box` não pode estar vazia, portanto o ponteiro é sempre válido e não nulo (`null`). Isto\n" "permite que o compilador otimize o layout da memória:" #: src/std/box-niche.md:19 -#, fuzzy msgid "" "```bob\n" " Stack Heap\n" @@ -8847,17 +9143,16 @@ msgid "" "```" msgstr "" "```bob\n" -" Stack Heap\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" +" Pilha Heap\n" +".- - - - - - - - - - - - -. .- - - - - - - - - - - - - - - - - - - - - - -.\n" +": : : :\n" +": lista : : :\n" +": +----+----+ : : +----+----+ +----+------+ :\n" +": | 1 | o--+-----------+-----+--->| 2 | o--+--->| // | null | :\n" +": +----+----+ : : +----+----+ +----+------+ :\n" +": : : :\n" +": : : :\n" +"`- - - - - - - - - - - - -' '- - - - - - - - - - - - - - - - - - - - - - -'\n" "```" #: src/std/rc.md:1 @@ -8873,7 +9168,6 @@ msgstr "" "os mesmos dados a partir de vários locais:" #: src/std/rc.md:6 -#, fuzzy msgid "" "```rust,editable\n" "use std::rc::Rc;\n" @@ -8887,12 +9181,15 @@ msgid "" "}\n" "```" msgstr "" -"```rust, editable\n" +"```rust,editable\n" +"use std::rc::Rc;\n" +"\n" "fn main() {\n" -" let x = 42;\n" -" let y = x;\n" -" println!(\"x: {x}\");\n" -" println!(\"y: {y}\");\n" +" let mut a = Rc::new(10);\n" +" let mut b = Rc::clone(&a);\n" +"\n" +" println!(\"a: {a}\");\n" +" println!(\"b: {b}\");\n" "}\n" "```" @@ -8904,40 +9201,46 @@ msgid "" "* You can *downgrade* a shared pointer into a [`Weak`][4] pointer to create cycles\n" " that will get dropped." msgstr "" -"Se você precisar alterar os dados dentro de um `Rc`, precisará agrupar os dados em\n" -"um tipo como [`Cell` ou `RefCell`][2]. Veja [`Arc`][3] se você estiver em um contexto multi-" -"threads.\n" -"Você pode regredir um ponteiro compartilhado dentro de um ponteiro [`Weak`][4] para criar ciclos\n" -"que serão descartados." +"* Se você precisar alterar os dados dentro de um `Rc`, precisará agrupar os dados em\n" +" um tipo como [`Cell` ou `RefCell`][2].\n" +"* Veja [`Arc`][3] se você estiver em um contexto multi-thread.\n" +"* Você pode *downgrade* um ponteiro compartilhado para um ponteiro [`Weak`][4] para criar ciclos\n" +" que serão descartados." #: 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" -"* `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" +"* `Rc`'s count ensures that its contained value is valid for as long as " +"there are references.\n" +"* `Rc` in Rust is like `std::shared_ptr` in C++.\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" "* 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" +"* 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 "" -"* Como `std::shared_ptr` do C++.\n" -"* `clone` é barato: cria um ponteiro para a mesma alocação e aumenta a contagem de referência.\n" -"* `make_mut` realmente clona o valor interno se necessário (\"clone-on-write\") e retorna uma " +"* O contador do `Rc` garante que os seus valores contidos sejam válidos enquanto houver referências.\n" +"* `Rc` em Rust é como `std::shared_ptr` em C++.\n" +"* `Rc::clone` é barato: ele cria um ponteiro para a mesma alocação e aumenta a contagem de referência. " +"Ele não faz um \"clone profundo\" (_deep clone_) e geralmente pode ser ignorado ao procurar problemas de desempenho " +"no código.\n" +"* `make_mut` realmente clona o valor interno se necessário (\"_clone-on-write_\") e retorna uma " "referência mutável.\n" -"* Você pode invocar `downgrade()` em um `Rc` para obter um objeto contador de referências `Weak` " -"para criar\n" +"* Use `Rc::strong_count` para verificar a contagem de referência.\n" +"* Compare os diferentes tipos de dados mencionados. `Box` permite empréstimos mutáveis e imutáveis que são impostos " +"em tempo de compilação. `RefCell` permite empréstimos mutáveis e imutáveis impostos em tempo de execução e irá lançar um " +"`panic` caso falhe.\n" +"* `Rc::downgrade` lhe fornece um objeto *contador de referências \"fraco\" (weak)* para criar\n" "ciclos que podem ser apropriadamente descartados (provavelmente combinados com `RefCell`)." #: src/std/rc.md:41 -#, fuzzy msgid "" "```rust,editable\n" "use std::rc::{Rc, Weak};\n" @@ -8967,18 +9270,33 @@ msgid "" "}\n" "```" msgstr "" +"```rust,editable\n" +"use std::rc::{Rc, Weak};\n" +"use std::cell::RefCell;\n" +"\n" +"#[derive(Debug)]\n" +"struct Node {\n" +" valor: i64,\n" +" pai: Option>>,\n" +" filhos: Vec>>,\n" +"}\n" +"\n" "fn main() {\n" -" let mut raiz = Rc::new(RefCell::new(No {\n" +" let mut raiz = Rc::new(RefCell::new(Node {\n" " valor: 42,\n" " pai: None,\n" " filhos: vec![],\n" " }));\n" -" let filho = Rc::new(RefCell::new(No {\n" +" let filho = Rc::new(RefCell::new(Node {\n" " valor: 43,\n" " filhos: vec![],\n" " pai: Some(Rc::downgrade(&raiz))\n" " }));\n" -" raiz.borrow_mut().filhos.push(filho);" +" raiz.borrow_mut().filhos.push(filho);\n" +"\n" +" println!(\"Grafo: {raiz:#?}\");\n" +"}\n" +"```" #: src/modules.md:1 msgid "# Modules" @@ -8987,12 +9305,11 @@ msgstr "# Módulos" #: src/modules.md:3 msgid "We have seen how `impl` blocks let us namespace functions to a type." msgstr "" -"Vimos como os blocos `impl` nos permitem funções de usando espaços de nomes (_namespace_) para um " -"tipo." +"Vimos como os blocos `impl` nos permitem usar _namespaces_ (espaços de nomes) de funções para um tipo." #: src/modules.md:5 msgid "Similarly, `mod` lets us namespace types and functions:" -msgstr "Da mesma forma, `mod` nos permite tipos e funções usando espaço de nomes:" +msgstr "Da mesma forma, `mod` nos permite usar _namespaces_ de tipos e funções:" #: src/modules.md:7 msgid "" @@ -9015,9 +9332,26 @@ msgid "" "}\n" "```" msgstr "" +"```rust,editable\n" +"mod foo {\n" +" pub fn faz_algo() {\n" +" println!(\"No módulo foo\");\n" +" }\n" +"}\n" +"\n" +"mod bar {\n" +" pub fn faz_algo() {\n" +" println!(\"No módulo bar\");\n" +" }\n" +"}\n" +"\n" +"fn main() {\n" +" foo::faz_algo();\n" +" bar::faz_algo();\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" @@ -9025,11 +9359,11 @@ msgid "" "compiles to a library.\n" "* 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" -"* Módulos definem a organização, o escopo e são o foco desta sessão." +"* Pacotes (_packages_) fornecem funcionalidades e incluem um arquivo `Cargo.toml` que descreve como " +"gerar um pacote com um ou mais _crates_.\n" +"* _Crates_ são arvores de módulos, onde um _crate_ binário cria um executável e um _crate_ de " +"biblioteca é compilado em uma biblioteca.\n" +"* Módulos definem organização, escopo e são o foco desta seção." #: src/modules/visibility.md:1 msgid "# Visibility" @@ -9037,7 +9371,7 @@ msgstr "# Visibilidade" #: src/modules/visibility.md:3 msgid "Modules are a privacy boundary:" -msgstr "Os módulos são um limitador de privacidade:" +msgstr "Módulos são limitadores de privacidade:" #: src/modules/visibility.md:5 msgid "" @@ -9046,8 +9380,10 @@ msgid "" "* In other words, if an item is visible in module `foo`, it's visible in all the\n" " descendants of `foo`." msgstr "" -"* Os itens do módulo são privados por padrão (ocultam detalhes de implementação).\n" -"* Os itens pai e irmão estão sempre visíveis." +"* Itens do módulo são privados por padrão (ocultam detalhes de implementação).\n" +"* Itens paternos e fraternos são sempre visíveis.\n" +"* Em outras palavras, se um item é visível no módulo `foo`, ele é visível em todos os\n" +" descendentes de `foo`." #: src/modules/visibility.md:10 msgid "" @@ -9078,21 +9414,45 @@ msgid "" "}\n" "```" msgstr "" +"```rust,editable\n" +"mod externo {\n" +" fn privado() {\n" +" println!(\"externo::privado\");\n" +" }\n" +"\n" +" pub fn publico() {\n" +" println!(\"externo::publico\");\n" +" }\n" +"\n" +" mod interno {\n" +" fn privado() {\n" +" println!(\"externo::interno::privado\");\n" +" }\n" +"\n" +" pub fn publico() {\n" +" println!(\"externo::interno::publico\");\n" +" super::privado();\n" +" }\n" +" }\n" +"}\n" +"\n" +"fn main() {\n" +" externo::publico();\n" +"}\n" +"```" #: src/modules/visibility.md:39 -#, fuzzy msgid "* Use the `pub` keyword to make modules public." -msgstr "* Use a palavra reservada `pub` para tornar um módulo público." +msgstr "* Use a palavra reservada `pub` para tornar módulos públicos." #: 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" -"escopo da visibilidade pública." +"* Adicionamente, existem especificadores `pub(...)` avançados para restringir o\n" +"escopo de 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" @@ -9102,21 +9462,19 @@ msgid "" msgstr "" "* 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" +"* A configuração de visibilidade `pub(crate)` é um padrão comum.\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)." +"* Em todo caso, a visibilidade deve ser concedida a um módulo ancestral (e a todos os seus descendentes)." #: src/modules/paths.md:1 msgid "# Paths" -msgstr "# Caminhos (paths)" +msgstr "# Caminhos (_Paths_)" #: src/modules/paths.md:3 msgid "Paths are resolved as follows:" -msgstr "Os caminhos são resolvidos da seguinte forma:" +msgstr "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" @@ -9126,8 +9484,12 @@ msgid "" " * `crate::foo` refers to `foo` in the root of the current crate,\n" " * `bar::foo` refers to `foo` in the `bar` crate." msgstr "" +"1. Como um caminho relativo:\n" +" * `foo` ou `self::foo` referem-se à `foo` no módulo atual,\n" +" * `super::foo` refere-se à `foo` no módulo pai.\n" +"\n" "2. Como um caminho absoluto:\n" -" * `crate::foo` refere-se a `foo` na raiz do _crate_ atual,\n" +" * `crate::foo` refere-se à `foo` na raiz do _crate_ atual,\n" " * `bar::foo` refere-se a `foo` no _crate_ `bar`." #: src/modules/paths.md:13 @@ -9135,9 +9497,10 @@ 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 "" +"Um módulo pode trazer símbolos de outro módulo para o escopo com `use`.\n" +"Normalmente, você verá algo assim na parte superior de cada módulo:" #: src/modules/paths.md:16 -#, fuzzy msgid "" "```rust,editable\n" "use std::collections::HashSet;\n" @@ -9145,11 +9508,13 @@ msgid "" "```" msgstr "" "```rust,editable\n" -"use std::collections::HashMap;" +"use std::collections::HashSet;\n" +"use std::mem::transmute;\n" +"```" #: src/modules/filesystem.md:1 msgid "# Filesystem Hierarchy" -msgstr "# Hierarquia do sistema de arquivos" +msgstr "# Hierarquia do Sistema de Arquivos" #: src/modules/filesystem.md:3 msgid "The module content can be omitted:" @@ -9162,32 +9527,32 @@ msgid "" "```" msgstr "" "```rust,editable,compile_fail\n" -"mod garden;\n" +"mod jardim;\n" "```" #: src/modules/filesystem.md:9 msgid "The `garden` module content is found at:" -msgstr "O conteúdo do módulo `garden` é encontrado em:" +msgstr "O conteúdo do módulo `jardim` é encontrado em:" #: src/modules/filesystem.md:11 msgid "" "* `src/garden.rs` (modern Rust 2018 style)\n" "* `src/garden/mod.rs` (older Rust 2015 style)" msgstr "" -"* `src/garden.rs` (estilo Rust 2018 moderno)\n" -"* `src/garden/mod.rs` (antigo estilo Rust 2015)" +"* `src/jardim.rs` (estilo Rust 2018 moderno)\n" +"* `src/jardim/mod.rs` (antigo estilo Rust 2015)" #: src/modules/filesystem.md:14 msgid "Similarly, a `garden::vegetables` module can be found at:" -msgstr "Da mesma forma, um módulo `garden::vegetables` pode ser encontrado em:" +msgstr "Da mesma forma, um módulo `jardim::vegetais` pode ser encontrado em:" #: src/modules/filesystem.md:16 msgid "" "* `src/garden/vegetables.rs` (modern Rust 2018 style)\n" "* `src/garden/vegetables/mod.rs` (older Rust 2015 style)" msgstr "" -"* `src/garden/vegetables.rs` (estilo Rust 2018 moderno)\n" -"* `src/garden/vegetables/mod.rs` (antigo estilo Rust 2015)" +"* `src/jardim/vegetais.rs` (estilo Rust 2018 moderno)\n" +"* `src/jardim/vegetais/mod.rs` (antigo estilo Rust 2015)" #: src/modules/filesystem.md:19 msgid "The `crate` root is in:" @@ -9206,6 +9571,8 @@ 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 "" +"Módulos definidos em arquivos também podem ser documentados usando \"comentários internos de documento\" (_inner doc comments_).\n" +"Estes documentam o item que os contém - neste caso, um módulo." #: src/modules/filesystem.md:27 msgid "" @@ -9224,6 +9591,20 @@ msgid "" "pub fn harvest(garden: &mut Garden) { todo!() }\n" "```" msgstr "" +"```rust,editable,compile_fail\n" +"//! Este módulo implementa o jardim, incluindo uma implementação de germinação\n" +"//! de alto desempenho.\n" +"\n" +"// Re-exporta tipos deste módulo.\n" +"pub use sementes::SementePacote;\n" +"pub use jardim::Jardim;\n" +"\n" +"/// Semeia os pacotes de semente fornecidos.\n" +"pub fn semear(sementes: Vec) { todo!() }\n" +"\n" +"/// Colhe os vegetais no jardim que está pronto.\n" +"pub fn colher(jardim: &mut Jardim) { todo!() }\n" +"```" #: src/modules/filesystem.md:44 msgid "" @@ -9255,6 +9636,33 @@ msgid "" " 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 "" +"* A mudança de `modulo/mod.rs` para `modulo.rs` não impede o uso de submódulos no Rust " +"2018.\n" +" (Isto era obrigatório no Rust 2015)\n" +"\n" +" O seguinte é válido:\n" +"\n" +" ```ignore\n" +" src/\n" +" ├── main.rs\n" +" ├── top_module.rs\n" +" └── top_module/\n" +" └── sub_module.rs\n" +" ```\n" +"\n" +"* A principal razão para a alteração é evitar muitos arquivos denominados `mod.rs`, que podem ser difíceis\n" +" de distinguir em IDEs.\n" +"\n" +"* Rust procurará módulos em `modulonome/mod.rs` e `modulonome.rs`, mas isso pode ser alterado\n" +" com uma diretiva de compilador:\n" +"\n" +" ```rust,ignore\n" +" #[caminho = \"algum/caminho.rs\"]\n" +" mod algum_modulo { }\n" +" ```\n" +"\n" +"Isto é útil, por exemplo, se você quiser colocar testes para um módulo em um arquivo chamado\n" +" `algum_modulo_teste.rs`, semelhante à convenção em Go." #: src/exercises/day-2/afternoon.md:1 msgid "# Day 2: Afternoon Exercises" @@ -9274,7 +9682,7 @@ msgid "" "validate credit card numbers. The algorithm takes a string as input and does the\n" "following to validate the credit card number:" msgstr "" -"O [algoritmo Luhn](https://en.wikipedia.org/wiki/Luhn_algorithm) é usado para\n" +"O [algoritmo de Luhn](https://en.wikipedia.org/wiki/Luhn_algorithm) é usado para\n" "validar números de cartão de crédito. O algoritmo recebe uma string como entrada e faz o\n" "seguinte para validar o número do cartão de crédito:" @@ -9292,6 +9700,17 @@ msgid "" "\n" "* The credit card number is valid if the sum ends with `0`." msgstr "" +"* Ignore todos os espaços. Rejeite número com menos de dois dígitos.\n" +"\n" +"* Movendo-se da direita para a esquerda, dobre cada segundo dígito: para o número `1234`,\n" +" dobramos `3` e `1`.\n" +"\n" +"* Depois de dobrar um dígito, some os dígitos. Portanto, dobrando `7` torna-se `14`, que\n" +" torna-se `5`.\n" +"\n" +"* Some todos os dígitos, dobrados ou não.\n" +"\n" +"* 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 "" @@ -9352,10 +9771,58 @@ msgid "" "fn main() {}\n" "```" msgstr "" +"```rust\n" +"// TODO: remova isto quando você estiver terminado com sua implementação.\n" +"#![allow(unused_variables, dead_code)]\n" +"\n" +"pub fn luhn(cc_numero: &str) -> bool {\n" +" unimplemented!()\n" +"}\n" +"\n" +"#[test]\n" +"fn teste_cc_numero_nao_digito() {\n" +" assert!(!luhn(\"foo\"));\n" +"}\n" +"\n" +"#[test]\n" +"fn teste_cc_numero_vazio() {\n" +" assert!(!luhn(\"\"));\n" +" assert!(!luhn(\" \"));\n" +" assert!(!luhn(\" \"));\n" +" assert!(!luhn(\" \"));\n" +"}\n" +"\n" +"#[test]\n" +"fn teste_cc_numero_digito_simples() {\n" +" assert!(!luhn(\"0\"));\n" +"}\n" +"\n" +"#[test]\n" +"fn teste_cc_numero_dois_digitos() {\n" +" assert!(luhn(\" 0 0 \"));\n" +"}\n" +"\n" +"#[test]\n" +"fn teste_cc_numero_valido() {\n" +" assert!(luhn(\"4263 9826 4026 9299\"));\n" +" assert!(luhn(\"4539 3195 0343 6467\"));\n" +" assert!(luhn(\"7992 7398 713\"));\n" +"}\n" +"\n" +"#[test]\n" +"fn teste_cc_numero_invalido() {\n" +" assert!(!luhn(\"4223 9826 4026 9299\"));\n" +" assert!(!luhn(\"4539 3195 0343 6476\"));\n" +" assert!(!luhn(\"8273 1232 7352 0569\"));\n" +"}\n" +"\n" +"#[allow(dead_code)]\n" +"fn main() {}\n" +"```" #: src/exercises/day-2/strings-iterators.md:1 msgid "# Strings and Iterators" -msgstr "# Strings e iteradores" +msgstr "# Strings e Iteradores" #: src/exercises/day-2/strings-iterators.md:3 msgid "" @@ -9364,9 +9831,9 @@ msgid "" "_request paths_. The path prefixes can contain a wildcard character which\n" "matches a full segment. See the unit tests below." msgstr "" -"Neste exercício, você está implementando um componente de roteamento de um servidor web. O\n" +"Neste exercício, você irá implementar um componente de roteamento de um servidor web. O\n" "servidor está configurado com um número de _prefixos de caminhos_ que são comparados\n" -"com os _caminhos pedidos_. Os prefixos de caminho podem conter um caractere curinga que\n" +"com os _caminhos requisitados_. Os prefixos de caminho podem conter um caractere curinga que\n" "corresponde a um segmento completo. Veja os testes unitários abaixo." #: src/exercises/day-2/strings-iterators.md:8 @@ -9421,6 +9888,47 @@ msgid "" "}\n" "```" msgstr "" +"```rust\n" +"// TODO: remova isto quando você estiver terminado com sua implementação.\n" +"#![allow(unused_variables, dead_code)]\n" +"\n" +"pub fn corresponde_prefixo(prefixo: &str, caminho_requisitado: &str) -> bool {\n" +" unimplemented!()\n" +"}\n" +"\n" +"#[test]\n" +"fn teste_corresponde_sem_curinga() {\n" +" assert!(corresponde_prefixo(\"/v1/editores\", \"/v1/editores\"));\n" +" assert!(corresponde_prefixo(\"/v1/editores\", \"/v1/editores/abc-123\"));\n" +" assert!(corresponde_prefixo(\"/v1/editores\", \"/v1/editores/abc/livros\"));\n" +"\n" +" assert!(!corresponde_prefixo(\"/v1/editores\", \"/v1\"));\n" +" assert!(!corresponde_prefixo(\"/v1/editores\", \"/v1/editoresLivros\"));\n" +" assert!(!corresponde_prefixo(\"/v1/editores\", \"/v1/pai/editores\"));\n" +"}\n" +"\n" +"#[test]\n" +"fn teste_corresponde_com_curinga() {\n" +" assert!(corresponde_prefixo(\n" +" \"/v1/editores/*/livros\",\n" +" \"/v1/editores/foo/livros\"\n" +" ));\n" +" assert!(corresponde_prefixo(\n" +" \"/v1/editores/*/livros\",\n" +" \"/v1/editores/bar/livros\"\n" +" ));\n" +" assert!(corresponde_prefixo(\n" +" \"/v1/editores/*/livros\",\n" +" \"/v1/editores/foo/livros/livro1\"\n" +" ));\n" +"\n" +" assert!(!corresponde_prefixo(\"/v1/editores/*/livros\", \"/v1/editores\"));\n" +" assert!(!corresponde_prefixo(\n" +" \"/v1/editores/*/livros\",\n" +" \"/v1/editores/foo/livrosPorAutor\"\n" +" ));\n" +"}\n" +"```" #: src/welcome-day-3.md:1 msgid "# Welcome to Day 3"