diff --git a/po/pt-BR.po b/po/pt-BR.po index c0301efd..72cd6dbc 100644 --- a/po/pt-BR.po +++ b/po/pt-BR.po @@ -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" -"" +" " #: 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`." 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`." #: 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 "" -"
\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" -"
" +"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,\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::();\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 "" -"
\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 "" -"
\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" -"
" +"* 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" -"
" +"* 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" -"" +"* 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 and fill in the missing\n" "methods:" -msgstr "Copie o código abaixo para e implemente os métodos:" +msgstr "" +"Copie o código abaixo em 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 e preencha os métodos que faltam para fazer os\n" +"em 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::>();\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::>();\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"