Iterador: enumerate()
enumerate() transforma cualquier iterador en uno que produce pares [índice, valor]. Es la forma idiomática de llevar la posición de cada elemento sin manejar a mano una variable contador.
Código
// Iteradores: enumerate() para obtener pares (índice, valor)
fn print_pair(idx: int, val: int) {
print("[" + int_to_string(idx) + "] = " + int_to_string(val))
}
fn main() -> int {
let frutas: Array = [10, 20, 30, 40, 50]
// enumerate() retorna un iterador de pares {index, value}
// Se puede iterar con for-in desempaquetando idx y val
let enumerado: Array = frutas.iter().enumerate().collect()
// Cada elemento es un array [indice, valor]
var i: int = 0
while i < enumerado.length() {
let par: Array = enumerado[i]
let idx: int = par[0]
let val: int = par[1]
print_pair(idx, val)
i = i + 1
}
// También se puede combinar con otros adapters
let primeros: Array = frutas.iter().enumerate().take(3).collect()
print("primeros 3 enumerados: " + int_to_string(primeros.length()))
return 0
}Salida
[0] = 10 [1] = 20 [2] = 30 [3] = 40 [4] = 50 primeros 3 enumerados: 3
Explicación
Llamar a .iter() sobre un array produce un iterador perezoso. Encadenar .enumerate() envuelve cada elemento en un array de dos posiciones [índice, valor], y .collect() materializa todo el pipeline en un Array concreto. Cada elemento del resultado es a su vez un array, así que par[0] da el índice y par[1] da el valor original.
Como enumerate() es solo otro adaptador de iterador, se compone libremente con el resto de la API de iteradores. El segundo pipeline de este ejemplo agrega .take(3) después de .enumerate() para recolectar solo los primeros tres pares indexados — lo que demuestra que los adaptadores se pueden apilar en cualquier orden.
Este patrón elimina el patrón propenso a errores de mantener una variable contador separada junto a un loop, y deja claro de inmediato el propósito del código para cualquier lector.