Módulos en Haskell

En programación, un módulo es una porción o archivo de código independiente que cumple una tarea específica dentro de un sistema más grande. Dentro de estos archivos podemos contener funciones específicas para ser reutilizadas por otros módulos o programas.

Un módulo de Haskell es una colección de funciones, tipos y clases de tipos relacionadas entre sí. Un programa Haskell es una colección de módulos donde el módulo principal carga otros módulos y utiliza las funciones definidas en ellos para realizar algo.

En Haskell podemos importar módulos propios del lenguaje y además crear los nuestros.

Módulos en Haskell

Usaremos Cabal para crear un proyecto Haskell y mostraremos cómo crear un módulo e importarlo a nuestro programa principal (que también es un módulo).

1. Crearemos el directorio raíz de nuestro proyecto:

$ mkdir pruebasModulos
$ cd pruebasModulos   

2. Crear proyecto con Cabal:

$ cabal update
$ cabal init

Elegiremos una aplicación normal y elegiremos la configuración por default.

Nos creará una estructura como esta:

pruebasModulos/
   app/
     Main.hs
   CHANGELOG.md
   dist-newstyle
   LICENSE
   pruebasModulos.cabal

Cómo Módulos en Haskell

Un módulo tendrá la misma extensión que un programa Haskell (*.hs). La sintaxis de un módulo es la siguiente:

module NombreModulo (nombre_funcion) where

-- Encabezado de la función

-- Cuerpo de la función

El módulo debe ser el mismo que el nombre del archivo.

Contendrá la declaración del encabezado de la función. Por último, su cuerpo. Lo que hace la función.

Ejemplo 1. Crearemos un módulo, siguiendo la lógica de las mónadas, que sume dos números enteros (Int).

MiModulo.hs

module MiModulo (suma) where

suma :: Maybe Int -> Maybe Int -> Maybe Int

suma mx my = do
   x <- mx
   y <- my
   return ( x + y )

Ésta imagen nos da una idea de como el programa principal (Main.hs) depende del módulo (MiModulo.hs). Dentro de éste programa se invocará la función creada. La sintaxis para importar un módulo es la siguiente:

module Nombre_DelPrograma_Principal where

import Modulo_A_Importar(nombre_funcion)


-- Cuerpo del programa principal

Siguiendo esto, vamos a dar un vistazo al programa principal:

Main.hs

module Main where

import MiModulo (suma)

main :: IO()
main = do
    putStrLn "\t [ Uso de modulos en Haskell ]"
    putStrLn "Introduce numero 1:"
    input1 <- getLine
    putStrLn "Introduce numero 2:"
    input2 <- getLine
    let x = Just (read input1 :: Int)
    let y = Just (read input2 :: Int)
    let resultado = suma x y
    putStrLn ("Suma = " ++ show resultado)
    pure()

El programa funciona de la siguiente manera:

  1. El usuario introducirá dos números enteros. 
  2. Se realizará la operación de la suma de éstos números. 
  3. Se imprimirá el resultado en pantalla.

También podemos notar que hemos empleado una palabra rara denominada Just. Así como la función pure().

El constructor Just

Just es un constructor de datos que envuelve un valor existente para indicar que está presente dentro del tipo opcional Maybe. Es parte del tipo de dato Maybe, que se usa para representar valores que pueden estar o no presentes. Útil para evitar errores cuando no hay un valor presente a evaluar.

Función pure()

En Haskell, es una función (propia del lenguaje) que nos ayuda a tomar un valor normal y lo introduce (o "eleva") dentro de un contexto aplicativo o mónada. Pertenece a la clase de tipos Applicative.

Construiremos el proyecto:

$ cabal build

Ejecutaremos:

$ cabal run

Salida:

     [ Uso de modulos en Haskell ]
Introduce numero 1:
33
Introduce numero 2:
42
Suma = Just 75

Ejemplo 2. Crearemos un módulo que contenga funciones para calcular grados celsius (la entrada serán grados fahrenheit) y grados fahrenheit (la entrada serán grados celsius). Se importará el módulo al programa principal.

Comenzaremos con el módulo ``Grados.hs`` que contenga las funciones para la conversión de grados celsius a fahrenheit y viceversa:

module Grados
  ( celsius
  , fahrenheit
  ) where

-- De fahrenheit a celsius
celsius :: Maybe Float -> Maybe Float
celsius grado_f = fmap (\f -> (f - 32) / 1.8) grado_f

-- De celsius a fahrenheit
fahrenheit :: Maybe Float -> Maybe Float
fahrenheit grado_c = fmap (\c -> (c * 1.8) + 32) grado_c

Ahora importaremos este módulo:

Main.hs

module Main where

import Grados (celsius, fahrenheit)

main :: IO()
main = do
    putStrLn "\t [ Uso de modulos en Haskell ]"
    putStrLn "\n \t Conversor de grados  \n \t 1. De Celsius a Fahrenheit.\n \t 2. De Fahrenheit a Celsius \nIntroduce opcion:"
    input1 <- getLine
    putStrLn "Introduce valor de los grados:"
    input2 <- getLine
    let opcion = Just (read input1 :: Int)
    let grados = Just (read input2 :: Float)
    let resultado = case opcion of 
            Just 1 -> fahrenheit grados
            Just 2 -> celsius grados
            _      -> Nothing
    putStrLn ("Grados obtenidos = " ++ show resultado)
    pure()

¿Qué podemos notar?

  • Hemos usado la expresión case variable of la cual es similar al switch en otros lenguajes. 
  • Importamos el módulo ``Grados.hs`` y específicamos las funciones a emplear.

Construiremos el proyecto:

$ cabal build

Ejecutaremos:

$ cabal run

Salida:

         [ Uso de modulos en Haskell ]

         Conversor de grados
         1. De Celsius a Fahrenheit.
         2. De Fahrenheit a Celsius
Introduce opcion:
1
Introduce valor de los grados:
43.2
Grados obtenidos = Just 109.76

Podríamos expandir este tema pero considero que es suficiente.

Continuaremos hablando de módulos y otras cosas en próximas entregas.

Enlaces:

https://onlyhaskellforyou.blogspot.com/2026/08/monadas-monads-en-haskell.html
https://onlyhaskellforyou.blogspot.com/2026/08/funciones-en-haskell.html
https://alquimistadecodigo.blogspot.com/2025/03/plutus-un-lenguaje-de-programacion-del.html
https://stackoverflow.com/questions/18808258/what-does-the-just-syntax-mean-in-haskell
https://hoogle.haskell.org/?q=Just
http://aprendehaskell.es/content/Modulos.html


Comentarios

Entradas populares de este blog

Cabal

Tipos de datos en Haskell

Lenguajes similares Haskell: Agda