Compilador_Haskell_de_Glasgow

Compilador Haskell de Glasgow

Tipus	compilador, programari lliure, programari de codi obert, programari lliure i de codi obert i compilador optimitzador
Versió inicial	1989
Versió estable	9.8.1 (9 octubre 2023)
Llicència	llicència BSD de 3 clàusules
Part de	Haskell Platform (en)
Característiques tècniques
Sistema operatiu	Linux, FreeBSD, NetBSD, OpenBSD, Solaris, macOS, Microsoft Windows i DragonFly BSD
Escrit en	C i Haskell
Equip
Desenvolupador(s)	Universitat de Glasgow
Fonts de codi  Codi font Codi font Debian ghc Arch Linux ghc Ubuntu ghc Gentoo dev-lang/ghc Fedora ghc
Més informació
Lloc web	haskell.org… (anglès)
Free Software Directory	Ghc

ghc, ordre d'ordinador que respon a la sigla de "Glasgow Haskell Compiler", en català Compilador Haskell de Glasgow, és un compilador nadiu de codi lliure per al llenguatge de programació funcional Haskell, el qual va ser originalment desenvolupat a la universitat de Glasgow per Simon Peyton Jones i Simon Marlow. El desenvolupament continua actualment sota l'auspici del Departament d'Investigació de Microsoft (Microsoft Research), al Regne unit on treballa Peyton Jones. GHC ha pres humorísticament el sobrenom "Glorious Haskell Compiler".

El nom ghc segueix el costum antic d'anomenar les ordres amb un identificador curt d'una a tres lletres, on la 'c' designa compilador, la 'h' designa el llenguatge i la primera lletra, la ciutat de la universitat que el desenvolupà originàriament (com també ho fa mmc: "Compilador Mercury de Melbourne",^[1] o bé yhc:"Compilador Haskell de York"^[2] o bé uhc:"Compilador Haskell d'Utrecht").^[3]

El compilador també està escrit en Haskell (una tècnica coneguda com a bootstrapping), però el nucli de sistema per a Haskell està escrit en C i una adaptació del C--^[4][5] (versió de C, no per a l'ús humà sinó específica per a sortida de compiladors, com a interfície independent del maquinari) referida com a Cmm en el codi del compilador.^[6] L'última versió del compilador compleix amb l'estàndard més nou del llenguatge, que és, ara per ara, el Haskell 2010.^[7] GHC està disponible per a moltes plataformes, incloent Windows i la majoria de sistemes Unix (com les diferents distribucions de GNU/Linux), Mac OS X i la majoria d'arquitectures de processador.

Aquest incloïa, fins a la versió 6.10.x, la majoria d'extensions al Haskell estàndard, fins i tot la biblioteca STM, que serveix per fer transaccions atòmiques (o tot o no res) de dades compartides entre diferents fils d'execució.

A partir de GHC 6.12 les biblioteques ja no venen amb el compilador sinó que es distribueixen en edicions diferides, dins la Plataforma Haskell ("The Haskell Platform").^[8][9] La corresponent a GHC 6.12.1 ja està disponible. Entre altres millores, suporta tractament d'entrada/sortida per a caràcters no anglosaxons, segons la codificació del sistema subjacent^[10]

HaskellStack subordina GHC

Stackage és un rebost que per cada versió de GHC guarda instantànies d'un conjunt de biblioteques compatibles amb compilació verificada, evitant la problemàtica de seleccionar per cada biblioteca una versió que encaixi en els requeriments de les restants.

HaskellStack (2015) possibilita el desenvolupament multiversió respecte de GHC, i descarrega automàticament la versió de GHC corresponent al rebost Stackage més recent que inclogui les dependències (biblioteques) d'una aplicació si hi ha fitxer de projecte .cabal al directori, proporcionant una eina que subordina i encapsula diverses versions de GHC i dels rebostos per al desenvolupament d'aplicacions en capsa de proves (Sandbox).

També proporciona un conjunt de plantilles d'aplicacions (comanda: stack templates) per engegar projectes nous (stack new projecte plantilla).^[11][12][13]

Biblioteques estàndard i correspondències de versions

Biblioteques de la darrera versió.^[14]

Normalment la propietat "since version X.X.X.X" de la doc. de les funcions ofereix la versió inicial de la biblioteca on es van definir.

Per saber quina versió mínima de GHC suporta una biblioteca estàndard, cal consultar les taules.

• taula de versions corresp. a GHC de 6.6 a 7.2^[15]
• taula de versions més recents.^[16] Es pot consultar versions anteriors al llistat d'actualitzacions de la pàg.

Compilar codi antic Haskell98 amb GHC

Per compilar projectes antics en Haskell98 cal tenir en compte que

• el llenguatge per defecte ja no és el mateix (ara és Haskell2010), caldrà afegir al fitxer de projecte (.cabal):

Default-language: Haskell98

• especificar la biblioteca haskell98 a les dependències

Si no fa servir excepcions, potser en tindreu prou amb els mòduls de la biblio haskell98

Build-Depends:	haskell98, ...

Si fa servir excepcions caldrà incloure el paquet base, i desambiguar, a les importacions, la biblioteca d'origen d'alguns mòduls Prelude, Numeric, ... presents a totes dues, com s'explica més avall.

Build-Depends:	base, haskell98, ...

• el sistema d'excepcions ja no és el mateix.

• Haskell98 agrupa les excepcions en un tipus Exception, unió discriminada dels diferents tipus d'excepcions. La pega és que és un grup tancat.

-- Haskell98
data Exception 
 = IOException IOException -- IO exceptions
 | ArithException ArithException -- Arithmetic exceptions
 | ArrayException ArrayException -- Array-related exceptions
 | ErrorCall String -- Calls to 'error'
 | ExitException ExitCode -- Calls to 'System.exitWith'
 | NonTermination -- Program is in an infinite loop
 | UserError String -- General purpose exception
 ...

• Haskell2010 modela les excepcions en una interfície, permetent caracteritzar com a excepcions, diferents tipus on l'usuari pot especificar els camps que convingui, requerint que han d'implementar les interfícies de les classes de tipus Exception, Show i Data.Typeable.

• La implementació de la classe Exception (del H2010) es pot derivar automàticament si el tipus implementa Show, afegint la derivació de la classe Data.Typeable i esmentant l'extensió de llenguatge DeriveDataTypeable.
• Hi ha un tipus genèric per recollir les excepcions (del H2010) no tractades, SomeException definit de manera existencial amb l'excepció com a component.

-- Haskell2010
data SomeException = forall e. Exception e => SomeException e

-- classe x convertir en excepció un tipus definit x l'usuari
class (Typeable e, Show e) => Exception e where
 toException :: e -> SomeException
 fromException :: SomeException -> Maybe e

Exemple de tractament d'excepcions al H98 i H2010 aquí.

Les excepcions antigues, des de GHC 6.10.1 van passar al mòdul Control.OldException del paquet base,^[17] s'hi van conservar fins a la versió 7.4.2^[18] i ha estat eliminat a la versió GHC-7.6.1.^[19]

Primer de tot cal descarregar^[20] el compilador de GHC-7.4.2, l'últim que conté el mòdul Control.OldException, configurar i instal·lar, en una carpeta de l'usuari (subdir. de $HOME):

# en un sistema UNIX
cd carpeta-d-extracció-del-paquet-GHC-7.4.2

./configure --prefix=$HOME/carpeta-d-instal·lacio
make install

# establir variables d'entorn
GHC_VER=7.4.2
GHC_HOME=$HOME/carpeta-d-instal·lacio/ghc-$GHC_VER
export GHC=$GHC_HOME/bin/ghc # camí de GHC per a fitxers de comandes (.sh | Makefile)
export PATH=$GHC_HOME/bin:$PATH # camí d'executables
export LD_LIBRARY_PATH=$GHC_HOME/lib/ghc-$GHC_VER/:$LD_LIBRARY_PATH # camí de biblioteques de càrrega dinàmica (.so | .dll)
export LIBRARY_PATH=$GHC_HOME/lib/ghc-$GHC_VER/:$LIBRARY_PATH # camí de biblioteques per a compilació

• Caldrà reanomenar les importacions de Exception i també Control.Exception

import Control.OldException ... -- en comptes de Control.Exception

• Després, en compilar un mòdul H98 apareix un error respecte el Prelude (mòdul de predefinits):

 Ambiguous module name ‘Prelude’:
 it was found in multiple packages: base haskell98

Una manera de desambiguar-ho és explicitant a cada mòdul l'origen del Prelude desitjat.

-- Al fitxer de projecte (.cabal) indicar:
Extensions: NoImplicitPrelude -- no volem el Prelude per defecte
 PackageImports -- volem especificar el paquet als "import"

-- als fitxers fonts:
import "haskell98" Prelude

Gestió de memòria

Vegeu doc.^[21] GHC compila per defecte amb memòria dinàmica il·limitada. Per establir-ne límits vegeu el senyal de compilació -M.^[22] Disposa d'un recollidor de memòria brossa generacional (per defecte dues gen.), amb control d'envelliment (nombre de recol·leccions abans de passar a la generació següent) de dos passos per generació.^[23]

L'allotjament es fa dins de blocs reutilitzables, partions d'un megabloc que és el tros que es reclama al sistema quan cal i que només li retornen en havent acabat.^[24]

Megabloc

bloc d'un megabyte, que l'allotjador de memòria demana de cop.

Capability

fil d'execució lligat a un del sistema, un per cada processador elemental, sobre els quals s'executen els fils d'execució lleugers del planificador del Run Time System multiprocessador (quan es fa servir l'opció -threaded).

Nursery (maternitat)

zona d'allotjament de dades noves (una per capability/P.E.), del recollidor de memòria brossa generacional.

A l'inici les dades s'allotgen a la maternitat (ang:nursery) (conjunt fix de blocs) i se'n disposa d'una per capability.^[25] després passen a la generació 0, i següents^[26] tantes com s'estableixi a les opcions de l'intèrpret d'ordres per al RunTimeSystem.

Per la generació més vella, es pot triar el sistema de recollida de la brossa, entre el mètode de Cheney (aturar la recollida i copiar dades a un espai net) per defecte i el mètode de compactació que estalvia espai però és més lent. Les altres generacions fan servir el mètode de Cheney.^[27]

• Per forçar la recollida de brossa quan convingui: System.Mem.performGC^[28]
• Referències dèbils (ang:weak pointer) per a taules de memoïtzació^[29][30] i també per a MVar's (Mutable variable) amb mkWeakMVar.^[31]

Fent servir biblioteques de relligat dinàmic

A partir de GHC >= 6.12^[32][33][34] Cal que GHC s'hagi compilat amb ./configure --enable-shared

 # relliga amb les versions compartides (no estàtiques) (bib.so o bé bib.dll segons sistema op.) del RunTimeSystem i dels paquets

 ghc --make -dynamic Main.hs

Paral·lelisme

Novetats al bloc butlletí "Parallel Haskell Digest"^[35]

Paral·lelisme de tasques

Primitives de paral·lelisme - Compilació per a processadors multicor

Vegeu-ho a Haskell concurrent#Primitives de paral·lelisme - Compilació per a processadors multicor

Futurs

Encadenament de càlculs asíncrons - la mònada Par

Vegeu-ho a Haskell concurrent#Encadenament de càlculs asíncrons - la mònada Par

El paquet meta-par ofereix una versió de la mònada Par per compartir recursos de hardware amb un planificador de tasques SMP.^[36]

Paral·lelisme en operacions IO - El functor aplicatiu Concurrently

Vegeu-ho a Haskell concurrent#Operacions d'Entrada/Sortida asíncrones i simultànies

Paral·lelisme de dades

Vectors pluridimensionals de procés paral·lel (Regular parallel arrays)

Un primer nivell de tractament paral·lel s'ofereix mitjançant el paquet Repa ("Regular parallel arrays")^[37][38] de tractament en paral·lel de vectors pluridimensionals. Exemple més avall.

Data Parallel Haskell

GHC implementa el, més complex, paral·lelisme de dades niuat, trad. de "Nested Data Parallelism"^[39][40][41] basat en treballs de Guy E. Blelloch.^[42]

Per a proves cal instal·lar el paquet dph-examples.

cabal install dph-examples

#si la versió de GHC és la 7.4.x i dona error en compilar el paquet ''bmp'',
# caldrà provar forçant la versió anterior a la que peta.
cabal install dph-examples "--constraint= bmp < 1.2.3.1"

Cal fixar-se en la versió instal·lada (diferent segons la versió de GHC) i descarregar-ne les fonts per investigar.

# per obtenir-ne la versió instal·lada
ghc-pkg list | grep dph-examples

Per desenvolupar-hi cal tenir en compte que...

• Cal separar les operacions per mòduls segons si són o no vectoritzades
• A la interfície el tipus ha de ser (PArray t)
• El tipus vector ([: t :]) és NO-polimòrfic i cal especificar el tipus de l'element, com ara [: Double :], les operacions sobre els tipus primitius no estan sobrecarregades i per cada tipus cal importar-ne el mòdul d'operacions corresponent (per ex.: Data.Array.Parallel.Prelude.Double).

Vegeu exemple més avall.

SIMD - Single Instruction, Multiple Data - Ús de les instruccions de CPU vectoritzades

Aprofitament de les instruccions de dades vectoritzades dels processadors (MMX, 3DNow!, SSE, Altivec, AVX, ...) per al procés a CPU de corrents de dades multimèdia.

Tipus i operacions primitius SIMD a GHC.Prim.^[43]

Pàg. inicial sobre SIMD a GHC (Hi ha una branca de GHC per a desenvolupament en SIMD, però els paquets esmentats més avall i l'exemple funcionen en versions estàndard de GHC utilitzant el rerefons de compilació LLVM).^[44]

Paquets d'interfície SIMD: simd,^[45] primitive-simd.^[46]

Exemple amb dades vectoritzades de 4 Floats (4x32 bits), per a un ordinador amb SIMD sse2 de 128 bits (Pentium 4 o posterior). Compilat amb GHC v. 7.10.1. Requereix l'ús del rerefons de compilació LLVM (compilar amb l'opció -fllvm).

 # la versió del paquet "simd" del Hackage té un error a la funció unVectorizeUnboxedX4
 # cal baixar la del GitHub
 git clone https://github.com/mikeizbicki/simd
 cd simd
 cabal install --allow-newer # (--allow-newer): ignora els límits superiors de les dependències

{-# OPTIONS_GHC -fllvm #-} -- opció per compilar amb el rerefons de compilació LLVM
{-# LANGUAGE PackageImports, ExistentialQuantification, StandaloneDeriving #-}
import "vector" Data.Vector.Unboxed as V
import "simd" Data.SIMD (X4, vectorizeUnboxedX4, unVectorizeUnboxedX4)
import Control.Monad as M

-- Hi ha versions de tipus (X<n> a), n ∈ {4,8,16} per a paquets SIMD de n elements de tipus 'a'
-- amb instàncies de les classes numèriques definides per als tipus (Xn Float), (Xn IntN), ...

-- vectorizeUnboxedX4 :: V.Vector a -> V.Vector (X4 a) -- simd-vectoritza (empaqueta els elements) un vector Unboxed
-- unVectorizeUnboxedX4 :: V.Vector (X4 a) -> V.Vector a -- inversa de vectorizeUnboxedX4

-- hi ha un error a la funció unVectorizeUnboxedXn del paquet simd-0.1.0.1 (a tots els mòduls SIMD<n>),
-- però ja està arreglat a la versió que hi ha al 'github'

default (Int, Float)

mostra :: Int -> V.Vector Float
mostra n = V.fromList [1 .. fromIntegral n]

mkFloatVec :: V.Vector Float -> V.Vector (X4 Float) -- comprova i simd-vectoritza un vector normal de 'floats'
mkFloatVec vec
 | V.length vec `mod` 4 == 0 = vectorizeUnboxedX4 vec
 | otherwise = error "mkVec: el nombre d'elements ha d'omplir els paquets completament"

data Obj = forall a. Show a => Obj a -- objectes presentables

deriving instance Show Obj -- la derivació d'instàncies dels objectes existencials va separada

main = do
 let v1 = mkFloatVec v0
 v2 = V.map (/ 2.0) v1
 v3 = unVectorizeUnboxedX4 v2 -- cal la versió del GitHub perquè funcioni correctament

 -- com que v0..v3 són de tipus diferents, farem una llista d'objectes presentables
 M.forM_ [Obj v0, Obj v1, 
 Obj v2, Obj v3] print -- print = show >>> putStrLn
 where
 v0 = mostra 8

dona:

Obj [1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0]
Obj [(1.0,2.0,3.0,4.0),(5.0,6.0,7.0,8.0)]
Obj [(0.5,1.0,1.5,2.0),(2.5,3.0,3.5,4.0)]
Obj [0.5,1.0,1.5,2.0,2.5,3.0,3.5,4.0]

Paral·lelisme GPGPU

• Per a targetes gràfiques amb capacitat GPGPU de Nvidia o AMD-ATI, o bé sobre CPU's multicor de AMD o bé Intel via OpenCL

En l'execució de rutines sobre vectors de dades, ús de la GPU per l'execució simultània del nucli d'iteració sobre els elements dels paràmetres vectors, repartint automàticament valors del cursor (que indexa els paràmetres vectors) als diferents processadors elementals.

• Biblioteca Accelerate^[47][48] amb suport per a rerefons CUDA,^[49] OpenCL^[50] i RePa^[51] (per a CPUs), i genera nuclis (d'iteracions en paral·lel) per a GPU/CPU partint d'un llenguatge incrustat (EDSL) en Haskell. La biblioteca Accelerate va ser desenvolupada a la Universitat de Nova Gal·les del Sud (Austràlia) amb els auspicis de NVIDIA, desenvolupant inicialment per a dispositius NVIDIA-CUDA.^[47]
• Biblio. OpenCLWrappers facilita l'ús de lligams amb biblioteques externes que implementin l'estàndard OpenCL,^[52] article: OpenCL from Haskell^[53]
• Simultanejant càrregues de treball en CPU i GPU. Vegeu "How to write hybrid CPU/GPU programs with Haskell".^[54]

Exemple GPGPU d'ús de la biblioteca Accelerate

• Mòdul principal amb intèrpret de simulació del llenguatge incrustat (EDSL: "embedded domain specific language").^[55]
• Mòduls per al paral·lelisme a GPUs

• RerefonsCUDA de NVIDIA.^[56] Requereix tenir instal·lat el compilador NVCC del ToolKit de NVIDIA.^[57]
• Rerefons OpenCL de HIPERFIT.^[58] Cal tenir instal·lat el kit de desenvolupament (SDK) del fabricant de la GPU. L'estàndard OpenCL està implementat tant per NVIDIA^[59] com per AMD-ATI, però AMD a més d'implementar-lo en dispositius GPU, tracta la CPU multicor com un altre dispositiu de paral·lelisme.^[60]
• Rerefons OpenCL basat en el llenguatge per al paral·lelisme Icc-Cilk de Intel.^[61]

• Mòduls per al paral·lelisme a CPUs multicor

• Rerefons biblioteca RePa (Regular Parallel Arrays).^[62]
• Rerefons via LLVM.^[63]

cabal install accelerate # instal·la paquet base amb simulador (intèrpret del llenguatge de domini específic)

# si teniu targeta gràfica NVIDIA amb capacitat GPGPU i heu instal·lat el kit de desenvolupament CUDA
CUDA_HOME=/usr/local/cuda-7.0 
cabal install cuda \ 
 --extra-include-dirs=$CUDA_HOME/include \ 
 --extra-lib-dirs=$CUDA_HOME/lib64

cabal install accelerate-cuda

La versió per a OpenCL és al GitHub i el funcionament bàsic és idèntic.

{-# LANGUAGE CPP, PackageImports #-}
import Data.Array.Accelerate as A

-- biblioteques "accelerate" de procés paral·lel

#define PROC_PAR_CUDA 1 /* maquinari NVIDIA */
#define PROC_PAR_HIPERFIT_OPENCL 2 /* maquinari que suporta l'estàndard OPENCL */
#define PROC_PAR_INTEL_OPENCL 3 /* maquinari INTEL */ 
#define PROC_PAR_INTERPRET 0 /* sense maquinari de procés paral·lel (simulació per l'intèrpret) */

#define BIBLIO PROC_PAR_CUDA /* assigneu la vostra */ 

#if BIBLIO == PROC_PAR_CUDA
import qualified "accelerate-cuda" Data.Array.Accelerate.CUDA as ProcPar

#elif BIBLIO == PROC_PAR_HIPERFIT_OPENCL
import qualified "accelerate-opencl" Data.Array.Accelerate.OpenCL as ProcPar

#elif BIBLIO == PROC_PAR_INTEL_OPENCL
import qualified "accelerate-icc-opencl" Data.Array.Accelerate.OpenCL as ProcPar

#elif BIBLIO == PROC_PAR_INTERPRET
-- intèrpret del llenguatge simulant un procés paral·lel (per manca de maquinari)
import qualified "accelerate" Data.Array.Accelerate.Interpreter as ProcPar
#endif

-- `Acc` (:: Type -> Type) designa el context del dispositiu accelerador

-- `use` (:: a -> Acc a) carrega un paràmetre a la memòria del dispositiu accelerador

-- `run` (:: Acc a -> a) executa el càlcul a l'accelerador, i descarrega el resultat

-- vectors de dades amb indicador de dimensionalitat (tipus Shape)
xs, ys :: Array DIM1 Float
xs = A.fromList (Z :. 2) [1, 2]
ys = A.fromList (Z :. 2) [2, 2]

-- type Scalar a = Array DIM0 a

-- producte escalar de vectors carregats al dispositiu accelerador (Acc a)
prodEscalar :: Acc (Array DIM1 Float) -> Acc (Array DIM1 Float) -> Acc (Scalar Float)
prodEscalar xs ys = A.fold (+) 0 (A.zipWith (*) xs ys)

-- prova per al dispositiu de paral·lelisme principal (n'hi pot haver diversos GPU's o bé CPU)

-- càlcul al dispositiu: carrega dades amb 'use'; 'run' executa i descarrega el resultat
càlcul :: Scalar Float
càlcul = ProcPar.run $ prodEscalar (use xs) (use ys)

main = print càlcul

Cal compilar amb la versió multi-tasca (opció -threaded) del RunTimeSystem

$ ghc --make -threaded prova.hs
$ ./prova
Array (Z) [6.0]

Concurrència

• MVar's - Mutable/Mailbox Variable—variables protegides, aprofitant la concurrència basada en bústies d'un sol element.
• forkIO / forkOS
• Software Transactional Memory
• Futurs—Encadenament de càlculs asíncrons - la mònada Par
• Operacions d'Entrada/Sortida asíncrones i simultànies
• Cloud Haskell (computació distribuïda, a l'estil del sistema d'actors distribuïts de l'Erlang)
• Biblioteca Actor
• Communicating Haskell Processes (CSP)

Vegeu Haskell concurrent.

Metaprogramació - Template Haskell

Extensió de GHC que permet l'anàlisi i generació de codi o bé Haskell o bé a expressions del tipus algebraic de l'arbre d'operacions (AST) d'un programa, com els generats internament pel compilador de Haskell.^[64]

Avaluació en temps de compilació

El prefix "$" a un terme o bé a una expressió entre parèntesis, $terme o bé $(expr), s'anomena crida splice o d'inserció, i vol dir que cal avaluar l'expressió en temps de compilació i substituir-la, en el codi, pel seu valor. Exemple: #Punts de control al codi amb Loch-TH

Quasi-Quotations (Plantilles per a gramàtiques DSL)

Construcció^[65] que s'avalua en temps de compilació, que permet incrustar texts convertibles a codi, escrits en gramàtiques anomenades "DSL" (Domain Specific Language), específiques per a una temàtica o domini d'aplicació, generant, per metaprogramació, expressions inter-operables amb les del mòdul que l'allotja, per exemple, plantilles HTML amb interpolació d'expressions vàlides en l'àmbit d'avaluació de la plantilla.^[66]

Sintaxi

Les acotacions QuasiQuotation utilitzen una sintaxi anomenada Claus d'Oxford [|... |] o bé [prefix|... |] on el nom del prefix indica el registre que aporta els traductors del text acotat per les claus.^[67]

Context

Una acotació QuasiQuotation pot descriure, segons el lloc on s'utilitza, una expressió, o bé un patró, o bé un tipus, o bé una llista de declaracions a nivell de mòdul, i, per traduir-la, s'utilitzarà el traductor corresponent al context, component del tipus descrit tot seguit.

Tipus

Un tipus quasiQuoter es defineix com un registre amb traductors opcionals per cadascun dels 4 possibles contextos en què es pretengui inserir, assignant als altres el valor undefined.^[68]

La seva definició ha d'aportar funcions per la traducció del text a expressions del llenguatge Template Haskell que incorpora combinadors per generar clàusules de codi Haskell (metaprogramació).^[69][70][71]

-- tipus del registre que aporta els traductors d'una plantilla on s'esmenta com a prefix [elMeuTraductor|...|]
data QuasiQuoter = 
 QuasiQuoter { -- ha d'incloure algun dels camps següents:
 quoteExp :: String → Q Exp, -- traductor en context d'expressions (metaprogramació d'expressions)
 quotePat :: String → Q Pat, -- traductor en context de patrons (metaprogramació de patrons)
 quoteType :: String → Q Type, -- traductor en context de tipus (metaprogramació de tipus)
 quoteDec :: String → Q [Dec] -- traductor en context de declaracions (metaprogramació de declaracions)
 }
elMeuTraductor = QuasiQuoter { quoteExp = tradCasDExpressions, quotePat = tradCasDePatrons, ...}

Exemple senzill: document tot seguit

Traductor simple per incloure textos multilínia en expressions (estil hereDoc o document-tot-seguit), com a literals, amb la funció stringE de T.H.^[72]

• les funcions de traducció per als contextos que no interessen es deixen undefined.
• l'ús i la definició han d'estar en mòduls separats.

{-# LANGUAGE TemplateHaskell #-}
{-# OPTIONS_GHC -Wno-missing-fields #-} -- que GHC no es queixi pel registre QuasiQuoter incomplet

module ElMeuDocTotSeguit where
 import Language.Haskell.TH (stringE)
 import Language.Haskell.TH.Quote (QuasiQuoter(..))

 docTotSeguit = QuasiQuoter {quoteExp = stringE} -- aporta només el traductor per al context d'expressions

-- ús
{-# LANGUAGE QuasiQuotes #-}
module Main where
 import ElMeuDocTotSeguit (docTotSeguit)

-- format a GHC 7+ :
 elMeuTextPluriLínia = [docTotSeguit|text de la primera línia
segona línia i següents
|]

-- format a GHC 6.12 (cal prefixar el traductor amb '$'): [$docTotSeguit|text|]

Exemple: Incrustació de HTML amb interpolació d'expressions

De les biblioteques del Yesod.^[66]

La plantilla shamlet tradueix, a expressions del Template Haskell, un llenguatge de marques afegint automàticament les marques de tancament segons el sagnat.

Permet la interpolació d'expressions Haskell delimitades amb claus prefixades per un caràcter que determina la funcionalitat.

• Les claus "#{" ... "}" inclouen expressions avaluables quin tipus resultant ha de ser convertible implementant la classe Text.Blaze.ToMarkup.
• Les claus "^{" ... "}" permeten la inclusió per referència d'altres sub-plantilles de tipus coincident amb la que les allotja.

{-# LANGUAGE PackageImports, QuasiQuotes, OverloadedStrings #-}
module Plantilla (pàgina) where

-- "Hamlet" fa referència a un trosset de Html (és un joc de paraules amb les lletres de "HTML")
import "shakespeare" Text.Hamlet (Html, shamlet)
import Data.Text (Text)

nom = "Biel" :: Text
títol = "Títol de la pàgina" :: Text

data TAmic = Amic {amicNom::String, amicEdat:: Int}
elsAmics = [Amic "Joan" 30, Amic "Montse" 40]

-- Plantilla per al cos de la pàgina
-- amb #{expr} interpola l'avaluació de l'expressió per a tipus que implementin la classe Text.Blaze.ToMarkup

cosDeLaPàg :: [TAmic] -> Html
cosDeLaPàg amics = [shamlet|
 <p>Hola el meu nom és #{nom}
 $if null amics
 <p>Ho sento, no hi ha amics.
 $else
 <p>Els meus amics són:
 <ul>
 $forall amic <- amics
 <li>#{amicNom amic} que té #{amicEdat amic} anys
|]

-- Plantilla principal
-- amb ^{expr} interpola una crida a una altra plantilla QQ del mateix tipus de resultat.

pàgina :: Html
pàgina = [shamlet|
 !!!
 <html>
 <head>
 <title>#{títol}
 <body>^{cosDeLaPàg elsAmics}
|]

{-# LANGUAGE PackageImports #-}

import Plantilla (pàgina)
import "blaze-markup" Text.Blaze.Renderer.Text (renderMarkup)
import qualified Data.Text.Lazy.IO as TLIO

main = TLIO.putStrLn $ renderMarkup pàgina

Facilitats per l'optimització de fusió

En aplicar una composició sobre una estructura, per ex., (reducció. filtre p'. map f. filtre p).

Malgrat que, en ser un llenguatge d'avaluació tardana, no hi ha la problemàtica de la desforestació, hi ha propostes per fusionar-ne les iteracions.

L'ús de la pragma RULES Arxivat 2009-04-22 a Wayback Machine. permet que el compilador, en fase de pre-procés, refaci (reescrigui) operacions de composició.^[73]

Stream fusion

Fusió de bucles en la composició d'operacions sobre estructures mitjançant la conversió de l'estructura en un corrent de dades (ang: Stream)^[74] i especificant l'operació per cada element del corrent.

El corrent incorpora la possibilitat de tenir elements sense dades, a conseqüència del filtratge.

Les funcions com ara els filtres s'han d'aplicar començant per l'operació de conversió stream sobre l'estructura, que la converteix en corrent de dades, i acabant per la inversa unstream.

En la composició de funcions, l'aparició juxtaposada de les conversions unstream al final d'una funció amb la inversa stream de l'inici de la següent és eliminada pel compilador mitjançant pragmes RULES aportades per la implementació.^[75][76]

Vegeu biblioteca Stream-fusion al rebost Hackage^[77]

Referència ràpida de la biblioteca

Vegeu l'API del GHC^[78] i la de la plataforma^[9] Haskell.

contenidors

Vegeu ref.^[79]

Recordatori d'algunes operacions

S'esmenten les ops. ometent el paràm. de l'estructura sobre la qual s'aplica (Col·lecció -> Col·lecció). Si l'estructura va primer, l'operació s'esmenta en forma d'aplicació parcial infix (`op` p2 p3..). Cas de consultes o bé resultats opcionals, s'especifica ocasionalment el tipus del retorn. Respecte als tipus de les funcions, consulteu les refs.

notes

llistes amb optimització de fusió

• el paquet stream-fusion^[77] aporta llistes amb funcions fusionables pel mètode stream fusion.

conjunts i diccionaris

• Set ε^[80] i Map κ ε^[81] del paquet "containers" implementen conjunts i diccionaris basats en arbres de cerca binària balancejats amb cost de cerca O(log n).
• IntSet^[82] i IntMap ε^[83] també de "containers" implementen Set i Map sobre el domini Int amb implementació basada en arbres de prefix (Tries) sobre la seqüència de bits amb cost de cerca, com a màxim el nombre de bits del tipus Int.
• el paquet hashmap^[84] aporta una implementació de conjunts^[85] i diccionaris^[86] basada en IntSet i IntMap de containers, que requereix una aplicació del domini de les claus al tipus Int (funció resum (de hash en anglès) classe Hashable)^[87] i desant al conjunt/diccionari o bé un sol element/parell o bé, en en cas de col·lisions, un cistell dels elements/parells quines claus col·lideixen, implementat com a Set/Map del paquet containers. El paquet hashmap ha quedat desaconsellat en favor del paquet unordered-containers.
• el paquet unordered-containers^[88] implementa conjunts^[89] i diccionaris^[90] (HashSet i HashMap) quines claus han d'implementar una funció resum (classe Hashable) però no cal que implementin Ord (ordenable). El cistell de col·lisions en té prou amb la implementació de Eq per distingir-les.

seqüències finites de dos caps, amb accés més ràpid que les llistes

• Seq ε de Data.Sequence^[91] implementa seqüències finites amb dos caps (ang:double ended queue) i accés constant O(1) en afegir i recuperar per ambdós costats. viewl proporciona la vista per l'esquerra i viewr la de la dreta.

Cost d'accés aleatori inferior a les llistes: O(log(min(i,n-i))) per a l'accés indexat;

Cost de la concatenació: O(log(min(n1,n2)));

Cost de la consulta de llargària O(1). Avantatge sobre les llistes (on és O(n)) per prevenir l'accés indexat fora de rang.

vectors pluridimensionals

• Amb vector fem referència a seqüències d'accés aleatori (accés a qualsevol element amb cost constant O(1))
• El tipus Array shape ε del paquet Repa^[37][92] aporta vectors pluridimensionals d'elements no-encapsulats (unboxed) (allotjats directament)
  • Els elements del Repa han d'implementar

class (Show a, Unbox a) => Elt a
 zero :: a
 one :: a
 ...

• • Els tipus dels índexs del Repa prenen una forma semblant a una pila de dimensions, i implementen la classe Shape:

type DIM0 = Z -- zero dimensions: escalar
type DIM1 = DIM0 :. Int -- una dimensió, ex. Z :. 3
type DIM2 = DIM1 :. Int -- dues dimensions, ex. Z :. 3 :. 3
...

• Data.Array.Repa utilitza la terminologia dels llenguatges on l'avaluació tardana és explícita, anomenant vectors diferits (ang:delayed) les aplicacions no-avaluades, per exemple amb map, forçant-ne l'avaluació amb la funció force (com a l'OCaml) que avalua, paral·lelitzant els càlculs.

A ghci:

Prelude>:m +Data.Array.Repa
Prelude Data.Array.Repa> let v22 = fromList (Z :. 2 :. 2) [1,2,3,4] :: Array DIM2 Int
Prelude Data.Array.Repa> let consultaV22 i j = v22 ! (Z :. i :. j)
Prelude Data.Array.Repa> consultaV22 1 0
3
Prelude Data.Array.Repa> extent v22
(Z :. 2) :. 2
Prelude Data.Array.Repa> size $ extent v22
4
Prelude Data.Array.Repa> let w22 = force $ Data.Array.Repa.map (\x → x * 2) v22
Prelude Data.Array.Repa> w22 -- Data.Array.Repa.force avalua els mapejos en paral·lel
Array (Z :. 2 :. 2) [2,4,6,8]

Vectors d'alt rendiment

Vectors amb índexs enters amb base 0.

Vector ε i MVector σ ε del paquet Vector^[93] aporten vectors immutables i mudables, basats en famílies de tipus, que permeten implementacions més flexibles, i, a banda, funcions fusionables (stream fusion per la composició).^[94][95]

• cas d'allotjament directe dels elements: Per a vectors d'elements de tipus primitius el mòdul Data.Vector.Unboxed aporta vectors immutables i mudables d'elements no encapsulats.^[96]
• hi ha altres paquets relacionats amb funcionalitats diverses
  • vector-algorithms: algorismes sobre vectors mudables MVector
  • vector-binary-instances: serialització
  • vector-read-instances: instància de Read
  • vector-instances: instàncies de diverses classes
  • ...

biblioteca mono-traversable de Tipus Abstractes de Dades

Les classes de la biblio estàndard requereixen que les col·leccions estiguin parametritzades amb el tipus de l'element com a variable. Això fa que no es puguin aplicar a les col·leccions monomòrfiques on el tipus de l'element és fix (ex.: Word8 a Bytestring) perquè l'aritat del tipus de la col·lecció no concorda.

El paquet mono-traversable^[97] aporta un conjunt de classes d'un sol índex, on els paràmetres de tipus dependents de les col·leccions hi son referits mitjançant tipus associats a la classe o bé famílies de tipus, aplicables tant a estructures paramètriques com monomòrfiques.

class SemiSequence t -- classe monoparàmetre, per a seqüències no buides (implementen Semigrup)
 type Index t -- tipus de l'índex de seqüències com a tipus associat (indexat al paràm. de la classe)

type family Element t -- definit globalment per evitar fer diferents versions de les interfícies.
class MonoFunctor t
 omap :: (Element t -> Element t) -> t -> t

-- Si Element t fos un tipus associat, caldria fer-ne versions diferents per a {seqüències, conjunts, diccionaris} i particularitzar {Functor, Foldable, Traversable, ..} per cada classe de contenidors

A més a més aporta instàncies dels TADs per a les estructures més utilitzades relacionant-hi les operacions.

• MonoPointed:^[98] operacions per elevar un element a la categoria de contenidor mono amb l'element d'entrada.
• MonoFunctor:^[99] Functor sobre contenidors mono.
• MonoZip:^[100] operacions de combinació per posició (zips) de contenidors mono. Requereix MonoFunctor
• MonoFoldable:^[101] Catamorfismes sobre contenidors mono.
• MonoTraversable:^[102] Recorregut (visita) dels elements dels contenidors mono que es poden travessar seqüencialment d'esquerra a dreta, aplicant-los una funció d'efectes o avaluant-los si ja ho són.
• NonNull:^[103] tipus per embolcallar estructures no buides i efectuar-hi amb seguretat operacions parcials que petarien en estructures buides.

Interfícies per l'abstracció de seqüències

• SemiSequence:^[104] Abstracció de les seqüències no-buides amb operacions basades en Semigrups. Aporta {cons, snoc, find, sortBy, reverse, intersperse}.
• IsSequence:^[105] Abstracció de les seqüències buidables, afegint l'element neutre a SemiSequence formant un Monoide. Requereix SemiSequence, Monoid, MonoPointed, MonoTraversable
• Textual:^[106] TAD per a seqüències de caràcters divisibles en paraules i línies. Aporta {words, unwords, lines, unlines, toUpper, toLower, ...}
• Utf8:^[107] TAD multiparàmetre per codificar seqüències textuals en UTF-8, parametritzat amb el tipus de l'estructura d'intercanvi no codificada.

Interfícies per l'abstracció de conjunts i diccionaris

• SetContainer:^[108] TAD amb les operacions comunes als contenidors d'elements distingits per una clau. (tipus de la clau, aporta consultes de la clau {member, notMember, keys}, ops. de combinació {union, unions, difference, intersection})
• IsSet:^[109] SetContainer quins elements són claus, (Element t) coincideix amb (ContainerKey t), amb operacions dels conjunts. Requereix SetContainer.
• IsMap:^[110] SetContainer travessable, amb les operacions dels diccionaris. Requereix SetContainer i MonoTraversable

Els noms de mono-traversable que defineixen funcions coincidents amb les del Prelude duen el prefix "o" (onull, olength, oelem, ...) per evitar haver de desfer ambiguïtats contínuament.

{-| prova.hs 
* Implementa la func. 'trossos' d'un màxim de n elements d'una seqüència retornant-ne la seqüència de seqüències.
* Abstracció dels tipus de la seq. d'origen i de la seq de seqs de sortida.
-}
{-# LANGUAGE PackageImports, TypeFamilies #-}
import "mono-traversable" Data.Sequences as S
import "mono-traversable" Data.MonoTraversable as M
import Data.Function ((&)) -- (&): aplicació cap enrere, (paquet base)
import Control.Monad (mfilter)

-- IsSequence implica MonoFoldable a la qual pertany 'onull', i també implica Monoid

trossos :: (IsSequence t, IsSequence t', Element t' ~ t) => Index t -> t -> t'
trossos n seq = desplega (parteixIValida n) seq

-- desplega equival a 'unfoldr' a les llistes
desplega :: (IsSequence t, a ~ Element t) => (b -> Maybe (a, b)) -> b -> t
desplega f estat = case f estat of
 Just (x, estat') -> S.cons x $ desplega f estat'
 Nothing -> mempty -- cas final, seqüència buida (neutre de concat) (IsSequence implica Monoid)

parteixIValida :: IsSequence t => Index t -> t -> Maybe (t, t)
parteixIValida n seq = 
 S.splitAt n seq
 & Just
 & mfilter (not. M.onull. fst) -- si el trosset era buit, estem al final (retorna Nothing)

provant-ho sobre instàncies de IsSequence com ara String o bé Vector de Data.Vector. Caldrà especificar els tipus de seqüències desitjats com a restricció de tipus:

$ ghci
GHCi, version 7.10.3: http://www.haskell.org/ghc/ :? for help
Prelude> :load prova
[1 of 1] Compiling Main (prova.hs, interpreted)
Ok, modules loaded: Main.
* Main> trossos 2 "abcdef" :: [String]
["ab","cd","ef"]
* Main> import Data.Vector as Vec
* Main Vec> trossos 2 (Vec.fromList [1..4]) :: Vector (Vector Int)
[[1,2],[3,4]]

altres biblioteques rellevants

• el paquet bytestring-trie^[111] aporta una implementació de diccionaris com a arbres de prefix (Tries) per a claus de tipus ByteString
• el paquet dlist^[112] aporta llistes per diferència que redueixen el cost de concatenació en cas d'aniuament d'expressions Vegeu ref.^[113]
• el paquet heap^[114] aporta cues amb prioritat per a seqüències d'ordenables ({Min|Max}Heap) o bé de parells (prioritat, valor) ({Min|Max}PrioHeap)
• el paquet semigroups,^[115] a partir de GHC 8.0 queda integrat al paquet base. Aporta la classe Semigroup^[116] i Data.List.NonEmpty per a llistes no buides.^[117]

module Data.List.NonEmpty
...
data NonEmpty a = a :| [a] -- infixr 5

-- afegeix pel davant
(<|), cons :: a -> NonEmpty a -> NonEmpty a
...

generació

• Contenidors mono-valor d'opcionalitat o bé de dualitat resultat/error

• Seqüències d'accés lineal

Data.List.cycle dispara error si la llista era buida.

• Seqüències d'accés aleatori

• Altres estructures

• TADs de mono-traversable

consulta

• fromJust dispara error si la Maybe era buida ; fromMaybe n'és una versió segura (amb valor per defecte per als casos sense valor).

• Al mòdul Data.List head, tail, init i last disparen error si la seqüència era buida. Al mòdul Data.List.NonEmpty no, perquè les seq. són no-buides: data NonEmpty a = a :| [a]

Els errors generats per funcions definides parcialment, com ara head en seqüències buidables, tenen una depuració complicada (la crida a error no informa de la situació de la crida que incompleix la pre-condició (excepte si es compila per l'ajustatge, ang:profiling i s'executa amb opcions addicionals per la depuració), ni normalment tampoc del valor causant (ex.: (dicc `Map.!` clau) pot donar l'error "Map.!: given key is not an element in the map" perquè la implementació de Show pels paràmetres no es requereix), només dispara una excepció genèrica ErrorCall amb el missatge).^[134][135]

actualització / transformació

• Els tipus monomòrfics (ByteString, Text i també IntSet) no implementen Functor, que requereix tipus amb l'element com a paràmetre, altrament dit, kind * -> * (aritat del tipus == 1)

• Els tipus (Set a) i (HashSet a) no implementen Functor (#perquè els conjunts no implementen Functor).

Nota per les funcions d'actualització als diccionaris:

• adjust (f::v→v) clau dicc : actualitza el valor, si i només si clau pertany al diccionari dicc.
• update (f::v→Maybe v) clau dicc : actualitza o bé elimina, segons existeixi (isJust) la imatge de la funció f per al valor corresponent a la clau
• alter (f::Maybe v → Maybe v) clau dicc : (actualitza o bé elimina o bé insereix) si clau no existeix, la insereix amb el valor (f Nothing); altrament com update

accés indexat

• TADs de mono-traversable^[132] -- accés indexat

-- Del mòdul Data.Sequences del paquet ''mono-traversable''
-- les funcions parcials (poden disparar ''error'') duen el sufix Ex

indexEx :: IsSequence seq => seq -> Index seq -> Element seq -- funció parcial !! (dispara ''error'')

index :: IsSequence seq => seq -> Index seq -> Maybe (Element seq) -- resultat opcional

combinació

• TADs de mono-traversable^[132] -- combinació

{-| Composició a ''mono-traversable'' -}

-- els zips sobre llistes es resolen amb un (''newtype'' ZipList a) que implementa un ''functor aplicatiu''.
import Data.MonoTraversable (ZipList (ZipList, getZipList))
zipWithN combinador xs1 xs2 ... xsN = getZipList $ combinador <$> ZipList xs1 <*> ... <*> ZipList xsN

-- les seqüències són Monoides
import Data.Sequences
class (Monoid seq, ...) => IsSequence seq

-- consulta d'inclusió
is{Prefix|Suffix|Infix}Of :: (IsSequence seq, Eq (Element seq)) => seq -> seq -> Bool

-- composició de conjunts i diccionaris
import Data.Containers
class (Monoid set, ...) => SetContainer set
 union :: set -> set -> set
 unions :: (MonoFoldable t, Element t ~ set) => t -> set -- redueix una col·lecció de ''SetContainer'' a un de sol.
 -- com que (SetContainer set) requereix (Monoid set) llavors: unions = oconcat
 difference :: set -> set -> set
 intersection :: set -> set -> set
 ...
-- instàncies de contenidors ordenats (del mòdul ''containers'')
instance Ord element => SetContainer (Set.Set element) -- els conjunts d'ordenables es poden compondre
instance Ord k => SetContainer (Map.Map k v) -- els diccionaris amb clau ordenable també

-- instàncies de contenidors amb claus que implementen Hashable (funció resum) (del mòdul ''unordered-containers'')
instance (Eq element, Hashable element) => SetContainer (HashSet.HashSet element)
instance (Eq key, Hashable key) => SetContainer (HashMap.HashMap key value)

reducció

• foldl1, foldr1, scanl1, scanr1: disparen error si la col·lecció era buida.

• minimum, maximum disparen error si la col·lecció era buida
• minIndex, maxIndex disparen error si el vector era buit
• findMin, findMax disparen error si el conjunt o diccionari eren buits
• els tipus monomòrfics (ByteString, Text, IntSet) no implementen Foldable que requereix tipus amb l'element com a paràmetre, altrament dit Kind (* -> *) (aritat del tipus == 1)

partició

• (span{l|r} predicat) parteix com (takeWhile{L|R} predicat, dropWhile{L|R} predicat)
• (break{l|r} predicat) equival a (span{l|r} (not. predicat))^[139]

implementació de classes

classes de la biblioteca GHC que les col·leccions implementen:

• control seqüencial:

• Monad: encadenament d'accions funció del resultat de la precedent. Seqüencia les accions.
• Applicative: combinació de resultats d'accions: Seqüencia només les engegades. Aplicable en paral·lelisme.

• composició no-seqüencial: Monoid
• composició seqüencial (control seqüencial amb Monoide): Alternative, MonadPlus
• mapejat no-seqüencial: Functor (Functor garanteix que l'aplicació de la composició de morfismes equival a la composició de les aplicacions dels morfismes individualment, estalviant la multiplicitat de travessaments)
• visita seqüencial (cas d'elements amb efectes o bé les imatges d'un mapeig amb una funció d'efectes): Traversable
• reducció: Foldable
• comparació de les col·leccions: Eq, Ord
• textualitzacio de les col·leccions: Show,^[140] Read^[141]
• travessament genèric de l'estructura de les col·leccions: Data,^[142] Generic^[143]
• avaluació en profunditat (a forma normal) de les col·leccions: NFData (contracció de Normal Form Data)^[144]
• serialització de les col·leccions: Binary^[145]

excepcions i crítiques

• els tipus monomòrfics (ByteString,^[121] Text^[122] i IntSet^[82] no poden implementar les classes Functor i Foldable, Applicative, Monad, Alternative, MonadPlus, Traversable (quines funcions estan definides per a tipus amb un paràmetre). En intentar-ho, dona l'error: Kind mis-match (l'aritat del tipus no és l'esperada). Solució paquet mono-traversable (vegeu #alternatives)
• no implementen Functor:
  • Els conjunts. #perquè els conjunts no implementen Functor!

alternatives

• • El paquet mono-traversable^[146] aporta versions genèriques de classes estàndard per a contenidors, sense l'exclusió dels tipus monomòrfics, definint l'element com una família de tipus.

Les funcions parcials tenen versions amb sufix Ex (poden disparar excepció cridant error), o bé sufix May (resultat opcional)

perquè els conjunts no implementen Functor

Perquè no mantenen la regla de la composició de morfismes dels Functors: ${\displaystyle F(g\circ f)=F(g)\circ F(f)}$ per a tot morfisme ${\displaystyle f:X\rightarrow Y\,\!}$ i ${\displaystyle g:Y\rightarrow Z}$. Vegeu Functor#Els conjunts no són Functor

implementacions

• Al GHC 7.10 està previst que Applicative esdevingui superclasse de Monad, i que Alternative ho sigui de MonadPlus.^[148]
• Alternative i MonadPlus inclouen implementacions que obeeixen regles diferents. Hi ha una proposta per separar cadascuna d'elles en dues classes.^[149][150]

• La regla de l'element absorbent per l'esquerra (ang:Left Catch): Maybe la compleix; la Llista no

 mplus (return x) k ≡ return x -- element absorbent per l'esquerra

• La propietat distributiva per l'esquerra (ang:Left Distribution): La Llista la compleix; Maybe no

 (mplus a b) >>= k ≡ mplus (a >>= k) (b >>= k) -- propietat distributiva per l'esquerra

Altres classes habituals dels contenidors:

• Eq t: Compara contenidors igualables comparant els elements segons l'ordre seqüencial o bé mitjançant la conversió a llista.
• Ord t: Compara contenidors ordenables comparant els elements segons l'ordre seqüencial o bé mitjançant la conversió a llista ascendent.
• Show t: Contenidor textualitzable a String independent de la codificació de caràcters (els caràcters ASCII imprimibles (0x20 a 0x7F) tal com són, els metacaràcters (com ara '\t',..) amb el prefix '\', altres caràcters en representació numèrica, inclosos els no-anglosaxons). Per una sortida humanament llegible dels caràcters no anglosaxons, cal fer servir el paquet Text.
• Read t: Omple contenidor llegint la sortida de (Show t).

Implementació de Binary (serialitzable) amb binary-generic

Cal que el tipus implementi la classe Data^[153] del mòdul Data.Data que possibilita el recorregut genèric de l'estructura del tipus. Vegeu el paquet binary-generic^[158]

{-# LANGUAGE PackageImports #-}
import Data.Data (Data) -- Data possibilita el travessament genèric de l'estructura
import Data.Binary (Binary(..)) -- la classe Binary i els seus mètodes (..)
import "binary-generic" Data.Binary.Generic (getGeneric, putGeneric)

-- Text de Data.Text ja implementa Data

import Data.Text (Text)
import Data.HashSet (HashSet)
import Data.Hashable (Hashable)

instance Binary Text where
 get = getGeneric
 put = putGeneric -- versió tàcita (sense paràm. formals reduïbles)

instance (Data a, Hashable a, Eq a) => Binary (HashSet a) where
 get = getGeneric
 put = putGeneric

prova:

cabal install binary-generic
ghc -c prova.hs

Sobrecàrrega de literals

La sobrecàrrega de literals permet associar-los a una classe de tipus, en comptes d'a un tipus fix, permetent-ne l'ús en posicions d'operands d'aquells tipus que les implementin.

Sobrecàrrega de literals String

Així com els literals numèrics obtenen el tipus de la signatura de les operacions en que intervenen, la classe IsString fa possible això mateix per als literals String admetent-ne l'ús en posicions d'altres tipus que n'implementin la conversió, en el mètode fromString de la classe IsString.^[160] Cal especificar l'extensió de llenguatge OverloadedStrings.^[161]

{-# LANGUAGE OverloadedStrings #-}
import Data.ByteString.Char8 as BS

-- "abc" convertit automàticament al tipus esperat
-- sempre que instancii IsString implementant ''fromString''
main = BS.putStrLn "abc"

A partir de GHC 7.8, els literals String, si hi ha l'extensió OverloadedStrings, ja no tenen tipus String, sinó que el tipus es descriu de manera existencial com un tipus d'aquells que implementen IsString

(IsString t) => t

de manera similar als literals numèrics.