El GHCi (Glasgow Haskell Compiler interactive) es una herramienta interactiva que permite a los desarrolladores escribir y probar código Haskell en tiempo real. Es una parte esencial del entorno de desarrollo de Haskell y es muy útil para aprender y experimentar con el lenguaje.

¿Qué es GHCi?

GHCi es el intérprete interactivo de Haskell que viene con el compilador GHC (Glasgow Haskell Compiler). Permite ejecutar expresiones Haskell, cargar módulos, y probar funciones de manera interactiva. Es una herramienta poderosa para el desarrollo y la depuración de código Haskell.

Instalación de GHCi

Antes de usar GHCi, necesitas tener instalado el compilador GHC. Puedes instalarlo siguiendo las instrucciones en la sección de configuración del entorno de Haskell.

Iniciando GHCi

Para iniciar GHCi, abre tu terminal y escribe:

ghci

Deberías ver algo similar a esto:

GHCi, version 8.10.4: https://www.haskell.org/ghc/  :? for help
Prelude>

El prompt Prelude> indica que estás en el entorno interactivo de GHCi.

Comandos Básicos de GHCi

Aquí hay algunos comandos básicos que puedes usar en GHCi:

  • :quit o :q: Salir de GHCi.
  • :load o :l: Cargar un archivo Haskell.
  • :reload o :r: Recargar el archivo actual.
  • :type o :t: Mostrar el tipo de una expresión.
  • :info o :i: Mostrar información sobre un nombre (función, tipo, etc.).
  • :help o :?: Mostrar ayuda sobre los comandos de GHCi.

Ejemplos Prácticos

Evaluar Expresiones

Puedes evaluar expresiones directamente en GHCi. Por ejemplo:

Prelude> 2 + 3
5

Prelude> 10 * 5
50

Definir Funciones

Puedes definir funciones directamente en GHCi:

Prelude> let square x = x * x
Prelude> square 4
16

Cargar Archivos

Supongamos que tienes un archivo Main.hs con el siguiente contenido:

module Main where

main :: IO ()
main = putStrLn "Hola, Mundo!"

Puedes cargar este archivo en GHCi usando el comando :load:

Prelude> :load Main.hs
[1 of 1] Compiling Main             ( Main.hs, interpreted )
Ok, one module loaded.
*Main>

Luego, puedes ejecutar la función main:

*Main> main
Hola, Mundo!

Inspeccionar Tipos

Puedes usar el comando :type para inspeccionar el tipo de una expresión:

Prelude> :type 42
42 :: Num p => p

Prelude> :type "Hello"
"Hello" :: [Char]

Obtener Información

El comando :info proporciona información sobre funciones, tipos y más:

Prelude> :info Maybe
data Maybe a = Nothing | Just a
    -- Defined in ‘GHC.Base’

Ejercicio Práctico

Ejercicio 1: Definir y Probar Funciones en GHCi

  1. Abre GHCi.
  2. Define una función doble que duplique un número.
  3. Define una función cuadrado que calcule el cuadrado de un número.
  4. Prueba ambas funciones con diferentes valores.

Solución

Prelude> let doble x = x * 2
Prelude> let cuadrado x = x * x
Prelude> doble 5
10
Prelude> cuadrado 3
9

Ejercicio 2: Cargar y Ejecutar un Archivo Haskell

  1. Crea un archivo Saludo.hs con el siguiente contenido:
module Saludo where

saludar :: String -> String
saludar nombre = "Hola, " ++ nombre ++ "!"
  1. Carga el archivo en GHCi.
  2. Usa la función saludar con diferentes nombres.

Solución

Prelude> :load Saludo.hs
[1 of 1] Compiling Saludo           ( Saludo.hs, interpreted )
Ok, one module loaded.
*Saludo> saludar "Mundo"
"Hola, Mundo!"
*Saludo> saludar "Haskell"
"Hola, Haskell!"

Conclusión

GHCi es una herramienta esencial para cualquier programador de Haskell. Permite experimentar con el código de manera interactiva, lo que facilita el aprendizaje y la depuración. En esta sección, hemos cubierto los conceptos básicos de GHCi, incluyendo cómo iniciar el intérprete, evaluar expresiones, definir funciones, cargar archivos y usar comandos útiles. Con esta base, estarás bien preparado para explorar y aprender Haskell de manera más efectiva.

© Copyright 2024. Todos los derechos reservados