Rust Funcional: inmutabilidad e iteradores

Estilo Funcional en Rust: Inmutabilidad, Código Declarativo y Manejo de Errores

La programación funcional en Rust aborda problemas comunes de los estilos imperativo y orientado a objetos: mutabilidad, bucles imperativos y manejo implícito de errores. En lugar de mutar estado, el código se construye sobre transformaciones inmutables, operaciones declarativas y tipos explícitos como Result y Option. Esto hace que los programas sean predecibles y menos propensos a errores.

Rust es inmutable por defecto, lo que anima a los desarrolladores a repensar patrones familiares. El estilo funcional utiliza iteradores, composición de funciones y coincidencia de patrones para un código limpio y libre de efectos secundarios.

Inmutabilidad en Lugar de Mutación

Las variables mutables crean dependencias ocultas: los valores cambian inesperadamente, complicando la depuración. En código imperativo, una variable mut x puede alterarse en cualquier punto entre su declaración y su uso.

fn my_function(num: i32) -> i32 {
    let mut x = num;
    // ...30 líneas más...
    x += 96;
    // ...50 líneas más...
    x
}

Aquí, el valor original se corrompe y el resultado es impredecible debido a posibles cambios intermedios. La inmutabilidad resuelve esto: se crean nuevos valores en lugar de modificar los antiguos.

let x = 10;
let new_x = process(x); // x permanece sin cambios

En Rust, la inmutabilidad es la norma. La mutación requiere mut explícito, pero el estilo funcional minimiza su uso:

• Verifica si un problema puede resolverse de forma inmutable usando iteradores o map.
• Si la mutación es inevitable, aíslala en el bloque más pequeño posible.
• Prefiere clone o préstamo para la propagación de datos.

Esto reduce los riesgos de condiciones de carrera y simplifica la concurrencia.

Código Declarativo vs. Imperativo

El código imperativo describe pasos de ejecución: bucles, condiciones, mutaciones. El código funcional describe el resultado deseado. Para obtener cuadrados de números del 0 al 9, la versión imperativa requiere un vector y push:

let mut squares = Vec::new();
for num in 0..10 {
    squares.push(num * num);
}

El enfoque declarativo utiliza una cadena de iteradores:

let squares: Vec<i32> = (0..10)
    .map(|x| x * x)
    .collect();

Ventajas del estilo declarativo:

• Menos código: las cadenas de iteradores reemplazan bucles.
• Inmutabilidad: sin mutaciones de colecciones.
• Composabilidad: las funciones se combinan fácilmente.
• Concurrencia: .par_iter() habilita multihilo sin bloqueos.

Los iteradores en Rust son perezosos: map no se ejecuta hasta collect o for_each, optimizando memoria.

Manejo Explícito de Errores

Las excepciones en otros lenguajes ocultan errores: try-catch permite ignorar tipos y contexto. En Rust, Result<T, E> y ? requieren manejo o propagación explícita.

Ejemplo incorrecto con unwrap:

old_toaster().unwrap(); // Entra en pánico ante error

Enfoque correcto usando match o map_err:

let toast = match old_toaster() {
    Ok(t) => t,
    Err(e) => {
        eprintln!("Error: {}", e);
        std::process::exit(1);
    }
};

Consejos para el manejo:

• match para control total.
• map_err para transformación de errores.
• ? solo si quien llama lo maneja.
• Librerías como anyhow o thiserror para conveniencia.

Esto evita pánicos en producción y obliga a considerar errores en tiempo de compilación.

Eliminando la Vaciedad Implícita

En lenguajes imperativos, null acecha en todas partes, causando NullPointerException. Rust usa Option<T>: Some(valor) o None explícitamente.

let maybe_candies: Option<Vec<Candy>> = get_candies();
let candies = match maybe_candies {
    Some(c) => c,
    None => Vec::new(),
};

La coincidencia de patrones asegura que ambos casos se manejen. El compilador no pasará por alto None.

Conclusiones Clave

• Inmutabilidad por defecto reduce errores por cambios de estado.
• Iteradores y map reemplazan bucles, haciendo el código declarativo.
• Result y Option imponen manejo explícito de errores y vaciedad.
• Composición de funciones simplifica pruebas y refactorización.
• El estilo funcional se adapta al 80% de tareas en Rust; las mutaciones son solo para E/S o puntos críticos de rendimiento.

— Editorial Team