pt-BR: Update and Complete chapter 12 to 15.2 (#920)

* Translate chap 12 to 15.2

* Remove unicode chars

po/pt-BR.po

@@ -5855,7 +5855,7 @@ msgstr ""
 
 #: src/welcome-day-2.md:1
 msgid "# Welcome to Day 2"
-msgstr "# Bem-vindo ao dia 2"
+msgstr "# Bem-vindos ao Dia 2"
 
 #: src/welcome-day-2.md:3
 msgid "Now that we have seen a fair amount of Rust, we will continue with:"
@@ -5875,6 +5875,17 @@ msgid ""
 "\n"
 "* Modules: visibility, paths, and filesystem hierarchy."
 msgstr ""
+"* Estruturas (structs), enumerações (enums), métodos (methods).\n"
+"\n"
+"* Correspondência de padrões: desestruturando enums, structs, e arrays.\n"
+"\n"
+"* Construtos de fluxo de controle: `if`, `if let`, `while`, `while let`, `break`, e\n"
+"  `continue`.\n"
+"\n"
+"* A Biblioteca Padrão: `String`, `Option` e `Result`, `Vec`, `HashMap`, `Rc`\n"
+"  e `Arc`.\n"
+"\n"
+"* Módulos: visibilidade, caminhos (paths), e hierarquia do sistema de arquivos."
 
 #: src/structs.md:1
 msgid "# Structs"
@@ -5937,7 +5948,6 @@ msgid "Key Points:"
 msgstr "Pontos chave:"
 
 #: src/structs.md:33
-#, fuzzy
 msgid ""
 "* Structs work like in C or C++.\n"
 "  * Like in C++, and unlike in C, no typedef is needed to define a type.\n"
@@ -5951,19 +5961,14 @@ msgid ""
 "having to explicitly type it all out. It must always be the last element."
 msgstr ""
 "* Structs funcionam como em C ou C++.\n"
-"  * Como em C++, e ao contrário de C, nenhum typedef é necessário para definir um tipo.\n"
+"  * Como em C++, e ao contrário de C, nenhum _`typedef`_ é necessário para definir um tipo.\n"
-"  * Ao contrário do C++, não há herança entre structs.\n"
+"  * Ao contrário do C++, não há herança entre _structs_.\n"
-"* Os métodos são definidos em um bloco `impl`, que veremos nos próximos slides.\n"
+"* Os métodos são definidos em um bloco _`impl`_, que veremos nos próximos slides.\n"
-"* Este pode ser um bom momento para que as pessoas saibam que existem diferentes tipos de "
+"* Este pode ser um bom momento para que as pessoas saibam que existem diferentes tipos de _structs_.\n"
-"structs.\n"
+"  * _Structs_ de tamanho zero `por exemplo, struct Foo;` podem ser usadas ao implementar uma característica em algum tipo, mas não possuem nenhum dado que\n"
-"  * _Structs_ de tamanho zero `por exemplo, struct Foo;` podem ser usadas ao implementar uma "
+"você deseja armazenar nelas.\n"
-"característica em algum tipo,\n"
+"  * O próximo slide apresentará as estruturas tuplas (_Estruturas Tupla_) usadas quando o nome dos campos não são importantes.\n"
-"mas não possuem nenhum dado que você deseja armazenar nelas.\n"
+"* A sintaxe `..pedro` permite copiar a maioria dos campos de uma _struct_ sem precisar explicitar seus tipos. Sempre deve ser o último elemento."
-"  * O próximo slide apresentará as estruturas tuplas (_Tuple Structs_) usadas quando o nome dos "
-"campos não são importantes.\n"
-"* A sintaxe `..pedro` permite a cópia da maioria do campos de uma _struct_ sem precisar explicitar "
-"seus tipos.\n"
-" Ele precisa ser o último elemento."
 
 #: src/structs/tuple-structs.md:1
 msgid "# Tuple Structs"
@@ -5974,7 +5979,6 @@ msgid "If the field names are unimportant, you can use a tuple struct:"
 msgstr "Se os nomes dos campos não forem importantes, você pode usar uma estrutura de tupla:"
 
 #: src/structs/tuple-structs.md:5
-#, fuzzy
 msgid ""
 "```rust,editable\n"
 "struct Point(i32, i32);\n"
@@ -5985,6 +5989,9 @@ msgid ""
 "}\n"
 "```"
 msgstr ""
+"```rust,editable\n"
+"struct Ponto(i32, i32);\n"
+"\n"
 "fn main() {\n"
 "    let p = Ponto(17, 23);\n"
 "    println!(\"({}, {})\", p.0, p.1);\n"
@@ -5993,7 +6000,7 @@ msgstr ""
 
 #: src/structs/tuple-structs.md:14
 msgid "This is often used for single-field wrappers (called newtypes):"
-msgstr "Isso geralmente é usado para wrappers de campo único (chamados newtypes):"
+msgstr "Isso é comumente utilizado para _wrappers_ (invólucros) com campo único (chamados _newtypes_):"
 
 #: src/structs/tuple-structs.md:16
 msgid ""
@@ -6016,9 +6023,26 @@ msgid ""
 "\n"
 "```"
 msgstr ""
+"```rust,editable,compile_fail\n"
+"struct LibrasDeForca(f64);\n"
+"struct Newtons(f64);\n"
+"\n"
+"fn calcular_forca_nas_turbinas() -> LibrasDeForca {\n"
+"    todo!(“Pergunte para um cientista de foguetes da NASA”)\n"
+"}\n"
+"\n"
+"fn definir_forca_nas_turbinas(force: Newtons) {\n"
+"    // …\n"
+"}\n"
+"\n"
+"fn main() {\n"
+"    let forca = calcular_forca_nas_turbinas();\n"
+"    definir_forca_nas_turbinas(forca);\n"
+"}\n"
+"\n"
+"```"
 
 #: src/structs/tuple-structs.md:37
-#, fuzzy
 msgid ""
 "* Newtypes are a great way to encode additional information about the value in a primitive type, "
 "for example:\n"
@@ -6033,25 +6057,25 @@ msgid ""
 "* The example is a subtle reference to the [Mars Climate Orbiter](https://en.wikipedia.org/wiki/"
 "Mars_Climate_Orbiter) failure."
 msgstr ""
-"Newtypes são uma ótima maneira de codificar informações adicionais sobre o valor em um tipo "
+"_Newtypes_ são uma ótima maneira de codificar informações adicionais sobre o valor em um tipo primitivo, por exemplo:\n"
-"primitivo, por exemplo:\n"
+"  * O número é medido em alguma unidade: `Newtons` no exemplo acima.\n"
-"  * O número é medido em algumas unidades: `Newtons` no exemplo acima.\n"
+"  * O valor passou por alguma validação quando foi criado, então não é preciso validá-lo novamente a cada uso: `NumeroTelefone(String)` ou `NumeroImpar(u32)`.\n"
-"  * O valor passou por alguma validação quando foi criado, então você não precisa mais validá-lo "
+"* Demonstre como somar um valor `f64` em um valor do tipo `Newtons` acessando o campo único do _newtype_.\n"
-"novamente a cada uso:  `PhoneNumber(String)` ou `OddNumber(u32)`.\n"
+"  *  Geralmente, Rust não gosta de coisas implícitas, como _unwrapping_ automático ou, por exemplo, usar booleanos como inteiros.\n"
-"    \n"
+"  *  Sobrecarga de operadores é discutido no Dia 3 (_generics_).\n"
-"</details>"
+"* O examplo é uma referência sutil a falha do [Orbitador Climático de Marte](https://pt.wikipedia.org/wiki/Mars_Climate_Orbiter)."
 
 #: src/structs/field-shorthand.md:1
 msgid "# Field Shorthand Syntax"
-msgstr "# Sintaxe abreviada de campo"
+msgstr "# Sintaxe Abreviada de Campo"
 
 #: src/structs/field-shorthand.md:3
 msgid ""
 "If you already have variables with the right names, then you can create the\n"
 "struct using a shorthand:"
 msgstr ""
-"Se você já tiver variáveis com os nomes corretos, poderá criar o\n"
+"Se você já tiver variáveis com os nomes corretos, poderá criar a\n"
-"struct usando uma abreviação:"
+"estrutura (_struct_) usando uma abreviação:"
 
 #: src/structs/field-shorthand.md:6
 msgid ""
@@ -6074,6 +6098,24 @@ msgid ""
 "}\n"
 "```"
 msgstr ""
+"```rust,editable\n"
+"#[derive(Debug)]\n"
+"struct Pessoa {\n"
+"    nome: String,\n"
+"    idade: u8,\n"
+"}\n"
+"\n"
+"impl Pessoa {\n"
+"    fn new(nome: String, idade: u8) -> Pessoa {\n"
+"        Pessoa { nome, idade }\n"
+"    }\n"
+"}\n"
+"\n"
+"fn main() {\n"
+"    let pedro = Pessoa::new(String::from(\"Pedro\"), 27);\n"
+"    println!(\"{pedro:?}\");\n"
+"}\n"
+"```"
 
 #: src/structs/field-shorthand.md:27
 msgid ""
@@ -6125,6 +6167,50 @@ msgid ""
 "will no longer be accessible afterwards.\n"
 "* Use `{:#?}` when printing structs to request the `Debug` representation."
 msgstr ""
+"*  A função `new` poderia ser escrita utilizando `Self` como tipo, já que ele é intercambiável com o nome da _struct_\n"
+"\n"
+"     ```rust,editable\n"
+"     #[derive(Debug)]\n"
+"     struct Pessoa {\n"
+"         nome: String,\n"
+"         idade: u8,\n"
+"     }\n"
+"     impl Pessoa {\n"
+"         fn new(nome: String, idade: u8) -> Self {\n"
+"             Self { nome, idade }\n"
+"         }\n"
+"     }\n"
+"     ```    \n"
+"* Implemente a _trait_ `Default` (Padrão) para a _struct_. Defina alguns campos e utilize valores padrão para os demais.\n"
+"\n"
+"     ```rust,editable\n"
+"     #[derive(Debug)]\n"
+"     struct Pessoa {\n"
+"         nome: String,\n"
+"         idade: u8,\n"
+"     }\n"
+"     impl Default for Pessoa {\n"
+"         fn default() -> Pessoa {\n"
+"             Pessoa {\n"
+"                 nome: \"Robô\".to_string(),\n"
+"                 idade: 0,\n"
+"             }\n"
+"         }\n"
+"     }\n"
+"     fn create_default() {\n"
+"         let tmp = Pessoa {\n"
+"             ..Default::default()\n"
+"         };\n"
+"         let tmp = Pessoa {\n"
+"             nome: \"Sam\".to_string(),\n"
+"             ..Default::default()\n"
+"         };\n"
+"     }\n"
+"     ```\n"
+"\n"
+"* Métodos são definidos no bloco `impl`.\n"
+"* Use struct update syntax to define a new structure using `peter`. Note that the variable `peter` will no longer be accessible afterwards.\n"
+"* Utilize `{:#?}` para imprimir _structs_ para utilizar a representação `Debug` (de Depuração)."
 
 #: src/enums.md:1
 msgid "# Enums"
@@ -6139,7 +6225,6 @@ msgstr ""
 "variações diferentes:"
 
 #: src/enums.md:6
-#, fuzzy
 msgid ""
 "```rust,editable\n"
 "fn generate_random_number() -> i32 {\n"
@@ -6167,17 +6252,33 @@ msgid ""
 "}\n"
 "```"
 msgstr ""
-"fn jogar_moeda() -> CaraCoroa {\n"
+"```rust,editable\n"
-"    let numero_aleatorio = gerador_numero_aleatorio();\n"
+"fn gerar_numero_aleatorio() -> i32 {\n"
-"    if numero_aleatorio % 2 == 0 {\n"
+"    // Implementação baseada em https://xkcd.com/221/\n"
-"        return CaraCoroa::Cara;\n"
+"    4  // Escolhido por uma rolagem de dados justa. Garantido ser aleatório.\n"
-"    } else {\n"
-"        return CaraCoroa::Coroa;\n"
 "}\n"
-"}"
+"\n"
+"#[derive(Debug)]\n"
+"enum MoedaJogada {\n"
+"    Cara,\n"
+"    Coroa,\n"
+"}\n"
+"\n"
+"fn jogar_moeda() -> MoedaJogada {\n"
+"    let numero_aleatorio = gerar_numero_aleatorio();\n"
+"    if numero_aleatorio % 2 == 0 {\n"
+"        return MoedaJogada::Cara;\n"
+"    } else {\n"
+"        return MoedaJogada::Coroa;\n"
+"    }\n"
+"}\n"
+"\n"
+"fn main() {\n"
+"    println!(\"Você tirou: {:?}\", jogar_moeda());\n"
+"}\n"
+"```"
 
 #: src/enums.md:36
-#, fuzzy
 msgid ""
 "* Enumerations allow you to collect a set of values under one type\n"
 "* This page offers an enum type `CoinFlip` with two variants `Heads` and `Tail`. You might note "
@@ -6189,20 +6290,17 @@ msgid ""
 "  * You could even implement the different variants of an enum with separate structs but then they "
 "wouldn’t be the same type as they would if they were all defined in an enum. "
 msgstr ""
-"* As enumerações permitem que você colete um conjunto de valores em um tipo\n"
+"* Enumerações permitem coletar um conjunto de valores em um tipo\n"
-"* Esta página oferece um tipo de Enum `CoinFlip` com duas variantes `Heads` e `Tail`. Você pode "
+"* Esta página oferece um tipo de _enum_ `MoedaJogada` com duas variantes `Cara` e `Coroa`. Você pode observar o _namespace_ ao usar variantes.\n"
-"observar o namespace ao usar variantes.\n"
+"* Este pode ser um bom momento para comparar _Structs_ e _Enums_:\n"
-"* Este pode ser um bom momento para comparar Structs e Enums:\n"
+"  * Em ambos, você pode ter uma versão simples sem campos (_unit struct_, ou estrutura unitária) ou uma com diferentes tipos de campo.\n"
-"  * Em ambos, você pode ter uma versão simples sem campos (unit struct) ou uma com diferentes "
-"tipos de campos (variant payloads).\n"
 "  * Em ambos, as funções associadas são definidas dentro de um bloco `impl`.\n"
-"  * Você pode até mesmo implementar as diferentes variantes de uma Enum com Structs separadas, mas "
+"  * Você pode até mesmo implementar as diferentes variantes de uma _Enum_ com _Structs_ separadas, mas elas não seriam do mesmo tipo, como seriam se todas "
-"elas não seriam do mesmo tipo que seriam se todas fossem definidas em uma Enum.\n"
+"fossem definidas em uma _Enum_. "
-"</details>"
 
 #: src/enums/variant-payloads.md:1
 msgid "# Variant Payloads"
-msgstr "# Variantes de carga útil (payloads)"
+msgstr "# Conteúdos Variantes"
 
 #: src/enums/variant-payloads.md:3
 msgid ""
@@ -6210,7 +6308,7 @@ msgid ""
 "`match` statement to extract the data from each variant:"
 msgstr ""
 "Você pode definir enums mais ricos onde as variantes carregam dados. Você pode então usar a\n"
-"instrução `match` para extrair os dados de cada variante:"
+"instrução `match` (corresponder) para extrair os dados de cada variante:"
 
 #: src/enums/variant-payloads.md:6
 msgid ""
@@ -6241,9 +6339,34 @@ msgid ""
 "}\n"
 "```"
 msgstr ""
+"```rust,editable\n"
+"enum EventoWeb {\n"
+"    CarregarPagina,               // Variante sem conteúdo\n"
+"    TeclaPressionada(char), // Variante tupla\n"
+"    Clique { x: i64, y: i64 },   // Variante completa\n"
+"}\n"
+"\n"
+"#[rustfmt::skip]\n"
+"fn inspecionar(evento: EventoWeb) {\n"
+"    match evento {\n"
+"        EventoWeb::CarregarPagina       => println!(\"página carregada\"),\n"
+"        EventoWeb::TeclaPressionada(c)    => println!(\"pressionou '{c}'\"),\n"
+"        EventoWeb::Clique { x, y } => println!(\"clicou em x={x}, y={y}\"),\n"
+"    }\n"
+"}\n"
+"\n"
+"fn main() {\n"
+"    let carregar = EventoWeb::CarregarPagina;\n"
+"    let pressionar = EventoWeb::TeclaPressionada('x');\n"
+"    let clicar = EventoWeb::Clique { x: 20, y: 80 };\n"
+"\n"
+"    inspecionar(carregar);\n"
+"    inspecionar(pressionar);\n"
+"    inspecionar(clicar);\n"
+"}\n"
+"```"
 
 #: src/enums/variant-payloads.md:35
-#, fuzzy
 msgid ""
 "* The values in the enum variants can only be accessed after being pattern matched. The pattern "
 "binds references to the fields in the \"match arm\" after the `=>`.\n"
@@ -6263,13 +6386,20 @@ msgid ""
 "`struct Click { ... }`. The inlined version cannot implement traits, for example.  \n"
 "  "
 msgstr ""
-"* No exemplo acima, acessar o `char` em `KeyPress`, ou `x` e `y` em `Click` só funciona dentro de "
+"* Os valores nas variantes de uma _enum_ só podem ser acessados após uma correspondência de padrão. O padrão vincula referências aos campos no \"braço\" do "
-"uma instrução `match`\n"
+"_match_ após `=>`.\n"
-" ou em uma expressão `if let`.\n"
+"  * A expressão é comparada com os padrões de cima a baixo. Não existe _fall-through_ como em C ou C++.\n"
-"* `match` inspeciona um campo discriminante oculto no `enum`.\n"
+"  * A expressão _match_ possui um valor. O valor é o da última expressão executada em um \"braço\" do _match_.\n"
-"* É possível recuperar o campo discriminante chamando `std::mem::discriminant()`.\n"
+"  * Começando do topo, nós procuramos qual padrão corresponde ao valor, e então executamos o código após a flecha. Quando uma correspondência é encontrada, nós "
-"* `WebEvent::Click { ... }` não é exatamente o mesmo que `WebEvent::Click(Click)` com um `struct "
+"paramos. \n"
-"Click { ... }` de nível superior. A versão embutida não pode implementar traits, por exemplo."
+"* Demonstre o que acontece quando a busca não abrange todas as possibilidades. Mencione a vantagem que o compilador do Rust oferece confirmando quando todos os "
+"casos foram tratados. \n"
+"* `match` inspeciona um campo discriminant escondido na `enum`.\n"
+"* É possível recuperar o discriminante chamando `std::mem::discriminant()`\n"
+"  * Isso é útil, por exemplo, ao implementar `PartialEq` para _structs_ nas quais comparar valores de campos não afeta a igualdade.\n"
+"* `EventoWeb::Clique { ... }` não é exatamente o mesmo que `EventoWeb::Clique(Clique)` com uma `struct Clique { ... }` _top-level_. A versão no próprio local "
+"(_inline_) não permite implementar _traits_, por exemplo.  \n"
+"  "
 
 #: src/enums/sizes.md:1
 msgid "# Enum Sizes"
@@ -6277,12 +6407,9 @@ msgstr "# Tamanhos de Enum"
 
 #: src/enums/sizes.md:3
 msgid "Rust enums are packed tightly, taking constraints due to alignment into account:"
-msgstr ""
+msgstr "Enums, em Rust, são empacotados firmemente, levando em consideração as restrições devido ao alinhamento:"
-"Enums, em Rust, são empacotados firmemente, levando em consideração as restrições devido ao "
-"alinhamento:"
 
 #: src/enums/sizes.md:5
-#, fuzzy
 msgid ""
 "```rust,editable\n"
 "use std::mem::{align_of, size_of};\n"
@@ -6304,12 +6431,25 @@ msgid ""
 "}\n"
 "```"
 msgstr ""
+"```rust,editable\n"
+"use std::mem::{align_of, size_of};\n"
+"\n"
 "macro_rules! dbg_size {\n"
 "    ($t:ty) => {\n"
-"        println!(\"{}: tamano: {} byte(s), alinhamento: {} byte(s)\",\n"
+"        println!(\"{}: tamanho {} bytes, alinhamento: {} bytes\",\n"
 "                 stringify!($t), size_of::<$t>(), align_of::<$t>());\n"
 "    };\n"
-"}"
+"}\n"
+"\n"
+"enum Foo {\n"
+"    A,\n"
+"    B,\n"
+"}\n"
+"\n"
+"fn main() {\n"
+"    dbg_size!(Foo);\n"
+"}\n"
+"```"
 
 #: src/enums/sizes.md:25
 msgid "* See the [Rust Reference](https://doc.rust-lang.org/reference/type-layout.html)."
@@ -6444,6 +6584,129 @@ msgid ""
 "     }\n"
 "     ```"
 msgstr ""
+" * Internamente Rust utiliza um campo (discriminante) para saber qual a variante da _enum_.\n"
+"\n"
+" * É possível controlar a discriminante se necessário (e.g., para compatibilidade com C):\n"
+" \n"
+"     ```rust,editable\n"
+"     #[repr(u32)]\n"
+"     enum Bar {\n"
+"         A,  // 0\n"
+"         B = 10000,\n"
+"         C,  // 10001\n"
+"     }\n"
+"     \n"
+"     fn main() {\n"
+"         println!(\"A: {}\", Bar::A as u32);\n"
+"         println!(\"B: {}\", Bar::B as u32);\n"
+"         println!(\"C: {}\", Bar::C as u32);\n"
+"     }\n"
+"     ```\n"
+"\n"
+"    Sem `repr`, o tipo da discriminante usa 2 bytes, porque 10001 cabe em 2\n"
+"    bytes.\n"
+"\n"
+"\n"
+" * Tente outros tipos como\n"
+" \n"
+"     * `dbg_size!(bool)`: tamanho 1 bytes, alinhamento: 1 bytes,\n"
+"     * `dbg_size!(Option<bool>)`: tamanho 1 bytes, alinhamento: 1 bytes (otimização de nicho, seja abaixo),\n"
+"     * `dbg_size!(&i32)`: tamanho 8 bytes, alinhamento: 8 bytes (em uma máquina de 64-bits),\n"
+"     * `dbg_size!(Option<&i32>)`: tamanho 8 bytes, alinhamento: 8 bytes (otimização de ponteiro nulo, veja abaixo).\n"
+"\n"
+" * Otimização de nicho: Rust vai mesclar padrões de bits não utilizados na discriminante\n"
+"   da _enum_.\n"
+"\n"
+" * Otimização de ponteiro nulo: para [alguns\n"
+"   tipos](https://doc.rust-lang.org/std/option/#representation), o Rust garante\n"
+"   que `size_of::<T>()` se iguala `size_of::<Option<T>>()`.\n"
+"\n"
+"     Código de exemplo caso queira mostrar como a representação em bits *pode* ser na prática.\n"
+"     É importante apontar que o compilador não oferece nenhuma garantia a respeito dessa representação, portanto isso é completamente inseguro.\n"
+"\n"
+"     ```rust,editable\n"
+"     use std::mem::transmute;\n"
+"\n"
+"     macro_rules! dbg_bits {\n"
+"         ($e:expr, $bit_type:ty) => {\n"
+"             println!(\"- {}: {:#x}\", stringify!($e), transmute::<_, $bit_type>($e));\n"
+"         };\n"
+"     }\n"
+"\n"
+"     fn main() {\n"
+"         // TOTALMENTE INSEGURO. Rust não oferece nenhuma garantia sobre a\n"
+"         // representação dos tipos em bits.\n"
+"         unsafe {\n"
+"             println!(\"Representação em bits de booleano\");\n"
+"             dbg_bits!(false, u8);\n"
+"             dbg_bits!(true, u8);\n"
+"\n"
+"             println!(\"Representação em bits de Option<bool>\");\n"
+"             dbg_bits!(None::<bool>, u8);\n"
+"             dbg_bits!(Some(false), u8);\n"
+"             dbg_bits!(Some(true), u8);\n"
+"\n"
+"             println!(\"Representação em bits de Option<Option<bool>>\");\n"
+"             dbg_bits!(Some(Some(false)), u8);\n"
+"             dbg_bits!(Some(Some(true)), u8);\n"
+"             dbg_bits!(Some(None::<bool>), u8);\n"
+"             dbg_bits!(None::<Option<bool>>, u8);\n"
+"\n"
+"             println!(\"Representação em bits de Option<&i32>\");\n"
+"             dbg_bits!(None::<&i32>, usize);\n"
+"             dbg_bits!(Some(&0i32), usize);\n"
+"         }\n"
+"     }\n"
+"     ```\n"
+"\n"
+"     Exemplo mais complexo caso queira demonstrar o que acontece ao encadear mais de 256 `Option`s de uma vez.\n"
+"\n"
+"     ```rust,editable\n"
+"     #![recursion_limit = \"1000\"]\n"
+"\n"
+"     use std::mem::transmute;\n"
+"     \n"
+"     macro_rules! dbg_bits {\n"
+"         ($e:expr, $bit_type:ty) => {\n"
+"             println!(\"- {}: {:#x}\", stringify!($e), transmute::<_, $bit_type>($e));\n"
+"         };\n"
+"     }\n"
+"\n"
+"     // Macro que envolve um valor em 2^n Some() no qual n é o número de \"@\".\n"
+"     // É preciso aumentar o limite de recursão para aplicar essa macro.\n"
+"     macro_rules! muitos_options {\n"
+"         ($value:expr) => { Some($value) };\n"
+"         ($value:expr, @) => {\n"
+"             Some(Some($value))\n"
+"         };\n"
+"         ($value:expr, @ $($more:tt)+) => {\n"
+"             muitos_options!(muitos_options!($value, $($more)+), $($more)+)\n"
+"         };\n"
+"     }\n"
+"\n"
+"     fn main() {\n"
+"         // TOTALMENTE INSEGURO. Rust não oferece nenhuma garantia sobre a\n"
+"         // representação dos tipos em bits.\n"
+"         unsafe {\n"
+"             assert_eq!(muitos_options!(false), Some(false));\n"
+"             assert_eq!(muitos_options!(false, @), Some(Some(false)));\n"
+"             assert_eq!(muitos_options!(false, @@), Some(Some(Some(Some(false)))));\n"
+"\n"
+"             println!(\"Representação em bits de uma sequência de 128 Option's.\");\n"
+"             dbg_bits!(muitos_options!(false, @@@@@@@), u8);\n"
+"             dbg_bits!(muitos_options!(true, @@@@@@@), u8);\n"
+"\n"
+"             println!(\"Representação em bits de uma sequência de 256 Option's.\");\n"
+"             dbg_bits!(muitos_options!(false, @@@@@@@@), u16);\n"
+"             dbg_bits!(muitos_options!(true, @@@@@@@@), u16);\n"
+"\n"
+"             println!(\"Representação em bits de uma sequência de 257 Option's.\");\n"
+"             dbg_bits!(muitos_options!(Some(false), @@@@@@@@), u16);\n"
+"             dbg_bits!(muitos_options!(Some(true), @@@@@@@@), u16);\n"
+"             dbg_bits!(muitos_options!(None::<bool>, @@@@@@@@), u16);\n"
+"         }\n"
+"     }\n"
+"     ```"
 
 #: src/methods.md:3
 msgid ""