Variables en Haskell

En Haskell el concepto de variable cambia un poco; en este lenguaje funcionan como nombres inmutables asignados a valores o expresiones, actuando de forma idéntica a las matemáticas puras en lugar de como casillas de memoria modificables, como en C o lenguajes similares.

Por ejemplo, tenemos este ejemplo en C:

variables.c

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <stdbool.h>

int main(){
	
	bool bandera = true;
	int estado = -3;
	char cadena[] = "FERROCARRILERO.";
	float flotante = 3.0f;
	double real = 22.0880;
	
	printf("Booleano: %d\n",bandera);
	printf("Estado: %d\n",estado);
	printf("Cadena: %s\n",cadena);
	printf("Flotante: %f\n",flotante);
	printf("Double: %f\n",real);
	
	return 0;
}

En Haskell sería de este modo:

variables.hs

bandera :: Bool
bandera = True

estado :: Integer
estado = 3

cadena :: String
cadena = 3

flotante :: Float
flotante = 3.0

real :: Double
real = 22.0880

letra :: Char
letra = 'A'

Otra forma de "declarar variables" sería de esta forma:

main :: IO ()
main = do
    let bandera  = True          -- Bool
    let estado   = -3            -- Int
    let cadena   = "FERROCARRILERO." -- String
    let flotante = 3.0 :: Float  -- Float
    let real     = 22.0880 :: Double -- Double

    putStrLn $ "Booleano: " ++ show bandera
    putStrLn $ "Estado: " ++ show estado
    putStrLn $ "Cadena: " ++ cadena
    putStrLn $ "Flotante: " ++ show flotante
    putStrLn $ "Double: " ++ show real

Hasta aquí todo muy bonito, pero que pasa con el concepto de inmutabilidad de las variable en Haskell.

La inmutabilidad de las variable en Haskell

Como mencionamos, en Haskell las variables son inmutables y funcionan como nombres para valores, no como contenedores que puedes modificar. Esto obliga al programador incipiente en a pensar en términos de transformación de datos en lugar de actualización de estado.

En C, esto está permitido:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <stdbool.h>

int main(){
	
	bool bandera = true;
	int num = -3;
        if(bandera){
          num = 4;
          bandera = false; // bandera ahora es false
        }
	printf("Numero: %d\n",num);// num ahora vale 4
	
	return 0;
}

Hemos actualizado el valor de las variables bandera de true a false y num de -3 a 4. Lo cual es válido en C, pero en lenguajes como Haskell no lo es.

Regla de la inmutabilidad

La regla de la inmutabilidad es: "Una vez que una variable es definida, su valor no puede cambiar".

En Haskell, esto no es válido:

main :: IO ()
main = do
    let num = 32
    putStrLn $ "Número inicial: " ++ show num
    let num = 34 -- Esto no es permitido
    putStrLn $ "Número actualizado: " ++ show num

Para remediarlo, podríamos hacer lo siguiente:

main :: IO ()
main = do
    let num = 32
    putStrLn $ "Número inicial: " ++ show num
    -- let num = 34  -- Esto no es reasignación, es una nueva definición en otro ámbito
    let num2 = 34
    putStrLn $ "Otro número: " ++ show num2

Tenemos entonces que num siempre será 32, y num2 siempre será 34. El programador C podrá actualizar el valor de sus variables, el programador Haskell deberá usar la transformación, crear nuevas variables. Dicho de otro modo, el programador Haskell deberá pensar en nuevos valores que se deriven de los anteriores. Pues al no existir el concepto de reasignación deberá encontrar otras alternativas.

Podríamos extendernos en esta explicación, pero considero que es suficiente por hoy. Continuaremos sobre los conceptos más importantes de este lenguaje en próximas entregas.

Enlaces:

https://en.wikibooks.org/wiki/Haskell/Variables_and_functions
https://onlyhaskellforyou.blogspot.com/2026/03/tipos-de-datos-en-haskell.html