Tipos de datos en Haskell

Como hemos mencionado, Haskell es un lenguaje de programación funcional de tipado estático. ¿Qué quiere decir esto?

• En Haskell es necesario especificar qué tipos de datos vamos a emplear en nuestros programas. 
• Puesto que al compilar el programa (sí, Haskell se compila) se evaluarán los tipos para saber si son enteros, booleanos o cadenas de caracteres.
• Además al tener inferencia de tipos no tenemos que especificar, por ejemplo, que un número es un número.

Comprobemos esto. Abrimos una terminal y tecleamos:

$ ghci

Esto abrirá el REPL de Haskell. Usemos el comando :type o el abreviado :t para ver los tipos de datos.

ghci> :type "Esto es una cadena"
"Esto es una cadena" :: String
ghci> :type 33
33 :: Num a => a
ghci> :type True
True :: Bool
ghci> :t 'X'
'X' :: Char
ghci> :t 23 + 32
23 + 32 :: Num a => a

En este ejemplo vemos los tipos: Char, String, Num y Bool.

Incluso aplica en las propias funciones de Haskell:

ghci> :type succ
succ :: Enum a => a -> a
ghci> :type max
max :: Ord a => a -> a -> a
ghci> :type min
min :: Ord a => a -> a -> a

Incluso nuestras propias definiciones de función:

ghci> :l factorial.hs
[1 of 2] Compiling Main             ( factorial.hs, interpreted )
Ok, one module loaded.
ghci> :type factorial
factorial :: Int -> Int

Hay más tipos de datos, incluso podrías crear los tuyos. Similar a la lógica de los typedef de C.

Para ello tenemos a data, newtype y type . Veamos unos ejemplos.

Ejemplos con data

Tipos algebraicos de datos. Permiten crear estructuras que pueden tener múltiples constructores.

data Color = Rojo | Verde | Azul

Usar Maybe para representar valores opcionales.

data Maybe a = Nothing | Just a

Los registros permiten definir tipos con campos con nombre, lo que facilita el acceso y la actualización.

data Persona = Persona { nombre :: String, edad :: Int }

Podemos crear "objetos" y acceder a sus "propiedades". Similar a lo que se hace en C con los struct.

juan = Persona { nombre = "Juan", edad = 30 }

Ejemplos con type

Con ellos puedes crear alias de tipos, útiles para dar más claridad.

type Nombre = String
type Edad = Int
type Persona = (Nombre, Edad)

Ejemplos con newtype

Útiles cuando quieres crear un tipo distinto pero basado en otro, con costo cero en tiempo de ejecución.

newtype UsuarioId = UsuarioId Int

En este caso, esto evita confusiones entre enteros que representan cosas diferentes.

Hacer uso de esto es muy útil para cuando necesitemos usar estructuras complejas, alias más legibles o datos más seguros.

Haskell tiene tipos Int e Integer para representar números enteros.

Float para los números reales en coma flotante.

Double para los números reale en coma flotante de doble precisión.

Y demás tipos útiles en nuestros programas, además de permitir nuestras propias definiciones de datos.

Vamos a crear un programa en Haskell que muestre los tipos básicos como Int, Integer, Float, Double, Char, String y Bool.

tipos_datos.hs

-- Programa en Haskell para mostrar tipos de datos básicos
main :: IO ()
main = do
    -- Int: enteros con tamaño fijo
    let xInt :: Int
        xInt = 42
    putStrLn ("Int: " ++ show xInt)

    -- Integer: enteros arbitrariamente grandes
    let xInteger :: Integer
        xInteger = 123456789012345678901234567890
    putStrLn ("Integer: " ++ show xInteger)

    -- Float: números en coma flotante de precisión simple
    let xFloat :: Float
        xFloat = 3.14159
    putStrLn ("Float: " ++ show xFloat)

    -- Double: números en coma flotante de precisión doble
    let xDouble :: Double
        xDouble = 2.718281828459045
    putStrLn ("Double: " ++ show xDouble)

    -- Char: un solo carácter
    let xChar :: Char
        xChar = 'A'
    putStrLn ("Char: " ++ show xChar)

    -- String: lista de caracteres
    let xString :: String
        xString = "Hola, Haskell!"
    putStrLn ("String: " ++ xString)

    -- Bool: valores booleanos
    let xBoolTrue :: Bool
        xBoolTrue = True
    let xBoolFalse :: Bool
        xBoolFalse = False
    putStrLn ("Bool (True): " ++ show xBoolTrue)
    putStrLn ("Bool (False): " ++ show xBoolFalse)

Entramos al REPL de Haskell:

$ ghci

Cargamos el programa y lo ejecutamos. La salida será la siguiente:

ghci> :l tipos_datos.hs
[1 of 2] Compiling Main             ( tipos_datos.hs, interpreted )
Ok, one module loaded.
ghci> main
Int: 42
Integer: 123456789012345678901234567890
Float: 3.14159
Double: 2.718281828459045
Char: 'A'
String: Hola, Haskell!
Bool (True): True
Bool (False): False

Haskell cuida que los tipos de datos sean los correctos, y esto ocurre en el tiempo de compilación. Asegurando que el programa cumpla con los criterios de definición de datos. Lo que asegura que nuestro prograa funcionará correctamente (ahí te hablan Python).

Enlaces:

https://wiki.haskell.org/index.php?title=Type
https://serokell.io/blog/kinds-and-hkts-in-haskell