Variáveis, mutabilidade e tipos primitivos: valores, tipos e memória

let e let mut: o valor pode mudar, o tipo nãoVídeo · 0:48 · legendas em português

ENTENDA A IDEIA

A ideia central

Exemplo Rust

let capacity = 30;   // sem mut: não aceita reatribuição
let mut enrolled = 0; // com mut: aceita novo valor
enrolled += 5;       // soma 5 ao valor atual

EXPERIMENTE

Edite e execute

Troque let enrolled por let mut enrolled. Antes do println!, acrescente enrolled += 5;. Execute o programa. O total deve ser 5. Não substitua o valor inicial zero.

Objetivo

Autorize a mudança do contador e acrescente cinco matrículas.

Saída esperada

matrículas: 5

Rust 2021 · Edite e execute

fn main() {
    let enrolled = 0;
    println!("matrículas: {enrolled}");
}

CÓDIGO ANOTADO

Código anotado

A anotação : u32 escolhe um inteiro sem sinal de 32 bits: a quantidade não pode ser negativa. O compilador verifica o tipo em cada uso.

Uma declaração const exige o tipo e um valor calculável em compilação. Ela pode ficar fora das funções e não aceita mut. A convenção para o nome é UPPER_SNAKE_CASE.

Este trecho inicia um programa que continua nos próximos blocos anotados. Os blocos mostram o código, mas não são programas independentes. Para executar o programa completo no computador, reúna os cinco blocos em src/main.rs de um projeto criado com cargo new tipos. Execute com cargo run. Os desafios de edição já contêm programas completos.

Exemplo Rust

const MAX_SEATS: u32 = 30;

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

EXPERIMENTE

Edite e execute

Troque o valor de MAX_SEATS de 30 para 40. Troque o incremento de 5 para 8. Mantenha u32, o zero inicial e o formato da mensagem. Execute para conferir os dois valores.

Objetivo

Ajuste a capacidade e o número de matrículas sem mudar os tipos.

Saída esperada

matrículas: 8 de 40

Rust 2021 · Edite e execute

const MAX_SEATS: u32 = 30;

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

Shadowing: um novo let com o mesmo nomeVídeo · 0:34 · legendas em português

CÓDIGO ANOTADO

Código anotado

Exemplo Rust

    let spaces = "   ";
    let spaces = spaces.len();
    println!("espaços: {spaces}");

EXPERIMENTE

Edite e execute

Altere somente o primeiro valor de spaces: coloque cinco espaços entre as aspas duplas. Mantenha os dois let e execute. A segunda variável deve guardar a contagem 5.

Objetivo

Transforme um texto de cinco espaços em sua contagem.

Saída esperada

espaços: 5

Rust 2021 · Edite e execute

fn main() {
    let spaces = "   ";
    let spaces = spaces.len();
    println!("espaços: {spaces}");
}

ENTENDA A IDEIA

A ideia central

Rust tem tipos estáticos com inferência: o compilador deduz o tipo, mas não permite mudá-lo depois. Sem outra restrição, inteiros usam i32 e floats usam f64. Existe também f32.

Os inteiros têm versões com sinal (i8 a i128) e sem sinal (u8 a u128), em larguras de 8, 16, 32, 64 e 128 bits. isize e usize acompanham a largura do ponteiro da plataforma.

Use inteiros para quantidades exatas. Floats representam valores aproximados; nem todo decimal tem representação binária exata. Rust não converte automaticamente um inteiro em float. Já bool admite somente true ou false; uma comparação também produz um bool.

Exemplo Rust

let delta = -2;         // i32: inteiro inferido
let enrolled: u32 = 5;  // sem sinal
let mean = 8.5;         // f64: float inferido
let open: bool = true;  // true ou false

EXPERIMENTE

Edite e execute

Troque o valor de enrolled de 30 para 29. Troque a comparação enrolled > capacity por enrolled < capacity. Execute: a comparação deve produzir true. Preserve os tipos e a capacidade.

Objetivo

Use uma comparação entre valores do mesmo tipo para calcular a disponibilidade.

Saída esperada

vagas abertas: true

Rust 2021 · Edite e execute

fn main() {
    let enrolled: u32 = 30;
    let capacity: u32 = 30;
    let open: bool = enrolled > capacity;
    println!("vagas abertas: {open}");
}

Overflow: checked_add e wrapping_addVídeo · 1:03 · legendas em português

ENTENDA A IDEIA

A ideia central

Exemplo Rust

// u8 aceita 0..=255; 250 + 10 não cabe.
250_u8.checked_add(10)  // None: resultado fora do intervalo
250_u8.wrapping_add(10) // 4: retorno explícito ao início
250_u8.checked_add(5)   // Some(255): resultado válido

EXPERIMENTE

Edite e execute

Na chamada de checked_add, troque 10 por 5. Mantenha wrapping_add(10). Execute para obter Some(255) na primeira linha e 4 na segunda. Não use a soma direta que estoura o tipo.

Objetivo

Compare uma soma válida com um retorno explícito ao início do intervalo.

Saída esperada

soma verificada: Some(255)
soma circular: 4

Rust 2021 · Edite e execute

fn main() {
    let small: u8 = 250;
    let checked = small.checked_add(10);
    let wrapped = small.wrapping_add(10);
    println!("soma verificada: {checked:?}");
    println!("soma circular: {wrapped}");
}

CÓDIGO ANOTADO

Código anotado

Um char representa um valor escalar Unicode e ocupa 4 bytes como valor Rust. 'A', 'ç', '日' e '🦀' são exemplos. Aspas simples indicam char; aspas duplas indicam texto (&str).

O tamanho em UTF-8 responde outra pergunta: quantos bytes codificam esse valor? len_utf8() retorna de 1 a 4. 'A' precisa de 1; 'ç', de 2; '日', de 3; o caranguejo, de 4.

A conversão as u32 extrai o code point. A formatação :X mostra esse número em hexadecimal: 1F980 para o caranguejo. Trocar as aspas simples por duplas impede essa conversão: um texto não é um único número Unicode. A próxima função mede as duas propriedades sem confundi-las.

Exemplo Rust

    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");

DESAFIO

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.

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

Rust 2021 · 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)
}

Arquivos, contrato, dicas e solução

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.

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

symbol as u32 extrai o número do valor escalar Unicode. len_utf8() calcula o tamanho da codificação: 1 byte até U+007F, 2 até U+07FF, 3 até U+FFFF e 4 acima disso, para valores válidos.

As duas operações têm custo O(1) e não precisam de alocação. Responder 4 para todo símbolo confunde o tamanho do char com o tamanho da codificação.

A conversão inversa exige validação: nem todo u32 representa um valor escalar Unicode válido. A faixa dos surrogates é proibida. Use char::from_u32, que devolve Option, em vez de tentar as char. Esse retorno será estudado no módulo de enums.

CÓDIGO ANOTADO

Código anotado

Uma tupla reúne uma quantidade fixa de valores. Os tipos podem ser diferentes: (u32, bool) é um tipo de tupla válido. Cada posição tem seu próprio tipo.

Use dimensions.0 para a primeira posição, ou a desestruturação let (width, height) para dar nomes aos dois valores. O comprimento faz parte do tipo: uma tupla de três elementos não cabe em uma anotação de dois elementos (E0308).

Funções podem devolver tuplas para fornecer mais de um resultado. O próximo exercício devolve reais e centavos. A divisão inteira / fornece o quociente; % fornece o resto. Por exemplo, 450 / 100 vale 4 e 450 % 100 vale 50. Nenhum float é necessário.

Exemplo Rust

    let dimensions: (i32, i32) = (3, 4);
    let (width, height) = dimensions;
    println!("área: {}", width * height);

DESAFIO

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.

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

Rust 2021 · 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)
}

Arquivos, contrato, dicas e solução

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.

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

Entre inteiros positivos, / descarta a parte fracionária: 450 / 100 é 4. O operador % fornece o resto: 450 % 100 é 50. A ordem da tupla segue o contrato: primeiro reais, depois centavos.

A expressão reais * 100 + centavos reconstrói o total original. A função tem custo O(1); isso não promete um número específico de instruções de máquina.

Não passe por float para separar dinheiro. Operações com decimais aproximados podem introduzir erros de arredondamento. O caso 7 também funciona sem condição especial: 7 / 100 é 0 e 7 % 100 é 7. Se o intervalo de u32 for insuficiente, um contrato com u64 amplia o intervalo sem introduzir ponto flutuante.

CÓDIGO ANOTADO

Código anotado

Um array contém elementos do mesmo tipo. Seu comprimento faz parte do tipo: [f64; 3] é diferente de [f64; 4]. Os índices começam em zero.

notes.len() retorna usize. A divisão exige operandos compatíveis, então as f64 converte o comprimento explicitamente. O formato {mean:.1} exibe uma casa decimal; esta média aparece como 8.2.

O array contém os valores diretamente. Esses três f64 ocupam 24 bytes como valor Rust, mas isso não determina sua localização física. Para uma coleção que pode crescer, existe Vec, cujo buffer normalmente usa o heap. O módulo de collections trata dessa diferença.

O próximo exercício mantém as três notas no tipo da função e calcula a média sem laços.

Exemplo Rust

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

DESAFIO

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.

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

Rust 2021 · 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]
}

Arquivos, contrato, dicas e solução

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.

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

O array tem exatamente três posições. Os índices 0, 1 e 2 são válidos. Para esse array, Rust 1.98 rejeita um acesso literal notes[3]. Um índice calculado durante a execução também recebe uma verificação de limites.

A função faz duas somas e uma divisão, com custo O(1). O divisor 3.0 tem tipo compatível com f64. Escrever / 3 causa E0277: Rust não promove esse inteiro automaticamente.

A alternativa / notes.len() as f64 faz a conversão explícita. O formato {mean:.1} altera apenas a exibição, não a precisão do cálculo. Como floats representam aproximações, o harness compara a resposta com tolerância de 1e-9. Não arredonde a resposta da função antes de devolvê-la.

ENTENDA A IDEIA

A ideia central

Esses tipos têm tamanho conhecido em compilação. Isso não significa que cada let reserve obrigatoriamente um espaço na pilha. O compilador pode manter valores em registradores, reutilizar armazenamento ou eliminar valores.

Nenhuma dessas declarações exige uma alocação no heap para guardar os valores. Essa afirmação não inclui detalhes internos de operações como println!. Um literal de texto tem armazenamento estático; &str guarda uma referência ao texto, não uma cópia dos seus bytes.

A tabela seguinte compara variáveis e valores como um modelo conceitual, não como um mapa de endereços. Shadowing oculta um nome anterior; não garante que o armazenamento anterior permaneça até o fim do escopo.

Exemplo Rust

let count: u32 = 5;               // valor: 4 bytes
let rate: f64 = 8.5;              // valor: 8 bytes
let notes: [f64; 3] = [0.0; 3];  // valor: 24 bytes
// Tamanho do valor não prova o endereço físico.

ENTENDA A IDEIA

A ideia central

Compare os estados. A soma altera o valor de enrolled, mas mantém u32. O segundo let spaces cria um novo vínculo com tipo usize. Essas linhas não representam posições físicas na memória.

Modelo conceitual: valores e tipos
Estado	Valor	Tipo
`enrolled` antes da soma	`0`	`u32`
`enrolled` depois de += 5	`5`	`u32`
`spaces` primeiro let	`" "`	`&str`
`spaces` novo let	`3`	`usize`

EXPERIMENTE

Edite e execute

Troque [f64; 3] por [f64; 4] e acrescente 10.0 ao array. Execute. size_of_val deve medir 32 bytes, sem afirmar se o array está na pilha ou em um registrador.

Objetivo

Meça o tamanho de um array sem confundi-lo com sua localização.

Saída esperada

array: 32 bytes

Rust 2021 · Edite e execute

fn main() {
    let notes: [f64; 3] = [7.5, 8.0, 9.0];
    println!("array: {} bytes", std::mem::size_of_val(&notes));
}

ENTENDA A IDEIA

A ideia central

Em Go, var count int já recebe zero. Em Rust, ler uma variável antes da primeira atribuição causa E0381. Declare o tipo se necessário e atribua um valor antes da leitura. A primeira atribuição não exige mut.

O int de Go depende da plataforma. Em Rust, o inteiro inferido sem outras restrições é i32; usize acompanha a largura do ponteiro e serve para índices.

Outra diferença: rune é um apelido para int32 e pode conter números que não representam valores escalares Unicode. O char de Rust mantém essa validade. Construtores seguros rejeitam valores inválidos; não basta qualquer número de 32 bits.

Exemplo Rust

let count: i32; // ainda não tem valor
count = 0;     // primeira atribuição, não reatribuição
println!("{count}");

EXPERIMENTE

Edite e execute

Troque a primeira atribuição count = 0; por count = 7;. Preserve a declaração sem valor e sem mut. Execute. Essa é a primeira atribuição, não uma alteração de um valor anterior.

Objetivo

Atribua o valor inicial antes da primeira leitura, sem mut.

Saída esperada

contador inicial: 7

Rust 2021 · Edite e execute

// A declaração separada demonstra a primeira atribuição.
#[allow(clippy::needless_late_init)]
fn main() {
    let count: i32;
    count = 0;
    println!("contador inicial: {count}");
}

ENTENDA A IDEIA

A ideia central

Anote tipos onde eles expressam uma restrição. Deixe a inferência trabalhar quando o contexto já determina o tipo. Um u32 impede valores negativos; [f64; 3] exige exatamente três notas.

Evite conversões que não mudam o tipo. O lint clippy::unnecessary_cast identifica, por exemplo, x as f64 quando x já é f64. Use as quando a conversão é necessária e consciente, como na passagem de um comprimento usize para o divisor f64.

O capítulo 3.2 do The Rust Book reúne os tipos escalares e compostos desta aula. A assinatura de uma função registra parte do contrato antes da execução. No último teste, use diretamente um divisor float, sem uma conversão redundante.

Exemplo Rust

let capacity: u32 = 30; // anotação com intenção: sem negativos
let mean = 8.5;         // o compilador infere f64
let divisor = 3.0;      // nenhuma conversão necessária

EXPERIMENTE

Edite e execute

Troque o divisor 2.0 por 3.0. Mantenha a soma das notas em 24.0 e não acrescente as f64. Execute para obter a média 8.0.

Objetivo

Divida entre floats sem uma conversão redundante.

Saída esperada

média: 8.0

Rust 2021 · Edite e execute

fn main() {
    let total = 24.0;
    let divisor = 2.0;
    let mean = total / divisor;
    println!("média: {mean:.1}");
}

RESUMO DA AULA

O que você leva desta aula

Escolha	Efeito
`let` / `let mut`	Valor imutável / alteração permitida
Novo `let` com o mesmo nome	Shadowing; pode mudar o tipo
`const`	Tipo obrigatório; valor calculável em compilação
Tupla / array	Tipos por posição / um tipo e comprimento fixo

i32 e f64 são os padrões sem outras restrições; usize serve para comprimentos e índices.
Conversões numéricas são explícitas; bool contém true ou false.
checked_add detecta overflow; wrapping_add explicita o retorno ao início.
char ocupa 4 bytes; UTF-8 usa de 1 a 4 por valor escalar.
Tamanho conhecido não garante uma posição na pilha.
Na próxima aula: funções, condições e laços.

+265 XPpossíveis nesta aula

A ideia central

Edite e execute

Objetivo

Saída esperada

Código anotado

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

A ideia central

Edite e execute

Objetivo

Saída esperada

Código anotado

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

Casos e valores esperados

Execute com o Cargo local

Código anotado

Quebre os centavos em uma tupla

Casos e valores esperados

Execute com o Cargo local

Código anotado

Calcule a média sem laço

Casos e valores esperados

Execute com o Cargo local

A ideia central

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

O que você leva desta aula

Você transformou esta ideia em prática.