Mostra la font per a Característiques del llenguatge Haskell

Característiques del [[llenguatge de programació]] [[Haskell]]

== Fonamentat en el [[càlcul lambda]] ==
El càlcul lambda es basa (entre d'altres regles) en la reducció d'expressions, per [[#reducció beta del càlcul lambda en notació Haskell|l'aplicació sistemàtica d'una funció al primer paràmetre]], obtenint una funció dels paràmetres que li manquen.

Això facilita l'ús d'aplicacions parcials (de menys paràmetres del que correspon a la seva [[aritat]]), en [[funció d'ordre superior|funcions d'ordre superior]].

<syntaxhighlight lang="Haskell">
-- (->) indica retorn
f :: a -> r -- indica el tipus d'una funció f amb paràm. de tipus 'a' que retorna un tipus 'r'
 -- els tipus en minúscula són variables, 
 -- quan es repeteix una variable de tipus en una signatura, 
 -- indica que el tipus ha de coincidir amb el de la primera posició

-- (->) és associatiu per la dreta:
-- l'aplicació parcial del primer paràmetre, retorna una funció dels paràmetres restants
(a -> b -> c) ≡ (a -> (b -> c)) 
</syntaxhighlight>

=== separació de codi funcional pur i codi amb efectes col·laterals ===
L'assignació de tipus específics al codi impur (amb efectes sobre l'entorn: ent./sort., canvis d'estat, ...) facilita la distinció del codi pur (el que només depèn dels paràmetres) per a millores de rendiment mitjançant el paral·lelisme (procés en paral·lel).

; codi pur (el resultat només depèn dels paràmetres):
:* L'ordre de les operacions és irrellevant.
:* l'ordre d'execució dels operadors en una expressió queda a discreció de l'optimitzador del compilador, per tant serà indeterminat.
<syntaxhighlight lang="haskell">
-- codi pur

f x y = (x * 2) + (y * 4)
</syntaxhighlight>

; codi impur (modifica o depèn de l'estat de l'entorn):
:* Una acció (com ara: ''getLine'') produeix un resultat. Un bloc d'accions pot expressar-se de diverses maneres.
:* L'ordre és rellevant (el resultat de la seq. d'efectes coŀlaterals depèn de l'ordre d'execució)
:* El tipus de l'acció/efecte és el de l'entorn que l'acció modifica parametritzat pel tipus del resultat
<syntaxhighlight lang="haskell">
-- codi impur

acció :: IO Int -- tipus de l'entorn, aplicat al tipus del resultat
acció = do
 putStrLn "entreu nombre enter"
 hFlush stdout
 str <- getLine -- (resultat <- acció)
 let { x = read str :: Int -- el bloc 'let' facilita definicions basades en resultats precedents
 ; y = x * 2 }
 return y -- ''return'' (o bé ''pure'') és el generador d'una acció simple 
-- que ofereix el paràmetre com a resultat en l'entorn del context
</syntaxhighlight>
Les accions es poden compondre
* per encadenament del resultat (serialització temporal)
<syntaxhighlight lang="haskell">
-- composició monàdica (>>=)
bloc :: IO ()
bloc = getLine >>= \x -> putStrLn x -- imprimeix el resultat de l'entrada
</syntaxhighlight>
* per combinació dels resultats (les accions poden ser simultànies)
<syntaxhighlight lang="haskell">
-- composició aplicativa (<*>)
bloc :: IO (String, String) -- retorna un parell de pàgines
bloc = runConcurrently $ -- fem ús de la biblio async
 (,) <$> Concurrently (getURL "url1") -- aplica el combinador (,) al resultat de la primera acció
 <*> Concurrently (getURL "url2") -- quina aplicació parcial s'aplica al resultat de l'acció següent
</syntaxhighlight>

=== separació d'especificació i execució ===
El codi d'un mòdul no s'executa en l'ordre d'especificació, sinó mitjançant l'avaluació ''no-estricta'', partint de l'expressió arrel ''main'' del mòdul ''Main'' que processa els arguments de la crida des de la consola de comandes.

==== avaluació no-estricta, normalment tardana - Thunks ====
En ''[[avaluació tardana]]'' les expressions, definides en variables i paràmetres, no es calculen quan es formulen sinó en el moment que se'n demana el valor en una altra expressió. Correspon a l'expressió anglesa ''lazy evaluation''.

Haskell és d'avaluació ''no-estricta'', que vol dir que l'avaluació va de l'arrel a les branques en l'arbre d'operacions de l'expressió. L'avaluació comença per l'expressió definida a la clàusula ''main''. En en cas de ''(b * c + a)'' primer s'avalua el ''(+)'' i després el ''(*)'', al revés dels llenguatges estrictes.<ref name="lazy_vs_non_strict">[http://www.haskell.org/haskellwiki/Lazy_vs._non-strict Haskell.org - Lazy vs. Non-strict] {{en}} Avaluació tardana i avaluació no-estricta</ref> Les altres definicions s'avaluen sota comanda (avaluació tardana). D'aquesta manera només s'avaluen les subexpressions que facin falta, estalviant càlculs.

A la pràctica Haskell no és un llenguatge purament tardà. L'encaix de patrons és, normalment, estricte —almenys s'avalua si tindrà èxit—, i un analitzador d' ''estrictesa''<ref name="haskell-is-strict">{{Ref-web |url=http://cgi.cse.unsw.edu.au/~dons/blog/2008/05/04 |títol=Haskell is a strict language |consulta=2009-10-24 |arxiuurl=https://web.archive.org/web/20091019225618/http://cgi.cse.unsw.edu.au/~dons/blog/2008/05/04 |arxiudata=2009-10-19}}</ref> determina quan un terme serà sempre requerit en les expressions, i converteix la seva avaluació en primerenca (ang.: ''eager evaluation'').<ref name="lazy_vs_non_strict"/> El programador també pot forçar l'estrictesa com s'explica [[#Avaluació estricta explícita|més avall]].

''Thunk'' és el nom de la càpsula de codi corresponent a cada expressió pendent d'avaluar.<ref name="thunk">[http://www.haskell.org/haskellwiki/Thunk HaskellWiki - Thunk]{{en}}</ref>

=== separació d'estructura i operacions (comparat amb la POO) ===
Haskell. a diferència dels lleng. amb [[orientació a objectes]] separa estructures de dades i comportament.

Els tipus de dades no impliquen operacions. Si són simples (ex.: Int, Double), defineixen el conjunt de valors, i si són compostos (tipus producte o tipus suma (unió discriminada de tipus)) defineixen l'estructura (clàusula ''data'').

Les operacions sobre el tipus poden agrupar-se en ''"classes de tipus"'', equivalents en la [[orientació a objectes]] a les interfícies, i són com mòduls abstractes parametritzats pel tipus. Per fer-ne ús cal generar una instància de la classe genèrica per al tipus concret, aportant la implementació.

<syntaxhighlight lang="Haskell">
-- signatura
class CForma t where -- parametritzada per a un tipus t
 perímetre :: t -> Double -- les variables de tipus als mètodes coincidents a la declaració de classe
 àrea :: t -> Double -- es refereixen a aquells tipus que implementin la classe.

type TCostat = Double -- ''type'' dona un àlies a una expressió de tipus

-- tipus de l'estructura, amb ''constructor'' seguit de components
data TRectangle = Rectangle TCostat TCostat -- habitualment es fa servir el mateix nom per al tipus i el constructor (són espais de noms diferents)

-- implementació de la signatura
-- generem una instància del genèric abstracte CForma per al tipus TRectangle 
-- que haurà d'estar visible en l'àmbit de les expressions que en facin ús
instance CForma TRectangle where 
 perímetre (Rectangle x y) = 2 * (x + y)
 àrea (Rectangle x y) = x * y
</syntaxhighlight>
<syntaxhighlight lang="Haskell">
{-# LANGUAGE NamedFieldPuns #-} -- sintaxi de literals de registres simplificada

data TPersona = Persona {nom::String, edat::Int}
 deriving (Eq, Show) -- demana al compilador que derivi instàncies de classes bàsiques
 -- partint de les representacions internes del tipus

-- enumeració: unió de 'constructors' d'aritat 0 (sense paràmetres)
data TLlenguatge = Lleng_FORTRAN | Lleng_JAVA | Lleng_HASKELL 
 deriving (Eq, Show, Ord, Enum)

data TProgramador = Programador { persona::TPersona, llenguatges::[TLlenguatge] } 
 deriving (Eq, Show)

class CPersona t where -- un tipus t que implementi CPersona haurà de proveir les funcions ..
 fer_anys :: t -> t

-- defineix la classe CProgramador per aquells tipus t
-- tals que (CPersona t) -- que implementin CPersona
-- requereix la visibilitat, en el context d'ús, d'una instància de CPersona per al tipus involucrat.

class (CPersona t) => CProgramador t where
 aprendre_llenguatge :: TLlenguatge -> t -> t

-- generem una instància de CPersona per al tipus TPersona implementant la signatura de la classe

-- L'operador (@) (variable @ patró), anomenat ''com el patró'', unifica la variable amb el valor encaixat al patró

-- El lligam dels literals de camps dels registres "{camp = expressió, ...}" al constructor o variable precedent
-- té major precedència que l'aplicació o que cap dels operadors, per això no cal agrupar-los entre parèntesis.

instance CPersona TPersona where
 fer_anys p @ Persona {edat} = -- {edat} equival a {edat = edat} per l'extensió NamedFieldPuns
 p {edat = edat +1} -- el primer és el nom del camp, el segon és la variable del patró.

instance CPersona TProgramador where
 fer_anys prog @ Programador {persona} =
 prog {persona = fer_anys persona}

instance CProgramador TProgramador where
 aprendre_llenguatge llenguatge_nou prog @ Programador {llenguatges} =
 if not (llenguatge_nou `elem` llenguatges)
 then prog {llenguatges = llenguatge_nou : llenguatges}
 else prog

-- valors

joan_persona = Persona { nom="Joan", edat=50}

joan_programador = Programador { persona = joan_persona, 
 llenguatges = [Lleng_FORTRAN, Lleng_JAVA] }

-- l'operador (.) de composició de funcions permet especificar la composició que s'aplicarà de dreta cap a l'esquerra
fer_més_savi = fer_anys. (aprendre_llenguatge Lleng_HASKELL) -- el punt (composició) ha d'ésser envoltat d'espais

-- l'operador (>>>) de Control.Category permet especificar la composició de funcions d'esquerra a dreta
fer_més_savi = (aprendre_llenguatge Lleng_HASKELL) >>> fer_anys

joan_més_savi = fer_més_savi joan_programador

main = print joan_més_savi
</syntaxhighlight>

Per ser un llenguatge d'[[#avaluació no-estricta, normalment tardana|avaluació no-estricta]], l'execució comença per l'avaluació de la clàusula d'engegada ''main'', calculant les expressions que calguin quan se'n demana el valor (avaluació tardana) i no quan es defineix l'expressió (optimitzacions a banda).

=== associació única de valors a identificadors ===
No es poden fer dues associacions al mateix identificador en el mateix àmbit (a nivell de mòdul, ''let'' o ''where'')

=== Composició de tipus ===
Els tipus (conjunts de valors) es poden compondre, partint dels tipus primitius i enumeracions, en tipus producte (etiquetats: els registres; anònims: les tuples) i tipus suma (cas de variants no-parametritzades: les enumeracions; variants parametritzades: unió discriminada), distingint-los amb un constructor que ens permetrà discriminar-los en l'encaix de patrons. Vegeu [[#tipus algebraics]].

Les [[#Famílies de tipus|famílies de tipus]] permeten generalitzar els tipus basant-se en un o més índexs i concretar-ne instàncies de diferent estructura.

=== Composició de comportament ===
Les classes designen la signatura (operacions) referides a variables de tipus i no a tipus concrets (com a les signatures del [[ML Estàndard]] o cas dels ''interface'' del [[Java (llenguatge de programació)|Java]] referits al tipus que els implementi). Les classes poden requerir operacions d'altres classes que cal esmentar com a requeriment de context (requeriment de visibilitat d'una instància de la classe per al tipus en el context d'ús) (en el Java s'esmentarien a les clàusules ''extends'' o bé ''implements''). Vegeu [[#Encapsulament estil O.O.]].

Els tipus poden aportar implementacions específiques de la signatura d'una classe o incorporar les implementacions per defecte definides a la classe.

No hi ha l'herència pare/fill com entre les classes de la O.O. estalviant el temps esmerçat en el despatx per taula de mètodes virtuals (''vtable'') i els conflictes de l'herència.

Les implementacions poden establir requeriments de context per a les variables de tipus, addicionals als establerts a la signatura.

Vegeu [[#modificacions per a l'especialització per instàncies (implementació)|exemple]]

=== Col·leccions heterogènies ===
Les llistes són de tipus homogenis. Per encabir elements de tipus divers per un tractament comú, cal caracteritzar-los amb un [[#Tipus existencial|tipus existencial]] que admeti components d' '''aquells tipus que implementin la interfície''' que inclogui l'operació que s'hi vol aplicar.

=== Variables ===
Haskell disposa de variables globals [[#Variables d'estat global no sincronitzades IORef|IORef]]'s similars a les ''ref'' del [[ML Estàndard]], i variables [[#encapsulament d'efectes col·laterals (amb variables d'àmbit local STRef)|STRef]]'s d'àmbit local per encapsular actualitzacions destructives.

Per al cas de sincronització blocant, Haskell fa servir com a variables de modificació sincronitzada el mecanisme de comunicació per bústies on una [[Haskell concurrent#accés sincronitzat amb variables MVar (Mutable variable)|MVar]] és una bústia d'un sol element. Les operacions sobre la bústia són posar i treure. Al retirar un element de la bústia, la gestió de memòria de l'element queda en l'àmbit del procés que l'obté. Per consultar-ne el contingut l'has de treure, deixant la bústia buida. Per al cas de comunicació amb encuament, [[Haskell concurrent#bústies de comunicació amb MVar, Chan, BoundedChan|Chan i BoundedChan]] són bústies amb encuament i blocatge.

Per la concurrència amb ''memòria transaccional per programari'' (STM), hi ha les variables transaccionals [[Haskell concurrent#memòria transaccional: variables TVar, i bústies amb TMVar i TChan|TVar, TMVar (MVar's protegides per transaccions) i bústies TChan]].

=== Efectes col·laterals ===
Una acció amb efecte (un canvi) pot produir, a més, un resultat computable (per ex. l'entrada de consola: ''<code>getline</code>''). El tipus de l'efecte vindrà parametritzat pel tipus del resultat.

El més emprat és l'efecte global IO (engloba entrada/sortida, variables globals IORef's i tractament d'excepcions) i el tipus d'una acció d'efecte global serà <code>(IO tipusDelResultat)</code>.

Vegeu [[#Efectes]]

=== Composició d'efectes ===
Per a les mònades vegeu [[Mònada (programació funcional)#Transformadors de mònades|Transformadors de mònades]].

L'equivalent per a les [[Fletxa (programació funcional)|fletxes]] són els ''Arrow Functors''. Vegeu doc. "Generalizing Monads to Arrows".<ref name="generalizing">[http://www.cse.chalmers.se/~rjmh/Papers/arrows.pdf Generalising Monads to Arrows]{{en}}</ref>

== Lèxic ==
=== Identificadors ===
Un identificador consisteix en una lletra seguida de zero o més {lletra, dígit, guió baix, o bé apòstrof}. L'especificació no fa esment de límits en la llargada dels identificadors.<ref>[https://www.haskell.org/definition/haskell2010.pdf Haskell 2010]{{en}} Secció 2.4 Identifiers and Operators</ref>

Haskell98 admet caràcters no anglosaxons als identificadors segons la codificació [[Unicode]].<ref>[http://www.haskell.org/onlinereport/lexemes.html Estructura lèxica del Haskell98] {{en}}</ref> S'admeten caràcters accentuats, la ç, l'apòstrof, el caràcter l· ([[ela geminada]]), si el podeu compondre ([[AltGr]]+L al [[Linux]]), però no el [[punt volat]] (ang:''mid dot'') (·) considerat com a separador.

L'apòstrof també pot formar part del nom, per a un ús amb estil matemàtic <pre>v, v', v''</pre>, però també com a part interna d'un identificador.

A l'intèrpret GHCi sobre Linux/Ubuntu amb LANG=ca_ES.UTF-8:
<syntaxhighlight lang="bash">
 ghci # a l'intèrpret les definicions van precedides de ''let''
 # igual que al codi dins els blocs ''do''
 # distingint-les de les expressions a avaluar
 # Si la versió < 7.4, no admet declaracions de tipus (cal carregar-les d'un fitxer).
 # Ajuda teclejant '':help''

 Prelude> let alçada = 1.5
 Prelude> alçada
 1.5
 Prelude> let opinió = 2
 Prelude> let funcPrima' x = x +1
 Prelude> let l'internauta=123
 Prelude> let {funcSegona'' :: Int -> Int; funcSegona'' x = x * 2}
 Prelude> let col·legi = "abc" -- amb ela geminada Unicode (AltGr+l al Linux)
</syntaxhighlight>

La [[pragma]] {-# LANGUAGE UnicodeSyntax #-} permet la substitució de determinades seqüències per caràcters Unicode equivalents.<ref>[http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#unicode-syntax Extensió UnicodeSyntax] {{Webarchive|url=https://web.archive.org/web/20051129140339/http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#unicode-syntax |date=2005-11-29}}{{en}}</ref>

;ent/sort. amb caràcters no anglosaxons: A partir de la versió 6.12.1, el compilador GHC incorporarà la codificació de caràcters del sistema subjacent per al tractament d'ent./sort. de les tires de caràcters.
:Si no disposem d'aquesta versió podem tractar fitxers [[UTF-8]] amb el paquet ''utf8-string''.

=== Grafia ===
==== començant per lletra ====
* cas de primera lletra minúscula, indica ''variable'' (de valor o de tipus segons el context)
* cas de primera lletra majúscula, indica ''constructor'' (de valor o de tipus segons el context)

==== començant per símbol ====
; cas de guió baix:
* patró comodí '_': patró irrefutable quin valor encaixat no interessa per al càlcul
* patró comodí amb identificador ''_abc123'' : quan una variable no es fa servir però s'hi manté per documentar, el guió baix precedint la variable no utilitzada evita que el compilador mostri un missatge d'atenció (''Warning'') per inútil.<ref>[http://www.haskell.org/onlinereport/haskell2010/haskellch2.html#x7-180002.4 H2010 - Identificadors i variables]{{en}}</ref>
; començant per '' ':' '' (caràcter dos-punts) : constructors no alfanumèrics binaris definits per a ser emprats en posició [[infix]] segons la definició de sintaxi del Haskell,<ref>[https://www.haskell.org/onlinereport/haskell2010/haskellch2.html#x7-180002.4 Sintaxi H2010]{{en}} La producció ''consym'' distingeix com a constructors aquells símbols que comencen per ':' mentre que la ''varsym'' exceptua els que comencen pel mateix caràcter.</ref><ref>[https://www.haskell.org/definition/haskell2010.pdf Haskell 2010]{{en}} La producció consym està continguda en la qop dels operadors binaris infix (secció 3.4 Operator Applications)</ref> per exemple:<blockquote>
* (:) constructor ''cons'' de llistes (ex.: cap : cua)
* (:+) constructor de nombres complexos (ex.: part_real :+ part_imag)
* (:.) constructor de dimensions i d'índexs per a vectors pluridimensionals (ex.matriu 3x3: (Z:. 3 :. 3)) al paquet Repa
</blockquote>
; començant per '?': variables que es passen com a [[#Àmbit dinàmic - paràmetres implícits|paràmetres implícits]] (associables a l'àmbit de la funció que ha fet la crida, semblant al pas de paràmetres per referència del [[llenguatge C|lleng. C]]) amb l'extensió ImplicitParams<ref>[https://wiki.haskell.org/Implicit_parameters haskellWiki - Implicit parameters]{{en}}</ref>
; començant per altres símbols: operadors

== Sintaxi ==
Vegeu. produccions sintàctiques del Haskell2010.<ref>[http://www.haskell.org/onlinereport/haskell2010/haskellch10.html#x17-17500010 Referència de sintaxi de Haskell2010]{{en}}</ref>

=== comentaris ===
<syntaxhighlight lang="Haskell">
 {-
 comentari multilínia
 {- comentari niuat
 -}
 -}
 -- comentari fins a fi de línia
</syntaxhighlight>

==== comentaris d'autodocumentació ====
Comentaris<ref>[http://www.haskell.org/haddock/doc/html/markup.html Haddock - Com documentar]{{en}}</ref> per ésser extractats a un resum mitjançant el programa ''haddock''<ref>[http://www.haskell.org/haddock/doc/html/invoking.html Invocant Haddock - opcions]{{en}}</ref> amb comentaris de blocs entre delimitadors <code>{-| -}</code> i comentaris de línia precedits per <code>-- <comanda></code>

Els comentaris admeten llenguatge de marcatge (els delimitadors en determinen el tractament):
<pre>
'identificador_enllaçat' 
/èmfasi/ 
__ressaltat__ 
@monoespaiat@ 
<http://domini.com/camí-al-document etiqueta de la URL>
<<fitxer_imatge.png etiqueta de la imatge>>
</pre>

<syntaxhighlight lang="Haskell">
{-|
Module : W
Description : Short description
Copyright : (c) Some Guy, 2013
 Someone Else, 2014
License : GPL-3
Maintainer : sample@email.com
Stability : experimental
Portability : POSIX

Descripció llarga del mòdul que pot contenir llenguatge de marcatge.
-}
module W where

-- == capçalera html h2
-- === capçalera html h3

{-| documentació en bloc que precedeix una declaració
-}

-- | documentació en línies que precedeix una declaració
-- continuació de la documentació

arrel2 = sqrt -- ^ documentació a posteriori

-- ^ documentació a posteriori, referida a la definició precedent
</syntaxhighlight>

* invocació per generar documentació (per la sortida en ''html'': opció -h):
<syntaxhighlight lang="bash">
haddock -h fitxers.hs -o docdir
</syntaxhighlight>
En el cas molt probable que hi hagi símbols enllaçats definits en altres paquets
sortiran missatges de manca d'enllaç amb la documentació dels altres paquets

 "Warning: Haddock could not find link destinations for ..(paquets)"

Per evitar-los cal generar enllaços a la doc. dels altres paquets, esmentant per cada paquet l'opció
--read-interface (-i) amb el camí de la doc i el fitxer d'interfície "haddock" (extensió: .haddock)
(que es pot generar amb l'opció --dump-interface) per exemple:

 -i /usr/share/doc/ghc6-doc/html/libraries/base-4.2.0.0,/usr/lib/ghc-6.12.1/haddock/base-4.2.0.0/base.haddock

=== Espais de noms ===
Hi ha sis menes de noms que constitueixen espais independents (es pot fer servir el mateix identificador per al que convingui en cada espai)<ref name="h2010-namespaces">[https://www.haskell.org/definition/haskell2010.pdf Haskell 2010]{{en}} Secció 1.4 Namespaces</ref>

* variables
* constructors de dades (els de la dreta de l'assignació en una instrucció ''data'')
* variables de tipus
* noms (constructors) de tipus
* noms de classes de tipus
* noms de mòdul

Un mateix identificador no pot ser emprat com a constructor de tipus i com a classe en el mateix àmbit.<ref name="h2010-namespaces"/>

Exemples de possible confusió:

* L'identificador ''ArithException'' és un constructor (dins el tipus Exception de H98) i també un nom de tipus ArithException

Vegeu-ho [[#tipus suma|aquí]]

És habitual fer coincidir el nom del tipus i el del constructor, en una clàusula ''data'' d'un únic constructor, o bé en una clàusula ''newtype''.

=== definició de blocs ===
De dues maneres possibles:

<ol>
<li>La compacta, blocs definits per claus {} i separant les instruccions per punt-i-coma
<syntaxhighlight lang="haskell">
class Eq t where { (==) :: t -> t -> Bool ; (/=) :: t -> t -> Bool }

-- a l'intèrpret ghci
Prelude> let { incr :: Int -> Int ; incr x = x + 1}
</syntaxhighlight>
</li>
<li>L'elegant, blocs definits per la profunditat del [[sagnat]] (marge esquerre).<ref>[http://dlc.iec.cat/results.asp?txtEntrada=sagnat IEC.DLC - Sagnat]</ref> Els punt-i-coma al final de línia es poden estalviar. Substituint les claus '{', '}' de l'exemple anterior per salts de línia amb augment o disminució del sagnat:
<syntaxhighlight lang="haskell">
class Eq t where
 (==) :: t -> t -> Bool
 (/=) :: t -> t -> Bool

-- a l'intèrpret ghci, amb el mode multilínia :{ :}
Prelude> :{
Prelude| let incr :: Int -> Int
Prelude| incr x = x + 1 -- cal alinear els blocs 'let' al primer identificador
Prelude| :}
Prelude>
</syntaxhighlight>
</li>
</ol>
Per fer macros de CPP convé fer servir la sintaxi de claus, doncs les macros no generen salts de línia.

=== Funcions binàries en posició [[infix]] en expressions ===
Qualsevol funció de dos o més operands es pot emprar en posició ''infix'' (entremig) si posem el seu nom entre cometes revesses entre el primer i el segon, fetes amb la tecla de l'accent greu seguida de la tecla espai. En anglès s'hi refereixen per ''backquotes''
<syntaxhighlight lang="Haskell">
 afegint x y = x + y

 valor = 4 `afegint` 3 -- l'ús com a operador infix li atorga característiques dels operadors.
 -- per defecte: associativitat per l'esquerre i precedència màxima
</syntaxhighlight>

Els noms en infix admeten declaracions d'associativitat i precedència, per defecte màxima precedència i associativitat per l'esquerre. Els noms d'operacions habituals usats en infix que no tenen altre operador (`div`, `mod`, ...) tenen assignades l'associativitat i precedència del grup d'operacions al qual pertanyen.<ref name="precedencies">[http://www.haskell.org/onlinereport/decls.html#sect4.4.2 Fixity declarations]{{en}} Precedències i associativitat dels operadors</ref>

=== operadors d'aplicació ($) i (&) ===
L'operador d'aplicació ($) és molt freqüent i estalvia parèntesis en aplicar una funció a una expressió de més d'un terme.
* excepte quan el paràmetre és una funció polimòrfica sense declaració de tipus, perquè ($) és una funció amb [[Polimorfisme (programació)|polimorfisme]] de rang 1 i no admet funcions polimòrfiques com a paràmetres, com s'explica a la ref.<ref name="dolar_i_monomorfisme">[http://hackage.haskell.org/package/Takusen-0.8.7/docs/Database-Enumerator.html#g:4 Rank-2 types, ($), and the monomorphism restriction] {{en}}</ref>

* ($) té la menor de les precedències dels operadors i associativitat per la dreta.<ref name="precedencies"/>

<syntaxhighlight lang="Haskell">
f $ x ≡ f x -- ($) infixr 0

f $ g z $ x + y ≡ f (g z (x + y)) -- excepte si g no té declaració de tipus
</syntaxhighlight>

Quan el nombre d'aplicacions amb ($) passa de dues es complica copsar el sentit de l'expressió i és preferible utilitzar l'aplicació cap enrere (&amp;) obtenint un estil de navegació de dades.

<syntaxhighlight lang="Haskell">
import Data.Function ((&)) -- aplic. cap enrere, des de GHC 7.10.1

-- x & f ≡ f x -- associativitat i precedència: (infixl 1)

-- imprimir els dobles dels parells de llista amb aplicació cap enrere (&)
v = llista & filter ésParell -- filtra
 & map doblar -- aplica funció als elements
 & show -- textualitza a String
 & putStrLn -- imprimeix a consola

-- (&) té major precedència que ($) que és (infixr 0): x & f $ y ≡ (x & f) $ y
-- a ghci:
Prelude Data.Function> 2 & (/) $ 4 -- ≡ (/) 2 4
0.5
</syntaxhighlight>

* Hi ha un altre ús de [[Compilador Haskell de Glasgow#Avaluació en temps de compilació|$ com a prefix a GHC]] (prefixant l'identificador com ''$identif'', o bé prefixant el parèntesi com ''$(expr)'') per avaluar un identificador o bé una expressió '''en temps de compilació'''.

== Tipus i classes ==
El tipus indica únicament el domini.

Les classes de tipus designen un grup d'operacions que un tipus pot implementar. La paraula reservada ''class'' introdueix un mòdul genèric de signatures d'operacions, indexat pel paràmetre de tipus, amb possible implementació per defecte de les operacions.

Les classes de tipus només poden contenir signatures i implementacions de funcions que facin ús del paràmetre de la classe.

Les classes de tipus s'assemblen als mòduls genèrics de l'[[Ada (llenguatge de programació)|Ada]] amb un paràmetre de tipus, amb l'exclusió de tot allò que no faci ús del paràmetre de tipus del genèric (la classe); també es poden assimilar als ''Interface'' de [[Java (llenguatge de programació)|Java]] assimilant el paràmetre de tipus al tipus de l'objecte Java que els ha d'implementar.

<syntaxhighlight lang="haskell">
class Eq t where
 (==) :: t -> t -> Bool
 (/=) :: t -> t -> Bool

 -- implementació per defecte
 x /= y = not (x == y)
 x == y = not (x /= y)
 -- estan definides circularment, caldrà implementar-ne només una, en definir-ne una instància

 {-# MINIMAL (==) | (/=) #-} -- indicació de quins mètodes cal implementar com a mínim
</syntaxhighlight>

=== classes i clàusula ''deriving'' ===
La clàusula ''deriving'' demana al compilador que derivi instàncies (implementacions)<ref>[http://www.haskell.org/tutorial/stdclasses.html#sect8.4 Guia de classes estàndards - Instàncies derivades ] {{en}}</ref><ref>[http://www.haskell.org/onlinereport/derived.html Instàncies derivades - especificació] {{en}}</ref> de classes bàsiques<ref name="prelude98">[http://www.haskell.org/onlinereport/prelude-index.html Prelude del H98 (Predefinits)]{{en}} La majoria de les classes instanciables amb la clàusula ''deriving'' són aquí</ref> a partir de les representacions internes dels tipus. Aquestes classes són:

{| class=wikitable
|-
! classe !! requeriment<br/>de context<br/><span style="font-weight:normal;">(requereix visibilitat d'instàncies<br/>de les classes esmentades<br/>en l'àmbit d'ús)</span>!! descripció !! operacions afegides
|-
| Eq α<ref name="data-eq">[http://hackage.haskell.org/package/base/docs/Data-Eq.html Data.Eq]{{en}}</ref> || || Igualable || (==) (/=)
|-
| Ord α<ref name="data-ord">[http://hackage.haskell.org/package/base/docs/Data-Ord.html Data.Ord]{{en}}</ref> || Eq α || Ordenable || (<), (<=), ..., (''compare'': amb resultat ternari ''Ordering''), (''max''), (''min'')
|-
| Enum α<ref name="data-enum">[http://hackage.haskell.org/package/base/docs/Prelude.html#t:Enum Prelude#Enum]{{en}}</ref> || || Enumerable || (''succ'': successor) (''pred'': predecessor)<br/> (''fromEnum α'': enter ordinal corresponent)<br/>(''toEnum n :: TipusEnumerat'': enumerat corresponent a l'enter ordinal, la restricció de tipus indica el domini, defineix una [[Successió (matemàtiques)|Successió]])
|-
| Bounded α<ref name="data-bounded">[http://hackage.haskell.org/package/base/docs/Prelude.html#t:Bounded Prelude#Bounded]{{en}}</ref> || || Acotat || (''minBound''::TipusAcotat: cota inferior, la restricció de tipus indica el domini) (''maxBound''::TipusAcotat: cota superior)
|-
| Ix α<ref name="data-ix">[http://hackage.haskell.org/package/base/docs/Data-Ix.html Data.Ix - classe dels índexs] {{en}}</ref> || Ord α || Indexador || (''index'': índex basat en 0), (''inRange''), (''rangeSize''), (''range'': llista compresos)
|}

Classes {Show, Read} per la representació textual de dades numèriques:

{| class=wikitable
|-
! classe !! descripció !! operacions
|-
| Show α<ref name="text-show">[http://hackage.haskell.org/package/base/docs/Text-Show.html Text.Show]{{en}}</ref> || Textualitzable a String || (''show''), (''showList''), (''showsPrec'').
|-
| Read α<ref name="text-read">[http://hackage.haskell.org/package/base/docs/Text-Read.html Text.Read]{{en}}</ref> || Llegible des de String || (''readList''), (''readsPrec'')
|}

* Els caràcters no [[ASCII]] (quina repr. depèn de la codificació) en un tipus String es mostren amb un codi numèric:
<syntaxhighlight lang="bash">
$ ghci
Prelude> "alçada" -- sortida via 'show'
"al\231ada"
Prelude> putStrLn "alçada" -- sortida via System.IO (codificada segons el sistema subjacent)
alçada
</syntaxhighlight>

* Per la manipulació de texts no anglosaxona, cal fer servir el tipus Text del paquet del mateix nom (encapsula un vector de caràcters codificat segons [[UTF-16]]).<ref>[http://hackage.haskell.org/package/text/docs/Data-Text-Internal.html Data.Text.Internal] Internally, the Text type is represented as an array of Word16 UTF-16 code units.</ref>

* el mòdul ''Numèric'' proporciona un ventall més ampli de conversions entre text i nombres.<ref name="numeric">[http://hackage.haskell.org/package/base/docs/Numeric.html Numeric]{{en}}</ref>

Classes de tipus numèrics:

{| class=wikitable
|-
! classe !! requeriment<br/>de context !! descripció !! operacions afegides
|-
| Num α<ref name="data-num">[http://hackage.haskell.org/package/base/docs/Prelude.html#t:Num Prelude#Num]{{en}}</ref> || || Numèric, estructura d'[[Anell (matemàtiques)|Anell unitari]] ||op. binaris: (+), (-), (*)<br/>literals elements neutres: 0, 1<br/>op. unaris: (negate: invers de la suma), (abs), (signum: retorna {-1,0,1});<br/>llei: {<code>abs x * signum x == x</code>}<br/>(fromInteger: per decodificar literals enters o convertir de precisió il·limitada) 
|-
| Bits α<ref name="data-bits">[http://hackage.haskell.org/package/base/docs/Data-Bits.html Data.Bits]{{en}}</ref> || Num α || Adreçable als bits || (.&. :[[i]]), (.<nowiki>|</nowiki>. :[[o]]), ''xor'', ''complement'',<br/>''shift'', ''rotate'', ...
|-
| Real α<ref name="data-real">[http://hackage.haskell.org/package/base/docs/Prelude.html#t:Real Prelude#Real]{{en}}</ref> || (Num α, Ord α) || Estructura d'[[Anell (matemàtiques)|Anell unitari]] [[anell ordenat|ordenat]] || (''toRational'': obtenció de l'aproximat [[Nombre racional|Racional]],<br/>ex.: toRational $ sqrt 2)
|-
| Integral α<ref name="data-integral">[http://hackage.haskell.org/package/base/docs/Prelude.html#t:Integral Prelude#Integral]{{en}}</ref> || (Real α, Enum α) || [[Anell íntegre|Íntegre]]; Estructura d'[[Anell (matemàtiques)|Anell unitari]] [[Anell ordenat|ordenat]] i [[Anell euclidià|euclidià]] || {(div), (mod), (divMod)} -- divisió partint cap a menys infinit [[divisió euclidiana|euclidiana]]<br/>{(quot: quocient), (rem: romanent), (quotRem)} -- divisió partint cap a zero [[divisió euclidiana|NO euclidiana]] <br/>(toInteger: a sencer de precisió il·limitada)
|-
|}

* Classes per al suport de racionals i reals.

{| class=wikitable
|-
! classe !! requeriment<br/>de context !! descripció !! operacions afegides
|-
| Fractional α<ref name="data-fractional">[http://hackage.haskell.org/package/base/docs/Prelude.html#t:Fractional Prelude#Fractional]{{en}}</ref> || Num α || Fraccionable<br/>([[Cos (matemàtiques)|estructura de cos]]) || (''recip'': recíproc, invers del producte), (/),<br/>(fromRational: per decodificar literals amb part decimal o convertir de racionals de precisió il·limitada)
|-
| RealFrac α<ref name="data-realfrac">[http://hackage.haskell.org/package/base/docs/Prelude.html#t:RealFrac Prelude#RealFrac]{{en}}</ref> || (Real α, Fractional α) || [[Cos (matemàtiques)|estructura de cos]] ordenat /<br/> info sobre fraccions|| (''truncate''), (''round''),<br/> (''ceiling'': (sostre) menor sencer superior), (''floor'': (terra) major sencer inferior),<br/>(''properFraction'': [[fracció pròpia]])
|-
| Floating α<ref name="data-floating">[http://hackage.haskell.org/package/base/docs/Prelude.html#t:Floating Prelude#Floating]{{en}}</ref> || Fractional α || [[Cos (matemàtiques)|estructura de cos]] <br/>amb càlculs en [[coma flotant]], logaritmes i trigonometria || (sqrt), (**: exponenciació), (exp), (log: logaritme natural), (logBase), <br/>(pi), (sin), (cos), (tan), (asin), (sinh), (asinh), ...
|-
| RealFloat α<ref name="data-realfloat">[http://hackage.haskell.org/package/base/docs/Prelude.html#t:RealFloat Prelude#RealFloat]{{en}}</ref> || (RealFrac α, Floating α) || [[Cos (matemàtiques)|estructura de cos]] ordenat /<br/> info dels reals en coma flotant|| (''significand'': signe * valor de la [[mantissa]] (interval obert ''[0.5 .. 1)'')),<br/>(''exponent'': segons l'equació: r == (significand r) * (2 ^^ (exponent r)));<br/>1 == 0.1<sub>base_2</sub> * 2^^1 <br/>-- no correspon a l'exponent de la notació científica!!<br/> (''isNaN'': és No-Numèric?), (''isInfinite'': resultat de sobreiximent?),<br/> (''isDenormalized'': és nombre subnormal (d'exponent inferior al mínim)?), ...
|}

Les operacions dels racionals, per la seva especificitat, no estan definides com a classe. Són en un mòdul a banda.<ref name="data-ratio">[http://hackage.haskell.org/package/base/docs/Data-Ratio.html Data.Ratio]{{en}}</ref> El tipus està parametritzat pel tipus dels components del parell (numerador, denominador).

* (Ratio ''a''): Ops. dels racionals: (''%'': op. generador) (numerator), (denominator), ..

Els reals de [[Coma fixa]] estan definits al mòdul Data.Fixed<ref name="data-fixed">[http://hackage.haskell.org/package/base/docs/Data-Fixed.html Data.Fixed - reals de coma fixa]{{en}}</ref>

[[Compilador Haskell de Glasgow|GHC]] estén el mecanisme de derivació d'instàncies a algunes classes més. Vegeu ref.<ref>[http://haskell.org/ghc/docs/latest/html/users_guide/deriving.html GHC - Extensions a la clàusula ''deriving''] {{Webarchive|url=https://web.archive.org/web/20100410074050/http://www.haskell.org/ghc/docs/latest/html/users_guide/deriving.html |date=2010-04-10}}{{en}}</ref>

==== Tipus ====
{| class=wikitable
|+ bàsics
|-
! tipus !! constructors / =expr !! mòdul !! descripció
|-
| () -- Unit<br/>-- tipus d'un únic valor || () || Prelude || resultat buit en efectes col·laterals (ex.: print "abc" :: IO ())<br/>equival al "void" o buit del llenguatge C
|-
| Bool<ref name="data-bool">[http://hackage.haskell.org/package/base/docs/Data-Bool.html Data.Bool]{{en}}</ref> || True <nowiki>|</nowiki> False || Data.Bool || [[Àlgebra de Boole|Nombres ''booleans'']] (Cert <nowiki>|</nowiki> Fals)
|-
| Ordering<ref name="data-ord"/> || LT <nowiki>|</nowiki> EQ <nowiki>|</nowiki> GT || Data.Ord || (Menor <nowiki>|</nowiki> Igual <nowiki>|</nowiki> Major) resultat ternari de ''(compare)''
|-
| Char<ref name="data-char">[http://hackage.haskell.org/package/base/docs/Data-Char.html Data.Char]{{en}}</ref> || || Data.Char || caràcters de 32 bits<br/>amb codificació [[Unicode]]
|-
| String<ref name="data-string">[http://hackage.haskell.org/package/base/docs/Data-String.html Data.String]{{en}}</ref> || = [Char] || Data.Char<br/>Data.String || llista de caràcters
|}

El tipus String no és el millor per al tractament de text: ''show string'' mostra els caràcters no anglosaxons imprimint el codi numèric, cosa que s'utilitza per a la serialització de dades i la seva recuperació gràcies a la representació unívoca independent de la codificació. Les ops. d'Entrada/sortida sí que n'ofereixen la representació segons la codificació del sistema subjacent.

El tipus Text del paquet ''text''<ref>[https://hackage.haskell.org/package/text El paquet ''text'']{{en}}</ref> (ve amb les biblios de la Plataforma Haskell), està implementat com a vector de caràcters [[UTF-16]] i té millor suport per la manipulació de textos i l'entrada/sortida que es mostra segons la codificació del sistema subjacent.

{| class=wikitable
|+ numèrics
|-
! tipus !! requeriment<br/>de context !! constructors / =expr !! mòdul !! descripció
|-
| Int, Int&lt;N&gt; N∈{8,16,32,64}<ref name="data-int">[http://hackage.haskell.org/package/base/docs/Data-Int.html Data.Int]{{en}}</ref> || || || Data.Int || [[Nombre enter|Sencers]] (aritmètica del "[[Complement a dos]]")<br/>(cas de Int: rang mínim [-2^29 .. 2^29-1])<ref>[https://www.haskell.org/onlinereport/haskell2010/haskellch18.html#x26-22300018 Haskell2010 - Especificació dels enters]{{en}}</ref>
|-
| Word, Word&lt;N&gt; N∈{8,16,32,64}<ref name="data-word">[http://hackage.haskell.org/package/base/docs/Data-Word.html Data.Word]{{en}}</ref> || || || Data.Word || Paraula de bits: Adreça de memòria o valor [[Nombre natural|natural]], segons amplada paraula ordinador, ([[aritmètica modular]], mòdul 2^nombre_de_bits)<br/>-- cas concret: op. (negate) vàlida (Word instancia Num); al ghci:<br/>Prelude&gt; Numeric.showHex (-(2::Word)) ""<br/>"fffffffffffffffe"
|-
| Integer || || || Prelude || Sencer de precisió il·limitada
|-
| Natural<ref>[http://hackage.haskell.org/package/base/docs/Numeric-Natural.html Numeric.Natural]{{en}}</ref> || || || Numeric.Natural || Natural de precisió il·limitada<br/>-- cas curiós: op. (negate) vàlida (Natural instancia Num); al ghci:<br/>Prelude Numeric.Natural&gt; -(10::Natural)<br/>*** Exception: arithmetic underflow
|-
| Float, Double || || || Prelude || [[Coma flotant]]
|-
| Ratio t<ref name="data-ratio"/> || Integral t || Generador: (%)<br/><code>numerador&nbsp;%&nbsp;denominador</code> || Data.Ratio || Racionals genèrics ''(t * t)'': parells (numerador, denom.), <br/> per a tipus t amb estructura d'[[anell íntegre]] [[anell euclidià|euclidià]]<ref>[https://hackage.haskell.org/package/base/docs/Data-Ratio.html mòdul Data.Ratio]{{en}}</ref>
|-
| Rational<ref name="data-ratio"/> || || = Ratio Integer || Data.Ratio || Racionals ''(Integer * Integer)''
|-
| Uni, Deci, Centi,<br/>Milli, Micro,<br/>Nano, Pico<ref name="data-fixed"/> || || || Data.Fixed || [[Coma fixa]] de representació sencera<br/> valor = representació * resolució del tipus
|-
| Complex t<ref name="data-complex">[http://hackage.haskell.org/package/base/docs/Data-Complex.html Data.Complex]{{en}}</ref> || RealFloat t || = !t :+ !t || Data.Complex || amb constructor [[infix]] (:+)<br/>i prefix '!' d'avaluació estricta als components
|}

{| class=wikitable
|+ efectes
|-
! tipus !! requeriment<br/>de context !! constructors / =expr !! mòdul !! descripció
|-
| Maybe<code> t</code> || || Nothing <nowiki>|</nowiki> Just x || Data.Maybe || * efecte fallada (resultat opcional en operacions parcialment definides) <br/> * paràm. opcionals
|-
| Either <code>tipError tipResultat</code> || || Left error <nowiki>|</nowiki> Right resultat || Data.Either || * efecte fallada amb indicació de l'error <br/> * paràm. dual ''Right'' (dreta o correcte) o ''Left'' (esquerre o mancat) <br/> * Èxit o fracàs de l'avaluació amb ''try''<br/>de codi que pot llançar excepcions<br/>capturant l'excepció que retorna amb Left o el resultat amb Right.
|-
| [] <code>tipElement</code> || || [], (x : xs), [x], [1,2,3], [1..7], <br/>[1,3..7] (==[1,3,5,7])<br/>-- llistes infinites: <br/>[1..], [1,3..] || Data.List || * llistes <br/> * efecte múltiple (resultat múltiple en operacions)
|-
| IO <code>tipResultat</code> || || || System.IO,<br/>Data.IORef,<br/>Control.Exception || * operacions d'entrada/sortida,<br/> * lectura/escriptura de variables globals IORef (cicle de vida no acotat),<br/> * tractament d'excepcions.
|-
| ST s <code>tipResultat</code> || || || Data.STRef<br/>Control.Monad.ST || * lectura/escriptura de variables amb vida limitada a un àmbit<br/>* encapsulament d'actualitzacions destructives de les variables STRef<br/>avaluables en un espai ''s'' local (runST) o bé global (stToIO) 
|}

{| class=wikitable
|+ excepcions
|-
! tipus !! requeriment<br/>de context !! constructors / =expr !! mòdul !! descripció
|-
| IOError || || || System.IO.Error || Excepció en expressions IO
|-
| Exception || || || Control.OldException || tipus algebraic d'error del Haskell98<br/>obsolet—la nova classe Exception permet construir<br/>excepcions amb tipus definits per l'usuari.
|-
| SomeException || Exception e || SomeException e || Control.Exception || nou tipus genèric de les excepcions<br/>definit existencialment com<br/>un tipus d'aquells que implementen la classe Exception
|}

{| class=wikitable
|+ altres
|-
! tipus !! constructors / exemples !! mòdul !! descripció
|-
| <code>(t1,t2,...,tn)</code> || (,) t1 t2<br/>(,,) t1 t2 t3<br/>(,,...,) t1 t2 .. tn|| Data.Tuple || tipus producte anònim (tupla)
|-
| rowspan=4 | ''data'' nomDeTipus || Constructor t1 t2 .. tn<br/>deriving &lt;classes a instanciar automàticament&gt; || || tipus producte amb nom<br/>la clàusula "deriving (Eq, Show, ..)"<br/>demana al compilador que generi instàncies de les classes bàsiques esmentades partint de la representació interna
|-
| Dl <nowiki>|</nowiki> Dt <nowiki>|</nowiki> Dc <nowiki>|</nowiki> Dj <nowiki>|</nowiki> Dv <nowiki>|</nowiki> Ds <nowiki>|</nowiki> Dg ''deriving'' (Eq, Show, Ord, Enum, Bounded) || || Enumeració (de constructors d'[[aritat]] 0)
|-
| Constructor1 t11 t12 .. t1n <br/><nowiki>|</nowiki> Constructor2 t21 t22 .. t2m<br/><nowiki>|</nowiki> ... deriving ... || || tipus suma (Unió discriminada)
|-
| Constructor {camp1 :: t1, camp2,camp3 :: t2i3, ...} || || Registres (tipus producte amb accessors)
|-
| <code>''newtype'' nomDeTipusDerivat</code> || Constructor nomDeTipusBase ''deriving'' &lt;classes preservades&gt;<br/>o bé: Constructor {accessor :: nomDeTipusBase} ''deriving'' ... || || tipus derivats d'un tipus base,<br/> * el Constructor constitueix un morfisme del tipus base al derivat,<br/> mantenint l'estructura de les classes esmentades a la clàusula ''deriving''<br/>quines instàncies hereta el tipus derivat<br/>* l'accessor, si hi és, constitueix el morfisme invers del Constructor
|}

* classes que implementen (a banda de Eq,<ref name="data-eq"/> Show<ref name="text-show"/> i Read)<ref name="text-read"/>

{| class=wikitable style="text-align:center"
|+ bàsics
|-
! !! Ord!!<ref name="data-ord"/> Enum!!<ref name="data-enum"/> Ix!!<ref name="data-ix"/> Bounded<ref name="data-bounded"/>
|-
| || ordenable || enumerable || indexador || acotat
|-
| () -- Unit<br/>-- equival al ''void'' del C || {{cel·la sí}} || {{cel·la sí}} || {{cel·la sí}} || {{cel·la sí}}
|-
| Bool || {{cel·la sí}} || {{cel·la sí}} || {{cel·la sí}} || {{cel·la sí}}
|-
| Ordering || {{cel·la sí}} || {{cel·la sí}} || {{cel·la sí}} || {{cel·la sí}}
|-
| Char || {{cel·la sí}} || {{cel·la sí}} || {{cel·la sí}} || {{cel·la sí}}
|}

{| class=wikitable style="text-align:center"
|+ numèrics
|-
! !! Ord!!<ref name="data-ord"/> Enum!!<ref name="data-enum"/> Ix!!<ref name="data-ix"/> Bounded!!<ref name="data-bounded"/> Num!!<ref name="data-num"/> Bits!!<ref name="data-bits"/> Real!!<ref name="data-real"/> Integral!!<ref name="data-integral"/> Fractional!!<ref name="data-fractional"/> RealFrac!!<ref name="data-realfrac"/> Floating!!<ref name="data-floating"/> RealFloat<ref name="data-realfloat"/>
|-
| requereix || Eq || || Ord || || || Num || Num, Ord || Real, Enum || Num || Real, Fractional || Fractional || RealFrac, Floating
|-
| descripció || ordenable || enumerable || indexador || acotat || Numèric || adreçable<br/>als bits || Real || [[Anell íntegre|íntegre]] amb [[divisió euclidiana]] || fraccionable || infos. de<br/>fraccionables || càlculs i<br/>trigonometria || infos. de<br/>[[coma&nbsp;flotant]]
|-
| estructura || [[ordre total]] || [[Successió (matemàtiques)|Successió]] || [[Successió (matemàtiques)|Successió]] || [[Ordre_total#Ordres_totals_finits|Ordre total finit]] || [[Anell (matemàtiques)|anell unitari]] || vector de bits || [[Anell ordenat|anell unitari ordenat]] || [[Anell euclidià|anell unitari ordenat euclidià]] || [[Cos (matemàtiques)|estructura algebraica de cos]] || estruct. de cos ordenat || estruct. de cos || estruct. de cos ordenat
|-
| Int, Int&lt;N&gt;<br/>aritmètica del<br/>[[complement a dos]] || {{cel·la sí}} || {{cel·la sí}} || {{cel·la sí}} || {{cel·la sí}} || {{cel·la sí}} || {{cel·la sí}} || {{cel·la sí}} || {{cel·la sí}} || colspan=4 {{cel·la no}}
|-
| Word, Word&lt;N&gt;<br/>[[aritmètica modular]] || {{cel·la sí}} || {{cel·la sí}} || {{cel·la sí}} || {{cel·la sí}} || {{cel·la sí}} || {{cel·la sí}} || {{cel·la sí}} || {{cel·la sí}} || colspan=4 {{cel·la no}}
|-
| --&nbsp;precisió&nbsp;il·limitada<br/>Integer, Natural || {{cel·la sí}} || {{cel·la sí}} || {{cel·la sí}} || {{cel·la no}} || {{cel·la sí}} || {{cel·la sí}} || {{cel·la sí}} || {{cel·la sí}} || colspan=4 {{cel·la no}}
|-
| -- coma&nbsp;flotant<br/>Float, Double || {{cel·la sí}} || {{cel·la sí}} || {{cel·la no}} || {{cel·la no}} || {{cel·la sí}} || {{cel·la no}} || {{cel·la sí}} || {{cel·la no}} || colspan=4 {{cel·la sí}}
|-
| Rational || {{cel·la sí}} || {{cel·la sí}} || {{cel·la no}} || {{cel·la no}} || {{cel·la sí}} || {{cel·la no}} || {{cel·la sí}} || {{cel·la no}} || colspan=2 {{cel·la sí}} || colspan=2 {{cel·la no}}
|-
| -- coma&nbsp;fixa<br/>Uni, Deci, Centi,<br/>Milli, Micro,<br/>Nano, Pico || {{cel·la sí}} || {{cel·la sí}} || {{cel·la no}} || {{cel·la no}} || {{cel·la sí}} || {{cel·la no}} || {{cel·la sí}} || {{cel·la no}} || colspan=2 {{cel·la sí}} || colspan=2 {{cel·la no}}
|-
| <code>Complex t</code> || {{cel·la no}} || {{cel·la no}} || {{cel·la no}} || {{cel·la no}} || {{cel·la sí}} || {{cel·la no}} || {{cel·la no}} || {{cel·la no}} || {{cel·la sí}} || {{cel·la no}} || {{cel·la sí}} || {{cel·la no}}
|}

Vegeu també:
* [[Compilador Haskell de Glasgow#contenidors|contenidors]]

===== El cas dels tres operadors d'exponenciació =====
El domini de l'exponent determina el context del domini d'aplicació per les operacions requerides:

<syntaxhighlight lang="haskell">
-- exponent natural => cal que el domini ''a'' de la base implementi el producte (definit a Num: estructura d'anell)
(^) :: (Num a, Integral ex) => a -> ex -> a -- dispara excepció si l'exponent és negatiu

-- exponent enter => cal que el domini de la base implementi, a més a més, l'invers del producte (''recip'': recíproc) (definit a Fractional: estructura de cos)
(^^) :: (Fractional a, Integral ex) => a -> ex -> a

-- exponent real en coma flotant => cal que el domini de la base implementi l'exponenciació (''exp'' i ''log'': logaritme natural), definits a Floating
(**) :: (Floating a, Floating ex) => a -> ex -> a
</syntaxhighlight>

===== literals =====
Els literals numèrics no s'associen a tipus. Sense punt decimal requereixen que el tipus tingui estructura d'[[anell (matemàtiques)|anell unitari]] (implementi la classe ''Num''), mentre que els nombres amb part fraccionaria o notació exponencial (ex.: 5E2) requereixen que el tipus tingui estructura algebraica de [[cos (matemàtiques)|cos]] (implementi la classe ''Fractional'').

El signe menys no forma part del literal, s'interpreta com a operador (unari si és al capdavant de l'expressió; binari si la posició és [[infix]]): <code>(-1)</code>.<ref name="signe-menys-unitari">[https://wiki.haskell.org/Unary_minus HaskellWiki - Unary minus]{{en}}</ref> Això no permet especificar els nombres negatius sense corresponent positiu: <code>(-128)::Int8</code>. L'extensió NegativeLiterals hi posa remei.

Amb l'intèrpret GHCi podem consultar el tipus d'una expressió amb

<syntaxhighlight lang="Haskell">
Prelude> :type 1
1 :: (Num t) => t -- tipus t tal que implementa la signatura de ''Num'' 
 -- un anell unitari en àlgebra: (+), (-), (*), 0: neutre de (+), 1: neutre de (*)

Prelude> :type 1.5
1.5 :: (Fractional t) => t -- tipus t tal que implementa la signatura de ''Fractional'' (requereix Num)
 -- estructura algebraica de cos: anell amb invers del producte
 -- implementada per Float, Double, Rational, Uni, Deci, Centi, Milli, Micro, Nano, Pico

 0x41 -- hexadecimal :: (Num t) => t
 0o377 -- octal :: (Num t) => t
 0b11001101 -- binari :: (Num t) => t -- (des de GHC 7.10 amb l'extensió BinaryLiterals)

 1E10 -- (1E10) :: (Fractional t) => t

 -- caràcters: 'A', notació decimal: '\65', hexadec: '\x41', apòstrof: '\''
</syntaxhighlight>

El tipus concret es determina:

* per l'operació on intervé, si el tipus del paràmetre és fix (en majúscula) o bé si és una variable de tipus en posició repetida
<syntaxhighlight lang="Haskell">
 -- l'operació (+) :: (Num a) => a -> a -> a
 -- el tipus del 2n paràmetre i el del resultat venen determinats pel tipus del primer paràmetre
</syntaxhighlight>

* explícitament, <code>(1::Double)</code>

* provant una seqüència de tipus (clàusula ''default'')<ref>[http://www.haskell.org/onlinereport/haskell2010/haskellch4.html#x10-790004.3.4 Ambiguous Types, and Defaults for Overloaded Numeric Operations]{{en}}</ref>
<syntaxhighlight lang="Haskell">
-- la clàusula "default" és una manera de resoldre les ambiguïtats dels literals
-- reduint les assignacions de tipus explícites
 default (Int, Double) -- seqüència de tipus a provar per desambiguar els literals
</syntaxhighlight>

====== literals amb notació científica ======
Des de GHC 7.8 els sencers poden tenir literals amb notació científica. Cal l'extensió de llenguatge ''NumDecimal''
<syntaxhighlight lang="Haskell">
{-# LANGUAGE NumDecimal #-}

n = 1.2E4 :: Int
</syntaxhighlight>

====== literals de llistes ======
<syntaxhighlight lang="Haskell">
[] -- Nil (llista buida)
[1,2,3] -- valors separats per comes
[1..3] ['a'..'z'] -- seqüència correlativa, tradueix a (enumFromTo 1 3) de la classe ''Enum''
[1..] ['a'..] -- tradueix a (enumFrom 1) de Enum
[1,3..10] -- (== [1,3,5,7,9]) seqüència incremental, tradueix a (enumFromThenTo 1 3 10) de Enum, també admet ['a','c'..'z']
[1,3..] -- tradueix a (enumFromThen 1 3) de Enum
</syntaxhighlight>

===== conversions (''casting'' de tipus) =====
Per la conversió, el tipus resultant serà el requerit per l'avaluació de l'expressió, exigible si cal mitjançant una restricció de tipus.

Les conversions funcionen com una caracterització de tipus (ang: ''cast'') i '''no disparen excepcions''' si la precisió del tipus de destinació és menor que la d'origen.<ref>[https://www.schoolofhaskell.com/user/griba/safe_int_addition_and_product Int addition and product avoiding bad results]</ref>

Les conversions entre Int i Word preserven la representació (no pas el signe).<ref name="data-word2">[http://hackage.haskell.org/package/base/docs/Data-Word.html#g:3 Data.Word - secció Notes]</ref>

* conversions des de tipus amb precisió il·limitada o indefinida (per ex. literals amb seqüència de dígits de llargada indeterminada):
<syntaxhighlight lang="haskell">
-- per la captura de literals enters a Numèric (anell), o convertir el tipus Integer de precisió il·limitada
fromInteger :: Num a => Integer -> a 

-- per la captura de literals amb part decimal, de precisió indefinida a Fractional (estructura de cos)
fromRational :: Fractional a => Rational -> a -- des de racional (type Rational = Ratio Integer)
</syntaxhighlight>

* conversions
<syntaxhighlight lang="haskell">
fromIntegral :: (Integral a, Num b) => a -> b -- de Íntegre (Anell ordenat euclidià) a Numèric (anell)

realToFrac :: (Real a, Fractional b) => a -> b -- de Real (Anell ordenat) a Fraccionable (estructura de Cos, exclou enters)
</syntaxhighlight>
Exemples:

* Des de [[Anell íntegre|Íntegre]] (ang:''Integral'') [[anell (matemàtiques)|Anell]] [[anell ordenat|ordenat]] [[Anell euclidià|euclidià]] segons la def.<ref>[http://hackage.haskell.org/package/base/docs/Prelude.html#t:Integral classe Integral]</ref>
<syntaxhighlight lang="haskell">
Prelude> fromIntegral (5::Int) :: Integer -- a sencer de precisió il·limitada
5
Prelude> fromIntegral (5::Integer) :: Int
5
Prelude> fromIntegral (5::Int) :: Float
5.0
Prelude> fromIntegral (5::Int) :: Double
5.0
Prelude> import Data.Int -- importa tipus IntN de precisió concreta, per a N pertanyent a {8,16,32,64}

Prelude Data.Int> fromIntegral (0x7FFF :: Int16) :: Int8 -- fromIntegral NO dispara excepcions per sobreeiximent !!
-1

</syntaxhighlight>

* Des de Real ([[anell ordenat]]): són instància de Real els ''Float, Double, Int, IntN, Integer, Natural, Word, WordN'', Racionals i els de [[Coma fixa]].<ref>[http://hackage.haskell.org/package/base/docs/Prelude.html#t:Real Instàncies de la classe Real]</ref>

<syntaxhighlight lang="haskell">
Prelude> realToFrac (1.0::Float) :: Double
1.0
Prelude> realToFrac (1.1234567890::Double) :: Float
1.1234568
# incorporem el mòdul de coma fixa Data.Fixed
Prelude> :m +Data.Fixed
Prelude Data.Fixed> realToFrac (1.5 ::Float) :: Centi
1.50
</syntaxhighlight>
* Amb Racionals : (% és el constructor dels racionals. Ha d'anar entre espais, però la viquipèdia el retalla si va precedit d'un nombre)

''fromRational'' és membre de la classe ''Fractional'' (Fraccionable, estruct. de [[Cos (matemàtiques)|Cos]]).
<syntaxhighlight lang="haskell">
# incorporem el mòdul dels racionals
Prelude> :m +Data.Ratio
Prelude Data.Ratio> realToFrac 1.50 :: Rational
3% 2
Prelude Data.Ratio> fromRational (2% 3) :: Float -- '%' és el generador infix dels racionals
0.6666667
</syntaxhighlight>

==== tipus algebraics ====
Creats amb la clàusula ''data'': Enumeracions, tipus producte, tipus suma, ...

===== enumeracions =====
Unió de constructors d'[[aritat]] 0 (sense paràmetres) quina definició estableix un conjunt amb un ordre seqüencial. El compilador facilita la derivació de classes específiques si les explicitem a la clàusula ''deriving'':

* Show: per a la conversió a String
* Eq: per a la distinció
* Ord: relació d'ordre
* Enum: {(succ: successor) (pred: predecessor) (fromEnum: enter ordinal corresp.) (toEnum: enumerat corresp. a l'enter ordinal)}
* Bounded: cotes inferior i superior

<syntaxhighlight lang="haskell">
 data DiaSetm = Dl | Dm | Dc | Dj | Dv | Ds | Dg
 deriving (Show, Eq, Ord, Enum, Bounded) -- demana al compilador que derivi instàncies
 -- de classes bàsiques partint de la representació interna del tipus
</syntaxhighlight>

===== Tipus producte =====
<syntaxhighlight lang="Haskell">
data TRectangle = Rectangle Int Int -- (Int * Int) amb constructor Rectangle
</syntaxhighlight>
* El constructor equival a un morfisme del producte dels components (per ex.: Int * Int) al tipus nou.
* De fet, a GHC, l'extensió GADTs, permet descriure els constructors com a funcions:
<syntaxhighlight lang="Haskell">
{-# LANGUAGE GADTs #-}

data TRectangle where
 Rectangle :: Int -> Int -> TRectangle
</syntaxhighlight>

Encaix dels paràmetres discriminant pel constructor si n'hi ha diversos.

<syntaxhighlight lang="Haskell">
 perímetre :: TRectangle -> Int
 perímetre (Rectangle x y) = 2 * (x + y)
</syntaxhighlight>

====== Registres ======
Augmenta el tipus producte, especificant noms de camps com a funcions accessores als components. No hi ha registres anònims (cal distingir-los pel constructor).

Els registres corresponen en la [[Programació orientada a objectes|P.O.O]] als objectes i els seus camps, mentre que el comportament es materialitza en les instàncies (implementacions) de les classes de tipus (interfícies).

* Definició: <code>data Tipus = CRec {camp1 :: tipus1, camp2, camp3 :: tipus2i3}</code>

* Inicialització de valors: Cas de fer servir el literal de camps, aquests hi han de ser tots. També podem utilitzar el constructor com al tipus producte, sense els noms de camp, amb els components en l'ordre especificat a la definició.
<syntaxhighlight lang="haskell">
 -- per evitar col·lisions en l'espai de noms, convé afegir un prefix als noms de camps
 data TPersona = Persona {pNom::String, pEdat::Int, pAlçada::Float} deriving (Show, Eq)
 data TQuisso = Quisso {qNom::String, qEdat::Int, qAlçada::Float} deriving (Show, Eq)

 persona = Persona {pNom="Joan", pEdat=33, pAlçada=1.50}

 -- equivalent amb inicialització posicional
 persona = Persona "Joan" 33 1.50

 -- accedint per nom de camp, el tipus de l'accessor pNom :: TPersona -> String
 nom = pNom persona

 -- encaix posicional
 Persona nom edat alçada = persona
</syntaxhighlight>

* Literal dels camps als patrons (només cal especificar els parells (camp = patró) que interessin):
<syntaxhighlight lang="haskell">
getCampX CRec {campX = vCampX} = vCampX

-- amb l'extensió de sintaxi "NamedFieldPuns", ens estalviem repeticions
aniversari p @ Persona {pEdat} = -- {pEdat} equival a {pEdat = pEdat} (ext. NamedFieldPuns),
 -- aquí el pEdat visible és la variable del patró, en comptes de la funció accessora al camp
 p { pEdat = pEdat +1}

-- amb l'extensió de sintaxi "RecordWildcards", incorpora la resta de camps a l'àmbit, evitant mencionar-los tots
getCombinaCamps CRec {campX = v1, ..} = (v1, campY, campZ) -- l'el·lipsi ", .." (ext. RecordWildcards) incorpora a l'espai de noms la resta de camps

-- el literal de camps pot ser buit quan al patró només interessa el constructor
f CRec {} = ....
</syntaxhighlight>

* Literal dels camps a l'actualització
<syntaxhighlight lang="haskell">
setCampX nouX reg = reg {campX = nouX}
-- si fem servir el nom del camp com a var.
setCampX campX reg = reg {campX} -- l'ext. NamedFieldPuns pren "campX" com a "campX = campX" també a l'actualització
</syntaxhighlight>

* El literal dels camps "{campA=x}" està lligat sintàcticament al terme precedent amb major precedència que l'operació d'aplicació, tant en patrons com en cas d'actualització. No caldrà agrupar-los:
<syntaxhighlight lang="Haskell">
$ ghci
Prelude> data TRec = Rec {campA::Int}
Prelude> campA Rec {campA=2} -- no cal agrupar amb parèntesis el constructor amb el literal dels camps
2
</syntaxhighlight>

* Espai de noms: Els noms dels camps pertanyen a l'espai de noms del mòdul i convé afegir-los-hi un prefix per evitar col·lisions. L'extensió ''DuplicateRecordFields'' (GHC 8.0) permet la coincidència de noms de camps entre registres d'un mateix mòdul, sempre que el seu ús sigui inambigu (fent servir restriccions de tipus quan calgui), i la seva exportació es faci com a símbol intern del tipus.<ref name="DuplicateRecordFields">[https://ghc.haskell.org/trac/ghc/wiki/Records/OverloadedRecordFields/DuplicateRecordFields L'extensió DuplicateRecordFields]{{en}}</ref>

Per la sintaxi simplificada a GHC vegeu<ref>[http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#record-puns Extensions de GHC - Record Puns] {{Webarchive|url=https://web.archive.org/web/20051129140339/http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#record-puns |date=2005-11-29}}{{en}} simplificació de sintaxi en l'encaix dels camps dels registres</ref>

Cas de registres niuats o bé camps estructurals, les [[#Lents (Referències funcionals) - Consulta i manipulació de parts d'estructures complexes|referències funcionals anomenades lents]] ofereixen la possibilitat de consulta i modificació d'estructures complexes

====== Reversibilitat de tipus en registres d'un sol component ======
És una construcció força utilitzada per què en aquests registres, el constructor i l'accessor són funcions inverses l'una de l'altra.

<syntaxhighlight lang="haskell">
data NouTipus a = Constructor { accessor :: a}

-- Constructor :: a -> NouTipus a
-- accessor :: NouTipus a -> a

-- (accessor. Constructor) == id
</syntaxhighlight>

Vegeu també més avall [[#Tipus derivats -- newtype]]

====== Tuples ======
tipus producte anònim amb constructors com: (,); (,,); ....<ref>[http://www.haskell.org/onlinereport/basic.html#basic-tuples Tuples a Haskell98]{{en}}</ref> Ops. definides a Data.Tuple<ref>[http://hackage.haskell.org/package/base/docs/Data-Tuple.html Data.Tuple]</ref>

<syntaxhighlight lang="Haskell">
 () -- la tupla buida és un valor del tipus Unit (tipus d'un sol valor) 
 -- i també designa el tipus esmentat (emprat per al resultat buit en efectes (IO ()))

 parell = (1,"abc") -- valor
 (Int, String) -- tipus

 fst parell -- funció primer (fst) i segon (snd) (només implementades per a tupla2),
 -- no definit a tupla3.. i següents
 snd parell -- segon
 (,) -- constructor de tupla2: (,) a b == (a,b)
 (,,) -- constructor de tupla3: (,,) a b c == (a,b,c)
 (,,,) -- constructor de tupla4

 -- encaix
 (primer, segon) = parell
</syntaxhighlight>

===== tipus suma =====
Unió de tipus discriminada per etiquetes (constructors), seguits dels tipus dels components

<syntaxhighlight lang="haskell">
 -- en aquest exemple l'etiqueta o ''constructor'' coincideix amb el nom del tipus que el segueix
 -- en diverses ocasions però és vàlid perquè són espais de noms diferents

data Exception -- aquest tipus del H98 va passar al mòdul Control.OldException, que ha sigut eliminat de GHC
 = 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
 ...

type Coord = Double

-- estil algebraic
data Punt = Punt2D Coord Coord
 | Punt3D Coord Coord Coord
 deriving (Eq, Show)

-- estil GADTs (algebraic generalitzat) -- requereix pragma: {-# LANGUAGE GADTs #-}
-- per cadascun dels constructors se'n descriu el tipus com si fos una funció:
data Punt where
 Punt2D :: Coord -> Coord -> Punt
 Punt3D :: Coord -> Coord -> Coord -> Punt
 deriving (Eq, Show)

p2D = Punt2D 2 4
p3D = Punt3D 4 6 8

-- encaix discriminant pel ''constructor''

mòdul :: Punt -> Coord
mòdul (Punt2D x y) = sqrt $ x^2 + y^2
mòdul (Punt3D x y z) = sqrt $ x^2 + y^2 + z^2
</syntaxhighlight>

====== Registres variants i accessors parcials ======
Els accessors no definits per tots els constructors, són funcions parcials (poden fer petar el programa)
<syntaxhighlight lang="haskell">

data Punt = Punt2D {x,y :: Coord}
 | Punt3D {x,y,z :: Coord} -- compte! l'accessor (z :: Punt -> Coord) és parcial
</syntaxhighlight>

* Una alternativa és no fer servir els noms de camp com a accessors, sinó només en patrons, però els resultats incerts dels camps no comuns mostren que no és un bon disseny.

<syntaxhighlight lang="haskell">
{-# LANGUAGE NamedFieldPuns #-}

-- l'obtenció i modificació de la coord. Z és incerta en aquest disseny

getZ :: Punt -> Maybe Coord -- Potser tindrà èxit, potser no !! 
getZ Punt3D {z} = Just z
getZ Punt2D {} = Nothing

setZ :: Coord -> Punt -> Maybe Punt -- Potser tindrà èxit, potser no !! Massa incerteses !!
setZ z pt @ Punt3D {} = Just pt {z}
setZ z pt @ Punt2D {} = Nothing
</syntaxhighlight>

* És millor fer-ne tipus diferents per cada cas, definint ''setZ'' només per al tipus 3D. Per un tractament comú dels camps comuns caldrà definir ''getters/setters'' en classes i instanciar-les per a ambdós tipus.

<syntaxhighlight lang="haskell">
data Punt2D = Punt2D {x,y :: Coord}
data Punt3D = Punt3D {x,y,z :: Coord}

class GetXY t where
 getXY :: t -> (Coord, Coord)

instance GetXY Punt2D where { getXY Punt2D {x, y} = (x, y) } 
instance GetXY Punt3D where { getXY Punt3D {x, y} = (x, y) } 
</syntaxhighlight>

====== Polimorfisme de registres amb camps específics - la classe HasField ======
:Des de GHC 8.2 ja no caldrà classes "getters" per aconseguir polimorfisme sobre els accessors comuns.<ref>[https://ghc.gitlab.haskell.org/ghc/doc/users_guide/exts/hasfield.html Record field selector polymorphism]{{en}}</ref>
::* requeriment d'existència d'accessor de nom "camp": <code>HasField "camp" tipusRegistre tipusCamp</code>

<syntaxhighlight lang="haskell">
{-# LANGUAGE DuplicateRecordFields, TypeApplications, DataKinds, FlexibleContexts #-} 

module Lib1 (
 prova1 
 {-, prova2 GHC >= 9.2-}
) where

import GHC.Records (HasField(getField {- GHC >= 8.2 -}
 {-, hasField // pròximament a GHC >= 9.2 -}
))
type Coord = Double

data Punt2D = Punt2D {x,y :: Coord} deriving (Show)
data Punt3D = Punt3D {x,y,z :: Coord} deriving (Show)

p2D = Punt2D 1 2
p3D = Punt3D 3 4 5

-- getter desde GHC 8.2
prova1 :: (Coord, Coord)
prova1 = (getField @"x" p2D, getField @"x" p3D)

{-
-- parell (getter, setter) pròximament a GHC 9.2
prova2 :: (Coord, Coord, Punt2D, Punt3D)
prova2 = (getX p2D, getX p3D, setX p2D 0, setX p3D 0)
 where (getX, setX) = hasField @"x" 
-}</syntaxhighlight>

===== tipus polimòrfics =====
Amb variables de tipus (els identificadors que comencen per minúscula).

* Maybe (paràmetres i resultats opcionals).<ref>[http://hackage.haskell.org/package/base/docs/Data-Maybe.html El tipus Maybe]{{en}}</ref>
* Either (èxit o fracàs de l'avaluació d'una acció que llança excepcions, retornant Left amb l'excepció o bé Right amb el resultat).<ref>[https://hackage.haskell.org/package/base/docs/Data-Either.html El tipus Either]{{en}}</ref><ref>[http://hackage.haskell.org/package/base/docs/Control-Exception.html#v:try ''try'' avalua una acció que llança excepcions retornant el resultat en un tipus Either]{{en}}</ref>

<syntaxhighlight lang="haskell">
 -- el tipus Maybe : paràmetres opcionals o resultats de funcions definides parcialment
 data Maybe a = Nothing | Just a deriving (Eq, Ord, Read, Show)

 -- el tipus Either: domini dual, emprat en l'avaluació amb 'try' d'una acció que llança excepcions
 data Either a b = Left a {- error -} | Right b {- resultat -}

 -- tipus recursius
 data [a] = [] | a : [a] -- tipus llista; (:) és un constructor infix 
 -- per definició de la sintaxi, tots els operadors q. comencen per ':' són infix

 data Arbre a = Fulla a | Branca (Arbre a) a (Arbre a)
</syntaxhighlight>
Els tipus que no inclouen variables de tipus s'anomenen ''monomòrfics''.

==== sinònims de tipus ====
Els sinònims de tipus són com macros al nivell de tipus.<ref name="liberal-type-syn">[http://www.haskell.org/ghc/docs/latest/html/users_guide/data-type-extensions.html#type-synonyms Sinònims de tipus liberals] {{Webarchive|url=https://web.archive.org/web/20100425082929/http://www.haskell.org/ghc/docs/latest/html/users_guide/data-type-extensions.html#type-synonyms |date=2010-04-25}}{{en}}</ref>

<syntaxhighlight lang="haskell">
type String = [Char] -- el tipus String (cat: enfilall o tira) està definit com a llista de caràcters (seqüència d'accés lineal)
type LaMevaEstructura = (String, Int, Double)
</syntaxhighlight>

===== sinònims paramètrics =====
El següent sinònim inclou paràmetres de tipus.
<syntaxhighlight lang="haskell">
type LlistaNumerada a = [(Int, a)]
</syntaxhighlight>

==== llistes ====
El tipus Llista (seqüència d'accés lineal), amb constructors "[]" (llista buida, anomenat ''nil'')<ref name="nil-cons">[http://www.haskell.org/onlinereport/basic.html#basic-lists Llistes - Nil i Cons]{{en}}</ref> i ":" (tip_elem * llista_elem, anomenat ''cons'')<ref name="nil-cons"/> Operacions al mòdul Data.List<ref>[http://hackage.haskell.org/package/base/docs/Data-List.html Data.List]{{en}}</ref>
<syntaxhighlight lang="haskell">
 data [a] = [] {- "nil" -} | a : [a] -- ':' és el constructor "cons" (infix, per def. sintàctica)

 [a] -- en una decl. de tipus, llista d'elements de tipus a

 [] -- llista buida
 elem_cap : llista_cua

 [1,2,3] -- els valors han de ser homogenis (del mateix tipus)
 [1,3..10] == [1, 3, 5, 7, 9]

 -- consultes
 null xs -- és buida?
 length xs -- mida
 xs !! posició -- el primer és llista!!0 -- funció parcial !!
 elem x xs -- pertinença a la llista
 ésFeiner dia = dia `elem` [Dl, Dm, Dc, Dj, Dv] -- `elem` en posició infix per les cometes revesses

 -- llistes infinites
 [1..]
 [1,3..] == [1, 3, 5, 7, 9, ...
 iterate f x == [x, f x, f (f x), ...] -- seqüència d'aplicacions reiterades d'una funció
 repeat x -- llista per repetició del valor x
 cycle xs -- converteix la llista NO-BUIDA xs en circular -- funció parcial !!
</syntaxhighlight>

Més operacions a [[Compilador Haskell de Glasgow#contenidors|contenidors]]

===== [[llista per comprensió]] =====
Especifica l'expressió objectiu, obtenint-ne els valors de les variables d'una seqüència de generadors i filtres separats per comes

<syntaxhighlight lang="haskell">
 s :: [Int]
 s = [ x+y | x <- [0, 2..], y <- [1, 3..20], x^2 > 3, y `mod` 9 /= 0 ]

 print $ take 5 s -- imprimeix els primers
</syntaxhighlight>

====== [[llista per comprensió]] monàdica ======
La llista per comprensió precedent es pot expressar amb un bloc monàdic

<syntaxhighlight lang="haskell">
s :: [Int]
s = do
 x <- [0, 2..]
 y <- [1, 3..20]
 guard $ x^2 > 3
 guard $ y `mod` 9 /= 0
 return $ x+y
</syntaxhighlight>

Vegeu-ho a [[Mònada (programació funcional)#Llista per comprensió monàdica]]

====== [[llista per comprensió|llistes per comprensió]] a l'estil de [[SQL]] ======
L'extensió de [[Compilador Haskell de Glasgow#llistes per comprensió a l'estil de SQL|GHC]] TransformListComp permet incorporar-hi transformacions.<ref>[https://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#generalised-list-comprehensions Generalised (SQL-Like) List Comprehensions] {{Webarchive|url=https://web.archive.org/web/20141025114735/https://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#generalised-list-comprehensions |date=2014-10-25}} {{en}}</ref> Vegeu [[Compilador Haskell de Glasgow#llistes per comprensió a l'estil de SQL|exemple]].<ref>[https://www.fpcomplete.com/school/to-infinity-and-beyond/pick-of-the-week/guide-to-ghc-extensions/list-comprehension-extensions FPComplete.com - List comprehension extensions] {{Webarchive|url=https://web.archive.org/web/20141025100109/https://www.fpcomplete.com/school/to-infinity-and-beyond/pick-of-the-week/guide-to-ghc-extensions/list-comprehension-extensions |date=2014-10-25}} {{en}}</ref>

==== tires de text ====
-- el tipus String (cat: corda o enfilall d'objectes, indica seqüència, aquí en direm ''tira'' com les tires de números consecutius de les rifes) és una llista de caràcters i és el tipus de les tires incloses al codi. String no és definit com a estructura (''data'') sinó com a àlies o sinònim (''type'') de l'expressió:
 type String = [Char]
 -- literals: "" "abc" "\"abc\""

* Llegiu l'article "How to pick your string library in Haskell"<ref>[http://blog.ezyang.com/2010/08/strings-in-haskell/?utm_source=feedburner&utm_medium=feed&utm_campaign=Feed%3A+ezyang+%28Inside+245s%29 How to pick your string library in Haskell]{{en}} Com escollir la biblioteca de cadenes de caràcters en Haskell</ref>

L'extensió OverloadedStrings permet fer servir literals de tipus ''String'' com a valors de tipus que n'implementin la conversió, instanciant la classe [[Compilador Haskell de Glasgow#La classe IsString|IsString]].

===== Tires de text implementades amb vectors - El tipus Text =====
Tires com a seqüències d'accés aleatori, a diferència de ''String'' definit com a llista (seqüència d'accés lineal)

* amb un tipus text que empaqueta els caràcters en un vector de [[UTF-16]], definit a la biblioteca "text"<ref>[http://hackage.haskell.org/packages/archive/text/latest/doc/html/Data-Text.html biblioteca "text" de tires com a vectors de caràcters de 16 bits]{{en}}</ref>

Estructura del tipus ''Text'' que és un tipus opac (l'estructura és només d'ús intern):<ref>[https://hackage.haskell.org/package/text/docs/src/Data-Text-Internal.html#Text Estructura del tipus Text a Data.Text.Internal]{{Enllaç no actiu|bot=InternetArchiveBot |data=2021}}{{en}}</ref>
<syntaxhighlight lang="haskell">
-- | A space efficient, packed, unboxed Unicode text type.
data Text = Text
 {-# UNPACK #-} !A.Array -- payload (Word16 elements)
 {-# UNPACK #-} !Int -- offset (units of Word16, not Char)
 {-# UNPACK #-} !Int -- length (units of Word16, not Char)
 deriving (Typeable)
</syntaxhighlight>

Exemple d'ús:
<div style="background-color:#f4f6fe; border-style:solid; border-width:1px;">
<syntaxhighlight lang="haskell">

#if __GLASGOW_HASKELL__>=612 /* GHC >= 6.12.0 */

 import System.IO (stdout, hFlush)

 -- amaguem les funcions predefinides per a String que volem Text
 -- cal haver instal·lat el paquet "text"

 import Prelude hiding (putStr, putStrLn, getLine)
 import Data.Text.IO (putStr, putStrLn, getLine)
 import Data.Text (pack, unpack, -- conversió
 empty, singleton, cons, -- generadors
 uncons)

 text1 = pack "Entreu lletres tot seguit: " -- pack :: String -> Text

 main = do
 putStr text1
 hFlush stdout

 x <- getLine
 case uncons x of -- uncons :: Text -> Maybe (Char, Text)
 Just (lletra, _resta) -> do
 putStr $ pack "comença per "
 putStrLn $ singleton lletra -- singleton :: Char -> Text

 Nothing -> putStrLn $ pack "entrada buida"
#else
 #error "no provat en versions anteriors"
#endif
</syntaxhighlight></div>

compilant amb preprocés (opcions -cpp o bé -XCPP o bé {-# LANGUAGE CPP #-} al codi)
<syntaxhighlight lang="batch">
 runhaskell -cpp prova.hs 
</syntaxhighlight>

===== Sobrecàrrega de literals ''String'' i llista =====
L'extensió de llenguatge ''OverloadedStrings'' facilita que, de manera similar als literals numèrics, els literals de tires de caràcters admetin també l'assignació del tipus requerit per l'operador, sempre que el tipus de l'operand proporcioni la conversió, implementant ''fromString'' de la classe ''IsString''.<ref name="overloaded-strings">[http://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#overloaded-strings Extensió OverloadedStrings]{{Enllaç no actiu|bot=InternetArchiveBot |data=2021}}{{en}}</ref>

<syntaxhighlight lang="Haskell">
{-# LANGUAGE OverloadedStrings #-}
import Data.Text (Text) -- el tipus Text instancia la classe IsString
import qualified Data.Text as T

-- T.take :: Int -> Text -> Text

abc = T.take 3 "abcdef" -- el literal "abcdef" pren tipus Text en comptes de String
</syntaxhighlight>

De manera similar, des de GHC 7.8 amb l'extensió ''OverloadedLists'', els literals llista també poden prendre tipus d'altres col·leccions que n'implementin la conversió instanciant la classe ''IsList''. Vegeu [[Compilador Haskell de Glasgow#Sobrecàrrega de literals Llista]]

{| class="wikitable collapsible" style="text-align:center"
|-
!
! colspan=4 | literals i decodificació
|-
! literal !! classe !! funció decodificadora<br/>o de conversió !! extensió de llenguatge<br/>requerida !! exemples
|-
| 999<br/>(* sense parts decimal/exp. *)<br/>0xFF, 0o377 || Num || fromInteger || ||
|-
| 999[.99] [E[±]999]<br/>(* notació científica *) || Fractional || fromRational || || 2.5E-2 :: Rational<br/>2.5E-2 :: Float
|-
| 999[.99] [E[±]999]<br/>(* notació cient.<br/> avaluable a enter *) || Num || fromInteger || NumDecimals || 2.5E2 :: Int
|-
| 0b11001100 || Num || fromInteger || BinaryLiterals ||
|-
| "tira de caràcters" || IsString<ref name="data-string"/> || fromString || OverloadedStrings<ref name="overloaded-strings"/> || "abc" :: Text
|-
| '[' 1,2,3 ']'<br/>(* seq. de valors *) || IsList<ref name="data-islist">[https://hackage.haskell.org/package/base/docs/GHC-Exts.html#t:IsList La classe IsList]{{en}}</ref> || fromList || OverloadedLists<ref name="overloaded-lists">[http://www.haskell.org/ghc/docs/latest/html/users_guide/glasgow_exts.html#overloaded-lists OverloadedLists]{{Enllaç no actiu|bot=InternetArchiveBot |data=2021}}{{en}}</ref> || [1, 3..9] :: Set Int<br/>[(1,"a"), (2,"b")] :: Map Int String
|}

== Expressions ==
=== funcions ===
A la declaració cal especificar els tipus dels paràmetres separats per fletxes; si son genèrics en minúscula

<syntaxhighlight lang="Haskell">
-- (->) indica retorn
f :: a -> r -- indica el tipus d'una funció f amb paràm. de tipus 'a' que retorna un tipus 'r'
</syntaxhighlight>

* la repetició d'una variable de tipus a la signatura, indica que el tipus corresponent a les aparicions repetides d'una mateixa variable ha de coincidir amb el tipus encaixat en primera posició.

<syntaxhighlight lang="haskell">
ésApreciable :: (Ord a) => a -> a -> Bool 
ésApreciable llindar valor = valor >= llindar

-- l'ús de (>=) requereix que el tipus a implementi Ordenable 
-- i cal especificar-ho com a requeriment de context (abans de "=>")
-- indicant que cal la visibilitat d'una instància de Ordenable en el context
-- d'ús de la funció, per al tipus que prengui la variable ''a''.
</syntaxhighlight>

Qualsevol importació d'un mòdul importa totes les instàncies exportades (visibles a nivell de mòdul)

==== [[funció anònima|Funcions anònimes]] anomenades [[càlcul lambda|Expressions lambda]] ====
La barra invertida, caràcter del teclat que més s'assembla a la lletra grega [[lambda]] (per referència a l'[[abstracció lambda]] del [[càlcul lambda]], fonament de la [[programació funcional]]), introdueix una funció anònima com a expressió.
<syntaxhighlight lang="haskell">
 \ x y -> x + y
</syntaxhighlight>
és equivalent a
<syntaxhighlight lang="haskell">
 \ x -> \ y -> x + y
</syntaxhighlight>
És una notació importada del [[càlcul lambda]] on <math>\lambda x. \lambda y. \lambda z. E</math> s'abreuja com a <math>\lambda x y z. E</math>

Cal tenir en compte que el cos de la lambda abasta el màxim cap a la dreta
<syntaxhighlight lang="haskell">
(\ x -> M N) ≡ (\ x -> (M N)) -- com al càlcul lambda
</syntaxhighlight>

* L'extensió de llenguatge ''LambdaCase'' permet obviar la variable quan introdueix un ''case''.<ref>[https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/syntax-extns.html#lambda-case Lambda-case] {{Webarchive|url=https://web.archive.org/web/20160413074834/https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/syntax-extns.html#lambda-case |date=2016-04-13 }}{{en}}</ref>

<syntaxhighlight lang="haskell">
{-# LANGUAGE LambdaCase #-}

\ case { patró1 -> expr1; ...; patN -> expN }

-- equival a
\ x -> case x of { patró1 -> expr1; ...; patN -> expN }
</syntaxhighlight>

==== Aplicació parcial ====
Vegeu ref.<ref>[http://www.haskell.org/haskellwiki/Partial_application Aplicació parcial]</ref>

L'aplicació parcial d'un paràmetre actual a una funció causa la substitució de la variable pel paràmetre en l'expressió, resultant una funció de les variables restants.
<syntaxhighlight lang="haskell">
(\ x y -> E) {- equival a -} \ x -> (\ y -> E)

-- aplicació d'una lambda a un paràmetre és l'expressió beta-reduïble
(\x -> E) E'
</syntaxhighlight>

Per la [[#reducció beta del càlcul lambda en notació Haskell|reducció ''beta'' del càlcul lambda]] <math>((\lambda x. E) \ E')</math> és la substitució <math>E[x := E']</math>.

L'aplicació és associativa per l'esquerra. <code>f x y ≡ (f x) y</code>

L'operador de funció (->) "retorna" és associatiu per la dreta:
<syntaxhighlight lang="Haskell">
(a -> b -> c) ≡ (a -> (b -> c)) -- en aplicar el primer paràmetre s'obté una funció dels paràmetres restants.
</syntaxhighlight>

==== Pas de paràmetres ====
Per defecte: per necessitat (ang: ''lazy'')<ref>[https://wiki.haskell.org/Haskell/Lazy_evaluation HaskellWiki - Lazy evaluation] {{en}}</ref> = avaluació tardana (quan se'n requereix l'ús) amb substitució de l'avaluació del [[#avaluació no-estricta, normalment tardana - Thunks|thunk]] de l'argument, i memoïtzació del resultat de l'avaluació de l'argument.

El mode d'avaluació del paràmetre es pot alterar amb un prefix al patró segons la taula següent:

{| class=wikitable
|-
! extensió !! prefix als patrons<br/>dels paràmetres formals !! avaluació || comentaris
|-
| rowspan=2 | -- per defecte || patró || ''lazy'' (avaluació per necessitat ''call by need'') ||
|-
| ~patró || aval. tardana i irrefutable de l'encaix || Vegeu [[#Avaluació tardana explícita en els patrons d'encaix|Avaluació tardana explícita de l'encaix]]
|-
| BangPatterns<br/>-- afegeix sintaxi prefix&nbsp;<nowiki>'!'</nowiki> || <nowiki>!patró</nowiki> || estricta, per valor ||
|-
| rowspan=2 | Strict<ref name="strict-strictdata">[https://ghc.haskell.org/trac/ghc/wiki/StrictPragma Pragmes Strict i StrictData]{{en}}</ref><br/>-- modifica la semàntica || patró || per defecte: estricta i per valor ||
|-
| ~patró || ''lazy'' (avaluació per necessitat ''call by need'') ||
|}

Vegeu extensions ''BangPatterns'' i ''Strict''<ref name="bang-patterns-strict">{{Ref-web |url=https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#bang-patterns-and-strict-haskell |títol=BangPatterns i Strict |consulta=2021-07-15 |arxiuurl=https://web.archive.org/web/20180821174039/http://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#bang-patterns-and-strict-haskell |arxiudata=2018-08-21 }}</ref>

===== Pas de paràmetres per valor =====
Vegeu [[#Avaluació estricta explícita]], [[passar per referència]].

L'especificació d'estrictesa als paràm. formals requereix l'extensió BangPatterns o bé la Strict.<ref name="bang-patterns-strict"/>

<syntaxhighlight lang="haskell">
-- amb indicació d'avaluació estricta (!) als patrons

{-# LANGUAGE BangPatterns #-}
ident !param_formal = expressió (param_formal) -- def. de funció amb estrictesa (!) als patrons (ext. BangPatterns), avalua el paràmetre a WHNF

-- o bé amb aplicació estricta ($!)
(ident $! param_actual) -- = param_actual `seq` ident param_actual -- 'seq' avalua el primer paràmetre a HNF i retorna el segon

-- o bé amb aplicació estricta a Forma Normal ($!!), avalua en profunditat, requereix que el tipus implementi NFData
import "deepseq" Control.DeepSeq (NFData, deepseq, ($!!))
(ident $!! param_actual) -- = param_actual `deepseq` ident param_actual -- 'deepseq' avalua el primer paràmetre a Forma Normal i retorna el segon
</syntaxhighlight>

L'extensió de llenguatge ''Strict'' de GHC 8.0 capgira el mode d'avaluació dels patrons, on per defecte l'avaluació serà estricta (excepte per als identificadors a nivell de mòdul "Top level bindings"), assenyalant el pas de paràmetres tardà (''lazy'') amb (~).<ref name="bang-patterns-strict"/>

==== Àmbit dinàmic - paràmetres implícits ====
Permet lligar variables '''amb prefix '?' ''' a l'àmbit del procediment que fa la crida, com el pas de paràmetres per referència del [[llenguatge C|lleng. C]], sempre que s'especifiqui la variable en un requeriment de context (requereix visibilitat en l'àmbit de la crida).
* Cal esmentar-les als requisits de context per fer referència a l'àmbit d'origen.
* Cal l'extensió de llenguatge {-# LANGUAGE ImplicitParams #-}. Vegeu ref.<ref>[http://haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#implicit-parameters GHC - Implicit parameters] {{Webarchive|url=https://web.archive.org/web/20120130224958/http://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#implicit-parameters |date=2012-01-30}}{{en}}</ref>
<syntaxhighlight lang="haskell">
{-# LANGUAGE ImplicitParams #-}

-- definint la variable implícita
prova = let ?implícit = 2 -- espai local de la variable implícita
 in cridaIntermèdia

cridaIntermèdia :: (?implícit :: Int) => Int -- refereix ?implícit a l'àmbit del punt de crida
cridaIntermèdia = multiplicaAmbImplícit 5

multiplicaAmbImplícit :: (?implícit :: Int) => Int -> Int -- refereix ?implícit a l'àmbit del punt de crida
multiplicaAmbImplícit x = ?implícit * x

main = print prova
</syntaxhighlight>

==== Explicitar un tipus amb el paràmetre ''Proxy'' ====
El tipus (Proxy a) és un tipus de paràmetre que no comporta dades, i s'utilitza per fer coincidir un tipus amb el de paràmetres subseqüents.<ref>[https://hackage.haskell.org/package/base/docs/Data-Proxy.html Data.Proxy]{{en}}</ref>

Exemple d'ús en l'entorn Servant.<ref>[https://hackage.haskell.org/package/servant-server/docs/Servant-Server.html#v:serve ''serve'' a Servant.Server]{{en}}</ref>
<syntaxhighlight lang="haskell">
import Servant.Server (Application, Server, serve)

data User = User {nom :: String} deriving (Eq, Show, Generic, ToJSON)

type API = "usuaris" :> Get '[JSON] [User]

serveixUsuaris :: Server API 
serveixUsuaris = return [User "Joan", User "Josep"]

-- la signatura de `serve` assegura la coincidència de l'API del servidor amb la desitjada

-- serve :: HasServer api '[] => Proxy api -> Server api -> Application

appServidor = serve (Proxy :: Proxy API) serveixUsuaris
</syntaxhighlight>

==== [[Funcions d'ordre superior]] ====
Quan algun dels paràmetres és una funció:

<syntaxhighlight lang="haskell">
-- per descriure un paràmetre funció cal acotar-lo entre parèntesis:
flip :: (a -> b -> c) -> b -> a -> c 
flip f x y = f y x
</syntaxhighlight>

Els operadors bàsics sobre funcions són al mòdul Data.Function<ref name="data-function">[http://hackage.haskell.org/package/base/docs/Data-Function.html El mòdul Data.Function]</ref>

Al passar un paràmetre funció no se'n comprova l'aritat.

===== Secció (tall) d'un operador en [[infix]] =====
La secció d'un operador en infix consisteix en convertir una expressió d'un operador binari en una funció anònima d'un dels operands, que s'omet i es tanca entre parèntesis, per exemple <code>(< 5)</code>. Vegeu ref.<ref>[http://www.haskell.org/haskellwiki/Section_of_an_infix_operator Secció (tall) d'un operador binari en infix] {{en}}</ref>
<syntaxhighlight lang="haskell">
-- exemple d'ús: quick-sort en llistes
import Data.List as L
qs [] = []
qs (x:xs) = qs precedents ++ [x] ++ qs no_precedents
 where 
 (precedents, no_precedents) = L.partition (< x) xs

$ ghci
Prelude> :type (2^) -- equival a l'aplic. parcial ((^) 2)
(2^) :: (Integral b, Num a) => b -> a

Prelude> :t (^2) -- equival a l'aplicació parcial (flip (^) 2)
(^2) :: Num a => a -> a

Prelude> :t (`elem` "AEIOU") -- equival a l'aplic. parcial (flip elem "AEIOU") 
(`elem` "AEIOU") :: Char -> Bool
</syntaxhighlight>

* excepte el cas <code>(-1)</code> doncs el signe menys a l'inici d'expressió es considera operador unari.<ref name="signe-menys-unitari"/>

==== Patrons i guardes ====
===== casuística per [[encaixar patrons|encaix de patrons]] dels paràmetres =====
El nom de la funció precedeix cada cas.

<syntaxhighlight lang="haskell">
 -- _ és el comodí, que pot portar un sufix per a documentació (ex.: "_x", "_xs")
 llargada :: [a] -> Int
 llargada [] = 0 -- [] patró del constructor ''nil'' de llista buida.
 llargada (_:xs) = 1 + llargada xs -- (_cap : _cua) patró del constructor ''cons''.
</syntaxhighlight>

!! [[Compilador Haskell de Glasgow|GHC]] no avisa quan els encaixos són incomplets (no exhaustius),<ref>[http://www.haskell.org/ghc/docs/latest/html/users_guide/options-sanity.html#id569598 GHC Guia d'usuari - senyal de compilació: -fwarn-incomplete-patterns] {{Webarchive|url=https://web.archive.org/web/20100325172906/http://haskell.org/ghc/docs/latest/html/users_guide/options-sanity.html#id569598 |date=2010-03-25}}{{en}} deshabilitada per defecte</ref> excepte que ho demanis explícitament amb l'opció -fwarn-incomplete-patterns o -Wall

La determinació de si un encaix és viable s'avalua de manera estricta. Per a avaluar-los de manera tardana vegeu [[#Avaluació tardana explícita en els patrons d'encaix]]

===== l'operador (@) - assignació del valor encaixat a una variable =====
l'operador (@), anomenat ''as-pattern'', com a (''variable'' @ ''patró'') unifica la variable i el valor encaixat al patró

<syntaxhighlight lang="haskell">
 descriuLlista ll @ (_:_) = "llista no buida: " ++ show ll
</syntaxhighlight>

===== Signatures de tipus als patrons =====
Totes les variables de patrons admeten signatures, quines variables de tipus han de pertànyer a l'àmbit de la definició.<ref>[http://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#pattern-type-sigs Pattern type signatures] {{Webarchive|url=https://web.archive.org/web/20100414113701/http://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#pattern-type-sigs |date=2010-04-14}} {{en}}</ref>

<syntaxhighlight lang="haskell">
 f :: forall a. [a] -> (Int, [a]) -- forall a. fa visible el tipus 'a' al codi definit
 f xs = (n, zs)
 where
 (ys::[a], n) = (reverse xs, length xs) -- Correcte, restricció amb tipus a la vista
 zs::[a] = xs ++ ys -- Bé

 Just (v::b) = ... -- Incorrecte. b no està a la vista!
</syntaxhighlight>

===== Definició per ''Guardes'' =====
Definició de funcions basada en condicions
<syntaxhighlight lang="haskell">
 prova x
 | x > 0 = 1
 | x == 0 = 0
 | otherwise = -1
</syntaxhighlight>

===== Definició per guardes de patrons =====
Haskell2010. (extensió de llenguatge ''PatternGuards'') Permet condicionar una definició a una seqüència d'encaixos subordinats.<ref>[http://www.haskell.org/haskellwiki/Pattern_guard Pattern guards]{{en}}</ref>

Quan volem donar categoria de definició a una expressió subjecta a una cascada d'encaixos
<syntaxhighlight lang="haskell">
addLookup env var1 var2 = 
 case lookup env var1 of
 Just val1 ->
 (case lookup env var2 of 
 Just val2 -> val1 + val2
 Nothing -> cas_residual
)
 Nothing -> cas_residual
</syntaxhighlight>
podem escriure la cascada d'encaixos en seqüència com a condicionant de la definició:
<syntaxhighlight lang="haskell">
addLookup env var1 var2
 | Just val1 <- lookup env var1,
 Just val2 <- lookup env var2
 = val1 + val2
addLookup _ _ _ = cas_residual
</syntaxhighlight>

===== Sinònims de patrons =====
Des de GHC 7.8.1 amb l'extensió de llenguatge ''PatternSynonyms''.<ref name="pattern-syns">[https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#pattern-synonyms GHC users guide - Pattern synonyms] {{Webarchive|url=https://web.archive.org/web/20180821174039/http://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#pattern-synonyms |date=2018-08-21 }}{{en}}</ref>

* Per al cas de patrons niuats, per distingir els patrons segons el component pretès amb noms més entenedors
* o també, per donar noms a valors als patrons

<ref>[https://ghc.haskell.org/trac/ghc/ticket/8583 Associated pattern synonyms]{{en}}</ref>
<syntaxhighlight lang="haskell">
{-# LANGUAGE PatternSynonyms #-}

pattern Cap y <- y : _ -- amb sintaxi unidireccional (<-): ús només en patrons
pattern Cua ys <- _ : ys

obtenirElCapDeLaCuaDeLaCua :: [a] -> Maybe a
obtenirElCapDeLaCuaDeLaCua xs =
 case xs of
 Cua (Cua (Cap y)) -> Just y 
 _ -> Nothing

main = print $ obtenirElCapDeLaCuaDeLaCua [1::Int,2,3]
</syntaxhighlight>

* hi ha dues sintaxis, segons l'ús pretès del sinònim:<ref name="pattern-syns"/>
:* unidireccional <code>(<-)</code> : circumscriu l'ús del sinònim al context de patrons.
:* bidireccional <code>(=)</code> : per emprar el sinònim tant en patrons i com en expressions.
* també poden estar definits dins una classe (associats), abstractes dins la classe, amb la definició concretada a les instàncies.

===== Patrons de vistes =====
S'entén per ''vista'' una funció d'un argument quin resultat es pot analitzar per patrons. La sintaxi ''(vista -> patró)'' es fa servir en el lloc d'un argument, aplicant la funció ''vista'' a l'argument i encaixant el resultat al patró. També es pot fer servir en un ''case'' o en una definició amb ''let''. Extensió ''ViewPatterns''.<ref>[https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/syntax-extns.html#view-patterns ghc users guide - View patterns] {{Webarchive|url=https://web.archive.org/web/20160413074834/https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/syntax-extns.html#view-patterns |date=2016-04-13 }}{{en}}</ref>

* En una definició: <code>f (vista -> patró) = … ≡ f v | patró <- vista v = … </code>
* En un case: <code>case v of { (vista -> patró) -> e1 ; _ -> e2 } ≡ case vista v of { patró -> e1 ; _ -> e2 }</code>

Exemple a [[#Tipatge dinàmic - Paràmetres de tipus divers]]

==== Definicions d'àmbit local ====
Vegeu "''Let'' vs ''Where''".<ref>[http://www.haskell.org/haskellwiki/Let_vs._Where HaskellWiki - Let vs Where]</ref>
; amb ''where'', estil declaratiu (ús abans de la definició) : permet definir variables esmentades als patrons i guardes de la definició. Cada alternativa pot tenir el seu ''where''.
<syntaxhighlight lang="haskell">
 -- En una definició amb (=) o en una alternativa de case (amb (->))
 -- (EBNF)
 alternativa = patró, (("|", guarda, "=", expressió, -- o bé amb guardes
 { "|", guarda, "=", expressió }) -- guardes addicionals
 | ("=", expressió) -- o bé sense guardes
)
 ["where", declaracions_locals]
</syntaxhighlight>
; amb ''let..in'', estil imperatiu (definició abans de l'ús): cada (''let .. in'') estableix un àmbit on no s'hi pot redefinir un símbol, però es poden establir àmbits (''let .. in'') successius
<syntaxhighlight lang="haskell">
-- ghci
Prelude>let x = 1; y = x in let x = y +1 in print x
2 -- resultat
</syntaxhighlight>

Als blocs d'accions (efectes col·laterals) ''do'', els subblocs ''let'' (que no duen la paraula reservada ''in'' al final) permeten definir expressions basades en resultats d'accions precedents

<syntaxhighlight lang="haskell">
main = do
 s <- getLine -- resultat "<-" efecte
 let x = (read s :: Int)
 y = x+1
 let x = y +2
 print x
</syntaxhighlight>

=== Alternatives if, case ===
<syntaxhighlight lang="haskell">
-- if del haskell98 (en una única línia)
if expr_booleana then expr1 else expr2

-- if del haskell2010, es pot partir en línies
if expr_booleana
 then expr1
 else expr2

case expr of
 patró | guardaA -> exprA
 | guardaB -> exprB
 patró2 | guarda2 -> expr2

-- alternativa múltiple
case () of
 _ | condició1 -> expr1
 | condició2 -> expr2
 | otherwise -> expr3

-- versió moderna (desde GHC v. 7.6.1 !!) requereix pragma d'extensió de llenguatge MultiWayIf:
{-# LANGUAGE MultiWayIf #-}
if | x == 0 -> ...
 | x > 1 -> ...
 | x < 0 -> ...
 | otherwise -> ...
</syntaxhighlight>

=== Iteracions funcionals sense efectes col·laterals ===
Amb [[recursivitat]] els casos queden més clars de cara a assegurar-ne la finalització. Vegeu [[funció recursiva]]
<syntaxhighlight lang="haskell">
bucle params = if condició params
 then {- cas simple -} expressió
 else {- cas recursiu -} bucle $ següent params
 where
 següent params = ...
</syntaxhighlight>

=== Operadors ===
* Associativitat especificant {''infixl'': per l'esquerra | ''infixr'': per la dreta | ''infix'': no associatiu}
* Precedència (0..9). Vegeu taula.<ref name="precedencies"/>

Per defecte: màxima precedència i associativitat per l'esquerra (<code>infixl 9</code>)

<syntaxhighlight lang="haskell">
 (++) :: [a] -> [a] -> [a] -- concatenació de dues llistes
 infixr 5 ++

 [] ++ ys = ys -- cas simple
 (x:xs) ++ ys = x : (xs ++ ys) -- cas recursiu
</syntaxhighlight>

=== operadors de funcions ===
Vegeu ref.<ref name="data-function"/>

(.) composició:

<syntaxhighlight lang="haskell">
-- ús: punt envoltat d'espais
 f. g -- un robot de la viquipèdia malinterpreta els punts com a punt de final de frase i n'elimina els espais precedents
</syntaxhighlight>

($) aplicació normal (tardana) <code>f $ x = f x</code>. Permet estalviar parèntesis en aplicar operacions sobre el darrer paràmetre quan és una expressió (hi ha més d'un terme) o bé la part esquerra és una composició de funcions.
:Restricció: Hi ha objeccions a la seva aplicació en cas que el paràmetre o el retorn siguin funcions polimòrfiques que no tinguin declaració de tipus.<ref name="dolar_i_monomorfisme"/>

<syntaxhighlight lang="haskell">
f $ g $ x + y ≡ f (g (x + y))

f. g $ x ≡ (f. g) x

-- exemple:
print $ "el resultat és" ++ show result
-- en comptes de
print ("el resultat és" ++ show result)
</syntaxhighlight>

==== lectura de dreta a esquerra en la composició amb (.) ====
En aplicar una composició de funcions <code>''<nowiki>(f. g. h) obj</nowiki>''</code> sobre una variable o expressió, l'entendrem més fàcilment si les analitzem tenint en compte el tipus de l'objecte (domini) de l'aplicació i llavors les funcions que s'hi apliquen, començant per l'última de la composició, en sentit de dreta cap a l'esquerra.

Es pot escriure la composició a l'estil de flux de dades (d'esquerra a dreta), amb l'operador d'aplicació cap enrere (&) definit a Data.Function desde GHC 7.10.1
<syntaxhighlight lang="haskell">
import Control.Exception (assert)
import Control.Category ((>>>)) -- morfismes definits a la classe Category. Les funcions la implementen!
import Control.Monad
import Data.Function ((&)) -- (&) = flip ($) -- infixl 1 -- desde GHC 7.10.1

obj = "0"
f = (++"3")
g = (++"2")
h = (++"1")

estil0 = f (g (h obj)) -- pels aimants dels parèntesis (enyorats del LISP)
estil1 = f $ g $ h obj -- estil aplicatiu
estil2 = (f. g. h) obj -- estil funcional
estil3 = (h >>> g >>> f) obj -- estil transformacional (morfismes)
estil4 = obj & h & g & f -- estil navegació de dades (com a la O.O. obj.mètode),

estils = [estil0, estil1, estil2, estil3, estil4]

main = do
 forM_ estils print -- imprimeix el resultat de cada estil
 assert comprovació $ print "són iguals"
 where
 comprovació = all (== "0123") estils
</syntaxhighlight>

=== [[Currificació]] ===
* ''curry'': converteix una func. d'una Tupla2 en una que admet els paràm. separats
: + possibilita l'aplicació parcial de part dels paràmetres

* ''uncurry'': conv. una funció de dos param. en una que els admet aparellats en Tupla2
<syntaxhighlight lang="haskell">
 curry::((a,b) -> c) -> a -> b -> c

 uncurry::(a -> b -> c) -> (a,b) -> c

 --
 f = \(x,y) -> 2*x+y
 f_currificada = curry f

 assert (f (3, 4) == f_currificada 3 4) "equivalència de currificació"

 -- aplicació parcial
 op :: a -> b -> c
 (`op` segon) :: a -> c
 (primer `op`) :: b -> c
</syntaxhighlight>

=== Traçabilitat dins el codi funcional ===
El codi funcional no permet l'ús de ''print'' (efecte col·lateral). Cal fer servir ''trace'' o bé ''traceStack'' del mòdul ''Debug.Trace''.<ref>[http://www.haskell.org/haskellwiki/Debugging Depuració al Haskell]{{en}}</ref> Imprimeix el primer paràmetre, via ''unsafePerformIO'' i retorna el segon.<ref>[http://hackage.haskell.org/package/base/docs/Debug-Trace.html Debug.Trace - Imprimir traces des del codi funcional]{{en}}</ref>

Atenció: l'ordre d'execució de subexpressions en codi funcional és indeterminat, i igualment ho serà l'ordre d'impressió de les traces.

En codi monàdic (seqüencial), l'ordre d'impressió de les traces, està subjecte al moment de l'avaluació que, per ésser tardana, és difícil de predir amb seguretat.
<syntaxhighlight lang="haskell">
-- prova.hs
import Debug.Trace (trace) -- trace :: String -> a -> a

quadrat x = trace msg resultat
 where
 msg = "traça de quadrat: x: " ++ show x ++ " resultat: " ++ show resultat
 resultat = x * x

cub x = x * quadrat x

main = putStrLn $ "cub de 2: " ++ show (cub 2)
</syntaxhighlight>

A partir de GHC v.7.4.1 hi ha també ''traceStack :: String -> a -> a''<ref>[http://hackage.haskell.org/package/base/docs/Debug-Trace.html#v:traceStack Debug.Trace.traceStack]</ref> que a més bolca la traça de crides si s'ha compilat amb opcions de ''perfilat''.

Substituïm ''trace'' per ''traceStack'' i ...
<pre>
ghc --make -prof -fprof-auto-calls prova.hs
./prova
traça de quadrat: x: 2 resultat: 4
Stack trace:
 Main.quadrat.resultat' (prova.hs:6:17-39)
 Main.cub (prova.hs:10:13-21)
 Main.cub (prova.hs:10:9-21)
 Main.main (prova.hs:12:42-46)
 Main.main (prova.hs:12:36-47)
 Main.main (prova.hs:12:19-47)
 Main.main (prova.hs:12:8-47)
 Main.CAF (<entire-module>)
cub de 2: 8
</pre>

== Comportament: Classes de tipus ==
Els tipus només descriuen el domini de valors.

Les classes designen la interfície (signatures) d'un conjunt d'operacions, amb possible implementació per defecte, parametritzades pel tipus de la classe.

Les classes de tipus no són com les classes de [[C++]], que són classes d'objectes, sinó com els ''Interface'' de [[Java (llenguatge de programació)|Java]], els genèrics de l'[[Ada (llenguatge de programació)|Ada]] o les signatures de [[ML Estàndard|ML]].

Per utilitzar-les amb un tipus concret, cal generar una instància de la classe per al tipus definint-hi la implementació. Les instàncies visibles en l'àmbit, es passen implícitament a les funcions que les requereixen.

* Les instàncies no tenen identificació, no n'hi poden haver dues de la mateixa classe per al mateix tipus al mateix àmbit. Quan s'importa un mòdul s'importen totes les instàncies.<ref name="orphan-instance">[https://wiki.haskell.org/Orphan_instance haskellwiki - Orphan instance]{{en}}</ref>
* Les instàncies no es poden tapar amb altres instàncies.<ref>[https://wiki.haskell.org/Multiple_instances haskellWiki Multiple instances]{{en}}</ref>
* Les instàncies s'han de definir en un dels mòduls on hi hagi, o bé la definició de la classe, o bé la del tipus, altrament seran etiquetades com a instàncies ''òrfenes'' i rebutjades pel compilador.<ref name="orphan-instance"/>
* L'única manera de redefinir instàncies és fer-ho sobre una derivació del tipus amb ''newtype'', esmentant les altres instàncies a la clàusula ''deriving'' amb el mecanisme de l'extensió ''[[#etiquetar tipus bàsics - GeneralizedNewtypeDeriving|GeneralizedNewtypeDeriving]]'' que estalvia la redefinició d'instàncies.<ref name="orphan-instance"/>

=== Especialització, instanciació per tipus ===
L'ús d'operacions que no són de la pròpia classe a les implementacions per defecte, fa necessari requerir la presència, en el context d'ús, d'instàncies de les classes que incorporen les operacions.
<div style="background-color:#f4f6fe; border-style:solid; border-width:1px;">
<syntaxhighlight lang="haskell">
-- per aquells tipus t que implementin les classes requerides
class (ClasseRequeridaA t, ClasseRequeridaB t, ...) => ClasseNova t where ...
</syntaxhighlight>

<syntaxhighlight lang="haskell">

{-# LANGUAGE NamedFieldPuns #-} -- simplificació en literals de registres 
 -- (interpreta 'camp' seguit de separador o delimitador, com a 'camp = camp')
class PropXY t where
 getXY :: t -> (Int, Int)
 setXY :: Int -> Int -> t -> t

-- funcionalitat 2D requereix que el tipus implementi PropXY

class (PropXY t) => IFun2D t where
 desplaça2D :: Int -> Int -> t -> t

 -- implementació per defecte a la classe

 desplaça2D dx dy punt = setXY (x+dx) (y+dy) punt
 where
 (x,y) = getXY punt

data TPunt2D = Punt2D {x, y ::Int}

instance PropXY TPunt2D where
 getXY Punt2D {x, y} = (x, y)
 setXY x y punt = punt {x, y} -- equival a punt {x = x, y = y}

instance IFun2D TPunt2D -- genera una instància per a TPunt2D amb la implementació per defecte
</syntaxhighlight></div>

Vegeu exemple més complet [[#Encapsulament estil O.O.|més avall]]

==== Instanciació genèrica ====
Quan totes les operacions es basen en operacions de les classes base i no en particularitats d'un tipus, es pot definir la instanciació a nivell de classe amb efecte automàtic. (Requereix l'extensió de llenguatge ''UndecidableInstances'').

<div style="background-color:#f4f6fe; border-style:solid; border-width:1px;">
<syntaxhighlight lang="haskell">
{-# LANGUAGE FlexibleInstances, UndecidableInstances #-}

class PropXY t where
 getXY :: t -> (Int, Int)
 setXY :: Int -> Int -> t -> t

class IFun2D t where
 desplaça2D :: Int -> Int -> t -> t

instance (PropXY t) => IFun2D t where -- (IFun2D t) serà automàtic per a tot tipus t tal que (PropXY t)
 desplaça2D dx dy punt = setXY (x+dx) (y+dy) punt
 where
 (x,y) = getXY punt
</syntaxhighlight></div>

==== Derivació d'instàncies per a tipus paramètrics amb requeriments ====
Amb l'extensió de llenguatge ''StandaloneDeriving'' el compilador permet que afegeixis requeriments de context a la derivació d'instàncies amb clàusules ''deriving'' independents de la definició de l'estructura.<ref>[https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#stand-alone-deriving-declarations GHC - Stand-alone deriving] {{Webarchive|url=https://web.archive.org/web/20180821174039/http://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#stand-alone-deriving-declarations |date=2018-08-21 }}{{en}}</ref>

<syntaxhighlight lang="haskell">
{-# LANGUAGE StandaloneDeriving #-}

data Foo a = Bar a | Baz String

deriving instance Eq a => Eq (Foo [a])
deriving instance Eq a => Eq (Foo (Maybe a))
</syntaxhighlight>

==== Derivació ràpida d'instàncies de classes amb implementació per defecte ====
L'extensió ''DeriveAnyClass'' ho permet.<ref>[http://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#derive-any-class GHC users guide - DeriveAnyClass] {{Webarchive|url=https://web.archive.org/web/20161120032007/http://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#derive-any-class |date=2016-11-20}}{{en}}</ref> Si Bar és una classe on tots els mètodes tenen implementació per defecte

<syntaxhighlight lang="haskell">
data Foo = Foo ...
instance Bar Foo -- sense implementació específica
</syntaxhighlight>

es pot escriure en una sola línia (a banda de la [[pragma]] d'extensió de llenguatge)

<syntaxhighlight lang="haskell">
{-# LANGUAGE DeriveAnyClass #-}

data Foo = Foo ... deriving (Bar)
</syntaxhighlight>

Exemple a [[Compilador Haskell de Glasgow#serialització en format JSON]]

== Tipus derivats -- ''newtype'' ==
''newtype'' defineix un tipus derivat d'un altre tipus (anomenat tipus base) amb possible herència de les instàncies de classes de tipus instanciades pel tipus base.

<syntaxhighlight lang="haskell">
-- defineix el tipus TipusDerivat amb la mateixa representació interna que el tipus base
newtype TipusDerivat = Constructor TipusBase deriving (Classes_quines_instàncies_del_tipusBase_heretarà)
-- o bé
newtype TipusDerivat = Constructor { accessor: TipusBase} deriving ...
</syntaxhighlight>

''newtype''<ref>[http://www.haskell.org/haskellwiki/Newtype Haskellwiki - newtype]</ref> defineix un tipus derivat mitjançant una estructura d'un únic component, el tipus base, mantenint la mateixa representació interna ('''el compilador esborra el constructor''').<ref name="newtype-el-compilador-elimina-el-constructor"/>

''newtype'' defineix un [[morfisme]] (el constructor) del tipus base al derivat, que manté l'estructura de les classes que esmentem a la clàusula ''deriving'' heretant-ne, el tipus derivat, les instàncies. Si el ''newtype'' es defineix com a registre, l'accessor del camp constitueix el morfisme invers.

Per al cas de voler múltiples implementacions d'una classe de tipus (diverses [[relació d'ordre|relacions d'ordre]] o diversos [[monoide]]s), com que les implementacions no tenen nom, cal definir un tipus derivat nou per cadascuna d'elles (vegeu exemple tot seguit).

L'extensió ''GeneralizedNewtypeDeriving'' permet que el tipus definit amb ''newtype'' hereti les instàncies de classes mono-paràmetre, esmentant-les a la clàusula ''deriving'', més enllà de les quatre especificades per la versió Haskell98 del llenguatge (Eq, Ord, Enum, Bounded).<ref name="generalized-newtype-deriving">[https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#ghc-flag--XGeneralizedNewtypeDeriving L'extensió GeneralizedNewtypeDeriving] {{Webarchive|url=https://web.archive.org/web/20180821174039/http://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#ghc-flag--XGeneralizedNewtypeDeriving |date=2018-08-21 }}{{en}}</ref>

<syntaxhighlight lang="haskell">
{-# LANGUAGE GeneralizedNewtypeDeriving #-}

-- | Monoide per a la suma.
newtype Sum a = Sum { getSum :: a }
 deriving (Eq, Ord, Read, Show, Bounded, Generic, Generic1, Num) -- instàncies a heretar

-- el constructor: Sum :: a -> Sum a -- morfisme que manté l'estructura de les classes esmentades
-- l'accessor: getSum :: Sum a -> a -- morfisme invers

instance (Num a) => Monoid (Sum a) where -- Num a => `a` té l'estructura algebraica d'anell 
 mappend (Sum x) (Sum y) = Sum (x + y) -- associativa
 mempty = Sum 0 -- element neutre

-- | Monoide per al producte.
newtype Product a = Product { getProduct :: a }
 deriving (Eq, Ord, Read, Show, Bounded, Generic, Generic1, Num)

instance (Num a) => Monoid (Product a) where
 mappend (Product x) (Product y) = Product (x * y) -- associativa
 mempty = Product 1 -- element neutre
</syntaxhighlight>
ús:
<syntaxhighlight lang="haskell">
import Data.Monoid
import Data.Foldable (Foldable, foldMap)
import Data.Category ((>>>)) -- (>>>): composició esq. a dreta

plegatSuma, plegatProd :: (Num a, Foldable t) => t a -> a
plegatSuma = foldMap Sum >>> getSum
plegatProd = foldMap Product >>> getProduct
</syntaxhighlight>

* Newtype també possibilita l'etiquetatge de tipus bàsics per evitar errors de transposició de paràmetres: "Keyword arguments in Haskell"<ref>[http://blog.ezyang.com/2010/09/keyword-arguments-in-haskell/ Keyword arguments in Haskell]{{en}}</ref>

=== ús dels ''newtypes'' predefinits ===
Els tipus ''All'' i ''Any'' definits amb ''newtype'' per als quals s'implementa un [[Monoide]] per a la conjunció o bé disjunció, permeten un tractament similar en definir els següents quantificadors de col·leccions basats en propietats.

Apliquem el constructor adequat (''All'' o bé ''Any'') als valors i el plegat amb monoide farà servir l'op. definida per al ''newtype'' corresponent. En acabat, caldrà convertir el tipus del resultat amb la inversa del constructor: l'accessor.

<syntaxhighlight lang="haskell">
{-| Ús dels newtype All i Any predefinits a Data.Monoid
-}

import Data.Function ((&)) -- (&) = flip ($) -- aplicació cap enrere
import Control.Category ((>>>)) -- f >>> g = g. f -- composició esq. a dreta

import Data.Monoid (All(..), Any(..))

{-| 
-- de la definició a Data.Monoid

newtype All = All { getAll :: Bool } -- implementa monoid per a la conjunció (&&)
 deriving (Eq, Ord, Read, Show, Bounded, Generic)

newtype Any = Any { getAny :: Bool } -- implementa monoid per a la disjunció (||)
 deriving (Eq, Ord, Read, Show, Bounded, Generic)

-- de Data.Foldable
foldMap :: (Foldable t, Monoid m) => (a -> m) -> t a -> m
-}

existeix, perATots :: Foldable t => (a -> Bool) -> t a -> Bool

-- convertint la sortida de 'prop' al Monoide adequat, i reconvertint el resultat:

existeix prop xs = foldMap (prop >>> Any) xs & getAny
perATots prop xs = foldMap (prop >>> All) xs & getAll

ésParell :: Integral t => t -> Bool
ésParell x = x `mod` 2 == 0

-- versió tàcita (sense param. formals reduïbles)
ésParell = (`mod` 2) >>> (== 0)

default (Int) -- desambiguació literals numèrics 

mostra = [1,2,3]

main = do
 print $ existeix ésParell mostra
 print $ perATots ésParell mostra
</syntaxhighlight>

=== tipus derivats de funcions ===
També s'utilitza per definir un tipus com a abstracció d'un tipus de funció. Això permet definir operacions de combinació de funcions del tipus específic, com a les [[Fletxa (programació funcional)|Fletxes]]

<div style="background-color:#f4f6fe; border-style:solid; border-width:1px;">
<syntaxhighlight lang="haskell">

 -- sigui, per exemple, f :: a -> [b] -- el tipus de funció sobre el que volem definir operacions
 -- x :: a

 newtype TFiltre a b = Filtre { runFiltre :: a -> [b] }

 -- Constructor: Filtre :: (a -> [b]) -> TFiltre 
 -- Inversa del constructor: runFiltre :: TFiltre -> (a -> [b]) 

 filtre_f = Filtre f -- element del nou tipus aplicant el constructor a la funció

 runFiltre filtre_f -- retorna la funció f original, aplicant la ''inversa_del_constructor''

 runFiltre filtre_f x -- aplica la funció original a x
</syntaxhighlight></div>

== Col·leccions polimòrfiques ==
=== Tipus existencial ===
El tipus existencial (contrari d'universal) designa tipus amb condicionants, i és un mecanisme de tipus per poder acomodar components de tipus divers que tinguin una interfície (operatòria, classe de tipus) en comú i així poder agrupar-los en col·leccions i tractar-ne els elements amb les operacions que comparteixen.

Vegeu <ref>[[b:en:Haskell/Existentially quantified types|tipus existencials en Haskell]]{{en}}</ref>
El ''tipus existencial'', originàriament és una mena de tipus abstracte, relacionat amb registres que poden prendre diverses formes concretes que se'n consideren subtipus, donant lloc a un conjunt de tipus.

<blockquote>
<pre>
(pseudocodi)
T = ∃x { v: x; f: (x -> Int); } -- tipus existencial de registre, variant el tipus x
IntT = { v: Int; f: (Int -> Int); } -- subtipus on x = Int
FloatT = { v: Float; f: (Float -> Int); } -- subtipus on x = Float
</pre>
</blockquote>

* El compilador GHC utilitza la paraula reservada ''forall'' (quantificador ∀), per als tipus existencials apel·lant a un [[isomorfisme]].<ref>[http://www.haskell.org/ghc/docs/latest/html/users_guide/data-type-extensions.html#existential Haskell GHC - Perquè existencial] {{Webarchive|url=https://web.archive.org/web/20100425082929/http://www.haskell.org/ghc/docs/latest/html/users_guide/data-type-extensions.html#existential |date=2010-04-25}}{{en}}</ref><ref>{{Ref-web |url=http://www.haskell.org/ghc/docs/latest/html/users_guide/data-type-extensions.html#existential-quantification |títol=Quantificació existencial |consulta=2010-06-15 |arxiuurl=https://web.archive.org/web/20100425082929/http://www.haskell.org/ghc/docs/latest/html/users_guide/data-type-extensions.html#existential-quantification |arxiudata=2010-04-25}}</ref>

* Altres compiladors de Haskell fan servir la paraula reservada ''exists'' com a quantificador existencial, el EHC/UHC segons la ref.,<ref>[http://www.cs.uu.nl/wiki/bin/view/Ehc/UhcUserDocumentation#3_6_Existential_types Tipus existencial a EHC/UHC amb la paraula reservada ''exists''] {{Webarchive|url=https://web.archive.org/web/20120429171940/http://www.cs.uu.nl/wiki/bin/view/Ehc/UhcUserDocumentation#3_6_Existential_types |date=2012-04-29 }}{{en}}</ref> i el JHC també,<ref>[http://repetae.net/computer/jhc/manual.html#existential-types Tipus existencial al JHC amb la paraula reservada ''exists'']{{en}}</ref> en comptes del ''forall'' del GHC.

Tipificació més habitual, per exemple, objectes amb un component textualitzable (Show a)

<div style="background-color:#f4f6fe; border-style:solid; border-width:1px;">
<syntaxhighlight lang="haskell">
 {-# LANGUAGE ExistentialQuantification #-}

data TObj = forall a. (Show a) => Obj a -- per aquells tipus 'a' textualitzables "(Show a)"

 -- Si l'expressem amb sintaxi GADTs, el quantificador no serà necessari
 {-# LANGUAGE GADTs #-}

 data TObj where
 Obj :: (Show a) => a -> TObj
</syntaxhighlight></div>

; quantificació existencial als registres:
Vegeu ref.<ref name="exist-recs">[https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/data-type-extensions.html#existential-records Existentially quantified - Record constructors] {{Webarchive|url=https://web.archive.org/web/20160314060330/https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/data-type-extensions.html#existential-records |date=2016-03-14 }}{{en}}</ref>
::* No es permeten els camps quantificats existencialment en les actualitzacions de registres.<ref name="exist-recs"/>
::* Cas de sintaxi GADT's els camps quantif. existencialment només poden aparèixer en actualitzacions, si la var. quantificada existencialment apareix individualment en el tipus resultat del ''Constructor'', però no si hi apareix com a paràmetre, per exemple d'una llista.<ref name="exist-recs"/>

; quantificació existencial als àlies de tipus - sinònims liberalitzats:
Admet restriccions existencials, a més d'altres possibilitats.<ref name="liberal-type-syn"/> Per aquells tipus 'b' tals que ''(Show b)'' ...

<syntaxhighlight lang="haskell">
type Discard a = forall b. Show b => a -> b -> (a, String)
</syntaxhighlight>

=== Llistes homogènies d'elements amb components heterogenis ===
Vegeu.<ref name="tipus_existencial">[http://www.haskell.org/haskellwiki/Existential_types Tipus existencial] {{en}}</ref> El [[#Tipus existencial]] permet definir tipus de dades [[Polimorfisme (programació)|polimòrfics]] amb components caracteritzats per admetre un mateix grup d'operacions.

D'aquesta manera es pot treballar amb llistes d'elements que incorporen components de tipus divers que implementin una mateixa classe de tipus, i tractar-los amb les operacions de la classe.

Cal especificar l'opció de compilació "-XExistentialQuantification" o la [[pragma]] {-# LANGUAGE ExistentialQuantification #-}

<div style="background-color:#f4f6fe; border-style:solid; border-width:1px;">
<syntaxhighlight lang="haskell">

{-# LANGUAGE ExistentialQuantification #-}

 -- tipus amb constructor Obj i un component
 -- d'aquells tipus ''a'' que implementin la classe Show

 data ObjPresentable = forall a. (Show a) => Obj a

 llistaHetero :: [ObjPresentable]
 llistaHetero = [Obj 1, Obj "foo", Obj 'c']

 mostra :: [ObjPresentable] -> String
 mostra [] = ""
 mostra (Obj x : []) = show x -- mostra el darrer (la cua és buida)
 mostra (Obj x : xs) = show x ++ ", " ++ mostra xs -- aplica al component x l'operació show
 -- de la classe Show que el component d'Obj implementa
 main = putStrLn $ mostra llistaHetero
--------

-- amb derivació automàtica d'instàncies
deriving instance Show ObjPresentable -- la derivació d'instàncies dels objectes existencials va separada

main = print llistaHetero
</syntaxhighlight></div>

Vegeu-ne l'exemple [[#Col·leccions amb components heterogenis - Emulació del despatx dels mètodes virtuals de la O.O.]]

== Tipatge dinàmic - Paràmetres de tipus divers ==
Haskell admet pas de paràmetres amb control del tipus en temps d'execució, només per a tipus monomòrfics (sense variables de tipus).<ref name="tip-dynamic">[https://hackage.haskell.org/package/base-4.8.2.0/docs/Data-Dynamic.html mòdul Data.Dynamic - tipatge dinàmic bàsic]{{en}}</ref>

Exemple amb l'ús de l'extensió ''ViewPatterns'' (Vegeu [[#Patrons de vistes]])
<syntaxhighlight lang="haskell">
{-# LANGUAGE ViewPatterns, ScopedTypeVariables #-}

import Data.Dynamic

-- fromDynamic :: Dynamic -> Maybe a -- per obtenir un resultat, cal provar-ho amb restricció de tipus: 

-- control dinàmic del tipus del paràmetre, farem servir ViewPatterns: ''(vista -> patró)'' sobre el paràmetre.
printDynamic :: Dynamic -> IO ()
printDynamic (fromDynamic -> Just (x :: Int)) = putStrLn $ "era un Int: " ++ show x
printDynamic (fromDynamic -> Just (x :: Float)) = putStrLn $ "era un Float: " ++ show x
printDynamic (fromDynamic -> Just (xy :: (Int, Int))) = putStrLn $ "era un parell de Ints: " ++ show xy
printDynamic (fromDynamic -> Just (xs :: [Int])) = putStrLn $ "era una llista de Ints: " ++ show xs
printDynamic (fromDynamic -> Just (f :: (Int -> Int))) = putStrLn $ "era una funció (Int -> Int): 2 -> " ++ show (f 2)
printDynamic _ = error "printDynamic: tipus inesperat"

main = do
 printDynamic $ toDyn (1 :: Int)
 printDynamic $ toDyn (-2.5 :: Float)
 printDynamic $ toDyn ((2, 3) :: (Int, Int))
 printDynamic $ toDyn ([1..3] :: [Int])
 printDynamic $ toDyn ((*2) :: Int -> Int)
</syntaxhighlight>
dona
<syntaxhighlight lang="bash">
$ runhaskell prova3
era un Int: 1
era un Float: -2.5
era un parell de Ints: (2,3)
era una llista de Ints: [1,2,3]
era una funció (Int -> Int): 2 -> 4
</syntaxhighlight>

== Seqüències i col·leccions en codi funcional pur ==
Algunes de les funcions següents incorporen en la funció nucli de la iteració un paràmetre a l'entrada i a la sortida interpretable com a estat de la iteració, que evoluciona partint d'un valor inicial ''llavor'' per l'aplicació reiterada de la funció nucli.

=== Seqüències - generació d'una seqüència partint d'un valor ===
És la particularització de Haskell d'un [[Anamorfisme (programació funcional)|Anamorfisme]] o desplegament d'estructures: <code>(b -> a*)</code>.<ref name="meijer-fp-bananas">[http://eprints.eemcs.utwente.nl/7281/01/db-utwente-40501F46.pdf Erik Meijer et al. - Functional programming with Bananas, Lenses, Envelopes and Barbed Wire]{{en}}</ref>

<syntaxhighlight lang="haskell">
-- en un anamorfisme que forma una llista:
anamorf :: (estat -> (valor, estat)) -> (estat -> Bool) -> estat -> [valor]
anamorf desplega ésFinal estat =
 if ésFinal estat
 then []
 else valor : (anamorf desplega ésFinal estat')
 where (valor, estat') = desplega estat
</syntaxhighlight>

Amb la funció ''unfoldr'' ("unfold right", cat: desplega per la dreta) de Data.List. La seqüència s'acaba quan la funció nucli no retorna valor (''Nothing'').

<syntaxhighlight lang="haskell">
unfoldr :: (llavor -> Maybe (item, llavor {-següent-})) -> -- funció nucli per obtenir opcionalment el següent ''ítem''
 llavor {-inicial-} ->
 [item]
</syntaxhighlight>

=== Seqüències - transformació d'una seqüència amb memòria ===
Amb ''mapAccumL'' de Data.List, podem especificar la funció nucli de la iteració, que partint d'un estat i un element de la seqüència ens proporcioni l'estat inicial de la següent iteració, i l'element de la seqüència de sortida.

<syntaxhighlight lang="haskell">
mapAccum{L|R} :: (llavor -> item -> (llavor {-següent-}, item')) -> -- funció nucli de la iteració
 llavor {-inicial-} ->
 [item] {-inicial-} ->
 (llavor {-final-}, [item'])
</syntaxhighlight>

=== Col·leccions - reducció d'una col·lecció a un valor o bé estructura (plegat) - Les classes Foldable/Bifoldable i Monoid ===
És la versió de Haskell d'un [[catamorfisme]] o reducció d'estructures <code>(a* -> b)</code>.<ref name="meijer-fp-bananas"/>

Cal especificar com a paràmetre la funció del plegat:

<syntaxhighlight lang="haskell">

foldl :: (acc -> item -> acc {-següent-}) -> -- funció nucli de la iteració
 acc {-inicial-} ->
 [item] {-inicial-} ->
 acc {-final-}

foldl op acc [] = acc
foldl op acc (x:xs) = foldl op (acc `op` x) xs
</syntaxhighlight>

''foldl'' de Data.List per a llistes ha estat substituïda en el mòdul Prelude per ''foldl'' de Data.Foldable per a col·leccions de tipus genèric.

Vegeu també [[#foldl': iteracions amb plegat per l'esquerra estricte|iteracions a espai constant de la pila amb plegat per l'esquerra estricte]]

* La classe ''Foldable'', del mòdul <code>Data.Foldable</code>, generalitza la reducció per a les col·leccions

<syntaxhighlight lang="haskell">
class Foldable t where
 foldr, foldr' :: (a -> acc -> acc) -> acc -> t a -> acc -- plegat per la dreta, foldr' estricte
 foldl, foldl' :: (acc -> a -> acc) -> acc -> t a -> acc -- plegat per l'esquerra, foldl' estricte
 foldMap :: Monoid m => (a -> m) -> t a -> m -- plegat amb mapeig a un tipus que implementa Monoide
 fold :: Monoid a => t a -> a -- plegat per a col·leccions d'elements que implementen Monoide
 ...
 -- plegats especials
 toList :: t a -> [a] -- foldMap pure 
 null :: t a -> Bool -- existeix algun element: null = foldr (\ _ _ -> False) True
 length :: t a -> Int -- compta els elements: length = foldl' (\ c _ -> c+1) 0
 elem :: Eq a => a -> t a -> Bool -- algun element igual?: elem = any. (==)

 maximum, minimum :: forall a. Ord a => t a -> a -- obté el superior/inferior per a tot element de la col·lecció NO buida
 sum :: Num a => t a -> a -- plegat sobre el monoide (a,+,0)
 product :: Num a => t a -> a -- plegat sobre el monoide (a,*,1)

-- altres plegats
and :: Foldable t => t Bool -> Bool -- plegat sobre el monoide (Bool,&&,True)
or :: Foldable t => t Bool -> Bool -- plegat sobre el monoide (Bool,||,False)
concat :: Foldable t => t [a] -> [a] -- plegat sobre el monoide ([a],++,[])
all, any :: Foldable t => (a -> Bool) -> t a -> Bool -- plegat aplicant predicat
</syntaxhighlight>

* En cas que vulguem avaluació estricta, si l'acumulador és un tipus algebraic convé especificar avaluació estricta explícita als components de l'acumulador, altrament l'avaluació ''HNF'' deixa pendent d'avaluar les expressions dels components, engreixant la pila que pot petar de la mateixa manera que en els ''fold{l|r}'' no estrictes.

; la classe Bifoldable

Des de GHC 8.2 el mòdul Data.Bifoldable proporciona, per a col·leccions d'elements de dominis duals, per ex. (Either a b), la possibilitat de reduir amb dues funcions de plegat, una per cada domini.
<syntaxhighlight lang="haskell">
class Bifoldable t where
 bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> t a b -> m

 bifoldr :: (a -> acc -> acc) -> (b -> acc -> acc) -> acc -> t a b -> acc

 bifoldl :: (acc -> a -> acc) -> (acc -> b -> acc) -> acc -> t a b -> acc
 ...
</syntaxhighlight>

Per cada funció de Data.Foldable hi ha una funció corresp. de Data.Bifoldable anb el prefix ''bi''.

==== Monoides per als plegats ====
* La classe ''Monoid'', del mòdul <code>Data.Monoid</code>, facilita la definició de [[Monoide]]s
* Podem necessitar diferents implementacions de Monoide (ex. per a la Suma i per al Producte), però les instàncies no tenen nom i, per tant, no es poden seleccionar. Cal crear tipus derivats amb ''newtype''<ref>[https://wiki.haskell.org/Newtype Haskell wiki - Newtype]{{en}}</ref> per cada instància addicional. El mòdul Data.Monoid en té uns quants de predefinits.
* Els tipus derivats amb ''newtype'' només poden tenir un sol component (el tipus base). Si estan definits com a registre, l'accessor ens proporcionarà la conversió inversa de la del constructor. No suposen cap sobrecost d'accés, doncs el compilador esborra el constructor.<ref name="newtype-el-compilador-elimina-el-constructor">[https://wiki.haskell.org/Performance/Data_types#Newtypes HaskellWiki - Performance, Newtypes]{{en}} "The newtype constructor will be optimised away."</ref>

<syntaxhighlight lang="haskell">
class Monoid a where
 mappend :: a -> a -> a -- operació associativa del monoide
 mempty :: a -- element neutre del monoide
 ...

-- Hi ha monoides predefinits, per exemple per a la suma i el producte

newtype Sum a = Sum { getSum :: a}

-- * el constructor del ''newtype'' constitueix una funció del tipus base al tipus derivat
-- * l'accessor del ''newtype'' constitueix una funció del tipus derivat al tipus base

instance (Num a) => Monoid (Sum a) where
 mappend (Sum x) (Sum y) = Sum (x + y) -- associativa
 mempty = Sum 0 -- element neutre

newtype Product a = Product { getProduct :: a }
</syntaxhighlight>

Exemple. Plegat de la suma i el producte sobre una col·lecció de numèrics <code>(Num t)</code>, utilitzant els "newtype" respectius:

<syntaxhighlight lang="haskell">
import Data.Monoid (Sum(..), Product(..)) -- importa constructor i accessors del tipus ..
import Data.Foldable (Foldable, foldMap)
import Data.Category ((>>>)) -- composició d'esquerra a dreta: f >>> g == g. f 

plegatSuma, plegatProd :: (Num a, Foldable t) => t a -> a
plegatSuma xs = getSum $ foldMap (Sum) xs

-- alternativa tàcita (sense paràmetres formals reduïbles)
plegatSuma = foldMap Sum >>> getSum 
plegatProd = foldMap Product >>> getProduct
</syntaxhighlight>

=== Col·leccions - composició - les classes Semigroup i Monoid ===
Des de GHC 8.0 s'ha incorporat al paquet ''base'' l'estructura [[Semigrup]] en un mòdul Data.Semigroup amb una operació associativa definida per <code>(<>)</code> amb associativitat <code>infixr 6 <></code>.

Abans ja teníem la classe Monoid de Data.Monoid on ''mappend'' és l'operació associativa que en posició infix (<code>`mappend`</code>) processa associant per l'esquerra (assoc. per defecte: <code>infixl 9</code>), mentre que també es defineix <code>(<>)</code> com a sinònim que processa associant per la dreta (<code>infixr 6 <></code>).

Exemple sobre llistes, conjunts i diccionaris (tots ells implementen les classes Semigroup i Monoid). Els vectors del paquet ''vector'' també.
<syntaxhighlight lang="haskell">
ghci
Prelude> import Data.Semigroup
Prelude Data.Semigroup> [1,2] <> [3,4] -- composició de llistes
[1,2,3,4]

Prelude Data.Semigroup>:set -XOverloadedLists -- extensió OverloadedLists per l'ús de literals llistes en altres tipus
Prelude Data.Semigroup> import Data.Set as S
Prelude Data.Semigroup S> import Data.Map as M
Prelude Data.Semigroup S M> import Data.Vector as V
Prelude Data.Semigroup S M V> ([1,2] :: Vector Int) <> ([3,4] :: Vector Int) -- composició de vectors
[1,2,3,4]

Prelude Data.Semigroup S M V> ([1,2] :: Set Int) <> ([2,3] :: Set Int) -- composició de conjunts
fromList [1,2,3]

Prelude Data.Semigroup S M V> ([(1,"a"), (2,"b")] :: Map Int String) <> ([(2,"b'"), (3,"c'")] :: Map Int String) -- composició de diccionaris
fromList [(1,"a"),(2,"b"),(3,"c'")]
</syntaxhighlight>

=== Col·leccions - aplicació als elements d'una col·lecció ===
==== La classe Functor ====
La classe [[Functor]] descriu una estructura de correspondències entre elements i contenidors que mapeja objectes a objectes i funcions a funcions mantenint la identitat dels objectes i la composició de les funcions en els dos dominis.

Un functor ''F'' és un [[homomorfisme]] que compleix:
:* <math>F(\mathrm{id}_{X}) = \mathrm{id}_{F(X)}\,\!</math> per a tot objecte <math>X</math> del domini d'origen; en Haskell: <code>fmap id ≡ id</code>,
:* <math>F(g \circ f) = F(g) \circ F(f)</math> per a tot morfisme <math>f:X \rightarrow Y\,\!</math> i <math>g:Y\rightarrow Z</math>; en Haskell: <code>fmap (g · f) ≡ (fmap g) · (fmap f)</code>

Això possibilita substituir la composició d'aplicacions de morfismes (<code>(fmap g) · (fmap f)</code>), per l'aplicació de la composició (<code>fmap (g · f) </code>). (Vegeu també [[Desforestació (informàtica)|desforestació]]).

L'operació
''fmap''<ref>[https://hackage.haskell.org/package/base/docs/Data-Functor.html#t:Functor ''Functor'' al mòdul Data.Functor]{{en}}</ref> defineix la correspondència de funcions del domini dels elements al domini dels contenidors mitjançant l'aplicació d'una funció als elements de les col·leccions (ex.: [a]) o bé als resultats dels d'efectes (ex.: IO a) que l'instancien.
<syntaxhighlight lang="haskell">
class Functor t where
 fmap :: (a -> b) -> (t a -> t b) -- aplica una funció als elements de la col·lecció ''t''
 -- o bé si ''t'' és un efecte (ex. IO), al resultat de l'efecte
</syntaxhighlight>

* [[Functor#Els conjunts no són Functor|Els conjunts no l'instancien]]:
Si la funció no és [[funció injectiva|injectiva]] la imatge de diversos elements del domini origen pot coincidir, i en cas de tractar-se d'un conjunt, no preserva la mida de l'original, incomplint la regla de la composició com a l'exemple de la ref.<ref>[https://www.schoolofhaskell.com/user/chad/snippets/random-code-snippets/set-is-not-a-functor Set is not a Functor] {{Webarchive|url=https://web.archive.org/web/20160215214430/https://www.schoolofhaskell.com/user/chad/snippets/random-code-snippets/set-is-not-a-functor |date=2016-02-15}}{{en}}</ref><ref>[http://stackoverflow.com/questions/19177125/sets-functors-and-eq-confusion Sets, Functors and Eq confusion]{{en}}</ref>
:* Tanmateix les implementacions de conjunts aporten la seva operació ''map'' particular, malgrat no implementar ''Functor''.

* Els tipus monomòrfics (que no incorporen paràmetres, com ara Text, ByteString) tampoc. (El tipus ha de venir parametritzat amb el tipus de l'element)
:* El paquet ''mono-traversable'' aporta una solució vàlida per a totes les col·leccions siguin paramètriques o monomòrfiques, basada en classes genèriques i, per als tipus dependents, "tipus associats" (Index t, ContainerKey t, MapValue t) o bé ''[[#Famílies de tipus]]'' (Element t).

==== La classe Bifunctor ====
Des de GHC 8.2 el paquet base estén els ''Functors'' a les col·leccions d'elements amb domini dual (per ex.: <code>Either a b</code>) amb mapeig que incorpora funcions per cadascun dels dominis. Del mòdul ''Data.Bifunctor''

<syntaxhighlight lang="haskell">
class Bifunctor p where

 bimap :: (a -> b) -> (c -> d) -> p a c -> p b d

 first :: (a -> b) -> p a c -> p b c
 second :: (b -> c) -> p a b -> p a c
</syntaxhighlight>

==== Functors contravariants - la classe Contravariant ====
Quan el contingut del contenidor és una funció, es pot definir un Functor sobre el domini dels arguments (posicions contravariants) de la funció.

La covariança i contravariança es fa servir més als llenguatges que implementen subtipatge. [[Scala (llenguatge de programació)#Relacions de Subtipus, Covariança, Contravariança|Subtipatge, covariança i contravariança a Scala]]

Al paquet ''contravariant''.<ref>[https://hackage.haskell.org/package/contravariant El paquet contravariant]{{en}}</ref>

<syntaxhighlight lang="haskell">
newtype Predicat a = Predicat {getPredicat :: a -> Bool} -- tipus 'a' en posició contravariant

newtype Comparació a = Comparació {getComparació :: a -> a -> Ordering} -- tipus 'a' en posició contravariant

-- Donada una relació 'f' en el conjunt del tipus 'b', una projecció (a -> b) estableix la relació en el conjunt del tipus 'a' entre aquells elements quines imatges formin part de la relació.
class Contravariant f where
 contramap :: (a -> b) -> f b -> f a
 ...

-- contramap sobre el newtype Comparació, que defineix una relació d'ordre, confereix ordenació al domini origen de la projecció

-- per exemple: una projecció sobre parells:
ghci
Prelude> import Data.Functor.Contravariant as C
Prelude C> import Data.Function as F ((&))

-- apliquem amb "contramap" una projecció "snd" cap al domini contravariant de Comparison, obtenint un Comparison sobre l'origen de la projecció, els parells
Prelude C F> let f = contramap snd (Comparison compare) 
Prelude C F> :t f -- el tipus del resultat és Comparison sobre parells, comparant pel segon de la tupla
f :: Ord a1 => Comparison (a, a1)
</syntaxhighlight>

==== Profunctors ====
Un ''Profunctor'' és un Bifunctor que és contravariant en el domini del primer paràmetre de tipus i covariant en el segon.

Per tant, podem qualificar el primer paràmetre com a entrada, i el segon com a sortida (Les funcions en serien una instància donat que els paràm. d'una funció són contravariants i la sortida covariant).

Podem implementar els profunctors en tot allò que tingui un o més arguments (posició contravariant) del domini del primer paràmetre de tipus i un resultat (posició covariant) del segon paràmetre de tipus.

L'objectiu és poder aplicar simultàniament un ''contramap'' (funció incident) al domini contravariant (l'entrada) i un ''map'' (funció sortint) al domini covariant (la sortida), obtenint un nou ''profunctor'' sobre els dominis origen del ''contramap'' i el de destí del ''map''.

Al paquet ''profunctors''.<ref>[https://hackage.haskell.org/package/profunctors El paquet profunctors]{{en}}</ref>

<syntaxhighlight lang="haskell">
class Profunctor p where
 dimap :: (a -> b) -> (c -> d) -> p b c -> p a d
</syntaxhighlight>

Exemple d'instàncies de Profunctors són
* les funcions: <code>((-&gt;) a b)</code>
* les Fletxes: <code>(Arrow p => p a b)</code> (vegeu secció d'[[#Efectes fletxa|efectes fletxa]])

Els ''profunctors'' poden ser base per a les [[#Lents basades en profunctors|Lents]].<ref>[https://hackage.haskell.org/package/lens/docs/Control-Lens-Iso.html paquet "lens" - lents per a isomorfismes] {{en}}</ref><ref>[https://hackage.haskell.org/package/mezzolens/docs/Mezzolens-Optics.html Mezzolens - Lents basades en profunctors] {{en}}</ref>

== Efectes ==
Un efecte és un possible canvi (d'estat, de l'entorn, una excepció, una fallada de càlcul (resultat no definit)), amb la possible producció d'un, diversos o bé cap resultat, que recomani seqüenciar les operacions que en depenguin per aconseguir la constància del resultat per a les mateixes entrades.

Es representa amb un tipus parametritzat pel tipus del resultat, com ara <code>(IO tipusDelResultat)</code>.
* efecte simple: quan sempre hi ha resultat (representable amb ''(Efecte a)'').
* efecte fallada: quan no sempre s'obté resultat (Les mònades amb [[element absorbent]] per l'esquerra en <code>(>>=)</code> en faciliten l'ús,<ref>[https://wiki.haskell.org/MonadPlus_reform_proposal MonadPlus reform proposal]{{en}}</ref> per ex.: un tipus ''opcional'': ''(Maybe a)''). Vegeu [[Mònada (programació funcional)#Mònades amb efecte fallada|Mònades amb efecte fallada]]. La implementació de l'[[element absorbent]] per l'esquerra en <code>(>>=)</code> fa innecessari la comprovació de la correctesa a cada encadenament.
* efecte múltiple amb possible fallada: diversos resultats o bé cap. Vegeu [[Mònada (programació funcional)#La classe MonadPlus (computacions amb solucions múltiples)|la classe MonadPlus]], que permet la composició de resultats amb un [[Monoide]].

Exemples:
* IO ''a'' : efectes superficials (ent/sortida, vars. globals, excepcions) amb resultat de tipus 'a'
* ST ''s a'' : encapsulament d'actualitzacions destructives (vars. locals amb cicle de vida limitat a l'àmbit i avaluació del càlcul)
:: (La variable ''s'' representa l'espai d'avaluació de l'efecte)
* Maybe ''a'' : efecte fallada, resultat opcional de funcions parcialment definides.
* Either ''err'' ''a'': efecte fallada amb info. de l'error, resultat de l'avaluació de codi de resultat incert. (<code>try acció_que_pot_disparar_excepcions</code>)

=== Composició d'efectes - Combinació o bé encadenament de resultats ===
* La classe Applicative possibilita combinar els resultats de diverses accions amb una funció combinadora elevada al tipus de l'efecte. Defineix la composició d'un efecte amb resultat funció amb un efecte subseqüent sobre quin resultat s'aplicarà la funció resultant de l'efecte precedent. Com que en aplicar una funció de N paràmetres sobre un valor s'obté una funció de <code>(N-1)</code>, podrem combinar els resultats d'una seqüència de N efectes amb un efecte que tingui per resultat una funció de N paràmetres o bé un constructor de N components. Vegeu [[Functor aplicatiu]]

* La classe Mònada possibilita la composició d'efectes mitjançant l'encadenament (>>=) combinant un efecte amb una funció d'efectes sobre el resultat de l'efecte precedent. Vegeu [[Mònada (programació funcional)]]

* La classe Arrow (cat:Fletxa) generalitza les mònades prenent les funcions amb efecte de la mònada, fixant-ne el tipus de l'entrada, modelant la seqüència d'efectes com un encadenament de funcions d'efectes col·laterals. Per poder efectuar càlculs amb els resultats en una seqüència d'efectes, caldrà aparellar el resultat precedent amb l'actual, i utilitzar el tractament de parells que les ''fletxes'' inclouen. Vegeu [[Fletxa (programació funcional)]]

El model ''Applicative'' no seqüència les computacions sinó només la seva engegada i per això s'utilitza en la combinació de processos paral·lels, mentre que en els altres models el resultat de la computació precedent s'ofereix de paràmetre de la següent.

==== Efectes aplicatius ====
Efectes que implementen la classe ''Applicative''.<ref name="applicative">[http://hackage.haskell.org/package/base/docs/Control-Applicative.html#t:Applicative classe ''Applicative'']{{en}}</ref>

===== Generació d'efectes aplicatius =====
* A la classe Applicative (mòdul Control.Applicative) ''"pure"'' eleva un valor (funcions incloses) a la categoria d'efecte aplicatiu (que implementa Applicative).

<syntaxhighlight lang="haskell">
-- generador
pure :: tipResultat -> efecte tipResultat

-- exemple
instance Applicative Maybe where
 pure = Just 
 ...

-- ús habitual, tenint en compte que (<*>) :: efecte (a -> b) -> efecte a -> efecte b
-- combina els resultats de N accions amb un combinador de N paràmetres

combinaNAccions :: (a1 -> a2 -> ... -> aN -> r) :: efecte r
combinaNAccions combinadorAmbNParàmetres = (pure combinadorAmbNParàmetres) <*> acció1 <*> acció2 <*> ... <*> accióN
</syntaxhighlight>

===== Combinació de resultats d'efectes aplicatius =====
* La classe Applicative facilita la combinació dels resultats d'una seqüència d'efectes amb un combinador (funció, o bé un constructor), elevat a la categoria d'efecte. És com aplicar la funció o constructor elevats a efecte, als resultats dels efectes com a paràmetres.
:* El generador ''pure'' servirà per elevar el combinador (funció o bé constructor) a la categoria d'efecte.
:* La funció ''fmap'' si s'aplica a un combinador de diversos paràmetres sobre un efecte, retorna un efecte funció aplicable sobre la resta de paràmetres.
:* Applicative no pressuposa la seqüenciació dels efectes col·laterals sinó només la seva engegada, doncs els efectes poden executar-se en paral·lel i esperar que acabin per combinar-ne els resultats, com ara el cas de l'efecte aplicatiu [[Haskell concurrent#L'efecte Concurrently|Concurrently]] que combina resultats d'accions executades en paral·lel.

<syntaxhighlight lang="haskell">
class (Functor efecte) => Applicative efecte where
 pure :: tipResultat -> efecte tipResultat -- l'utilitzarem per elevar el combinador a la categoria de l'efecte.

 -- (<*>) aplica la funció resultant del primer efecte, al resultat del segon
 -- si la funció té N paràmetres, el resultat serà una funció de (N-1) paràmetres que es podrà combinar amb els resultats de (N-1) efectes subsegüents
 (<*>) :: efecte (a -> b) -> efecte a -> efecte b 

 -- (*>) i (<*) seqüencien dos efectes, retornant només un dels resultats
 (*>) :: efecte a -> efecte b -> efecte b 
 (<*) :: efecte a -> efecte b -> efecte a 

instance Applicative Maybe where
 pure = Just

 Just f <*> acció = fmap f acció
 Nothing <*> _ = Nothing
 ...
</syntaxhighlight>

Exemple combinant amb el constructor de Tupla2:
<syntaxhighlight lang="haskell">
-- (,) :: a -> b -> (a, b)
-- pure (,) :: efecte (a -> b -> (a, b)) -- pure eleva el constructor (,) a la categoria d'efecte
aparellaDuesEntrades = pure (,) <*> llegeixPrimer <*> llegeixSegon

-- fmap de la classe Functor (base per a la Applicative) sobre la funció i el primer efecte
fmap :: (a -> b) -> efecte a -> efecte b -- si la funció. té més d'un param. (''b'' és una funció)
 -- podrem combinar el resultat de fmap amb (<*>)
aparellaDuesEntrades = (fmap (,) llegeixPrimer) <*> llegeixSegon -- els parèntesis són per subratllar (no fan falta)

-- substituint fmap per l'operador infix equivalent (<$>) tenim la forma més utilitzada
aparellaDuesEntrades = (,) <$> llegeixPrimer <*> llegeixSegon
</syntaxhighlight>

==== Efectes monàdics ====
Efectes que implementen la classe ''Monad''.<ref name="monad">[http://hackage.haskell.org/package/base/docs/Control-Monad.html#t:Monad classe ''Monad'']{{en}}</ref>

===== Generació d'efectes monàdics =====
* A la classe [[mònada (programació funcional)|Mònada]] (mòdul Control.Monad) ''"return"'' eleva un valor a la categoria d'efecte monàdic (que implementa Monad).

<syntaxhighlight lang="haskell">
-- generador
return :: tipResultat -> efecte tipResultat

-- exemple
instance Monad Maybe where
 return = Just 
 ...

-- els efectes monàdics tenen una sintaxi especial en els blocs 'do' explicats més avall.
acció params = do
 ...
 return resultat -- return genera un valor mònada amb el paràm. com a resultat
</syntaxhighlight>

Actualment la classe Applicative és base per a la classe Monad, i <code>return = pure</code>, i <code>(>>) = (*>)</code>

===== Seqüenciació d'efectes monàdics =====
* A la classe [[mònada (programació funcional)|Mònada]] (mòdul Control.Monad) ''(&gt;&gt;=)'' encadena un efecte amb una funció efecte sobre el resultat de l'efecte precedent.

<syntaxhighlight lang="haskell">
class (Applicative efecte) => Monad efecte where
 return :: tipResultat -> efecte tipResultat

 (>>=) :: efecte a -> (a -> efecte b) -> efecte b

-- exemple:
llegeixData = llegeixDia >>= (\ dia -> llegeixMes >>= (\ mes -> if ésVàlidDiaDelMes dia mes
 then return $ construeixData dia mes
 else ioError $ userError "data incorrecta"
))

-- (>>) encadena dues accions, ignorant el resultat de la primera
 (>>) :: Monad efecte => efecte a -> efecte b -> efecte b

 -- (>>) s'expressa en termes de (>>=)
 m_x >> m_y = m_x >>= (\ _ -> m_y) 
</syntaxhighlight>

Actualment la classe ''Applicative'' és base per a la classe ''Monad'' i els operadors corresp. ofereixen la mateixa operatòria<code>(>>) = (*>)</code>

Les funcions del mòdul [[mònada (programació funcional)#Control imperatiu|Control.Monad]] (''forM_'' llista acció, ''forever'' acció, replicateM_ n acció) fan la feina de les clàusules de control imperatiu d'altres llenguatges (''forEach'', ''while true do ...'', ''for i = 1 to n do ...'').<ref name="biblio-base">[http://www.haskell.org/ghc/docs/latest/html/libraries/ Biblioteca Base de GHC - vegeu mòduls marcats Base]{{en}}</ref>

Vegeu també [[Mònada (programació funcional)#Seqüències de computacions sense lligar resultats - Functors aplicatius|Combinadors aplicatius partint de mònades]]

==== Efectes fletxa ====
Vegeu ref.<ref name="arrows-general">[https://www.haskell.org/arrows/ Arrows: A General Interface to Computation]</ref>

Una fletxa, concepte desenvolupat per [[John Hughes]], és una generalització d'una funció on el resultat pot dependre d'efectes col·laterals o bé ser independent de l'entrada.<ref name="arrows-general"/> Es concreta en les classes ''Category''<ref name="category">[http://hackage.haskell.org/package/base/docs/Control-Category.html#t:Category classe ''Category'']{{en}}</ref> (que generalitza les funcions amb paràmetres pel tipus de l'entrada i de la sortida) i la seva especialització ''Arrow''<ref name="arrow">[http://hackage.haskell.org/package/base/docs/Control-Arrow.html#t:Arrow classe ''Arrow'']{{en}}</ref> que refina les categories amb el tractament de parells, necessari per combinar-ne resultats. Vegeu [[Fletxa (programació funcional)#Fletxes i Parells]]

===== Generació d'efectes fletxa =====
* A la classe Arrow (mòdul Control.Arrow) ''"arr"'' eleva una funció a la categoria d'efecte fletxa (computacions amb tractament de parells).

<syntaxhighlight lang="haskell">
-- generador
arr :: (tipEntrada -> tipResultat) -> efecte tipEntrada tipResultat
</syntaxhighlight>

Les [[Fletxa (programació funcional)|fletxes generalitzen les mònades]]. Podem convertir qualsevol funció d'efectes monàdics <code>(a -> efecte b)</code> en una Fletxa de Kleisli, prefixant-la amb el constructor ''Kleisli''.

<syntaxhighlight lang="haskell">
-- del mòdul Control.Arrow del paquet ''base''

newtype Kleisli efecte a b = Kleisli { runKleisli :: a -> efecte b }

-- inclou una instància de Fletxa per al tipus Kleisli
instance Monad efecte => Arrow (Kleisli efecte) where ...
</syntaxhighlight>

A ghci:
<syntaxhighlight lang="haskell">
* Prelude Control.Arrow> let funMonàdica = return

* Prelude Control.Arrow> :t funMonàdica
funMonàdica :: (Monad m) => a -> m a

* Prelude Control.Arrow> :t (Kleisli funMonàdica)
Kleisli funMonàdica :: (Monad m) => Kleisli m a a
</syntaxhighlight>

===== Seqüenciació d'efectes fletxa =====
* La classe Category (mòdul Control.Category)<ref name="ctrl-cat">[http://hackage.haskell.org/package/base/docs/Control-Category.html Control.Category]{{en}}</ref> generalitza els morfismes, la classe [[Fletxa (programació funcional)|Arrow]]<ref name="ctrl-arr">[http://hackage.haskell.org/package/base/docs/Control-Arrow.html Control.Arrow]{{en}}</ref> especialitza les categories amb el [[Fletxa (programació funcional)#Fletxes i Parells|tractament de parells, necessari per les computacions amb fletxes]]. Les funcions també implementen les categories.

Encadenament de computacions:

<syntaxhighlight lang="haskell">
 -- els morfismes venen parametritzats pel tipus de l'entrada i el tipus del resultat
 class Category cat where
 id :: cat a a -- morfisme identitat
 (.) :: cat b c -> cat a b -> cat a c -- composició de morfismes de dreta cap a l'esquerra

 (>>>) :: Category cat => cat a b -> cat b c -> cat a c -- composició de morfismes (d'esq. a dreta)
 (<<<) :: Category cat => cat b c -> cat a b -> cat a c -- sinònim de (.)

 -- les funcions (a -> b) implementen Category
 -- els efectes fletxa s'hi basen.
</syntaxhighlight>

La composició de fletxes ha de mantenir l'operació generadora (''arr'') i el tractament de parells.<ref name="ctrl-arr"/>

<syntaxhighlight lang="haskell">
class (Category efecte) => Arrow efecte where

 arr :: (b -> c) -> efecte b c -- eleva una funció a la categoria d'efecte fletxa

 -- first converteix un efecte fletxa en un altre sobre parells, actuant sobre el primer element.
 first :: efecte b c -> efecte (b, d) (c, d)
 ...

arr (f >>> g) ≡ arr f >>> arr g -- per a les funcions f i g

first (f >>> g) ≡ first f >>> first g -- per a les fletxes f i g
</syntaxhighlight>

Exemples: [[Fletxa (programació funcional)#Ent./Sort. amb fletxes de Kleisli (mònades elevades a fletxes)|Ent./Sort. amb fletxes de Kleisli]] (mònades elevades a fletxes) i el [[#Fletxes - Procés de XML|tractament de XML amb fletxes sobre subarbres XML]].<ref name='hxt'>[http://www.haskell.org/haskellwiki/HXT Introducció planera a "Haskell XML Toolbox"] {{en}}</ref>

Compiladors que suporten Fletxes: GHC,<ref>{{Ref-web |url=http://www.haskell.org/ghc/docs/latest/html/users_guide/arrow-notation.html |títol=Fletxes (Arrows) a GHC |consulta=2010-01-03 |arxiuurl=https://web.archive.org/web/20071014174133/http://haskell.org/ghc/docs/latest/html/users_guide/arrow-notation.html |arxiudata=2007-10-14}}</ref> [[Hugs]]<ref>{{Ref-web |url=http://cvs.haskell.org/Hugs/pages/libraries/base/Control-Arrow.html |títol=Fletxes (Arrows) a l'intèrpret Hugs |consulta=2010-01-03 |arxiuurl=https://web.archive.org/web/20090616000905/http://cvs.haskell.org/Hugs/pages/libraries/base/Control-Arrow.html |arxiudata=2009-06-16}}</ref>

=== Entrada / Sortida - Mònades ===
Les operacions d'entrada/sortida produeixen efectes a l'entorn i un resultat programàtic opcional en forma de valor (cas d'entrada), es representa amb el tipus ''(IO a)''. En cas de sortida, es retorna el valor buit ''()'', resultant el tipus ''(IO ())''.

Per la seqüenciació d'operacions s'utilitza preferentment la classe [[mònada (programació funcional)|mònada]] sobre el tipus ''(IO a)'', donant lloc a la mònada IO.

La funció inicial ''main'' de qualsevol programa ha de ser una expressió d'operacions d'ent./sortida i, per tant, del tipus de la [[mònada (programació funcional)|mònada]] IO.

La funció ''evaluate'' permet seqüenciar com a efecte IO, les excepcions que pot llançar una expressió funcional pura.

Les accions de lectura/escriptura de [[#Canvis d'estat - Variables|variables globals]] IORef també formen part dels efectes IO.

<div style="background-color:#f4f6fe; border-style:solid; border-width:1px;">
<syntaxhighlight lang="haskell">
 -- expressions de la ''mònada'' IO (el tipus porta com a paràmetre el tipus del resultat de les operacions)
 getLine -- captura línia d'entrada amb resultat String -- tipus ''IO String''
 getLine >>= putStr -- imprimeix línia introduïda (resultat buit) -- tipus ''IO ()''
 putStr "polseu Intro" >> getLine >> putStrLn "Fet" >> return True -- (resultat de la cadena: booleà) tipus ''IO Bool''
 return "abc" >>= putStrLn -- estableix "abc" com a resultat monàdic i l'imprimeix tot seguit

 -- >>= -- encadena amb una funció efecte que s'aplica al resultat de l'efecte precedent
 -- >> -- encadena amb un altre efecte, ignorant el resultat del precedent
 -- return x -- op. generadora d'una mònada amb resultat x quedant del tipus IO X
 -- no pressuposa ''retorn'' d'enlloc; per ex. (return 5 >>= print)

 -- fail missatge -- cridada internament, cas que el patró a l'esquerra de (<-) en un bloc 'do' no sigui exhaustiu.
 -- des de GHC 8.0 la funció 'fail' se separa de la classe Monad i va a la classe MonadFail amb instàncies per als tipus IO i Maybe.
</syntaxhighlight></div>

==== Blocs ''Do'': notació especial de les expressions monàdiques ====
Encadenament de les instruccions d'un bloc. Vegeu [[mònada (programació funcional)#Blocs do: notació especial de les expressions monàdiques|mònada - Blocs Do]]

La clàusula ''do'' exposa l'encadenament d'efectes de manera seqüencial, amb una expressió monàdica per línia, introduint l'estil imperatiu.

{| class=wikitable
|+ correspondència
|-
! sintaxi !! mònada !! expressió equivalent || comentari
|-
| rowspan=2| <code>patró <- acció; e</code> || Mònada amb mètode ''fail''<br/>per si falla l'encaix || <code>let { f&nbsp;patró = e ;<br/>f&nbsp;_ = fail&nbsp;"error ..." }</code><br/><code>in acció >>= f</code> || mònada Monad a GHC &lt; 8.8<ref name="monadfailprop">[https://wiki.haskell.org/MonadFail_Proposal Proposta MonadFail]</ref> <br/>o bé mònada MonadFail a GHC &gt;= 8.0<ref>[http://hackage.haskell.org/package/base/docs/Control-Monad-Fail.html Control.Monad.Fail]</ref>

|-
| Mònada sense mètode ''fail''.<br/>L'encaix haurà de ser irrefutable || <code>acció >>= (\ patró -> e)</code> || mònada ''Monad'' des de GHC &gt;= 8.8<ref name="monadfailprop"/>
|-
| <code>acció; e</code> || || <code>acció >> e</code> ||
|-
| <code>let {x = v1; y = v2} ; e</code> || || <code>let {x = v1; y = v2} in e</code> || el bloc del let es pot expressar amb sagnat<br/>aliniant el sagnat a la primera variable
|}

<div style="background-color:#f4f6fe; border-style:solid; border-width:1px;">
<syntaxhighlight lang="haskell">
-- exemple de bloc 'do'
bloc = do
 x <- getLine -- (<-) separa sintàcticament el resultat de l'efecte que el produeix
 putStrLn "Has teclejat: "
 putStrLn x
 return x

-- el patró (resultat "<-" efecte (";"|"\n") resta_del_bloc) 
-- es tradueix per (efecte >>= \ resultat -> resta_del_bloc)
-- les altres línies s'encadenen amb (>>) que ignora el resultat de l'efecte precedent

-- equivalent amb expressions monàdiques
bloc = getLine >>= \ x -> (-- encadena amb una lambda (funció anònima)
 -- la resta del bloc s'engloba al cos de la lambda
 -- permetent l'accés a la variable a totes les expressions del bloc
 putStrLn "Has teclejat: " >>
 putStrLn x >>
 return x
) -- el parèntesi només és per explicitar que l'abast d'una lambda és el màxim 
</syntaxhighlight></div>

Vegeu també [[Mònada (programació funcional)#Recursivitat en els blocs do|Recursivitat en les definicions als subblocs ''let'', i també, recursivitat en els efectes en subblocs ''rec'']]

===== Seqüències i efectes - la classe ''Traversable'' =====
Permet l'avaluació seqüencial dels elements d'una col·lecció travessable d'esquerra a dreta si són efectes o bé de les imatges del mapeig dels elements amb una funció d'efectes <code>(a -> efecte b)</code>. Vegeu el mòdul Data.Traversable.<ref name="data-traversable">[https://hackage.haskell.org/package/base/docs/Data-Traversable.html mòdul Data.Traversable]{{en}}</ref>

* Traversable i efectes aplicatius (que implementen Applicative)

<syntaxhighlight lang="haskell">
class (Functor t, Foldable t) => Traversable t

 -- 'traverse' avalua seqüencialment les imatges d'aplicar una funció d'efectes aplicatius als elements d'una col·lecció
 traverse :: Applicative efecte => (a -> efecte b) -> t a -> efecte (t b)

 -- 'sequenceA' avalua seqüencialment els elements d'una col·lecció d'efectes aplicatius 
 sequenceA :: Applicative efecte => t (efecte a) -> efecte (t a) 
 sequenceA xs = traverse id xs
</syntaxhighlight>

* Traversable i efectes monàdics (que implementen Monad)

<syntaxhighlight lang="haskell">
class (Functor t, Foldable t) => Traversable t

 -- 'mapM' avalua seqüencialment les imatges d'aplicar una funció d'efectes monàdics als elements d'una col·lecció
 mapM :: Monad efecte => (a -> efecte b) -> t a -> efecte (t b)

 -- 'sequence' avalua seqüencialment els elements d'una col·lecció d'efectes monàdics 
 sequence :: Monad efecte => t (efecte a) -> efecte (t a)
 sequence xs = mapM id xs
</syntaxhighlight>

* Des de GHC 8.2 la classe ''Bitraversable'' ofereix una operativa similar per a col·leccions d'elements de domini dual, per ex. (Either a b)

<syntaxhighlight lang="haskell">
class (Bifunctor t, Bifoldable t) => Bitraversable t where
 -- bitraverse avalua seqüencialment les imatges d'aplicar una funció d'efectes monàdics als elements d'una col·lecció
 -- proporcionant una funció diferent per als elements segons el domini.
 bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> t a b -> f (t c d) 
 ...
</syntaxhighlight>

* ''forM'' equival a ''mapM'' amb els paràmetres intercanviats.
* hi ha versions amb un guió baix al final per quan només interessa l'efecte col·lateral descartant els resultats (resultat buit com a ''(IO ())''). ''forM_'' equival al ''forEach'' d'altres llenguatges.

<syntaxhighlight lang="haskell">
import Control.Monad (forM, forM_)

-- forM avalua seqüencialment una funció efecte per als elements d'una llista
-- i retorna la llista de resultats com a resultat de l'efecte

imprimeix_i_retorna_dobles :: [Int] -> IO [Int]
imprimeix_i_retorna_dobles xs = forM xs $ \x -> do -- per cada x de la llista xs
 let y = 2 * x
 print y
 return y

-- el bloc ''do'' és un artifici sintàctic per encadenar instruccions d'efectes
-- per una de sola no paga la pena.

imprimeix_dobles :: [Int] -> IO ()
imprimeix_dobles xs = forM_ xs $ \x -> -- les versions amb guió baix al final (forM_) retornen (IO ())
 print $ 2 * x -- no cal fer un bloc ''do'' per una sola instrucció d'efectes
</syntaxhighlight>

* Bloc ''do'' com a paràmetre:

El bloc ''do'' no és més que un artifici sintàctic per escriure una expressió de tipus [[mònada (programació funcional)|mònada]], una acció formada per l'encadenament d'accions amb funcions d'efectes sobre el resultat de l'acció precedent. Com a tal expressió es pot posar com a paràmetre.

Aquí el posem com a paràmetre (operand de '$') d'un llaç (''Monad.forever'') amb control d'excepcions.

($) és una funció amb polimorfisme de rang 1 (Vegeu ''rank-n polymorphism''), i no admet funcions polimòrfiques com a paràmetre.

<div style="background-color:#f4f6fe; border-style:solid; border-width:1px;">
<syntaxhighlight lang="haskell">

import Control.Monad as Monad

main = do
 print "Farem l'eco fins que l'entrada sigui buida."
 catch(
 Monad.forever $ do -- bucle infinit, caldrà una excepció per sortir-ne
 x <- getLine
 case x of
 [] -> ioError (userError "Línia buida") -- llança excepció
 _ -> putStrLn x
)
 (\excep -> print excep
)

</syntaxhighlight></div>

===== Alternatives en efectes - Blocs ''do'' niuats =====
Per posar més d'una instrucció en una branca d'un "case" o d'un "if" cal agrupar-les dins un subbloc "do"

Les funcions ''when'' i ''unless'' de Control.Monad proporcionen l'avaluació condicionada d'un efecte.<ref>[https://hackage.haskell.org/package/base/docs/Control-Monad.html#v:when ''when'' i ''unless'' de Control.Monad]{{en}}</ref>

===== Recursivitat en els blocs do =====
Vegeu [[Mònada (programació funcional)#Recursivitat en els blocs do]]

=== excepcions ===
1. Les excepcions del mòdul Control.Exception de la biblioteca ''base'' són un efecte global IO. Poden ser llançades des de codi funcional, però només poden ésser caçades en una expressió o bloc ''do'' de la mònada IO<ref>[http://hackage.haskell.org/package/base/docs/Control-Exception-Base.html#v%3Athrow Throw / Catch, restriccions] {{en}}</ref> Aquesta limitació es pot superar si fem servir la biblioteca ''exceptions'' descrita a continuació.

2. La biblioteca ''exceptions'' suporta tractament d'excepcions genèric respecte al tipus de la mònada, i és extensible a les [[Mònada (programació funcional)#Transformadors de mònades|mònades transformades]]. A més inclou els tipus d'excepció genèric ''SomeException'' de la biblioteca ''base''. Les ''IOError'' (''IOException''s) són admeses en el context de la mònada ''IO'' que implementa les classes definides. També inclou un transformador per al tractament encapsulable en codi funcional pur.<ref name="bib-exceptions">[https://hackage.haskell.org/package/exceptions Biblioteca exceptions]{{en}}</ref>

3. La biblio ''safe-exceptions'' permet tractar adequadament de manera diferenciada les excepcions síncrones i les asíncrones (les llançades des d'altres fils d'execució al propi) sense perdre'n cap pel camí.<ref name="bib-safe-exceptions">[https://hackage.haskell.org/package/safe-exceptions Biblioteca safe-exceptions]{{en}}</ref>

Habitualment les expressions funcionals s'avaluen de manera tardana en el moment que se'n demana el valor. Per assegurar-ne la caça i tractament d'excepcions en un punt, la funció ''evaluate'' de ''Control.Exception'' permet forçar-ne el càlcul dins el codi seqüencial (monàdic) fent aflorar les possibles excepcions en un punt de la seqüència. Si l'expressió conté tipus algebraics, cal tenir en compte que els constructors poden aturar l'avaluació de les expressions dels components si aquests no estan definits com a estrictes (prefix '!'). Per avaluar-los completament en aquest cas, caldrà avaluar en profunditat a [[#Forma Normal|Forma Normal]], fent servir ''force'' de DeepSeq com a <code>(evaluate. force $ expr)</code>.<ref name="evaluate">[http://hackage.haskell.org/package/base/docs/Control-Exception.html#v:evaluate Control.Exception.evaluate]{{en}}</ref><ref>[http://hackage.haskell.org/package/deepseq/docs/Control-DeepSeq.html#v:force Control.DeepSeq.force]{{en}}</ref>

<syntaxhighlight lang="haskell">
evaluate :: a -> IO a -- força l'avaluació (a WHNF) d'una computació funcional per aflorar-ne les excepcions
--
-- amb el mòdul DeepSeq podem forçar les computacions d'expressions amb resultat de tipus algebraics
-- (perquè avaluant només a WHNF, els constructors aturen l'avaluació de les expressions dels components)
import "deepseq" Control.Deepseq

avaluaEnProfunditat :: NFData a => a -> IO a
avaluaEnProfunditat = evaluate. force
</syntaxhighlight>

Segons l'apartat ''Catching exceptions'' del mòdul ''Control.Exception''.<ref>[https://hackage.haskell.org/package/base/docs/Control-Exception.html#g:3 Catching exceptions]{{en}}</ref>
* Per fer neteja en recuperar-se d'una excepció, es recomana ''bracket'' o bé ''finally'' o bé ''onException''
* Per recuperar-se d'una excepció i fer alguna cosa més, es recomana ''try''
* Per caçar excepcions asíncrones (les llançades des d'un altre fil d'execució) es recomana ''catch'' o bé ''catches''.

Vegeu també "Exceptions Best Practices in Haskell".<ref>[https://www.fpcomplete.com/blog/2016/11/exceptions-best-practices-haskell FPComplete.com - Exceptions Best Practices in Haskell]{{en}}</ref>

==== Generadors d'excepcions ====
* userError: generador d'excepcions d'usuari del Haskell98.
<syntaxhighlight lang="haskell">
 userError :: String -> IOError
 userError missatge -- construeix una excepció IOError de l'aplicació

-- Per discriminar diferents 'IOError' al GHC actual, 
-- o bé fas encaix de patrons (userError msg)
-- o bé se'n pot consultar el subtipus i els atributs
-- al mòdul System.IO.Error, tenim 
-- isUserError :: IOError -> Bool
-- ioeGetErrorString :: IOError -> String
</syntaxhighlight>

* la nova classe Exception permet generar excepcions de tipus definits per l'usuari. Requereix que el tipus implementi ''Show'' i ''Typeable''.

<syntaxhighlight lang="haskell">
{-# LANGUAGE DeriveDataTypeable #-}
import Control.Exception
import Data.Typeable

data TExcepcionsDeLAplicació = EParàmetreIl·legal String | EUnaAltraExcepció String
 deriving (Show, Typeable)

instance Exception TExcepcionsDeLAplicació -- instancia els mètodes per defecte de la classe ''Exception''
</syntaxhighlight>

==== Llançadors ====
<syntaxhighlight lang="haskell">
throw :: Exception e => e -> a -- llança excep en el codi funcional pur
throwIO :: Exception e => e -> IO a -- llança excep. en el context de la mònada IO (efecte global)
ioError :: IOError -> IO a -- llança una excepció IOError

-- afegeix localització i informacions a un IOError
annotateIOError :: IOError -> String -> Maybe Handle -> Maybe FilePath -> IOError
</syntaxhighlight>

Vegeu errors I/O.<ref>[http://hackage.haskell.org/package/base/docs/System-IO-Error.html Crides d'error en Ent./Sort.]{{en}}</ref>

===== Llançador generalitzat =====
* el paquet ''exceptions''<ref name="pkg-exceptions">[https://hackage.haskell.org/package/exceptions El paquet exceptions]</ref> generalitza el context de les excepcions. Permet llançar i caçar excepcions des de mònades diferents de l'IO. (aquelles que implementin ''MonadThrow'' i ''MonadCatch'').

<syntaxhighlight lang="haskell">
-- definit a "exceptions" Control.Monad.Catch

class Monad efecte => MonadThrow efecte where
 throwM :: Exception e => e -> efecte a
</syntaxhighlight>

==== excepcions en la gestió de recursos ====
===== ''bracket'' =====
Enclou en tres paràmetres la vetlla d'excepcions en un càlcul amb un recurs, i els manipuladors per adquirir-lo i per alliberar-lo en cas d'excepció o en acabar.
:* el recurs obert a l'acció del primer paràmetre es passa als paràmetres següents.
<syntaxhighlight lang="haskell">
 bracket :: IO recurs -> -- adquisició de recurs, ex.: (openFile nom_fitxer mode) :: IO Handle
 (recurs -> IO b) -> -- alliberament del recurs, per ex.: hclose :: Handle -> IO ()
 (recurs -> IO c) -> -- computació amb el recurs adquirit, ex.: (\handle -> do {...}) :: Handle -> IO c
 IO c -- retorna el resultat de la computació
</syntaxhighlight>
Exemple:
<syntaxhighlight lang="haskell">
-- A System.IO:
withFile :: FilePath -> IOMode -> (Handle -> IO r) -> IO r
withFile name mode = bracket (openFile name mode) hClose -- aplicació parcial de ''bracket'', caldrà aplicar-lo sobre la computació a vetllar
</syntaxhighlight>
<syntaxhighlight lang="haskell">
-- ús: 
withFile nom_fitxer ReadMode (\ descriptor_del_fitxer -> acció_que_pot_llançar_excepcions)
</syntaxhighlight>

====== ''bracket'' i avaluació tardana ======
Un error comú amb l'Ent./Sortida tardana és el següent:

A l'exemple següent ''hGetContents'' no s'avalua fins que no s'avaluï el ''withFile'', però com que no entrega el contingut si no li ho demanen, ''bracket'' (''withFile'' és aplicació parcial de ''bracket'') tanca el recurs. El resultat és la sortida buida. El compilador no avisa de l'error !!

La versió correcta és ficar el consumidor dins l'acció vetllada pel ''bracket'', és a dir, el bloc del ''withFile'', consumint el contingut abans no es tanqui el recurs.

<syntaxhighlight lang="haskell">
{-| fitxer prova.hs -}
import System.IO (withFile, IOMode(ReadMode), hGetContents)
import Data.Function ((&)) -- aplicació cap enrere (infixl 1)

-- imprimeix nombre de línies llegides
incorrecte = do
 contingut <- withFile "test.txt" ReadMode hGetContents
 let nombreDeLínies = contingut & lines & length
 print nombreDeLínies

correcte = do
 withFile "test.txt" ReadMode $ \hd -> do
 contingut <- hGetContents hd
 let nombreDeLínies = contingut & lines & length
 print nombreDeLínies
-- fi de fitxer

-- fitxer test.txt
abc
-- fi de fitxer

ghci
Prelude> :l prova -- carrega i compila el codi precedent
[1 of 1] Compiling Main (prova.hs, interpreted)
Ok, modules loaded: Main.
* Main> incorrecte
*** Exception: test.txt: hGetContents: illegal operation (delayed read on closed handle)
* Main> correcte
1
</syntaxhighlight>

==== try - avaluació i anàlisi per casos de les expressions llançadores d'excepcions ====
''try'' avalua un efecte IO que pot llançar excepcions retornant èxit o fallada en un tipus Either permetent-ne l'anàlisi per casos. (Either tipError) implementa una mònada amb efecte fallada. (''Left'' error) és l'[[element absorbent]] per l'esquerra de ''Either'' en <code>(>>=)</code>. Això permet encadenar amb <code>(>>=)</code> diversos efectes que poden fallar obtenint l'error del primer que falla.

<div style="background-color:#f4f6fe; border-style:solid; border-width:1px;">
<syntaxhighlight lang="haskell">
-- prova.hs
import Control.Exception (try, evaluate, ArithException)
import Data.Fixed (Uni, Deci, Centi, Milli, Micro, Nano, Pico) -- coma fixa de representació sencera
-- (sencer * resolució_del_tipus)

-- try :: Exception e => IO a -> IO (Either e a)

type TipDada = Micro -- coma fixa, proveu també TipDada = Double

main = do
 let x = 0.0001 :: TipDada
 y = 0 :: TipDada
 -- ''evaluate'' avalua com a efecte IO una expr. funcional que pot llançar excepcions 
 result <- try (evaluate (x/y)) :: IO (Either ArithException TipDada)
 case result of
 Right valor -> putStrLn $ "correcte: " ++ show valor
 Left excep -> putStrLn $ "excepció: " ++ show excep
</syntaxhighlight></div>

Amb TipDada == Micro ([[Coma fixa]]) l'excepció salta
<pre>
excepció: divide by zero
</pre>
Amb TipDada == Double ([[Coma flotant]] [[IEEE 754]]), no hi ha excepció ([[Divisió entre zero]]), dona:
<pre>
correcte: Infinity
</pre>
'''try''' també es pot fer servir amb ''[[#finally|finally]]'', però [[#bracket|bracket]] és més adequat per la gestió de recursos.

===== ''try'' generalitzat =====
Del paquet ''exceptions'',<ref name="pkg-exceptions"/> generalitzant el context de llançament i caça d'excepcions per a mònades diferents de l'IO (aquelles que implementin ''MonadCatch'')

<syntaxhighlight lang="haskell">
try :: (MonadCatch efecte, Exception ex) => efecte a -> efecte (Either ex a)
</syntaxhighlight>

===== ''finally'' =====
Assegura l'exec. de la segona acció malgrat excepcions en la primera. Si hi ha hagut excepció, és rellançada al final.<ref>[https://hackage.haskell.org/package/base/docs/Control-Exception.html#v:finally finally de Control.Exception]{{en}}</ref>

;''onException'': com ''finally'' però només executa el segon bloc en cas que hi hagi hagut excepció.

<syntaxhighlight lang="haskell">
finally, onException :: IO a -> IO b -> IO a

-- es fa servir habitualment en posició ''infix''
acció `finally` (coses_a_fer_en_acabar_encara_que_peti_l'acció_vetllada)

-- exemple de "onException" a ghci
$ ghci
Prelude>import Control.Exception
Prelude Control.Exception> throwIO (userError "òstia") `onException` putStrLn "abc"
abc 
*** Exception: user error (òstia)
</syntaxhighlight>

==== catch -- per caçar excepcions (especialment les asíncrones) ====
La clàusula ''catch'' té dos paràmetres, l'operació vetllada i el manipulador d'excepcions
Les excepcions del Haskell98 (tipus algebraic Exception) a GHC van passar al mòdul Control.OldException però ha sigut retirat a la versió 7.6.1<ref>[https://downloads.haskell.org/~ghc/7.6.1/docs/html/users_guide/release-7-6-1.html#id9281219 Novetats de la 7.6.1 - biblio. base]{{en}} "The deprecated Control.OldException module has now been removed"</ref>
<div style="background-color:#f4f6fe; border-style:solid; border-width:1px;">
<syntaxhighlight lang="haskell">
-- excepcions del Haskell98, basades en un tipus Exception, unió discriminada dels diferents tipus d'excepcions 
{-# LANGUAGE CPP #-} -- codi de PreProcessador de llenguatge 'C', els comentaris s'hi delimiten per /* */

#ifdef __GLASGOW_HASKELL__
 #if __GLASGOW_HASKELL__ >= 706 /* GHC >= 7.6 */
 #error "les excepcions del H98 ja no estan suportades, el mòdul Control.OldException ja no hi és"
 #elif __GLASGOW_HASKELL__ >= 610 /* GHC >= 6.10 */
 import Control.OldException 
 #else /* cas de GHC < 6.10 */
 import Control.Exception
 #endif
#endif

 catch
 (evaluate (x/y) >>= print) -- ''evaluate'' força l'avaluació en el context IO d'una expressió que llança excepcions 
 (\excep -> case excep of
 ArithException ae | ae == DivideByZero -> print "divisió per zero"
 | otherwise -> print $ "excepcio aritmètica" ++ show excep
 _ -> print $ "excepció per " ++ show excep
)
</syntaxhighlight></div>
Per a les excepcions noves de GHC (qualsevol tipus que implementi la classe Exception), són al mòdul Control.Exception<ref>[http://hackage.haskell.org/package/base/docs/Control-Exception.html Control.Exception]{{en}}</ref>

* Gestors d'excepció segons el tipus. Requereix l'extensió de llenguatge ScopedTypeVariables.
* el model d'aplicació successiva de ''catch''s per tractar els diferents tipus d'excepcions té una pega: les excepcions llançades dins dels handlers poden ser caçades pels ''catch''s subseqüents
:* la funció ''catches'' posposa el tractament de les excepcions produïdes dins els handlers.

<syntaxhighlight lang="haskell">
-- excepcions del Haskell2010, basades en un tipus existencial SomeException amb components que implementen la classe Exception

{-# LANGUAGE DeriveDataTypeable #-} -- per poder derivar Typeable
{-# LANGUAGE ScopedTypeVariables #-}

import Prelude hiding (catch) -- el catch del prelude està desaconsellat per què no caça les excep. del codi funcional.
{- Del codi del Prelude:
-- Non-I\/O exceptions are not caught by this variant; to catch all
-- exceptions, use 'Control.Exception.catch' from "Control.Exception".
-}
import Control.Exception
import Data.Typeable

type ExcepcióDeLAplicació = Excepcio1 | Excepcio2 String 
 deriving (Show, Typeable) 

instance Exception ExcepcióDeLAplicació -- Exception requereix instàncies de Show i Typeable

-- si es tracta de caçar una excepció en una expr. funcional pura, cal forçar-ne l'avaluació com a efecte amb ''evaluate''.

-- alternativa1: les excepcions produïdes dins un handler poden ser caçades pel handler següent
f = acció `catch` (\ (excep :: ArithException) -> tractaExcepció_Aritmètica excep)
 `catch` (\ (excep :: ExcepcióDeLAplicació) -> tractaExcepció_DeLAplicació excep)
 `catch` (\ (excep :: IOException) -> tractaExcepció_IO excep) -- si tractaExcepció_IO en llança una altra
 -- aquesta altra excepció serà caçada pel següent 'catch'.
 `catch` (\ (excep :: SomeException) -> tractaExcepció_Altres excep) -- 'catch' escombra, per al tipus més genèric 'SomeException'

-- alternativa2: 'catches' no captura les excepcions llançades dins els handlers.
f = acció `catches` [Handler (\ (excep :: ArithException) -> tractaExcepció_Aritmètica excep),
 Handler (\ (excep :: ExcepcióDeLAplicació) -> tractaExcepció_DeLAplicació excep)
 Handler (\ (excep :: IOException) -> tractaExcepció_IO excep),
 Handler (\ (excep :: SomeException) -> tractaExcepció_Altres excep)
 ]
</syntaxhighlight>

Vegeu ''catches''.<ref>[https://hackage.haskell.org/package/base/docs/Control-Exception.html#v:catches Control.Exception.catches]</ref>

Vegeu exemple [[Compilador Haskell de Glasgow#Excepcions de tipus definits per l'usuari]].

===== ''catch'' generalitzat =====
* el paquet ''exceptions''<ref name="pkg-exceptions"/> generalitza el context de les excepcions. Permet llançar i caçar excepcions des de mònades diferents de l'IO (aquelles que implementin ''MonadCatch'').

<syntaxhighlight lang="haskell">
class MonadThrow efecte => MonadCatch efecte where
 catch :: Exception ex => efecte a -> (ex -> efecte a) -> efecte a

-- la implementació ha de complir la regla: catch (throwM ex) f ≡ f ex
</syntaxhighlight>

* el paquet ''safe-exceptions''<ref name="bib-safe-exceptions"/> permet separar el tractament de les excepcions síncrones i asíncrones (les originades des d'altres fils d'execució) millorant la seguretat del tractament.

==== La funció ''error'' assenyala la fallada del programa ====
Per al cas d'estats inconsistents o bé operacions no definides per als valors dels paràmetres.

La crida a la rutina ''error'' dispara una excepció genèrica ''ErrorCall'' que mostra el missatge.
<syntaxhighlight lang="haskell">
error missatge -- 'error' en funcions parcials no dona cap pista de la crida culpable.
 -- per la impressió de traces de crides, vegeu HasCallStack o bé compilació per l'ajustatge (profiling)
</syntaxhighlight>

És preferible evitar-ne l'ús en funcions parcials, convertint-les en totals amb resultat opcional i analitzar-ne el resultat dins la rutina que ha fet la crida amb paràmetres il·legals.

* des de GHC 7.8.1: ''errorWithStackTrace'' amb bolcat de pìla si s'ha compilat per l'ajustatge amb ''profiling''.
:No requereix l'opció d'execució de depuració <code>+RTS -xc</code> però sí <code>ghc -prof -fprof-auto Main.hs</code>;
:L'ús de la versió d'ajustatge (''profiling'') del RunTimeSystem requereix disposar de versions compilades amb ''profiling'' de totes les dependències.<ref>[https://ghc.haskell.org/trac/ghc/wiki/Commentary/Rts/Config Configuracions del RunTimeSystem]{{en}}</ref>
<syntaxhighlight lang="haskell">
import GHC.Stack (errorWithStackTrace) -- des de GHC 7.8.1, obsolet des de GHC 8.0 (funcionalitat integrada a 'error')

funcióParcial p1 p2 
 | precondició p1 p2 = resultat
 | otherwise = errorWithStackTrace "funció_tal: la precond. falla" -- bolca la pila de crides si s'ha compilat amb "-prof -fprof-auto"
 where
 resultat = ...
</syntaxhighlight>

Això millora a partir de la versió 7.10.2 amb un nou mecanisme d'[[Compilador Haskell de Glasgow#Obtenció programàtica del punt de crida|obtenció d'una pila de crides]] mitjançant paràmetres implícits especials inclosos al context de les crides que es pretén traçar, sense haver de recórrer al ''profiling''.

A GHC 8.0 ''error'' incorpora la funcionalitat de ''errorWithStackTrace'' mostrant la situació de l'error. Excepte al paquet ''base'', on les crides a ''error'' han estat reanomenades a ''errorWithoutStackTrace''.

Fins ara era millor reconvertir les funcions parcials en funcions totals amb resultat opcional (Maybe) analitzant el resultat a la funció que fa la crida, i en cas de resultat inesperat provocar la petada,
* o bé amb encaix incomplet obtenint la posició de la petada,<ref>[https://wiki.haskell.org/Debugging#Locating_a_failure_in_a_library_function HaskellWiki - Debugging - Locating a failure in a library function]{{en}}</ref>
* o bé amb la crida ''err'' equivalent a ''error'' del paquet ''file-location''<ref>[https://hackage.haskell.org/package/file-location-0.4.9/docs/FileLocation.html ''$(err')'' de File-location]{{en}}</ref> que ens permet mostrar la posició (requereix l'extensió TemplateHaskell). ''$(x)'' és un mecanisme de GHC per avaluar en temps de compilació, anomenat crida ''splice''.

<syntaxhighlight lang="haskell">
{-# LANGUAGE PackageImports, TemplateHaskell #-}

-- err' crida a ''error'' afegint la situació (fitxer:línia:columna) obtinguda en temps de compilació

-- la utilitzarem per assenyalar l'error "des de la funció culpable i no dins la funció parcial"
import "file-location" FileLocation (err') 

-- funció total headMaybe equivalent a la parcial ''head''
-- evitem la crida a error de la funció parcial i la traslladem a la funció culpable (la que fa la crida)

headMaybe :: [a] -> Maybe a
headMaybe (x : _) = Just x
headMaybe _ = Nothing

obtenirElCap :: [a] -> a
obtenirElCap llista =
 case headMaybe llista of
 Just cap -> cap
 Nothing -> $(err') "OH NO!" -- $(err') s'avalua en temps de compilació ($()), capturant la posició (fitxer:línia:columna)

main = print $ obtenirElCap ([] :: [Int])
</syntaxhighlight>
Resultat:
<syntaxhighlight lang="bash">
$ ./prova
prova: main:Main prova.hs:14:21 OH NO!
</syntaxhighlight>

La biblioteca [[Compilador Haskell de Glasgow#La biblioteca Safe millora les funcions parcials del Prelude|''Safe'']] ofereix diverses alternatives de les funcions del ''Prelude'' que poden petar.

Ara per ara, per assegurar la finalització del programa, és millor evitar les funcions parcials que criden a error i compilar amb ''-Wall'' per assegurar l'exhaustivitat dels encaixos.

Cal tenir en compte que els accessors de registres amb més d'un constructor que no siguin comuns a tots ells, també són funcions parcials.

==== Assercions, Precondicions i Postcondicions ====
''assert'' avalua la condició, i si és certa retorna el segon argument i,si no, peta dient-nos on.<ref>[http://hackage.haskell.org/package/base/docs/Control-Exception.html#v%3Aassert Assercions]{{en}}</ref>

L'ús de l'opció d'optimització (-O ó bé -On | n>0) elimina les assercions del codi objecte.
<syntaxhighlight lang="haskell">
assert condició expr -- si Fals, dispara l'excepció AssertionFailed indicant nom_del_fitxer i línia
</syntaxhighlight>
per exemple:
* Amb resultat opcional per evitar petades per crides a 'error'
<syntaxhighlight lang="haskell">
import Control.Exception (assert)

funcióParcial :: a -> b -> Maybe c
funcióParcial p1 p2 
 | precondició p1 p2 = assert (postcondició p1 p2 resultat) $ Just resultat
 | otherwise = Nothing -- "la precond. falla"
 where
 resultat = ...
</syntaxhighlight>

* Amb excepcions:

<syntaxhighlight lang="haskell">
{-# LANGUAGE DeriveDataTypeable #-}
import Control.Exception (assert, throw, evaluate, try)
import Data.Typeable

data TElMeuError = ElMeuError String 
 deriving (Typeable, Show)

instance Exception TElMeuError -- implementa la classe Exception

funcióParcial :: a -> b -> c
funcióParcial p1 p2 
 | precondició p1 p2 = assert (postcondició p1 p2 resultat) resultat
 | otherwise = throw $ ElMeuError "funcióParcial: la precond. falla"
 where
 resultat = ...

main = do
 -- 'evaluate' força l'avaluació d'una computació funcional pura llançadora d'excepcions
 -- 'try' captura el resultat o l'excepció en un Either
 eitherResultat <- try (evaluate (funcióParcial p1 p2)) :: IO (Either TElMeuError String) 
 case eitherResultat of
 Right resultat -> putStrLn $ "Correcte: " ++ show resultat
 Left (ElMeuError msg) -> putStrLn $ "ElMeuError: " ++ msg
</syntaxhighlight>

===== obtenció del punt de crida origen de la violació de la precondició =====
1. Amb paràmetre implícit especial de tipus CallStack

Vegeu ref.<ref>[http://downloads.haskell.org/~ghc/7.10.2/docs/html/users_guide/other-type-extensions.html#special-implicit-params Paràmetres implícits especials]{{en}}</ref> (Des de GHC 7.10.2)<ref>[http://downloads.haskell.org/~ghc/7.10.2/docs/html/users_guide/release-7-10-2.html Notes de la versió 7.10.2]{{en}}</ref> La seva obtenció reflecteix la pila d'aquelles crides on explícitament aparegui l'implícit de tipus ''CallStack'' com a restricció de context, amb el mateix nom de variable.

Des de GHC 8.0 vindrà definit un sinònim de restricció ''HasCallStack'' que evitarà la necessitat de l'extensió de sintaxi ''ImplicitParams''.<ref>[https://ghc.haskell.org/trac/ghc/wiki/Migration/8.0#ReworkedHasCallStackAPI GHC 8.0.x Migration Guide]{{en}}</ref>
<syntaxhighlight lang="haskell">
type HasCallStack = (?callStack :: CallStack) :: Constraint -- especifica Constraint com a 'kind' (tipus del tipus)
</syntaxhighlight>
Exemple:

<syntaxhighlight lang="haskell">
{-# LANGUAGE CPP #-} -- a les directives CPP els comentaris segueixen la sintaxi del C: /* comentari */

#if MIN_VERSION_base(4,9,0) /* GHC >= 8.0 */

import Control.Exception (assert)
import GHC.Stack (HasCallStack)

funcióParcial :: HasCallStack => a -> b -> c
funcióParcial p1 p2 
 | precondició p1 p2 = {- cas definit -} assert (postcondició p1 p2 resultat) resultat
 | otherwise = {- cas no definit -} error $ 
 "funcióParcial: la precondició falla" -- a GHC 8.0 hi ha bolcat automàtic del CallStack "?callStack" amb l'error
 -- la funció 'error' antiga (anterior a GHC 8.0) ha estat reanomenada 'errorWithoutCallStack' al paquet 'base'
 where
 resultat = expressió p1 p2

#elif MIN_VERSION_base(4,8,1) /* GHC >= 7.10.2 && < 8.0 */

{-# LANGUAGE ImplicitParams #-}

import Control.Exception (assert)
import GHC.Stack (CallStack, showCallStack) 

funcióParcial :: (?loc :: CallStack) => a -> b -> c
funcióParcial p1 p2 
 | precondició p1 p2 = {- cas definit -} assert (postcondició p1 p2 resultat) resultat
 | otherwise = {- cas no definit -} error $ 
 "funcióParcial: la precondició falla; cridat des de : \n" ++ showCallStack ?loc
 where
 resultat = expressió p1 p2
#endif
</syntaxhighlight>

2. Alternativa. Bolcar la pila de crides simulada, havent compilat amb la variant d'ajustatge del RunTimeSystem. (''profiling'')

La comprovació de la precondició dins la rutina no ens informarà de la rutina origen del problema, excepte si habilitem la simulació de pila de crides de l'ajustatge (compilant amb ''-prof'' i executant amb ''+RTS -xc''). Vegeu [[Compilador Haskell de Glasgow#El problema de la manca d.27informaci.C3.B3 de situaci.C3.B3 en les petades|Depuració. El problema de la manca d'informació de situació en les petades]]

==== No finalització - Símbol ⊥ (''Bottom'') ====
Valor intern que atura el programa prematurament indicant "No finalització del programa", especialment com a opció de fons en un ''case'', en cas que no encaixi cap de les opcions o bé un bucle sens fi. El tipus de ⊥ és arbitrari.<ref name="bottom">[https://wiki.haskell.org/Bottom Bottom (No finalització)]</ref>

<syntaxhighlight lang="haskell">
Prelude> :type error "abc"
error "abc" :: t -- el tipus de "no finalització" és arbitrari.
</syntaxhighlight>

En anglès ''bottom'' com a verb vol dir "tocar fons". En català es podria anomenar ''"fondeig"'' (fondejar: immobilitzar una barca, ancorant-la al fons).

===== Implementació pendent - ''Undefined'' =====
''undefined''<ref name="undefined">[https://wiki.haskell.org/Undefined Undefined (Implementació pendent)]</ref> és un valor de ''fondeig'' (⊥: atura el programa) per poder explicitar el tipus d'una funció pendent d'implementar i poder així passar la compilació. Crida a la funció error.
<syntaxhighlight lang="haskell">
-- ''undefined'' en una definició, explicita implementació pendent
 <identificador> <patrons> = undefined :: <tipus>
</syntaxhighlight>

=== Canvis d'estat - Variables ===
Haskell permet crear objectes mudables, que poden canviar d'estat mitjançant operacions sempre dins d'una [[mònada (programació funcional)|mònada]] (sinó l'ordre i, per tant, el resultat, no estarien garantits).

La mònada IO caracteritza l'estat global de l'aplicació amb objectes amb cicle de vida no acotat. Les variables mudables globals són les IORef's.

La mònada ST caracteritza l'estat local d'una computació puntual, permetent encapsular actualitzacions ''in situ'' (destructives) dins de codi funcional pur. Les variables mudables locals són les STRef's i el seu cicle de vida queda limitat a l'àmbit de l'efecte ST.

Caldrà distingir el tipus de la mònada especificant el tipus resultant de l'expressió o ''bloc do''.

La sincronització d'accés a variables des de diferents fils d'execució (detallat a [[Haskell concurrent]]) es pot obtenir:

* amb sincronització per baldes (ang:''locks'') amb variables MVar's (ang:''mutable variable'' o més precisament ''mailbox variable'').
* amb les transaccions en memòria (similars a les de ''bases de dades''). La mònada STM (inicials de '''S'''oftware '''T'''ransactional '''M'''emory) modela el funcionament i validació de les transaccions. Les variables transaccionals són les TVar (immutables) i TMVar (mudables).

{| class=wikitable
|+ variables
|-
! tipus !! mònada !! generadors !! mòdul !! descripció
|-
| IORef a<ref name="data-ioref">[http://hackage.haskell.org/package/base/docs/Data-IORef.html Data.IORef]{{en}}</ref> || IO || newIORef x || Data.IORef || vars. globals no sincronitzades,<br/>cicle de vida no acotat
|-
| STRef&nbsp;a<ref name="data-stref">[http://hackage.haskell.org/package/base/docs/Data-STRef.html Data.STRef]{{en}}</ref> || ST || newSTRef x || Data.STRef || vars. per a canvis d'estat encapsulables,<br/>cicle de vida lligat a l'àmbit de ST
|-
| MVar a<ref name="data-mvar">[https://hackage.haskell.org/package/base/docs/Control-Concurrent-MVar.html Control.Concurrent.MVar]{{en}}</ref> || IO || newMVar x<br/>-- var buida per a un tipus T<br/>newEmptyMVar:: IO (MVar&nbsp;T) || Control.Concurrent.MVar || bústia de comunicació d'un sol element<br/>emprada com a variable sincronitzada amb [[Monitor (concurrència)]]<br/>també es pot fer servir com a semàfor binari.
|-
| TVar a<ref name="data-tvar">[https://hackage.haskell.org/package/stm/docs/Control-Concurrent-STM-TVar.html Control.Concurrent.STM.TVar]{{en}}</ref> || STM<br/>IO || newTVar x -- encapsulable<br/>newTVarIO x -- global || Control.Concurrent.STM.TVar || posicions de memòria compartida<br/>suporten transaccions de memòria atòmiques
|-
| TMVar&nbsp;a<ref name="data-tmvar">[https://hackage.haskell.org/package/stm/docs/Control-Concurrent-STM-TMVar.html Control.Concurrent.STM.TMVar]{{en}}</ref> || STM<br/>IO || newTMVar x -- encapsulable<br/>newTMVarIO x -- global || Control.Concurrent.STM.TMVar || MVar protegida per transaccions de memòria
|}

==== Variables d'estat global no sincronitzades IORef ====
Les referències IORef,<ref>[http://hackage.haskell.org/package/base/docs/Data-IORef.html IORef's - referències mudables dins la mònada IO]</ref><ref>[http://www.haskell.org/haskellwiki/Top_level_mutable_state Top level mutable state] {{en}} Estat de nivell global d'un programa</ref> equivalents de les ''ref'' del [[ML Estàndard]], permeten modificar l'estat global caracteritzat com a efecte IO.

No és convenient utilitzar una mateixa IORef en diferents fils d'execució. Protegir-ne més d'una mitjançant ''atomicModifyIORef'' està desaconsellat<ref>[http://hackage.haskell.org/package/base/docs/Data-IORef.html#v:atomicModifyIORef Data.IORef atomicModifyIORef]{{en}} L'ús d' ''atomicModifyIORef'' per protegir més d'una IORef està desaconsellat</ref> (les [[#accés sincronitzat amb variables MVar (Mailbox variable)|MVar]] hi són més indicades).

<div style="background-color:#f4f6fe; border-style:solid; border-width:1px;">
<syntaxhighlight lang="haskell">
 import Data.IORef (IORef, newIORef, readIORef, writeIORef, modifyIORef)
 import qualified Control.Monad as Monad
 import System.IO (stdout, hFlush)

 tornem_hi :: IORef Bool -> IO ()
 tornem_hi ref_estat = do

 x <- readIORef ref_estat -- llegeix variable ref_estat
 writeIORef ref_estat $ not x -- escriu

 -- modifyIORef ref_estat (not) -- alternativa: modifica la ref. amb la funció

 putStrLn $ 
 if x then "Blanc" else "Negre"

 putStr "Premeu intro:"
 hFlush stdout
 getLine -- espera tecleig Intro i ignora el resultat del getLine
 -- sense variable (v <- getline),
 -- el bloc do compon les línies amb (>>) en lloc de (>>=)
 return ()

 main = do
 ref_estat <- newIORef False -- crea variable del tipus del valor inicial
 -- i n'obté la referència
 Monad.forever $ tornem_hi ref_estat -- repeteix seqüencialment
</syntaxhighlight></div>

==== Variables d'àmbit local STRef per l'encapsulament d'efectes col·laterals ====
La mònada ST<ref>[http://www.haskell.org/haskellwiki/Monad/ST La mònada ST] {{en}} efecte de canvis d'estat</ref><ref>[http://hackage.haskell.org/package/base/docs/Control-Monad-ST.html La mònada ST - referència]{{en}}</ref> (abbrev. de ''State'') encapsula canvis d'estat dins de codi funcional pur i permet fer computacions amb actualitzacions ''in situ'' (destructives) mitjançant referències STRef<ref>[http://hackage.haskell.org/package/base/docs/Data-STRef.html STRef's - referències a valors mudables dins la mònada ST]</ref> a objectes de cicle de vida restringit a l'àmbit i avaluació de l'efecte.

===== en memòria local =====
* Els efectes locals produïts en un fil d'execució (ST&nbsp;s&nbsp;tipusDelResultat), venen parametritzats amb una variable ''s'' (l'espai d'avaluació de l'efecte), que es deixa lliure per indicar l'espai propi del fil d'execució.
* la funció ''runST'' avalua un efecte local i n'extreu el resultat.

<div style="background-color:#f4f6fe; border-style:solid; border-width:1px;">
<syntaxhighlight lang="haskell">
 import Control.Monad.ST (ST, runST, stToIO)
 import Data.STRef (STRef, newSTRef, readSTRef, writeSTRef, modifySTRef)
 import Control.Monad as Monad

 -- fold_left: aplica operació binària ''f'' acumulant resultat
 -- sobre un valor inicial i els elements d'una llista d'esq. a dreta

 foldlST :: (a -> b -> a) -> a -> [b] -> ST s a
 foldlST f acc_ini xs = do
 ref_acc <- newSTRef acc_ini -- Crea una variable per a l'acumulador amb el valor inicial acc_ini

 Monad.forM_ xs $ \x -> do -- encadena l'aplicació a tots els x de la llista xs...

 acc <- readSTRef ref_acc -- llegeix l'acumulador
 writeSTRef ref_acc (f acc x) -- aplica f a l'acumulador i a x i en desa el resultat a la variable

 -- modifySTRef ref_acc $ (flip f) x -- alternativa, flip altera l'ordre dels paràmetres formals

 readSTRef ref_acc -- finalment llegeix l'acumulat que passa a ser
 -- el resultat de l'efecte del bloc ''do'' més extern

 main = do
 -- runST avalua foldlST en l'espai del fil actual
 let resultat = runST $ foldlST (+) 0 [1..4]
 putStrLn $ "total: " ++ show resultat
</syntaxhighlight></div>

===== en memòria global =====
* ''stToIO'' avalua un efecte local de tipus (''ST&nbsp;s&nbsp;tipusDelResultat'') en l'espai de memòria global, assignant ''RealWorld'' a la variable ''s'', oferint el resultat en la mònada IO.<ref>[https://hackage.haskell.org/package/base/docs/Control-Monad-ST.html#v:stToIO Control.Monad.ST - Converting ST to IO]{{en}}</ref>

<div style="background-color:#f4f6fe; border-style:solid; border-width:1px;">
<syntaxhighlight lang="haskell">

 -- implementació de foldlST igual que l'anterior

 main = do
 resultat <- stToIO $ foldlST (+) 0 [1..4] -- stToIO avalua l'efecte encapsulat ST en l'espai global RealWorld
 putStrLn $ "total: " ++ show resultat
</syntaxhighlight></div>

==== Variables MVar per a l'accés sincronitzat ====
Les variables MVar ofereixen l'accés sincronitzat entre fils d'execució amb el mecanisme de les bústies de comunicació. Ampliació a [[Haskell concurrent]]

==== Mutabilitat als vectors ====
Vegeu [[#Vectors mudables de dades no encapsulades|vectors d'elements d'allotjament directe]]

=== Entrada/Sortida reactiva - Els Iterats (ang:Iteratees) ===
L'abstracció dels ''Iterats'' aporta un altre enfocament, descomponent l'entrada/sortida en ''productors'' del corrent de dades, ''consumidors'' i ''transformadors''.<ref name="iteratee-io">[https://wiki.haskell.org/Iteratee_I/O Iteratee I/O]{{en}}</ref>

* Els ''Iterats'' (consumidors) es descriuen com una abstracció componible per al procés incremental d'una seqüència de parts de l'entrada de dades, per l'obtenció d'un resultat. És un component reactiu. Es reacciona a l'entrada de cadascun dels elements (o bé troç de fitxer (ang:''chunk'')) com si fos un ''plegat'' (reducció), combinant l'element (o bé el troç de fitxer) en funció de l'estat, que s'actualitza en funció de l'entrada, i en rebre el "fi de seqüència" s'ofereix el resultat.

* L'Enumerador (productor) és l'abstracció que genera el corrent de dades per al consum dels Iterats.

* Els Enumerats (ang: Enumeratee) actuen com a consumidors i productors alhora, fent de transformadors interposats.

El procés es completa en associar un productor (l'Enumerador) amb un o més components reactius (l'Iterat amb possible interposició dels Enumerats)

;Nota el sufix '''-ee'''
::En anglès, donat un verb afegint-li el sufix '''-er''' tenim un nom subjecte d'una acció<ref>[https://www.lexico.com/en/definition/-er Lèxic anglès sufix -er] {{Webarchive|url=https://web.archive.org/web/20210604033354/https://www.lexico.com/en/definition/-er |date=2021-06-04 }}{{en}}</ref> com ara del verb ''employ'' el substantiu ''Employer''.
::El sufix '''-ee''' obté de l'acció un subjecte passiu (persona/objecte afectats o subordinats),<ref>{{Ref-web |url=https://www.lexico.com/en/definition/-ee |títol=Lèxic anglès sufix -ee |consulta=2021-07-15 |arxiuurl=https://web.archive.org/web/20210715114523/https://www.lexico.com/en/definition/-ee |arxiudata=2021-07-15}}</ref> així el parell ''(Employer, Employee)'' es podria traduir per (''Contractador'', ''Contractat'')
::Així els termes tècnics ''{Iteratee, Enumeratee}'' en català serien ''{l'Iterat, l'Enumerat}'' com ''Refugee'' és {el refugiat}.

Algunes implementacions inclouen una capa de gestió de recursos (ex. el [[Mònada (programació funcional)#Transformadors de mònades|transformador de mònades]] ''ResourceT''<ref>[http://hackage.haskell.org/package/resourcet Deterministic allocation and freeing of scarce resources]{{en}} Allotjament determinista i alliberament de recursos escassos.</ref> als ''conduits'')<ref>[https://www.fpcomplete.com/user/snoyberg/library-documentation/conduit-overview Introducció als conduits] {{Webarchive|url=https://web.archive.org/web/20140222011452/https://www.fpcomplete.com/user/snoyberg/library-documentation/conduit-overview |date=2014-02-22}}{{en}}</ref> que en ésser cridat (runResourceT), executa les accions incrementals i, en acabar, les accions d'alliberament registrades pel generador.

<syntaxhighlight lang="haskell">
import Data.Conduit
import Data.Conduit.Binary as CB
import Data.Conduit.List as Cl
import Data.Conduit.Text as Ct

main :: IO ()
main = do
 let canonada = CB.sourceFile "test.txt" -- productor per trossets (''Enumerador'')
 $$ Ct.decode Ct.utf8 -- transformador reactiu (''Enumerat'')
 =$ Ct.lines -- transformador reactiu (''Enumerat'')
 =$ Cl.fold (\x _ -> x +1) (0::Int) -- consumidor reactiu dels trossets (''Iterat'')

 nombreDeLínies <- runResourceT $ canonada
 putStrLn $ show nombreDeLínies
</syntaxhighlight>

=== Efecte ''fallada'' en una seqüència de computacions ===
Els [[element absorbent|elements absorbents per l'esquerra]] de l'encadenament en una mònada, en produir un resultat absorbent assimilable a fallada, fan inútil l'avaluació de la computació subseqüent, perquè el resultat és el mateix valor, de manera que l'encadenament progressa només per als elements no absorbents en (>>=).

Per exemple:
* a la mònada Maybe: l'encadenament de resultats opcionals de funcions definides parcialment <code>(f x >>= g)</code>, s'atura a la primera fallada
* a la mònada Either: l'encadenament d'avaluacions d'accions que disparen excepcions <code>(try acció1 >>= \_ -> try acció2)</code>, s'atura al primer ''Left''
<syntaxhighlight lang="haskell">
-- a la mònada Maybe
Nothing >>= _ = Nothing -- l'encadenament no s'avalua en aquest cas
Just r >>= f = f r

-- a la mònada Either
Left err >>= _ = Left err -- l'encadenament no s'avalua en aquest cas
Right r >>= f = f r
</syntaxhighlight>

Això facilita l'encadenament de computacions que poden fallar, sense haver de consultar la correcció del resultat a cada pas.

{| class="wikitable collapsible"
! tipus de la mònada !! [[element absorbent]] en (>>=)
|-
| [[Mònada (programació funcional)#Mònada (programació funcional)|Maybe a]] || Nothing
|-
| [[Mònada (programació funcional)#La mònada Either (resultats duals)|Either err a]] || Left err
|-
| [[Mònada_(programació_funcional)#exemple: la mònada Llista|<nowiki>[a]</nowiki>]] || [&nbsp;]
|-
! classe !!
|-
| [[Mònada (programació funcional)#La classe MonadPlus (computacions amb solucions múltiples)|MonadPlus m]] || mzero
|}

==== fallada monàdica en el codi funcional ====
Com acabem d'esmentar, l'[[element absorbent]] en l'encadenament en la mònada [[Mònada (programació funcional)#La mònada Maybe (computacions que poden fallar)|Maybe]] (o bé [[Mònada (programació funcional)#La mònada Either (resultats duals)|Either]]) evita l'avaluació de les computacions posteriors.

<syntaxhighlight lang="haskell">
{-| fitxer total.hs
-}
{-# LANGUAGE UnicodeSyntax #-}

headMay :: [a] → Maybe a
headMay (x : _) = return x -- resultat exitós, equival a (Just x)
headMay [] = Nothing -- element absorbent de la mònada Maybe: (Nothing >>= _ = Nothing)

doblar :: Num a => a → Maybe a
doblar x = return $ 2 * x

doblarElCap :: Num a => [a] → Maybe a
doblarElCap llista = headMay llista >>= doblar
</syntaxhighlight>
prova:
<syntaxhighlight lang="haskell">
$ ghci
Prelude> :load total.hs
[1 of 1] Compiling Main (total.hs, interpreted)
Ok, modules loaded: Main.
* Main> doblarElCap []
Nothing
* Main> doblarElCap [1,2,3]
Just 2
</syntaxhighlight>

===== un tipus específic per al subdomini de casos definits =====
I una funció de validació dels casos definits:

<syntaxhighlight lang="haskell">
import Control.Category ((>>>)) -- composició esq-dreta -- f >>> g = g. f
import Data.Function ((&)) -- aplic. cap enrere -- (&) = flip ($) -- infixl 1 -- desde GHC 7.10.1

newtype TLlistaNoBuida a = LlistaNoBuida { obtenirLlista :: [a]} deriving (Eq, Ord, Show)

-- Constructor: LlistaNoBuida :: [a] -> TLlistaNoBuida a
-- Inversa del constructor: obtenirLlista :: TLlistaNoBuida a -> [a]

validaLlistaNoBuida :: [a] -> Maybe (TLlistaNoBuida a)
validaLlistaNoBuida xs @ (_ : _) = Just $ LlistaNoBuida xs
validaLlistaNoBuida [] = Nothing

head :: TLlistaNoBuida a -> a
head = obtenirLlista >>> Prelude.head 

-----------------------------------
-- operant en la mònada Maybe:
-- un resultat Nothing (element absorbent en (>>=)) fa que l'encadenament no progressi
--
obtenirLaLlistaNoBuidaMenor :: Ord a => [a] -> [a] -> Maybe (TLlistaNoBuida a)
obtenirLaLlistaNoBuidaMenor l1 l2 = do
 nb1 <- validaLlistaNoBuida l1
 nb2 <- validaLlistaNoBuida l2
 if nb1 < nb2 then return nb1 else return nb2

default (Int) -- desambiguació dels literals numèrics segons seqüència de tipus

main = do
 case obtenirLaLlistaNoBuidaMenor [1,2,3] [2,3,4] of
 Just llistaNoBuida -> llistaNoBuida & show & putStrLn
 Nothing -> putStrLn "alguna de les llistes era buida"
</syntaxhighlight>

==== fallada monàdica en els efectes col·laterals - el transformadors EitherT i MaybeT ====
La fallada en la mònada IO per encaixos incomplets del segon operand de (>>=) (op. ''fail'' desplaçada (des de GHC 8.0) a la classe ''MonadFail'')<ref>[https://wiki.haskell.org/MonadFail_Proposal proposta MonadFail]{{en}}</ref> es produeix disparant una excepció IOError.<ref>[http://hackage.haskell.org/package/base/docs/src/GHC-IO.html#failIO GHC.IO - failIO]{{Enllaç no actiu|bot=InternetArchiveBot |data=2021}}{{en}}</ref>

En el cas de la mònada ST, el comportament no està definit. La implementació per defecte crida la rutina ''error'' aturant el programa.<ref>[http://hackage.haskell.org/package/base/docs/src/GHC-Base.html#Monad Monad - fail (implementació per defecte en la classe Monad)]{{Enllaç no actiu|bot=InternetArchiveBot |data=2023 }}{{en}}</ref>

Per afegir-hi la funcionalitat de l'[[element absorbent]] en (>>=) cal aplicar-hi un [[Mònada (programació funcional)#Transformadors de mònades|transformador de mònades]] que la incorpori.

El [[Mònada (programació funcional)#Transformadors de mònades|transformador de mònades]] EitherT,<ref name="transf-eitherT">[http://hackage.haskell.org/package/either paquet ''either'' amb el transformador ''EitherT'']{{en}}</ref> de manera similar al [[Mònada (programació funcional)#Implementació del transformador MaybeT|MaybeT]], afegeix la possibilitat d'evitar càlculs posteriors a la fallada, a una mònada, afegint-hi a més a més, informació de l'error. Aquí l'aplicarem a la mònada IO, resultant la mònada (EitherT tipError IO).

<syntaxhighlight lang="haskell">
{-# LANGUAGE PackageImports, UnicodeSyntax #-}
import "either" Control.Monad.Trans.Either (EitherT (..))
import "transformers" Control.Monad.Trans.Class (lift)
import Control.Category ((>>>)) -- g >>> f == f. g

-- el tipus EitherT, definit a Control.Monad.Trans.Either
-- newtype EitherT err mònada a = EitherT { runEitherT :: mònada (Either err a) }

-- els valors (Left err) són elements absorbents de la mònada Either en (>>=)

-- errors de l'aplicació
data Err = ErrLectura | ErrForaMarges Int deriving (Eq)

instance Show Err where
 show ErrLectura = "error de lectura"
 show (ErrForaMarges x) = "fora marges: " ++ show x

-- funció total -- en comptes d'excepció retorna fallada amb l'error
llegirSencer :: String → Either Err Int
llegirSencer s = case reads s of
 [(x, "")] → return x
 _ → Left ErrLectura -- element absorbent

llegeixSencerDEntrada :: EitherT Err IO Int
llegeixSencerDEntrada = do
 s <- lift getLine
 EitherT $ return $ llegirSencer s

-- apliquem encadenaments sobre el resultat de la lectura, segurs que no petarà.

comprovaMarges :: Int → EitherT Err IO Int
comprovaMarges x = if x >= 0
 then return x
 else EitherT $ return $ Left $ ErrForaMarges x -- element absorbent

obtenirLArrelQuadrada :: Int → EitherT err IO Float
obtenirLArrelQuadrada = fromIntegral >>> sqrt >>> return

main = do
 -- en l'encadenament (>>=) el primer resultat Left (element absorbent en (>>=)) fa que l'avaluació no progressi.
 eiResult <- runEitherT $ llegeixSencerDEntrada >>= comprovaMarges >>= obtenirLArrelQuadrada
 case eiResult of
 Right v → putStrLn $ "resultat: " ++ show v
 Left err → putStrLn $ "error: " ++ show err -- mostra el primer error que es produeixi
</syntaxhighlight>

<syntaxhighlight lang="bash">
cabal install either
runhaskell prova.hs
</syntaxhighlight>

== Lents (Referències funcionals) - Consulta i manipulació de parts d'estructures complexes ==
Una lent és un mecanisme componible per enfocar una part d'una estructura per la consulta, o bé per la modificació de l'estructura alterant-ne el component enfocat.<ref>[https://github.com/ekmett/lens/wiki/Overview Eduard Kmett - Lens wiki - Overview]{{en}}</ref><ref>[http://lens.github.io/ The lens library]{{en}}</ref><ref>[https://wiki.haskell.org/Lens HaskellWiki - Lens]{{en}}</ref><ref name="biblio-lens">[https://hackage.haskell.org/package/lens El paquet ''lens'']{{en}}</ref>

També s'anomenen ''referències funcionals'', per ésser l'equivalent funcional dels punters als components de l'[[Orientació a objectes]].

Classes de lents:
# ''lents'' pròpiament dites: permeten adreçar components d'un tipus producte, per exemple un tipus de registre
# ''prismes'': permeten adreçar components d'un tipus suma (unió discriminada), on la selecció del component pot fallar si el valor no correspon a la variant pretesa.
# ''isos'': permeten adreçar components sobre una transformació reversible, per exemple d'una tupla2 ''(a, b)'' transformada en ''(b, a)''
# ''travesses i plegats'': permeten adreçar múltiples components per una transformació dels mateixos o bé una reducció dels valors mitjançant un plegament.

* Història de les lents.<ref>[https://github.com/ekmett/lens/wiki/History-of-Lenses History of lenses]{{en}}</ref>
* Lents de Van Laarhoven.<ref>[http://www.twanvl.nl/blog/haskell/cps-functional-references Van Laarhoven - CPS Functional References]{{en}}</ref> Va ser el creador de la base teòrica de les lents actual emprada per la biblioteca "lens" de Edward Kmett.<ref name="biblio-lens"/>
* Lents basades en Profunctors. Recentment s'ha comprovat que els ''profunctors'' descrits més amunt ofereixen una manera més planera de definir-hi les lents.<ref>[https://github.com/purescript-contrib/purescript-lens/issues/26 Edward Kmett - Consider "pure profunctor" lenses]{{en}}</ref><ref>[https://github.com/purescript-contrib/purescript-profunctor-lenses Purescript profunctor lenses - Biblioteca de lents per al llenguatge PureScript (quasi-haskell compilable a JavaScript)]{{en}}</ref><ref>[https://hackage.haskell.org/package/mezzolens La biblio mezzolens]{{en}}</ref>

Exemple amb biblioteca "lens" (lents de Van Laarhoven) a [[Compilador Haskell de Glasgow#Lents de Van Laarhoven -- Consulta i manipulació de parts d'estructures complexes]]

=== Lents basades en [[#Profunctors|profunctors]] ===
* la biblioteca Mezzolens defineix les lents com una funció de transformadors: una transformació (profunctor) d'estructures en funció de la transformació d'un component.

Per fabricar una lent caldrà una funció de selecció del component enfocat i una funció de transformació de l'estructura en funció de la imatge (transformada) del component enfocat.

Són instàncies de Profunctor les funcions i les [[Fletxa (programació funcional)|fletxes de Kleisli]].
<syntaxhighlight lang="haskell">
instance Profunctor (->) 
instance (Functor f) => Profunctor (Kleisli f)
</syntaxhighlight>

Per exemple podem aplicar una lent a un ''profunctor'' funció que transformi el component, obtenint un ''profunctor'' del mateix tipus (funció) que transforma l'estructura que el conté.

La composició de lents (composició de funcions de profunctors) ens permetrà manipular components inserits profundament.

<syntaxhighlight lang="haskell">
-- Sigui 'a' el tipus del component objectiu de l'estructura d'entrada de tipus 'ta'
-- i 'b' el tipus del component transformat, pertanyent a l'estructura de sortida de tipus 'tb'

-- type Lens ta tb a b = forall p. Strong p => p a b -> p ta tb 
</syntaxhighlight>

''Strong'' és una especialitat de ''Profunctor''. Els seus mètodes poden passar com a lents que proporcionen una transformació de l'estructura Parell mitjançant la transformació d'un component amb el profunctor d'entrada. (vegeu Mezzolens.Profunctor)

<syntaxhighlight lang="haskell">
class Profunctor p => Strong p where
 _1 :: p a b -> p (a, c) (b, c) -- lent sobre el primer component d'un parell (tupla2)
 _2 :: p a b -> p (c, a) (c, b) -- lent sobre el segon component
</syntaxhighlight>
així, aplicant les lents precedents a una funció que transformi el component obtenim una funció sobre el parell que el conté:
<syntaxhighlight lang="haskell">
Prelude> import Mezzolens.Profunctor as MP

Prelude MP>:t _1 (f :: a -> b) 
:: (a, c) -> (b, c)

Prelude MP>:t _2 (f :: a -> b) 
:: (c, a) -> (c, b)
</syntaxhighlight>
Generació de lents (amb "lens getter setter" de Mezzolens.Unchecked)
* el ''getter'' selecciona de l'estructura el component que interessa <code>(ta -> a)</code>.
* el ''setter'' proporciona la transformació de l'estructura continent en funció de la imatge del component enfocat <code>(b -> ta -> tb)</code>.
* el resultat és una lent que ofereix una transformació de les estructures ''ta'' a ''tb'', en funció d'una transformació del component de ''a'' a ''b'' <code>(p a b -> p ta tb)</code>.
<syntaxhighlight lang="haskell">
-- lens :: (ta -> a) -> (b -> ta -> tb) -> Lens ta tb a b
</syntaxhighlight>

Treballarem amb lents simples, que no modifiquen el tipus
<syntaxhighlight lang="haskell">
-- type Lens' ta a = Lens ta ta a a -- lents simples

-- Les lents es poden compondre 
-- (.) :: Lens' a b -> Lens' b c -> Lens' a c
</syntaxhighlight>

Exemple:
<syntaxhighlight lang="haskell">
{-| fitxer prova-mezzo.hs -}
{-# LANGUAGE PackageImports #-}

import "mezzolens" Mezzolens (Lens', get, (^.), set)
import "mezzolens" Mezzolens.Unchecked (lens)
import Data.Function ((&)) -- (&): aplic. cap enrere

-- seguim la convenció del paquet "lens" de nomenar els camps amb prefix '_' i les lents corresponents sense el prefix

data Arc = Arc {_graus, _minuts, _segons :: Int} deriving (Show)
data Situació = Situació {_latitud, _longitud :: Arc} deriving (Show)

-- estructura a manipular
sitBcn = Situació (arcDeGrausDec 41.399423) (arcDeGrausDec 2.128037)

-- decimal a sexagesimal
arcDeGrausDec :: Double -> Arc
arcDeGrausDec v = Arc partSencera mins secs
 where
 -- fracció pròpia, retorna fracció negativa cas de valors negatius de Lat/Lon 
 (partSencera, partFracció) = properFraction v 
 (mins, secs) = truncate (partFracció * 3600) `quotRem` 60 -- parteix cap a zero amb `quotRem`

-- generació de lents (amb "lens getter setter" de Mezzolens.Unchecked)
-- lens :: (ta -> a) -> (b -> ta -> tb) -> Lens ta tb a b

graus, minuts, segons :: Lens' Arc Int
graus = lens _graus (\v arc -> arc {_graus = v})
minuts = lens _minuts (\v arc -> arc {_minuts = v})
segons = lens _segons (\v arc -> arc {_segons = v})

latitud :: Lens' Situació Arc
latitud = lens _latitud (\v sit -> sit {_latitud = v})

-- lents compostes
lentGrausDeLatitud, lentMinutsDeLatitud, lentSegonsDeLatitud :: Lens' Situació Int
lentGrausDeLatitud = latitud. graus
lentMinutsDeLatitud = latitud. minuts
lentSegonsDeLatitud = latitud. segons

-- llegeix (get) el component enfocat per la lent
grausLat = sitBcn & get lentGrausDeLatitud

-- (^.) és una versió infix de get
-- grausLat = sitBcn ^. lentGrausDeLatitud

-- actualitza el component enfocat amb una funció:
-- (+2) és una funció (les funcions són instància de ''Profunctor'')
-- apliquem la lent sobre el valor de Profunctor (+2) sobre el domini del component i obtindrem un Profunctor del mateix tipus (una funció) que aplicarem a l'estructura continent sitBcn.

sitDosGrausMésAlNordDeBcn = sitBcn & lentGrausDeLatitud (+2)

-- estableix (set) el valor del component enfocat
sitBcnAmbGrausLat45 = sitBcn & set lentGrausDeLatitud 45 -- set lent v = lent (const v)

-- fi de fitxer

# amb GHCi v. 7.10.3
ghci 
Prelude> :l prova-mezzo.hs -- carrega el codi precedent
[1 of 1] Compiling Main (prova-mezzo.hs, interpreted)
Ok, modules loaded: Main.

* Main> :t lentGrausDeLatitud
lentGrausDeLatitud
 :: Mezzolens.Profunctor.Strong p =>
 Mezzolens.Optics.Optical p Situació Situació Int Int

* Main> import Mezzolens as M

* Main M> :t M.get lentGrausDeLatitud
M.get lentGrausDeLatitud :: Situació -> Int

* Main M> :t lentGrausDeLatitud (+2)
lentGrausDeLatitud (+2) :: Situació -> Situació
</syntaxhighlight>

==== Prisma ====
Un prisma és una lent per enfocar un component d'un tipus suma (pluri-constructor), que pot no ser present en un valor i, per tant, fallar.

<syntaxhighlight lang="haskell">
-- Sigui 'a' el tipus del component objectiu de l'estructura d'entrada de tipus 'ta'
-- i 'b' el tipus del component transformat, pertanyent a l'estructura de sortida de tipus 'tb'
</syntaxhighlight>

La funció de selecció, primer paràmetre del generador ''prism'', ofereix en un tipus Either el component enfocat o bé, cas que la variant del tipus suma no sigui la desitjada, un valor del tipus de l'estructura transformada resultant que signifiqui la fallada <code>(ta -> Either tb a)</code>.

El segon paràmetre del generador ''prism'' construeix l'estructura resultant partint de la imatge del component enfocat <code>(b -> tb)</code>.

Exemple amb el cap en una llista.

<syntaxhighlight lang="haskell">
-- de Mezzolens.Optics substituint l'àlies Optical
type Prism ta tb a b = forall p. Choice p => p a b -> p ta tb 

-- Choice és una especialitat de Profunctor amb lents que permeten transformar un tipus Either en funció de la transformació d'un component.
class Profunctor p => Choice p where
 _Left :: p a b -> p (Either a c) (Either b c) -- lent sobre el component de la variant Left
 _Right :: p a b -> p (Either c a) (Either c b) -- lent sobre el component de la variant Right

-- de Mezzolens.Unchecked
prism :: (ta -> Either tb a) -> (b -> tb) -> Prism ta tb a b
-- ^ prism match build
-- match proporciona el component amb Right o bé l'estructura resultant buida amb Left 
-- build forma una variant de l'estructura resultant multi-constructor, partint de la imatge del component

* Main> import Mezzolens as M
* Main M> import Mezzolens.Unchecked as MU
* Main M MU> :set -XLambdaCase

-- prisma sobre el cap d'una llista
* Main M MU> :{ -- getter parcial oferint el resultat en un Either
 let headMatch :: [a] -> Either [a] a 
 headMatch = \case 
 (x : _) -> Right x -- resultat per a variant objectiu
 [] -> Left [] -- resultat per a variant no objectiu 

 headBuild = \x -> [x]

 let _Cap = MU.prism headMatch headBuild
 :}

-- Consulta amb el prisma
* Main M MU> [sitBcn] ^? (_Cap. lentGrausDeLatitud) -- (^?) ofereix el resultat del 'getter' parcial en un Maybe
Just 41

-- Actualització sobre estructura que conté la variant objectiu del prisma
* Main M MU> [sitBcn] & (_Cap. lentGrausDeLatitud) (+2)
[Situació {_latitud = Arc {_graus = 43, _minuts = 23, _segons = 57}, _longitud = Arc {_graus = 2, _minuts = 7, _segons = 40}}]

-- Actualització sobre estructura que no conté la variant objectiu 
* Main M MU> [] & (_Cap. lentGrausDeLatitud) (+2)
[]
</syntaxhighlight>

==== Travesses i plegats amb lents ====
La classe Wandering ofereix una lent per enfocar tots els elements d'un contenidor travessable.

<syntaxhighlight lang="haskell">
class (Strong p, Choice p) => Wandering p where
 wander :: Traversable f => p a b -> p (f a) (f b)
</syntaxhighlight>

* el mètode ''wander'' del ''profunctor'' Wandering ofereix una lent per travessar un travessable. Caldrà compondre'l amb la lent sobre l'element.<ref>[https://hackage.haskell.org/package/mezzolens/docs/Mezzolens-Profunctor.html#v:wander Mezzolens - La lent ''wander'']{{en}}</ref>

* la funció ''Mezzolens.gets'' fa servir Data.Functor.Constant.Constant com a Applicative, que ignora les funcions de composició i retorna la composició Monoidal dels elements.<ref>[https://www.schoolofhaskell.com/user/griba/easier_lenses_profunctor_based_with_mezzolens Easier lenses, Profunctor based, with the Mezzolens library]{{en}}</ref>

* ''toListOf'' obté una seqüència de resultats, a base d'elevar-los amb ''pure'' a un Applicative Monoide que cal concretar amb una restricció de tipus.<ref name="mezzolens-src-tolistof">[https://hackage.haskell.org/package/mezzolens/docs/src/Mezzolens.html#toListOf Mezzolens - toListOf, sumOf]{{en}}</ref>
* ''sumOf'' obté el plegat sobre el Monoide del ''newtype'' Sum.<ref name="mezzolens-src-tolistof"/>

<syntaxhighlight lang="haskell">
* Main>import Mezzolens as M
* Main M>import Mezzolens.Profunctor as MP

-- travessa un travessable actualitzant-ne els elements
* Main M MP>[sitBcn, sitDosGrausMésAlNordDeBcn] & (MP.wander. lentGrausDeLatitud) (+3)
[Situació {_latitud = Arc {_graus = 44, _minuts = 23, _segons = 57}, _longitud = Arc {_graus = 2, _minuts = 7, _segons = 40}},Situació {_latitud = Arc {_graus = 46, _minuts = 23, _segons = 57}, _longitud = Arc {_graus = 2, _minuts = 7, _segons = 40}}]

-- "toListOf" els elements del recorregut són elevats amb "pure" a un Applicative que cal concretar amb una restricció de tipus.
* Main M MP>[sitBcn, sitDosGrausMésAlNordDeBcn] & M.toListOf (MP.wander. lentGrausDeLatitud) :: [Int]
[41,43]

-- (^..) és un sinònim infix de 'toListOf'
* Main M MP>[sitBcn, sitDosGrausMésAlNordDeBcn] ^.. (MP.wander. lentGrausDeLatitud) :: [Int]
[41,43]

-- "sumOf": plegat sobre el Monoide del "newtype Sum"
* Main M MP>[sitBcn, sitDosGrausMésAlNordDeBcn] & M.sumOf (MP.wander. lentGrausDeLatitud)
84
</syntaxhighlight>

== Mòduls ==
Per compilar no cal especificar tots els mòduls a la comanda sinó només el fitxer del mòdul que conté la clàusula ''main''.
<syntaxhighlight lang="bash">
ghc --make Main.hs
# o bé
ghc --make -i src Main.hs # cas que els fonts siguin a la carpeta 'src'
</syntaxhighlight>

Els mòduls a importar s'interpreten com a noms de fitxer sense l'extensió (l'extensió del fitxer pot indicar un tipus de document del qual s'obtindrà el codi Haskell mitjançant un preprocessador),<ref>[http://blog.ezyang.com/2010/06/the-haskell-preprocessor-hierarchy/ Edward Z. Yang - The Haskell Preprocessor Hierarchy]{{en}}</ref> els compostos per parts separades per un punt com a camí ''CarpetaA.CarpetaB.NomDelFitxer''.

* (.hs): mòdul en codi Haskell
* (.lhs): mòdul de Haskell [[Programació literària|literari]].<ref>[https://wiki.haskell.org/Literate_programming HaskellWiki - Programació literària (codi inserit en documentació)]{{en}}</ref>
* (.x): mòdul d'especificació de lèxic segons preprocessador ''Alex''.<ref>[https://wiki.haskell.org/Alex HaskellWiki - Alex]</ref>
* (.y): mòdul d'especificació de gramàtica segons preprocessador ''Happy''.<ref>[https://wiki.haskell.org/Happy HaskellWiki - Happy]</ref>

=== encapsulament ===
No hi ha doble especificació (interfície / implementació) per als mòduls.
S'exporten els identificadors llistats a la clàusula ''module'', o tots si no hi ha llista.

<syntaxhighlight lang="haskell">
module A(
 func1, Tipus2, Classe3,
 pattern SinònimDePatró, -- amb l'extensió de llenguatge 'PatternSynonyms'
 module MòdulP, {- reexporta tot el que s'importa d'aquest mòdul -}
 module MòdulX, {- cas d'un àlies, reexporta tot el que s'importa dels mòduls reanomenats -}
 module A {- si el nom del mòdul coincideix amb l'actual, exporta totes les declaracions locals -}
) where

import MòdulP (A,B,C) -- detalla elements a importar que re-exportarem citant el mòdul

-- el mateix àlies permet reexportar el contingut de diversos mòduls de cop
import MòdulQ as MòdulX
import MòdulR as MòdulX
import MòdulS as MòdulX
...
</syntaxhighlight>

==== distingir entre tipus i valors a l'export./import. quan hi ha coincidències ====
Per exportar operadors constructors de tipus i no confondre'ls amb un operador funció del mateix nom, cal prefixar-lo amb el prefix ''type'' que explicita l'espai de noms al qual pertany l'identificador que volem exportar o bé importar. Cal esmentar l'extensió de llenguatge ''ExplicitNamespaces'' o altres que la impliquin.<ref>{{Ref-web |url=https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/syntax-extns.html#explicit-namespaces |títol=Explicit namespaces in import/export |consulta=2021-07-15 |arxiuurl=https://web.archive.org/web/20160413074834/https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/syntax-extns.html#explicit-namespaces |arxiudata=2016-04-13 }}</ref>
<syntaxhighlight lang="haskell">
{-# LANGUAGE ExplicitNamespaces #-}

module N(-- 'type' a l'exportació explicita l'espai de noms de l'identificador que segueix
 f, 
 type (++) -- amb 'type' exporta el constructor de tipus (++) definit tot seguit
 -- evitant la confusió amb la funció (++) de les llistes
) where 
 data family a ++ b = L a | R b

-- per reexportar-lo
module M(f, type (++)) where ...
 import N(f, type (++))
</syntaxhighlight>

==== accés públic als membres de classes i tipus ====
Per
* exportar els identificadors interns d'un '''tipus''': constructors; noms de camp en registres.
* i facilitar l'accés públic als mètodes d'una '''classe''',

cal esmentar-los entre parèntesis a l'exportació, o bé adjuntar l'el·lipsi (..) per indicar tots. Altrament el tipus o la classe seran opacs.
<syntaxhighlight lang="haskell">
module A(
 func1,

 Tipus2(..), -- tipus transparent, accés public als constructors
 Tipus3, -- tipus opac, modificable només per les operacions del tipus
 Tipus4(ConstructorPúblic_A, accessorPúblic_B), -- només publica els esmentats

 Classe4(..), -- classe amb accés públic a tots els mètodes
 UnaAltraClasse(mètodePúblic_A, mètodePúblic_B), -- els mètodes no publicats només son accessibles en el mòdul

) where
...
</syntaxhighlight>

==== Importació ====
<syntaxhighlight lang="haskell">
 import MòdulA -- importa-ho tot
 import MòdulA (id1, id2, id3) -- enumeració: importa només els esmentats
 import MòdulA hiding (id1, id2) -- ''hiding'': tots excepte els esmentats
 -- as B: reanomenament del mòdul
 import qualified MòdulB as B -- ''qualified'': qualificació obligatòria: B.ident
 import MòdulB as B [hiding (...] -- sense ''qualified'': qualificació opcional en cas de col·lisió de noms
 import MòdulA as B (id1, id2) -- importa els esmentats amb qualificació opcional reanomenada
</syntaxhighlight>

===== Importació d'instàncies (implementacions de classes) =====
<syntaxhighlight lang="haskell">
 import MòdulA () -- llista buida, per importar només les instàncies
</syntaxhighlight>
* les instàncies ''visibles'' d'un mòdul s'exporten sempre; qualsevol importació del mòdul les importa totes.<ref>[http://www.haskell.org/onlinereport/modules.html#import-instances Importació d'instàncies]</ref>

===== Importacions especificant el paquet desitjat =====
Cal esmentar la [[pragma]] d'ampliació de sintaxi {-# LANGUAGE PackageImports #-}
<syntaxhighlight lang="haskell">
import "nom_del_paquet" Nom_del_mòdul
-- com ara:
import "network" Network.Socket
import qualified "network" Network.Socket as NS
</syntaxhighlight>

===== Evitar la importació automàtica de les funcions predefinides =====
Per evitar-ne la importació de només algunes:
<syntaxhighlight lang="haskell">
import Prelude hiding (head, tail, init, last) -- amaga funcions parcials del 'Prelude' que poden petar (n'hi ha una colla)
</syntaxhighlight>

Amb la [[pragma]] <code>{-# LANGUAGE NoImplicitPrelude #-}</code> amaguem tot el ''Prelude'', i podem substituir-lo per un altre mòdul:

<syntaxhighlight lang="haskell">
-- Per a l'exemple que substitueix l'entrada/sortida de tipus String per la de tipus Text
-- perquè els caràcters no anglosaxons ([[ASCII]]), el tipus String els mostra amb codis numèrics.
module ElMeuPrelude (
 putStr, putStrLn, getLine
 module PreludeMancat, -- exporta la resta del Prelude de 'PreludeMancat'
) where

import Prelude as PreludeMancat hiding (putStr, putStrLn, getLine) -- amaga la E/S amb operands String
import Data.Text.IO (putStr, putStrLn, getLine) -- importa la E/S per al tipus Text
</syntaxhighlight>
ús:
<syntaxhighlight lang="haskell">
-- no importis el Prelude que ja tinc el meu.
{-# LANGUAGE NoImplicitPrelude #-}
module ... where
import ElMeuPrelude
...
</syntaxhighlight>

==== espai de noms de mòdul jeràrquic ====
Els detalls de tractament intern que no formaran part de l'API se solen encapsular en mòduls allotjats en carpetes internes. Per accedir-hi, un nom del mòdul separat per punts ("A.B.NomDelFitxer") reflecteix el camí d'accés (''A/B/NomDelFitxer''), excepte l'extensió del fitxer, que indica si el font és de codi (.hs) o és un document al qual cal aplicar un preprocessador (de lèxic (.x), de gramàtica (.y), de [[programació literària]] (incrustada dins la documentació) (.lhs), o altres) per obtenir-ne el codi font.

En compilar, el senyal -i''<dirs>'' indica a GHC la llista de directoris base de la recerca dels fonts<ref>[http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#hierarchical-modules Noms de mòdul jeràrquics] {{Webarchive|url=https://web.archive.org/web/20051129140339/http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#hierarchical-modules |date=2005-11-29}}{{en}}</ref>

És corrent reanomenar els noms jeràrquics a un sobrenom curt
<syntaxhighlight lang="haskell">
 import qualified Control.Monad.ST.Strict as ST
</syntaxhighlight>

==== mòduls amb referències mútues (mútuament recursius) ====
Vegeu-ho a [[Compilador Haskell de Glasgow#Mòduls amb referències mútues (mútuament recursius)]]

==== arrencada ====
El mòdul principal ha de dur per nom de mòdul "Main" i ha d'exportar la funció "main". Si no hi ha clàusula ''module'' es pren per defecte "module Main where", exportant tots els identificadors (útil per a proves a l'intèrpret).

Els arguments de la línia d'ordres de consola (''getArgs''), no inclouen el nom del programa, que s'obté amb ''getProgName''.

Per indicar l'eixida amb codi de finalització: <code>exitWith (ExitSuccess | ExitFailure codi_de_finalització)</code> dispara una excepció de fi de programa.

Exemple senzill. (System.Environment no té en compte la codif. local, vegeu comentari):

<syntaxhighlight lang="haskell">
-- per una lectura correcta (dels caràcters no anglosaxons) de la consola de comandes a Linux
-- cal esmentar "System.Environment.UTF8" del paquet utf8-string
--, en lloc de "System.Environment"

import System.Environment (getProgName, getArgs) -- a Linux System.Environment.UTF8
import System.Exit (exitSuccess, exitWith, ExitCode(..))
import Text.Printf (printf)

main = do
 args <- getArgs
 nomProg <- getProgName
 case args of
 [] -> do
 printf "%s: cal especificar un paràmetre.\n" nomProg
 exitWith (ExitFailure 1) -- dispara excep. de fi de programa especificant el codi de finalització.

 (arg:_) -> do
 printf "el primer param. és: %s\n" arg
 exitSuccess -- equival a: exitWith ExitSuccess -- dispara excep. de fi de programa amb codi 0

</syntaxhighlight>

En el llançament, a més dels paràmetres del programa, s'hi poden afegir paràmetres per al Run Time System a partir del separador ''+RTS'' tancant opcionalment amb ''-RTS''<ref>[http://haskell.org/ghc/docs/latest/html/users_guide/runtime-control.html Running a compiled program] {{Webarchive|url=https://web.archive.org/web/20090417001825/http://www.haskell.org/ghc/docs/latest/html/users_guide/runtime-control.html |date=2009-04-17}} {{en}} Paràmetres per al Run Time System</ref> en cas d'haver d'afegir, tot seguit, paràmetres pel programa

===== arrencada amb opcions =====
Vegeu-ho a [[Compilador Haskell de Glasgow#Arrencada amb opcions|GHC]].

==== funcions i tipus predefinits i biblioteques bàsiques ====
El mòdul de funcions predefinides es coneix com a "Prelude". Vegeu Prelude estàndard.<ref>[https://www.haskell.org/onlinereport/haskell2010/haskellch5.html#x11-1110005.6 H2010 Standard Prelude - funcions i tipus predefinits]{{en}}</ref><ref>[http://www.haskell.org/onlinereport/standard-prelude.html H98 Standard Prelude - funcions i tipus predefinits]{{en}}</ref> Prelude del GHC.<ref>[http://hackage.haskell.org/package/base/docs/Prelude.html Prelude del GHC]{{en}}</ref>

Les [[API]]'s de les biblioteques bàsiques són aquí<ref name="api-biblio">[http://www.haskell.org/ghc/docs/latest/html/libraries/ API's de les biblioteques bàsiques del Haskell]{{en}}</ref>

Podeu consultar a quins mòduls pot pertànyer un identificador mitjançant els cercadors de l'[[API]] del Haskell [http://holumbus.fh-wedel.de/hayoo/hayoo.html {{Webarchive|url=https://web.archive.org/web/20100322194454/http://holumbus.fh-wedel.de/hayoo/hayoo.html |date=2010-03-22}} Hayoo] o bé [https://www.haskell.org/hoogle/ Hoogle]

==== Precisió dels tipus bàsics ====
Vegeu-ho a [[Compilador Haskell de Glasgow#Precisió dels tipus bàsics|GHC#Precisió dels tipus bàsics]]

== Vectors ==
=== Vectors per interfície ===
<blockquote>
; Vectors immutables: interfície (classe) IArray, parametritzats pels tipus de l'índex i de l'element.<ref>[http://hackage.haskell.org/package/array/docs/Data-Array-IArray.html Interfície dels vectors immutables]{{en}}</ref> Vegeu [[#Vectors immutables del H98]]
; Vectors mudables: interfície (classe) MArray, parametritzats pels tipus de l'índex i de l'element.<ref>[http://hackage.haskell.org/package/array/docs/Data-Array-MArray.html Interfície dels vectors mudables]{{en}}</ref> Exemple a [[#Vectors mudables de dades no encapsulades]]
; Vectors d'alt rendiment: al paquet ''vector'',<ref>[https://hackage.haskell.org/package/vector Paquet vector] {{en}}</ref> vectors d'índex enter amb base 0, immutables (tipus Vector) i mudables (tipus MVector), amb versions per a elements allotjats indirectament (allotjament encapsulat) o bé amb allotjament directe (qualificats ''Unboxed''). Paquets relacionats: vector-algorithms ('''algorismes eficients en espai amb actualitzacions in-situ''' per a vectors mudables), vector-instances, vector-binary-instances (instàncies de serialització), vector-read-instances, ...
; Vectors pluridimensionals (amb paral·lelisme intern): a GHC [[Compilador Haskell de Glasgow#vectors pluridimensionals|amb el paquet REPA (Regular Parallel Arrays)]]
; Vectors de tractament paral·lel (paral·lelisme de dades DPH): interfície PArray.<ref>[https://hackage.haskell.org/package/dph-lifted-vseg/docs/Data-Array-Parallel.html mòdul Data.Array.Parallel]{{en}}</ref> (cada op. conclou havent avaluat tots els elements) Només a GHC.<ref>[http://www.haskell.org/haskellwiki/GHC/Data_Parallel_Haskell Vectors de tractament paral·lel (paral·lelisme de dades)]{{en}}</ref>
; Vectors amb allotjament contigu, per a ésser accedits des de mòduls forans (per ex. [[llenguatge C|lleng. C]]): interfície Storable.<ref>[http://hackage.haskell.org/package/array/docs/Data-Array-Storable.html Vectors en memòria amb accés de nivell baix]{{en}}</ref>
</blockquote>

==== Immutables, per implementació i allotjament dels elements ====
Els elements dels vectors poden estar:
* allotjats indirectament (''encapsulats'' en memòria dinàmica, ang:''boxed''): representats per un punter (l'avaluació serà tardana)
* allotjats directament (''no encapsulats'', ang:''unboxed''): representats per un valor, evidentment avaluats abans d'ésser-hi assignats (avaluació estricta, el nom del tipus es diferencia incorporant la lletra 'U' de ''Unboxed'' com a ''xxUArray'').

===== amb actualització de còpia completa =====
Ineficients en espai. Vegeu Array<ref>[http://hackage.haskell.org/package/array/docs/Data-Array.html Vectors d'elements encapsulats]{{en}}</ref> UArray<ref>[http://hackage.haskell.org/package/array/docs/Data-Array-Unboxed.html Vectors d'elements Unboxed (No encapsulats)]{{en}}</ref>
<syntaxhighlight lang="haskell">
 data Array idx elem -- Elements allotjats indirectament (encapsulats en memòria dinàmica, avaluació tardana)
 data UArray idx elem -- Amb U de ''Unboxed'': elements no encapsulats, allotjats directament, avaluació estricta.
</syntaxhighlight>

<syntaxhighlight lang="haskell">
-- exemple
import Data.Array.Unboxed (UArray) -- UArray: tipus amb elements 'unboxed' (no encapsulats)
import Data.Array.IArray (listArray) -- IArray: interfície immutable

vec :: UArray Int Float -- vector de Floats amb índex de tipus Int
vec = listArray (0,2) [0.5, 1.5, 2.5]

-- (//) actualització amb una llista de parells (índex, nou_valor)
nouVec = vec // [(indx, nou_valor)] -- còpia completa
</syntaxhighlight>

===== amb actualització per aplicació de diferències. ''DiffArrays'' =====
* Vegeu ''DiffArrays''.<ref>[http://www.haskell.org/haskellwiki/Arrays#DiffArray_.28module_Data.Array.Diff.29 HaskellWiki - DiffArrays]{{en}}</ref> s'afavoreix l'accés en temps constant a la versió més recent; els valors de referències antigues s'obtenen per aplicació de les diferències i, per tant, l'accés és més lent com més antiga sigui la variable, és a dir, més actualitzacions funcionals hagi sofert.<ref>[http://hackage.haskell.org/packages/archive/diffarray/latest/doc/html/Data-Array-Diff.html Hackage - DiffArrays - Vectors per diferència]{{en}}</ref>
<syntaxhighlight lang="haskell">
import Data.Array.Diff (DiffUArray) -- Amb U de Unboxed: elements no encapsulats, allotjats directament, avaluació estricta
import Data.Array.IArray (listArray)

vec :: DiffUArray Int Float
vec = listArray (0,2) [0.5, 1.5, 2.5]

-- (//) actualització; l'accés al valor de ''nouVec'' serà més ràpid que al del seu antecessor ''vec''
nouVec = vec // [(indx, nou_valor)]
</syntaxhighlight>

==== Mudables, per implementació i allotjament ====
* Vectors d'accés aleatori com a efecte global IO (objectes amb cicle de vida no acotat), en memòria global.<ref>[http://hackage.haskell.org/package/array/docs/Data-Array-IO.html Vectors en memòria global (mònada IO)]{{en}}</ref>
<syntaxhighlight lang="haskell">
 data IOArray idx elm -- amb allotjament indirecte dels elements (encapsulats en memòria dinàmica, avaluació tardana).
 data IOUArray idx elm -- amb U de Unboxed: elements no encapsulats, allotjats directament, avaluació estricta.
</syntaxhighlight>

* Vectors d'accés aleatori com a efecte encapsulable ST (objectes amb vida lligada a l'àmbit de l'efecte), en memòria local (o bé global cas d'avaluació de l'efecte ST amb ''stToIO'').<ref>[http://hackage.haskell.org/package/array/docs/Data-Array-ST.html Vectors en memòria local (mònada ST)]{{en}}</ref>
<syntaxhighlight lang="haskell">
 data STArray s idx elm -- amb allotjament indirecte dels elements (encapsulats en memòria dinàmica).
 data STUArray s idx elm -- amb U de Unboxed: elements no encapsulats, allotjats directament, avaluació estricta.
</syntaxhighlight>

(El paràm. 's' correspon al param. de l'espai de l'efecte local ''(ST s tipResultat)'')

Exemples a [[#Vectors mudables de dades no encapsulades]].

==== Vectors immutables del H98 ====
La classe Array combinada amb la Ix (índexs), especificades en el Haskell98, implementen vectors immutables amb elements d'avaluació tardana.<ref>[http://hackage.haskell.org/package/array/docs/Data-Array.html mòdul Data.Array]{{en}}</ref><ref name="data-ix"/>

<div style="background-color:#f4f6fe; border-style:solid; border-width:1px;">
<syntaxhighlight lang="haskell">
 -- vector d'una dimensió, s'inicialitza amb
 -- el rang i una llista exhaustiva de parells (índex, valor)
 import Data.Array -- Array al Haskell98

 vec = array (menor, major) [ (i, expr_valor) | i <-[ menor..major ]]
 element = vec!indx -- (!) valor per a l'índex indx

 -- (//) actualització amb una llista de parells (índex, nou_valor)
 nouVec = vec // [(indx, nou_valor)]

 -- vector de dues dimensions
 w = array ((menor_i1, menor_i2), (major_i1, major_i2)) [((i, j), expr_valor) |
 i <- [menor_i1..major_i1], j <- [menor_i2..major_i2]]
</syntaxhighlight></div>

===== vector amb índex de tipus enumerat =====
Caldrà que l'enumerat implementi la classe dels índexs Ix (A GHC: al mòdul Data.Ix)<ref>[http://hackage.haskell.org/package/base/docs/Data-Ix.html Data.Ix]{{en}}</ref>
<syntaxhighlight lang="haskell">

class Ord a => Ix a where
 range :: (a, a) -> [a] -- '(range (desDe, finsA))' obté la llista [desDe .. finsA]
 index :: (a, a) -> a -> Int -- '(índex (desDe, finsA) x)' obté la distància(desDe, x)
 inRange :: (a, a) -> a -> Bool -- '(inRange (desDe, finsA) x)' indica si (desDe <= x && x <= finsA)
 rangeSize :: (a, a) -> Int -- '(rangeSize (desDe, finsA))' obté la mida de [desDe .. finsA]
</syntaxhighlight>

Exemple:
<syntaxhighlight lang="haskell">

 import Data.Array -- Array al Haskell98 
 import Data.Ix -- Ix al Haskell98
 import Text.Printf
 import Data.Function ((&)) -- (&) = flip ($) -- infixl 1 -- desde GHC 7.10.1

 data DiaFeiner = Dl | Dm | Dc | Dj | Dv
 deriving (Show, Eq, Ord, Enum, Ix) -- el compilador instancia Ix

 encàrrecs :: Array DiaFeiner Int
 encàrrecs = array (Dl,Dv) [(Dl,5),(Dm,6),(Dc,3),(Dj,7),(Dv,8)] -- rang i parells (índex, valor)

 main = do
 printf "Per dimecres tinc %d encàrrecs\n" (encàrrecs!Dc)

 putStr "De Dilluns a Divendres: "
 range (Dl,Dv) & map (encàrrecs!) -- aplicació parcial de l'operació (!)
 & show
 & putStrLn
</syntaxhighlight>

A part d'aquests vectors, que generen una còpia a cada actualització, n'hi ha d'altres de força més eficients.<ref>[http://haskell.org/haskellwiki/Arrays Altres tipus de vectors a GHC] {{en}}</ref><ref>[http://haskell.org/ghc/docs/3.01/users_guide/libs.html Extensions comunes a GHC i Hugs] {{Webarchive|url=https://web.archive.org/web/20130126164659/http://www.haskell.org/ghc/docs/3.01/users_guide/libs.html |date=2013-01-26}} {{en}}</ref> Entre aquests vegeu més avall [[#Vectors mudables de dades no encapsulades]].

==== Vectors mudables de dades no encapsulades ====
Amb allotjament directe (no encapsulat) dels elements.

===== vect. mudables amb cicle de vida lligat a l'àmbit (efecte encapsulable ST) =====
* Per a vectors amb cicle de vida lligat a l'àmbit i tipus del vector: (STUArray s ''tipus_de_l'índex'' ''tipus_de_l'element''). (La 'U' és per Unboxed: allotja el valor i no un punter)

:el tipus de l'índex ha d'implementar la classe ''Ix'' igual que els [[#Vectors immutables del H98|vectors de la def. del 98]].

<div style="background-color:#f4f6fe; border-style:solid; border-width:1px;">
<syntaxhighlight lang="haskell">

import Control.Monad.ST
import Data.Array.ST

obtenirParell :: ST s (Int, Int) -- el param. 's' indica l'espai d'avaluació de l'efecte
obtenirParell = do

 -- indiquem el tipus de ''newArray '' per indicar el tipus del vector STUArray
 -- (si volguéssim vectors d'elements d'allotjament indirecte i avaluació tardana utilitzaríem STArray)
 -- i perquè els literals 1,10,37, són de tipus indeterminat (vegeu secció "literals" més amunt)
 -- i cal concretar-ne el tipus.

 arr <- newArray (1,10) 37 :: ST s (STUArray s Int Int) -- rang valorInicial i tipus
 a <- readArray arr 1
 writeArray arr 1 64
 b <- readArray arr 1
 return (a,b)

main = do
 let x = runST obtenirParell -- avalua l'efecte ST en l'espai del fil d'execució
 print x

</syntaxhighlight></div>

===== vect. mudables amb cicle de vida no acotat (efecte superficial IO) =====
* En memòria global i tipus del vector: (IOUArray ''tipus_de_l'índex'' ''tipus_de_l'element'')

<div style="background-color:#f4f6fe; border-style:solid; border-width:1px;">
<syntaxhighlight lang="haskell">

import Data.Array.IO

obtenirParell :: IO (Int, Int)
obtenirParell = do

 -- indiquem el tipus de ''newArray '' per indicar el tipus del vector IOUArray
 -- (si volguéssim vectors d'elements d'allotjament indirecte i avaluació tardana utilitzaríem IOArray)

 arr <- newArray (1,10) 37 :: IO (IOUArray Int Int) -- rang valorInicial i tipus
 a <- readArray arr 1
 writeArray arr 1 64
 b <- readArray arr 1
 return (a,b)

main = obtenirParell >>= print

</syntaxhighlight></div>

== Genèrics ==
L'equivalent dels mòduls genèrics (paramètrics en tipus) d'altres llenguatges, es pot fer de dues maneres:
* l'antiga, afegint tots els paràmetres de tipus als paràmetres de la classe de tipus, especificant les dependències funcionals.
* la moderna, els paràmetres de tipus independents s'afegeixen als de la classe i els dependents es defineixen com a tipus associats a la classe.

=== Genèrics amb ''dependències funcionals'' ===
Afegint les variables de tipus com a paràmetres de les classes i definint-ne les relacions amb ''dependències funcionals''.

A les classes multiparàmetre pot ser que una part dels paràmetres vingui determinada per altres (per exemple el tipus de la col·lecció determina el tipus de l'element).<ref name="fundeps">[http://www.haskell.org/haskellwiki/Functional_dependencies Classes multiparàmetre i dependències funcionals]{{en}}</ref>

La sintaxi de les dependències funcionals és:
<syntaxhighlight lang="haskell">
class NomClasse a b c | a b -> c where
</syntaxhighlight>
indicant que a les instàncies el grup de valors (''a'', ''b'') determina el de '' 'c' '' i n'ha d'esperar un sol valor per cada ocurrència del grup determinador. Els tipus determinats s'expressen en funció dels determinadors, i si són monomòrfics (sense variables) n'hi ha prou amb el comodí '_'.

<syntaxhighlight lang="haskell">
-- exemple de classe multi-param. amb dependències funcionals
{-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies, FlexibleInstances #-}
class (Eq elt) => Conjunt cjt elt | cjt -> elt where
 buit :: cjt
 afegeix :: elt -> cjt -> cjt

instance Eq a => Conjunt [a] a where
 buit = []
 afegeix x [] = [x]
 afegeix x (y : ys)
 | x == y = y : ys
 | otherwise = y : afegeix x ys

test = afegeix 1 $ (buit :: [Int])

main = print test
</syntaxhighlight>

=== Genèrics amb ''tipus associats'' ===
Els paràmetres de tipus dependents del tipus índex de la classe s'especifiquen en funció del mateix. Són abstractes a la definició de la signatura i concretables a les instàncies.
<syntaxhighlight lang="haskell">
class Col·lecció t where
 type Element t -- tipus associat com a àlies, instanciable mitjançant una expressió de tipus
 data Opcions t -- tipus associat estructural, instanciable mitjançant constructors
</syntaxhighlight>
Exemple:
<syntaxhighlight lang="haskell">
-- exemple de classe amb tipus associats
{-# LANGUAGE TypeFamilies, FlexibleContexts #-}

class (Eq (Element t)) => Conjunt t where
 type Element t
 buit :: t
 afegeix :: Element t -> t -> t

instance Eq a => Conjunt [a] where
 type Element [a] = a
 buit = []
 afegeix x [] = [x]
 afegeix x (y : ys)
 | x == y = y : ys
 | otherwise = y : afegeix x ys

prova = afegeix 1 $ (buit :: [Int])
</syntaxhighlight>

* Una variant d'aquest sistema és definir els tipus associats no dins la classe sinó a nivell de mòdul, mitjançant [[#Famílies de tipus]] (clàusules ''type family/instance'' per als àlies de tipus, ''data family/instance'' per als tipus estructurals):

<syntaxhighlight lang="haskell">
-- exemple de classe amb famílies de tipus
{-# LANGUAGE TypeFamilies, FlexibleContexts #-}

type family Element t
type instance Element [a] = a

class (Eq (Element t)) => Conjunt t where
 buit :: t
 afegeix :: Element t -> t -> t

instance Eq a => Conjunt [a] where
 buit = []
 afegeix x [] = [x]
 afegeix x (y : ys)
 | x == y = y : ys
 | otherwise = y : afegeix x ys

prova = afegeix 1 $ (buit :: [Int])
</syntaxhighlight>

==== Correspondència amb els ''functors'' de [[ML Estàndard|ML]] ====
Correspondència de les classes de Haskell amb els ''functors'' de [[ML Estàndard|ML]], en definir una signatura de conjunt i la seva implementació. Vegeu [[OCaml#Estructures paramètriques: Functors|Functors a OCaml]]

{| class=wikitable
|+ correspondència aproximada
|-
! Haskell || ML !! a l'exemple
|-
| ''class'' || ''signature'' || Conjunt
|-
| ''instance'' || ''structure'' ||
|-
| ''class'' (amb requeriments de context) || signatura del ''functor'' ||
|-
| ''instance'' paramètrica (amb requeriments de context) || def. del ''functor'' || ConjuntVectorAmbIgualtat
|-
| restricció a un tipus concret del tipus d'una ''instance'' paramètrica || aplicació del ''functor'' || ConjuntVectorDeSencers<br/>(els Int implementen igualtat)
|}

* Amb classes i tipus associats i canviant l'agregació de llista a vector.

<div style="background-color:#f4f6fe; border-style:solid; border-width:1px;">
<syntaxhighlight lang="haskell">
{-# LANGUAGE TypeFamilies, MultiParamTypeClasses, FlexibleInstances #-}

import Data.Vector as Vector
import Data.Function ((&)) -- (&) = flip ($) -- infixl 1 -- desde GHC 7.10.1

class Set tip_conjunt where -- signatura del model de Conjunt
 type Element tip_conjunt -- Element és funció de tipus de tipconjunt

 buit :: tip_conjunt
 afegeix :: Element tip_conjunt -> tip_conjunt -> tip_conjunt
 llistar :: tip_conjunt -> [Element tip_conjunt]

-- functor ConjuntVectorAmbIgualtat
-- la var. del genèric és tip_elemt
-- els requeriments del tipus de la var. del genèric s'expliciten en el ''context =>''
-- i queda restringit existencialment (aquells tip_elemt tals que ''Eq tip_elemt'')

instance Eq tip_elemt => Set (Vector tip_elemt) where -- la var. del genèric és tip_elemt
 -- el tipus de la var és "aquells tip_elemt tals que Eq tip_elemt"

 type Element (Vector tip_elemt) = tip_elemt -- obtenció de tip_elemt per encaix de tip_conjunt
 buit = Vector.empty
 afegeix = \x xs -> Vector.cons x $ Vector.filter (/= x) xs
 llistar = Vector.toList

-- aplicació del functor al tipus ''Int'' mitjançant una restricció de tipus,
-- substituint la variable existencial ''tip_elemt'' del genèric
-- pel tipus concret Int com a subtipus (compleix els requeriments (def. d'igualtat) de ''tip_elemt'')

conj_buit = buit :: Vector Int -- ConjuntVectorDeSencers

prova1 = conj_buit & afegeix 2
 & afegeix 1
 & llistar
--------------------------------------------
-- Ampliació amb noves funcions

class (Set tip_conjunt) => SetHelp tip_conjunt where -- signatura noves funcions

 -- Element és membre de la classe base
 afegeixLlista :: [Element tip_conjunt] -> tip_conjunt -> tip_conjunt 

instance Eq tip_elemt => SetHelp (Vector tip_elemt) where -- estructura complementària

 afegeixLlista llista conjunt = Vector.foldr afegeix conjunt (Vector.fromList llista)

prova2 = conj_buit & afegeixLlista [1,2]
 & llistar
</syntaxhighlight></div>

== Temes avançats ==
=== Monomorfisme, polimorfisme i quantificadors explícits ===
Vegeu ref.<ref>[http://www.haskell.org/haskellwiki/Monomorphism_restriction Monomorphism_restriction]{{en}}</ref>

==== Polimorfisme universal ====
El polimorfisme per defecte dels paràmetres de funcions és l{{'}}'''universal'''.<ref>[[b:en:Haskell/Polymorphism|Polimorfisme]]</ref> El nombre de nivells de quantificació universal en una funció s'anomena ordre del tipus de la funció (ang: type rank). Vegeu ''Rank-N types'' (tipus d'ordre ''N'').<ref>[http://www.haskell.org/haskellwiki/Rank-N_types Rank-N types]{{en}}</ref>

<syntaxhighlight lang="haskell">
{-# LANGUAGE ExplicitForAll #-}

 -- declaracions idèntiques -- per a tot tipus ''a''
 id :: a -> a -- (tipus de 1r ordre)
 id :: forall a. a -> a -- amb quantificador universal explícit. (tipus de 1r ordre)

 -- forall explícit als paràmetres
 foo :: (forall a. a -> a) -> (Char,Bool) -- funció amb tipus de 2n ordre (ang: rank-2 type)
</syntaxhighlight>
El ''forall'' explícit incorpora les variables de tipus a l'àmbit de la definició fent que les variables coincidents de les restriccions de tipus internes quedin unificades.<ref>[https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#scoped-type-variables Lexically scoped type variables] {{Webarchive|url=https://web.archive.org/web/20180821174039/http://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#scoped-type-variables |date=2018-08-21 }}{{en}}</ref><ref>[https://www.schoolofhaskell.com/user/PthariensFlame/guide-to-ghc-extensions/explicit-forall Guia d'extensions de GHC - ExplicitForAll]</ref>
<syntaxhighlight lang="haskell">
{-# LANGUAGE ScopedTypeVariables #-}

f :: forall a. [a] -> [a] -- incorpora la var. 'a' a l'àmbit de la definició
f xs = ys ++ ys
 where
 ys :: [a] -- 'a' és el tipus del primer paràmetre de la funció
 ys = reverse xs
</syntaxhighlight>

Vegeu també
* Rank-2 types, ($) and the Monomorphism restriction<ref name="dolar_i_monomorfisme"/>
* Extensió {-# LANGUAGE NoMonomorphismRestriction #-}<ref>[https://downloads.haskell.org/ghc/latest/docs/html/users_guide/glasgow_exts.html#switching-off-the-dreaded-monomorphism-restriction Switching off the Monomorphism restriction] {{Webarchive|url=https://web.archive.org/web/20210131014154/https://downloads.haskell.org/ghc/latest/docs/html/users_guide/glasgow_exts.html#switching-off-the-dreaded-monomorphism-restriction |date=2021-01-31}}{{en}}</ref>
* Des de GHC 7.2 Monomorfisme als lligams locals (let|where), excepte que s'expliciti la generalització.<ref>[https://www.haskell.org/ghc/blog/20100930-LetGeneralisationInGhc7.html Let Generalisation in GHC 7.2]{{en}} Monomorfisme als lligams locals</ref>

=== Tipus de Dades Algebraics Generalitzats (GADTs) ===
És un tipus de dades paramètric, definit amb la clàusula ''data'' on els constructors venen descrits dins una clàusula ''where'', amb una entrada per constructor com si fos una funció, permetent que els constructors retornin subtipus (més específics) del tipus paramètric que es defineix.

Té aplicació en els llenguatges incrustats per a camps d'aplicació específics, anomenats DSL (Domain Specific Language). Requereix l'extensió de llenguatge 'GADTs'.

Vegeu<ref>{{Ref-web |url=http://haskell.org/ghc/docs/latest/html/users_guide/data-type-extensions.html#gadt |títol=Tipus de Dades Algebraics Generalitzats (GADTs) |consulta=2010-03-07 |arxiuurl=https://web.archive.org/web/20100410075414/http://www.haskell.org/ghc/docs/latest/html/users_guide/data-type-extensions.html#gadt |arxiudata=2010-04-10}}</ref>

* El guany és el refinament de tipus en fer l'encaix de patrons.

<div style="background-color:#f4f6fe; border-style:solid; border-width:1px;">
<syntaxhighlight lang="haskell">
{-# LANGUAGE GADTs #-}

data Terme a where
 Literal :: Int -> Terme Int -- retorna el subtipus (Terme Int)
 Successor :: Terme Int -> Terme Int
 EsZero :: Terme Int -> Terme Bool -- retorna (Terme Bool)
 SiCondició :: Terme Bool -> Terme a -> Terme a -> Terme a -- retorna el tipus paramètric
 Parell :: Terme a -> Terme b -> Terme (a,b) -- retorna un parell com a paràmetre

avalua :: Terme a -> a -> a
avalua (Literal i) j = i+j -- l'operació + és permesa per què es dedueix
 -- que ''Literal i'' és de tipus (''Terme Int'')
 -- i per tant, en aquest encaix, ''a'' és Int
 -- ja no caldrà declarar que el tipus de ''a''
 -- ha d'implementar la suma: (Num a) => ...

</syntaxhighlight></div>

=== Variables d'accés no garantit (amb ''unsafePerformIO'') ===
És una solució poc ortodoxa per la modificació de variables globals sense haver de passar la variable com a paràmetre, bàsicament per la modificació de preferències en temps d'execució.

De fet trenca el principi de transparència referencial de les funcions que les incorporin: constància del resultat amb les mateixes entrades, impedint l'ús de tècniques d'optimització com la memoïtzació (taules paràmetres/resultats per evitar el recàlcul).

Cal assegurar-se que la seva modificació sigui avaluada, abans de fer-ne ús, perquè el llenguatge no ho garanteix.

''unsafePerformIO'' és la ''"porta del darrere"'' de la mònada IO.<ref>[https://hackage.haskell.org/package/base/docs/System-IO-Unsafe.html System.IO.Unsafe - unsafePerformIO]{{en}}</ref>

<syntaxhighlight lang="haskell">
{-# OPTIONS_GHC -fno-cse -fno-full-laziness #-} -- recomanació de System.IO.Unsafe
import System.IO.Unsafe
import Data.IORef

-- variable de prova, a l'estil del llenguatge ML
{-# NOINLINE intRef #-} -- recomanació de System.IO.Unsafe
intRef :: IORef Int
intRef = unsafePerformIO $ newIORef 0

-- amp paràmetre ''unit'' () per forçar el recàlcul a cada invocació
-- evitant la memorització de les definicions sense paràmetres

{-# NOINLINE llegeix #-}
llegeix :: () -> Int
llegeix _ = unsafePerformIO $ readIORef intRef
</syntaxhighlight>

Aquesta solució és incompatible amb la certificació ''[[Compilador Haskell de Glasgow#Safe Haskell|Safe Haskell]]''.

El sistema més correcte és tractar les preferències com un entorn canviant i passar-lo com a paràmetre allà on calgui, fent servir [[Mònada (programació funcional)#La mònada Reader|la mònada ''Reader'']] o bé el [[Mònada (programació funcional)#Transformadors de mònades|transformador de mònades]] corresponent ''ReaderT''.<ref>[https://wiki.haskell.org/All_About_Monads#The_Reader_monad The Reader monad]{{en}}</ref>

Vegeu [[Compilador Haskell de Glasgow#Tractament d'un entorn canviant, amb la mònada Reader]]

=== Classificacions dels tipus ===
GHC utilitza la següent nomenclatura:<ref>[https://ghc.haskell.org/trac/ghc/wiki/Commentary/Compiler/TypeType#Classifyingtypes Classifying Types]{{en}}
</ref><ref name="ghc-heap-obj">[https://ghc.haskell.org/trac/ghc/wiki/Commentary/Rts/Storage/HeapObjects GHC - Heap objects]{{en}}</ref>

; ''Unboxed'': Un tipus és ''Unboxed'' (no "encapsulat en memòria dinàmica") si i només si la seva representació no és un punter.
; ''Lifted'': El tipus Lifted és el dels objectes de codi, quin resultat s'avalua per encaix, on, després de provar tots els encaixos, el valor de fons (⊥)<ref name="bottom"/> atura el programa si els encaixos no són exhaustius o bé s'hi produeix un bucle.<ref name="ghc-heap-obj"/> Es diu que el tipus del resultat dels objectes de codi incorpora aquest valor (⊥).
::* Les tuples no encapsulades com a retorn ''(# ... #)'' són ''unlifted''. Els tipus unlifted a la dreta d'una fletxa o assignació, són augmentats a Lifted implícitament.<ref name="ghc-heap-obj"/>
::* Només els tipus encapsulats (representats per un punter, ang:''boxed'') poden ser ''Lifted''. Però hi ha tipus encapsulats ''Unlifted'' com ara ''ByteArray#''.<ref name="ghc-heap-obj"/>
; ''Data'': Un tipus declarat amb la clàusula ''data''.
; ''Algebraic'': És un tipus amb un o més constructors, encaixable amb un ''case'', tant si s'ha creat amb ''data'' com amb ''newtype''.
; ''Primitiu'': Un tipus és primitiu si no està definit mitjançant el Haskell.

=== kind ===
Vegeu les refs.<ref name="kind">[http://www.haskell.org/haskellwiki/Kind HaskellWiki - Kind] {{en}}</ref><ref>[https://diogocastro.com/blog/2018/10/17/haskells-kind-system-a-primer/#types-and-kinds Haskell's kind system - a primer]</ref>

El ''kind'' (cat:mena) és una mena de ''tipus'' per als constructors de tipus, o, dit d'altra manera, un tipus d'ordre superior.

Defineix un conjunt de tipus,
* o bé amb una màscara que descriu l'[[aritat]] del tipus, i la dels components de tipus d'ordre superior entre parèntesis (ex.: * -> (* -> *) -> *),
:: El Kind té dos constructors '*' i (->)
* o bé partint d'un conjunt de restriccions de context (''[[#kind Constraint|kind Constraint]]'').
* Afegit posteriorment, el kind '#'. '*' és el ''kind'' dels tipus [[#Classificacions dels tipus|Lifted]] (objectes de codi) mentre que '#' ho és dels tipus [[#Classificacions dels tipus|Unlifted]] (ex.:''ByteArray#'').<ref>[https://ghc.haskell.org/trac/ghc/wiki/UnliftedDataTypes Unlifted Data Types]{{en}}</ref><ref>[https://ghc.haskell.org/trac/ghc/wiki/Commentary/Compiler/TypeType El tipus Type i els seus col·legues]{{en}}</ref>

{| class=wikitable
|-
! expressió de tipus !! ''kind'' !! comentari
|-
| Int || * || tipus d'aritat 0 (no és funció de cap paràmetre de tipus)
|-
| Maybe || * -> * || constructor de tipus que és funció d'un component (Maybe a) (funció de tipus d'aritat 1)
|-
| Maybe Bool || * || aplicant el constructor ''Maybe'' a un tipus, tenim un tipus d'aritat 0
|-
| (Int -> Double) -> Int -> Double || (* -> *) -> * -> * || quan un dels paràmetres és una funció, s'expressa entre parèntesis
|}

Són d'aplicació a les [[#Famílies de tipus]], l'especificació de ''kind'' pot indicar l'aritat de la família i, en conseqüència, els paràmetres addicionals que requereixen les instàncies.

Vegeu també "GHC - Quantificació de ''kind'' explícita".<ref>[http://haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#kinding Explicitly-kinded quantification] {{Webarchive|url=https://web.archive.org/web/20120130224958/http://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#kinding |date=2012-01-30}}{{en}}</ref> Requereix extensió {-# LANGUAGE KindSignatures #-}

; sort

Els Kind tenen una categoria que els classifica (tipus a nivell de ''kind'') que s'anomena ''sort''. Només hi ha un valor de sort que és ''BOX''.<ref name="dt-promotion">[https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#datatype-promotion Promoció de tipus] {{Webarchive|url=https://web.archive.org/web/20180821174039/http://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#datatype-promotion |date=2018-08-21 }}{{en}}</ref>

* Promoció de tipus: GHC facilita automàticament la promoció de tipus a Kinds i de constructors de tipus a constructors de Kind, amb l'extensió DataKinds.<ref name="dt-promotion"/>

<syntaxhighlight lang="haskell">
data Nat = Zero | Succ Nat

-- és promogut a:

Nat :: BOX
Zero :: Nat
Succ :: Nat -> Nat
</syntaxhighlight>

Per indicar en una expressió que ens referim a tipus i constructors de llistes i tuples promoguts a ''kinds'', cal prefixar-ne els identificadors amb un apòstrof.<ref name="dt-promotion"/>

<syntaxhighlight lang="haskell">
{-# LANGUAGE DataKinds, PolyKinds, KindSignatures, GADTs, TypeOperators #-}
data Nat = Zero | Succ Nat

data Vec :: * -> Nat -> * where
 Nil :: Vec a Zero
 Cons :: a -> Vec a n -> Vec a (Succ n)

data HList :: [*] -> * where
 HNil :: HList '[]
 HCons :: a -> HList t -> HList (a ': t)

data Tuple :: (*,*) -> * where
 Tuple :: a -> b -> Tuple '(a,b)
</syntaxhighlight>

==== ''kind'' Constraint ====
''kind'' que defineix el conjunt de tipus per les restriccions de context que han de complir.

Hi ha 3 menes de restriccions:<ref>{{Ref-web |url=https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/constraint-kind.html |títol=El ''kind'' Constraint |consulta=2015-12-07 |arxiuurl=https://web.archive.org/web/20150905183541/https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/constraint-kind.html |arxiudata=2015-09-05}}</ref>
* requeriment de visibilitat d'instància de classe en el context d'ús, com a (Show a)
* [[#àmbit dinàmic - paràmetres implícits|paràmetres implícits]], com a (?x::Int) -- cal l'extensió ImplicitParams
* requeriment d'unificació de tipus, com a (a ~ T b)<ref>[http://www.haskell.org/ghc/docs/latest/html/users_guide/type-families.html#equality-constraints Equality constraints] {{Webarchive|url=https://web.archive.org/web/20120804093315/http://www.haskell.org/ghc/docs/latest/html/users_guide/type-families.html#equality-constraints |date=2012-08-04}}{{en}}</ref> -- amb l'extensió TypeFamilies o GADTs
A partir de GHC 7.4, una especificació de restriccions de context adopta la categoria de ''kind Constraint'' i se li pot assignar un àlies.<ref>[http://blog.omega-prime.co.uk/?p=127 Constraint Kinds for GHC]{{en}}</ref>

<syntaxhighlight lang="haskell">
{- LANGUAGE ConstraintKinds -}

-- (Show a, Read a) :: Constraint -- requeriment de visibilitat d'instància de classe en el context d'ús
-- (?x::Int) :: Constraint -- arguments implícits (requeriment de visibilitat de l'implícit en el punt de crida)
-- (a ~ T b) :: Constraint -- restricció d'unificació de tipus

-- els podem assignar un àlies
type Textual a = (Show a, Read a)

viaString :: Textual a => a -> a
viaString = read. show

--- ghci

Prelude> :set -XExplicitForAll
Prelude> :kind forall t.(Show t, Read t)
forall t.(Show t, Read t) :: Constraint

Prelude> :set -XConstraintKinds
Prelude> type Textual t = (Show t, Read t)
Prelude> :kind forall t. Textual t
forall t. Textual t :: Constraint</syntaxhighlight>

=== Famílies de tipus ===
Són una generalització dels ''[[#Genèrics amb tipus associats en classes mono-paràmetre|tipus associats a les classes]]'',<ref>{{Ref-web |url=http://www.haskell.org/ghc/docs/latest/html/users_guide/type-families.html |títol=GHC - Famílies de tipus |consulta=2011-12-20 |arxiuurl=https://web.archive.org/web/20120804093315/http://www.haskell.org/ghc/docs/latest/html/users_guide/type-families.html |arxiudata=2012-08-04}}</ref> i permeten la definició, a nivell de mòdul, dels tipus dependents d'un altre tipus, declarat com a ''índex'' de la família, que en el cas dels tipus associats correspondria al tipus índex de la classe.

L'especificació equivalent a la signatura del tipus associat duu el qualificatiu ''family'' (com ''<code>data family</code>'' o bé ''<code>type family</code>'') mentre que la corresponent a les instàncies duen el qualificatiu ''instance'' com es detalla tot seguit.

==== Famílies de tipus estructurals ====
Permeten una diversificació de l'estructura, així com les ''classes'' admeten una diversificació del comportament, en instàncies per tipus.

Designen un conjunt de tipus mitjançant un constructor de família, i una variable anomenada l'índex i, opcionalment, una especificació de ''[[#kind]]'', l'ordre del tipus.

Vegeu ref.<ref>[http://www.haskell.org/haskellwiki/GHC/Type_families HaskellWiki - Type Families]{{en}}</ref> Requereix l'extensió de llenguatge ''TypeFamilies''.
<syntaxhighlight lang="haskell">
{-# LANGUAGE TypeFamilies, FlexibleInstances #-}

-- família de llistes
data family XList t -- t és l'índex de la família, de manera similar a les classes

-- instància de la família de tipus XList per al tipus Char
data instance XList Char = XNil | XCons Char (XList Char) deriving (Eq, Show)

-- instància de la família de tipus XList per al tipus () -- Unit (buit)
 -- com que el tipus () té un únic valor (), estalviem recursos
 -- especificant directa i únicament la llargada de la llista de ()
data instance XList () = XListUnit Int deriving (Eq, Show)

-- -------------- ús, requereix extensió FlexibleInstances

class TéLlargada t where
 llargada :: t -> Int

instance TéLlargada (XList ()) where
 llargada (XListUnit len) = len

instance TéLlargada (XList Char) where
 llargada XNil = 0
 llargada (XCons x xs) = 1 + llargada xs

laMevaLlistaDeBuits = XListUnit 10

main = print $ llargada laMevaLlistaDeBuits

</syntaxhighlight>

* L'especificació de ''kind'' permet conèixer els paràmetres de tipus que cal afegir-hi:

<syntaxhighlight lang="haskell">
-- família de diccionaris per tipus de clau
data family Dicc k :: * -> *

-- el ''kind'' :: * -> * indica funció de tipus d'aritat 1,
-- o sigui que la instància requereix un altre paràmetre de tipus, el de l'element

-- instància per a claus de tipus String
data instance Dicc String e = DiccStringNil | DiccStringCons (String, e) (Dicc String e)

-- instància per a claus de tipus Unit (un únic valor de clau
 -- i, per tant, un sol element possible)
data instance Dicc () e = DiccUnitNil | DiccUnitSimple e
</syntaxhighlight>

==== Famílies de sinònims de tipus (funcions de tipus) ====
Les famílies de tipus especificades com a àlies (clàusula ''type family'') defineixen funcions de tipus, quines correspondències (origen -&gt; imatge) es concreten en instàncies de la família de tipus per casos d'encaix.

Exemple:
:Les col·leccions monomòrfiques (el seu tipus és d'aritat 0, kind '*') com ara Text, ByteString o bé IntSet no poden implementar la classe de tipus Functor ja que aquesta requereix que estiguin parametritzades pel tipus de l'element (''kind'' * -&gt; *).

:Això els impedeix d'implementar les classes derivades de Functor, per ex.: ''Foldable'' (per la reducció) i ''Traversable'' (per l'avaluació seqüencial dels elements si són efectes, o de les imatges d'un mapeig amb una funció d'efectes) que en depenen.

:El paquet ''mono-traversable'' hi aporta una solució basada en famílies de sinònims de tipus, que permet un tractament universal de les col·leccions, siguin o no monomòrfiques.<ref>[https://hackage.haskell.org/package/mono-traversable/docs/Data-MonoTraversable.html mòdul Data.MonoTraversable]{{en}}</ref>

<syntaxhighlight lang="haskell">
{-# LANGUAGE TypeFamilies #-}
type family Element t -- família de tipus Element de 't'
type instance Element Text = Char -- instància de la família Element per al tipus 'Text'
type instance Element IntSet = Int
type instance Element ByteString = Word8
type instance Element [a] = a
type instance Element (Set a) = a
...

class MonoFunctor t where
 omap :: (Element t -> Element t) -> t -> t 

instance MonoFunctor Text where
 omap = Text.map
...

-- també defineix les classes MonoFoldable i MonoTraversable
-- així com MonoFoldableEq (defineix pertinença (''elem'') com a plegat, per a contenidors amb elements amb igualtat)
--, MonoFoldableOrd (defineix màxim i mínim per a contenidors amb elements ordenables)
--, MonoFoldableMonoid (defineix concatMap per a contenidors amb elements que implementen Monoide)
-- ...
</syntaxhighlight>

* Els tipus associats a les classes no són altra cosa que famílies de tipus indexades pels paràmetres de la classe dels quals depenguin

<syntaxhighlight lang="haskell">
{-# LANGUAGE TypeFamilies #-}

class Pila t where
 type Element t -- tipus associat: família de tipus indexada al param. de la classe
 buida :: t
 apila :: Element t -> t -> t
 ésBuida :: t -> Bool
 daltIDesapila :: t -> Maybe (Element t, t) -- resultat opcional per si la Pila era buida

-- instancia una Pila basada en llistes
instance Pila [a] where
 type Element [a] = a -- instància de la família de tipus
 buida = [] -- Nil
 apila = (:) -- Cons
 ésBuida = null
 daltIDesapila (x : resta) = Just (x, resta)
 daltIDesapila [] = Nothing -- evitem l'error "daltIDesapila: la llista era buida!"
</syntaxhighlight>

===== Famílies de sinònims de tipus tancades =====
Una família de sinònims de tipus amb un conjunt tancat (no ampliable) d'instàncies es pot expressar incloent les instàncies de la família en una clàusula ''where''.<ref>[https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/type-families.html#closed-type-families Closed type families] {{Webarchive|url=https://web.archive.org/web/20160314053108/https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/type-families.html#closed-type-families |date=2016-03-14 }}{{en}}</ref>
<syntaxhighlight lang="haskell">
type family F a where
 F Int = Double
 F Bool = Char
 F a = String
</syntaxhighlight>

=== tipus dependents de valors ===
Vegeu ref.<ref>[https://www.fpcomplete.com/user/konn/prove-your-haskell-for-great-safety/dependent-types-in-haskell Dependent Types in Haskell] {{Webarchive|url=https://web.archive.org/web/20151222163407/https://www.fpcomplete.com/user/konn/prove-your-haskell-for-great-safety/dependent-types-in-haskell |date=2015-12-22}}{{en}}</ref> Exemple a [[Compilador Haskell de Glasgow#Tipus dependents de valors]]

== Exemples ==
=== Encapsulament estil O.O. ===
(Aquest enfocament ha quedat superat pel tractament d'estructures complexes amb ''[[#Lents (Referències funcionals) - Consulta i manipulació de parts d'estructures complexes|lents (referències funcionals)]]'').

Cercant una aproximació funcional (amb immutabilitat) a l'encapsulament de la [[orientació a objectes]] i simulació d'herència de propietats del component:

* Exemple. Els tipus d'objecte TPunt2D i TPunt3D (en terminologia Java ''classes'' (d'objectes) sense operacions), implementen (els en terminologia Java ''interfaces''), el primer IFun2D i el segon IFun3D que requereix també IFun2D.

Un mòdul per cada tipus, encapsulant dades i operacions.

* Es pot evitar duplicar les implementacions d'alguns mètodes desacoblant-los de l'estructura, definint classes de propietats (mètodes ''getters/setters''), i classes basades en aquestes, implementant els mètodes per defecte a la classe en un mòdul a banda, i sobreescrivint-los quan convingui a la instanciació invalidant el mètode per defecte. (ang.:''overriding'')

<div style="background-color:#f4f6fe; border-style:solid; border-width:1px;">
<syntaxhighlight lang="haskell">
-- fitxer ClassesPropietats.hs -- (getters/setters)
module ClassesPropietats (PropXY(..), PropZ(..)) where

class PropXY t where
 getXY :: t -> (Int, Int)
 setXY :: Int -> Int -> t -> t

class PropZ t where
 getZ :: t -> Int
 setZ :: Int -> t -> t
</syntaxhighlight>
<syntaxhighlight lang="haskell">
{-# LANGUAGE FlexibleInstances, UndecidableInstances #-}
-----------------------------------------------------------------------
-- Interfícies de funcionalitat
-- fitxer ClassesBasadesEnPropietats.hs 
module ClassesBasadesEnPropietats (IFun2D(..), IFun3D(..)) where

import ClassesPropietats

-- funcionalitat 2D

class (PropXY t) => IFun2D t where
 desplaça2D :: Int -> Int -> t -> t

instance (PropXY t) => IFun2D t where -- instanciació genèrica (ext. UndecidableInstances)
 desplaça2D dx dy punt = setXY (x+dx) (y+dy) punt
 where
 (x,y) = getXY punt

-- funcionalitat 3D

class (IFun2D t, PropZ t) => IFun3D t where
 desplaça3D :: Int -> Int -> Int -> t -> t

instance (IFun2D t, PropZ t) => IFun3D t where -- instanciació genèrica (ext. UndecidableInstances)
 desplaça3D dx dy dz punt = setZ (z+dz) $ desplaça2D dx dy punt
 where
 z = getZ punt
</syntaxhighlight>
<syntaxhighlight lang="haskell">
-- fitxer Punt2D.hs per al tipus TPunt2D
{-# LANGUAGE NamedFieldPuns #-} -- sintaxi de literals de registres simplificada
module Punt2D (
 TPunt2D, -- tipus opac (no exportem els constructors)
 nouPunt2D, -- el separador coma al final s'accepta
) where

import ClassesPropietats
import ClassesBasadesEnPropietats

data TPunt2D = Punt2D { x,y ::Int} deriving (Eq, Show)

-- generadors
nouPunt2D :: Int -> Int -> TPunt2D
nouPunt2D = Punt2D -- definició tàcita (estalviant arguments)

-- propietats
instance PropXY TPunt2D where
 getXY Punt2D {x,y} = (x, y) -- el literal dels camps lliga amb més precedència que l'aplicació (no cal agrupar-lo amb el constructor.
 -- {x, y} a l'encaix, equival a {x = x, y = y} per l'extensió NamedFieldPuns
 setXY x y punt = punt { x, y} -- {x, y} al cos equival a {x = x, y = y} per l'extensió NamedFieldPuns
</syntaxhighlight>
<syntaxhighlight lang="haskell">
-- fitxer Punt3D.hs per al tipus TPunt3D
{-# LANGUAGE NamedFieldPuns #-} -- sintaxi de literals de registres simplificada
module Punt3D (TPunt3D {- tipus opac -}, nouPunt3D) where

import ClassesPropietats
import ClassesBasadesEnPropietats

data TPunt3D = Punt3D { x, y, z :: Int} deriving (Eq, Show)

-- generador
nouPunt3D :: Int -> Int -> Int -> TPunt3D
nouPunt3D = Punt3D 

-- propietats
instance PropXY TPunt3D where
 getXY Punt3D {x,y} = (x, y)
 setXY x y punt = punt { x, y} -- {x, y} al cos equival a {x = x, y = y} per l'extensió NamedFieldPuns

instance PropZ TPunt3D where
 getZ Punt3D {z} = z -- a l'encaix {z} equival a {z = z}
 setZ z punt = punt {z} -- {z} equival a {z = z}
</syntaxhighlight>
</div>
prova:
<div style="background-color:#f4f6fe; border-style:solid; border-width:1px;">
<syntaxhighlight lang="haskell">
-- fitxer Main.hs
module Main where

import ClassesPropietats
import ClassesBasadesEnPropietats
import Punt2D
import Punt3D
import Data.Function ((&)) -- (&) = flip ($) -- infixl 1 -- desde GHC 7.10.1

p2D = nouPunt2D 1 2
 & setXY 3 4
 & desplaça2D 1 1

p3D = nouPunt3D 1 2 3
 & desplaça2D 2 2
 & desplaça3D 1 1 1

main = do
 putStrLn $ "p2D: " ++ show p2D
 putStrLn $ "p3D: " ++ show p3D
</syntaxhighlight></div>
execució
 runhaskell Main

* Amb la prevista incorporació del polimorfisme de "registres amb camps específics" com a requeriment de context, les classes basades en accessors de camps, es derivaran automàticament.<ref>[http://www.well-typed.com/blog/2015/03/overloadedrecordfields-revived/#part-2-polymorphism-over-record-fields Polymorphism over record fields]{{en}}</ref><ref>[https://ghc.haskell.org/trac/ghc/wiki/Records/OverloadedRecordFields/MagicClasses OverloadedRecordFields - MagicClasses]{{en}}</ref>

=== Col·leccions amb components heterogenis - Emulació del despatx dels mètodes virtuals de la [[Orientació a objectes|O.O.]] ===
Vegeu ref.<ref name="tipus_existencial"/> El [[#Tipus existencial]] dona solució al tractament de col·leccions heterogènies incorporant els elements heterogenis com a components amb quantificació existencial (requerint que instancïin les classes que aportin la operatòria requerida), sense trencar l'homogeneïtat de les col·leccions.

<div style="background-color:#f4f6fe; border-style:solid; border-width:1px;">
<syntaxhighlight lang="haskell">
{-# LANGUAGE ExistentialQuantification #-}
module Forma (TForma(..), CForma(..)) where

import Text.Printf
import Data.Function ((&))

-- Farem una col·lecció de formes diverses que implementin CForma per obtenir-ne perímetre i àrea

class CForma t where
 perímetre :: t -> Double
 àrea :: t -> Double
 nom :: t -> String

-- tipus existencial (designa un cjt. de tipus amb característiques pròpies)
-- característica: incorpora un component d'aquells tipus ''t'' que implementin CForma

data TForma = forall t. CForma t => Forma t

-- implementació del tipus existencial amb
-- despatx dels mètodes propis als mètodes del component

instance CForma TForma where
 perímetre (Forma forma) = perímetre forma
 àrea (Forma forma) = àrea forma
 nom (Forma forma) = nom forma

instance Show TForma where
 show forma = printf format (forma & nom) (forma & perímetre) (forma & àrea)
 where format = "(Forma %s: perímetre %.2f, àrea %.2f)\n" 
</syntaxhighlight>

<syntaxhighlight lang="haskell">
module Cercle (TCercle, cercleNou) where

import Forma (CForma(..))

type TRadi = Double

data TCercle = Cercle TRadi deriving (Eq, Show)

cercleNou :: TRadi -> Maybe TCercle
cercleNou r
 | r > 0 = Just (Cercle r)
 | otherwise = Nothing

instance CForma TCercle where
 perímetre (Cercle r) = 2 * pi * r
 àrea (Cercle r) = pi * r ^ 2
 nom _ = "Cercle"
</syntaxhighlight>

<syntaxhighlight lang="haskell">
module Rectangle (TRectangle, rectangleNou) where

import Forma (CForma(..))

type TCostat = Double

data TRectangle = Rectangle TCostat TCostat deriving (Eq, Show)

rectangleNou :: TCostat -> TCostat -> Maybe TRectangle
rectangleNou x y
 | x > 0 && y > 0 = Just $ Rectangle x y
 | otherwise = Nothing

instance CForma TRectangle where
 perímetre (Rectangle x y) = 2 * (x + y)
 àrea (Rectangle x y) = x * y
 nom _ = "Rectangle"
</syntaxhighlight>
<syntaxhighlight lang="haskell">
module Main where

import Forma (TForma(..)) 
import Cercle (cercleNou)
import Rectangle (rectangleNou)

formes :: [Maybe TForma]
formes = [fmap Forma (cercleNou 2.4),
 fmap Forma (rectangleNou 3.1 4.4),
 fmap Forma (cercleNou (-2))]

main = print formes
</syntaxhighlight></div>

 runhaskell Main.hs

dona la següent sortida:

[Just (Forma Cercle: perímetre 15.08, àrea 18.10)<br/>
,Just (Forma Rectangle: perímetre 15.00, àrea 13.64)<br/>
,Nothing]

=== Entrada / Sortida amb descriptor ''regionalitzat'' ===
* Vegeu [http://hackage.haskell.org/package/base/docs/System-IO.html#v%3AwithFile withFile] (fitxers de text) / withBinaryFile (de System.IO) basat en la clàusula de gestió de recursos ''bracket'' amb tancament automàtic en cas d'excepció.
<syntaxhighlight lang="haskell">
-- obre el fitxer, proporciona al tercer param. el 'Handle' per a l'acció i tanca el fitxer en havent acabat l'acció o en cas d'excepció.
withFile, withBinaryFile :: FilePath -> IOMode -> (Handle -> IO r) -> IO r 

-- per al cas de codi espars (disgregat)
openFile, openBinaryFile :: FilePath -> IOMode -> IO Handle -- obre el fitxer i proporciona el recurs
hClose :: Handle -> IO () -- tanca el recurs

-- withFile es defineix mitjançant bracket
withFile nomDelFitxer mode acció = bracket (openFile nomDelFitxer mode) hClose acció

-- o per eta-reducció, obtenint la versió tàcita (que estalvia arguments)
withFile nomDelFitxer mode = bracket (openFile nomDelFitxer mode) hClose
</syntaxhighlight>

Exemple:
<div style="background-color:#f4f6fe; border-style:solid; border-width:1px;">
<syntaxhighlight lang="haskell">
 -- Fitxer prova.hs (decodifica nombres i n'imprimeix el factorial)
 module Main(main) where

 import qualified Control.Monad as Monad
 import qualified Numeric
 import Control.Exception (try)
 import Text.Printf
 import System.IO
 import System(getArgs)

 llegirSencerDecimal :: String -> Maybe (Int, String)
 llegirSencerDecimal text =
 case Numeric.readDec text of -- retorna llista d'interpretacions sintàctiques
 [(n_descodificat, resta)] -> Just (n_descodificat, resta) -- una sola interpretació
 [] -> Nothing -- cap ni una => no hi ha dígits
 _ -> Nothing -- diverses interpretacions => entrada ambigua

 -- Integer: precisió arbitrària, Int: precisió s/. paraula de la màquina

 fact :: Int -> Integer
 fact 0 = 1
 fact n | n > 0 = fact_rf 1 n

 where fact_rf :: Integer -> Int -> Integer
 fact_rf acum n | n > 1 = fact_rf (acum * toInteger n) (n-1)
 | n == 1 = acum

 imprimeix_fact n resta_de_linia = do
 printf "n=%d => fact n =%d" n (fact n) -- escriu n, (fact n)
 case resta_de_linia of
 [] -> putStrLn "" -- escriu salt de línia
 (sep:_) | sep `elem` "," -> putStrLn " (seguit de separador)"
 _ -> putStrLn " (hi ha text enganxat al nombre)"

 analitza_linia_i_tracta_nombre :: Handle -> IO (Either IOError ())
 analitza_linia_i_tracta_nombre h1 = try -- retorna excepció en un tipus Either per controlar-la més tard
 (do
 línia <- hGetLine h1
 case llegirSencerDecimal línia of
 Just (n, resta) -> imprimeix_fact (abs n) resta
 Nothing -> putStrLn "error de descodificació o nombre inexistent"
)

 processa_linia_fitxer:: Handle -> IO ()
 processa_linia_fitxer h1 = do
 resultat <- analitza_linia_i_tracta_nombre h1
 case resultat of -- controla excepció al resultat de tipus Either IOError ()
 Left excepcio -> do
 -- tasques de finalització
 -- hClose h1 -- tanca fitxer (amb withFile ja no caldrà)
 ioError excepcio -- dispara excepció
 Right _valor -> return ()

 processa_nom_fitxer nom = catch
 (do
 withFile nom ReadMode $ \handle ->
 -- llaç fins que es dispari una excepció per fi de fitxer
 Monad.forever $ processa_linia_fitxer handle
)
 (\excep -> putStrLn $ show excep
)

 main = do
 args <- getArgs
 case args of
 [] -> print "afegiu nom_del_fitxer\n"
 -- mapM_ mapeja seqüencialment la funció efecte als arguments, descartant resultats
 _ -> Monad.mapM_ processa_nom_fitxer args

 -- fi de prova.hs
</syntaxhighlight></div>

 -- fitxer nums.txt
 0
 1ABC
 2,
 10
 15—fi de nums.txt

 runhaskell prova.hs nums.txt
produeix la sortida següent:
 n=0 => fact n =1
 n=1 => fact n =1 (hi ha text enganxat al nombre)
 n=2 => fact n =2 (seguit de separador)
 n=10 => fact n =3628800
 n=15 => fact n =1307674368000
 nums.txt: hGetLine: end of file

=== Expressions regulars ===
Vegeu-ho a [[Compilador Haskell de Glasgow#Expressions regulars]]

=== Lents de Van Laarhoven -- consulta i manipulació de parts d'estructures complexes ===
Vegeu-ho a [[Compilador Haskell de Glasgow#Òptica funcional -- consulta i manipulació de parts d'estructures complexes|GHC]]

=== Exemples de Fletxes (seqüenciació d'efectes basada en l'encadenament de funcions amb efectes) ===
==== Ent./Sort. amb fletxes de Kleisli (mònades elevades a fletxes) ====
Vegeu exemple a [[Fletxa (programació funcional)#Ent./Sort. amb fletxes de Kleisli (mònades elevades a fletxes)]]

==== Extreure informació d'un document XML ====
Vegeu exemple a [[Fletxa (programació funcional)#Exemple - Extreure informació d'un document XML|Fletxa (programació funcional)]]

=== Plantilles per a expressions, patrons, tipus i declaracions ===
Vegeu [[Compilador Haskell de Glasgow#Quasi-Quotations (Plantilles)]]

=== Concurrència ===
==== Concurrència simple amb MVars - Productor-consumidor ====
Vegeu-ho a [[Haskell concurrent#Concurrència simple amb MVars - Productor-consumidor|Haskell concurrent]]

==== Canals amb cues d'entrada (Chan) - Client-servidor ====
Vegeu exemple a [[Haskell concurrent#Client-servidor - Canals amb cues d'entrada (Chan)|Haskell concurrent]]

==== Concurrència condicionada amb variables transaccionals (TVar) - Mònada STM (transaccions de memòria per programari) ====
Vegeu exemple a [[Haskell concurrent#Concurrència condicionada amb variables transaccionals (TVar) - Mònada STM (transaccions de memòria per programari)|Haskell concurrent]]

=== Paral·lelisme ===
Vegeu [[Compilador Haskell de Glasgow#Paral·lelisme de tasques - Compilació per a processadors multicor]]

==== Paral·lelisme de tasques - Compilació per a processadors multicor ====
Només a [[Compilador Haskell de Glasgow|GHC]]. Vegeu [[Compilador Haskell de Glasgow#Paral·lelisme de tasques - Compilació per a processadors multicor]].

==== Amb ''Estratègies'' ====
Vegeu: [[Haskell concurrent#Estratègies|Estratègies]] i també [[Haskell concurrent#Reducció en paral·lel mitjançant estratègies|Reducció en paral·lel mitjançant estratègies]]

==== Amb la mònada Par ====
Vegeu [[Haskell concurrent#Futuribles -- Encadenament de càlculs asíncrons - la mònada Par]]

==== Paralel·lisme d'accions IO - El ''functor aplicatiu'' Concurrently ====
Vegeu [[Haskell concurrent#Operacions d'Entrada/Sortida asíncrones i simultànies]]

==== Amb paral·lelisme de dades DPH ====
Vegeu [[Compilador Haskell de Glasgow#Data Parallel Haskell|QuickSort amb Data Parallel Haskell]]

==== Ús de les instruccions [[SIMD]] sobre dades vectoritzades ====
Vegeu [[Compilador Haskell de Glasgow#SIMD - Single Instruction, Multiple Data - Ús de les instruccions de CPU vectoritzades|SIMD - Single Instruction, Multiple Data]]

==== Paral·lelisme a GPUs ([[GPGPU]]) o equivalent (via [[OpenCL]]) sobre CPUs multicor ====
Vegeu [[Compilador Haskell de Glasgow#Paral·lelisme GPGPU|Paral·lelisme GPGPU]]

== Relacionat ==
* [[Haskell concurrent]]
* [[Mònada (programació funcional)]]
* [[Fletxa (programació funcional)]]
* [[Compilador Haskell de Glasgow]]

== Referències ==
{{referències}}

{{Llenguatges de programació}}
{{Autoritat}}

{{ORDENA:Haskell, Caracteristiques}}
[[Categoria:Llenguatge de programació Haskell| ]]