Variáveis, mutabilidade e tipos primitivos: o que cada let coloca na pilha

ENTENDA A IDEIA

A ideia central

Pense na pilha como a bancada de uma oficina: cada ferramenta tem um encaixe recortado sob medida, e você sabe de antemão quantos encaixes precisa e o tamanho exato de cada um. É assim que Rust trata as variáveis desta aula: cada let reserva um espaço de tamanho conhecido em compilação — 4 bytes para um u32, 8 para um f64, 24 para um [f64; 3] — e o programa inteiro é montado sabendo onde cada valor mora. Nada do que você vai declarar aqui toca o heap; essa é a razão de tipos primitivos serem baratos, e é a fundação sobre a qual o módulo de ownership constrói tudo.

Exemplo Rust

let mut enrolled: u32 = 0; // um slot de 4 bytes na pilha
enrolled += 5;             // mut: o mesmo slot, novo valor
let spaces = "   ";        // &str
let spaces = spaces.len(); // shadowing: outra variável, outro tipo

ENTENDA A IDEIA

A ideia central

A primeira decisão de design aparece antes dos tipos: em Rust, o encaixe é lacrado por padrão. Um let x = 5 cria uma variável que não aceita reatribuição — tentar x = 6 é o erro E0384 que você provocou na primeira aula. Para reescrever o valor no mesmo slot, você declara a intenção com let mut. Isso inverte o hábito da maioria das linguagens, onde tudo é mutável e a constância é o caso especial. A consequência prática é enorme para leitura de código: quando mut é raro e visível, cada variável sem ele é uma promessa verificada de que o valor não muda até o fim do escopo.

ENTENDA A IDEIA

A ideia central

Rust oferece ainda um terceiro caminho, que confunde no início e vicia depois: o shadowing. Declarar let spaces = spaces.len() depois de let spaces = " " não reescreve nada — cria uma variável nova com o mesmo nome, e a antiga simplesmente deixa de ser alcançável (o slot dela continua na pilha até o fim do escopo, como o carrossel mostra). Por ser uma variável nova, o tipo pode mudar: texto virou número. Com mut isso seria impossível, porque mut autoriza trocar o valor, nunca o tipo do slot. O shadowing existe para um padrão real: transformar uma entrada em etapas — texto bruto, texto limpo, número validado — sem inventar três nomes para a mesma ideia.

ENTENDA A IDEIA

A ideia central

Sobre os tipos em si, a regra que organiza tudo: Rust é estaticamente tipado com inferência — o compilador deduz o tipo de quase todo let, mas o tipo existe, é fixo e é verificado em cada uso. Os inteiros vêm em pares com e sem sinal, de 8 a 128 bits (i8/u8 até i128/u128), mais isize/usize no tamanho do ponteiro da máquina — usize é o tipo de todo índice e de todo len(). O padrão inferido é i32; floats são f64 por padrão (f32 existe, mas só vale a pena com motivo). Escolher o tipo certo é modelagem: uma quantidade nunca é negativa, então u32 documenta e impõe isso — em vez de um comentário pedindo “não passe negativo”, o compilador recusa.

ENTENDA A IDEIA

A ideia central

E há uma pegadinha que merece parágrafo próprio: o char. Em C, char é 1 byte; em Rust, char é um valor escalar Unicode de 4 bytes — ‘A’, ‘ç’, ‘日’ e ’🦀’ são todos um único char. Mas atenção à distinção que vai voltar na aula de strings: 4 bytes é o tamanho do char na memória; quando o mesmo símbolo é gravado dentro de uma String, ele é codificado em UTF-8 e ocupa de 1 a 4 bytes. O primeiro exercício mede exatamente essa diferença.

ENTENDA A IDEIA

A ideia central

Go inicializa toda variável com zero value: var count int já vale 0, e usar antes de atribuir nunca é erro. Rust recusa o programa se você ler uma variável não inicializada — não existe valor padrão implícito, existe erro de compilação (E0381). A segunda diferença é o rune do Go, que é só um apelido para int32: qualquer número serve, inclusive um que não é Unicode válido. O char do Rust é um tipo de verdade com invariante garantida — construir um char inválido não compila. E onde Go tem um int de tamanho dependente da plataforma como padrão, Rust prefere i32 explícito e reserva usize para índices, tornando o custo de cada inteiro visível na assinatura.

CÓDIGO ANOTADO

Código anotado

O programa desta aula percorre cada conceito na mesma ordem do carrossel: mutação, shadowing, constante, tupla, array e o char de 4 bytes. Crie um projeto (cargo new tipos), substitua o src/main.rs e rode com cargo run.

src/main.rs

// MAX_SEATS é uma constante: tipo obrigatório, avaliada em compilação,
// válida no escopo inteiro — por convenção, UPPER_SNAKE_CASE.
const MAX_SEATS: u32 = 30;

fn main() {
    let mut enrolled: u32 = 0;
    enrolled += 5;
    println!("matrículas: {enrolled} de {MAX_SEATS}");

CÓDIGO ANOTADO

Código anotado

const é diferente de let em três pontos: o tipo é obrigatório (nada de inferência), o valor precisa ser calculável em compilação e a declaração pode viver fora de qualquer função. Já enrolled nasce com mut porque o programa reescreve o valor — e o carrossel mostra o que acontece na pilha: o mesmo slot de 4 bytes recebe 5; nenhuma variável nova, nenhuma alocação. A anotação : u32 aqui é escolha de modelagem: matrículas não são negativas.

src/main.rs

    // Shadowing: cada let cria uma variável nova com o mesmo nome —
    // o tipo pode mudar, porque o slot é outro.
    let spaces = "   ";
    let spaces = spaces.len();
    println!("espaços: {spaces}");

CÓDIGO ANOTADO

Código anotado

O primeiro spaces é &str; o segundo é usize, porque len devolve usize — o tipo de toda contagem e todo índice em Rust. Compare com a alternativa proibida: se a primeira linha fosse let mut spaces = " ";, a segunda (spaces = spaces.len();) seria rejeitada com E0308, mismatched types — mut permite novo valor, jamais novo tipo. O shadowing contorna isso de forma honesta: são duas variáveis, e o compilador trata cada uma com seu tipo.

src/main.rs

    // Tupla: tipos heterogêneos, tamanho fixo, desestruturação com let.
    let dimensions: (i32, i32) = (3, 4);
    let (width, height) = dimensions;
    println!("área: {}", width * height);

CÓDIGO ANOTADO

Código anotado

A tupla agrupa valores de tipos possivelmente diferentes em um único valor de tamanho fixo — aqui, 8 bytes na pilha. O acesso pode ser por índice (dimensions.0) ou, mais legível, por desestruturação: o let (width, height) abre a tupla em duas variáveis de uma vez. Você vai reencontrar esse padrão em todo lugar — funções que devolvem dois valores devolvem uma tupla, como o take_and_return que aparecerá no módulo de ownership.

src/main.rs

    // Array: um único tipo, comprimento no próprio tipo: [f64; 3].
    let notes: [f64; 3] = [7.5, 8.0, 9.0];
    let mean = (notes[0] + notes[1] + notes[2]) / notes.len() as f64;
    println!("média: {mean:.1}");

CÓDIGO ANOTADO

Código anotado

No array, o comprimento faz parte do tipo: [f64; 3] e [f64; 4] são tipos diferentes, e passar um onde se espera o outro não compila. Os 24 bytes vivem inteiros na pilha. Duas miudezas importantes na linha da média: notes.len() devolve usize, e Rust não converte inteiro para float sozinho — o as f64 é obrigatório, explícito, e a divisão sem ele nem compila. O {mean:.1} formata com uma casa decimal. Para coleções que crescem existe o Vec, que vive no heap — assunto do módulo de collections.

Aspas simples declaram char; aspas duplas, &str — confundir os dois é erro de tipo imediato. O caranguejo é um único char de 4 bytes na pilha, e crab as u32 extrai o code point (o {code_point:X} imprime em hexadecimal: 1F980). Já len_utf8 responde outra pergunta: quantos bytes esse símbolo ocupa quando codificado em UTF-8 dentro de uma String — 4 para o emoji, mas 2 para ‘ç’ e 1 para ‘A’. A saída completa do programa:

matrículas: 5 de 30
espaços: 3
área: 12
média: 8.2
🦀 é U+1F980 e ocupa 4 bytes em UTF-8

src/main.rs

    // char: valor escalar Unicode — sempre 4 bytes na memória.
    let crab = '🦀';
    let encoded = crab.len_utf8();
    let code_point = crab as u32;
    println!("{crab} é U+{code_point:X} e ocupa {encoded} bytes em UTF-8");
}

PASSO A PASSO

O que cada let coloca na pilha

VISUALIZAÇÃOO que cada let coloca na pilha

1 / 4

PRÁTICA LOCAL

Pratique no seu computador

Preveja a saída completa antes de rodar — em especial a linha do overflow:

checked_add devolve Some(soma) quando o resultado cabe no tipo e None quando estouraria — 260 não cabe em u8 (máximo 255). O Option que apareceu aí tem módulo próprio mais adiante; por ora, observe que o overflow virou um valor inspecionável, não um número silenciosamente errado.

Depois, três alterações — preveja o resultado de cada uma antes de compilar:

Troque checked_add(10) por small + 10. Em modo debug (cargo run), o programa compila e encerra com panic na soma: attempt to add with overflow. Rust prefere parar ruidosamente a entregar 4 como resultado de 250 + 10, que é o que aconteceria com wraparound silencioso em C.
Mude a tupla para (1.5, -2.0, 3.0) sem mudar a anotação (f64, f64). O erro E0308 diz “expected a tuple with 2 elements, found one with 3 elements” — o comprimento faz parte do tipo, exatamente como nos arrays.
Troque 'A' por "A" (aspas duplas). Qual erro aparece, e em qual operação? Repare que a mensagem aponta o as u32: fatias de texto não têm conversão numérica direta — só char tem essa garantia de ser um único code point.

A pergunta central: dos três erros, quais o compilador pegou antes de o programa existir — e qual só apareceu em tempo de 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

fn main() {
    let small: u8 = 250;
    let sum = small.checked_add(10);
    println!("250 + 10 em u8: {sum:?}");

    let byte = 'A' as u32;
    let accent = 'ç' as u32;
    println!("'A' = {byte}, 'ç' = {accent}");

    let point: (f64, f64) = (1.5, -2.0);
    let (x, y) = point;
    println!("distância da origem: {:.2}", (x * x + y * y).sqrt());
}

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

Meça o char: code point e bytes em UTF-8

Escreva a função char_info, que mede um char pelos dois ângulos da aula:

pub fn char_info(symbol: char) -> (u32, usize)

Entrada: qualquer char.
Saída: a tupla (code point, bytes em UTF-8) — o code point Unicode como u32 e quantos bytes o símbolo ocupa quando codificado em UTF-8.
Exemplo: char_info('A') devolve (65, 1); char_info('ç') devolve (231, 2); char_info('🦀') devolve (129408, 4).
Restrições: sem condicionais — os dois valores saem direto do char com uma conversão e um método.

O exercício cobra a distinção central do char: o valor na memória (sempre 4 bytes, o code point) e a representação codificada (1 a 4 bytes em UTF-8). Quem confunde as duas medidas vai tropeçar na aula de strings; quem as separa agora, não.

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

Exercício 1

Meça o char: code point e bytes em UTF-8

stub.rs

// char_info devolve (code point Unicode, bytes que o símbolo ocupa em UTF-8).
// Exemplo: 'ç' é o code point 231 e ocupa 2 bytes quando codificado.
pub fn char_info(symbol: char) -> (u32, usize) {
    // implemente:
    let _ = symbol;
    (0, 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: [(char, u32, usize); 4] = [
        ('A', 65, 1),
        ('ç', 231, 2),
        ('日', 26085, 3),
        ('🦀', 129408, 4),
    ];
    for (index, (symbol, want_point, want_bytes)) in cases.iter().enumerate() {
        let (point, bytes) = char_info(*symbol);
        let pass = point == *want_point && bytes == *want_bytes;
        print_result(
            index + 1,
            pass,
            &format!("{symbol:?}"),
            &format!("({want_point}, {want_bytes})"),
            &format!("({point}, {bytes})"),
        );
    }
}

cases.json

[
  {
    "case": 1,
    "input": "'A'",
    "want": "(65, 1)"
  },
  {
    "case": 2,
    "input": "'ç'",
    "want": "(231, 2)"
  },
  {
    "case": 3,
    "input": "'日'",
    "want": "(26085, 3)"
  },
  {
    "case": 4,
    "input": "'🦀'",
    "want": "(129408, 4)"
  }
]

Casos e valores esperados

Caso	Entrada	Valor esperado
1	`'A'`	`(65, 1)`
2	`'ç'`	`(231, 2)`
3	`'日'`	`(26085, 3)`
4	`'🦀'`	`(129408, 4)`

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-03-variaveis-e-tipos-exercicio-1
cd imersao-03-variaveis-e-tipos-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-03-variaveis-e-tipos-exercicio-1
cargo clippy -- -D warnings

Abrir o Rust Playground (opcional)

Mostrar dicas

Um char sempre cabe em u32 — a conversão explícita com `as` extrai o code point; o método len_utf8 diz quantos bytes ele ocupa quando codificado.
Devolva a tupla (symbol as u32, symbol.len_utf8()) — os dois valores saem direto do char, sem condição nenhuma.

Revelar solução

solution.rs

// char_info devolve (code point Unicode, bytes que o símbolo ocupa em UTF-8).
// Exemplo: 'ç' é o code point 231 e ocupa 2 bytes quando codificado.
pub fn char_info(symbol: char) -> (u32, usize) {
    (symbol as u32, symbol.len_utf8())
}

O char guarda o code point Unicode em 4 bytes fixos na memória; `as u32` lê esse número e len_utf8 calcula o tamanho variável na codificação. A armadilha é confundir os dois: 'ç' é o code point 231, mas ocupa 2 bytes em UTF-8, não 4.

Uma conversão e uma chamada de método:

pub fn char_info(symbol: char) -> (u32, usize) {
    (symbol as u32, symbol.len_utf8())
}

symbol as u32 é uma conversão sem custo: o char já é um número de 32 bits na memória — a conversão apenas o reinterpreta, em O(1) e sem alocação. len_utf8 calcula em quantos bytes o code point seria codificado: 1 byte até U+007F (o ASCII), 2 até U+07FF (onde vivem os acentos do português), 3 para a maioria dos ideogramas e 4 para emojis e além.

A armadilha clássica é responder “4” para tudo, porque “char tem 4 bytes” — verdade na pilha, falso na codificação. A conversão inversa também merece nota: u32 para char não funciona com as livremente, porque nem todo número é um code point válido (a faixa dos surrogates, por exemplo, é proibida); o caminho seguro é char::from_u32, que devolve Option e aparece no módulo de enums. Rust manteve a porta de saída barata e a porta de entrada vigiada — é a invariante do tipo trabalhando a seu favor.

DESAFIO LOCAL

Quebre os centavos em uma tupla

Escreva a função split_cents, que decompõe um valor em centavos nas partes de exibição:

pub fn split_cents(total_cents: u32) -> (u32, u32)

Entrada: um total em centavos (ex.: o retorno do inventory_line da primeira aula).
Saída: a tupla (reais, centavos) — quantos reais inteiros e quantos centavos sobram.
Exemplo: split_cents(450) devolve (4, 50); split_cents(7) devolve (0, 7); split_cents(100) devolve (1, 0); split_cents(0) devolve (0, 0).
Restrições: apenas aritmética inteira — nenhum f64 no caminho.

Dinheiro é o exemplo canônico de por que tipos inteiros importam: em ponto flutuante, 0.1 + 0.2 não é 0.3, e centavos somem em arredondamentos. Guardar centavos em inteiro e decompor na exibição é o padrão que sobrevive a auditoria.

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

Exercício 2

Quebre os centavos em uma tupla

stub.rs

// split_cents decompõe um total em centavos na tupla (reais, centavos):
// 450 vira (4, 50); 7 vira (0, 7). Apenas aritmética inteira.
pub fn split_cents(total_cents: u32) -> (u32, u32) {
    // implemente:
    (total_cents, 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, u32); 4] = [(450, 4, 50), (7, 0, 7), (100, 1, 0), (0, 0, 0)];
    for (index, (total, want_reais, want_cents)) in cases.iter().enumerate() {
        let (reais, cents) = split_cents(*total);
        let pass = reais == *want_reais && cents == *want_cents;
        print_result(
            index + 1,
            pass,
            &total.to_string(),
            &format!("({want_reais}, {want_cents})"),
            &format!("({reais}, {cents})"),
        );
    }
}

cases.json

[
  {
    "case": 1,
    "input": "450",
    "want": "(4, 50)"
  },
  {
    "case": 2,
    "input": "7",
    "want": "(0, 7)"
  },
  {
    "case": 3,
    "input": "100",
    "want": "(1, 0)"
  },
  {
    "case": 4,
    "input": "0",
    "want": "(0, 0)"
  }
]

Casos e valores esperados

Caso	Entrada	Valor esperado
1	`450`	`(4, 50)`
2	`7`	`(0, 7)`
3	`100`	`(1, 0)`
4	`0`	`(0, 0)`

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-03-variaveis-e-tipos-exercicio-2
cd imersao-03-variaveis-e-tipos-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-03-variaveis-e-tipos-exercicio-2
cargo clippy -- -D warnings

Abrir o Rust Playground (opcional)

Mostrar dicas

Divisão inteira entre u32 já descarta o resto: total_cents / 100 dá os reais; o operador % devolve o que sobrou.
Devolva (total_cents / 100, total_cents % 100) — teste mentalmente com 7: 7/100 = 0 e 7%100 = 7.

Revelar solução

solution.rs

// split_cents decompõe um total em centavos na tupla (reais, centavos):
// 450 vira (4, 50); 7 vira (0, 7). Apenas aritmética inteira.
pub fn split_cents(total_cents: u32) -> (u32, u32) {
    (total_cents / 100, total_cents % 100)
}

A divisão inteira e o resto decompõem o valor sem floats — dinheiro em ponto flutuante é fonte clássica de bugs de arredondamento. A armadilha é inverter a ordem da tupla ou tentar converter para f64 e perder centavos no caminho.

Divisão inteira e resto, na ordem do contrato:

pub fn split_cents(total_cents: u32) -> (u32, u32) {
    (total_cents / 100, total_cents % 100)
}

Entre inteiros, / já trunca: 450 / 100 é 4, sem parte fracionária para gerenciar. O % devolve exatamente o que a divisão descartou: 450 % 100 é 50. Juntas, as duas operações formam uma decomposição sem perda — reais * 100 + centavos reconstrói o total sempre. Custo O(1), duas instruções de máquina.

A alternativa perigosa é passar por float: (total_cents as f64 / 100.0) e depois separar parte inteira e decimal. Compila, e para 450 até funciona — mas floats de 64 bits não representam todos os decimais exatamente, e em valores grandes ou em cadeias de operações os centavos derrapam. O caso split_cents(7) também derruba soluções apressadas que assumem “sempre há reais”: 7 / 100 é 0, e a tupla (0, 7) é a resposta correta sem nenhum caso especial. Se o hábito de u32 para dinheiro parecer limitante, a resposta idiomática é subir para u64 — nunca descer para float.

DESAFIO LOCAL

Calcule a média sem laço

Escreva a função average_grade, que calcula a média de um array de exatamente três notas:

pub fn average_grade(notes: [f64; 3]) -> f64

Entrada: um array [f64; 3] — o tipo garante as três posições.
Saída: a média aritmética das três notas.
Exemplo: average_grade([7.5, 8.0, 9.0]) devolve 8.166...; average_grade([0.0, 0.0, 0.0]) devolve 0.0; average_grade([10.0, 10.0, 10.0]) devolve 10.0.
Restrições: sem laços (eles chegam na próxima aula) — indexe as três posições diretamente. O harness compara com tolerância de 1e-9, então não se preocupe com o último dígito binário.

Repare no que a assinatura já provou antes de qualquer código seu rodar: a função não pode receber duas notas nem quatro. O comprimento no tipo elimina a validação de tamanho que outras linguagens fazem em tempo de execução.

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

Exercício 3

Calcule a média sem laço

stub.rs

// average_grade devolve a média aritmética das três notas do array.
// Sem laços: indexe as três posições diretamente e divida por 3.0.
pub fn average_grade(notes: [f64; 3]) -> f64 {
    // implemente:
    notes[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: [([f64; 3], f64); 4] = [
        ([7.5, 8.0, 9.0], 8.166_666_666_666_666),
        ([0.0, 0.0, 0.0], 0.0),
        ([10.0, 10.0, 10.0], 10.0),
        ([5.0, 6.5, 8.0], 6.5),
    ];
    for (index, (notes, want)) in cases.iter().enumerate() {
        let got = average_grade(*notes);
        let pass = (got - want).abs() < 1e-9;
        print_result(
            index + 1,
            pass,
            &format!("{notes:?}"),
            &format!("{want}"),
            &format!("{got}"),
        );
    }
}

cases.json

[
  {
    "case": 1,
    "input": "[7.5, 8.0, 9.0]",
    "want": "8.166666666666666"
  },
  {
    "case": 2,
    "input": "[0.0, 0.0, 0.0]",
    "want": "0"
  },
  {
    "case": 3,
    "input": "[10.0, 10.0, 10.0]",
    "want": "10"
  },
  {
    "case": 4,
    "input": "[5.0, 6.5, 8.0]",
    "want": "6.5"
  }
]

Casos e valores esperados

Caso	Entrada	Valor esperado
1	`[7.5, 8.0, 9.0]`	`8.166666666666666`
2	`[0.0, 0.0, 0.0]`	`0`
3	`[10.0, 10.0, 10.0]`	`10`
4	`[5.0, 6.5, 8.0]`	`6.5`

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-03-variaveis-e-tipos-exercicio-3
cd imersao-03-variaveis-e-tipos-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-03-variaveis-e-tipos-exercicio-3
cargo clippy -- -D warnings

Abrir o Rust Playground (opcional)

Mostrar dicas

O array tem exatamente 3 posições conhecidas em compilação — some notes[0], notes[1] e notes[2] direto, sem laço.
A divisão precisa ser entre f64: some os três elementos e divida por 3.0 (não por 3, que é inteiro e nem compila na divisão com float).

Revelar solução

solution.rs

// average_grade devolve a média aritmética das três notas do array.
// Sem laços: indexe as três posições diretamente e divida por 3.0.
pub fn average_grade(notes: [f64; 3]) -> f64 {
    (notes[0] + notes[1] + notes[2]) / 3.0
}

Indexar as três posições e dividir por 3.0 resolve em O(1); o tipo [f64; 3] garante em compilação que as posições existem. A armadilha é dividir por um inteiro — Rust não converte 3 para 3.0 sozinho, e o erro E0277 aparece na hora.

Soma direta das três posições, divisão por 3.0:

pub fn average_grade(notes: [f64; 3]) -> f64 {
    (notes[0] + notes[1] + notes[2]) / 3.0
}

O acesso notes[0] até notes[2] é seguro por construção: o tipo [f64; 3] garante os índices, e um notes[3] literal seria rejeitado em compilação — o rustc avalia o índice constante contra o comprimento do tipo. Custo O(1): três somas e uma divisão.

A armadilha desta solução mora no divisor. Escrever / 3 não compila: o erro E0277 explica que não existe divisão de f64 por inteiro — Rust nunca promove tipos numéricos silenciosamente, e o 3.0 (ou 3_f64) é a forma de dizer que a divisão é entre floats. A alternativa / notes.len() as f64, usada no programa da aula, também é correta e tem a vantagem de acompanhar o tipo se o comprimento mudar; para um array fixo de 3, as duas são equivalentes e a literal é mais direta. Por fim, a comparação com tolerância no harness não é frescura: (7.5 + 8.0 + 9.0) / 3.0 produz 8.166666666666666, e exigir igualdade exata entre floats é o bug clássico que o módulo de testes vai revisitar.

ENTENDA A IDEIA

A ideia central

Anote tipos onde eles carregam intenção e deixe a inferência trabalhar no resto. let mut enrolled: u32 = 0 diz “isto nunca é negativo” — a anotação é modelagem. Já let mean: f64 = ... quando o lado direito só produz f64 é ruído, e o mesmo vale para conversões: o clippy marca com unnecessary_cast todo as que não muda nada (x as f64 quando x já é f64). O capítulo 3.2 do The Rust Book cataloga os tipos escalares e compostos desta aula; a disciplina que fica é usar o sistema de tipos como documentação executável — cada u32, usize e [f64; 3] conta ao leitor algo que um comentário contaria pior.

RESUMO DA AULA

O que você leva desta aula

Todo let desta aula reserva um slot de tamanho conhecido na pilha; imutabilidade é o padrão e mut autoriza reescrever o valor — nunca trocar o tipo (E0308).
Shadowing (let repetido) cria uma variável nova com o mesmo nome, podendo mudar o tipo — o caminho idiomático para transformar dados em etapas.
Inteiros vêm em pares com/sem sinal (i8–i128, u8–u128); i32 e f64 são os padrões inferidos, usize é o tipo de índices e len(), e overflow em debug vira panic, não número errado.
char ocupa 4 bytes fixos (um code point Unicode); a codificação UTF-8 do mesmo símbolo ocupa de 1 a 4 bytes — a distinção volta na aula de strings.
Tuplas agrupam tipos heterogêneos e se abrem com let (a, b); arrays levam o comprimento no tipo ([f64; 3]), e ambos vivem inteiros na pilha.
Na próxima aula — funções, if/else e loops — o if que devolve valor e o ponto e vírgula que muda o significado de uma linha: o erro E0308 mais famoso do Rust, decodificado.

+200 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

O que cada let coloca na pilha

Pratique no seu computador

Meça o char: code point e bytes em UTF-8

Casos e valores esperados

Execute com o Cargo local

Quebre os centavos em uma tupla

Casos e valores esperados

Execute com o Cargo local

Calcule a média sem laço

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.