You've already forked comprehensive-rust
mirror of
https://github.com/google/comprehensive-rust.git
synced 2026-05-22 07:55:37 +02:00
pt-BR: Update and Complete chapters 15 to 17.2 (#922)
* pt-BR: update and translate chapters 15 to 17.2 * address the comments as you wish Thank you, @joaovicmendes !
This commit is contained in:
João Victor Mendes
committed by
GitHub
GitHub
parent
2f6c4f2226
commit
d0b1217c8c
+366
-160
@@ -2,7 +2,7 @@ msgid ""
|
||||
msgstr ""
|
||||
"Project-Id-Version: Comprehensive Rust 🦀\n"
|
||||
"POT-Creation-Date: \n"
|
||||
"PO-Revision-Date: 2023-06-29 13:11-0700\n"
|
||||
"PO-Revision-Date: 2023-07-07 14:39-0300\n"
|
||||
"Last-Translator: \n"
|
||||
"Language-Team: \n"
|
||||
"Language: pt_BR\n"
|
||||
@@ -265,11 +265,11 @@ msgstr "Sintaxe Abreviada de Campos"
|
||||
|
||||
#: src/SUMMARY.md:79
|
||||
msgid "Enums"
|
||||
msgstr "Enumerações (Enums)"
|
||||
msgstr "Enums"
|
||||
|
||||
#: src/SUMMARY.md:80
|
||||
msgid "Variant Payloads"
|
||||
msgstr "Variantes de Carga Útil (payload)"
|
||||
msgstr "Conteúdos Variantes"
|
||||
|
||||
#: src/SUMMARY.md:81
|
||||
msgid "Enum Sizes"
|
||||
@@ -6214,7 +6214,7 @@ msgstr ""
|
||||
|
||||
#: src/enums.md:1
|
||||
msgid "# Enums"
|
||||
msgstr "# Enumerações (Enums)"
|
||||
msgstr "# Enums"
|
||||
|
||||
#: src/enums.md:3
|
||||
msgid ""
|
||||
@@ -6740,9 +6740,29 @@ msgid ""
|
||||
"}\n"
|
||||
"```"
|
||||
msgstr ""
|
||||
"```rust,editable\n"
|
||||
"#[derive(Debug)]\n"
|
||||
"struct Pessoa {\n"
|
||||
" nome: String,\n"
|
||||
" idade: u8,\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"impl Pessoa {\n"
|
||||
" fn dizer_ola(&self) {\n"
|
||||
" println!(\"Olá, meu nome é {}\", self.nome);\n"
|
||||
" }\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"fn main() {\n"
|
||||
" let pedro = Pessoa {\n"
|
||||
" nome: String::from(\"Pedro\"),\n"
|
||||
" idade: 27,\n"
|
||||
" };\n"
|
||||
" pedro.dizer_ola();\n"
|
||||
"}\n"
|
||||
"```"
|
||||
|
||||
#: src/methods.md:31
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"* It can be helpful to introduce methods by comparing them to functions.\n"
|
||||
" * Methods are called on an instance of a type (such as a struct or enum), the first parameter "
|
||||
@@ -6762,25 +6782,17 @@ msgid ""
|
||||
"* We describe the distinction between method receivers next.\n"
|
||||
" "
|
||||
msgstr ""
|
||||
"Pontos chave:\n"
|
||||
"* Pode ser útil introduzir métodos comparando-os com funções.\n"
|
||||
" * Métodos são chamados em uma instância de um tipo (como struct ou enum), o primeiro parâmetro "
|
||||
"representa a instância como `self`.\n"
|
||||
" * Os desenvolvedores podem optar por usar métodos para aproveitar a sintaxe do receptor do "
|
||||
"método e ajudar a mantê-los mais organizados. Usando métodos, podemos manter todo o código de "
|
||||
"implementação em um local previsível.\n"
|
||||
" * Métodos são chamados em uma instância de um tipo (como _struct_ ou _enum_), o primeiro parâmetro representa a instância como `self`.\n"
|
||||
" * Os desenvolvedores podem optar por usar métodos para aproveitar a sintaxe do receptor do método e ajudar a mantê-los mais organizados. Usando métodos, "
|
||||
"podemos manter todo o código de implementação em um local previsível.\n"
|
||||
"* Destaque o uso da palavra-chave `self`, um receptor de método.\n"
|
||||
" * Mostre que é um termo abreviado para `self:&Self` e talvez mostre como o nome da struct também "
|
||||
"poderia ser usado.\n"
|
||||
" * Explique que `Self` é um apelido de tipo para o tipo em que o bloco `impl` está e pode ser "
|
||||
"usado em qualquer outro lugar no bloco.\n"
|
||||
" * Observe como _self_ é usado com outras _Structs_ e a notação de _ponto_ pode ser usada para se "
|
||||
"referir a campos individuais.\n"
|
||||
" * Este pode ser um bom momento para demonstrar como `&self` difere de `self` modificando o "
|
||||
"código e tentando executar `diz_ola` duas vezes.\n"
|
||||
" * Mostre que é um termo abreviado para `self:&Self` e talvez mostre como o nome da struct também poderia ser usado.\n"
|
||||
" * Explique que `Self` é um apelido de tipo para o tipo em que o bloco `impl` está e pode ser usado em qualquer outro lugar no bloco.\n"
|
||||
" * Observe como `self` é usado como outras _Structs_ e a notação de ponto pode ser usada para se referir a campos individuais.\n"
|
||||
" * Este pode ser um bom momento para demonstrar como `&self` difere de `self` modificando o código e tentando executar `dizer_ola` duas vezes.\n"
|
||||
"* Descreveremos a distinção entre os receptores de método a seguir.\n"
|
||||
" \n"
|
||||
"</details>"
|
||||
" "
|
||||
|
||||
#: src/methods/receiver.md:1
|
||||
msgid "# Method Receiver"
|
||||
@@ -6791,11 +6803,10 @@ msgid ""
|
||||
"The `&self` above indicates that the method borrows the object immutably. There\n"
|
||||
"are other possible receivers for a method:"
|
||||
msgstr ""
|
||||
"O `&self` acima indica que o método toma emprestado o objeto imutavelmente. Abaixo há\n"
|
||||
"O `&self` acima indica que o método toma emprestado o objeto imutavelmente. Existem\n"
|
||||
"outros receptores possíveis para um método:"
|
||||
|
||||
#: src/methods/receiver.md:6
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"* `&self`: borrows the object from the caller using a shared and immutable\n"
|
||||
" reference. The object can be used again afterwards.\n"
|
||||
@@ -6810,16 +6821,16 @@ msgid ""
|
||||
" create constructors which are called `new` by convention."
|
||||
msgstr ""
|
||||
"* `&self`: pega emprestado o objeto do chamador como uma referência compartilhada\n"
|
||||
" e mutável. O objeto pode ser usado novamente depois.\n"
|
||||
" e imutável. O objeto pode ser usado novamente depois.\n"
|
||||
"* `&mut self`: pega emprestado o objeto do chamador como uma referência única\n"
|
||||
" e mutável. O objeto pode ser usado novamente depois.\n"
|
||||
"* `self`: toma posse do objeto e o afasta do chamador.\n"
|
||||
"* `self`: toma posse do objeto e o move do chamador.\n"
|
||||
" O método se torna o proprietário do objeto. O objeto será descartado (desalocado)\n"
|
||||
" quando o método retorna, a menos que sua ownership seja explicitamente\n"
|
||||
" transmitida.\n"
|
||||
" quando o método retorna, a menos que sua _ownership_ (posse) seja explicitamente\n"
|
||||
" transmitida. Posse completa não significa automaticamente mutabilidade.\n"
|
||||
"* `mut self`: o mesmo que acima, mas enquanto o método possui o objeto, ele pode\n"
|
||||
" alterá-lo também. A ownership completa não significa automaticamente mutabilidade.\n"
|
||||
"* Sem receptor: isso se torna um método static na estrutura. Normalmente usado para\n"
|
||||
" alterá-lo também.\n"
|
||||
"* Sem receptor: isso se torna um método estático (_static_) na estrutura. Normalmente usado para\n"
|
||||
" criar construtores que, por convenção, são chamados `new`."
|
||||
|
||||
#: src/methods/receiver.md:18
|
||||
@@ -6829,26 +6840,19 @@ msgid ""
|
||||
"allowed to be receiver types, such as `Box<Self>`."
|
||||
msgstr ""
|
||||
"Além das variantes de `self`, também existem\n"
|
||||
"[tipos especiais de wrapper](https://doc.rust-lang.org/reference/special-types-and-traits.html)\n"
|
||||
"[tipos especiais de _wrapper_](https://doc.rust-lang.org/reference/special-types-and-traits.html)\n"
|
||||
"que podem ser tipos de receptores, como `Box<Self>`."
|
||||
|
||||
#: src/methods/receiver.md:24
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"Consider emphasizing \"shared and immutable\" and \"unique and mutable\". These constraints always "
|
||||
"come\n"
|
||||
"together in Rust due to borrow checker rules, and `self` is no exception. It isn't possible to\n"
|
||||
"reference a struct from multiple locations and call a mutating (`&mut self`) method on it."
|
||||
msgstr ""
|
||||
"<details>\n"
|
||||
" \n"
|
||||
"Considere enfatizar \"compartilhado e imutável\" e \"único e mutável\". Essas restrições sempre "
|
||||
"vêm\n"
|
||||
"juntos no Rust devido às regras do verificador de empréstimo, e `self` não é uma exceção. Não será "
|
||||
"possível\n"
|
||||
"referenciar um struct de vários locais e chamar um método mutável (`&mut self`) nele.\n"
|
||||
" \n"
|
||||
"</details>"
|
||||
"Considere enfatizar \"compartilhado e imutável\" e \"único e mutável\". Essas restrições sempre vêm\n"
|
||||
"juntos no Rust devido às regras do _Borrow Checker_ (verificador de empréstimo), e `self` não é uma exceção. Não será possível\n"
|
||||
"referenciar uma _struct_ de vários locais e chamar um método mutável (`&mut self`) nela."
|
||||
|
||||
#: src/methods/example.md:1 src/concurrency/shared_state/example.md:1
|
||||
msgid "# Example"
|
||||
@@ -6897,35 +6901,63 @@ msgid ""
|
||||
"}\n"
|
||||
"```"
|
||||
msgstr ""
|
||||
"```rust,editable\n"
|
||||
"#[derive(Debug)]\n"
|
||||
"struct Corrida {\n"
|
||||
" nome: String,\n"
|
||||
" voltas: Vec<i32>,\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"impl Corrida {\n"
|
||||
" fn new(nome: &str) -> Corrida { // Sem receptor, método estático\n"
|
||||
" Corrida { nome: String::from(nome), voltas: Vec::new() }\n"
|
||||
" }\n"
|
||||
"\n"
|
||||
" fn adicionar_volta(&mut self, volta: i32) { // Empréstimo único com acesso de leitura e escrita em self\n"
|
||||
" self.voltas.push(volta);\n"
|
||||
" }\n"
|
||||
"\n"
|
||||
" fn imprimir_voltas(&self) { // Empréstimo compartilhado com acesso apenas de leitura em self\n"
|
||||
" println!(\"Registrou {} voltas para {}:\", self.voltas.len(), self.nome);\n"
|
||||
" for (idx, volta) in self.voltas.iter().enumerate() {\n"
|
||||
" println!(\"Volta {idx}: {volta} seg\");\n"
|
||||
" }\n"
|
||||
" }\n"
|
||||
"\n"
|
||||
" fn encerrar(self) { // Propriedade exclusiva de self\n"
|
||||
" let total = self.voltas.iter().sum::<i32>();\n"
|
||||
" println!(\"Corrida {} foi encerrada, tempo de voltas total: {}\", self.nome, total);\n"
|
||||
" }\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"fn main() {\n"
|
||||
" let mut corrida = Corrida::new(\"Monaco Grand Prix\");\n"
|
||||
" corrida.adicionar_volta(70);\n"
|
||||
" corrida.adicionar_volta(68);\n"
|
||||
" corrida.imprimir_voltas();\n"
|
||||
" corrida.adicionar_volta(71);\n"
|
||||
" corrida.imprimir_voltas();\n"
|
||||
" corrida.encerrar();\n"
|
||||
" // corrida.adicionar_volta(42);\n"
|
||||
"}\n"
|
||||
"```"
|
||||
|
||||
#: src/methods/example.md:47
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"* All four methods here use a different method receiver.\n"
|
||||
" * You can point out how that changes what the function can do with the variable values and if/"
|
||||
"how it can be used again in `main`.\n"
|
||||
" * You can point out how that changes what the function can do with the variable values and if/how it can be used again in `main`.\n"
|
||||
" * You can showcase the error that appears when trying to call `finish` twice.\n"
|
||||
"* Note that although the method receivers are different, the non-static functions are called the "
|
||||
"same way in the main body. Rust enables automatic referencing and dereferencing when calling "
|
||||
"methods. Rust automatically adds in the `&`, `*`, `muts` so that that object matches the method "
|
||||
"signature.\n"
|
||||
"* You might point out that `print_laps` is using a vector that is iterated over. We describe "
|
||||
"vectors in more detail in the afternoon. "
|
||||
"* Note that although the method receivers are different, the non-static functions are called the same way in the main body. Rust enables automatic referencing "
|
||||
"and dereferencing when calling methods. Rust automatically adds in the `&`, `*`, `muts` so that that object matches the method signature.\n"
|
||||
"* You might point out that `print_laps` is using a vector that is iterated over. We describe vectors in more detail in the afternoon. "
|
||||
msgstr ""
|
||||
"<details>\n"
|
||||
" \n"
|
||||
"Pontos chave:\n"
|
||||
"* Todos os quatro métodos aqui usam um receptor de método diferente.\n"
|
||||
" * Você pode apontar como isso muda o que a função pode fazer com os valores das variáveis e se/"
|
||||
"como ela pode ser usada novamente em `main`.\n"
|
||||
" * Você pode mostrar o erro que aparece ao tentar chamar `finish` duas vezes.\n"
|
||||
"* Observe que, embora os receptores do método sejam diferentes, as funções não estáticas são "
|
||||
"chamadas da mesma maneira no corpo principal. Rust permite referenciar e desreferenciar "
|
||||
"automaticamente ao chamar métodos. Rust adiciona automaticamente `&`, `*`, `muts` para que esse "
|
||||
"objeto corresponda à assinatura do método.\n"
|
||||
"* Você pode apontar que `print_laps` está usando um vetor iterado. Descreveremos os vetores com "
|
||||
"mais\n"
|
||||
"detalhes à tarde."
|
||||
" * Você pode apontar como isso muda o que a função pode fazer com os valores das variáveis e se/como ela pode ser usada novamente na `main`.\n"
|
||||
" * Você pode mostrar o erro que aparece ao tentar chamar `encerrar` duas vezes.\n"
|
||||
"* Observe que, embora os receptores do método sejam diferentes, as funções não estáticas são chamadas da mesma maneira no corpo principal. Rust permite "
|
||||
"referenciar e desreferenciar automaticamente ao chamar métodos. Rust adiciona automaticamente `&`, `*`, `muts` para que esse objeto corresponda à assinatura do "
|
||||
"método.\n"
|
||||
"* Você pode apontar que `imprimir_voltas` está usando um vetor e iterando sobre ele. Descreveremos os vetores com mais detalhes à tarde. "
|
||||
|
||||
#: src/pattern-matching.md:1
|
||||
msgid "# Pattern Matching"
|
||||
@@ -6936,16 +6968,14 @@ msgid ""
|
||||
"The `match` keyword let you match a value against one or more _patterns_. The\n"
|
||||
"comparisons are done from top to bottom and the first match wins."
|
||||
msgstr ""
|
||||
"A palavra-chave `match` permite que você corresponda um valor a um ou mais _padrões_ (_patterns_). "
|
||||
"As\n"
|
||||
" comparações são feitas de cima para baixo e a primeira correspondência encontrada é selecionada."
|
||||
"A palavra-chave `match` permite que você corresponda um valor a um ou mais _padrões_ (_patterns_). As\n"
|
||||
"comparações são feitas de cima para baixo e a primeira correspondência encontrada é selecionada."
|
||||
|
||||
#: src/pattern-matching.md:6
|
||||
msgid "The patterns can be simple values, similarly to `switch` in C and C++:"
|
||||
msgstr "Os padrões podem ser valores simples, similarmente a `switch` em C e C++:"
|
||||
|
||||
#: src/pattern-matching.md:8
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"```rust,editable\n"
|
||||
"fn main() {\n"
|
||||
@@ -6960,11 +6990,15 @@ msgid ""
|
||||
"}\n"
|
||||
"```"
|
||||
msgstr ""
|
||||
" match input {\n"
|
||||
" 'q' => println!(\"Sair\"),\n"
|
||||
" 'a' | 's' | 'w' | 'd' => println!(\"Movendo-se\"),\n"
|
||||
" '0'..='9' => println!(\"Entrada numérica\"),\n"
|
||||
" _ => println!(\"Algo mais\"),\n"
|
||||
"```rust,editable\n"
|
||||
"fn main() {\n"
|
||||
" let entrada = 'x';\n"
|
||||
"\n"
|
||||
" match entrada {\n"
|
||||
" 'q' => println!(\"Encerrando\"),\n"
|
||||
" 'a' | 's' | 'w' | 'd' => println!(\"Movendo por ai\"),\n"
|
||||
" '0'..='9' => println!(\"Entrada de número\"),\n"
|
||||
" _ => println!(\"Alguma outra coisa\"),\n"
|
||||
" }\n"
|
||||
"}\n"
|
||||
"```"
|
||||
@@ -6974,39 +7008,30 @@ msgid "The `_` pattern is a wildcard pattern which matches any value."
|
||||
msgstr "O padrão `_` é um padrão curinga que corresponde a qualquer valor."
|
||||
|
||||
#: src/pattern-matching.md:26
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"* You might point out how some specific characters are being used when in a pattern\n"
|
||||
" * `|` as an `or`\n"
|
||||
" * `..` can expand as much as it needs to be\n"
|
||||
" * `1..=5` represents an inclusive range\n"
|
||||
" * `_` is a wild card\n"
|
||||
"* It can be useful to show how binding works, by for instance replacing a wildcard character with "
|
||||
"a variable, or removing the quotes around `q`.\n"
|
||||
"* It can be useful to show how binding works, by for instance replacing a wildcard character with a variable, or removing the quotes around `q`.\n"
|
||||
"* You can demonstrate matching on a reference.\n"
|
||||
"* This might be a good time to bring up the concept of irrefutable patterns, as the term can show "
|
||||
"up in error messages.\n"
|
||||
"* This might be a good time to bring up the concept of irrefutable patterns, as the term can show up in error messages.\n"
|
||||
" "
|
||||
msgstr ""
|
||||
"<details>\n"
|
||||
" \n"
|
||||
"Pontos chave:\n"
|
||||
"* Você pode apontar como alguns caracteres específicos podem ser usados em um padrão\n"
|
||||
" * `|` como um `ou`\n"
|
||||
" * `..` pode expandir o quanto for necessário\n"
|
||||
" * `1..=5` representa um intervalo inclusivo\n"
|
||||
" * `_` é um curinga\n"
|
||||
"* Pode ser útil mostrar como funciona a vinculação, por exemplo, substituindo um caractere curinga "
|
||||
"por uma variável ou removendo as aspas ao redor de `q`.\n"
|
||||
"* Pode ser útil mostrar como funciona a vinculação, por exemplo, substituindo um caractere curinga por uma variável ou removendo as aspas ao redor de `q`.\n"
|
||||
"* Você pode demonstrar correspondência em uma referência.\n"
|
||||
"* Este pode ser um bom momento para trazer à tona o conceito de padrões irrefutáveis, já que o "
|
||||
"termo pode aparecer em mensagens de erro.\n"
|
||||
" \n"
|
||||
"</details>"
|
||||
"* Este pode ser um bom momento para trazer à tona o conceito de padrões irrefutáveis, já que o termo pode aparecer em mensagens de erro.\n"
|
||||
" "
|
||||
|
||||
#: src/pattern-matching/destructuring-enums.md:1
|
||||
msgid "# Destructuring Enums"
|
||||
msgstr "# Desestruturando enunerações (Enums)"
|
||||
msgstr "# Desestruturando Enums"
|
||||
|
||||
#: src/pattern-matching/destructuring-enums.md:3
|
||||
msgid ""
|
||||
@@ -7017,7 +7042,6 @@ msgstr ""
|
||||
"que você inspeciona a estrutura de seus tipos. Vamos começar com um tipo `enum` simples:"
|
||||
|
||||
#: src/pattern-matching/destructuring-enums.md:6
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"```rust,editable\n"
|
||||
"enum Result {\n"
|
||||
@@ -7042,11 +7066,25 @@ msgid ""
|
||||
"}\n"
|
||||
"```"
|
||||
msgstr ""
|
||||
"```rust,editable\n"
|
||||
"enum Resultado {\n"
|
||||
" Ok(i32),\n"
|
||||
" Erro(String),\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"fn divide_em_dois(n: i32) -> Resultado {\n"
|
||||
" if n % 2 == 0 {\n"
|
||||
" Resultado::Ok(n / 2)\n"
|
||||
" } else {\n"
|
||||
" Resultado::Erro(format!(\"não é possível dividir {n} em duas partes iguais\"))\n"
|
||||
" }\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"fn main() {\n"
|
||||
" let n = 100;\n"
|
||||
" match divide_por_dois(n) {\n"
|
||||
" Result::Ok(metade) => println!(\"{n} dividido em dois é {metade}\"),\n"
|
||||
" Result::Err(msg) => println!(\"Desculpe, ocorreu um erro: {msg}\"),\n"
|
||||
" match divide_em_dois(n) {\n"
|
||||
" Resultado::Ok(metade) => println!(\"{n} divido em dois é {metade}\"),\n"
|
||||
" Resultado::Erro(msg) => println!(\"desculpe, aconteceu um erro: {msg}\"),\n"
|
||||
" }\n"
|
||||
"}\n"
|
||||
"```"
|
||||
@@ -7057,37 +7095,29 @@ msgid ""
|
||||
"arm, `half` is bound to the value inside the `Ok` variant. In the second arm,\n"
|
||||
"`msg` is bound to the error message."
|
||||
msgstr ""
|
||||
"Aqui usamos a verificação de correspondência para _desestruturar_ o valor contido em `Result`. Na "
|
||||
"primeira\n"
|
||||
"verificação de correspondência, `metade` está vinculado ao valor dentro da variante `Ok`. Na "
|
||||
"segunda,\n"
|
||||
"Aqui usamos a verificação de correspondência para _desestruturar_ o valor contido em `Result`. Na primeira\n"
|
||||
"verificação de correspondência, `metade` está vinculado ao valor dentro da variante `Ok`. Na segunda,\n"
|
||||
"`msg` está vinculado à mensagem de erro."
|
||||
|
||||
#: src/pattern-matching/destructuring-enums.md:36
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"* The `if`/`else` expression is returning an enum that is later unpacked with a `match`.\n"
|
||||
"* You can try adding a third variant to the enum definition and displaying the errors when running "
|
||||
"the code. Point out the places where your code is now inexhaustive and how the compiler tries to "
|
||||
"give you hints."
|
||||
"* You can try adding a third variant to the enum definition and displaying the errors when running the code. Point out the places where your code is now "
|
||||
"inexhaustive and how the compiler tries to give you hints."
|
||||
msgstr ""
|
||||
"Pontos chave:\n"
|
||||
"* A expressão `if`/`else` está retornando um enum que é posteriormente descompactado com um "
|
||||
"`match`.\n"
|
||||
"* Você pode tentar adicionar uma terceira variante à definição de Enum e exibir os erros ao "
|
||||
"executar o código. Aponte os lugares onde seu código agora é \"não exaustivo\" e como o compilador "
|
||||
"tenta lhe dar dicas."
|
||||
"* A expressão `if`/`else` está retornando um `enum` que é posteriormente descompactado com um `match`.\n"
|
||||
"* Você pode tentar adicionar uma terceira variante à definição de Enum e exibir os erros ao executar o código. Aponte os lugares onde seu código agora é \"não "
|
||||
"exaustivo\" e como o compilador tenta lhe dar dicas."
|
||||
|
||||
#: src/pattern-matching/destructuring-structs.md:1
|
||||
msgid "# Destructuring Structs"
|
||||
msgstr "# Desestruturando estruturas (Structs)"
|
||||
msgstr "# Desestruturando Structs"
|
||||
|
||||
#: src/pattern-matching/destructuring-structs.md:3
|
||||
msgid "You can also destructure `structs`:"
|
||||
msgstr "Você também pode desestruturar `structs`:"
|
||||
|
||||
#: src/pattern-matching/destructuring-structs.md:5
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"```rust,editable\n"
|
||||
"struct Foo {\n"
|
||||
@@ -7106,13 +7136,19 @@ msgid ""
|
||||
"}\n"
|
||||
"```"
|
||||
msgstr ""
|
||||
"```rust,editable\n"
|
||||
"struct Foo {\n"
|
||||
" x: (u32, u32),\n"
|
||||
" y: u32,\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"#[rustfmt::skip]\n"
|
||||
"fn main() {\n"
|
||||
" let foo = Foo { x: (1, 2), y: 3 };\n"
|
||||
" match foo {\n"
|
||||
" Foo { x: (1, b), y } => println!(\"x.0 = 1, b = {b}, y = {y}\"),\n"
|
||||
" Foo { y: 2, x: i } => println!(\"y = 2, i = {i:?}\"),\n"
|
||||
" Foo { y, .. } => println!(\"y = {y}, outros campos foram ignorados\"),\n"
|
||||
" Foo { y: 2, x: i } => println!(\"y = 2, x = {i:?}\"),\n"
|
||||
" Foo { y, .. } => println!(\"y = {y}, outros campos foram ignorados\"),\n"
|
||||
" }\n"
|
||||
"}\n"
|
||||
"```"
|
||||
@@ -7125,6 +7161,11 @@ msgid ""
|
||||
" spot. Try changing the `2` in the second arm to a variable, and see that it subtly\n"
|
||||
" doesn't work. Change it to a `const` and see it working again."
|
||||
msgstr ""
|
||||
"* Modifique os valores em `foo` para corresponder com os outros padrões.\n"
|
||||
"* Adicione um novo campo a `Foo` e faça mudanças nos padrões conforme necessário.\n"
|
||||
"* A diferença entre uma captura (_capture_) e uma expressão constante pode ser difícil de\n"
|
||||
" perceber. Tente modificar o `2` no segundo braço para uma variável, e veja que, de forma sútil,\n"
|
||||
" não funciona. Mude para `const` e veja funcionando novamente."
|
||||
|
||||
#: src/pattern-matching/destructuring-arrays.md:1
|
||||
msgid "# Destructuring Arrays"
|
||||
@@ -7132,7 +7173,7 @@ msgstr "# Desestruturando Vetores"
|
||||
|
||||
#: src/pattern-matching/destructuring-arrays.md:3
|
||||
msgid "You can destructure arrays, tuples, and slices by matching on their elements:"
|
||||
msgstr "Você pode desestruturar vetores, tuplas e slices combinando seus elementos:"
|
||||
msgstr "Você pode desestruturar vetores, tuplas e _slices_ combinando seus elementos:"
|
||||
|
||||
#: src/pattern-matching/destructuring-arrays.md:5
|
||||
msgid ""
|
||||
@@ -7163,7 +7204,6 @@ msgstr ""
|
||||
"```"
|
||||
|
||||
#: src/pattern-matching/destructuring-arrays.md:21
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"* Destructuring of slices of unknown length also works with patterns of fixed length.\n"
|
||||
"\n"
|
||||
@@ -7190,31 +7230,42 @@ msgid ""
|
||||
"* Point out that how `..` will expand to account for different number of elements.\n"
|
||||
"* Show matching against the tail with patterns `[.., b]` and `[a@..,b]`"
|
||||
msgstr ""
|
||||
"#[rustfmt::skip]\n"
|
||||
"fn inspect(slice: &[i32]) {\n"
|
||||
" println!(\"Fale-me sobre {slice:?}\");\n"
|
||||
" match slice {\n"
|
||||
" &[0, y, z] => println!(\"O primeiro é 0, y = {y}, e z = {z}\"),\n"
|
||||
" &[1, ..] => println!(\"O primeiro é 1 e o restante é ignorado\"),\n"
|
||||
" _ => println!(\"Todos os elementos foram ignorados\"),\n"
|
||||
" }\n"
|
||||
"}\n"
|
||||
"```\n"
|
||||
"* Mostre as correspondências com o final do padrão usando `[.., b]` e `[a@..,b]`\n"
|
||||
"</details>"
|
||||
"* Desestruturar _slices_ de tamanho desconhecido é possível utilizando padrões de tamanho fixo.\n"
|
||||
"\n"
|
||||
"\n"
|
||||
" ```rust,editable\n"
|
||||
" fn main() {\n"
|
||||
" inspecionar(&[0, -2, 3]);\n"
|
||||
" inspecionar(&[0, -2, 3, 4]);\n"
|
||||
" }\n"
|
||||
"\n"
|
||||
" #[rustfmt::skip]\n"
|
||||
" fn inspecionar(slice: &[i32]) {\n"
|
||||
" println!(\"Fale-me sobre {slice:?}\");\n"
|
||||
" match slice {\n"
|
||||
" &[0, y, z] => println!(\"Primeiro é 0, y = {y}, and z = {z}\"),\n"
|
||||
" &[1, ..] => println!(\"Primeiro é 1 e o resto foi ignorado\"),\n"
|
||||
" _ => println!(\"Todos os elementos foram ignorados\"),\n"
|
||||
" }\n"
|
||||
" }\n"
|
||||
" ```\n"
|
||||
" \n"
|
||||
"* Crie um novo padrão usando `_` para representar um elemento. \n"
|
||||
"* Adicione mais valores ao vetor.\n"
|
||||
"* Aponte que `..` vai expandir para levar em conta um número diferente de elementos.\n"
|
||||
"* Mostre correspondência com a cauda usando os padrões `[.., b]` and `[a@..,b]`"
|
||||
|
||||
#: src/pattern-matching/match-guards.md:1
|
||||
msgid "# Match Guards"
|
||||
msgstr "# Guardas de correspondência (match guards)"
|
||||
msgstr "# Guardas de Correspondência (Match Guards)"
|
||||
|
||||
#: src/pattern-matching/match-guards.md:3
|
||||
msgid ""
|
||||
"When matching, you can add a _guard_ to a pattern. This is an arbitrary Boolean\n"
|
||||
"expression which will be executed if the pattern matches:"
|
||||
msgstr ""
|
||||
"Ao verificar uma correspondência, você pode adicionar um _guarda_ para um padrão. É uma expressão "
|
||||
"booleana\n"
|
||||
"que será executada se o padrão corresponder:"
|
||||
"Ao verificar uma correspondência, você pode adicionar uma guarda (_guard_) para um padrão. É uma expressão Booleana\n"
|
||||
"arbitrária que será executada se o padrão corresponder:"
|
||||
|
||||
#: src/pattern-matching/match-guards.md:6
|
||||
msgid ""
|
||||
@@ -7235,9 +7286,9 @@ msgstr ""
|
||||
"```rust, editable\n"
|
||||
"#[rustfmt::skip]\n"
|
||||
"fn main() {\n"
|
||||
" let pair = (2, -2);\n"
|
||||
" println!(\"Fale-me sobre {pair:?}\");\n"
|
||||
" match pair {\n"
|
||||
" let par = (2, -2);\n"
|
||||
" println!(\"Fale-me sobre {par:?}\");\n"
|
||||
" match par {\n"
|
||||
" (x, y) if x == y => println!(\"Estes são gêmeos\"),\n"
|
||||
" (x, y) if x + y == 0 => println!(\"Antimatter, kaboom!\"),\n"
|
||||
" (x, _) if x % 2 == 1 => println!(\"O primeiro é ímpar\"),\n"
|
||||
@@ -7247,7 +7298,6 @@ msgstr ""
|
||||
"```"
|
||||
|
||||
#: src/pattern-matching/match-guards.md:23
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"* Match guards as a separate syntax feature are important and necessary when we wish to concisely "
|
||||
"express more complex ideas than patterns alone would allow.\n"
|
||||
@@ -7258,33 +7308,31 @@ msgid ""
|
||||
"* You can use the variables defined in the pattern in your if expression.\n"
|
||||
"* The condition defined in the guard applies to every expression in a pattern with an `|`."
|
||||
msgstr ""
|
||||
"Pontos chave:\n"
|
||||
"* Guardas de correspondência, como um recurso de sintaxe separado, são importantes e necessários.\n"
|
||||
"Permitem expressar ideias mais complexas do que somente o padrão permitiria.\n"
|
||||
"* Eles não são iguais à expressão `if` separada dentro do bloco de correspondência. Uma expressão "
|
||||
"`if` dentro do bloco de ramificação (depois de `=>`) acontece depois que a correspondência é "
|
||||
"selecionada. A falha na condição `if` dentro desse bloco não resultará em outras verificações de "
|
||||
"correspondência\n"
|
||||
"da expressão `match` original serem consideradas.\n"
|
||||
"* Guardas de correspondência, como um recurso de sintaxe separado, são importantes e necessárias quando se quer expressar ideias mais complexas do que somente o "
|
||||
"padrão permitiria.\n"
|
||||
"* Eles não são iguais à expressão `if` separada dentro do bloco de correspondência. Uma expressão `if` dentro do bloco de ramificação (depois de `=>`) acontece "
|
||||
"depois que a correspondência é selecionada. A falha na condição `if` dentro desse bloco não resultará em outras verificações de correspondência da expressão "
|
||||
"`match` original serem consideradas.\n"
|
||||
"* Você pode usar as variáveis definidas no padrão em sua expressão `if`.\n"
|
||||
"* A condição definida na guarda se aplica a todas as expressões em um padrão com um `|`.\n"
|
||||
"</details>"
|
||||
"* A condição definida na guarda se aplica a todas as expressões em um padrão com um `|`."
|
||||
|
||||
#: src/exercises/day-2/morning.md:1
|
||||
msgid "# Day 2: Morning Exercises"
|
||||
msgstr "# Dia 2: Exercícios matinais"
|
||||
msgstr "# Dia 2: Exercícios Matinais"
|
||||
|
||||
#: src/exercises/day-2/morning.md:3
|
||||
msgid "We will look at implementing methods in two contexts:"
|
||||
msgstr "Veremos a implementação de métodos em dois contextos:"
|
||||
|
||||
#: src/exercises/day-2/morning.md:5
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"* Simple struct which tracks health statistics.\n"
|
||||
"\n"
|
||||
"* Multiple structs and enums for a drawing library."
|
||||
msgstr "* Várias estruturas e enumerações para uma biblioteca de desenho."
|
||||
msgstr ""
|
||||
"* Uma _struct_ simples que guarda estatísticas de saúde.\n"
|
||||
"\n"
|
||||
"* Várias _structs_ e _enums_ para uma biblioteca de desenho."
|
||||
|
||||
#: src/exercises/day-2/health-statistics.md:1
|
||||
msgid "# Health Statistics"
|
||||
@@ -7295,8 +7343,7 @@ msgid ""
|
||||
"You're working on implementing a health-monitoring system. As part of that, you\n"
|
||||
"need to keep track of users' health statistics."
|
||||
msgstr ""
|
||||
"Você está trabalhando na implementação de um sistema de monitoramento de saúde. Como parte disso, "
|
||||
"você\n"
|
||||
"Você está trabalhando na implementação de um sistema de monitoramento de saúde. Como parte disso, você\n"
|
||||
"precisa acompanhar as estatísticas de saúde dos usuários."
|
||||
|
||||
#: src/exercises/day-2/health-statistics.md:6
|
||||
@@ -7305,16 +7352,17 @@ msgid ""
|
||||
"struct definition. Your goal is to implement the stubbed out methods on the\n"
|
||||
"`User` `struct` defined in the `impl` block."
|
||||
msgstr ""
|
||||
"Você começará com algumas funções fragmentadas em um bloco `impl` e também com a definição da "
|
||||
"estrutura `User`.\n"
|
||||
"Seu objetivo é implementar os métodos esboçados para a\n"
|
||||
"`struct` `User` definidos no bloco `impl`."
|
||||
"Você começará com algumas funções fragmentadas em um bloco `impl` e também com a definição da estrutura `Usuario`.\n"
|
||||
"Seu objetivo é implementar os métodos esboçados para a `struct` `Usuario`\n"
|
||||
"definidos no bloco `impl`."
|
||||
|
||||
#: src/exercises/day-2/health-statistics.md:10
|
||||
msgid ""
|
||||
"Copy the code below to <https://play.rust-lang.org/> and fill in the missing\n"
|
||||
"methods:"
|
||||
msgstr "Copie o código abaixo para <https://play.rust-lang.org/> e implemente os métodos:"
|
||||
msgstr ""
|
||||
"Copie o código abaixo em <https://play.rust-lang.org/> e implemente os métodos\n"
|
||||
"que estão faltando:"
|
||||
|
||||
#: src/exercises/day-2/health-statistics.md:13
|
||||
msgid ""
|
||||
@@ -7374,6 +7422,61 @@ msgid ""
|
||||
"}\n"
|
||||
"```"
|
||||
msgstr ""
|
||||
"```rust,should_panic\n"
|
||||
"// TODO: remova a linha abaixo quando terminar sua implementação.\n"
|
||||
"#![allow(unused_variables, dead_code)]\n"
|
||||
"\n"
|
||||
"pub struct Usuario {\n"
|
||||
" nome: String,\n"
|
||||
" idade: u32,\n"
|
||||
" peso: f32,\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"impl Usuario {\n"
|
||||
" pub fn new(nome: String, idade: u32, peso: f32) -> Self {\n"
|
||||
" unimplemented!()\n"
|
||||
" }\n"
|
||||
"\n"
|
||||
" pub fn nome(&self) -> &str {\n"
|
||||
" unimplemented!()\n"
|
||||
" }\n"
|
||||
"\n"
|
||||
" pub fn idade(&self) -> u32 {\n"
|
||||
" unimplemented!()\n"
|
||||
" }\n"
|
||||
"\n"
|
||||
" pub fn peso(&self) -> f32 {\n"
|
||||
" unimplemented!()\n"
|
||||
" }\n"
|
||||
"\n"
|
||||
" pub fn definir_idade(&mut self, nova_idade: u32) {\n"
|
||||
" unimplemented!()\n"
|
||||
" }\n"
|
||||
"\n"
|
||||
" pub fn definir_peso(&mut self, novo_peso: f32) {\n"
|
||||
" unimplemented!()\n"
|
||||
" }\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"fn main() {\n"
|
||||
" let beto = Usuario::new(String::from(\"Beto\"), 32, 155.2);\n"
|
||||
" println!(\"Eu sou {} e minha idade é {}\", beto.nome(), beto.idade());\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"#[test]\n"
|
||||
"fn test_peso() {\n"
|
||||
" let beto = Usuario::new(String::from(\"Beto\"), 32, 155.2);\n"
|
||||
" assert_eq!(beto.peso(), 155.2);\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"#[test]\n"
|
||||
"fn test_set_age() {\n"
|
||||
" let mut beto = Usuario::new(String::from(\"Beto\"), 32, 155.2);\n"
|
||||
" assert_eq!(beto.idade(), 32);\n"
|
||||
" beto.definir_idade(33);\n"
|
||||
" assert_eq!(beto.idade(), 33);\n"
|
||||
"}\n"
|
||||
"```"
|
||||
|
||||
#: src/exercises/day-2/points-polygons.md:1
|
||||
msgid "# Polygon Struct"
|
||||
@@ -7386,7 +7489,7 @@ msgid ""
|
||||
"tests pass:"
|
||||
msgstr ""
|
||||
"Vamos criar uma estrutura `Poligono` que contém alguns `Pontos`. Copie o código abaixo\n"
|
||||
"para <https://play.rust-lang.org/> e preencha os métodos que faltam para fazer os\n"
|
||||
"em <https://play.rust-lang.org/> e preencha os métodos que faltam para fazer os\n"
|
||||
"testes passarem:"
|
||||
|
||||
#: src/exercises/day-2/points-polygons.md:7
|
||||
@@ -7499,27 +7602,130 @@ msgid ""
|
||||
"fn main() {}\n"
|
||||
"```"
|
||||
msgstr ""
|
||||
"```rust\n"
|
||||
"// TODO: remova a linha abaixo quando terminar sua implementação.\n"
|
||||
"#![allow(unused_variables, dead_code)]\n"
|
||||
"\n"
|
||||
"pub struct Ponto {\n"
|
||||
" // adicione atributos\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"impl Ponto {\n"
|
||||
" // adicione métodos\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"pub struct Poligono {\n"
|
||||
" // adicione atributos\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"impl Poligono {\n"
|
||||
" // adicione métodos\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"pub struct Circulo {\n"
|
||||
" // adicione atributos\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"impl Circulo {\n"
|
||||
" // adicione métodos\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"pub enum Forma {\n"
|
||||
" Poligono(Poligono),\n"
|
||||
" Circulo(Circulo),\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"#[cfg(test)]\n"
|
||||
"mod tests {\n"
|
||||
" use super::*;\n"
|
||||
"\n"
|
||||
" fn arredonda_dois_digitos(x: f64) -> f64 {\n"
|
||||
" (x * 100.0).round() / 100.0\n"
|
||||
" }\n"
|
||||
"\n"
|
||||
" #[test]\n"
|
||||
" fn testa_magnitude_ponto() {\n"
|
||||
" let p1 = Ponto::new(12, 13);\n"
|
||||
" assert_eq!(arredonda_dois_digitos(p1.magnitude()), 17.69);\n"
|
||||
" }\n"
|
||||
"\n"
|
||||
" #[test]\n"
|
||||
" fn testa_distancia_ponto() {\n"
|
||||
" let p1 = Ponto::new(10, 10);\n"
|
||||
" let p2 = Ponto::new(14, 13);\n"
|
||||
" assert_eq!(arredonda_dois_digitos(p1.distancia(p2)), 5.00);\n"
|
||||
" }\n"
|
||||
"\n"
|
||||
" #[test]\n"
|
||||
" fn testa_somar_ponto() {\n"
|
||||
" let p1 = Ponto::new(16, 16);\n"
|
||||
" let p2 = p1 + Ponto::new(-4, 3);\n"
|
||||
" assert_eq!(p2, Ponto::new(12, 19));\n"
|
||||
" }\n"
|
||||
"\n"
|
||||
" #[test]\n"
|
||||
" fn testa_ponto_mais_a_esquerda_poligono() {\n"
|
||||
" let p1 = Ponto::new(12, 13);\n"
|
||||
" let p2 = Ponto::new(16, 16);\n"
|
||||
"\n"
|
||||
" let mut poli = Poligono::new();\n"
|
||||
" poli.adiciona_ponto(p1);\n"
|
||||
" poli.adiciona_ponto(p2);\n"
|
||||
" assert_eq!(poli.ponto_mais_a_esquerda(), Some(p1));\n"
|
||||
" }\n"
|
||||
"\n"
|
||||
" #[test]\n"
|
||||
" fn testa_iterador_poligono() {\n"
|
||||
" let p1 = Ponto::new(12, 13);\n"
|
||||
" let p2 = Ponto::new(16, 16);\n"
|
||||
"\n"
|
||||
" let mut poli = Poligono::new();\n"
|
||||
" poli.adiciona_ponto(p1);\n"
|
||||
" poli.adiciona_ponto(p2);\n"
|
||||
"\n"
|
||||
" let pontos = poli.iter().cloned().collect::<Vec<_>>();\n"
|
||||
" assert_eq!(pontos, vec![Point::new(12, 13), Point::new(16, 16)]);\n"
|
||||
" }\n"
|
||||
"\n"
|
||||
" #[test]\n"
|
||||
" fn testa_perimetros_forma() {\n"
|
||||
" let mut poli = Poligono::new();\n"
|
||||
" poli.adiciona_ponto(Ponto::new(12, 13));\n"
|
||||
" poli.adiciona_ponto(Ponto::new(17, 11));\n"
|
||||
" poli.adiciona_ponto(Ponto::new(16, 16));\n"
|
||||
" let formas = vec![\n"
|
||||
" Forma::from(poli),\n"
|
||||
" Forma::from(Circulo::new(Ponto::new(10, 20), 5)),\n"
|
||||
" ];\n"
|
||||
" let perimetros = formas\n"
|
||||
" .iter()\n"
|
||||
" .map(Forma::perimetro)\n"
|
||||
" .map(arredonda_dois_digitos)\n"
|
||||
" .collect::<Vec<_>>();\n"
|
||||
" assert_eq!(perimetros, vec![15.48, 31.42]);\n"
|
||||
" }\n"
|
||||
"}\n"
|
||||
"\n"
|
||||
"#[allow(dead_code)]\n"
|
||||
"fn main() {}\n"
|
||||
"```"
|
||||
|
||||
#: src/exercises/day-2/points-polygons.md:117
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"Since the method signatures are missing from the problem statements, the key part\n"
|
||||
"of the exercise is to specify those correctly. You don't have to modify the tests."
|
||||
msgstr ""
|
||||
"Como as assinaturas dos métodos estão faltando nas declarações do problema, a parte principal\n"
|
||||
"do exercício é especificá-las corretamente."
|
||||
"do exercício é especificá-las corretamente. Não é preciso modificar os testes."
|
||||
|
||||
#: src/exercises/day-2/points-polygons.md:120
|
||||
msgid "Other interesting parts of the exercise:"
|
||||
msgstr ""
|
||||
msgstr "Outras partes interessante do exercício:"
|
||||
|
||||
#: src/exercises/day-2/points-polygons.md:122
|
||||
#, fuzzy
|
||||
msgid ""
|
||||
"* Derive a `Copy` trait for some structs, as in tests the methods sometimes don't borrow their "
|
||||
"arguments.\n"
|
||||
"* Discover that `Add` trait must be implemented for two objects to be addable via \"+\". Note that "
|
||||
"we do not discuss generics until Day 3."
|
||||
"* Derive a `Copy` trait for some structs, as in tests the methods sometimes don't borrow their arguments.\n"
|
||||
"* Discover that `Add` trait must be implemented for two objects to be addable via \"+\". Note that we do not discuss generics until Day 3."
|
||||
msgstr ""
|
||||
"Outras partes interessantes do exercício:\n"
|
||||
" \n"
|
||||
@@ -23071,7 +23277,7 @@ msgstr ""
|
||||
#~ msgstr "* Estruturas (`structs`), enumerações (`enums`) e métodos."
|
||||
|
||||
#~ msgid "* Pattern matching: destructuring enums, structs, and arrays."
|
||||
#~ msgstr "* Correspondência de padrões: desestruturando enumerações, estruturas e vetores."
|
||||
#~ msgstr "* Correspondência de padrões: desestruturando _enums_, _structs_ e vetores."
|
||||
|
||||
#~ msgid ""
|
||||
#~ "* Control flow constructs: `if`, `if let`, `while`, `while let`, `break`, and\n"
|
||||
|
||||
Reference in New Issue
Block a user