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:
- El usuario introducirá dos números enteros.
- Se realizará la operación de la suma de éstos números.
- 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.htmlhttps://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
Publicar un comentario