Lição 5: Configurações Dinâmicas

Narrativa

Piloto, bem-vindo à sala de calibração da Academia Æther! Nem todas as configurações do seu mecha são gravadas em pedra. Algumas — como o modelo do reator — são fixas desde a construção. Outras — como a intensidade dos escudos — precisam de ajustes em tempo real durante missões críticas.

Nesta lição, você aprenderá a diferença entre valores imutáveis (como as especificações do núcleo) e mutáveis (como os níveis de energia redistribuídos). Também descobrirá o shadowing: a arte de redefinir uma variável com um novo valor e tipo, como quando recalibramos sensores com novos parâmetros.

Conceito

Em Rust, todas as variáveis são imutáveis por padrão. Isso significa que, uma vez atribuído um valor, ele não pode ser alterado:

let modelo_reator = "Æther-X7";  // Imutável - não pode mudar
// modelo_reator = "Æther-X8";  // ERRO! Não pode reatribuir

Para permitir mudanças, usamos mut:

let mut intensidade_escudo = 50;  // Mutável - pode mudar
intensidade_escudo = 75;          // OK! Agora em 75%

Shadowing permite redeclarar uma variável com o mesmo nome, geralmente transformando o valor:

let sensores = 100;           // i32
let sensores = sensores * 2;  // Novo i32 com valor 200
let sensores = "ativos";      // Novo &str - tipo diferente!

Shadowing ≠ mutabilidade. Com shadowing, você cria uma nova variável. Com mut, você modifica a existente.

Requisitos

• Entrada: Valores de configuração do mecha (inteiros, floats, booleanos)
• Processamento: Aplicar mutabilidade e shadowing em operações de calibração
• Saída: Valores ajustados demonstrando os conceitos de let, let mut e shadowing

Design de Dados

Esta lição trabalha com tipos primitivos básicos (u32, i32, f64, bool) para demonstrar mutabilidade:

// Funções demonstrando mutabilidade e shadowing
pub fn ajustar_intensidade_escudo(valor: u32) -> u32;
pub fn calcular_energia_restante(total: u32, consumido: u32) -> u32;
pub fn recalibrar_sensores(valor: f64) -> f64;  // Requer mut internamente
pub fn incrementar_contador_missoes() -> u32;
pub fn validar_configuracao(base: i32, nova: i32) -> bool;

Todas as funções operam sobre primitivos, demonstrando quando usar mutabilidade vs imutabilidade.

Diagrama Conceitual

flowchart TD
    A[Configuração Inicial] --> B{Precisa Mudar?}
    B -->|Não| C[let - Imutável]
    B -->|Sim, Mesmo Tipo| D[let mut - Mutável]
    B -->|Sim, Novo Tipo| E[Shadowing - Nova Variável]
    C --> F[Segurança Garantida]
    D --> G[Flexibilidade Controlada]
    E --> H[Transformação Completa]
    F --> I[Código Confiável]
    G --> I
    H --> I

Funções e Módulos

//! Lição 5: Configurações Dinâmicas
//!
//! Aprendendo mutabilidade e shadowing na Academia Æther.

/// Ajusta a intensidade do escudo (shadowing demonstrativo)
pub fn ajustar_intensidade_escudo(valor: u32) -> u32;

/// Calcula energia restante (operação imutável)
pub fn calcular_energia_restante(total: u32, consumido: u32) -> u32;

/// Recalibra sensores (usando mut internamente)
pub fn recalibrar_sensores(valor: f64) -> f64;

/// Incrementa contador de missões (demonstra mutabilidade)
pub fn incrementar_contador_missoes() -> u32;

/// Valida se nova configuração é aceitável (shadowing de comparação)
pub fn validar_configuracao(base: i32, nova: i32) -> bool;

Exemplo do Conceito

// IMUTABILIDADE: Configurações fixas do mecha
let modelo_reator = "Æther-X7";
let capacidade_maxima = 1000;
// modelo_reator = "Outro";  // ERRO! Imutável

// MUTABILIDADE: Valores que mudam durante a missão
let mut nivel_escudo = 50;
nivel_escudo = 75;  // OK! Escudo reforçado
nivel_escudo = 90;  // OK! Escudo máximo

// SHADOWING: Transformando valores
let sensores = 10;                    // i32
let sensores = sensores * 10;         // Novo i32: 100
let sensores = sensores as f64 / 2.0; // Novo f64: 50.0
let sensores = "calibrados";          // Novo &str

// Shadowing em escopo limitado
let energia = 500;
{
    let energia = energia + 100;  // Sombra temporária
    println!("Energia reserva: {}", energia);  // 600
}
println!("Energia principal: {}", energia);  // 500

Explicação:

• Linha 1-3: Variáveis imutáveis são seguras e claras
• Linha 6-9: mut permite mudanças quando necessário
• Linha 12-16: Shadowing transforma valores e tipos
• Linha 19-23: Shadowing é limitado ao escopo

Missão

1. Implementar ajustar_intensidade_escudo: Use shadowing para dobrar o valor recebido e aplicar um limite máximo de 100
2. Implementar calcular_energia_restante: Subtraia consumido de total de forma imutável
3. Implementar recalibrar_sensores: Use uma variável mutável para ajustar o valor em 10%, retornando o resultado
4. Implementar incrementar_contador_missoes: Retorne o próximo número de missão usando shadowing

Nota: Esta função demonstra o conceito de mutabilidade interna; o contador real será explorado na Lição 016 (Const/Static). Como a função não recebe estado, ela sempre retorna o mesmo valor (a primeira missão) — o objetivo é praticar a sintaxe de shadowing, não manter um contador persistente.

5. Implementar validar_configuracao: Use shadowing para calcular a diferença e retornar true se a nova configuração estiver dentro de 50 unidades da base

Diagrama de Fluxo da Missão

flowchart TD
    A[Tarefa: Calibrar Sistemas] --> B[ajustar_intensidade_escudo]
    B --> C[calcular_energia_restante]
    C --> D[recalibrar_sensores]
    D --> E[incrementar_contador_missoes]
    E --> F[validar_configuracao]
    F --> G[Testes verificam]
    G --> H{Clippy limpo?}
    H -->|Sim| I[Concluído]
    H -->|Não| J[Corrigir warnings] --> G

Como Executar

# Executar testes
cargo test

# Verificar lint
cargo clippy -- -D warnings

# Formatar código
cargo fmt --check

Dicas

• Prefira imutabilidade sempre que possível — código mais seguro e claro
• Use mut apenas quando o valor realmente precisa mudar ao longo do tempo
• Shadowing é útil para transformações: converter tipos, aplicar cálculos intermediários
• Shadowing em escopo interno não afeta a variável externa — use para isolamento
• A diferença entre mut e shadowing: mut modifica, shadowing substitui
• Lembre-se: shadowing permite mudar o tipo; mut exige manter o mesmo tipo