Haskell · Rust · lenguajes

Haskell vs Rust

Haskell y Rust son ambos de tipado estatico, ambos compilados, y ambos atraen a programadores que valoran la correccion. Esa similitud superficial esconde una divergencia profunda en lo que cada lenguaje trata como la fuente principal de bugs, y por tanto en lo que te obliga a manejar en tiempo de compilacion.

Haskell trata los efectos secundarios como el peligro principal. Una funcion que lee un archivo o muta una variable lleva ese hecho en su tipo. Las funciones puras, que toman valores y devuelven valores sin otra interaccion, son el modo por defecto, y la impureza es la excepcion que debes declarar.

Rust trata el mal uso de la memoria como el peligro principal. Sus reglas de ownership y borrowing garantizan en tiempo de compilacion que dos partes de un programa nunca mantienen simultaneamente una referencia mutable a los mismos datos. Las carreras de datos, los use-after-free y los double-free quedan excluidos por el verificador de tipos, no por un recolector de basura.

Ninguno es un superconjunto del otro. La pregunta no es cual es mejor, sino que problema estas resolviendo.

Sistemas de tipos: pureza vs ownership

El sistema de tipos de Haskell desciende de Hindley-Milner. Soporta polimorfismo parametrico, clases de tipos (similares en proposito a los traits de Rust), tipos de kind superior y una separacion entre codigo puro y con efectos impuesta por la monada IO. La inferencia de tipos es omnipresente: puedes escribir programas enteros sin una sola anotacion y el compilador inferira cada tipo.

El sistema de tipos de Rust es afin. Cada valor tiene exactamente un propietario; cuando el ownership se mueve, la variable original deja de ser utilizable. El borrowing (compartido &T o exclusivo &mut T) permite referenciar datos sin tomar el ownership, sujeto a la regla de que puedes tener o una referencia mutable o cualquier numero de referencias compartidas, nunca ambas. Los lifetimes, escritos como 'a, le dicen al compilador cuanto tiempo es valida una referencia.

En la practica, la diferencia se manifiesta en contra de que peleas con el compilador. En Haskell, luchas contra el verificador de tipos cuando tus firmas de funciones no componen. En Rust, luchas contra el borrow checker cuando tu flujo de datos viola las reglas de ownership.

Gestion de memoria

Haskell usa un recolector de basura por rastreo (GC). El runtime de GHC incluye un GC generacional, por copia, que se ejecuta de forma concurrente en una capability separada. La asignacion es rapida (incrementar un puntero en una nursery), y los valores de corta duracion son baratos. El coste aparece como pausas del GC, que el flag -N de GHC y el dimensionamiento de la nursery pueden reducir pero no eliminar.

Rust no usa ningun recolector de basura. La memoria se libera de forma determinista cuando la variable propietaria sale del ambito. Box, Rc, Arc y las colecciones estandar gestionan la memoria heap, pero todas liberan su contenido en un punto conocido. La contrapartida es que debes satisfacer al borrow checker, lo cual es un coste en tiempo de compilacion en esfuerzo del desarrollador, no un coste en tiempo de ejecucion en pausas.

Caracteristicas de rendimiento

Rust compila a codigo nativo sin sobrecarga de ejecucion mas alla de lo que el programador solicita explicitamente. El compilador (rustc, respaldado por LLVM) produce binarios comparables en velocidad a C y C++. La biblioteca estandar de Rust evita las asignaciones ocultas: cuando una funcion asigna, lo dice en su firma tomando o devolviendo un tipo propio.

Haskell compila a codigo nativo a traves de GHC, pero la evaluacion perezosa hace que razonar sobre el rendimiento sea mas dificil. La evaluacion perezosa significa que las expresiones no se calculan hasta que se necesita su valor. Esto permite abstracciones elegantes (listas infinitas, pipelines componibles) pero tambien puede acumular cadenas de computos no evaluados llamados thunks que consumen memoria de forma inesperada. Las anotaciones de estrictez (!, BangPatterns, seq) corrigen esto, pero saber donde colocarlas es una habilidad adquirida.

En benchmarks como el Computer Language Benchmarks Game, los programas Rust son tipicamente de 2 a 10 veces mas rapidos que los programas Haskell equivalentes y usan significativamente menos memoria. La brecha se reduce cuando el codigo Haskell esta cuidadosamente optimizado, pero el esfuerzo base requerido es mayor.

Concurrencia y paralelismo

El runtime de Haskell proporciona hilos verdes ligeros (lanzados por forkIO), memoria transaccional por software (STM), y la biblioteca async para concurrencia estructurada. Como el codigo puro no tiene efectos secundarios, es trivialmente seguro ejecutarlo en paralelo: el compilador puede incluso paralelizar computos puros automaticamente con par y pseq.

Rust previene las carreras de datos en tiempo de compilacion mediante el ownership. Send y Sync son traits marcadores que el compilador verifica automaticamente: un tipo que no es seguro enviar entre hilos simplemente no compilara en un contexto que intente hacerlo. El runtime tokio proporciona un ejecutor async; rayon proporciona paralelismo de datos. Ambos son bibliotecas, no caracteristicas del lenguaje.

La diferencia practica: Haskell hace que la concurrencia sea facil de escribir pero mas dificil de predecir (los thunks perezosos pueden migrar entre hilos). Rust hace que la concurrencia sea mas dificil de escribir (el borrow checker es estricto sobre el estado mutable compartido) pero mas facil de predecir (sabes exactamente que se ejecuta donde).

Ecosistema y herramientas

El gestor de paquetes de Rust es cargo. Se encarga de compilar, probar, hacer benchmarks, documentar y resolver dependencias. El registro, crates.io, alberga mas de 150 000 crates en 2026. rustfmt formatea el codigo, clippy lo analiza, y ambos vienen con la cadena de herramientas.

Las herramientas de build principales de Haskell son cabal-install y stack, que coexisten de forma algo incomoda. Hackage alberga unos 17 000 paquetes. ghcup gestiona las versiones de GHC y la cadena de herramientas. El Haskell Language Server (HLS) proporciona funciones de IDE. El ecosistema es mas pequeno pero profundo en dominios especificos: parsing (megaparsec, attoparsec), compiladores, metodos formales y modelado financiero.

Curva de aprendizaje

Ambos lenguajes son dificiles de aprender comparados con Python o JavaScript. Son dificiles de maneras diferentes.

Haskell requiere aprender un nuevo paradigma de programacion. Si vienes de un trasfondo imperativo, las monadas, los functores, los aplicativos, las clases de tipos y la evaluacion perezosa son conceptos genuinamente nuevos. La sintaxis es poco familiar, y los mensajes de error de GHC pueden ser cripticos hasta que aprendes a leer los informes de discordancia de tipos.

Rust requiere aprender un nuevo modelo de memoria. Los conceptos de ownership, borrowing, lifetimes y la distincion entre Copy y Clone no tienen equivalente directo en la mayoria de lenguajes. El borrow checker rechaza codigo que compilaria sin queja en C++, y aprender por que es la parte dificil.

Cuando elegir cual

Elige Haskell cuando la correccion de la logica importa mas que el control del hardware. Los compiladores, interpretadores, parsers, lenguajes especificos de dominio, motores de reglas financieras y prototipos de investigacion son buenos candidatos. Si tu problema se expresa mejor como una composicion de transformaciones puras, Haskell te permite escribirlo directamente.

Elige Rust cuando necesitas rendimiento predecible sin recolector de basura. La programacion de sistemas, firmware embebido, motores de juegos, modulos WebAssembly, servicios de red bajo presupuestos de latencia estrictos y herramientas de linea de comandos que deben arrancar al instante son buenos candidatos. Si tu programa no debe hacer pausas, Rust lo impone estructuralmente.

Se solapan en backends web (Haskell tiene Servant y Yesod; Rust tiene Actix-web y Axum), herramientas CLI y procesamiento de datos. En estas areas, la eleccion depende de si valoras el prototipado rapido con abstracciones fuertes (Haskell) o el rendimiento bruto con control explicito (Rust).

Lo que comparten

Ambos lenguajes usan tipos de datos algebraicos (data en Haskell, enum en Rust). Ambos tienen pattern matching exhaustivo que el compilador impone. Ambos soportan genericos (polimorfismo parametrico en Haskell, parametros de tipo generico en Rust). Ambos tienen traits o clases de tipos como mecanismo de polimorfismo ad-hoc. Ambos producen binarios independientes sin necesidad de interprete.

Y ambos recompensan al programador que lee atentamente los mensajes de error del compilador, porque en ambos casos, el compilador suele tener razon.

Lectura relacionada: como leer una firma de tipo Haskell, que es WebAssembly.