Lição 35: Métodos Encadeados (Encadeamento de Sistemas)

1. Narrativa

O mecha Æther precisa configurar seus subsistemas em sequência fluida — cada ajuste no reator prepara o próximo estágio. Encadeamento de Sistemas é a técnica de conectar métodos onde cada um retorna a instância modificada, permitindo pipelines de configuração e transformação de dados. O piloto que domina o encadeamento escreve código expressivo e legível.

2. Conceito

Method chaining é o padrão onde cada método retorna &mut Self (ou Self), permitindo chamadas encadeadas como obj.metodo_a().metodo_b().metodo_c(). Em Rust, aparece em:

• Builder pattern: Configuração fluente de objetos com &mut Self
• Iterator pipelines: .map().filter().collect() — transformações encadeadas
• Option/Result chaining: .and_then() — fluxos de dados opcionais
• Transformação fluente: Pipeline de dados com zero alocações intermediárias

3. Requisitos

• Criar struct com builder pattern encadeável
• Usar encadeamento de iterators para pipeline de dados
• Aplicar chaining com Option para busca encadeada

4. Design de Dados

graph LR
    A[Reator::novo] --> B[.definir_potencia]
    B --> C[.definir_temperatura]
    C --> D[.ativar]
    D --> E[Reator configurado]

5. Diagrama de Fluxo

flowchart TD
    A[Início] --> B[Ler temperatura]
    B --> C{ > 500°C?}
    C -->|Sim| D[Etiqueta: CRITICA]
    C -->|Não| E{ > 100°C?}
    E -->|Sim| F[Etiqueta: ALTA]
    E -->|Não| G[Descartar]
    D --> H[Adicionar ao resultado]
    F --> H
    G --> I{Mais leituras?}
    H --> I
    I -->|Sim| B
    I -->|Não| J[Fim]

6. Funções

Função	Descrição
Reator::novo	Cria reator com valores padrão
Reator::definir_potencia	Define potência MW (encadeável)
Reator::definir_temperatura	Define temperatura alvo (encadeável)
Reator::ativar	Ativa o reator (encadeável)
Reator::obter_potencia	Retorna potência configurada
Reator::esta_ativo	Verifica se reator está ativo
classificar_temperaturas	Pipeline .map().filter().collect()
transformar_dados	Pipeline .map().map().filter().collect()
processar_sensores	Pipeline .filter().map().fold()
buscar_config	Encadeamento Option com .and_then()
normalizar_nomes	Pipeline de strings .map().map().collect()

7. Exemplo

// Builder pattern encadeado
let reator = Reator::novo()
    .definir_potencia(500)
    .definir_temperatura(300)
    .ativar();

// Iterator pipeline encadeado
let resultado: Vec<_> = vec![100, 300, 600]
    .into_iter()
    .filter(|&t| t > 100)
    .map(|t| if t >= 500 { "CRITICA" } else { "ALTA" })
    .collect();

8. Missão

1. Implementar Reator::definir_potencia retornando &mut Self
2. Implementar Reator::definir_temperatura retornando &mut Self
3. Implementar Reator::ativar retornando &mut Self
4. Implementar classificar_temperaturas com .filter().map().collect()
5. Implementar transformar_dados com .map().filter().collect()
6. Usar .filter().map().fold() em processar_sensores
7. Usar .and_then() em buscar_config para encadeamento Option
8. Implementar normalizar_nomes com .map().map().collect()

9. Como Executar

cargo build
cargo test
cargo clippy -- -D warnings
cargo fmt --check

10. Dicas

• Builder pattern: cada setter retorna &mut Self para permitir chaining
• Iterator pipelines são lazy — só executam no consumidor final
• .and_then() em Option é ideal para encadear operações que podem falhar — e preserva None → None (se a entrada for None, o resultado é None, sem fallback). Evite .or() aqui: ele devolveria o fallback mesmo quando a entrada é None, quebrando o contrato de buscar_config
• Use &mut self quando quer modificar e encadear; &self para consultas