Variáveis e tipos básicos

// Variáveis com let: imutáveis por padrão, mutáveis com mut.
fn main() {
    // Sem mut, o valor não pode mudar depois de definido.
    let produto = "Caderno universitário";
    let preco = 24.90;

    // Com mut, a variável aceita novas atribuições.
    let mut estoque = 50;
    println!("{produto}: R$ {preco:.2}, {estoque} em estoque");

    // Chegou uma remessa e saíram algumas vendas.
    estoque += 30;
    estoque -= 12;
    println!("Depois do dia: {estoque} unidades");

    // Sombreamento: um novo let com o mesmo nome cria outra variável.
    let preco = preco * 0.9;
    println!("Com 10% de desconto: R$ {preco:.2}");

    // O sombreamento pode até trocar o tipo; mut não pode.
    let estoque = estoque > 0;
    println!("Disponível para venda? {estoque}");

    // Constantes: nome em maiúsculas e tipo sempre explícito.
    const LIMITE_POR_CLIENTE: u32 = 5;
    println!("Limite por cliente: {LIMITE_POR_CLIENTE} unidades");
}

// Os tipos escalares de Rust: inteiros, ponto flutuante, bool e char.
fn main() {
    // Inteiro com sinal: i32 é o padrão quando não há anotação.
    let pontos = -150;
    // Inteiro sem sinal de 8 bits: vai de 0 a 255.
    let nivel: u8 = 12;
    // u64 para valores grandes; o _ só separa os dígitos.
    let ouro: u64 = 1_250_000;

    // Ponto flutuante: f64 é o padrão.
    let velocidade = 3.5;
    let precisao: f32 = 0.875;

    // bool só aceita true ou false.
    let tem_escudo = true;

    // char usa aspas simples e guarda um caractere Unicode.
    let classe = 'M';
    let simbolo = '★';

    println!("Pontos: {pontos}, nível: {nivel}, ouro: {ouro}");
    println!("Velocidade: {velocidade}, precisão: {precisao}");
    println!("Escudo: {tem_escudo}, classe: {classe} {simbolo}");

    // Cada tipo inteiro tem limites conhecidos.
    println!("u8 vai de {} a {}", u8::MIN, u8::MAX);
    println!("i32 vai de {} a {}", i32::MIN, i32::MAX);

    // Um char ocupa 4 bytes, mesmo sendo uma letra simples.
    println!("Tamanho de um char: {} bytes", std::mem::size_of::<char>());
}

// Operações entre tipos: divisão inteira, resto e conversão com as.
fn main() {
    const PORCOES_ORIGINAIS: u32 = 4;
    let farinha_g: u32 = 500;
    let ovos: u32 = 3;
    let porcoes_desejadas: u32 = 6;

    // Divisão entre inteiros descarta a parte decimal.
    println!("Ovos por porção (inteiro): {}", ovos / PORCOES_ORIGINAIS);
    // O resto da divisão usa %.
    println!("Ovos que sobram: {}", ovos % PORCOES_ORIGINAIS);

    // Rust não mistura tipos: converta com as antes da conta.
    let fator = porcoes_desejadas as f64 / PORCOES_ORIGINAIS as f64;
    println!("Fator da receita: {fator}");

    let farinha_nova = farinha_g as f64 * fator;
    let ovos_novos = ovos as f64 * fator;
    println!("Farinha: {farinha_nova} g");
    println!("Ovos (exato): {ovos_novos}");

    // as de f64 para inteiro corta as casas decimais (não arredonda).
    println!("Ovos com as u32: {}", ovos_novos as u32);
    // Para arredondar para cima, use ceil() antes de converter.
    println!("Ovos arredondados para cima: {}", ovos_novos.ceil() as u32);

    // Conversão de inteiro grande para pequeno pode perder informação.
    let calorias: u32 = 300;
    println!("300 convertido para u8: {}", calorias as u8);

    // Tuplas agrupam valores de tipos diferentes.
    let (nome, minutos): (&str, u32) = ("Bolo de cenoura", 95);
    println!("{nome}: {}h{:02}min", minutos / 60, minutos % 60);
}