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

ENTENDA A IDEIA

A ideia central

Até aqui, todos os seus programas foram monólogos: dados fixos no código, saída previsível, nenhuma surpresa. Programas de verdade são conversas — e conversas têm um problema que os monólogos não têm: o outro lado pode dizer qualquer coisa. Quando você pede um número entre 1 e 100, o usuário pode digitar 50, mas também banana, uma linha vazia, ou 999. A diferença entre um programa de exemplo e um programa de produção é o que acontece nesses três últimos casos — e Rust foi desenhado para não deixar você fingir que eles não existem.

Exemplo Rust

let mut guess = String::new();
io::stdin().read_line(&mut guess)?;   // o mundo entra como texto
let guess: u32 = guess.trim().parse()?; // texto vira número... ou erro
match guess.cmp(&secret) { /* três casos, nenhum esquecido */ }

ENTENDA A IDEIA

A ideia central

O laboratório perfeito para essa conversa é o jogo mais tradicional do aprendizado de Rust, o mesmo que abre o The Rust Book: o programa escolhe um número secreto, você chuta, ele responde “muito alto” ou “muito baixo” até você acertar. O jogo é pequeno, mas atravessa a fronteira mais importante da programação: a entrada do teclado chega como texto, sempre — e texto precisa virar número antes de qualquer comparação. Essa conversão pode falhar, e é aqui que Rust mostra sua personalidade: parse não devolve um número, devolve um Result — um tipo que carrega ou o número (Ok) ou o erro (Err), e que o compilador se recusa a deixar você usar sem decidir o que fazer em cada caso. Em outras linguagens, esquecer o caso de erro é um bug à espera; em Rust, é um programa que não compila.

ENTENDA A IDEIA

A ideia central

A segunda peça nova é o match — e a comparação de palpite com segredo é sua estreia ideal. O método cmp devolve um Ordering, um tipo com exatamente três valores possíveis: Less, Greater, Equal. O match distribui o fluxo entre eles com uma garantia que o if/else não oferece: exaustividade. Se você escrever só dois dos três casos, o erro E0004 lista exatamente qual variante falta — o compilador conhece todas as possibilidades do tipo e cobra cada uma. Guarde essa sensação: ela é o coração dos módulos de enums e pattern matching, onde Option e Result vão revelar que este jogo já usava as ideias mais poderosas da linguagem.

ENTENDA A IDEIA

A ideia central

Uma decisão de design desta versão merece explicação honesta: o número secreto não é aleatório. Geradores de aleatoriedade de verdade vêm da crate rand, que você conhecerá quando o curso chegar a dependências externas; aqui, o segredo é derivado de uma semente com uma fórmula determinística — a mesma família de geradores congruenciais que implementa o rand de muitas linguagens. A mesma semente produz sempre o mesmo segredo, o que torna o programa testável (os exercícios aproveitam isso) e o jogo continua funcionando: quem joga não sabe a semente do dia, então não sabe o segredo.

ENTENDA A IDEIA

A ideia central

O que este programa fecha é o módulo inteiro: as variáveis e tipos da aula 3, as funções e laços da aula 4, e as duas caras novas — Result e match — que definem o resto do curso. Quando terminar, você terá escrito um programa que lê, valida, decide e repete: o esqueleto de todo CLI que existe.

Em Java, a leitura com Scanner.nextInt() lança InputMismatchException se o usuário digitar texto — uma exceção unchecked que o compilador não obriga ninguém a capturar, e que estoura em runtime se esquecida. O parse do Rust não lança nada: devolve Result<u32, ParseIntError>, um valor comum que você inspeciona com match. A diferença é de contrato: em Java, o caminho do erro é invisível na assinatura e opcional no código; em Rust, ele está no tipo de retorno e o compilador cobra o tratamento. O match sobre Ordering também tem um primo em Java — o switch com pattern matching dos Javas recentes chegou perto —, mas a exaustividade verificada sobre os três valores de compareTo (que em Java é um int qualquer, não um tipo de três variantes) continua sendo o diferencial.

CÓDIGO ANOTADO

Código anotado

O programa completo do jogo. Crie o projeto (cargo new adivinhe), substitua src/main.rs e jogue com cargo run. A versão interativa conversa com você pelo terminal; os trechos de leitura são exatamente os que o carrossel diagrama.

src/main.rs

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

CÓDIGO ANOTADO

Código anotado

Três imports do std. Ordering é o tipo de três variantes que o cmp devolve. BufRead traz a leitura de linhas e Write traz o flush — o as _ importa o trait sem nomear, porque só precisamos dos métodos. io::self traz o módulo para chamar io::stdin() e io::stdout().

src/main.rs

// 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
}

CÓDIGO ANOTADO

Código anotado

A fórmula é um gerador congruencial linear clássico (as constantes vêm da família usada pelo C de BSD): multiplica a semente, soma um incremento e deixa o transbordo de 32 bits fazer a mistura. O detalhe importante é o par wrapping_mul/wrapping_add: a multiplicação vai estourar u32 para quase toda semente, e você aprendeu na aula de tipos que overflow em debug é panic. Os métodos wrapping_* declaram que dar a volta é intencional — aritmética modular, não acidente. O % 100 + 1 reduz o resultado para a faixa 1..=100 do jogo.

src/main.rs

// 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",
    }
}

CÓDIGO ANOTADO

Código anotado

Aqui está o match exaustivo da aula. guess.cmp(&secret) compara os dois números e devolve a variante que descreve o palpite em relação ao segredo — Less significa “palpite menor que o segredo”, e a resposta certa é “muito baixo”. Os três braços têm o mesmo tipo (o match é uma expressão, como o if da aula passada) e cobrem as três variantes; apague qualquer braço e o E0004 aparece nomeando a variante esquecida. O & em &secret é um empréstimo — cmp só precisa ler o valor; o módulo de ownership explica essa assinatura em profundidade.

src/main.rs

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

O segredo nasce da semente 42 — troque o número para mudar o jogo. stdin.lock().lines() prepara um iterador de linhas do teclado; lines precisa ser mut porque cada leitura avança o iterador. A partir daqui, o programa entra na conversa.

src/main.rs

    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;
        };

CÓDIGO ANOTADO

Código anotado

Duas miudezas de terminal e uma construção nova. print! sem ln deixa o cursor na mesma linha do prompt, e o flush garante que o texto apareça antes de o programa bloquear esperando a digitação. O let ... else desempacota a próxima linha: lines.next() devolve `Option<Result

— pode não haver linha (fim da entrada, Ctrl+D) ou a leitura pode falhar. O padrãoSome(Ok(line))cobre o caminho feliz; qualquer outro caso cai noelse`, que encerra o jogo com elegância revelando o segredo.

src/main.rs

        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;
            }
        };

CÓDIGO ANOTADO

Código anotado

O coração da aula. A linha digitada vem com o \n do Enter grudado — trim() o remove (esquecê-lo faz todo parse falhar, a armadilha mais comum deste programa). parse() tenta converter o texto para o tipo anotado em guess: u32 e devolve Result: o match desempacota o Ok para dentro da variável e trata o Err reclamando e usando continue para voltar ao topo do loop. Repare que digitar -5 também cai no Err: u32 não representa negativos, e o parse falha na conversão — o tipo escolhido já validou de graça.

O fechamento amarra as peças: a resposta sai da função do chunk 3, e o break encerra o loop no acerto. Uma partida completa com a semente 42 (segredo: 76) tem esta cara — a saída do programa intercalada com 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

Releia a partida acompanhando o carrossel: cada linha percorre o ciclo lê → parse → compara, com os dois desvios (parse falhou, palpite errado) voltando ao topo. Esse ciclo — ler, validar, decidir, repetir — é o esqueleto de qualquer ferramenta de linha de comando, e você acabou de escrevê-lo inteiro.

src/main.rs

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

PASSO A PASSO

O ciclo do jogo: ler, validar, comparar

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

1 / 5

PRÁTICA LOCAL

Pratique no seu computador

Jogue primeiro: rode o programa da aula com cargo run e vença o segredo da semente 42. Depois, com o programa aberto, faça três explorações — prevendo o comportamento antes de cada cargo run:

Este é um irmão não interativo do jogo: em vez de ler do teclado, tabula os segredos de cinco sementes e o veredito de um palpite fixo de 50. Preveja: alguma semente produz segredo igual a 50?

Apague o braço Ordering::Equal do match em respond. O compilador responde com o erro da aula — leia a mensagem inteira:

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
  |
  ~         std::cmp::Ordering::Equal => todo!(),

O compilador não disse “faltou um caso” — disse qual caso faltou. Essa precisão vem do tipo: Ordering declara suas três variantes, e o match é auditado contra a lista completa.

No programa interativo da aula, troque line.trim().parse() por line.parse() e jogue. Todo palpite vira “isso não é um número” — o \n invisível do Enter sabota o parse. Essa é a armadilha número um de quem lê stdin em Rust; agora ela já mordeu você em ambiente controlado.
Troque wrapping_mul por * na fórmula e rode em modo debug. Para quais sementes da tabela o programa entra em panic com “attempt to multiply with overflow”? Confira sua previsão — e note que a semente 0 sobrevive.

A pergunta central: dos três desvios (variante esquecida, trim ausente, overflow), quais o compilador pegou antes de rodar e quais só apareceram na execução?

Adapte o trecho no projeto local da aula. Confira a saída esperada no enunciado.

O navegador não executa Rust. O registro abaixo confirma seu estudo, não um resultado de teste.

Pratique no seu computador

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, 42, 2026] {
        let secret = secret_from_seed(seed);
        let verdict = respond(50, secret);
        println!("semente {seed:>4} → segredo {secret:>3} ({verdict})");
    }
}

Comandos locais

cargo new --bin --edition 2024 exemplo-rust
cd exemplo-rust
# Use o código no projeto da aula.
cargo run
cargo clippy -- -D warnings

Rust Playground (opcional)

DESAFIO LOCAL

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 — inclusive em modo debug.

A restrição final é o ponto do exercício: a fórmula estoura u32 de propósito, e cabe a você usar a aritmética que declara isso.

O navegador não executa Rust. O registro abaixo confirma seu estudo, não um resultado de teste.

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.

DESAFIO LOCAL

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 > resolveria — mas o objetivo é praticar o match exaustivo sobre um tipo de variantes conhecidas, a construção que domina o resto do curso.

O navegador não executa Rust. O registro abaixo confirma seu estudo, não um resultado de teste.

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.

DESAFIO LOCAL

Valide a rodada inteira: parse + faixa + veredito

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

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

Entrada: a linha digitada pelo jogador (pode conter \n do Enter, espaços, texto qualquer) e o número secreto.
Saída: "inválido" se o texto não parseia como u32; "fora da faixa" se parseia mas não está em 1..=100; caso contrário, o veredito do exercício anterior ("muito baixo", "muito alto" ou "acertou").
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: trate o \n e os espaços das pontas antes do parse; a validação de faixa vem antes da comparação. Reaproveite a lógica de respond — no arquivo do exercício, escreva as duas funções.

Esta é a síntese da aula: os três portões (parse, faixa, comparação) na ordem certa, exatamente como o loop do jogo os atravessa.

O navegador não executa Rust. O registro abaixo confirma seu estudo, não um resultado de teste.

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

Trate o Result no ponto em que ele nasce e deixe cada valor validado carregar sua garantia adiante. O capítulo 2 do The Rust Book — que constrói este mesmo jogo — estabelece o padrão: match no parse para separar os mundos, e depois do Ok desempacotado, o resto do programa trabalha com um u32 de verdade, sem revalidar a cada uso. Para as validações de faixa, o clippy tem opinião registrada: manual_range_contains sugere (1..=100).contains(&guess) no lugar de guess >= 1 && guess <= 100 — o range diz a intenção em uma expressão, com as bordas visíveis. A regra geral que fica: em Rust, validação não é uma fase do programa, é uma fronteira de tipos — texto de um lado, número garantido do outro, e o compilador patrulhando a passagem.

RESUMO DA AULA

O que você leva desta aula

Entrada do teclado chega como texto com \n grudado: trim() antes de parse() — sempre; esquecer é a falha número um em CLIs Rust.
parse::<u32>() devolve Result: Ok(valor) ou Err(erro), e o compilador obriga a decidir os dois caminhos — o tipo escolhido já valida de graça (negativos não parseiam como u32).
match sobre Ordering (Less/Greater/Equal) é exaustivo: variante esquecida é erro E0004 com o nome do caso faltante, não bug silencioso.
Overflow proposital pede aritmética que o declare: wrapping_mul/wrapping_add para módulo 2³², checked_* quando estourar é erro — o * cru entra em panic em debug.
O ciclo ler → validar → decidir → repetir, com continue para os desvios e break para o fim, é o esqueleto de qualquer ferramenta de linha de comando.
Aqui fecha o módulo de primeiros passos. Na sequência da trilha, a pergunta que este jogo deixou no ar — o que exatamente acontece quando um valor entra e sai de uma função? — ganha resposta definitiva: pilha, heap e o custo de cada valor, a porta de entrada do ownership.

+205 XPpossíveis nesta aula

A ideia central

A ideia central

A ideia central

A ideia central

A ideia central

Código anotado

Código anotado

Código anotado

Código anotado

Código anotado

Código anotado

Código anotado

O ciclo do jogo: ler, validar, comparar

Pratique no seu computador

Derive o número secreto da semente

Casos e valores esperados

Execute com o Cargo local

Interprete o palpite com match sobre Ordering

Casos e valores esperados

Execute com o Cargo local

Valide a rodada inteira: parse + faixa + veredito

Casos e valores esperados

Execute com o Cargo local

A ideia central

O que você leva desta aula

Você transformou esta ideia em prática.