# Haskell

* Per a altres significats, vegeu «Haskell (desambiguació)».
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.
   * 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).
Els literals no tenen tipus associat sinó que poden pertànyer a aquells tipus que implementin una determinada classe:
La sobrecàrrega de literals fa possible incorporar-los a diferents estructures:
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.
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).
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

   * 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.
   * 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:
   * 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.
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
Amb el meta-gestor stack:
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.
Avaluador en-línia, a l'intèrpret d'expressions funcionals tryhaskell.org.

## 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:
* Hoogle5 permet alternatives de rebost (biblio estàndard, plataforma Haskell, el rebost Stackage) i cercar també en paquets específics, o bé per autor.

## 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.
Cal tenir en compte que
* 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
* 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.
Una expressió beta reduïble està en posició de capçalera si és de la forma (en notació Haskell)
La seva reducció seria

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

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

#### Head Normal Form

Una expressió lambda està en "forma normal en capçalera" (HNF) si
* 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).
* 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.
Automatitzable amb el travessament genèric de les estructures algebraiques.

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

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

#### Estrictesa als components dels tipus de dades

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.

#### Estrictesa als paràmetres formals

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

#### Estrictesa als patrons d'encaix

Lligams amb avaluació estricta a les variables dels patrons
* 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.
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.

#### 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.
* 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:

## 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:
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
* 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í.
* 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
* a partir de cabal-install v.1.16 cabal admet paral·lelisme en la instal·lació (opció -j)

### 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:
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.
En un entorn de desenvolupament aïllat en capsa-de-proves (sandbox):

### Instal·lació des del GitHub

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

### 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.
* 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.

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

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

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

## Referències

* ↑ Marlow, Simon. «Announcing Haskell 2010», 24-11-2009. [Consulta: 12 març 2011].
* 1 2 3 4 5 6 7 8 9 10 11 12 13 Peyton Jones 2003, p. xi
* ↑ Norell, Ulf. «Dependently Typed Programming in Agda». Gothenburg: Chalmers University, 2008. [Consulta: 9 febrer 2012].
* ↑ Hudak et al., 2007, p. 12-38,43.
* ↑ Stroustrup, Bjarne; Sutton, Andrew. Design of Concept Libraries for C++, 2011. «Còpia arxivada». Arxivat de l'original el 2012-02-10. [Consulta: 13 novembre 2015].
* 1 2 3 4 5 6 7 8 9 10 Hudak et al., 2007, p. 12-45–46.
* 1 2 Meijer, Erik «Confessions of a Used Programming Language Salesman: Getting the Masses Hooked on Haskell». OOPSLA 2007.
* ↑ Meijer, Erik. «C9 Lectures: Dr. Erik Meijer – Functional Programming Fundamentals, Chapter 1 of 13». Channel 9. Microsoft, 01-10-2009. Arxivat de l'original el 16 de juny 2012. [Consulta: 9 febrer 2012].
* ↑ Drobi, Sadek «Erik Meijer on LINQ». InfoQ. C4Media Inc. [QCon SF 2008], 04-03-2009 [Consulta: 9 febrer 2012].
* ↑ Hickey, Rich. «Clojure Bookshelf». Listmania!. Amazon.com. [Consulta: 9 febrer 2012].
* ↑ Heller, Martin «Turn up your nose at Dart and smell the CoffeeScript». JavaWorld. InfoWorld, 18-10-2011 [Consulta: 9 febrer 2012]. Arxivat 10 de febrer 2012 a Wayback Machine. «Còpia arxivada». Arxivat de l'original el 2012-02-10. [Consulta: 13 novembre 2015].
* ↑ «Declarative programming in Escher». [Consulta: 7 octubre 2015].
* ↑ Syme, Don; Granicz, Adam; Cisternino, Antonio. Expert F#. Apress, 2007, p. 2. «F# also draws from Haskell particularly with regard to two advanced language features called sequence expressions and workflows.»
* ↑ Wechsung, Ingo. «The Frege Programming Language». [Consulta: 26 febrer 2014].
* ↑ http://www.wired.com/2014/03/facebook-hack/
* ↑ «Idris, a dependently typed language». [Consulta: 26 octubre 2014].
* ↑ «LiveScript Inspiration». [Consulta: 4 febrer 2014].
* ↑ «Glossary of Terms and Jargon». Perl Foundation Perl 6 Wiki. The Perl Foundation, 28 February. Arxivat de l'original el 21 de gener 2012. [Consulta: 9 febrer 2012].
* ↑ Kuchling, A. M. «Functional Programming HOWTO». Python v2.7.2 documentation. Python Software Foundation. [Consulta: 9 febrer 2012].
* ↑ Fogus, Michael. «MartinOdersky take(5) toList». Send More Paramedics, 06-08-2010. [Consulta: 9 febrer 2012].
* ↑ Lattner, Chris. «Chris Lattner's Homepage». Chris Lattner, 03-06-2014. [Consulta: 3 juny 2014]. «The Swift language is the product of tireless effort from a team of language experts, documentation gurus, compiler optimization ninjas, and an incredibly important internal dogfooding group who provided feedback to help refine and battle-test ideas. Of course, it also greatly benefited from the experiences hard-won by many other languages in the field, drawing ideas from Objective-C, Rust, Haskell, Ruby, Python, C#, CLU, and far too many others to list.»
* ↑ «Timber/History». [Consulta: 7 octubre 2015].
* ↑ HaskellWiki - Polimorfisme(anglès)
* ↑ GHC Users guide - GeneralizedNewtypeDeriving Arxivat 2018-08-21 a Wayback Machine.(anglès)
* ↑ La classe Foldable(anglès)
* ↑ Erik Meijer et al. - Functional programming with Bananas, Lenses, Envelopes and Barbed Wire(anglès)
* ↑ La classe Traversable(anglès)
* ↑ La mònada Reader(anglès)
* ↑ La mònada Writer(anglès)
* ↑ La mònada State(anglès)
* ↑ Monad transformers(anglès)
* ↑ [Parallel Haskell: Projecte de dos anys per promocionar-ne l'ús en el món real](anglès)
* ↑ Haskell - Concurrència i paral·lelisme(anglès)
* ↑ Haskell98 Online Report(anglès)
* ↑ GHC - Notes de l'edició(anglès) GHC 7.0+ pren per defecte l'estàndard de llenguatge Haskell2010
* ↑ Haskell prima - Propostes per a l'evolució del llenguatge Arxivat 2016-02-20 a Wayback Machine. (anglès)
* ↑ Extensions del Haskell i compiladors que les implementen Arxivat 2019-12-21 a Wayback Machine.(anglès)
* ↑ Haskell2010 Online Report(anglès)
* 1 2 Anunciant Haskell 2010(anglès) Acord final sobre Haskell 2010
* ↑ Característiques del Haskell 2010 Arxivat 2009-11-30 a Wayback Machine. (anglès)
* ↑ Anunci del nou procés Haskell Prima, i del Haskell 2010 (anglès)
* ↑ Propostes per a Haskell 201x Arxivat 2018-01-25 a Wayback Machine.(anglès)
* ↑ Haskell wiki - Depuració(anglès)
* ↑ HaskellWiki - Stack Overflow(anglès)
* ↑ Simon Marlow - Why can't I get a Stack trace(anglès)
* ↑ El paquet safe(anglès)
* ↑ Extensible Records(anglès)
* ↑ «Extensió TRex de l'intèrpret Hugs». Arxivat de l'original el 2012-03-20. [Consulta: 12 març 2012].
* ↑ Well-typed - Polymorphism over record fields(anglès)
* ↑ OverloadedRecordFields(anglès)
* ↑ Implement HasField constraint solving and modify OverloadedLabels Arxivat 2018-01-25 a Wayback Machine.(anglès)
* 1 2 Obtenir el compilador GHC
* ↑ Haskell Stack(anglès)
* ↑ Linux - alternatives Arxivat 2015-10-07 a Wayback Machine.(anglès)
* ↑ GAlternatives - GUI per al selector d'alternatives a Linux(anglès)
* ↑ Comanda runghc (anglès)
* ↑ GHCi - guia d'usuari de l'intèrpret(anglès)
* ↑ GHCi - Declaracions de tipus i classes a l'intèrpret
* ↑ Hackage - Hayoo(anglès)
* ↑ Haskell wiki - Hoogle
* 1 2 3 Univ. de Girona - Introducció a la prog. funcional
* ↑ FOLDOC - Head Normal Form Arxivat 2016-03-03 a Wayback Machine.(anglès)
* 1 2 3 4 FOLDOC - Weak Head Normal Form Arxivat 2016-03-03 a Wayback Machine.(anglès)
* 1 2 HaskellWiki - Weak Head Normal Form
* ↑ El paquet deepseq(anglès)
* ↑ el mòdul Control.DeepSeq.Generics(anglès)
* ↑ «Haskell is a strict language». Arxivat de l'original el 2009-10-19. [Consulta: 24 octubre 2009].
* ↑ Haskell98 seq avalua a Head Normal Form(anglès)
* ↑ Haskell2010 seq avalua a Weak Head Normal Form(anglès)
* ↑ H2010 Language report - Strictness Flags(anglès)
* ↑ Eficiència i rendiment en tipus de dades (anglès)
* 1 2 BangPatterns - Avaluació estricta dels paràmetres Arxivat 2010-01-30 a Wayback Machine. (anglès)
* 1 2 GHC - Strict i StrictData(anglès)
* ↑ RealWorldHaskell - Optimitzacions - Strictness and Tail recursion(anglès)
* ↑ Haskellwiki - Tail recursion
* ↑ HaskellWiki - Thunk(anglès)
* ↑ Limitations of strictness analysis (anglès)
* ↑ Haskell.org - Lazy vs. Non-strict (anglès) Avaluació tardana i avaluació no-estricta
* ↑ Lazy pattern match(anglès)
* ↑ Lazy pattern match - Implications(anglès)
* ↑ Bash Shebang
* ↑ How to Script with Stack
* ↑ Haskell Wiki - Guia d'usuari de HUnit(anglès)
* ↑ paquet HUnit(anglès)
* ↑ Haskell Wiki - Introducció al QuickCheck(anglès)
* ↑ biblio. QuickCheck(anglès)
* ↑ Hspec: a testing framework for Haskell(anglès)
* ↑ Solving the diamond dependency problem(anglès) Solucionant el problema de la dependència en diamant
* ↑ HaskellWiki Cabal(anglès)
* ↑ Cabal User Guide(anglès)
* ↑ Repeat after me: "Cabal is not a Package Manager"(anglès)
* ↑ «Com crear un paquet Cabal». Arxivat de l'original el 2009-04-17. [Consulta: 1r juliol 2010].
* ↑ Cabal - Com instal·lar un paquet Cabal (anglès)
* ↑ Package versioning policy(anglès) Política de versionament dels paquets
* 1 2 Hackage - Rebost oficial d'aplicacions i biblioteques empaquetades amb Cabal Arxivat 2012-09-18 a Wayback Machine. (anglès)
* ↑ Cabal - Preguntes freqüents(anglès)
* ↑ Afegint paquets a una instal·lació Hugs Arxivat 2009-05-12 a Wayback Machine. (anglès)
* 1 2 Cabal FAQ - Conflictes de dependències(anglès)
* ↑ An introduction to cabal sandboxes Arxivat 2014-09-25 a Wayback Machine.(anglès)
* ↑ cabal-dev (anglès)
* ↑ HaskellWiki - Stackage(anglès)
* ↑ Com escriure (i empaquetar) un programa en Haskell(anglès)
* ↑ Actualitzant paquets a noves versions de GHC i biblioteques(anglès)
* ↑ HaskellWiki - ghc-pkg(anglès)
* ↑ Hackage - cabalg(anglès)
* ↑ [haskellstack.org/ The Haskell Tool Stack](anglès)
* ↑ How to play with Stack
* ↑ How to script with Stack
* ↑ How to build with Stack
* ↑ Stackage - rebostos de paquets amb compilació verificada respecte a una versió de GHC(anglès)
* ↑ Haskell wiki - Package versioning policy (anglès)
* ↑ cabal-progdeps (anglès)
* ↑ yackage (anglès)
* ↑ Docum de la Haskell Platform Arxivat 2013-01-26 a Wayback Machine.(anglès)
* ↑ Biblioteca Base de GHC - vegeu mòduls marcats Base(anglès)
* ↑ The Haskell Platform FAQ (anglès)
* ↑ E.Z. Yang - BackPack(anglès)
* ↑ HaskellWiki - Backpack(anglès)
* ↑ GHC wiki - Backpack(anglès)
* 1 2 A taste of Cabalized Backpack(anglès)
* ↑ Backpack: Retrofitting Haskell with Interfaces(anglès)
* ↑ MixML(anglès)
* 1 2 3 4 E. Z. Yang - Try Backpack(anglès)
* ↑ Try Backpack: Cabal packages
* ↑ Announcing Eta v0.8.6
* ↑ Paquet hlint que genera el programa del mateix nom(anglès)
* ↑ Leksah - Entorn gràfic de desenvolupament (IDE) per a Haskell Arxivat 2012-05-13 a Wayback Machine. (anglès)
* ↑ Instal·lació de l'entorn de desenvolupament Leksah(anglès)
* ↑ Endollable per a l'entorn de desenvolupament Eclipse (anglès)
* ↑ Fòrum StackOverflow - Visual Haskell(anglès)
* ↑ HaskellWiki - Internacionalització dels programes en Haskell(anglès)
* ↑ Implementacions de Haskell (anglès)
* ↑ Compilador GHC "Compilador Haskell de Glasgow" (anglès)
* ↑ Intèrpret del Glorious Compilador Haskell de Glasgow (anglès)
* ↑ Concurrència con Haskell(castellà)
* ↑ Glasgow Parallel Haskell(anglès)
* ↑ Un Tast de Haskell - Memoria Transaccional per Software (anglès)
* ↑ Haskell Wiki - Memoria Transaccional per Software(anglès)
* ↑ Rerefons del GHC (anglès)
* ↑ HaskellWiki - Data Parallel Haskell(anglès)
* ↑ Nested Data Parallellism in Haskell(anglès)
* ↑ Hugs intèrpret de Haskell (anglès)
* ↑ Registres extensibles TRex de l'intèrpret Hugs Arxivat 2009-10-30 a Wayback Machine. (anglès)
* ↑ Compilador nhc98 (anglès)
* ↑ Utrecht Haskell Compiler Arxivat 2012-05-03 a Wayback Machine. (anglès)
* ↑ UHC/EHC rerefons de compilació (anglès)
* ↑ York Haskell Compiler(anglès)
* ↑ Generació de codi Javascript des d'YHC(anglès)
* ↑ Traçador de crides Hat Arxivat 2007-05-16 a Wayback Machine.(anglès)
* ↑ Jhc Haskell Compiler (anglès)
* ↑ Web de John Meacham creador del compilador JHC(anglès)
* ↑ LHC Haskell Compiler(anglès)
* ↑ Preprocessadors de Haskell Arxivat 2010-07-06 a Wayback Machine.(anglès)
* ↑ wiki de HaLVM: The Haskell Lightweight Virtual Machine Arxivat 2010-12-08 a Wayback Machine.(anglès)
* ↑ Run Haskell on Xen - No Operating System Required! Arxivat 2010-12-04 a Wayback Machine.(anglès)
* ↑ «Adam Wick - The Haskell Lightweight VM». Arxivat de l'original el 2023-09-25. [Consulta: 9 març 2012].
* ↑ The Compilador Haskell de Glasgow and LLVM(anglès)
* ↑ Rerefons LLVM de GHC(anglès)
* ↑ Brian McKenna - Haskell on Android using Eta
* ↑ UHC Jazy - rerefons a la màq. virtual Java Arxivat 2013-01-04 a Wayback Machine.(anglès)
* ↑ El compilador Haste (anglès)
* ↑ El compilador GhcJs (anglès)
* ↑ YHC/Javascript (anglès)
* ↑ Rerefons Javascript del compilador UHC(anglès)
* 1 2 PureScript.org(anglès)
* ↑ rerefons CLR a UHC Arxivat 2012-04-29 a Wayback Machine.(anglès)
* ↑ Running Haskell on the CLR(anglès)
* ↑ El Compilador del Deixeble Disciplinat DDC(anglès)
* ↑ Llenguatge OOHaskell Arxivat 2010-03-29 a Wayback Machine.(anglès)
* ↑ Llenguatge O'Haskell(anglès)
* ↑ Llenguatge Timber(anglès)
* ↑ Timber - Limitacions i problemàtiques(anglès)
* ↑ Open Quark(anglès)
* ↑ OpenQuark (llenguatge CAL sobre JVM) Arxivat 2011-09-02 a Wayback Machine.(anglès)
* ↑ Jaskell Arxivat 2006-02-20 a Wayback Machine.(anglès)
* ↑ El llenguatge Frege al GitHub

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