Haskell

**Haskell** é unha linguaxe de programación puramente funcional de propósito xeral. O seu nome provén do lóxico Haskell Curry.

Nos anos 1980 constituíuse un comité cuxo obxectivo era crear unha linguaxe funcional que reunise as características das múltiples linguaxes funcionais da época, como Miranda, e resolvéuse a confusión creada polas múltiples linguaxes que seguían este paradigma.
A linguaxe evoluciona rapidamente con e (véxase máis abaixo) como os representantes actuais do estándar *de facto*. O último estándar *semi-oficial* é **Haskell 98**, coa intención de especificar unha versión mínima e compatible da linguaxe como base para futuras extensións e para o seu ensino.

As características máis interesantes de Haskell inclúen o soporte para tipos de datos e funcións recursivas, listas, tuplas, gardas e recoñecemento de patróns. A combinación das mesmas poden resultar nalgunhas funcións case triviais cuxa versión en linguaxes imperativas poden chegar a resultar extremadamente tediosas de programar. Haskell é, desde 2002, un dos linguaxes funcionais sobre os que máis se investigou. Desenvolvéronse moitas variantes:

* Versións paralelas do MIT e Glasgow, ambas as denominadas *Parallel Haskell*.
* Máis versións paralelas e distribuídas de Haskell chamadas *Distributed Haskell* (anteriormente *Goffin*) e Eden
* Unha versión con execución especulativa: *Eager Haskell*
* Varias versións orientadas a obxectos: *Haskell++*, ''Ou'Haskell* e *Mondrian''.
* Unha versión educativa chamada Gofer desenvolvida por Mark Jones que foi suplantada por HUGS (ver abaixo).

Para información máis detallada, referirse ao sitio oficial ou aos links ao final deste artigo.

## Historia 
A partir da publicación de Miranda, en 1985, as linguaxes funcionais proliferaron. En 1987, existían competindo entre elas máis dunha ducia de linguaxes de programación puras funcionais non estritas. Durante a conferencia sobre Linguaxes de Programación Funcionais e Arquitecturas de Computador (FPCA '87) en Portland, Oregón, mantívose un meeting durante o cal alcanzouse un forte consenso entre os seus participantes para formar un comité que definise un estándar aberto para tales linguaxes. Isto fíxose co propósito expreso de consolidar as linguaxes existentes nun único que servise como base para a investigación futura en deseño de linguaxes. A primeira versión de Haskell ("Haskell 1.0") definiuse en 1990. Os esforzos do comité resultaron nunha serie de definicións da linguaxe, que culminaron a finais de 1997 en **Haskell 98**, que se intentou fose unha versión da linguaxe mínima, estable e portable, xunto cunha biblioteca estándar asociada para o ensino, e como base de futuras extensións. O comité expresamente aprobou a creación de extensións e variantes de Haskell 98 mediante a adición e incorporación de características experimentais.

En xaneiro de 1999, o estándar da linguaxe Haskell 98 publicouse en The "Haskell 98 Report". En xaneiro de 2003, publicouse unha versión revisada en Haskell "98 Language and Libraries: The Revised Report". A linguaxe continúa evolucionando rapidamente, coas implementaciones de Hugs e de GHC (véxase máis adiante), que representan o actual estándar *de facto*. A principios do 2006 comezou o proceso de definición dun sucesor do estándar de Haskell 98, chamado informalmente **Haskell′** ("Haskell Prime"). Este proceso intenta producir unha revisión menor de Haskell 98.

## Tipos simples predefinidos 
### Tipo *Bool* 
Os valores con este tipo representan expresións lóxicas cuxo resultado pode ser *True* ou *False*.

#### Funcións e #operador\\\ 
* (&&) :: Bool -> Bool -> Bool. Conxunción lóxica.
* (||) :: Bool -> Bool -> Bool. Disyunción lóxica.
* not :: Bool -> Bool. Negación lóxica.
* otherwise :: Bool. Función constante que devolve o valor *True*.

### Tipo *Int* 
Os valores deste tipo son números enteiros de precisión limitada que cobren polo menos o 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),(e::ys),(l3),(i)) =if i=length (ys) then l3
 else (x * e)::mult((x),(ys),(l3),(i+1))
 in
 crea(mult((l1),(l2),([]),(0)))
 end;

### Tipo *Integer* 
Os valores deste tipo son números enteiros de precisión ilimitada que teñen as mesmas funcións e operadores do tipo Int.

### Tipo *Float* 
Os valores deste tipo son números reais

#### Funcións e #operador\\\ 
* (+), (-), (*), (/), (@^)\:: Float -> Float -> Float. Suma, resta, produto, división real e potencia de expoñente enteiro.
* abs, signum, negate :: Int -> Int. Valor absoluto, signo e negación.
* (**) :: Float -> Float. Potencia de expoñente real

### Tipo *Double* 
Os valores deste tipo son números reais, de maior rango e con aproximacións máis precisas que os de tipo Float.

### Tipo *Char* 
Os valores deste tipo son caracteres que se atopan nunha masa de alta complexidade dunha suma de caracteres dados coa súa alta definición

### Tuplas
Os elementos que forman unha tupla poden ser de distintos tipos.

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

### Listas
Os valores deste tipo son unha colección de elementos do mesmo tipo. Existen dúas construtoras para listas:

* [Elementos_separados_por_comas] , **por exemplo:** [1,2,3,4]
* (primeiro_elemento:resto_de_a_lista) , **por exemplo:** (1:(2:(3:(4:[]))))

## Implementacións 
Todas as seguintes implementacións cumpren na súa totalidade, ou case na súa totalidade, cos estándares de Haskell 98 e son distribuídas baixo licenzas *Open Source*. Non se coñecen implementaciones comerciais da linguaxe.

* ***Hugs*** (http://www.haskell.org/hugs/) é un intérprete. Ofrece unha compilación rápida dos programas e un tempo razoable de execución. Tamén vén cunha librería gráfica moi simple, o que o fai adecuado para quen o están aprendendo. Con todo non é unha implementación a desprezar, é unha das máis liviás e compatibles.
* ***GHC*** (http://www.haskell.org/ghc/): "Glasgow Haskell Compiler" compila a código nativo nunha variedade de arquitecturas e pode tamén compilar a C. É, probablemente, un dos compiladores máis populares e ata ten unhas cantas librerías (por exemplo OpenGL) que, aínda que moi útiles, só funcionan baixo GHC.
* ***nhc98*** (http://www.cs.york.ac.uk/fp/nhc98/ ) é outro compilador cun mellor tempo de execución que Hugs. Esta implementación enfocouse a minimizar a utilización da memoria converténdoa nunha boa opción para arquitecturas lentas ou antigas.
* ***HBC*** (http://www.cs.chalmers.se/augustss/hbc/hbc.html) é outro compilador a código nativo de Haskell. Aínda que non foi actualizado no último tempo segue sendo bastante útil.
* ***Helium*** (http://www.cs.uu.nl/helium/ ) é un novo dialecto de Haskell. Centrouse en ser moi fácil de aprender; por iso, non inclúe soporte para todo o estándar de Haskell, facendo que non sexa totalmente compatible.

## Exemplos 
```haskell
-—Función recursiva para calcular o factorial dun número
   factorial :: Integer -> Integer
   factorial 0 = 1
   factorial n = n * factorial (n - 1)

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

   --Función para calcular as raíces dunha ecuación de segundo grao a partir dos seus coeficientes
   raíces :: Float -> Float -> Float -> (Float, Float)
   raíces a b c
    | disc >=0= ((-b + raizDisc) / denom,
                   (-b - raizDisc) / denom)
    | otherwise = erro "A ecuación ten raíces complexas"
      where
         disc = b*b - 4*a c.*
         raizDisc = sqrt disc
         denom = 2*a

    --Función para calcular o 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|xp]

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

## Notas 
## Véxase tamén 
### Bibliografía 
* Ruiz, Blas; Gutiérrez, Francisco; Guerrero, Pablo; e Gallardo, José. *Razonando con Haskell. Un curso sobre programación funcional*. Thomson.

### Outros artigos 
* QuickCheck
### Ligazóns externas 
* Haskell Páxina oficial de Haskell
* A Gentle Introduction to Haskell 98 (pdf format) Unha simple introdución a Haskell 98
* The Evolution of a Haskell Programmer Unha forma cómica de ver os distintos estilos de programación en Haskell
* Online Bibliography of Haskell Research Bibliografía de investigacións en Haskell
* Haskell (programming language)
* Introdución ao Haskell
* Código exemplo Intérprete de proposicións lóxicas escrito en Haskell
* Razoando con Haskell Un curso sobre programación funcional
* Linguaxe de Programación Funcional Haskell Haskell Básico
* Hugs Haskell User's Gofer System
* GHC The Glasgow Haskell Compiler