Edición de «Haskell»

{{Ficha de lenguaje de programación
|nombre = Haskell
|logo = Haskell-Logo.svg
|paradigma = [[Paradigma funcional|Funcional]], no estricto, modular, [[fuertemente tipificado]]
|año = 1990
|diseñador = [[Universidad de Yale]], [[Universidad de Glasgow]]
|tipo_dato = Fuerte, estático
|implementaciones = [[GHC]], [[Hugs]], NHC, Yhc, JHC
|dialectos = 
|influido_por = Miranda, Orwell, ML, Gofer
|ha_influido = [[Python]], [[Java_(lenguaje_de_programación)|Java]], [[C Sharp|C#]], [[Scala_(lenguaje_de_programación)|Scala]]
}}

'''Haskell''' (pronunciado /{{IPA|ˈhæskəl}}/)<ref>{{cite mailing list |url=https://www.haskell.org/pipermail/haskell-cafe/2008-January/038756.html |title=anybody can tell me the pronuncation of "haskell"? |date=28 de enero de 2008 |accessdate=12 de marzo de 2011 |mailinglist=Haskell-cafe |last=Chevalier |first=Tim}}</ref> es un [[lenguaje de programación]] estandarizado multipropósito, [[Programación funcional|funcionalmente puro]], con [[Evaluación perezosa|evaluación no estricta y memorizada]], y [[fuertemente tipado|fuerte tipificación]] estática. Su nombre se debe al lógico estadounidense [[Haskell Curry]], debido a su aporte al [[cálculo lambda]], el cual tiene gran influencia en el lenguaje. En Haskell, «una función es un ciudadano de primera clase» del lenguaje de programación. Como lenguaje de programación funcional, el constructor de controles primario es la función. El lenguaje tiene sus orígenes en las observaciones de Haskell Curry y sus descendientes intelectuales.

En los años 1980 se constituyó un comité cuyo objetivo era crear un lenguaje funcional que reuniera las características de los múltiples lenguajes funcionales de la época, el más notable [[Lenguaje de programación Miranda|Miranda]], y resolviera la confusión creada por la proliferación de los mismos.

El lenguaje evoluciona rápidamente y (ver más abajo) como los representantes actuales del estándar ''[[de facto]]''. El último estándar oficial es: [https://wiki.haskell.org/Haskell_2010 '''Haskell 2010'''], cuyas diferencias respecto al anterior estándar [https://www.haskell.org/onlinereport/ '''Haskell 98'''] son:

Nuevas características del lenguaje:

<ul>
<li>[[Interfaz de funciones foráneas]] (FFI), que permite usar código C en un programa Haskell y código Haskell en un programa C. Un ejemplo explicativo se puede encontrar [https://wiki.haskell.org/FFI_Introduction '''aquí''']</li>
<li>Nombres jerárquicos para los módulos, por ejemplo Data.Bool.</li>
<li>Guardianes con patrones.</li>
</ul>

Características eliminadas del lenguaje:

<ul>
<li>Sintaxis de patrones (n+k). Con lo cual, la siguiente definición de la función factorial no es válida en Haskell 2010 y posteriores: <code>fact (n+1) = (n+1) * fact n</code>.</li>
</ul>

Las características más interesantes de Haskell incluyen el soporte para [[Tipo de dato|tipos de datos]] y funciones [[recursión|recursivas]], listas, [[tuplas]], guardas y [[encaje de patrones]]. La combinación de las mismas pueden resultar en algunas funciones casi triviales cuya versión en [[lenguajes imperativos]] pueden llegar a resultar extremadamente tediosas de programar. Haskell es, desde 2002, uno de los [[lenguajes funcionales]] sobre los que más se ha investigado. Se han desarrollado muchas variantes:

* [[Programación paralela|Versiones paralelas]] del [[MIT]] y [[Universidad de Glasgow|Glasgow]], ambas denominadas ''Parallel Haskell''.
* Más versiones paralelas y distribuidas de Haskell llamadas ''Distributed Haskell'' (anteriormente ''Goffin'') y Eden.
* Una versión con ejecución especulativa: ''Eager Haskell''.
* Varias versiones [[Programación orientada a objetos|orientadas a objetos]]: ''Haskell++'', ''O'Haskell'' y ''Mondrian''.
* Una versión educativa llamada Gofer desarrollada por Mark Jones que fue suplantada por [[Hugs]] (ver abajo).

Para información más detallada, referirse al sitio oficial o a los enlaces al final de este artículo.

== Historia ==

A partir de la publicación de [[Lenguaje de programación Miranda|Miranda]], en 1985, los lenguajes funcionales proliferaron. En 1987, existían compitiendo entre ellos más de una docena de lenguajes de programación puros funcionales no estrictos. Durante la conferencia sobre Lenguajes de Programación Funcional y Arquitecturas de Ordenador (FPCA '87) en [[Portland (Oregón)|Portland]], [[Oregón]], se mantuvo un encuentro durante el cual se alcanzó un fuerte consenso entre sus participantes para formar un comité que definiese un [[estándar abierto]] para tales lenguajes. Esto se hizo con el propósito expreso de consolidar los lenguajes existentes en uno único que sirviera como base para la investigación futura en diseño de lenguajes.<ref>{{Cita web|url=https://haskell.org/onlinereport/preface-jfp.html|título=Preface|obra=Haskell 98 Language and Libraries: The Revised Report|fecha = diciembre de 2002}}</ref> La primera versión de Haskell («Haskell 1.0») se definió en 1990.<ref>{{Cita web|url=http://www.haskell.org/haskell-history.html|título=The History of Haskell|urlarchivo=https://web.archive.org/web/20090429085841/http://haskell.org/haskell-history.html|fechaarchivo=29 de abril de 2009}}</ref> Los esfuerzos del comité resultaron en una serie de definiciones del lenguaje, que culminaron a finales de 1997 en '''Haskell 98''', que se intentó fuera una versión del lenguaje mínima, estable y portable, junto con una biblioteca estándar asociada para la enseñanza, y como base de futuras extensiones. El comité expresamente aprobó la creación de extensiones y variantes de Haskell 98 mediante la adición e incorporación de características experimentales.

En enero de 1999, el estándar del lenguaje Haskell 98 se publicó en «The Haskell 98 Report». En enero de 2003, se publicó una versión revisada en «Haskell 98 Language and Libraries: The Revised Report».<ref name="Revised report">{{Cita web|url=https://haskell.org/onlinereport/|título=Haskell 98 Language and Libraries: The Revised Report|fecha = diciembre de 2002|autor=Simon Peyton Jones|enlaceautor=Simon Peyton Jones}}</ref> El lenguaje continúa evolucionando rápidamente, con las implementaciones de [[Hugs]] y de [[GHC]] (véase más adelante), que representan el actual estándar ''de facto''. A principios del 2006 comenzó el proceso de definición de un sucesor del estándar de Haskell 98, llamado informalmente '''Haskell′''' («Haskell Prime»).<ref>{{Cita web|url=https://haskell.org/haskellwiki/Future|título=Future development of Haskell}}</ref> Este proceso intenta producir una revisión menor de Haskell 98.<ref>{{Cita web|url=http://hackage.haskell.org/trac/haskell-prime|título=Welcome to Haskell'|obra=The Haskell' Wiki|fechaacceso=5 de mayo de 2007|urlarchivo=https://web.archive.org/web/20090423011944/http://hackage.haskell.org/trac/haskell-prime/#|fechaarchivo=23 de abril de 2009}}</ref> En 2010 se lanza [https://wiki.haskell.org/Haskell_2010 '''Haskell 2010'''].

== Tipos simples predefinidos ==
En Haskell, y en lo siguiente, «o :: t» quiere decir que la expresión «o» es tiene tipo «t», y «t&nbsp;‑>&nbsp;s» es un tipo, específicamente una función, que consume algo de tipo «t» y produce algo de tipo «s». El operador (‑>) asocia a la derecha, ya que «t&nbsp;‑>&nbsp;s&nbsp;‑>&nbsp;r» quiere decir «t&nbsp;‑>&nbsp;(s&nbsp;‑>&nbsp;r)».

=== El tipo ''Bool'' ===

Los valores con este tipo representan expresiones lógicas cuyo resultado puede ser ''True'' o ''False''.

==== Funciones y operadores ====
* <code>(&&) :: Bool -> Bool -> Bool</code>. Conjunción lógica.
* <code>(||) :: Bool -> Bool -> Bool</code>. Disyunción lógica.
* <code>not :: Bool -> Bool</code>. Negación lógica.
* <code>otherwise :: Bool</code>. Función constante que devuelve el valor ''True''.

=== El tipo ''Int'' ===

Los valores de este tipo son números enteros de precisión limitada que cubren al menos el intervalo [-2^29, 2^29 - 1] ([minBound, maxBound]).

=== El tipo ''Float'' ===

Los valores de este tipo son números reales. ( 2010, 23.4, 5.7 )

==== Funciones y operadores ====

* <code>(+), (-), (*), (/), (^) :: Float -> Float -> Float</code>. Suma, resta, producto, división real y potencia de exponente entero.
* <code>abs, signum, negate :: Int -> Int</code>. Valor absoluto, signo y negación.
* <code>(**) :: Float -> Float</code>. Potencia de exponente real

=== El tipo ''Double'' ===

Los valores de este tipo son números reales, de mayor rango y con aproximaciones más precisas que los de tipo Float.

=== El tipo ''Char'' ===

Los valores de este tipo son caracteres que se encuentran en una masa de alta complejidad de en una suma de caracteres dados con su alta definición.

Antes de utilizar esta función en hugs debemos utilizar IMPORT CHAR antes de nuestro algoritmo.

=== Tuplas ===

Los elementos que forman una [[tupla]] pueden ser del mismo o de distintos tipos. Es un conjunto de componentes relacionados.
Por ejemplo: ('a', True,3)

=== Listas ===

Los valores de este tipo son una colección de elementos del mismo tipo. Existen dos constructores para listas:

* [Elementos_separados_por_comas], '''por ejemplo:''' <code>[1,2,3,4]</code>
* (primer_elemento:resto_de_la_lista), '''por ejemplo:''' <code>(1:(2:(3:(4:[]))))</code>

== Implementaciones ==

Todas las siguientes implementaciones cumplen en su totalidad, o casi en su totalidad, con los estándares de Haskell 98 y son distribuidas bajo licencias ''[[Open Source]]''. No se conocen implementaciones comerciales del lenguaje.

* '''''[[Hugs]]''''' ([https://www.haskell.org/hugs/]) es un [[intérprete (informática)|intérprete]]. Ofrece una compilación rápida de los programas y un tiempo razonable de ejecución. También viene con una biblioteca gráfica muy simple, lo que lo hace adecuado para quienes lo están aprendiendo. Sin embargo no es una implementación a despreciar, es una de las más livianas y compatibles.
* '''''[[GHC]]''''' ([https://www.haskell.org/ghc/]): «Glasgow Haskell Compiler» compila a código nativo en una variedad de [[sistema operativo|arquitecturas]] y puede también compilar a [[lenguaje de programación C|C]]. Es, probablemente, uno de los [[compiladores]] más populares e incluso tiene unas cuantas bibliotecas (por ejemplo [[OpenGL]]) que, aunque muy útiles, sólo funcionan bajo GHC.
* '''''nhc98''''' ([http://www.cs.york.ac.uk/fp/nhc98/] {{Wayback|url=http://www.cs.york.ac.uk/fp/nhc98/ |date=20050205041736 }}) es otro compilador con un mejor tiempo de ejecución que Hugs. Esta implementación se enfocó a minimizar la utilización de la memoria convirtiéndola en una buena opción para arquitecturas lentas o antiguas.
* '''''HBC''''' ([http://www.cs.chalmers.se/~augustss/hbc/hbc.html]) es otro compilador a código nativo de Haskell. Si bien no ha sido actualizado en el último tiempo sigue siendo bastante útil.
* '''''Helium''''' ([https://web.archive.org/web/20041230135916/http://www.cs.uu.nl/helium/]) es un nuevo dialecto de Haskell. Se centró en ser muy fácil de aprender; por ello, no incluye soporte para todo el estándar de Haskell, haciendo que no sea totalmente compatible.

== Entornos de desarrollo ==

Existen varios IDEs (Integrated Development Environment, o en español, entornos de desarrollo integrado) y/o plugins que se pueden utilizar para desarrollar aplicaciones en Haskell. La mayoría son open source, pero también existen con licencia comercial.

=== Open Source ===
* IntelliJ plugin for Haskell
* EclipseFP plugin for Eclipse IDE
* Colorer plugin for Eclipse IDE
* Leksah
* KDevelop
* Vim
* Emacs
* Atom

=== Comerciales ===
* Haskell for Mac
* Sublime-Haskell

== Web Frameworks ==
La comunidad de desarrollo web en Haskell ha tenido recientemente un gran impulso en la actividad, lo que resulta en una gran cantidad de opciones de bibliotecas para utilizar.<ref>{{Cita web|url=https://wiki.haskell.org/Web|título=Web - HaskellWiki|fechaacceso=26 de junio de 2017|sitioweb=wiki.haskell.org|idioma=en}}</ref> A continuación se presenta la lista de [[framework]] activos en Haskell para desarrollo web. 

=== Happstack ===
Está diseñado para que los desarrolladores puedan prototipar rápidamente, implementar sin dolor, escalar masivamente, operar confiablemente y cambiar fácilmente. Soporta entornos [[GNU/Linux]], [[macOS]], [[FreeBSD]] y [[Microsoft Windows|Windows]].

Se considera un framework web completo, el principal componente es happstack-server: un servidor [[Hypertext Transfer Protocol|HTTP]] integrado, combinadores de [[Encaminamiento|enrutamiento]] y fileserving. Además, una serie de paquetes que solían ser acoplados a Happstack ahora han sido desacoplados de él, pero siguen promocionados y documentados para su uso con Happstack:
* Safecopy: soporte de serialización y migración de tipos de datos
* Acid-state: un sistema de almacenamiento NoSQL ACID con soporte nativo para tipos Haskell

=== Snap ===
Es un framework de desarrollo web basado en una arquitectura snaplet.

Tiene una completa documentación y cuenta con una suite de pruebas con un alto nivel de cobertura de código, pero es un software de etapa inicial con interfaces en constante evolución

=== Yesod ===
Está diseñado para aplicaciones web [[Transferencia de Estado Representacional|RESTful]], de tipo seguro y con alto rendimiento.

Aprovechando la cuasi-cotización para las tareas más fáciles, se provee aplicaciones web concisas con altos niveles de seguridad. Las [https://www.yesodweb.com/book/shakespearean-templates plantillas de Hamlet] se comprueban en tiempo de compilación para ver si son correctas y el controlador utiliza [[URL]] seguras para asegurarse de que sólo está generando URL válidas. Sigue los principios del [[Modelo–vista–controlador|Modelo-Vista-Controlador]] de forma holgada.

=== Miku ===
Una biblioteca sencilla para el rápido prototipado web en Haskell, inspirada en [https://rack.github.io/ Ruby's Rack] y [http://www.sinatrarb.com/ Sinatra].

=== Lemmachine ===
Es un RESTful web framework. La arquitectura principal es una copia de [https://github.com/webmachine/webmachine/wiki Webmachine] basada en [[Erlang]], que es actualmente la mejor referencia de documentación. Se destaca por su dinámico Webmachine escrito de forma tipada dependiente en Agda.

=== Mohws ===
Es un servidor web con un sistema de módulos y soporte para [[Interfaz de entrada común|CGI]]. Basado en el Servidor Web Haskell original de Simon Marlow.

=== Salvia ===
Es un servidor web y un framework de aplicaciones web que puede ser utilizado para escribir sitios web dinámicos en Haskell. Desde el código de protocolo de nivel inferior hasta el código de aplicación de alto nivel, todo está escrito como un controlador de Salvia. Este enfoque hace que el servidor sea extremadamente extensible.

=== Scotty ===
Es un framework web inspirado en Sinatra de Ruby, usando [[Web Accessibility Initiative|WAI]] y Warp. Es una manera sencilla de escribir aplicaciones web RESTful y declarativas. Tiene buena documentación para todas las funciones relevantes.

=== Servant ===
Es un framework ligero principalmente para APIs REST. Permite especificar las especificaciones de una API como alias de tipo y luego trabajar con estos alias de tipo para crear servidores, documentación, código de cliente en Haskell y [[JavaScript|Javascript]]. Está basado en WAI.

=== MFlow ===
Es un servidor de aplicaciones web. MFlow es una abreviatura de «flujo de mensajes». Se trata de un ''framework'' basado en la continuación, en lugar de otros frameworks basados en la continuación como [https://ocsigen.org/ Ocsigen] (Ocaml), Coccoon (javascript) o [http://seaside.st/ Seaside] (Smalltalk), se basa en una mónada de retroceso que mantiene la sincronización del estado de ejecución con la navegación del usuario. Desde la discontinuación de [http://www2.informatik.uni-freiburg.de/~thiemann/WASH/ WASH], MFlow es el único marco de estilo de continuación escrito en Haskell hasta la fecha.

Utiliza las bibliotecas web Haskell estándares y/o técnicas: [https://hackage.haskell.org/package/wai-middleware-rollbar WAI], [https://hackage.haskell.org/package/warp Warp], Blaze HTML, HSP. Su núcleo es el servidor y la renderización independiente. Una clase de formlets extendidos se utilizan para crear componentes autónomos, llamados widgets. Tienen formato, [[AJAX]] y código de servidor. Se pueden componer para crear la interfaz de usuario.

=== Spock ===
Es un framework orientado al rápido desarrollo web: Ofrece todo lo necesario para iniciar rápidamente el hacking web con Haskell: enrutamiento, [[middleware]], [[JSON]], blaze, sesiones, [[Cookie (informática)|cookies]], ayudante de [[base de datos]], protección [[Cross-site request forgery|csrf]], estado global.

=== Wheb ===
Es un framework WAI para crear aplicaciones web robustas, de alta concurrencia, simples y efectivas. Su objetivo principal es ampliar la funcionalidad de la base de la biblioteca WAI y proporcionar un punto de entrada fácil en los servidores web de Haskell. Facilita la creación de [[Complemento (informática)|plugins]]. Los plugins pueden agregar rutas, middleware, configuraciones e incluso manejar la limpieza de recursos en el apagado del servidor. Las rutas denominadas permiten a los plugins generar dinámicamente sus rutas en tiempo de ejecución basadas en la configuración

=== WebAPI ===
WebApi es una biblioteca ligera basada en WAI que permite definir peticiones y respuestas para los puntos finales como tipos a través de un contrato. El contrato se considera la única fuente de verdad, con lo que WebApi permite crear servicios Web / API REST, generar un cliente Haskell para los servicios existentes de la API, generar un servidor simulador para simular las solicitudes y respuestas.

=== DAML ===
Es un framework de [[contrato inteligente]] basado en el [[Glasgow Haskell Compiler]].

== Comunidad ==

=== The Haskell Symposium ===
«''The'' ''Haskell Symposium''» es un simposio anual organizado por la ''International Conference on Functional Programming'' (ICFP). El simposio está patrocinado por la Association for Computing Machinery (ACM), bajo los auspicios del ''ACM Special Interest Group on programming languages'' (SIGPLAN).

El propósito del evento es discutir la experiencia de los programadores con Haskell, y el futuro desarrollo del lenguaje. El alcance del simposio incluye todos los aspectos del diseño, la semántica, la teoría, la aplicación, la ejecución, y la enseñanza de Haskell.

Antes de 2008, el evento era conocido como «''The Haskell Workshop''». El cambio de nombre refleja el aumento constante de la influencia del evento en la comunidad en general, así como un creciente número de presentaciones de alta calidad que hacen el proceso de aceptación muy competitivo.

=== The Summer of Haskell ===
«''The Summer of Haskell''» es un evento organizado por ''haskell.org'' para llegar a los estudiantes y animarles a contribuir a la comunidad Haskell con la ayuda de mentores experimentados. Este programa está abierto a estudiantes universitarios, mayores de 18 años, en la mayoría de los países.

== Ejemplos ==

Función [[recursividad|recursiva]] para calcular el [[factorial]] de un número natural:
<syntaxhighlight lang="Haskell">
   --Función recursiva que calcula el factorial de un número natural
   factorial :: Integer -> Integer
   factorial n
      | n < 0  = error "no existe el factorial para enteros negativos"
      | n == 0 = 1
      | otherwise = n * factorial (n-1)
</syntaxhighlight>

Otra versión de la función para calcular el [[factorial]] de un natural usando la función product del módulo [https://hackage.haskell.org/package/base-4.7.0.2/docs/Data-List.html Data.List]:
<syntaxhighlight lang="Haskell">
   --Función para calcular el factorial de un entero usando la función product del módulo Data.List
   factorial :: Integer -> Integer
   factorial n
      | n < 0  = error "no existe el factorial para enteros negativos"
      | otherwise = product [1..n]
</syntaxhighlight>

Función [[sumatorio]] de los elementos de una lista de enteros
<syntaxhighlight lang="Haskell">
   --Sumar elementos de una lista
   sumar :: [Int] -> Int
   sumar [] = 0
   sumar (x:xs) = x+sumar(xs)
</syntaxhighlight>

Función para calcular las raíces de una [[ecuación de segundo grado]] a partir de sus coeficientes
<syntaxhighlight lang="Haskell">
   --Función para calcular las raíces de una ecuación de segundo grado a partir de sus coeficientes
   raíces :: Float -> Float -> Float -> (Float, Float)
   raíces a b c
    | disc >= 0 = ((-b + raizDisc) / denom,
                   (-b - raizDisc) / denom)
    | otherwise = error "La ecuación tiene raíces complejas"
      where
         disc = b*b - 4*a*c
         raizDisc = sqrt disc
         denom = 2*a
</syntaxhighlight>

Función que aproxima el [[número e]]
<syntaxhighlight lang="Haskell">
   --Función para calcular el valor de e (2.71828182845905)
   euler :: Double -> Double
   euler 0.0 = 1.0
   euler n   = 1.0 / product [1..n] + euler (n - 1.0)
</syntaxhighlight>

Función para calcular el [[máximo común divisor]] de dos números enteros mediante el [[algoritmo de Euclides]]
<syntaxhighlight lang="Haskell">
   mcd::Int->Int->Int
   mcd x 0 = x
   mcd x y = mcd y (mod x y)
</syntaxhighlight>

Función que realiza la [[criba de Eratóstenes]] (de una lista dada deja solo los [[números primos]])
<syntaxhighlight lang="Haskell">
   eratostenes :: [Int] -> [Int]
   eratostenes [] = []
   eratostenes (x:xs) | not (null xs) && x^2 > last xs = (x:xs)
                      | otherwise = x: eratostenes [y | y <- xs, y `mod` x /= 0]
</syntaxhighlight>Función que determina si un [[número natural]] es [[palíndromo]] (en base 10)<syntaxhighlight lang="haskell">
isPalindrome :: Int -> Bool
isPalindrome n
  | n < 0 = False
  | otherwise = let s = show n
    in s == (reverse s)
</syntaxhighlight>Función que realiza la potencia de un número con [[recursividad]] dividiendo el expediente entre 2<syntaxhighlight lang="haskell">
potencia :: Double -> Int -> Double 
potencia b e = if e < 0 then 1 / (potencia b (-e))
  else if e == 0 then 1 
  else let p = potencia b (e `div` 2)
  in if e `mod` 2 == 1 then p * p * b else p * p
</syntaxhighlight>
Función que evalúa de manera perezosa la lista de [[números primos]] utilizando una cláusula ''where'' y [[Lista intencional|listas intencionales]] 
<syntaxhighlight lang="haskell">
numerosPrimos::[Integer]
numerosPrimos = 2 : [p | p <- [3 ..], es_primo p]
    where
      es_primo n
        | even n    = False
        | otherwise = null [m | m <- [3, 5 .. div n 2], mod n m == 0]
</syntaxhighlight>
Implementación del algoritmo [[Quicksort]]
<syntaxhighlight lang="haskell">
qsort :: (Ord a) => [a] -> [a]
qsort [] = []
qsort (x:xs) = qsort [y | y <- xs, y <= x] ++ [x] ++ qsort [y | y <- xs, y > x]
</syntaxhighlight>

== Véase también ==
* [https://github.com/politrons/Dive_into_Haskell Example of most Haskell features]
* [[QuickCheck]]

== Notas y referencias ==
{{listaref}}

== Bibliografía ==
* Ruiz, Blas; Gutiérrez, Francisco; Guerrero, Pablo; y Gallardo, José. Razonando con Haskell. Un curso sobre programación funcional. Thomson.

== Enlaces externos ==

'''Español:'''
* [https://github.com/politrons/Dive_into_Haskell Example of most Haskell features]
* [http://horru.lsi.uniovi.es/~labra/FTP/IntHaskell98.pdf Introducción a Haskell] {{Wayback|url=http://horru.lsi.uniovi.es/~labra/FTP/IntHaskell98.pdf |date=20100405044725 }}
* [https://web.archive.org/web/20070504042306/http://www.frt.utn.edu.ar/sistemas/paradigmas/Haskell.htm Lenguaje de programación funcional Haskell] Haskell Básico
* [http://www.lcc.uma.es/~blas/pfHaskell/gentle/index.html Una introducción agradable a Haskell] Versión en español del libro «''A Gentle Introduction to Haskell»''.
* [http://aprendehaskell.es/ ¡Aprende Haskell por el bien de todos!] Traducción de la obra «''Learn you a Haskell for great good''».
* [https://www.youtube.com/watch?v=YAKTlImnS-g&list=PLraIUviMMM3fbHLdBJDmBwcNBZd_1Y_hC&index=1 Haskell básico] Curso de Haskell

'''Inglés:'''
* [https://github.com/politrons/Dive_into_Haskell Example of Most Haskell Features]
* [http://www.haskell.org Haskell] Página oficial de Haskell
* [https://github.com/politrons/Dive_into_Haskell Haskell in Examples] Examples of how to use Haskell
* [https://tryhaskell.org/ Try Haskell] Prueba Haskell en línea
* [https://www.haskell.org/tutorial/ A Gentle Introduction to Haskell 98] ([https://www.haskell.org/tutorial/haskell-98-tutorial.pdf pdf] format) Una introducción agradable a Haskell 98
* [https://www.willamette.edu/~fruehr/haskell/evolution.html The Evolution of a Haskell Programmer] Una forma cómica de ver los distintos estilos de programación en Haskell
* [https://web.archive.org/web/20080915054919/http://haskell.readscheme.org/ Online Bibliography of Haskell Research] Bibliografía de investigaciones en Haskell
* [http://learnyouahaskell.com/ Learn You a Haskell for Great Good]

'''Implementaciones:'''
* [https://haskell.org/hugs/ Hugs] Haskell User's Gofer System
* [https://haskell.org/ghc/ GHC] The Glasgow Haskell Compiler
* [http://www.cs.uu.nl/wiki/Helium Helium], Helium

{{Control de autoridades}}
[[Categoría:Lenguajes de programación]]
[[Categoría:Lenguajes funcionales]]
[[Categoría:Lenguajes de programación educativos]]
[[Categoría:Software de 1990]]