Haskell

Per a altres significats, vegeu «Haskell (desambiguació)».

Haskell

Tipus	llenguatge de programació purament funcional, llenguatge de programació no estricte, llenguatge de programació modular, llenguatge interpretat, llenguatge de regles fora de joc, Llenguatge de programació compilat i llenguatge de programació
Data de creació	1990 (1990)
Disseny	Lennart Augustsson, Warren Burton, Kevin Hammond, Paul Hudak, John Hughes, Thomas Johnsson, Simon Peyton Jones, John Launchbury, Erik Meijer, Alastair Reid i Philip Wadler
Desenvolupador	Paul Hudak, Lennart Augustsson, John Hughes, Simon Peyton Jones, Erik Meijer i Philip Wadler
Epònim	Haskell Curry
Paradigma de programació	programació funcional estandarditzat de semàntica no estricta i avaluació tardana
Darrera versió estable	Haskell 2010
Majors implementacions	GHC, Hugs, NHC, JHC, Yhc, UHC
Dialectes	Helium, Gofer
Influenciat per	Clean, FP, Gofer, Hope and Hope+, Id, ISWIM, KRC, Lisp, Miranda, ML and ML Estàndard, Orwell, SASL, SISAL, Scheme
Ha influenciat	Agda, Bluespec, C++11/Concepts, C#/LINQ, Cayenne, Clean, Clojure, CoffeeScript, Curry, Escher, F#, Frege, Hack, Idris, Isabelle, Java/Generics, LiveScript, Mercury, Perl 6, Python, Scala, Swift, Timber, Visual Basic 9.0
Sistema operatiu	multiplataforma
Extensió dels fitxers	.hs, .lhs
Etiqueta d'Stack Exchange	Etiqueta
Pàgina web	haskell.org

Haskell és un llenguatge de programació funcional estandarditzat de semàntica no estricta i avaluació tardana de les expressions (ang: lazy evaluation) en el moment que se'n demana el valor i pren el nom del matemàtic Haskell Curry.

Es diu que és un llenguatge funcional pur. El cert és que admet variables d'estat però permet encapsular-ne els canvis (context ST), o bé circumscriure'n els efectes col·laterals al nivell superficial (context IO).

Haskell basa el polimorfisme en el requeriment d'implementació d'interfícies pels tipus dels paràmetres. Les interfícies amb un paràmetre de tipus t defineixen una partició de l'espai dels tipus en classes segons si les implementen o no, i per això s'anomenen classes de tipus.

-- classe de tipus (la interfície)
class Eq t where
 (==) :: t -> t -> Bool -- iguals
 (/=) :: t -> t -> Bool -- desiguals
 -- implementació per defecte
 x == y = not (x /= y)
 x /= y = not (x == y)
 -- caldrà especificar només una de les operacions en definir la implementació

data Bool = False | True -- definició del tipus Bool

-- instància (la implementació) de la classe Eq per al tipus Bool
instance Eq Bool where
 (==) False False = True
 (==) True True = True
 (==) _ _ = False

-- definició del tipus (Llista a) = Nil | Cons a (Llista a)
-- els símbols '[' i ']' designen una llista
data [a] = [] -- el constructor Nil es denota amb "[]"
 | a : [a] -- el constructor Cons es denota amb ':' en posició infix
-- * per sintaxi, si un símbol comença per ':', va infix
-- * tot identificador de funció es pot posar en infix si s'envolta de cometes revesses

-- exemple d'ús: "Eq t =>" es llegeix: per aquells tipus t tals que (Eq t)
ésMembre :: Eq t => t -> [t] -> Bool -- 
ésMembre x [] = False 
ésMembre x (cap : cua) = x == cap 
 || x `ésMembre` cua -- notació infix amb cometes revesses

• les classes de tipus són com un mòdul genèric, amb el tipus com a paràmetre o índex, que defineix la signatura de les operacions on intervé el tipus indexat.

Derivació automàtica d'instàncies (implementacions d'interfícies): També podem demanar al compilador que, per a classes de tipus bàsiques, derivi una instància partint de la representació interna del tipus (clàusula deriving en la definició de tipus estructurals (clàusula data).

data Color = Verd | Blau | Lila deriving (Eq, Show) -- el compilador deriva instàncies de les classes esmentades, obtenint la posició i el nom dels valors

Els literals no tenen tipus associat sinó que poden pertànyer a aquells tipus que implementin una determinada classe:

$ ghci -- a l'intèrpret
Prelude> :t 1
1 :: Num a => a -- 1 pot assignar-se a vars. d'aquells tipus que implementin la classe Num (que correspon a l'estructura algebraica d'anell)
Prelude> :t 1.5
1.5 :: Fractional a => a -- 1.5 pot assignar-se a vars. d'aquells tipus que implementin la classe Fractional (que correspon a l'estructura algebraica de cos)

-- la clàusula "default" permet l'assignació de tipus tradicional als literals, esmentant una seqüència de tipus a provar
default (Int, Double)

La sobrecàrrega de literals fa possible incorporar-los a diferents estructures:

{-# LANGUAGE OverloadedStrings, OverloadedLists #-}
import Data.Semigroup((<>))
import Data.Text (Text) -- text com a vectors de UTF-16
import Data.Set (Set)
import Data.Map (Map)

tiraDeText = ("abc" :: Text) <> "def" 
llista = ([1..3] :: [Int]) <> [4..6]
cjt = ([1..3] :: Set Int) <> [4..6]
dicc = ([(1,"a"), (2, "b")] :: Map Int String) <> [(3,"c")]

Tipus derivats: Corresponent a la derivació de classes de la P.O.O. Haskell possibilita la derivació de tipus amb la declaració newtype, heretant del tipus base les implementacions d'aquelles classes de tipus que esmentem a la clàusula deriving. Caldrà l'extensió de llenguatge GeneralizedNewtypeDeriving.

Les implementacions no tenen nom. Un tipus no pot tenir diverses implementacions d'una classe de tipus, per ex. diverses ordenacions o diversos monoides per un mateix tipus. Caldrà crear-ne un tipus derivat amb newtype per cadascuna de les implementacions.

{-# LANGUAGE GeneralizedNewtypeDeriving #-} -- amplia les instàncies heretables del Haskell98

-- tipus derivat per implementar un Monoide per a la suma, parametritzat pel tipus base
newtype Sum a = Sum { getSum :: a }
 deriving (Eq, Ord, Read, Show, Bounded, Generic, Generic1, Num) -- classes de les instàncies a heretar
 -- el constructor obté, del tipus base, el tipus derivat
 -- l'accessor obté, del tipus derivat, el tipus base

instance Num a => Monoid (Sum a) where -- per aquells `a` que implementin Num (un anell algebraic)
 mempty = Sum 0 -- element neutre del Monoide
 Sum x `mappend` Sum y = Sum (x + y) -- operació associativa

Les col·leccions heterogènies d'altres llenguatges, aquí es tipifiquen per les operacions requerides, mitjançant tipus existencials (aquells tipus quins components implementin les classes de tipus requerides per al seu tractament).

{-# LANGUAGE ExistentialQuantification #-}

llistaHomo :: [Int]
llistaHomo = [1, 3, 4] -- llista homogènia

-- tipus "existencial": amb un component de tipus variable que compleixi una restricció
data ObjPresentable = forall a. (Show a) => Obj a -- per aquells tipus 'a' tals que "(Show a)"

presentaObj :: ObjPresentable -> String
presentaObj (Obj x) = "Obj " ++ show x 

-- llista d'elements amb components heterogenis, 
-- als quals podrem aplicar les operacions de les classes especificades a la restricció 
llistaHetero :: [ObjPresentable]
llistaHetero = [Obj 1, Obj "abc"]

El control de les operacions sobre els elements dels contenidors es pot fer de diverses maneres:

• Mapeig: Si el contenidor implementa un Functor podrem estalviar múltiples recorreguts dels contenidors en aplicar diversos morfismes als elements, perquè per les lleis del Functor l'aplicació de la composició serà equivalent a la composició de les aplicacions individuals de cadascun dels morfismes. Els conjunts no són Functor

Si no hi ha efectes laterals

• Els catamorfismes o plegaments són operacions que redueixen una col·lecció de valors a un de sol, altrament dit, una gramàtica A* -> A, a la classe Data.Foldable.
• Inversament, els anamorfismes son operacions de desplegament que partint d'un valor anomenat llavor genera una col·lecció A -> A*. No tenen una classe específica. Es descriuen als mòduls de cada col·lecció.
• Un Hylomorfisme és l'aplicació consecutiva d'un anamorfisme seguida d'un catamorfisme. Per exemple el càlcul del factorial desplega una seqüència de crides que és plegada en un valor final.
• Un Metamorfisme és l'aplicació consecutiva d'un catamorfisme seguida d'un anamorfisme.
• Un Paramorfisme és l'extensió del concepte de catamorfisme. Modela la recursió sobre un tipus de dades inductiu.
• Un Apomorfisme és l'extensió del concepte d'anamorfisme, modelant la corecursió sobre un tipus coinductiu.

Quan hi ha efectes laterals cal controlar la seqüència de les operacions

la classe Traversable facilita l'avaluació seqüencial dels elements d'un contenidor d'accions o bé del mapeig dels elements amb una funció d'efectes.

L'avaluació d'accions es pot fer de tres maneres possibles

• Per combinació de resultats (les accions es podrien paral·lelitzar):

• Els Functors aplicatius permeten combinar els resultats d'un seguit d'accions sense restringir-ne la temporalitat i componen les accions aplicant un resultat combinador de la primera, al resultat de l'acció següent. L'obtenció d'un resultat combinador es pot fer mitjançant l'aplicació d'un combinador de més d'un paràmetre, amb `fmap` a la primera acció, o també, elevant el combinador com a valor amb `pure` al tipus de l'efecte.

• Per encadenament de resultats (serialització temporal):

• Les Mònades componen les accions per encadenament del resultat doncs la segona acció pren forma de funció (amb efectes laterals) sobre el resultat de la precedent Hi ha una sintaxi específica (els blocs do) per descriure la composició de manera imperativa.
• Les Fletxes generalitzen les funcions d'efectes laterals de les mònades, i componen les accions com un encadenament de resultats d'efectes funció d'una entrada que aplicarem a un valor inicial. Hi ha una sintaxi específica (els blocs proc) per descriure'n la composició.

Mònades amb efectes laterals funcionals

• La mònada Reader possibilita l'encapsulament d'una funció d'un entorn que podem consultar (ask) i executar localment (amb local) una acció subordinada passant-li l'entorn modificat. L'entorn l'haurem de proporcionar inicialment en executar l'acció.
• La mònada Writer possibilita l'encapsulament d'una sortida incrementable com a Monoide que es pot consultar (listen), actualitzar (tell) i incrementar (censor).
• La mònada State possibilita l'encapsulament d'un estat que podrem consultar (get) i actualitzar (put).
• Els transformadors de mònades possibiliten l'encapsulament de la funcionalitat de diverses mònades.

Programació genèrica

La programació genèrica, parametritzada per tipus, es concreta o bé

• afegint paràmetres de tipus a les classes de tipus,
• o bé, cas de tipus dependents, definint-los com a tipus associats a la classe
• o bé mitjançant #Famílies de tipus (especificació a nivell global d'un tipus dependent quan es vol comú a diferents classes, per exemple el tipus de l'Element per a diferents classes de contenidors).

Haskell destaca en la facilitat per al paral·lelisme, per aprofitar la potència dels processadors multicor.

A finals dels anys 1980 es va constituir un comitè amb l'objectiu de recollir en un llenguatge les característiques dels múltiples llenguatges funcionals de l'època, Miranda, ML i altres.

La primera versió va sortir el 1990. La versió més estesa actualment és la que correspon a l'informe Haskell 98. Tanmateix el compilador GHC incorpora l'estàndard Haskell2010 per defecte a partir de la versió 7.0

A principi de 2006 va començar el procés per definir-ne una nova revisió amb el nom de Haskell' ("Haskell prima", ang:"Haskell prime"). Diversos compiladors incorporen extensions del llenguatge que per a fer-les servir caldrà precedir el codi font amb la pragma {-# LANGUAGE extensió1, extensió2, ... #-} o bé el senyal corresp. de compilació (-Xextensió per al GHC). El wiki de "Haskell Prima" esmenta per cada extensió els compiladors que la implementen.

Haskell 2010: Actualment ha finalitzat el procés de discussió de les incorporacions a la nova versió de l'estàndard, així com un nou procés d'evolució amb revisions (bi-)anuals del llenguatge.

Propostes d'evolució del llenguatge aquí.

Crítiques:

• Haskell té un desavantatge important en la dificultat de depuració, que obliga a un esforç especial en la prevenció de fallades:
  • El model d'execució de Haskell fa que no hi hagi traça de pila de crides. Però se n'ha desenvolupat una de simulada per quan es compila per l'ajustatge (profiling). Per aquest cas, cal disposar de compilacions per l'ajustatge de totes les biblioteques relligades.
  • Les petades per crides a error de les funcions parcials (proveu head []) donen, en compilació de producció, informació molt escassa: ni situació de l'error (a partir de GHC 8.0 error ja dona la posició, excepte al paquet base on s'ha mantingut la versió antiga, reanomenada errorWithoutStackTrace), ni la de la crida que incompleix la precondició. Per això es recomana no utilitzar-les en funcions parcials i convertir-les en totals amb resultat opcional caçant el cas no previst en l'anàlisi del retorn. Recentment des de GHC 7.10.2 hi ha la possibilitat d'obtenir el punt de crida d'origen mitjançant paràmetres implícits especials (Vegeu exemple). Alternativa més segura: evitar les funcions parcials (La biblioteca Safe ofereix alternatives a les funcions parcials predefinides del Prelude; el mòdul Data.List.NonEmpty ofereix llistes no buides com a tipus NonEmpty per aplicar de manera segura les funcions que petarien sobre llistes buides, per ex.: head).
  • Els errors en funcions parcials de col·leccions no imprimeixen els valors causants, perquè la textualització dels elements (Show elem) no s'exigeix.
  • L'ús de traces per depurar es revela un maldecap per la irregularitat en l'ordre d'impressió que segueix l'ordre d'execució i no el d'especificació, indeterminat (per tant aleatori) en codi funcional pur, subjecte a l'avaluació tardana en traces en expressions let del codi monàdic (seqüencial).
  • El pas de paràmetres en les crides recursives (aval. tardana per defecte) pot fer petar la pila (pila d'avaluacions pendents) mentre no s'arriba al cas simple no-recursiu, si no s'avaluen de manera estricta els paràmetres acumuladors de manera completa, en profunditat (#Modes d'avaluació d'expressions i #Avaluació estricta explícita).

• S'ha criticat que no hi hagi un sistema d'extensió de registres i/o especialització. A l'intèrpret Hugs se'n va desenvolupar un anomenat TRex (exemple) que GHC no ha incorporat.

• En realitat es pot aconseguir facilitat en l'especialització de comportament, desacoblant la funcionalitat de l'estructura amb classes de propietats (getters/setters) com es descriu a l'Encapsulament estil O.O..
• La implementació recent de polimorfisme de registres amb camps específics permet especificar els accessors com a requeriment de context, mitjançant la classe HasField (GHC 8.2), estalviant definir classes getters per aconseguir el polimorfisme (exemple verificat a #Polimorfisme de registres amb camps específics - la classe HasField).
• Les referències funcionals, anomenades lents, permeten l'actualització funcional d'estructures complexes en els seus components com un tot, reduint la necessitat de dividir la funció en els mòduls corresponents als components afectats com faríem a la POO.

Problemàtiques:

Vegeu secció #Problemàtiques.

Programa Hola Món

El GHC (Compilador Haskell de Glasgow) és el compilador / intèrpret amb més possibilitats. Instruccions per obtenir-lo, les trobareu aquí. o potser millor descarregant la Plataforma Haskell (La versió que incorpora la e./s. de caràcters no anglosaxons ja està disponible).

Per a Windows i altres podem descarregar-lo d'aquí.

• Una altra opció és descarregar el meta-gestor stack que comprova el suport de biblioteques als rebostos #Stackage d'imatges de conjunts de versions compatibles de les biblioteques, i descarrega la versió més recent de GHC que s'hi ajusta, generant un fitxer stack.yaml amb les opcions escollides.

{-| fitxer hola-mon.hs
 * si no hi ha la clàusula ''module'', es pressuposa "module Main where"
-}
import Data.Function ((&)) -- importa l'operador (&): aplicació cap enrere
import Control.Category ((>>>)) -- importa l'op. composició d'esquerre a dreta

-- l'execució comença sempre per la funció inicial ''main'' del mòdul principal
-- alternatives:

main = putStrLn "Hola Món"

main = putStrLn $ "Hola" ++ " Món" -- ($) aplicació endavant, estalvia parèntesis

main = "Hola Món" & putStrLn -- (&) aplicació cap enrere 

main = ["Hola", "Món"] -- les claus designen una llista
 & unwords -- words separa paraules retornant-ne la llista, unwords és la inversa
 & putStrLn 

main = print 5
main = putStrLn . show $ 5 -- equivalent
main = show >>> putStrLn $ 5 -- equivalent
main = 5 & (show >>> putStrLn) -- equivalent

-- nota: 'print' converteix a String i imprimeix, equival a (putStrLn. show) 
-- show a una String li afegeix l'entrecomillat, amb 'print' una String acaba impresa amb duplicació de cometes.

En un sistema Linux podem tenir GHC i altres compiladors de Haskell i runhaskell es pot configurar per executar una alternativa o altra amb un selector d'alternatives de sistema o bé amb la interfície gràfica galternatives (normalment apunta a runghc). A MSWindows podem fer servir indistintament runhaskell o runghc.

Execució directa, sense generació d'executable, amb runhaskell

$ runhaskell hola-mon # cerca el nom de fitxer amb l'extensió .hs (haskell source) o bé .lhs (literary haskell source)

Hola Món

Amb el meta-gestor stack:

# stack templates -- llista plantilles
# stack new projecte nom-de-plantilla
stack new projecte simple
cd projecte
# caldrà actualitzar el fitxer Main.hs al programa Hola-món
stack setup # configura, i descarrega el compilador
stack build # compila i relliga l'executable
stack exec projecte[.exe]

Amb l'intèrpret GHCi del mateix paquet, comanda ghci. Amb el meta-gestor escriuríem stack ghci.

A l'intèrpret no serveix la mateixa sintaxi del nivell declaratiu dels programes, sinó només la dels blocs "do" que permet especificar seqüencialment l'encadenament de resultats d'efectes mònadics; a banda de les comandes específiques que comencen pel caràcter dos-punts i les expressions a avaluar.

Això canvia a partir de GHC 7.4.1 que admet tota mena de declaracions a l'intèrpret GHCi.

$ ghci
GHCi, version 6.10.1: http://www.haskell.org/ghc/ :? for help
Loading package ghc-prim ... linking ... done.
Loading package integer ... linking ... done.
Loading package base ... linking ... done.
Prelude> putStrLn "Hola Mon"
Hola Mon
Prelude> let str = "abc"
Prelude> :type str
str :: [Char]
Prelude> str
"abc"
Prelude> let f x y = x + y
Prelude> :type f
f :: Num a => a -> a -> a
Prelude>

Avaluador en-línia, a l'intèrpret d'expressions funcionals tryhaskell.org.

 reverse "Hola"
 > "aloH"
 :: [Char]

Cercadors de l'API

• Hayoo Arxivat 2010-03-22 a Wayback Machine. (servei interromput): on es podia consultar quines biblioteques exporten un identificador, a les biblioteques del rebost oficial (Hackage).

Permet cercar operadors no alfanumèrics com ara (>>=)

Disponible per a instal·lacions de cerca local

• Hoogle: permet, a més a més, cerca de funcions per signatura. Exemples de cerca:

map
(a -> b) -> [a] -> [b]
Ord a => [a] -> [a]
Data.Map.insert

• Hoogle5 permet alternatives de rebost (biblio estàndard, plataforma Haskell, el rebost Stackage) i cercar també en paquets específics, o bé per autor.

Característiques

Article principal: Característiques del llenguatge Haskell

Afinant el rendiment

Modes d'avaluació d'expressions

En Forma Normal els valors estan avaluats completament.

Els termes Head Normal Form i Weak Head Normal Form són normalitzacions d'expressions del càlcul lambda.

En català està explicat al llibre pdf "Introducció a la programació funcional" de la Universitat de Girona.

La definició del càlcul lambda segueix el document original d'Alonzo Church.

Terminologia del càlcul lambda (en notació Haskell):

• E1 E2: aplicació de l'expressió E1 sobre el terme E2. L'aplicació és associativa per l'esquerra (E1 E2 E3) ≡ (E1 E2) E3
• \ x -> E: abstracció lambda, quin cos pot contenir la variable lligada 'x' i altres de lliures. La var. lligada es refereix a l'argument de la lambda de var. coincident més pròxima que tapa el nom d'altres lambdes de nom coincident. L'abstracció lambda és associativa per la dreta.

(\ x -> \ y -> E) ≡ (\ x -> (\ y -> E))

Cal tenir en compte que

(\ x -> M N) ≡ (\ x -> (M N)) -- el cos de l'abstracció abasta el màxim cap a la dreta

(\ x y -> E) ≡ (\ x -> \ y -> E) -- abreviació d'abstraccions

• redex: contracció de l'anglès "reducible expression"
• conversió alfa: es pot canviar el nom de la variable d'una abstracció lambda mentre el nom nou no coincideixi amb el de cap variable lliure del seu cos alterant-ne la condició.
• beta-redex: expressió reduïble mitjançant una reducció beta.
• eta-redex: expressió reduïble mitjançant una reducció eta.

reducció beta del càlcul lambda en notació Haskell

Una expressió és beta-reduïble (beta-redex) si consisteix en l'aplicació d'una abstracció lambda (funció anònima d'una variable com a mínim) a un paràmetre. És de la forma

 (\ x -> E) P -- expressió "beta-reduïble"
-- la reducció 'beta' és la substitució de la variable 'x' pel paràmetre P en l'expressió E
-- el resultat ('reducte') en notació del càlcul lambda: E[x := P]

• En cas que hi hagi variables lligades a E que alterin la condició de variables lliures homònimes de P a la substitució E[x := P], caldrà reanomenar-les aplicant la conversió alfa del càlcul lambda.

• La notació d'índexs de De Bruijn evita el problema de col·lisió de noms en les substitucions. En comptes de noms les variables lligades es refereixen a l'argument per un índex d'aniuament de la variable respecte a l'abstracció lambda referida.

\ x -> \ y -> \ z -> x y z
-- amb notació de l'índex de De Bruijn seria
\ -> \ -> \ -> v3 v2 v1 -- la variable es refereix a l'argument per l'índex d'aniuament d'abstraccions

Una expressió beta reduïble està en posició de capçalera si és de la forma (en notació Haskell)

\ x1 x2 ... xi -> (\ y -> E) P1 P2 ... Pj -- l'expressió en capçalera és: (\ y -> E) P1 ... Pj

La seva reducció seria

\ x1 x2 ... xi -> E[y := P1] P2 ... Pj

reducció eta del càlcul lambda en notació Haskell

Amb notació Haskell, de la definició del càlcul lambda.

Una abstracció lambda de la forma (\ x -> E x) és eta-reduïble (substituïble per E) si

• la variable de l'abstracció coincideix amb el paràmetre més allunyat del cos,
• i el nom de la variable (x) no pertany a les variables lliures de E.

-- reducció 'eta': l'expressió "eta-reduïble"
(\ x -> E x) 
-- és substituïble per 
E
-- sempre que 'x' no sigui una variable lliure de E

definició tàcita o point-free

La programació tàcita o point-free (sense arguments) estalvia arguments en les definicions aplicant la reducció eta del càlcul lambda.

-- definició
arrelQuad x = sqrt x

-- en forma de lambda
arrelQuad = \x -> sqrt x 

-- per la reducció eta, atès que x no és una variable lliure de l'expressió (sqrt)
arrelQuad = sqrt -- versió tàcita o 'point-free' (estalviant arguments)

Head Normal Form

Una expressió lambda està en "forma normal en capçalera" (HNF) si

1. ja no té beta-redexs (expressions beta-reduïbles) en posició de capçalera, perquè s'han aplicat totes les reduccions beta possibles en aquesta posició (Forma normal beta).
2. l'expressió en posició de capçalera no ha d'ésser tampoc una abstracció lambda amb el cos reduïble, per què aquest cas es tipifica com a "forma normal dèbil en capçalera" (#Weak Head Normal Form).

Weak Head Normal Form

Vegeu i

Una expressió lambda amb el cos reduïble està en WHNF però no en HNF. El terme va ser encunyat per Simon Peyton Jones per explicitar la diferència entre HNF i el que la reducció de grafs fa a la pràctica: posposar la reducció del cos.

Una expressió està en WHNF si està en HNF o bé és una expressió lambda amb el cos reduïble.

Una expressió en WHNF està en una de les formes següents:

• Un Constructor, eventualment aplicat a expressions no reduïdes dels components
• Una funció primitiva simple (d'implementació interna, ang: built-in, que no es basa en definicions) aplicada a menys paràmetres del que correspon a la seva aritat (per ex. "(+) 1" no es pot reduir mentre no disposem de tots els paràmetres que li manquen, doncs no hi ha cap definició de (+) on substituir els paràmetres insuficients)
• Una abstracció lambda

Exemples de situacions d'avaluació a WHNF

• evaluate de Control.Exception avalua com a efecte una expressió funcional llançadora d'excepcions, forçant l'avaluació a WHNF.

• L'avaluació estricta de paràmetres quan es prefixen amb (!) els paràmetres formals (extensió BangPatterns) es fa a WHNF.

Forma Normal

Una expressió està en forma normal si no s'hi poden aplicar més reduccions. Està completament avaluada (en profunditat).

Una expressió que comença per un constructor està en HNF, i això impedeix l'avaluació de les expressions dels components (avaluant amb seq). Perquè quedin avaluades, cal, o bé definir-les estrictes als tipus, o bé avaluar amb deepseq o l'equivalent $!! a "forma normal".

La classe NFData (contracció de NormalFormData) del paquet deepseq (a partir de GHC 7.4.1 forma part del conjunt bàsic de biblioteques de GHC) defineix la signatura d'una funció rnf (inicials de Reduce to Normal Form) per l'avaluació en profunditat. Per crear una instància de NFData per a un tipus algebraic, caldrà una implementació de rnf que apliqui recursivament rnf a les variables d'encaix corresponents als components dels constructors.

-- la funció ''rnf'' inicials de la traducció anglesa de "Reducció a Forma Normal"
class NFData a where
 rnf :: a -> () -- rnf ha d'avaluar el paràmetre en profunditat a Forma Normal

import Control.DeepSeq

data NomDelTipus = Cons1 T1 T2 | Cons2 T3

instance NFData NomDelTipus where
 rnf (Cons1 t1 t2) = (rnf t1) `seq` (rnf t2) `seq` ()
 rnf (Cons2 t3) = (rnf t3) `seq` ()

Automatitzable amb el travessament genèric de les estructures algebraiques.

{-# LANGUAGE DeriveGeneric #-}

import Control.DeepSeq
import Control.DeepSeq.Generics (genericRnf)
import GHC.Generics

data NomDelTipus = Cons1 T1 T2 | Cons2 T3 deriving Generic

instance NFData NomDelTipus where rnf = genericRnf

Avaluació estricta explícita

A part de l'optimització en estrictesa dels compiladors (vegeu article "Haskell és un llenguatge estricte") es pot forçar l'avaluació estricta de les següents maneres:

Aplicació estricta (Crida per valor)

Avaluació del paràmetre abans de la substitució (càlcul lambda). Amb l'operador d'aplicació estricta ($!) com a alternativa de ($) d'avaluació tardana. (seq) avalua el primer operand i retorna el segon. Al Haskell98 (seq) avaluava a HNF però al Haskell2010 avalua a WHNF (posposa la reducció de les lambdes i de les expressions dels constructors).

 f $! x = x `seq` (f x)

Aplicació estricta a Forma Normal

($!!) amb doble signe d'exclamació, avalua l'operand en profunditat (amb deepseq) a Forma Normal, per als casos on l'operand és un tipus que implementa la classe NFData. La generació d'instàncies de NFData per a tipus algebraics es pot fer amb mecanismes de derivació genèrica (amb recorregut genèric dels tipus algebraics).

import Control.DeepSeq

-- ($!!) :: NFData a => (a -> b) -> a -> b -- infixr 0 $!!

f $!! x = x `deepseq` (f x)

Estrictesa als components dels tipus de dades

data T = C T1 !T2 ... -- sense prefix al component => aval. tardana, amb (!) avaluació estricta

Quan en una definició de tipus de dades es prefixa el tipus del component amb '!' l'avaluació de l'aplicació del constructor a una expressió corresponent al component es fa amb ($!) i si no hi ha el prefix '!' es fa amb ($).

Vegeu Eficiència i rendiment en tipus de dades

• La nova extensió de llenguatge StrictData de GHC 8.0 capgira el mode d'avaluació per defecte dels components, prefixant amb el caràcter titlla aquells que volguem d'avaluació tardana. Els newtype no queden afectats.

{-# LANGUAGE StrictData #-} -- des de GHC 8.0
data T = C ~T1 T2 ... -- sense prefix al comp. => aval. estricta, amb (~) avaluació tardana

Estrictesa als paràmetres formals

Avaluació estricta als paràmetres formals amb l'extensió {-# LANGUAGE BangPatterns #-}

{-# LANGUAGE BangPatterns #-}
f !x !y = 2 * x * y -- avalua estrictament (!) els paràmetres actuals (a WHNF)

{-# LANGUAGE Strict #-} -- des de GHC 8.0
f x y = 2 * x * y -- amb Strict avaluació estricta no-irrefutable per defecte, prefix (~) per l'avaluació com abans

Estrictesa als patrons d'encaix

Lligams amb avaluació estricta a les variables dels patrons

let !v = expr ... -- avalua estrictament l'expressió (amb (seq))
let (!x, !y) = (exprX, exprY) -- avalua estrict. les expr. de les variables del patró

• La nova extensió de llenguatge Strict de GHC 8.0 capgira el mode d'avaluació per defecte d'un mòdul a estricte. Per obtenir l'avaluació tardana caldrà prefixar amb el caràcter titlla (~).

foldl': iteracions amb plegat per l'esquerra estricte

l'operació foldl (foldLeft) permet fer "transformacions reiterades sobre una estructura de tipus a amb els valors d'una seqüència [b] ((a -> b -> a)), de manera equivalent als bucles for|forEach de la prog. imperativa tradicional.

 foldl :: (a -> b -> a) -> a -> [b] -> a -- essent ''a'' l'estructura i ''[b]'' la llista de valors a iterar

-- versió tardana, cost O(n) en allotjament d'operacions pendents d'avaluar
foldl op estructInicial (x:xs) = foldl op (op estructInicial x) xs

-- versió estricta, avaluació primerenca
foldl' op estructInicial (x:xs) = let aplega_x = op estructInicial x
 in aplega_x `seq` foldl' op aplega_x xs
-- (seq) avalúa el primer operand i retorna el segon
-- si el tipus de ''aplega_x'' és algebraic (conté constructors (aturen l'avaluació)))

L'ús de tipus algebraics en l'operació, aturant l'avaluació en els constructors, implica la generació d'una pila de thunks (expressions pendents d'avaluar) que poden comportar el sobreiximent de la pila.

Treballar a espai constant de la pila

El llibre RealWorldHaskell ofereix un exemple on l'operació nucli del plegat estricte foldl' plega sobre un parell, és a dir un tipus algebraic com a acumulador (constructor del parell amb les seves expressions). Els constructors en posició de capçalera (vegeu #Head Normal Form) estan en HNF, per tant les expressions dels components no són avaluades. Això fa que s'amuntegui la seva avaluació pendent a la pila.

• o bé s'avalua estrictament els components de l'acumulador compost dins l'operació del plegat

• o bé es pot definir una versió de foldl'/foldr' que avaluï estrictament, però en profunditat a #Forma Normal.

import Control.DeepSeq (NFData, ($!!))
import Data.Foldable

-- de la definició de foldl' i foldr', substituint ($!) per ($!!) de DeepSeq per avaluar a Forma Normal

foldl'' :: (Foldable t, NFData b) => (b -> a -> b) -> b -> t a -> b
foldl'' f z0 xs = foldr f' id xs z0
 where f' x k z = k $!! f z x -- ($!) substituït per ($!!)

foldr'' :: (Foldable t, NFData b) => (a -> b -> b) -> b -> t a -> b
foldr'' f z0 xs = foldl f' id xs z0
 where f' k x z = k $!! f x z -- ($!) substituït per ($!!)

Estrictesa en les crides recursives

Vegeu "Recursivitat final al Haskell".

• La "recursivitat final mòdulo cons" (recursivitat diferida) quan la crida recursiva és el component d'una dada que es retorna, no serà avaluada perquè els constructors de Tipus de dades algebraics aturen l'avaluació HNF.

duplicaLlista :: [a] -> [a]
duplicaLlista [] = []
duplicaLlista (x : xs) = x : duplicaLlista xs -- crida recursiva "mòdulo cons"

• En cas de recursivitat final normal, el compilador optimitza alguns casos per evitar generar una pila d'expressions pendents d'avaluar (thunks) però cal assegurar-se'n. Vegeu "Limitations of strictness analysis".

Avaluació tardana explícita en els patrons d'encaix

Els encaixos de patrons s'avaluen normalment de manera estricta (primerenca).

» pattern matching is usually strict. So trying a pattern match forces evaluation to happen at least far enough to accept or reject the match.

Per avaluar un encaix de manera tardana (lazy) cal prefixar-lo amb el caràcter titlla '~'.

L'avaluació tardana de l'encaix (vegeu exemple tot seguit) converteix l'encaix en irrefutable (no rebutjable, no parcial) evitant l'avaluació d'altres opcions.

L'ús de l'avaluació tardana explícita amb tipus amb més d'un constructor és perillós:

f :: [a] -> [a]
f ~(x:xs) = x:xs
-- és traduït internament a
f ys = head ys : tail ys -- compte! funcions parcials!!
-- l'encaix (f ys), encaix amb variable, sempre té èxit.

-- si, per filtrar el cas [] no definit anteriorment, l'avaluem primer ...
f [] = []
f ~(x:xs) = x:xs -- l'avaluació tardana aquí és estúpida perquè l'encaix
 -- ja ha estat avaluat estrictament pel cas precedent []

-- si haguéssim posat el cas [] després: 
f ~(x:xs) = x:xs
f [] = []
-- el segon encaix (f []) no s'avalua mai, perquè l'anterior és irrefutable!
-- L'ordre és rellevant!!! El compilador ens avisarà del codi inabastable.

Programació de nivell baix

Tipus primitius que es passen per valor (no encapsulats, ang:unboxed)

Vegeu-ho a GHC

Tuples no encapsulades per al retorn de múltiples valors

Vegeu-ho a GHC

Especialització d'operacions sobrecarregades

Vegeu-ho a GHC

Referència ràpida de la biblioteca

A GHC.

Haskell com a llenguatge Script

Execució de Haskell com a Script a Unix (mitjançant una directiva Shebang)., mitjançant l'eina stack:

#!/usr/bin/env stack # directiva "Shebang" amb l'intèrpret seguit de paràmetres per a `stack script`
{- stack script
 --resolver lts-11.22 
 --package shelly -}

{-# LANGUAGE OverloadedStrings #-}

import Shelly (Sh, shelly, echo)

hola :: Sh ()
hola = echo "hola"

main :: IO ()
main = shelly $ hola

També admet mòduls externs posicionats segons la nomenclatura jeràrquica NomCarpeta.NomDeMòdul respecte del programa script.

Eines per les Comprovacions de Qualitat

Proves unitàries

• Biblioteca HUnit (Haskell Unit testing).

• Biblioteca QuickCheck de comprovació de predicats sobre sèries de valors aleatoris amb acotació progressiva del domini del problema, mitjançant la instanciació de classes específiques (Arbitrary).

• Biblioteca HSpec inspirada per la biblioteca de Ruby RSpec.

Verificació formal estàtica

• La biblio. LiquidHaskell facilita la verificació formal estàtica mitjançant anotacions de "tipus refinats amb predicats" (ang: Logically Qualified Data Types) i un comprovador de lògica SMT (de l'anglès "Satisfiability modulo theories") determina si el programa és una solució d'una especificació teòrica formal que s'inclou.

Problemàtiques

L'ús simultani de diferents biblioteques que utilitzin diferents versions d'una mateixa tercera biblioteca comporta:

• El maleït problema de les dependències de biblioteques (ang: cabal dependency hell) (Solució: ús de rebostos Stackage d'imatges de conjunts de versions úniques compatibles de les biblioteques)

Un cop has generat l'executable, el següent maldecap són les petades de les funcions parcials, que criden a error per als valors per als quals no estan definides, (head []), sense cap pista del culpable:

• El problema de la manca d'informació de situació en les petades (Solució: evitar l'ús de crides a error, i oferir el resultat opcional en una mònada d'efecte fallada Maybe/Either, traspassant la responsabilitat a la rutina responsable de la crida amb paràmetres il·legals)

Les crides recursives i els plegats poden generar piles d'expressions pendents d'avaluar, fent petar la pila, si no s'explicita correctament l'avaluació estricta dels acumuladors i dels components de les estructures intermèdies:

• El problema del sobreiximent de la pila (Stack overflow) (Solució: ésser curós en l'estrictesa de l'avaluació quan convingui)

La modificació de l'estat global (preferències) en temps d'execució dona lloc al:

• El problema de les configuracions (Solució: la mònada Reader permet modificar l'entorn localment en l'avaluació d'una acció)

Perquè la imatge en memòria del programa no creixi més del compte cal tenir en compte:

• El problema de les fugues de memòria

Gestor de projectes i empaquetatge de biblioteques i aplicacions

El Haskell utilitza un gestor de projectes per resoldre les dependències d'altres biblioteques i facilitar-ne la compilació on s'instal·len, amb independència del compilador emprat.

Aquest gestor es diu Cabal (Common Architecture for Building Applications and Libraries) i utilitza arxius de descripció de projecte amb l'extensió ".cabal". Vegeu "Com crear un paquet executable o bé biblioteca"

El nom del paquet consta de nom-versió, per ex. shakespeare-css-1.0.1.2, on la versió major són els dos primers components numèrics (un canvi en la versió major indica trencament de compatibilitat amb l'API anterior), la versió menor és el tercer (identifica la API, un canvi significa un augment de l'API sense trencament)), i el quart indica modificacions sense variar l'API.

Els paquets es descarreguen en directoris dins del $HOME/.cabal, els executables de les aplicacions quedaran a $HOME/.cabal/bin que caldrà afegir a la variable d'entorn PATH.

Els paquets ja instal·lats per GHC es gestionen amb el programa ghc-pkg.

Al Linux podem començar treballant amb les biblioteques precompilades en paquets de la distribució de Linux. Si us cal una versió més recent del compilador, caldrà instal·lar-lo prèviament i, en acabat, instal·lar #The Haskell Platform, contràriament al Windows on el paquet #The Haskell Platform l'incorpora.

El rebost oficial de biblioteques i aplicacions és el Hackage

• instal·lació manual: Si no es disposa de l'executable cabal del paquet cabal-install, per instal·lar un paquet cal descarregar-lo, buscar el fitxer Setup.hs o bé Setup.lhs i executar

 runhaskell Setup clean # neteja arxius producte de compilacions anteriors
 runhaskell Setup configure —help # mostra opcions generals i específiques del paquet
 runhaskell Setup configure —user —altres-opcions
 runhaskell Setup build
 [sudo] runhaskell Setup install # ''sudo'' (privilegi d'admin. del sistema) si configures amb —global en comptes de —user
 #, per actualitzar el rebost del sistema

• instal·lació automatitzada d'un paquet del rebost Hackage:

Amb "cabal" descarrega, configura, compila i instal·la d'una sola tacada, després d'instal·lar automàticament els paquets dels quals depèn. Preguntes freqüents aquí.

 # l'ajuda és per comanda
 cabal help install
 # --with-compiler=... permet seleccionar el compilador
 # <versió> = <digit> {'.' <digit>} ['.' '*']
 # <paquet_o_dependència> :== nom | nom-versió | "nom < versió" | "nom == versió"
 cabal install paquet1 paquet2 --opcions

• per llistar els paquets que ja tenim a GHC, "ghc-pkg list". No existeix encara l'equivalent "hugs-pkg"
• en cas de problemes per biblioteques que no compilen bé, és útil limitar-ne la versió amb l'opció—constraint=dependència

# restricció de dependències en compilar
--constraint="nom_biblio < versió" 
# o bé 
--constraint=nom_biblio==versió # (Els 3 primers components de la versió identifiquen l'API)

# exemples (les cometes només fan falta si hi ha espais o bé
# si l'operador de comparació conté símbols '<' '>' de l'intèrpret de comandes per a la redirecció):
cabal install QuickCheck --constraint=BiblioDeLaQualDepen==2.3.4.*

• a partir de cabal-install v.1.16 cabal admet paral·lelisme en la instal·lació (opció -j)

cabal install -j "wx == 0.13.*"

Conflictes de dependències

Tanmateix cal tenir en compte que l'ús simultani de biblioteques que facin servir diferents versions d'un mateix paquet és molt problemàtic. Cal evitar absolutament la comanda cabal upgrade que ens abocaria al problema esmentat.

Entorn aïllat de desenvolupament amb cabal sandbox

cabal amb el verb sandbox crea un dipòsit de biblioteques específic del projecte en el subdirectori amagat ".cabal-sandbox". Una sandbox (capsa de sorra literalment) és un entorn tancat per a proves per evitar que els errors que s'hi produeixin repercuteixin a l'exterior. Aquesta funcionalitat es va desenvolupar al programa cabal-dev que ara ha quedat obsolet.

• els executables queden al directori ./.cabal-sandbox/bin que caldrà afegir a la var. d'entorn d'executables PATH.
• s'hi poden associar subprojectes amb la comanda

cabal sandbox add-sources camí/al/subprojecte

Per a més info. consulteu cabal sandbox --help.

• Aquesta funcionalitat ha quedat superada pel meta-gestor stack que allotja les dependències locals (definides al projecte.cabal) en una capsa-de proves "./.stack-work" i les globals en subcarpetes d'usuari "~./stack" per versions, evitant recompilar-les per cada projecte.

El rebost Stackage - rebost alternatiu amb dependències verificades

Stackage proporciona imatges de conjunts de biblioteques amb compatibilitat verificada de versions, entre elles i una versió específica de GHC, amb noves imatges dels rebostos a mesura que sorgeixen noves versions de dependències o del compilador.

Vegeu Compilador Haskell de Glasgow#Stackage - rebost alternatiu amb dependències verificades

Creació del fitxer de projecte .cabal

cabal init

interroga l'usuari a la cònsola de comandes i genera un esquelet de projecte que caldrà editar posteriorment per afegir-hi els noms dels fonts i els paquets dels quals depèn. Caldrà afegir-hi manualment la llista de mòduls exportats si és una biblioteca (secció exposed-modules), dels mòduls no exportats (secció other-modules) i de les dependències (secció build-depends).

• superat pel sistema de plantilles de stack: stack new projecte plantilla

leksah

Entorn gràfic d'usuari (IDE) que conté un formulari d'edició del fitxer de projecte.

Un cop creat, la comanda cabal sense nom de paquet treballa sobre el fitxer de projecte del directori de treball:

cabal sandbox init # genera un rebost de biblioteques específic del projecte
 # els executables quedaran a la carpeta ".cabal-sandbox/bin"
cabal sandbox add-sources camí/al/subprojecte # afegir subprojecte
cabal sandbox delete # elimina el rebost específic

cabal clean # neteja tots els fitxers generats per la compilació
cabal configure # estableix opcions i comprova compatibilitat de les dependències
cabal build # compila
cabal install # configura, compila, relliga i instal·la
cabal freeze # fixa les versions de les dependències com a restricció
 # al fitxer "cabal.config" de restriccions a la carpeta del projecte
cabal repl # engega l'intèrpret 'ghci' havent carregat mòduls i opcions esmentades al fitxer de projecte

Vegeu també "Com escriure (i empaquetar) un programa en Haskell". També "Actualitzant un paquet a noves versions de GHC i biblioteques".

Gestió dels paquets instal·lats

Amb ghc-pkg comprova paquets instal·lats a les BDD de paquets de l'usuari i del sistema.

$ ghc-pkg list 

$ ghc-pkg check # comprova dependències trencades per la reinstal·lació d'aquestes

En un entorn de desenvolupament aïllat en capsa-de-proves (sandbox):

cabal sandbox hc-pkg ...

Instal·lació des del GitHub

L'aplicació cabalg descarrega (amb git-clone a subcarpeta) i instal·la (amb cabal).

cabalg https://github.com/usuari/projecte-github # descarrega a subcarpeta de nom "projecte-github"

Stack - Meta-gestor de projectes

L'aplicació Stack sobreposa la seva operativa a la del gestor cabal millorant-la en diversos aspectes:

• proporciona plantilles per a diversos tipus d'aplicacions
• utilitza els rebostos Stackage de dependències de compilació verificada amb versions específiques de GHC
• cerca automàticament el rebost Stackage més recent que contingui les dependències (biblioteques) esmentades al fitxer .cabal del projecte
• descarrega la versió de GHC corresponent al rebost, si encara no ho ha fet
• millora el rendiment del desenvolupament aïllat en "Sandbox" (Capsa de proves): la Sandbox (a la carpeta ./.stack-work) només guarda les biblioteques definides localment, al fitxer de projecte .cabal, mentre que les dependències es compilen un sol cop per a diversos projectes, guardant dins la carpeta d'usuari (~/.stack) les compilacions de dependències requerides segons la versió d'origen del rebost.

stack templates # llista les plantilles de fonts per a nous projectes
stack new projecte <template> # genera un projecte nou (amb fonts i projecte.cabal) partint d'una plantilla
#
cd projecte
stack setup # cerca la versió de Stackage que contingui les dependències del projecte, i descarrega el compilador GHC corresponent.
stack build # compila i instal·la -- les dependències a (~/.stack), i els paquets locals del projecte a (./.stack-work)
# l'executable queda a .stack-work/install/<arquitectura>-<sist_op>/<versió_de_stackage>/<versió_de_ghc>/bin
stack exec projecte # nom de l'executable al fitxer de projecte .cabal (pot variar amb sufixos o extensions)

• les dependències (biblioteques) que no siguin al rebost stackage però sí al hackage cal esmentar-les a l'apartat extra-deps de stack.yaml.
• les dependències personalitzades per al projecte, cal allotjar-les en un subdirectori del projecte, esmentar-les a l'apartat packages de stack.yaml i instal·lar-les mitjançant el subdirectori.

stack install local-pkgs/el-meu-paquet-personalitzat/

Política de versions

Vegeu ref.

Els paquets s'identifiquen amb un número de versió amb dígits separats per un punt, amb un mínim de tres components A.B.C on A.B s'anomena versió major i C la versió menor.

• Cal incrementar el nombre de versió major A.B en cas de modificació de l'API quan:

• l'actualització elimina alguna entitat
• o bé s'han modificat tipus, entitats, definicions d'estructures (data), o classes
• o bé s'han afegit instàncies òrfenes (les que no acompanyen les definicions ni de la classe ni del tipus)
• o bé s'han eliminat instàncies de classes

• Cal incrementar la versió menor C en cas d'increment de l'API quan:

• s'afegeixen noves definicions, tipus, classes, instàncies no òrfenes i mòduls.

Eines relacionades amb el gestor de projectes

cabal-progdeps

llista les dependències en un directori de projecte

yackage

servidor de rebost "hackage" local per a desenvolupament

The Haskell Platform

The Haskell Platform vol ser un instal·lador empaquetant el compilador GHC (només a Windows, a Unix i derivats cal descarregar-lo prèviament), una biblioteca i un paquet d'eines incorporant paquets de rutines del rebost Hackage. amb encaix verificat respecte a la versió de la biblioteca Base inclosa. (Preguntes freqüents)

Backpack - Abstracció de biblioteques

Backpack (cat: Motxilla) permet substituir una dependència directa d'un paquet en una funció, tipus o paquet per una o més signatures. El desenvolupador adjunta un mòdul d'interfície abstracta de requeriments (clàusula Signature) i l'usuari decideix el paquet d'implementació que hi relligarà.

Backpack evita haver de mantenir diverses versions d'una mateixa biblioteca que facin servir tipus definits externament lleugerament diferents però amb la mateixa interfície (per exemple diferents tipus de cadenes: Data.ByteString.Lazy i Data.ByteString.Strict o també diferents implementacions d'un servei) i haver de relligar-les totes si se'n vol disposar.

Per evitar les múltiples versions del codi, Backpack emula els mòduls paramètrics functors de ML Estàndard, però amb l'estil de mix-in imitant el sistema de mòduls de MixML.

Caldrà que el codi client faci referència al tipus definit abstracte en un mòdul d'interfície (nova clàusula Signature) que descriurà la funcionalitat requerida, i que empaquetarem en un paquet functor.

Després, podrem fer-ne ús directament o també, generar paquets instàncies del functor, i donar nom específic als aparellaments de mòdul client de la signatura amb el mòdul que la implementa (clàusula "mixins" de Cabal, o bé clàusula "dependency" en el nou format .bkp).

Backpack requereix GHC >=8.2 i Cabal >=2.0.

Per a l'ús de Backpack amb el format tradicional de paquets i en paquets multi-biblioteca vegeu la ref. L'extensió dels fitxers de Signatura haurà de ser ".hsig"

Mentre Stack no suporti Backpack, es pot fer servir de moment mitjançant les "capses de prova Sandbox" cabal sandbox, fins i tot amb rebostos Stackage especificant el rebost desitjat ("remote-repo") en un fitxer de configuració local "cabal.config"

La versió de GHC per a la Màquina virtual Java anomenada "Eta" també suporta Backpack.

nou format

GHC suporta un format nou amb extensió (.bkp) de codi font amb múltiples clàusules unit com a unitat de compilació equivalent a biblioteques, que engloba diversos mòduls habituals d'implementació i mòduls d'interfície per la clàusula signature. Vegeu exemple.

{-| fitxer hello.bkp -}
unit main where -- unitat de compilació
 module Main where
 main = putStrLn "Hello world!"

# per compilar (GHC >= 8.1.20161007)
 ghc --backpack hello.bkp
# genera subcarpeta de compilats amb el nom de la unitat de compilació
# executable a ./<unit>/Main

exemple de paquet functor (en el sentit de ML_Estàndard)

Mòdul abstracte funció d'una signatura adjunta (motxilla). Permet definir mòduls concrets (al fitxer de projecte) per l'aplicació del mòdul functor a un mòdul que implementi la signatura, aportat per un altre paquet.

-- paquet functor
unit regex-indef where -- unitat de compilació 

 signature Str where -- interfície "motxilla" abstracta de requeriments 
 -- que haurà d'implementar un mòdul d'un paquet extern,
 data Str
 instance Eq Str
 null :: Str -> Bool
 singleton :: Char -> Str
 splits :: Str -> [(Str, Str)]
 parts :: Str -> [[Str]]

 module Regex where -- mòdul client
 import Str -- importa l'espai de noms de la interfície "motxilla"
 ...

Entorns de desenvolupament i altres eines

hlint

Aquí analitzador de codi amb suggeriments de millora. Avisa de construccions redundants i proposa alternatives al codi.

Leksah

Aquí. Entorn gràfic de desenvolupament (IDE) basat en GTK, útil per estudiar un paquet. Genera fitxers de projecte en format .cabal. Permet obtenir info. a partir del menú de context, dels elements que marqueu d'un programa. Instruccions d'instal·lació aquí Permet la depuració de programes (Truc: cal definir-hi un Workspace i un Package perquè s'activi la depuració).

eclipseFP

Aquí. Endollable per a l'entorn de desenvolupament (IDE) Eclipse

Visual Haskell 2005

Entorn de Microsoft Visual Studio per al Haskell. Hi va haver un desenvolupament per al Visual Studio 2005 inacabat segons les fonts. Malgrat que el compilador GHC el desenvolupa Microsoft Research a Cambridge (Regne Unit), no hi ha eines de suport específiques del Microsoft Windows.

ThreadScope

Analitzador de paral·lelisme al GHC. Vegeu GHC#Eines.

hpc (haskell program coverage)

Anàlisi de cobertura del codi. Genera traces d'execució i, després de diverses execucions, permet mostrar en un informe html, amb marcatge de colors, quines parts del codi no s'han executat mai i quines expressions booleanes són sempre certes o sempre falses. Vegeu GHC#Eines.

hp2any

perfil d'ús de memòria en temps real i diferit. Vegeu GHC#Eines.

hgettext

eina que permet extreure cadenes de text del codi font per preparar la internacionalització amb traduccions múltiples.

Implementacions

Vegeu

GHC ("Glasgow Haskell Compilation System")

Compilador i intèrpret (GHCi) que va més enllà del Haskell98.

Incorpora "concurrència","paral·lelisme","Memoria Transaccional per Software" i opcions d'optimització. Pot generar codi nadiu, codi C, o codi optimitzat mitjançant LLVM.

A partir de la versió 6.10 incorpora "Data Parallel Haskell" per al tractament paral·lel de vectors.

L'intèrpret ghci genera codi intermedi i admet l'execució mixta de codi intermedi i codi nadiu.

Hugs

Intèrpret. Implementació quasi completa del Haskell 98. Incorpora registres extensibles anomenats TRex.

nhc98

Compilador per a màquines de 32 bits. Intèrpret "Hi". Muntador "Hmake".

UHC / EHC

Utrecht Haskell Compiler / Essential Haskell Compiler amb rerefons de compilació per a llenguatge C, Java, LLVM i CLR.

YHC

York Haskell Compiler amb rerefons de compilació a Javascript i traçador de crides Hat

JHC

Jhc Haskell Compiler Compilador de John Meacham.

LHC

LHC Haskell Compiler Projecte derivat del JHC.

Extensions de noms de fitxer

Vegeu enllaç

.hs

Haskell source

.lhs (Literate haskell source)

font documentat segons Programació literària immergint el codi dins la documentació:

• o bé dins un doc. de text, prefixant les línies de codi amb '>' (anomenat estil rastre d'ocell assimilant la forma '>' a les petjades d'un ocell)
• o bé dins un doc. LaTeX situant el codi entre \begin{code} i \end{code} Vegeu http://people.cs.uu.nl/andres/lhs2tex/ Arxivat 2010-03-15 a Wayback Machine.

.cabal

descripció de paquet Cabal

.x

doc. de lèxic, entrada per al generador d'analitzadors de lèxic Alex (de l'estil del lex al Unix) (genera *.hs)

.lx

doc. de lèxic Alex literari (a l'estil del .lhs)

.y

doc. de gramàtica, per al generador d'analitzadors gramaticals Happy (de l'estil del yacc al Unix) (genera *.hs)

.ly

doc. de gramàtica Happy literari (a l'estil del .lhs)

.gc

doc. d'entrada al GreenCard (descripció enllaç amb codi C) adaptat al FFI (Foreign Function Interface) normatiu per a Haskell2010

.chs

doc. d'entrada al convertidor c2hs

.hsc

doc. d'entrada al convertidor hsc2hs

Plataformes, aspectes

plataformes virtuals

sobre Xen

• HaLVM (The Haskell Lightweight Virtual Machine): GHC runtime sobre l'hipervisor Xen.

rerefons de compilació

via LLVM (Low Level Virtual Machine)

• GHC pot compilar via LLVM per aprofitar-ne les optimitzacions específiques per arquitectura del processador. Comproveu-hi les "Plataformes suportades"

amb sortida JVM

• Eta (eta-lang.org): rerefons JVM per a GHC amb ampliació de sintaxi per la definició de la interfície d'importació/exportació a Java

• vegeu "Haskell on Android using Eta".

• UHC Jazy: Rerefons JVM per al compilador UHC. (implementació parcial).

amb sortida JavaScript

• Haste: modificació de GHC amb rerefons JavaScript.
• GhcJs: modificació de GHC amb rerefons JavaScript.
• Yrc2Js: Rerefons a Javascript del compilador YHC (Compilador Haskell de York).
• UHC: Rerefons (en desenvolupament) de l'"Utrecht Haskell Compiler"
• Elm: llenguatge per a interfícies Web d'arquitectura MVC amb sintaxi quasi Haskell, que compila a Javascript, per a la composició d'interfícies gràfiques sobre navegadors web.
• PureScript: llenguatge quasi Haskell d'avaluació estricta amb sortida JavaScript.

amb sortida CLR

• Rerefons CLR del compilador UHC

Altres plataformes

A sistemes d'Apple (Mac OS, iOS)

• Building a GHC cross-compiler for Apple iOS targets Compilador creuat de GHC per a l'IOS.
• IPhone al HaskellWiki (anglès) Recursos i suport per treballar amb Haskell a l'IPhone.
• Haskell al Mac (anglès)
• Haskell en un projecte Cocoa-Xcode (anglès)
• http://hoc.sourceforge.net/examples.html Arxivat 2012-04-22 a Wayback Machine. (anglès)

Dialectes del Haskell

DDC (The Disciplined Disciple Compiler)

(cat: El Compilador del Deixeble Disciplinat): versió d'avaluació estricta, contràriament a Haskell (en desenvolupament).

OOHaskell

biblioteca d'orientació a objectes d'Oleg Kyseliov i Ralf Lämmel (versió del 2005 no actualitzada).

O'Haskell

versió orientada a objectes de Johan Nordlander. Treball del 2001 evolucionat a Timber

Timber

evolució de O'Haskell, per a la programació reactiva de sistemes encastats. (del mateix autor Johan Nordlander). Limitacions i problemàtiques

Hume

llenguatge funcional estricte (avaluació primerenca) per a sistemes encastats de recursos limitats, amb concurrència per pas de missatges i característiques CSP on la sintaxi del nivell d'expressions és la del Haskell.

Incorpora limitació de costos de recursos per procés, en temps, memòria dinàmica i mida de la pila amb les corresponents excepcions.

CAL

aproximació a Haskell sobre la JVM integrat dins Open Quark de Business Objects, companyia francesa absorbida pel gegant alemany del programari SAP AG

Jaskell

llenguatge sobre la Màquina virtual Java, funcional i d'avaluació tardana, força diferent en sintaxi.

Frege

llenguatge quasi Haskell d'avaluació tardana sobre la JVM, amb particularitats del Java (literals Java, mètodes als tipus de dades, ...) sobre Java-7

Eta

eta-lang.org Compilador de Haskell estàndard (GHC) ampliat amb elements d'orientació a objectes, sortida a JVM i interoperativitat FFI amb Java.

Elm

llenguatge quasi Haskell estricte (avaluació primerenca), d'arquitectura MVC per generar interfícies gràfiques a la web, compilant a JavaScript (no admet definició de signatures de tipus, excepte algunes de predefinides anomenades categories).

Idris

llenguatge estricte (avaluació primerenca) amb sintaxi quasi haskell amb tipus dependents de valors i tipus com a objectes de primer ordre. Incorpora mecanismes de certificació estàtica, com els llenguatges anomenats "comprovadors de teoremes" per ex.: Coq i Agda.

PureScript

llenguatge quasi Haskell estricte (avaluació primerenca) per compilar a JavaScript en mòduls de Node.js, amb tipus bàsics Javascript, i construccions esbiaixades cap al JavaScript, per exemple les claus rectangulars no indiquen llista sinó el tipus Array.

DAML

daml.com llenguatge per l'especificació de contractes, basat en una modificació de GHC.

Exemples

Vegeu Característiques del llenguatge Haskell#Exemples

Vegeu també

• Haskell concurrent
• Mònada (programació funcional)
• Fletxa (programació funcional)
• Compilador Haskell de Glasgow
• Intèrpret Hugs

Enllaços externs

• Haskell - Lloc web oficial
• http://dir.gmane.org/gmane.comp.lang.haskell Arxivat 2016-10-14 a Wayback Machine. (anglès)
• Haskellers.com (anglès) Punt de trobada de programadors en Haskell.
• Univ. de Girona -- Programació funcional - Haskell