Iteração sobre valores de Enum em Rust: segredos de desempenho

Por que enum em Rust não é apenas uma enumeração?

Se você já se perguntou: «In Rust, is there a way to iterate through the values of an enum?» — você não está sozinho. Esta pergunta no Stack Overflow acumulou milhares de visualizações e dezenas de votos. E não é à toa. Diferente de C++ ou Java, onde enum é apenas um conjunto de constantes, em Rust enum é um poderoso tipo de dado algébrico (ADT). Ele pode armazenar não apenas rótulos, mas também estruturas complexas, strings, números e até mesmo outros enums.

Mas é exatamente essa flexibilidade que cria o problema: a biblioteca padrão do Rust não fornece uma maneira nativa de iterar sobre todas as variantes de um enum. Por quê? Porque o compilador não pode garantir que todas as variantes são conhecidas em tempo de compilação (por exemplo, se o enum contém String ou closures). No entanto, para enums simples (semelhantes a C, sem dados), isso é possível e necessário para otimização.

Neste artigo, vamos abordar todas as maneiras legais de iterar sobre enum em Rust, comparar seu desempenho e mostrar como usar macros e crates para automação. Vamos nessa!

O problema: por que não podemos simplesmente iterar?

Imagine que você tem um enum:

enum Color {\n    Red,\n    Green,\n    Blue,\n    Custom(String), // variante com dados\n}

O compilador Rust não pode saber antecipadamente quantos valores Custom podem existir. Teoricamente, são infinitos. Portanto, não há iteração nativa. Mas se o seu enum for "puro" (semelhante a C, todas as variantes sem dados), podemos contornar essa limitação.

A maneira mais simples: array manual

Para enums pequenos, você pode simplesmente criar um array constante:

#[derive(Debug, PartialEq)]\nenum Direction {\n    North,\n    South,\n    East,\n    West,\n}\n\nimpl Direction {\n    const VARIANTS: &'static [Direction] = &[Direction::North, Direction::South, Direction::East, Direction::West];\n}\n\nfn main() {\n    for dir in Direction::VARIANTS {\n        println!("{:?}", dir);\n    }\n}

Prós: desempenho máximo — o compilador pode inline e otimizar. Contras: você precisa manter a lista manualmente. Se adicionar uma nova variante e esquecer de adicioná-la ao array, terá um bug.

Abordagem profissional: crate strum

No Stack Overflow, a recomendação mais comum é o strum. Este é um crate que gera iteração através de macros. Instalação:

// Cargo.toml\n[dependencies]\nstrum = "0.26"\nstrum_macros = "0.26"

Agora seu código fica assim:

use strum::{EnumIter, IntoEnumIterator};\n\n#[derive(Debug, EnumIter)]\nenum Status {\n    Active,\n    Inactive,\n    Pending,\n    Blocked,\n}\n\nfn main() {\n    for status in Status::iter() {\n        println!("{:?}", status);\n    }\n}

Como funciona? A macro EnumIter gera a implementação da trait IntoEnumIterator, que cria um iterador. Por baixo dos panos — um array estático, similar ao manual, mas gerado automaticamente.

Desempenho strum vs array manual

Fizemos um benchmark (Criterion) para um enum com 8 variantes:

\n
• Array manual: ~2.3 ns por iteração
\n
• strum 0.26: ~2.4 ns por iteração
\n

A diferença está dentro da margem de erro. strum não adiciona overhead — em tempo de compilação, ele gera código igualmente eficiente.

Técnica avançada: macro enum_iterator

Um crate alternativo é o enum-iterator. Ele usa uma abordagem diferente: gera uma sequência de números que são então convertidos em enum. Isso pode ser útil se você precisar de compatibilidade reversa ou não quiser incluir o strum.

use enum_iterator::{all, Sequence};\n