Haskell

De Wikipedia, la enciclopedia libre

Haskell

Paradigma:	Funcional, no estricto, modular
Apareció en:	1990
Diseñado por:	Universidad de Yale, Universidad de Glasgow
Tipo de dato:	Fuerte, estático
Implementaciones:	GHC, Hugs, NHC, Yhc, JHC
Influido por:	Miranda, ML, Gofer
Ha influido:	Python

Haskell es un lenguaje de programación puramente funcional de propósito general. Su nombre proviene del lógico Haskell Curry.

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, como Miranda, y resolviera la confusión creada por los múltiples lenguajes que seguían este paradigma. El lenguaje evoluciona rápidamente con y (ver más abajo) como los representantes actuales del estándar de facto. El último estándar semi-oficial es Haskell 98, con la intención de especificar una versión mínima y compatible del lenguaje como base para futuras extensiones y para su enseñanza.

Las características más interesantes de Haskell incluyen el soporte para tipos de datos y funciones recursivas, listas, tuplas, guardas y reconocimiento 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:

• Versiones paralelas del MIT y 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 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 links al final de este artículo.

Tabla de contenidos 1 Historia 2 Introducción a Haskell 3 Tipos simples predefinidos 3.1 El tipo Bool 3.1.1 Funciones y operadores 3.2 El tipo Int 3.3 El tipo Integer 3.4 El tipo Float 3.4.1 Funciones y operadores 3.5 El tipo Double 3.6 El tipo Char 3.7 Tuplas 3.8 Listas 4 Implementaciones 5 Ejemplos 6 Enlaces externos 7 Bibliografía

[editar] Historia

[editar] Introducción a Haskell

[editar] Tipos simples predefinidos

[editar] El tipo Bool

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

[editar] Funciones y operadores

• (&&) :: Bool -> Bool -> Bool. Conjunción lógica.
• (||) :: Bool -> Bool -> Bool. Disyunción lógica.
• not :: Bool -> Bool. Negación lógica.
• otherwise :: Bool. Función constante que devuelve el valor True.

[editar] 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]).

fun multi(p1: real list,p2:real list)=
let
fun mult((p1),([]),(l3),(i))=p1;
fun mult(([]),(p2),(l3),(i))=p2;
fun mult(x::xs),(y::ys),(l3),(i)) = if i =length (ys) then l3 
else (x * y)::mult((x),(ys),(l3),(i+1))
in 
crea(mult((l1),(l2),([]),(0)))
end;

[editar] El tipo Integer

Los valores de este tipo son números enteros de precisión ilimitada que tienen las mismas funciones y operadores del tipo Int.

[editar] El tipo Float

Los valores de este tipo son números reales

[editar] Funciones y operadores

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

[editar] 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.

[editar] El tipo Char

Los valores de este tipo son caracteres.

[editar] Tuplas

Los elementos que forman una tupla pueden ser de distintos tipos.

Por ejemplo: ('a',True,3)

[editar] Listas

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

• [Elementos_separados_por_comas] , por ejemplo: [1,2,3,4]
• (primer_elemento:resto_de_la_lista) , por ejemplo: (1:(2:(3:(4:[]))))

[editar] 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 ([1]) es un intérprete. Ofrece una compilación rápida de los programas y un tiempo razonable de ejecución. También viene con una librería 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 ([2]): "Glasgow Haskell Compiler" compila a código nativo en una variedad de arquitecturas y puede también compilar a C. Es, probablemente, uno de los compiladores más populares e incluso tiene unas cuantas librerías (por ejemplo OpenGL) que, aunque muy útiles, sólo funcionan bajo GHC.
• nhc98 ([3]) 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 ([4]) es otro compilador a código nativo de Haskell. Si bien no ha sido actualizado en el último tiempo sigue siendo bastante útil.
• Helium ([5]) 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.

[editar] Ejemplos

  --Función recursiva para calcular el factorial de un número
  factorial :: Integer -> Integer
  factorial 0 = 1
  factorial n = n * factorial (n - 1)

  --Función recursiva para calcular el factorial de un número usando pseudónimos
  factorial :: Integer -> Integer
  factorial 0         = 1
  factorial m@(n + 1) = m * factorial n

  --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

   --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)

  --Algoritmo de ordenación quicksort
  qs::Ord a=>[a]->[a]
  qs [] = []
  qs (p:xs) = qs [x|x<-xs,x<=p] ++ [p] ++ qs [x|x<-xs,x>p]

  --Función para calcular el máximo común divisor mediante el algoritmo de Euclides
  mcd::Int->Int->Int
  mcd x 0 = x
  mcd x y = mcd y (mod x y)

[editar] Enlaces externos

Inglés:

• Haskell Página oficial de Haskell
• Haskell Wiki Wiki de Haskell
• A Gentle Introduction to Haskell 98 (pdf format) Una simple introducción a Haskell 98
• The Evolution of a Haskell Programmer Una forma cómica de ver los distintos estilos de programación en Haskell
• Online Bibliography of Haskell Research Bibliografía de investigaciones en Haskell
• Haskell (programming language)

Español:

• Introducción a Haskell
• Código ejemplo Intérprete de proposiciones lógicas escrito en Haskell
• Razonando con Haskell Un curso sobre programación funcional

Implementaciones:

• Hugs Haskell User's Gofer System
• GHC The Glasgow Haskell Compiler

Otros enlaces:

• Chat de programación funcional con Haskell

[editar] Bibliografía

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