Haskell

Na Galipedia, a Wikipedia en galego.
Haskell
Paradigma: Funcional, non estrito, modular
Data: 1990
Deseñador: Universidade de Yale, Universidade de Glasgow
Influído por: Miranda, ML, Gofer

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 (ver 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[editar | editar a fonte]

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, Oregon, 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.[1] A primeira versión de Haskell ("Haskell 1.0") definiuse en 1990.[2] 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".[3] 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").[4] Este proceso intenta producir unha revisión menor de Haskell 98.[5]

Introdución a Haskell[editar | editar a fonte]

Tipos simples predefinidos[editar | editar a fonte]

O tipo Bool [editar | editar a fonte]

Os valores con este tipo representan expresións lóxicas cuxo resultado pode ser True ou False.

Funcións e #operador\\\[editar | editar a fonte]

  • (&&) :: 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.

O tipo Int [editar | editar a fonte]

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;

O tipo Integer [editar | editar a fonte]

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

O tipo Float [editar | editar a fonte]

Os valores deste tipo son números reais

Funcións e #operador\\\[editar | editar a fonte]

  • (+), (-), (*), (/), (@^)\:: 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

O tipo Double [editar | editar a fonte]

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

O tipo Char [editar | editar a fonte]

Os valores deste tipo son carácteres.que se ensuentran nunha masa de alta complexidade de en unha suma de carácteres dados coa súa alta definición

Tuplas[editar | editar a fonte]

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

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

Listas[editar | editar a fonte]

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:[]))))

Implementaciones[editar | editar a fonte]

Todas as seguintes implementaciones 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 ([1]) é 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 ([2]): "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 ([3]) é 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 ([4]) é outro compilador a código nativo de Haskell. Aínda que non foi actualizado no último tempo segue sendo bastante útil.
  • Helium ([5]) é 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[editar | editar a fonte]

  --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|x<-xs,x<=p] ++ [p] ++ qs [x|x<-xs,x>p]
  --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[editar | editar a fonte]

  1. "Preface". Haskell 98 Language and Libraries: The Revised Report. December 2002. http://haskell.org/onlinereport/preface-jfp.html.
  2. "The History of Haskell". http://www.haskell.org/haskell-history.html.
  3. Simon Peyton Jones (editor) (December 2002). "Haskell 98 Language and Libraries: The Revised Report". http://haskell.org/onlinereport/.
  4. "Future development of Haskell". http://haskell.org/haskellwiki/Future.
  5. "Welcome to Haskell'". The Haskell' Wiki. http://hackage.haskell.org/trac/haskell-prime.

Véxase tamén[editar | editar a fonte]

QuickCheck

Ligazóns externas[editar | editar a fonte]

Inglés:

Español:

Implementacións:

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

Bibliografía[editar | editar a fonte]

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