# Tutorial de Haskell: aprender a programar en Haskell

[Haskell](https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/que-es-haskell/ "¿Qué es Haskell?") es un caso especial entre los lenguajes de programación funcionales: desde la definición de la primera versión en 1990, Haskell se considera el **estándar de facto** del [paradigma de programación](https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/paradigmas-de-programacion/ "Paradigmas de programación") funcional. No es coincidencia que muchos otros lenguajes funcionales sigan el modelo de Haskell. Aprender a programar en Haskell puede ser una experiencia frustrante al principio, sobre todo porque cuesta acostumbrarse a los **conceptos de la programación funcional**. Sin embargo, una vez superados los primeros obstáculos, hasta los usuarios más novatos pueden avanzar con éxito en el mundo de la programación Haskell.

En este tutorial de Haskell, te presentaremos paso a paso cómo **aprender a programar en Haskell de forma sencilla**, cómo instalar el lenguaje funcional y cómo funciona exactamente la programación en Haskell.

## Cómo instalar e iniciar Haskell

Como con muchos otros lenguajes de programación, Haskell ofrece muchas posibilidades para trabajar en tu sistema. Si quieres aprender Haskell o programar de forma cómoda, la solución más habitual es **GHCi**, un **entorno de desarrollo interactivo** y listo para usar, que está disponible en combinación con el [Glasgow Haskell Compiler](https://www.haskell.org/ghc/ "Página oficial del Glasgow Haskell Compiler (GHC)"). Además del compilador, se necesitan bibliotecas Haskell, que a su vez requieren **software de construcción** como [Cabal](https://www.haskell.org/cabal/ "Aplicación y construcción de la biblioteca con Cabal") o [Stack](https://docs.haskellstack.org/en/stable/README/ "Pila de construcción software de Haskell").

---

### Nota

La construcción general del compilador de Haskell y la aplicación de construcción correspondiente también forman parte de la **plataforma de Haskell**.

---

Para empezar de la forma más rápida posible, debes instalarte la plataforma completa de Haskell. Los **archivos de instalación** listos para usar en **Windows**, **macOS** y varias distribuciones de **Linux** (incluyendo instrucciones) se pueden descargar de forma gratuita, en el [sitio web oficial del proyecto Haskell](https://www.haskell.org/platform/ "haskell.org").

[![Imagen: Tutorial de Haskell: archivos de instalación en el sitio web de Haskell](https://www.ionos.com/es-us/digitalguide/fileadmin/_processed_/2/e/csm_DE-haskell-tutorial-1_bd677df9a8.webp "Tutorial de Haskell: archivos de instalación en el sitio web de Haskell")](https://www.ionos.com/es-us/digitalguide/fileadmin/DigitalGuide/Screenshots_2020/DE-haskell-tutorial-1.png) La instalación de los componentes de Haskell en Windows está asociada al gestor de paquetes Chocolatey, diseñado para Windows.       En los sistemas Linux también puedes elegir la ruta de instalación a través del **administrador de paquetes.** Si eres usuario de Ubuntu o Debian, escribe el siguiente **comando** en el terminal:

```none
sudo apt-get install haskell-platform
```

Una vez completada la instalación, deberías poder **iniciar** el entorno de desarrollo interactivo cuando lo desees con el comando “**ghci**” desde la línea de comandos de tu sistema: en Windows, por ejemplo, a través de [PowerShell](https://www.ionos.com/es-us/digitalguide/servidores/know-how/windows-powershell/ "Windows Powershell"), que también se recomienda para la instalación.

---

### Nota

Ten en cuenta que las versiones de la **plataforma Haskell en los sistemas de gestión de paquetes** no siempre están actualizadas. Es posible que tengas que actualizar los archivos de instalación.

---

## Aprender a programar en Haskell: entender los tipos de datos básicos

Haskell es un lenguaje puramente funcional, lo que lo hace mucho más interactivo e inteligente que otros lenguajes de programación. Los tipos de datos como **números**, **caracteres** o **valores lógicos** (booleanos) ya están predefinidos en Haskell o, al menos, cómodamente desglosados por la memoria del ordenador.

### Números en Haskell

Haskell interpreta los números naturales como tales. Esto significa que, en el código de Haskell, no es necesario indicar que una **entrada** es un **número**. Al iniciar el entorno de desarrollo, puedes realizar cálculos utilizando los operadores habituales como más (+) o menos (-). Por ejemplo, escribe “2+2” y confirma la entrada pulsando “Intro”:

```none
Prelude> 2+2
```

Haskell presenta entonces el **resultado** de este cálculo matemático: 4.

[![Imagen: Ejemplo del Tutorial de Haskell en Windows PowerShell ](https://www.ionos.com/es-us/digitalguide/fileadmin/_processed_/d/9/csm_DE-haskell-tutorial-2_171e682fc3.webp "Ejemplo del Tutorial de Haskell en Windows PowerShell ")](https://www.ionos.com/es-us/digitalguide/fileadmin/DigitalGuide/Screenshots_2020/DE-haskell-tutorial-2.png) Para iniciar el entorno de desarrollo ghci, solo tienes que escribir “ghci” en la herramienta de línea de comandos del sistema y confirmar la entrada con “Intro”.       ###  Letras en Haskell

Haskell también puede gestionar letras de forma inteligente, como te mostramos en este tutorial de Haskell: primero, ponemos la opción “:t” en el comando. Esto asegura que la línea de comandos imprima el tipo de datos después de confirmar el comando. Después de un espacio, inserta cualquier letra **entre comillas simples o dobles** y confirma con “Intro”.

```none
Prelude>:t "a"
```

El resultado de salida en este caso es correctamente “**\[Char\]**”, abreviatura de la palabra inglesa *character* (en castellano, “letra”).

[![Imagen: Salida con letra e haskell ](https://www.ionos.com/es-us/digitalguide/fileadmin/_processed_/e/a/csm_DE-haskell-tutorial-3_dab276bb28.webp "Salida con letra e haskell ")](https://www.ionos.com/es-us/digitalguide/fileadmin/DigitalGuide/Screenshots_2020/DE-haskell-tutorial-3.png) Salida de Haskell con letra registrada en Windows PowerShell.       ###  Cadenas de caracteres en Haskell

Haskell puede también reconocer cadenas de caracteres, conocidas en los lenguajes de programación como *strings*, sin ningún problema. En este caso, tampoco se necesita una sintaxis específica: basta con **poner la respectiva cadena entre comillas**. La siguiente entrada, compuesta por números y letras, nos sirve de ejemplo:

```none
Prelude>:t "12345abcde"
```

Al indicar la opción “:t”, en la salida Haskell indicará de qué tipo de datos se trata. Al igual que cuando es una sola letra, la línea de comandos mostrará “\[Char\]”.

[![Imagen: Tutorial de Haskell: entrada de cadena en ghci (Windows PowerShell)](https://www.ionos.com/es-us/digitalguide/fileadmin/_processed_/3/1/csm_DE-haskell-tutorial-4_2b149dd2cd.webp "Tutorial de Haskell: entrada de cadena en ghci (Windows PowerShell)")](https://www.ionos.com/es-us/digitalguide/fileadmin/DigitalGuide/Screenshots_2020/DE-haskell-tutorial-4.png) La cadena usada como ejemplo en el tutorial de Haskell es registrada correctamente por Haskell como entrada de caracteres o letras.       ##  Aprender Haskell: presentación de los operadores más importantes

En la sección de números, ya hemos señalado que en Haskell se pueden utilizar sin problemas los **operadores matemáticos** más comunes: suma, resta, división y multiplicación. También es posible utilizar el operador de secuencia o rango para el listado simple de valores consecutivos.

---

### Nota

Para ejecutar y presentar los resultados de los siguientes fragmentos de código de este tutorial de Haskell, se utiliza el entorno de desarrollo web [Online Haskell Compiler](https://www.tutorialspoint.com/compile_haskell_online.php "tutorialspoint.com: Online Haskell Compiler").

---

### Sumas en Haskell

El operador de suma para sumar dos o más valores también se representa clásicamente en Haskell con el signo **más** (+). En el siguiente ejemplo de código, que insertaremos en el archivo ***main.hs***, utilizamos la expresión “**let**” para añadir dos variables (“var1” y “var2”). La línea de comandos presenta el resultado en forma de un **mensaje de texto** definido en la expresión “**putStrLn**”:

```none
main = do 
let var1 = 2 
let var2 = 3 
putStrLn "El resultado de la suma de las dos cifras es:"
print(var1 + var2)
```

En la herramienta online mencionada anteriormente, la **entrada** (ventana izquierda) y la **salida** (ventana derecha) tienen este aspecto:

[![Imagen: Tutorial de Haskell: suma de dos valores ](https://www.ionos.com/es-us/digitalguide/fileadmin/_processed_/c/e/csm_DE-haskell-tutorial-5_cd337dd8a9.webp "Tutorial de Haskell: suma de dos valores ")](https://www.ionos.com/es-us/digitalguide/fileadmin/DigitalGuide/Screenshots_2020/DE-haskell-tutorial-5.png) Si aprendes Haskell, no tienes que romperte la cabeza con los operadores matemáticos. El lenguaje funcional emplea los caracteres habituales para el signo más.       ###  Restas en Haskell

Si quieres que Haskell reste un valor numérico de otro, utiliza el operador clásico de sustracción, expresado con el signo menos (-). Del anterior ejemplo del tutorial de Haskell para la suma, solo tenemos que cambiar el operador y el mensaje de salida:

```none
main = do 
let var1 = 2 
let var2 = 3 
putStrLn "El resultado de la resta de las dos cifras es:" 
print(var1 - var2)
```

[![Imagen: Aprender Haskell: resta de dos variables de valor ](https://www.ionos.com/es-us/digitalguide/fileadmin/_processed_/8/6/csm_DE-haskell-tutorial-6_f19db2705d.webp "Aprender Haskell: resta de dos variables de valor ")](https://www.ionos.com/es-us/digitalguide/fileadmin/DigitalGuide/Screenshots_2020/DE-haskell-tutorial-6.png) Si, a diferencia de los ejemplos del tutorial de Haskell, quieres sumar más de dos valores o restar varios números de un valor de base, Haskell también permite hacerlo.       ---

### Nota

Haskell también utiliza los símbolos típicos para los operadores de **división** y **multiplicación**: Con la barra o barra inclinada (/) puedes dividir valores, mientras que con el carácter asterisco (\*) indicas a Haskell que multiplique los valores.

---

### Listas de valores en Haskell

El operador de secuencia es un operador especial de Haskell. Te permite declarar un listado **con una secuencia de valores**. Se identifica mediante “**\[...\]”**. Por ejemplo, si quieres que Haskell muestre todos los números del 1 al 10, puedes indicar la entrada “\[1..10\]” para este rango de números. Puedes hacer lo mismo con las letras. Por ejemplo, con “\[a..z\]”, se representa el alfabeto. Aquí mostramos un ejemplo simple para el operador de secuencia:

```none
main :: IO()
main = do
print [1..10]
```

[![Imagen: Ejemplo de Haskell: operador de secuencia ](https://www.ionos.com/es-us/digitalguide/fileadmin/_processed_/0/6/csm_DE-haskell-tutorial-7_5aa4613393.webp "Ejemplo de Haskell: operador de secuencia ")](https://www.ionos.com/es-us/digitalguide/fileadmin/DigitalGuide/Screenshots_2020/DE-haskell-tutorial-7.png) Con el operador de secuencia, se puede obtener fácilmente una salida completa de las secuencias de valores en Haskell.       ##  Haskell: cómo declarar y definir funciones

Haskell es un lenguaje puramente funcional. Por esto, no es sorprendente que las funciones desempeñen un papel destacado en la programación con Haskell. Este, como otros lenguajes, emplea su propia manera de **declarar** y **definir funciones**.

---

### Nota

La **declaración** de una función indica al compilador que cierta función existe. También indica que se esperan determinados parámetros y cómo debe ser el resultado. La **definición** de una función es la integración real de la función en el código.

---

Para mostrar de forma clara el principio funcional de Haskell en este tutorial, veremos de nuevo un ejemplo de código:

```none
add :: Integer -> Integer -> Integer   --function declaration
add x y =  x + y                       --function definition
main = do 
putStrLn "La suma de ambos números es la siguiente:"
print(add 3 5)    --calling a function
```

En la primera línea del código se declara la función; los tres valores de la función (entrada y salida) son enteros. En la segunda línea se define la función: se añaden los dos argumentos “x” e “y”. Con el ya conocido **método “main”**, se compila el código y se obtiene el resultado de la función para los dos valores de entrada “3” y “5”.

[![Imagen: Aprender Haskell: declaración y definición de una función ](https://www.ionos.com/es-us/digitalguide/fileadmin/_processed_/6/9/csm_DE-haskell-tutorial-8_538ea10e5e.webp "Aprender Haskell: declaración y definición de una función ")](https://www.ionos.com/es-us/digitalguide/fileadmin/DigitalGuide/Screenshots_2020/DE-haskell-tutorial-8.png) Tutorial de Haskell: declaración, definición y llamada de una función en el compilador Haskell en línea.       El siguiente tutorial de YouTube para principiantes profundiza en el trabajo con funciones en Haskell:

## Más consejos para aprender a programar en Haskell

Haskell es un lenguaje muy popular, por lo que en internet se pueden encontrar muchos recursos de ayuda en forma de manuales en línea, tutoriales y foros de apoyo. Recomendamos, por ejemplo, la **serie de tutoriales de YouTube** [*Haskell for Imperative Programmers*](https://www.youtube.com/playlist?list=PLe7Ei6viL6jGp1Rfu0dil1JH1SHk9bgDV "Serie de tutoriales en YouTube “Haskell para programadores imperativos”") de Philipp Hagenlocher, que resume los componentes más importantes del lenguaje funcional en **más de 30 vídeos con diferentes temas**. La [comunidad de la página oficial de Haskell](https://www.haskell.org/community/ "haskell.org: Community") contiene también numerosos recursos y ayuda. Si prefieres la letra impresa, puedes encontrar el **libro** [*Haskell from the very beginning*](https://www.haskellfromtheverybeginning.com/ "Sitio oficial de “Haskell from the very beginning“") de John Whitington.

Si utilizas el entorno de desarrollo interactivo ghci, puedes también **mostrar un resumen completo de los comandos disponibles** en todo momento mientras aprendes a programar en Haskell. Solo tienes que escribir este comando en la línea de comandos y confirmar la entrada con la tecla “Intro”:

```none
Prelude>:?
```

[![Imagen: Tutorial de Haskell: resumen de los comandos ghci ](https://www.ionos.com/es-us/digitalguide/fileadmin/_processed_/5/6/csm_DE-haskell-tutorial-9_4dca38c27d.webp "Tutorial de Haskell: resumen de los comandos ghci ")](https://www.ionos.com/es-us/digitalguide/fileadmin/DigitalGuide/Screenshots_2020/DE-haskell-tutorial-9.png) El acceso al resumen de comandos puede facilitarte mucho el uso del entorno de desarrollo interactivo de Haskell ghci.


This is a markdown version of: [https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/tutorial-de-haskell/](https://www.ionos.com/es-us/digitalguide/paginas-web/desarrollo-web/tutorial-de-haskell/) for AI/LLM consumption.