Lição 30: Síntese Rápida (Turbo Fish)

1. Narrativa

O piloto do mecha Æther domina a notação ::<> — o Turbo Fish — para sintetizar tipos explicitamente quando o compilador precisa de ajuda para desambiguar. Em vez de deixar o motor de inferência adivinhar, o piloto injeta o tipo exato com precisão cirúrgica.

2. Conceito

Turbo Fish (::<>) especifica tipos explicitamente onde a inferência falha:

• parse: "42".parse::<i32>() — converter string para tipo específico
• collect: .collect::<Vec<i32>>() — materializar iterador em coleção
• Funções genéricas: funcao::<Tipo>(args) — chamar com tipo explícito
• FromStr: T::from_str(texto) — parsing com trait genérico
• Desambiguação: Quando múltiplos tipos são possíveis, turbo fish resolve

3. Requisitos

• Usar turbo fish com .parse::<T>() para conversões de string
• Usar turbo fish com .collect::<Tipo>() para materializar iteradores
• Chamar funções genéricas com tipo explícito
• Combinar turbo fish com traits do std (FromStr, Add, Mul)

4. Design de Dados

graph LR
    A["String '42'"] --> B[".parse::<i32>()"]
    B --> C["i32: 42"]
    D["String '3.14'"] --> E[".parse::<f64>()"]
    E --> F["f64: 3.14"]
    G["Iterator"] --> H[".collect::<Vec<i32>>()"]
    H --> I["Vec<i32>"]

5. Diagrama de Fluxo

flowchart TD
    A[Início] --> B{Tipo de síntese?}
    B -->|Parse| C[".parse::<i32>() ou ::<f64>() ou ::<bool>()"]
    B -->|Collect| D[".collect::<Vec<T>>() ou ::<HashSet<T>>()"]
    B -->|Função genérica| E["somar::<i32>() ou somar::<f64>()"]
    C --> F[Resultado tipado]
    D --> F
    E --> F

6. Funções

Função	Descrição
sintetizar_inteiro	Converte string para i32 via parse::<i32>()
sintetizar_decimal	Converte string para f64 via parse::<f64>()
sintetizar_booleano	Converte string para bool via parse::<bool>()
coletar_como_inteiros	Coleta iterator em Vec<i32>
filtrar_inteiros_validos	Filter_map com parse::<i32>()
converter_de_string	Genérico com T::from_str()
somar	Função genérica chamável com turbo fish
duplicar_valores	Map e collect genéricos
sintetizar_por_codigo	Despacha conversão por código de tipo
caracteres_unicos	Coleta em HashSet<char> via turbo fish

7. Exemplo

let num: i32 = "42".parse::<i32>().unwrap();
let decimal: f64 = "3.14".parse::<f64>().unwrap();
let nums: Vec<i32> = ["1", "2", "3"].iter().filter_map(|s| s.parse::<i32>().ok()).collect::<Vec<i32>>();
let soma = somar::<i32>(10, 20);

8. Missão

1. Implementar sintetizar_inteiro usando .parse::<i32>()
2. Implementar sintetizar_decimal usando .parse::<f64>()
3. Implementar sintetizar_booleano usando .parse::<bool>()
4. Implementar coletar_como_inteiros usando .collect::<Vec<i32>>()
5. Implementar filtrar_inteiros_validos combinando filter_map e parse
6. Implementar converter_de_string<T> usando T::from_str()
7. Implementar somar<T> com trait bound Add
8. Implementar duplicar_valores<T> com Mul e Copy
9. Implementar sintetizar_por_codigo despachando por caractere — use um match simples sobre o código ('i', 'f', 'b') chamando sintetizar_inteiro, sintetizar_decimal ou sintetizar_booleano. Como essas funções não são genéricas, turbo fish não se aplica aqui — o match é a implementação natural
10. Implementar caracteres_unicos usando .collect::<HashSet<char>>()

9. Como Executar

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

10. Dicas

• Turbo fish é necessário quando o compilador não pode inferir o tipo sozinho
• .parse::<T>() retorna Result<T, E> — use .unwrap() ou ? para extrair
• .collect() é genérico sobre o tipo de coleção — turbo fish resolve a ambiguidade
• somar::<i32>(a, b) é equivalente a deixar o compilador inferir, mas explícito é mais claro
• Avançado (Lição 28): converter_de_string<T>, somar<T> e duplicar_valores<T> usam parâmetros genéricos <T> — você os estudará na Lição 28. Por ora, trate T como "qualquer tipo" que satisfaça o trait bound
• Avançado (Lição 29): T: FromStr, T: Add e T: Mul + Copy são trait bounds — você estudará traits na Lição 29. Por ora, entenda que eles restringem quais tipos T podem ser usados