Funções, if/else e loops: quando um ponto e vírgula muda o programa

ENTENDA A IDEIA

A ideia central

Existe uma pergunta que separa as linguagens em duas famílias: “quanto vale um if?”. Na família de C, Java e Go, a pergunta nem faz sentido — if é uma instrução, um desvio de rota que não produz valor, e para guardar o resultado de uma decisão você declara a variável antes e atribui dentro de cada ramo. Rust pertence à outra família: quase tudo é expressão, isto é, quase tudo se reduz a um valor. Um if/else vale o ramo escolhido. Um bloco { ... } vale sua última expressão. Um loop pode valer o que o break entregar. Entender essa distinção não é trivia de sintaxe: é a chave de leitura de todo código Rust idiomático — e a origem do erro de compilação mais famoso para quem chega à linguagem.

Exemplo Rust

fn double(value: i32) -> i32 {
    value * 2   // expressão: este é o valor devolvido
}
// value * 2;  ← com ponto e vírgula seria uma instrução,
//               a função devolveria () e E0308 apontaria a seta ->

ENTENDA A IDEIA

A ideia central

O interruptor entre os dois mundos é o ponto e vírgula. value * 2 é uma expressão que vale o dobro de value; value * 2; é uma instrução que calcula o dobro, descarta o resultado e vale () — o tipo unitário, o “nada” de Rust. Dentro de uma função com tipo de retorno declarado, essa diferença de um caractere é a diferença entre compilar e receber o E0308 (mismatched types) dizendo que a função prometeu i32 e entregou (). A boa notícia: o rustc conhece esse tropeço tão bem que a mensagem aponta o ponto e vírgula culpado e sugere removê-lo. Nesta aula você vai provocar esse erro de propósito e aprender a lê-lo de relance.

ENTENDA A IDEIA

A ideia central

Dessa regra nasce o estilo de retorno do Rust: a última expressão do corpo, sem ponto e vírgula, é o valor devolvido — e o return explícito fica reservado para saídas antecipadas, no meio do fluxo. Não é frescura estética: quando o corpo inteiro é uma expressão, a função lê como uma definição matemática (“o dobro de value é value * 2”) em vez de uma sequência de comandos. O mesmo vale para o if/else como expressão: let profile = if release { "release" } else { "debug" }, que você já escreveu na aula do cargo, declara e decide em uma linha, sem variável mutável esperando atribuição.

ENTENDA A IDEIA

A ideia central

O outro lado do fluxo são os laços, e Rust tem exatamente três, cada um com seu nicho. O for percorre uma coleção ou um range (1..=10 inclui o 10; 1..10 para no 9) e é o laço de longe mais comum — inclusive porque elimina a clássica confusão de limites do for de C. O while repete enquanto uma condição vale, para quando você não sabe quantas voltas serão. E o loop é o laço infinito honesto: em vez de while true, Rust dá um laço que declara a intenção — e o recompensa com um superpoder que os outros não têm: break valor encerra o laço entregando um valor, transformando o laço inteiro em expressão. Buscas (“suba até achar o primeiro fator”) ficam naturais: o achado sai pelo break direto para um let.

ENTENDA A IDEIA

A ideia central

As três construções compartilham a mesma disciplina de tipos do resto da linguagem: a condição do if e do while é bool de verdade — número não é condição, e if value com value: i32 não compila, eliminando a família inteira de bugs do “0 é falso”. E quando um if/else é usado como expressão, os dois ramos precisam ter o mesmo tipo, porque o let que o recebe precisa de um tipo — o compilador confere isso antes de o programa existir.

ENTENDA A IDEIA

A ideia central

Python tem a expressão condicional ("par" if n % 2 == 0 else "ímpar"), mas ela é uma sintaxe à parte, limitada a uma linha — o if normal continua sendo instrução, e blocos não valem nada. Em Rust não há duas sintaxes: o mesmo if/else de sempre é expressão em qualquer posição, com blocos de qualquer tamanho valendo sua última linha. A segunda diferença está nos laços: o for i in range(1, 11) do Python vira for i in 1..=10 — atenção ao detalhe de que range(1, 11) exclui o 11 como 1..11 exclui, e o ..= inclusivo do Rust não tem equivalente direto. E onde Python aceita if lista: para testar vazio, Rust exige o booleano explícito: if !list.is_empty(). Truthiness não existe — o que parece burocracia é o compilador recusando a ambiguidade.

CÓDIGO ANOTADO

Código anotado

O programa da aula constrói uma tabela de classificação usando cada peça na posição em que ela brilha: if/else como expressão, for com range para percorrer, while para uma contagem com condição e loop com break de valor para uma busca. Crie o projeto (cargo new fluxo), substitua src/main.rs e rode.

src/main.rs

// classify devolve a faixa da temperatura; o corpo inteiro é UMA expressão.
fn classify(celsius: f64) -> &'static str {
    if celsius < 15.0 {
        "frio"
    } else if celsius < 30.0 {
        "agradável"
    } else {
        "quente"
    }
}

CÓDIGO ANOTADO

Código anotado

Nenhum return, nenhum ponto e vírgula nos ramos: a cadeia if/else if/else é a última (e única) expressão do corpo, e seu valor — o ramo escolhido — é o retorno. Repare que os três ramos têm o mesmo tipo, &'static str; se um deles devolvesse um número, o compilador rejeitaria a cadeia inteira com E0308, porque uma expressão precisa de um tipo só. O else final não é opcional aqui: sem ele, existiria um caminho sem valor, e a função não teria o que devolver.

src/main.rs

// first_factor sobe a partir de 2 até achar o primeiro divisor de value.
fn first_factor(value: u32) -> u32 {
    let mut candidate = 2;
    loop {
        if value.is_multiple_of(candidate) {
            break candidate;
        }
        candidate += 1;
    }
}

CÓDIGO ANOTADO

Código anotado

Duas coisas para ler neste chunk. A primeira é o teste de divisibilidade: você poderia escrever value % candidate == 0 com o operador de resto — funciona, mas o clippy aponta o lint manual_is_multiple_of e sugere o método is_multiple_of, que diz a intenção pelo nome e existe nos inteiros sem sinal exatamente para isso. Como este curso exige clippy limpo, adotamos a forma sugerida desde já. A segunda é o loop como expressão: break candidate encerra o laço entregando o candidato, e como o loop é a última expressão do corpo, esse valor é o retorno da função. Não há risco de laço infinito para value >= 2: no pior caso, o candidato sobe até o próprio value, que divide a si mesmo — é o caso dos primos, em que o primeiro fator é o próprio número. Compare mentalmente com a versão while true de outras linguagens: além de mais honesta, a versão com loop não precisa de variável extra para carregar o resultado para fora.

src/main.rs

fn main() {
    // for + range: 0..=35 inclui as duas pontas; step_by pula de 5 em 5.
    for celsius in (0..=35).step_by(5) {
        let label = classify(f64::from(celsius));
        println!("{celsius:>2}°C → {label}");
    }

CÓDIGO ANOTADO

Código anotado

O range 0..=35 gera os inteiros de 0 a 35, e step_by(5) seleciona um a cada cinco — o for visita 0, 5, 10, …, 35, sem variável de controle manual, sem condição de parada para errar. Como classify exige f64 e o range produz inteiros, a conversão é explícita: f64::from(celsius) — a irmã segura do as que você viu na aula passada, disponível quando a conversão nunca perde informação. O {celsius:>2} alinha o número à direita em duas colunas, só para a tabela sair alinhada.

src/main.rs

    // while: repete enquanto a condição vale; a condição é bool de verdade.
    let mut fahrenheit = 100.0;
    let mut steps = 0;
    while fahrenheit > 40.0 {
        fahrenheit *= 0.9;
        steps += 1;
    }
    println!("resfriou abaixo de 40°F em {steps} passos");

CÓDIGO ANOTADO

Código anotado

O while é o laço para “não sei quantas voltas”: a cada passo a temperatura cai 10%, e o laço para quando cruza o limiar. A condição fahrenheit > 40.0 é um bool genuíno — escrever while fahrenheit seria erro de tipo, não conversão implícita. Vale notar o padrão das duas variáveis mut: laços while são dos poucos lugares onde mutação local é o idioma natural, e o escopo curto a mantém inofensiva.

O fechamento usa a função do chunk 2: 91 não é primo (7 × 13), e o laço encontra o 7 na sexta volta. A saída completa do programa:

 0°C → frio
 5°C → frio
10°C → frio
15°C → agradável
20°C → agradável
25°C → agradável
30°C → quente
35°C → quente
resfriou abaixo de 40°F em 9 passos
primeiro fator de 91: 7

Confira as pontas da tabela contra o chunk 1: 15°C caiu em “agradável” e 30°C em “quente” — os limites usam <, então cada fronteira pertence à faixa de cima. Esse tipo de decisão de borda é exatamente o que o primeiro exercício cobra.

src/main.rs

    // loop como expressão: o break entrega o valor direto para o let.
    let factor = first_factor(91);
    println!("primeiro fator de 91: {factor}");
}

PRÁTICA LOCAL

Pratique no seu computador

O programa abaixo compila e roda. Antes de executar, preveja: quantas linhas ele imprime, e qual é a última?

Repare no bloco { ... } atribuído a total: ele declara, acumula e vale sua última expressão (sum, sem ponto e vírgula) — o mesmo mecanismo do retorno de funções, disponível em qualquer lugar.

Agora, três mudanças — preveja cada resultado antes de compilar:

Provoque o erro da aula: troque o corpo de countdown_label por if value > 0 { "contando" } else { "lançar!" }; — com ponto e vírgula no final. A mensagem é esta:

error[E0308]: mismatched types
 --> src/main.rs:1:35
  |
1 | fn countdown_label(value: i32) -> &'static str {
  |    ---------------                ^^^^^^^^^^^^ expected `&str`, found `()`
  |    |
  |    implicitly returns `()` as its body has no tail or `return` expression
2 |     if value > 0 { "contando" } else { "lançar!" };
  |                                                   - help: remove this semicolon to return this value

Leia as duas anotações: a função prometeu &'static str, mas o corpo “não tem expressão final” — o ponto e vírgula a converteu em instrução e o retorno implícito virou (). O help aponta o caractere exato a remover. Esse diagnóstico vai reaparecer na sua vida; agora você sabe decodificá-lo em segundos.

Remova o ramo else de countdown_label, deixando só o if. O erro muda: um if sem else usado como valor teria tipo () no caminho que falta. Qual das duas linhas da mensagem aponta isso?
No while, troque remaining >= 0 por remaining. Rust rejeita com “expected bool, found integer” — a linha que em C compilaria (e contaria errado) aqui nem vira programa.

A pergunta central: nos três erros, o que o compilador sabia sobre o tipo de cada expressão que permitiu recusar o programa?

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

fn countdown_label(value: i32) -> &'static str {
    if value > 0 { "contando" } else { "lançar!" }
}

fn main() {
    let mut remaining = 3;
    while remaining >= 0 {
        println!("{remaining}: {}", countdown_label(remaining));
        remaining -= 1;
    }

    let total: i32 = {
        let mut sum = 0;
        for value in 1..=4 {
            sum += value;
        }
        sum
    };
    println!("soma de 1 a 4: {total}");
}

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

Classifique a temperatura com if/else como expressão

Escreva a função classify, a mesma do programa da aula — agora sem olhar (e o harness confere as bordas):

pub fn classify(celsius: f64) -> &'static str

Entrada: uma temperatura em graus Celsius.
Saída: "frio" abaixo de 15.0; "agradável" de 15.0 (inclusive) até 30.0 (exclusive); "quente" de 30.0 em diante.
Exemplo: classify(14.9) devolve "frio"; classify(15.0) devolve "agradável"; classify(30.0) devolve "quente".
Restrições: sem return — o corpo deve ser uma única cadeia if/else if/else cujo valor é o retorno. As três strings devem bater byte a byte.

As fronteiras são o teste real: 15.0 e 30.0 pertencem cada uma à faixa de cima. Escreva primeiro os dois casos de borda no papel e só então a cadeia.

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

Exercício 1

Classifique a temperatura com if/else como expressão

stub.rs

// classify devolve a faixa da temperatura: "frio" abaixo de 15.0,
// "agradável" de 15.0 até 29.99..., "quente" de 30.0 em diante.
// Sem return: o corpo é uma única cadeia if/else if/else.
pub fn classify(celsius: f64) -> &'static str {
    // implemente:
    let _ = celsius;
    "frio"
}

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: [(f64, &str); 6] = [
        (14.9, "frio"),
        (15.0, "agradável"),
        (29.9, "agradável"),
        (30.0, "quente"),
        (-5.0, "frio"),
        (40.0, "quente"),
    ];
    for (index, (celsius, want)) in cases.iter().enumerate() {
        let got = classify(*celsius);
        let pass = got == *want;
        print_result(index + 1, pass, &format!("{celsius:.1}"), want, got);
    }
}

cases.json

[
  {
    "case": 1,
    "input": "14.9",
    "want": "frio"
  },
  {
    "case": 2,
    "input": "15.0",
    "want": "agradável"
  },
  {
    "case": 3,
    "input": "29.9",
    "want": "agradável"
  },
  {
    "case": 4,
    "input": "30.0",
    "want": "quente"
  },
  {
    "case": 5,
    "input": "-5.0",
    "want": "frio"
  },
  {
    "case": 6,
    "input": "40.0",
    "want": "quente"
  }
]

Casos e valores esperados

Caso	Entrada	Valor esperado
1	`14.9`	`frio`
2	`15.0`	`agradável`
3	`29.9`	`agradável`
4	`30.0`	`quente`
5	`-5.0`	`frio`
6	`40.0`	`quente`

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-04-funcoes-e-fluxo-exercicio-1
cd imersao-04-funcoes-e-fluxo-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-04-funcoes-e-fluxo-exercicio-1
cargo clippy -- -D warnings

Abrir o Rust Playground (opcional)

Mostrar dicas

São três faixas em ordem: abaixo de 15.0 é "frio", abaixo de 30.0 é "agradável", o resto é "quente" — um if/else if/else resolve, sem return.
Faça a cadeia inteira ser a última expressão da função: cada ramo termina em um literal &'static str sem ponto e vírgula, e o valor do if é o retorno.

Revelar solução

solution.rs

// classify devolve a faixa da temperatura: "frio" abaixo de 15.0,
// "agradável" de 15.0 até 29.99..., "quente" de 30.0 em diante.
// Sem return: o corpo é uma única cadeia if/else if/else.
pub fn classify(celsius: f64) -> &'static str {
    if celsius < 15.0 {
        "frio"
    } else if celsius < 30.0 {
        "agradável"
    } else {
        "quente"
    }
}

A cadeia if/else if/else como expressão final devolve o ramo escolhido; os limites usam < para que 15.0 caia em "agradável" e 30.0 em "quente". A armadilha é pôr ponto e vírgula nos ramos e transformar a expressão em instrução — o E0308 da aula.

A cadeia da aula, com os limites em <:

pub fn classify(celsius: f64) -> &'static str {
    if celsius < 15.0 {
        "frio"
    } else if celsius < 30.0 {
        "agradável"
    } else {
        "quente"
    }
}

A ordem dos testes faz o trabalho das faixas: quem chega ao segundo if já falhou no primeiro, então celsius < 30.0 ali significa, na prática, “de 15.0 a 29.999…”. As fronteiras saem naturalmente certas: 15.0 < 15.0 é falso, então 15.0 cai no segundo ramo; 30.0 < 30.0 é falso, então 30.0 cai no else. Custo O(1) — no máximo duas comparações.

A armadilha sintática é a da aula: pontuar os ramos ("frio";) ou a cadeia inteira transforma expressão em instrução e detona o E0308. A armadilha lógica é usar <= nos limites — celsius <= 15.0 moveria a fronteira 15.0 para “frio”, e o caso de borda do harness falharia na hora. A alternativa com return em cada ramo compila e passa, mas abre mão da leitura declarativa (“a classificação é esta cadeia”) e o clippy tem opinião: needless_return marca o return final desnecessário.

DESAFIO LOCAL

Some os múltiplos de um divisor com for e range

Escreva a função sum_multiples, que soma todos os múltiplos de um divisor dentro de um intervalo:

pub fn sum_multiples(limit: u32, divisor: u32) -> u64

Entrada: o limite superior (inclusive) e o divisor; o divisor é sempre ≥ 1.
Saída: a soma de todos os valores em 1..=limit que são divisíveis por divisor.
Exemplo: sum_multiples(10, 3) devolve 18 (3 + 6 + 9); sum_multiples(10, 5) devolve 15 (5 + 10); sum_multiples(4, 7) devolve 0 — nenhum múltiplo na faixa.
Restrições: use for com um range e um acumulador u64. O retorno comporta a soma de qualquer faixa de entradas u32.

O caso sum_multiples(10, 5) é o detector de range errado: o 10 está na faixa e é múltiplo de 5 — se sua soma der 5, o range exclusivo comeu a ponta.

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

Exercício 2

Some os múltiplos de um divisor com for e range

stub.rs

// sum_multiples soma todos os valores em 1..=limit divisíveis por divisor.
// O retorno u64 comporta a soma de qualquer faixa u32 completa.
pub fn sum_multiples(limit: u32, divisor: u32) -> u64 {
    // implemente:
    let _ = (limit, divisor);
    0
}

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, u64); 6] = [
        (10, 3, 18),
        (10, 5, 15),
        (4, 7, 0),
        (1, 1, 1),
        (100, 10, 550),
        (100_000, 1, 5_000_050_000),
    ];
    for (index, (limit, divisor, want)) in cases.iter().enumerate() {
        let got = sum_multiples(*limit, *divisor);
        let pass = got == *want;
        print_result(
            index + 1,
            pass,
            &format!("({limit}, {divisor})"),
            &want.to_string(),
            &got.to_string(),
        );
    }
}

cases.json

[
  {
    "case": 1,
    "input": "(10, 3)",
    "want": "18"
  },
  {
    "case": 2,
    "input": "(10, 5)",
    "want": "15"
  },
  {
    "case": 3,
    "input": "(4, 7)",
    "want": "0"
  },
  {
    "case": 4,
    "input": "(1, 1)",
    "want": "1"
  },
  {
    "case": 5,
    "input": "(100, 10)",
    "want": "550"
  },
  {
    "case": 6,
    "input": "(100000, 1)",
    "want": "5000050000"
  }
]

Casos e valores esperados

Caso	Entrada	Valor esperado
1	`(10, 3)`	`18`
2	`(10, 5)`	`15`
3	`(4, 7)`	`0`
4	`(1, 1)`	`1`
5	`(100, 10)`	`550`
6	`(100000, 1)`	`5000050000`

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-04-funcoes-e-fluxo-exercicio-2
cd imersao-04-funcoes-e-fluxo-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-04-funcoes-e-fluxo-exercicio-2
cargo clippy -- -D warnings

Abrir o Rust Playground (opcional)

Mostrar dicas

Percorra 1..=limit com for e acumule em uma variável mut iniciada em 0; o teste de múltiplo decide quem entra na soma.
if value.is_multiple_of(divisor) { total += u64::from(value); } dentro do laço — o acumulador largo evita overflow.

Revelar solução

solution.rs

// sum_multiples soma todos os valores em 1..=limit divisíveis por divisor.
// O retorno u64 comporta a soma de qualquer faixa u32 completa.
pub fn sum_multiples(limit: u32, divisor: u32) -> u64 {
    let mut total = 0u64;
    for value in 1..=limit {
        if value.is_multiple_of(divisor) {
            total += u64::from(value);
        }
    }
    total
}

O range inclusivo visita cada candidato uma vez. O acumulador u64 comporta a soma de toda a faixa u32, inclusive limites grandes.

Range inclusivo, teste de múltiplo, acumulador:

pub fn sum_multiples(limit: u32, divisor: u32) -> u64 {
    let mut total = 0u64;
    for value in 1..=limit {
        if value.is_multiple_of(divisor) {
            total += u64::from(value);
        }
    }
    total
}

O 1..=limit visita cada candidato exatamente uma vez — O(n) no limite — e is_multiple_of decide quem entra. O acumulador é u64, e cada candidato passa por u64::from. Assim, a soma de toda a faixa u32 cabe sem overflow. A última linha, total sem ponto e vírgula, é o retorno.

A armadilha número um é o range: 1..limit exclui o próprio limite, e sum_multiples(10, 5) devolveria 5 em vez de 15 — o caso do harness existe para isso. A segunda armadilha é sutil: inverter o teste para divisor.is_multiple_of(value) compila e até acerta alguns casos pequenos, mas pergunta “value divide o divisor?”, o contrário do contrato. E se você escreveu value % divisor == 0: o resultado é o mesmo, mas rode cargo clippy e veja o lint manual_is_multiple_of sugerir o método — é o tipo de melhoria de legibilidade que o linter automatiza. Existe uma alternativa aritmética O(1) — somar a progressão divisor + 2·divisor + ... = divisor · k·(k+1)/2 com k = limit / divisor — que vale conhecer para entrevistas; aqui o laço é o objetivo pedagógico, e para os tamanhos do exercício a diferença é invisível.

DESAFIO LOCAL

Encontre o primeiro fator com loop e break com valor

Escreva a função first_factor, a busca do programa da aula — com o loop entregando o resultado:

pub fn first_factor(value: u32) -> u32

Entrada: um inteiro value >= 2.
Saída: o menor fator de value que seja ≥ 2. Para números primos, é o próprio número.
Exemplo: first_factor(91) devolve 7; first_factor(12) devolve 2; first_factor(13) devolve 13.
Restrições: use loop com break carregando o valor — sem while, sem for, sem return dentro do laço. O loop deve ser a última expressão da função.

O objetivo é fixar o break com valor: o laço é a expressão de busca, e o achado sai por ele — nenhuma variável externa para carregar o resultado.

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

Exercício 3

Encontre o primeiro fator com loop e break com valor

stub.rs

// first_factor devolve o menor fator ≥ 2 de value (value >= 2).
// Para primos, é o próprio número. Use loop com break carregando o valor.
pub fn first_factor(value: u32) -> u32 {
    // implemente:
    value
}

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] = [(91, 7), (12, 2), (13, 13), (2, 2), (49, 7)];
    for (index, (value, want)) in cases.iter().enumerate() {
        let got = first_factor(*value);
        let pass = got == *want;
        print_result(
            index + 1,
            pass,
            &value.to_string(),
            &want.to_string(),
            &got.to_string(),
        );
    }
}

cases.json

[
  {
    "case": 1,
    "input": "91",
    "want": "7"
  },
  {
    "case": 2,
    "input": "12",
    "want": "2"
  },
  {
    "case": 3,
    "input": "13",
    "want": "13"
  },
  {
    "case": 4,
    "input": "2",
    "want": "2"
  },
  {
    "case": 5,
    "input": "49",
    "want": "7"
  }
]

Casos e valores esperados

Caso	Entrada	Valor esperado
1	`91`	`7`
2	`12`	`2`
3	`13`	`13`
4	`2`	`2`
5	`49`	`7`

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-04-funcoes-e-fluxo-exercicio-3
cd imersao-04-funcoes-e-fluxo-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-04-funcoes-e-fluxo-exercicio-3
cargo clippy -- -D warnings

Abrir o Rust Playground (opcional)

Mostrar dicas

Comece um candidato em 2 e suba de um em um; o primeiro que dividir value sem resto é a resposta — e ele sempre existe, porque o próprio value se divide.
Use loop { ... } com break candidate; quando value.is_multiple_of(candidate) — o valor do break vira o valor do loop inteiro, que é a última expressão da função.

Revelar solução

solution.rs

// first_factor devolve o menor fator ≥ 2 de value (value >= 2).
// Para primos, é o próprio número. Use loop com break carregando o valor.
pub fn first_factor(value: u32) -> u32 {
    let mut candidate = 2;
    loop {
        if value.is_multiple_of(candidate) {
            break candidate;
        }
        candidate += 1;
    }
}

loop com break-com-valor devolve o primeiro fator ≥ 2; para primos, o laço sobe até o próprio número, garantindo término. A armadilha é esquecer o incremento (laço infinito) ou começar o candidato em 1, que divide tudo e responde errado sempre.

O chunk 2 do programa da aula, agora justificado linha a linha:

pub fn first_factor(value: u32) -> u32 {
    let mut candidate = 2;
    loop {
        if value.is_multiple_of(candidate) {
            break candidate;
        }
        candidate += 1;
    }
}

O break candidate faz três coisas de uma vez: para o laço, define o valor do loop inteiro e — como o loop é a última expressão do corpo — define o retorno da função. O término é garantido pela matemática: todo value >= 2 é divisível por si mesmo, então o candidato encontra um fator no mais tardar ao alcançar value. Custo O(n) no pior caso (primos); a otimização clássica de parar em √n e devolver value é bem-vinda em código real, mas não muda o mecanismo que o exercício treina.

Duas armadilhas encerram a aula. Começar candidate em 1: um divide tudo, a primeira volta responde 1 e todos os casos falham — o menor fator interessante começa em 2. E esquecer o candidate += 1: aí sim o loop faz jus ao nome, para sempre; se acontecer no seu teste local, Ctrl+C encerra o processo. Vale o contraste com a alternativa while: possível, mas exige declarar o resultado fora do laço e atribuir dentro — duas variáveis mut e um fluxo de dados que o break com valor expressa em uma linha.

ENTENDA A IDEIA

A ideia central

Devolva valores pela última expressão e reserve return para saídas antecipadas. O capítulo 3.3 do The Rust Book define a regra — corpos de função são blocos, blocos valem sua última expressão — e o clippy a policia dos dois lados: needless_return aponta o return supérfluo na última linha, e o próprio rustc aponta o ponto e vírgula que transforma seu retorno em (). A mesma disciplina se estende ao fluxo: prefira if/else como expressão a variável mutável mais atribuição, prefira for com range a contador manual, e prefira loop + break valor a while true com variável carregadora. Cada preferência remove um estado mutável do código — e estado que não existe é estado que não quebra.

RESUMO DA AULA

O que você leva desta aula

Rust divide o mundo em expressões (valem algo) e instruções (valem ()); o ponto e vírgula converte a primeira na segunda — e o E0308 “expected type, found ()” quase sempre aponta um ; sobrando na última linha.
Funções devolvem a última expressão do corpo; return é para saídas antecipadas, e o clippy marca o excesso com needless_return.
if/else é expressão: os ramos precisam do mesmo tipo, o else é obrigatório quando o valor é usado, e a condição é bool de verdade — número nunca é condição.
Os três laços têm nichos: for com ranges (1..10 exclusivo, 1..=10 inclusivo) para percorrer, while para condição, loop para repetição aberta — e só o loop devolve valor via break.
Blocos { ... } valem sua última expressão em qualquer posição — o mecanismo de retorno das funções disponível dentro de um let.
Na próxima aula, tudo isso vira um programa de verdade: o jogo de adivinhação com entrada do teclado, parse, match e o primeiro contato com Result — o assunto que abre o resto do curso.

+195 XPpossíveis nesta aula

A ideia central

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

Pratique no seu computador

Classifique a temperatura com if/else como expressão

Casos e valores esperados

Execute com o Cargo local

Some os múltiplos de um divisor com for e range

Casos e valores esperados

Execute com o Cargo local

Encontre o primeiro fator com loop e break com valor

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.