Um programa de verdade: adivinhe o número com stdin, parse e match

ENTENDA A IDEIA

A ideia central

Até aqui, os seus programas tinham dados fixos no código. Um programa de verdade conversa com alguém, e o outro lado pode digitar qualquer coisa: 50, mas também banana, uma linha vazia ou 999.

A entrada do teclado chega sempre como texto, com o Enter (\n) no final. trim() remove os espaços e a quebra de linha das pontas. Depois, parse() tenta transformar o texto em número. Sem o trim, "17\n" não é um número válido, e a conversão falha.

Nesta aula você monta o jogo de adivinhação do The Rust Book. Na próxima tela, corrija uma conversão que falha por causa do Enter.

Exemplo Rust

let typed = " 42\n";                  // o teclado entrega texto
let guess: u32 = typed.trim().parse()?; // texto vira número... ou erro
match guess.cmp(&secret) { /* menor, maior ou igual */ }

EXPERIMENTE

Edite e execute

O texto "17\n" tem o Enter no final, e parse falha: o braço Err mostra o texto com {typed:?}, que deixa o \n visível. Troque typed.parse::<u32>() por typed.trim().parse::<u32>(). Execute: o dobro deve ser 34.

Objetivo

Remova a quebra de linha antes da conversão para obter o número.

Saída esperada

dobro: 34

Rust 2021 · Edite e execute

fn main() {
    let typed = "17\n";
    match typed.parse::<u32>() {
        Ok(number) => println!("dobro: {}", number * 2),
        Err(_) => println!("não é um número: {typed:?}"),
    }
}

ENTENDA A IDEIA

A ideia central

Até aqui, os seus programas eram monólogos. Um programa de verdade é uma conversa, e a conversa tem um problema que o monólogo não tem: o outro lado pode dizer qualquer coisa. A diferença entre um programa de exemplo e um programa de produção é o que acontece com banana, com a linha vazia e com 999.

Rust não deixa você fingir que esses casos não existem. Em muitas linguagens, esquecer o caso de erro é um bug que espera o primeiro usuário. Em Rust, a conversão devolve um tipo que carrega o erro, e um programa que ignora esse tipo não compila.

Exemplo Rust

// exemplo: os dados estão no código, nada surpreende
let guess = 50;
// produção: o outro lado digita "banana", "" ou "999"

EXPERIMENTE

Edite e execute

O programa testa só duas entradas. Acrescente "" e "999" à lista. Execute: a linha vazia falha na conversão, mas 999 é um u32 válido. A faixa do jogo é outra regra, e a aula trata dela no exercício 3.

Objetivo

Teste a conversão com uma linha vazia e com um número fora da faixa.

Saída esperada

"50": Ok(50)
"banana": falhou
"": falhou
"999": Ok(999)

Rust 2021 · Edite e execute

fn main() {
    for typed in ["50", "banana"] {
        match typed.parse::<u32>() {
            Ok(value) => println!("{typed:?}: Ok({value})"),
            Err(_) => println!("{typed:?}: falhou"),
        }
    }
}

parse devolve Result: Ok ou ErrVídeo · 0:40 · legendas em português

ENTENDA A IDEIA

A ideia central

Exemplo Rust

match "42".trim().parse::<u32>() {
    Ok(value) => println!("número {value}"),   // deu certo
    Err(_) => println!("não é um u32"),         // deu errado
}
// "quarenta" e "-5" produzem Err para u32

EXPERIMENTE

Edite e execute

O braço Err imprime “número 0” e esconde o problema. Troque essa mensagem por "{typed}: inválido". Execute e repare que -3 também é inválido para u32.

Objetivo

Mostre inválido para os textos que não são um u32.

Saída esperada

8: número 8
oito: inválido
-3: inválido

Rust 2021 · Edite e execute

fn main() {
    for typed in ["8", "oito", "-3"] {
        match typed.parse::<u32>() {
            Ok(value) => println!("{typed}: número {value}"),
            Err(_) => println!("{typed}: número 0"),
        }
    }
}

CÓDIGO ANOTADO

Código anotado

Este é o início do jogo completo. Os imports trazem Ordering, a leitura de linhas (BufRead) e o flush (Write). O as _ importa o trait Write sem dar um nome a ele, porque o programa só usa os métodos. O segredo não é aleatório: um gerador de verdade vem da crate rand. Aqui, uma fórmula deriva o segredo de uma semente, e a mesma semente sempre produz o mesmo segredo.

A multiplicação estoura u32 para quase toda semente. Em um build de desenvolvimento, * com overflow causa panic. wrapping_mul e wrapping_add declaram que dar a volta é intencional: é aritmética modular. O % 100 + 1 leva o resultado para 1..=100.

Exemplo Rust

use std::cmp::Ordering;
use std::io::Write as _;
use std::io::{self, BufRead};

// secret_from_seed deriva o número secreto (1..=100) de uma semente,
// com um gerador congruencial: determinístico e testável.
fn secret_from_seed(seed: u32) -> u32 {
    seed.wrapping_mul(1_103_515_245).wrapping_add(12_345) % 100 + 1
}

EXPERIMENTE

Edite e execute

checked_mul devolve None, porque três bilhões vezes dois não cabe em u32. Para um gerador, a volta é o algoritmo. Troque checked_mul por wrapping_mul e o formato {mixed:?} por {mixed}. Execute.

Objetivo

Use a multiplicação que dá a volta de propósito em vez da que detecta o estouro.

Saída esperada

misturado: 1705032704

Rust 2021 · Edite e execute

fn main() {
    let big: u32 = 3_000_000_000;
    let mixed = big.checked_mul(2);
    println!("misturado: {mixed:?}");
}

ENTENDA A IDEIA

A ideia central

Por que o segredo não é aleatório? Um gerador aleatório de verdade vem da crate rand, e as dependências externas chegam mais adiante no curso. A fórmula da aula é da mesma família de geradores congruenciais que implementa o rand de muitas linguagens; as constantes vêm do C de BSD.

A mesma semente produz sempre o mesmo segredo. Isso torna o programa testável: os exercícios usam essa propriedade. O jogo continua a funcionar, porque quem joga não sabe a semente. Troque wrapping_mul por * e execute em debug: para toda semente maior que 3, o programa para com “attempt to multiply with overflow”. A semente 0 sobrevive.

Exemplo Rust

// gerador congruencial linear (constantes da família do C de BSD)
secret = (seed × 1103515245 + 12345) mod 2³², depois % 100 + 1

EXPERIMENTE

Edite e execute

Este irmão não interativo do jogo tabela os segredos de três sementes e o veredito de um palpite fixo de 50. Acrescente 42 e 2026 à lista de sementes. Antes de executar, preveja: alguma semente produz o segredo 50?

Objetivo

Tabele também os segredos das sementes 42 e 2026.

Saída esperada

semente    0 → segredo  46 (muito alto)
semente    1 → segredo  91 (muito baixo)
semente    7 → segredo  65 (muito baixo)
semente   42 → segredo  76 (muito baixo)
semente 2026 → segredo  96 (muito baixo)

Rust 2021 · Edite e execute

use std::cmp::Ordering;

fn secret_from_seed(seed: u32) -> u32 {
    seed.wrapping_mul(1_103_515_245).wrapping_add(12_345) % 100 + 1
}

fn respond(guess: u32, secret: u32) -> &'static str {
    match guess.cmp(&secret) {
        Ordering::Less => "muito baixo",
        Ordering::Greater => "muito alto",
        Ordering::Equal => "acertou",
    }
}

fn main() {
    for seed in [0, 1, 7] {
        let secret = secret_from_seed(seed);
        let verdict = respond(50, secret);
        println!("semente {seed:>4} → segredo {secret:>3} ({verdict})");
    }
}

DESAFIO

Derive o número secreto da semente

Escreva a função secret_from_seed, o gerador do jogo:

pub fn secret_from_seed(seed: u32) -> u32

Entrada: qualquer semente u32, inclusive 0.
Saída: o número secreto em 1..=100, derivado pela fórmula do gerador congruencial: multiplique a semente por 1_103_515_245 com transbordo modular, some 12_345 com transbordo modular e reduza com % 100 + 1.
Exemplo: secret_from_seed(42) devolve 76; secret_from_seed(0) devolve 46; secret_from_seed(1) devolve 91.
Restrições: o resultado deve estar sempre em 1..=100, e a função não pode entrar em panic para nenhuma semente, também em um build de desenvolvimento.

A restrição final é o ponto do exercício: a fórmula estoura u32 de propósito, e você deve usar a aritmética que declara isso. O stub só faz seed % 100 + 1, então ele acerta o caso da semente 0 por acaso e falha nos outros.

Edite stub.rs. Os controles mostram a execução disponível para este exercício.

Rust 2021 · stub.rs

// secret_from_seed deriva o número secreto (1..=100) da semente:
// multiplique por 1_103_515_245, some 12_345 — ambos com transbordo
// modular (wrapping) — e reduza com % 100 + 1. Sem panic para NENHUMA semente.
pub fn secret_from_seed(seed: u32) -> u32 {
    // implemente:
    seed % 100 + 1
}

Arquivos, contrato, dicas e solução

Exercício 1

Derive o número secreto da semente

stub.rs

// secret_from_seed deriva o número secreto (1..=100) da semente:
// multiplique por 1_103_515_245, some 12_345 — ambos com transbordo
// modular (wrapping) — e reduza com % 100 + 1. Sem panic para NENHUMA semente.
pub fn secret_from_seed(seed: u32) -> u32 {
    // implemente:
    seed % 100 + 1
}

harness.rs

fn json_escape(value: &str) -> String {
    value
        .replace('\\', "\\\\")
        .replace('"', "\\\"")
        .replace('\n', "\\n")
}

fn print_result(case: usize, pass: bool, input: &str, want: &str, got: &str) {
    println!(
        "RESULT {{\"case\":{case},\"pass\":{pass},\"input\":\"{}\",\"want\":\"{}\",\"got\":\"{}\"}}",
        json_escape(input),
        json_escape(want),
        json_escape(got)
    );
}

fn main() {
    let cases: [(u32, u32); 5] = [(42, 76), (0, 46), (1, 91), (7, 65), (2026, 96)];
    for (index, (seed, want)) in cases.iter().enumerate() {
        let got = secret_from_seed(*seed);
        let in_range = (1..=100).contains(&got);
        let pass = got == *want && in_range;
        print_result(
            index + 1,
            pass,
            &seed.to_string(),
            &want.to_string(),
            &got.to_string(),
        );
    }
}

cases.json

[
  {
    "case": 1,
    "input": "42",
    "want": "76"
  },
  {
    "case": 2,
    "input": "0",
    "want": "46"
  },
  {
    "case": 3,
    "input": "1",
    "want": "91"
  },
  {
    "case": 4,
    "input": "7",
    "want": "65"
  },
  {
    "case": 5,
    "input": "2026",
    "want": "96"
  }
]

Casos e valores esperados

Caso	Entrada	Valor esperado
1	`42`	`76`
2	`0`	`46`
3	`1`	`91`
4	`7`	`65`
5	`2026`	`96`

Execute com o Cargo local

Execute os comandos de preparação.
Copie os arquivos acima para os arquivos vazios com os mesmos nomes.
Execute a verificação de base. O stub deve mostrar o comportamento atual.

Comandos de preparação

cargo new --bin --edition 2024 imersao-05-primeiro-programa-exercicio-1
cd imersao-05-primeiro-programa-exercicio-1
touch stub.rs harness.rs cases.json
printf 'include!("../stub.rs");\ninclude!("../harness.rs");\n' > src/main.rs

Verificação de base — confirme o comportamento atual antes da mudança

cargo fmt --check
cargo run --bin imersao-05-primeiro-programa-exercicio-1
cargo clippy -- -D warnings

Abrir o Rust Playground (opcional)

Mostrar dicas

São três passos na ordem da fórmula: multiplicar pela constante, somar o incremento e reduzir com % 100 + 1 — use wrapping_mul e wrapping_add para o transbordo proposital.
seed.wrapping_mul(1103515245).wrapping_add(12345) % 100 + 1 — os métodos wrapping_* aplicam a aritmética modular que a fórmula exige sem panic em debug.

Revelar solução

solution.rs

// secret_from_seed deriva o número secreto (1..=100) da semente:
// multiplique por 1_103_515_245, some 12_345 — ambos com transbordo
// modular (wrapping) — e reduza com % 100 + 1. Sem panic para NENHUMA semente.
pub fn secret_from_seed(seed: u32) -> u32 {
    seed.wrapping_mul(1_103_515_245).wrapping_add(12_345) % 100 + 1
}

O gerador congruencial mistura a semente com multiplicação e soma módulo 2³², e o % 100 + 1 leva o resultado para 1..=100. A armadilha é usar * e + diretos: em debug, o transbordo intencional vira panic — wrapping_mul/wrapping_add declaram que dar a volta é o comportamento desejado.

A fórmula da aula, com a aritmética de transbordo explícita:

pub fn secret_from_seed(seed: u32) -> u32 {
    seed.wrapping_mul(1_103_515_245).wrapping_add(12_345) % 100 + 1
}

Os métodos wrapping_* calculam módulo 2³² sem reclamar: wrapping_mul mistura os bits da semente (a multiplicação por uma constante grande espalha a entrada pelos 32 bits) e wrapping_add desloca o resultado — é o miolo de um gerador congruencial linear. O % 100 leva para 0..=99 e o + 1 para 1..=100; esse último + não precisa de wrapping porque o máximo possível é 100, longe do limite. Custo O(1): três operações de inteiro.

A armadilha é exatamente a do experimento: escrever seed * 1_103_515_245 + 12_345 compila, mas o modo debug — o que você usa com cargo run — encerra com panic na primeira semente grande o suficiente (praticamente todas: qualquer seed > 3 já estoura). O caso seed = 0 do harness é o contraponto instrutivo: zero vezes qualquer coisa não estoura, então uma solução com * passaria nele e falharia nos outros — testes que só usam entradas pequenas escondem overflow. Os métodos irmãos checked_mul (devolve Option) e saturating_mul (trava no máximo) existem para quando o transbordo é erro; aqui ele é o algoritmo, e wrapping é a escolha que documenta isso.

CÓDIGO ANOTADO

Código anotado

guess.cmp(&secret) devolve um Ordering, um tipo com exatamente três valores: Less, Greater e Equal. Ele descreve o palpite em relação ao segredo: Less significa “palpite menor”, e a resposta é “muito baixo”.

O match é uma expressão, como o if: os três braços têm o mesmo tipo. Ele também é exaustivo. Sem o braço Equal, o compilador recusa o programa com E0004 e nomeia a variante esquecida: “non-exhaustive patterns: std::cmp::Ordering::Equal not covered”.

O & em &secret é um empréstimo: cmp só lê o valor. O módulo de ownership explica essa assinatura.

Exemplo Rust

// respond traduz a comparação palpite × segredo na resposta do jogo.
fn respond(guess: u32, secret: u32) -> &'static str {
    match guess.cmp(&secret) {
        Ordering::Less => "muito baixo",
        Ordering::Greater => "muito alto",
        Ordering::Equal => "acertou",
    }
}

ENTENDA A IDEIA

A ideia central

error[E0004]: non-exhaustive patterns: `std::cmp::Ordering::Equal` not covered
 --> src/main.rs:8:11
  |
8 |     match guess.cmp(&secret) {
  |           ^^^^^^^^^^^^^^^^^^ pattern `std::cmp::Ordering::Equal` not covered
  |
  = note: the matched value is of type `std::cmp::Ordering`
help: ensure that all possible cases are being handled by adding a match arm with a wildcard pattern or an explicit pattern as shown
  |
10 ~         Ordering::Greater => "muito alto",
11 ~         std::cmp::Ordering::Equal => todo!(),

Esta é a resposta do rustc 1.98 quando o braço Equal falta (sem as notas que apontam o código-fonte da biblioteca padrão). O compilador não diz “faltou um caso”: diz qual caso faltou.

Essa precisão vem do tipo: Ordering declara as suas três variantes, e o compilador confere o match contra a lista completa. Guarde essa sensação: nos módulos de enums, Option e Result mostram que este jogo já usava as ideias mais fortes da linguagem.

EXPERIMENTE

Edite e execute

O braço Ordering::Greater repete a resposta de Less. Troque o texto desse braço por "acima". Mantenha os três braços: o match continua exaustivo. Execute.

Objetivo

Corrija o braço Greater para classificar a temperatura acima do limite.

Saída esperada

25: abaixo
30: no limite
35: acima

Rust 2021 · Edite e execute

use std::cmp::Ordering;

fn main() {
    let limit = 30;
    for temperature in [25, 30, 35] {
        let label = match temperature.cmp(&limit) {
            Ordering::Less => "abaixo",
            Ordering::Greater => "abaixo",
            Ordering::Equal => "no limite",
        };
        println!("{temperature}: {label}");
    }
}

DESAFIO

Interprete o palpite com match sobre Ordering

Escreva a função respond, o juiz do jogo:

pub fn respond(guess: u32, secret: u32) -> &'static str

Entrada: o palpite do jogador e o número secreto.
Saída: "muito baixo" se o palpite é menor que o segredo; "muito alto" se é maior; "acertou" se são iguais.
Exemplo: respond(50, 76) devolve "muito baixo"; respond(80, 76) devolve "muito alto"; respond(76, 76) devolve "acertou".
Restrições: use match sobre o resultado de guess.cmp(&secret), sem if/else. Importe std::cmp::Ordering no seu arquivo.

Um if/else com < e > também resolveria, mas o objetivo é praticar o match exaustivo sobre um tipo de variantes conhecidas. Essa construção aparece no resto da trilha. O stub sempre devolve “muito baixo”.

Edite stub.rs. Os controles mostram a execução disponível para este exercício.

Rust 2021 · stub.rs

// respond compara o palpite com o segredo via guess.cmp(&secret) e devolve
// "muito baixo", "muito alto" ou "acertou". Use match sobre Ordering —
// sem if/else. Importe std::cmp::Ordering.
pub fn respond(guess: u32, secret: u32) -> &'static str {
    // implemente:
    let _ = (guess, secret);
    "muito baixo"
}

Arquivos, contrato, dicas e solução

Exercício 2

Interprete o palpite com match sobre Ordering

stub.rs

// respond compara o palpite com o segredo via guess.cmp(&secret) e devolve
// "muito baixo", "muito alto" ou "acertou". Use match sobre Ordering —
// sem if/else. Importe std::cmp::Ordering.
pub fn respond(guess: u32, secret: u32) -> &'static str {
    // implemente:
    let _ = (guess, secret);
    "muito baixo"
}

harness.rs

fn json_escape(value: &str) -> String {
    value
        .replace('\\', "\\\\")
        .replace('"', "\\\"")
        .replace('\n', "\\n")
}

fn print_result(case: usize, pass: bool, input: &str, want: &str, got: &str) {
    println!(
        "RESULT {{\"case\":{case},\"pass\":{pass},\"input\":\"{}\",\"want\":\"{}\",\"got\":\"{}\"}}",
        json_escape(input),
        json_escape(want),
        json_escape(got)
    );
}

fn main() {
    let cases: [(u32, u32, &str); 5] = [
        (50, 76, "muito baixo"),
        (80, 76, "muito alto"),
        (76, 76, "acertou"),
        (1, 100, "muito baixo"),
        (100, 1, "muito alto"),
    ];
    for (index, (guess, secret, want)) in cases.iter().enumerate() {
        let got = respond(*guess, *secret);
        let pass = got == *want;
        print_result(index + 1, pass, &format!("({guess}, {secret})"), want, got);
    }
}

cases.json

[
  {
    "case": 1,
    "input": "(50, 76)",
    "want": "muito baixo"
  },
  {
    "case": 2,
    "input": "(80, 76)",
    "want": "muito alto"
  },
  {
    "case": 3,
    "input": "(76, 76)",
    "want": "acertou"
  },
  {
    "case": 4,
    "input": "(1, 100)",
    "want": "muito baixo"
  },
  {
    "case": 5,
    "input": "(100, 1)",
    "want": "muito alto"
  }
]

Casos e valores esperados

Caso	Entrada	Valor esperado
1	`(50, 76)`	`muito baixo`
2	`(80, 76)`	`muito alto`
3	`(76, 76)`	`acertou`
4	`(1, 100)`	`muito baixo`
5	`(100, 1)`	`muito alto`

Execute com o Cargo local

Execute os comandos de preparação.
Copie os arquivos acima para os arquivos vazios com os mesmos nomes.
Execute a verificação de base. O stub deve mostrar o comportamento atual.

Comandos de preparação

cargo new --bin --edition 2024 imersao-05-primeiro-programa-exercicio-2
cd imersao-05-primeiro-programa-exercicio-2
touch stub.rs harness.rs cases.json
printf 'include!("../stub.rs");\ninclude!("../harness.rs");\n' > src/main.rs

Verificação de base — confirme o comportamento atual antes da mudança

cargo fmt --check
cargo run --bin imersao-05-primeiro-programa-exercicio-2
cargo clippy -- -D warnings

Abrir o Rust Playground (opcional)

Mostrar dicas

guess.cmp(&secret) devolve um Ordering com exatamente três variantes; um match sobre elas escolhe a resposta — importe std::cmp::Ordering no topo.
Ordering::Less → "muito baixo", Ordering::Greater → "muito alto", Ordering::Equal → "acertou" — cuidado com a perspectiva: Less significa que o PALPITE é menor.

Revelar solução

solution.rs

use std::cmp::Ordering;

// respond compara o palpite com o segredo via guess.cmp(&secret) e devolve
// "muito baixo", "muito alto" ou "acertou". Use match sobre Ordering —
// sem if/else. Importe std::cmp::Ordering.
pub fn respond(guess: u32, secret: u32) -> &'static str {
    match guess.cmp(&secret) {
        Ordering::Less => "muito baixo",
        Ordering::Greater => "muito alto",
        Ordering::Equal => "acertou",
    }
}

cmp compara palpite com segredo e o match exaustivo cobre as três variantes de Ordering — esquecer uma não compila (E0004). A armadilha é inverter a perspectiva: Ordering::Less descreve o palpite em relação ao segredo, não o contrário.

O match de três braços sobre o Ordering:

use std::cmp::Ordering;

pub fn respond(guess: u32, secret: u32) -> &'static str {
    match guess.cmp(&secret) {
        Ordering::Less => "muito baixo",
        Ordering::Greater => "muito alto",
        Ordering::Equal => "acertou",
    }
}

cmp responde a pergunta “como o receptor se compara ao argumento?” — e a ordem importa: guess.cmp(&secret) descreve o palpite, então Less é palpite baixo e a resposta é “muito baixo”. Inverter para secret.cmp(&guess) compila, passa no caso do empate e erra os outros dois com as mensagens trocadas — os casos do harness pegam a inversão imediatamente. Custo O(1), uma comparação.

A vantagem estrutural sobre o if/else aparece na manutenção: o match é auditado contra as variantes do tipo. Se um dia você trocar a comparação por um tipo com mais casos, o compilador apontará cada match incompleto no programa — o if/else silenciosamente deixaria o caso novo cair no ramo errado. Uma nota sobre a tentação do curinga: _ => "acertou" como último braço também compila, mas joga fora a exaustividade — se Ordering ganhasse uma variante (não vai, mas seus enums vão), o curinga a engoliria sem aviso. Escreva as três variantes por extenso; é documentação que o compilador confere.

CÓDIGO ANOTADO

Código anotado

O segredo nasce da semente 42; troque o número para mudar o jogo. io::stdin() dá acesso à entrada padrão, e stdin.lock().lines() cria um iterador que entrega uma linha digitada de cada vez.

lines precisa de mut, porque cada leitura avança o iterador. A partir daqui, o programa espera o jogador.

Este jogo lê o teclado, então execute-o no seu projeto local (cargo new adivinhe), com os seis blocos anotados em src/main.rs. O editor desta trilha aceita uma entrada padrão antes da execução, mas não conversa com você durante o programa.

Exemplo Rust

fn main() {
    let secret = secret_from_seed(42);
    let stdin = io::stdin();
    let mut lines = stdin.lock().lines();
    println!("Adivinhe o número entre 1 e 100!");

CÓDIGO ANOTADO

Código anotado

print!, sem ln, deixa o cursor na linha do prompt. O flush envia o texto ao terminal antes de o programa esperar a digitação.

lines.next() devolve Option<Result<String, _>>: pode não haver linha (fim da entrada, com Ctrl+D), e a leitura pode falhar. O let ... else desempacota o caminho feliz, Some(Ok(line)). Qualquer outro caso cai no else, que precisa sair do fluxo: aqui, um break encerra o jogo e mostra o segredo.

Exemplo Rust

    loop {
        print!("palpite> ");
        io::stdout().flush().expect("falha ao escrever no terminal");
        let Some(Ok(line)) = lines.next() else {
            println!("entrada encerrada — o segredo era {secret}");
            break;
        };

EXPERIMENTE

Edite e execute

O else usa continue e pula a linha vazia. Uma linha vazia deve encerrar a leitura: troque continue por break. Execute. A terceira linha não deve aparecer.

Objetivo

Encerre a leitura na primeira linha vazia, em vez de pular a linha.

Saída esperada

começa com 4
linha vazia

Rust 2021 · Edite e execute

fn main() {
    for line in ["40", "", "77"] {
        let Some(first) = line.chars().next() else {
            println!("linha vazia");
            continue;
        };
        println!("começa com {first}");
    }
}

CÓDIGO ANOTADO

Código anotado

Este é o centro da aula. trim() remove o Enter; sem ele, todo palpite falha. parse() converte para o tipo anotado em guess: u32 e devolve um Result.

O braço Ok entrega o número à variável. O braço Err reclama e usa continue para voltar ao topo do loop, sem comparar nada. Digitar -5 também cai no Err: o tipo u32 já fez essa validação.

Exemplo Rust

        let guess: u32 = match line.trim().parse() {
            Ok(value) => value,
            Err(_) => {
                println!("isso não é um número entre 1 e 100 — tente de novo");
                continue;
            }
        };

Uma partida inteira, rodada a rodadaVídeo · 1:00 · legendas em português

CÓDIGO ANOTADO

Código anotado

Exemplo Rust

        let answer = respond(guess, secret);
        println!("{answer}");
        if answer == "acertou" {
            break;
        }
    }
}

A resposta sai de respond, e o break encerra o loop no acerto. Uma partida com a semente 42 (segredo 76), com a saída e o que o jogador digita:

Adivinhe o número entre 1 e 100!
palpite> 50
muito baixo
palpite> oitenta
isso não é um número entre 1 e 100 — tente de novo
palpite> 80
muito alto
palpite> 76
acertou

Cada rodada passa por ler, converter e comparar. Os dois desvios, um texto inválido e um palpite errado, voltam ao topo do laço.

EXPERIMENTE

Edite e execute

Esta simulação usa uma lista no lugar do teclado e continua depois do acerto. Logo depois do println! da resposta, acrescente if answer == "acertou" { break; }. Execute: o palpite 40 não deve aparecer.

Objetivo

Encerre a simulação do jogo no acerto.

Saída esperada

10: muito baixo
vinte: não é um número
30: muito alto
23: acertou

Rust 2021 · Edite e execute

use std::cmp::Ordering;

fn respond(guess: u32, secret: u32) -> &'static str {
    match guess.cmp(&secret) {
        Ordering::Less => "muito baixo",
        Ordering::Greater => "muito alto",
        Ordering::Equal => "acertou",
    }
}

fn main() {
    let secret = 23;
    for typed in ["10", "vinte", "30", "23", "40"] {
        let guess: u32 = match typed.trim().parse() {
            Ok(value) => value,
            Err(_) => {
                println!("{typed}: não é um número");
                continue;
            }
        };
        let answer = respond(guess, secret);
        println!("{typed}: {answer}");
    }
}

PASSO A PASSO

O ciclo do jogo: ler, validar, comparar

VISUALIZAÇÃOO ciclo do jogo: ler, validar, comparar

1 / 5

ENTENDA A IDEIA

A ideia central

Três desvios apareceram nesta aula. Só o primeiro o compilador recusa antes da execução: ele conhece todas as variantes de Ordering. O trim ausente é uma questão de lógica, e o programa compila; você o descobre quando todo palpite vira “não é um número”. O overflow de * aparece como panic em um build de desenvolvimento.

Por isso as validações se apoiam em tipos sempre que possível: o que o tipo garante, o compilador confere. O que fica de fora, os testes precisam cobrir, como o caso da semente 0 mostra no exercício 1.

Este programa fecha o módulo: as variáveis e os tipos da aula 3, as funções e os laços da aula 4, e Result e match, que acompanham o resto do curso.

Exemplo Rust

// variante esquecida no match → E0004, antes de executar
// trim ausente               → todo palpite falha, na execução
// * no lugar de wrapping_mul → panic de overflow, na execução

DESAFIO

Valide a rodada inteira: parse + faixa + veredito

Escreva a função judge_round, que processa uma rodada completa a partir do texto digitado:

pub fn judge_round(input: &str, secret: u32) -> &'static str

Entrada: a linha digitada pelo jogador (pode conter o \n do Enter, espaços ou qualquer texto) e o número secreto.
Saída: "inválido" se o texto não é um u32; "fora da faixa" se é um u32 fora de 1..=100; nos outros casos, o veredito de respond.
Exemplo: judge_round("50\n", 76) devolve "muito baixo"; judge_round("banana", 76) devolve "inválido"; judge_round("999", 76) devolve "fora da faixa"; judge_round(" 76 ", 76) devolve "acertou".
Restrições: remova o \n e os espaços das pontas antes do parse; confira a faixa antes da comparação. O arquivo do exercício já traz respond pronta para você usar.

Esta é a síntese da aula: os três portões (conversão, faixa e comparação), na ordem do loop do jogo. O stub ignora a entrada e compara 0 com o segredo.

Edite stub.rs. Os controles mostram a execução disponível para este exercício.

Rust 2021 · stub.rs

use std::cmp::Ordering;

// respond é a função do exercício anterior — já pronta para você reusar.
pub fn respond(guess: u32, secret: u32) -> &'static str {
    match guess.cmp(&secret) {
        Ordering::Less => "muito baixo",
        Ordering::Greater => "muito alto",
        Ordering::Equal => "acertou",
    }
}

// judge_round processa a linha crua digitada: texto que não parseia como
// u32 → "inválido"; número fora de 1..=100 → "fora da faixa"; senão, o
// veredito de respond. Lembre do trim antes do parse.
pub fn judge_round(input: &str, secret: u32) -> &'static str {
    // implemente:
    let _ = input;
    respond(0, secret)
}

Arquivos, contrato, dicas e solução

Exercício 3

Valide a rodada inteira: parse + faixa + veredito

stub.rs

use std::cmp::Ordering;

// respond é a função do exercício anterior — já pronta para você reusar.
pub fn respond(guess: u32, secret: u32) -> &'static str {
    match guess.cmp(&secret) {
        Ordering::Less => "muito baixo",
        Ordering::Greater => "muito alto",
        Ordering::Equal => "acertou",
    }
}

// judge_round processa a linha crua digitada: texto que não parseia como
// u32 → "inválido"; número fora de 1..=100 → "fora da faixa"; senão, o
// veredito de respond. Lembre do trim antes do parse.
pub fn judge_round(input: &str, secret: u32) -> &'static str {
    // implemente:
    let _ = input;
    respond(0, secret)
}

harness.rs

fn json_escape(value: &str) -> String {
    value
        .replace('\\', "\\\\")
        .replace('"', "\\\"")
        .replace('\n', "\\n")
}

fn print_result(case: usize, pass: bool, input: &str, want: &str, got: &str) {
    println!(
        "RESULT {{\"case\":{case},\"pass\":{pass},\"input\":\"{}\",\"want\":\"{}\",\"got\":\"{}\"}}",
        json_escape(input),
        json_escape(want),
        json_escape(got)
    );
}

fn main() {
    let cases: [(&str, u32, &str); 6] = [
        ("50\n", 76, "muito baixo"),
        ("banana", 76, "inválido"),
        ("999", 76, "fora da faixa"),
        (" 76 ", 76, "acertou"),
        ("-5", 76, "inválido"),
        ("0", 76, "fora da faixa"),
    ];
    for (index, (input, secret, want)) in cases.iter().enumerate() {
        let got = judge_round(input, *secret);
        let pass = got == *want;
        print_result(
            index + 1,
            pass,
            &format!("({input:?}, {secret})"),
            want,
            got,
        );
    }
}

cases.json

[
  {
    "case": 1,
    "input": "(\"50\\n\", 76)",
    "want": "muito baixo"
  },
  {
    "case": 2,
    "input": "(\"banana\", 76)",
    "want": "inválido"
  },
  {
    "case": 3,
    "input": "(\"999\", 76)",
    "want": "fora da faixa"
  },
  {
    "case": 4,
    "input": "(\" 76 \", 76)",
    "want": "acertou"
  },
  {
    "case": 5,
    "input": "(\"-5\", 76)",
    "want": "inválido"
  },
  {
    "case": 6,
    "input": "(\"0\", 76)",
    "want": "fora da faixa"
  }
]

Casos e valores esperados

Caso	Entrada	Valor esperado
1	`("50\n", 76)`	`muito baixo`
2	`("banana", 76)`	`inválido`
3	`("999", 76)`	`fora da faixa`
4	`(" 76 ", 76)`	`acertou`
5	`("-5", 76)`	`inválido`
6	`("0", 76)`	`fora da faixa`

Execute com o Cargo local

Execute os comandos de preparação.
Copie os arquivos acima para os arquivos vazios com os mesmos nomes.
Execute a verificação de base. O stub deve mostrar o comportamento atual.

Comandos de preparação

cargo new --bin --edition 2024 imersao-05-primeiro-programa-exercicio-3
cd imersao-05-primeiro-programa-exercicio-3
touch stub.rs harness.rs cases.json
printf 'include!("../stub.rs");\ninclude!("../harness.rs");\n' > src/main.rs

Verificação de base — confirme o comportamento atual antes da mudança

cargo fmt --check
cargo run --bin imersao-05-primeiro-programa-exercicio-3
cargo clippy -- -D warnings

Abrir o Rust Playground (opcional)

Mostrar dicas

Três portões em sequência: trim().parse::<u32>() falhou? "inválido". Fora de 1..=100? "fora da faixa". Passou? Delegue para a comparação do exercício anterior.
match input.trim().parse::<u32>() { Err(_) => ..., Ok(guess) => ... } — e dentro do Ok, um if com !(1..=100).contains(&guess) antes do veredito.

Revelar solução

solution.rs

use std::cmp::Ordering;

// respond é a função do exercício anterior — já pronta para você reusar.
pub fn respond(guess: u32, secret: u32) -> &'static str {
    match guess.cmp(&secret) {
        Ordering::Less => "muito baixo",
        Ordering::Greater => "muito alto",
        Ordering::Equal => "acertou",
    }
}

// judge_round processa a linha crua digitada: texto que não parseia como
// u32 → "inválido"; número fora de 1..=100 → "fora da faixa"; senão, o
// veredito de respond. Lembre do trim antes do parse.
pub fn judge_round(input: &str, secret: u32) -> &'static str {
    match input.trim().parse::<u32>() {
        Err(_) => "inválido",
        Ok(guess) if !(1..=100).contains(&guess) => "fora da faixa",
        Ok(guess) => respond(guess, secret),
    }
}

O match sobre o Result separa entrada inválida de número válido, e o teste de faixa filtra antes de comparar — a ordem dos portões importa. A armadilha é esquecer o trim: a entrada do teclado vem com \n, e "50\n" não parseia.

O match sobre o Result distribui os caminhos, e os portões se encadeiam:

use std::cmp::Ordering;

pub fn respond(guess: u32, secret: u32) -> &'static str {
    match guess.cmp(&secret) {
        Ordering::Less => "muito baixo",
        Ordering::Greater => "muito alto",
        Ordering::Equal => "acertou",
    }
}

pub fn judge_round(input: &str, secret: u32) -> &'static str {
    match input.trim().parse::<u32>() {
        Err(_) => "inválido",
        Ok(guess) if !(1..=100).contains(&guess) => "fora da faixa",
        Ok(guess) => respond(guess, secret),
    }
}

Três decisões sustentam a solução. Primeira: trim() antes do parse — sem ele, o caso "50\n" do harness devolve “inválido” e o jogo real seria injogável; é a armadilha que o experimento demonstrou. Segunda: o match guard if !(1..=100).contains(&guess) no segundo braço — um braço de match pode carregar uma condição extra, e o range com contains lê como a regra que é (“está fora de 1..=100?”). Terceira: a ordem dos portões — validar a faixa antes de comparar evita responder “muito alto” para 999, que tecnicamente é maior que o segredo, mas é antes de tudo um palpite ilegal.

O caso " 76 " cobra a generosidade do trim com espaços, e o "-5" (está no harness) reforça o achado da aula: u32 rejeita negativos no próprio parse, sem código seu. A alternativa de parsear para i64 e validar o sinal manualmente funciona, mas reimplementa o que o tipo já garante — deixar o sistema de tipos validar é o hábito que separa Rust idiomático de Rust traduzido de outra linguagem. Custo total: O(n) no comprimento do texto (o parse percorre os dígitos), comparações O(1) depois.

ENTENDA A IDEIA

A ideia central

Em Java, Scanner.nextInt() lança InputMismatchException quando o usuário digita texto. É uma exceção unchecked: o compilador não obriga ninguém a capturá-la, e ela estoura durante a execução.

O parse do Rust não lança nada: devolve Result<u32, ParseIntError>, um valor comum que você inspeciona com match. O caminho do erro está no tipo de retorno. O switch com pattern matching das versões recentes de Java chegou perto, mas o compareTo devolve um int qualquer; o cmp do Rust devolve um Ordering com três variantes, e o match confere todas.

Exemplo Rust

// Java: Scanner.nextInt() lança InputMismatchException
// Rust: parse devolve Result<u32, ParseIntError>
let parsed: Result<u32, std::num::ParseIntError> = "oito".parse();

ENTENDA A IDEIA

A ideia central

Trate o Result onde ele nasce e deixe o valor validado seguir adiante. O capítulo 2 do The Rust Book, que constrói este mesmo jogo, usa esse padrão: depois do Ok, o resto do programa trabalha com um u32, sem validar de novo.

Para faixas, o lint clippy::manual_range_contains sugere (1..=100).contains(&guess) no lugar de guess >= 1 && guess <= 100: o range mostra as bordas em uma expressão. Em Rust, validação não é uma fase do programa: é uma fronteira de tipos, com texto de um lado e um número garantido do outro.

Exemplo Rust

let guess: u32 = match line.trim().parse() {
    Ok(value) => value,
    Err(_) => continue,
};
let in_range = (1..=100).contains(&guess); // e não: guess >= 1 && guess <= 100

RESUMO DA AULA

O que você leva desta aula

O teclado entrega texto com \n: use trim() antes de parse(); esquecer é a falha número um em programas de linha de comando.
parse::<u32>() devolve Result: Ok(valor) ou Err(erro); u32 já rejeita negativos.
match sobre Ordering é exaustivo: uma variante esquecida causa E0004.
wrapping_* declara um transbordo intencional, checked_* trata o transbordo como erro, e * com overflow causa panic em debug.
O ciclo ler → converter → comparar, com continue e break, é o esqueleto de uma ferramenta de linha de comando.
Na próxima aula: o que acontece quando um valor entra e sai de uma função? Pilha, heap e o custo de cada valor abrem o ownership.

+280 XPpossíveis nesta aula

A ideia central

Edite e execute

Objetivo

Saída esperada

A ideia central

Edite e execute

Objetivo

Saída esperada

A ideia central

Edite e execute

Objetivo

Saída esperada

Código anotado

Edite e execute

Objetivo

Saída esperada

A ideia central

Edite e execute

Objetivo

Saída esperada

Derive o número secreto da semente

Casos e valores esperados

Execute com o Cargo local

Código anotado

A ideia central

Edite e execute

Objetivo

Saída esperada

Interprete o palpite com match sobre Ordering

Casos e valores esperados

Execute com o Cargo local

Código anotado

Código anotado

Edite e execute

Objetivo

Saída esperada

Código anotado

Código anotado

Edite e execute

Objetivo

Saída esperada

O ciclo do jogo: ler, validar, comparar

A ideia central

Valide a rodada inteira: parse + faixa + veredito

Casos e valores esperados

Execute com o Cargo local

A ideia central

A ideia central

O que você leva desta aula

Você transformou esta ideia em prática.