Haskell

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

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

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

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

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

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

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

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

Haskell 2011 en preparació.

Crítiques:

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

En realitat es pot aconseguir facilitat en l'especialització de comportament, desacoblant la funcionalitat de l'estructura amb propietats (getters/setters) com es descriu a l'Encapsulament estil O.O..

Problemàtiques:

Vegeu secció #Problemàtiques.

Programa Hola Món

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

Per a Windows i altres podem descarregar-lo d'aquí. <source lang="Haskell"> -- fitxer hola-mon.hs main = putStrLn "Hola Món" -- fi de fitxer </source>

En un sistema Linux podem tenir GHC i altres compiladors de Haskell i runhaskell es pot configurar per executar una o altra alternativa amb un selector d'alternatives de sistema (normalment apunta a runghc o runghc6). A MSWindows podem usar indistintament runhaskell o runghc.

Execució per GHC sense compilació prèvia <source lang="Haskell">

runhaskell hola-mon.hs

Hola Món

</source>

Amb l'intèrpret GHCi del mateix paquet. Denominació ghci o ghci6 segons instal·lació.

A l'intèrpret no serveix la mateixa sintaxi del nivell declaratiu dels programes, sinó només la dels blocs d'operacions d'entrada / sortida, que corresponen al tipus Mònada, a banda de les comandes específiques que comencen pel caràcter dos-punts i les expressions a avaluar.

Això canvia a partir de GHC 7.4.1 que admet tot tipus de declaracions a l'intèrpret GHCi. <source lang="Haskell"> >ghci GHCi, version 6.10.1: http://www.haskell.org/ghc/ :? for help Loading package ghc-prim ... linking ... done. Loading package integer ... linking ... done. Loading package base ... linking ... done. Prelude> putStrLn "Hola Mon" Hola Mon Prelude> let str = "abc" Prelude> :type str str :: [Char] Prelude> str "abc" Prelude> let f x y = x + y Prelude> :type f f :: Num a => a -> a -> a Prelude> </source>

Avaluador en-línia, a l'intèrpret d'expressions funcionals tryhaskell.org, eviteu-hi operacions de sortida (print, putStr, etc ..) i de tipus mònada. <source lang="Haskell">

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

</source>

Cercadors

• Hayoo: on es pot consultar quines biblioteques exporten un identificador, a les biblioteques del rebost oficial (Hackage).

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

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

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

Característiques

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 paraŀlelisme (procés en paraŀlel).

<source lang="haskell"> -- codi pur. L'ordre de les operacions és irrellevant i per tant es podrien paraŀlelitzar f x y = (x * 2) + (y * 4)

-- codi impur (modif. de l'entorn o de l'estat). L'ordre és rellevant acció :: IO Int acció = do

  putStrLn "entreu nombre enter"
  hFlush stdout
  str <- getLine
  let x = read str
  let y = x * 2
  return y

</source>

separació d'especificació i execució

El codi d'un mòdul no s'executa en l'ordre d'especificació, sino 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 cas de (b * c + a) primer s'avalua el (+) i després el (*), al revés dels llenguatges estrictes. 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—al menys s'avalua si tindrà èxit--, i un analitzador d' estrictesa determina quan un terme serà sempre requerit en les expressions, i converteix la seva avaluació en primerenca (ang.: eager evaluation) . El programador també pot forçar l'estrictesa com s'explica més avall.

Thunk és el nom de la càpsula de codi corresponent a cada expressió pendent d'avaluar.

separació d'estructura i operacions (comparat amb la O.O.)

Haskell. a diferència dels lleng. amb orientació a objectes separa estructures de dades i comportament.

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

Les operacions sobre el tipus poden agrupar-se en "classes de tipus" que els tipus han d'implementar (amb la clàusula instance)

<source lang="haskell">

class CForma t where -- una classe defineix la signatura (tipus de params i resultat)

               -- d'un grup d'operacions. 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 dóna un àlies a una expressió de tipus

data TRectangle = Rectangle TCostat TCostat -- tipus de dada amb constructor seguit de components

instance CForma TRectangle where -- TRectangle implementa CForma definint-ne les operacions

perímetre (Rectangle x y) = 2 * (x + y)
àrea (Rectangle x y) = x * y

</source> <source lang="haskell"> {-# LANGUAGE NamedFieldPuns #-} -- sintaxi d'encaix de registres simplificada

data TPersona = Persona {nom::String, edat::Int} deriving (Eq, Show)

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

class (CPersona t) => CProgramador t where

 aprendre_llenguatge :: TLlenguatge -> t -> t

-- fem que el tipus TPersona implementi la signatura de la classe de tipus CPersona -- i n'esdevingui una instància

instance CPersona TPersona where

 fer_anys p @ (Persona {edat}) =    -- es llegeix: p com Persona quina edat és edat
                      p {edat = edat +1} -- el primer és el nom del camp, el segon és l'argument.

instance CPersona TProgramador where

 fer_anys prog @ (Programador { persona}) =
                    prog { persona = fer_anys persona}

instance CProgramador TProgramador where

 aprendre_llenguatge nou_llenguatge prog @ (Programador {llenguatges}) =
                         if not (nou_llenguatge `elem` llenguatges)
                           then prog {llenguatges = nou_llenguatge : llenguatges}
                           else prog

-- valors

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

joan_programador = Programador { persona = joan_persona

                              , llenguatges = [Lleng_FORTRAN, Lleng_JAVA]}

fer_més_savi = fer_anys . (aprendre_llenguatge Lleng_HASKELL)

joan_més_savi = fer_més_savi joan_programador

main = print joan_més_savi </source>

Per ser un llenguatge d'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 composar, partint dels tipus primitius i enumeracions, en tipus producte (etiquetats: els registres; anònims: les tuples) i tipus suma (unió discriminada), distingint-los amb un constructor que ens permetrà diferenciar-los en l'encaix de patrons. Vegeu #tipus algebraics.

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

Combinació aplicativa i funcional

Aplicacions parcials com a paràmetres d'ordre superior.

Vegeu també #operadors de funcions.

Composició de comportament

Les classes designen la signatura (operacions) referides a variables de tipus i no a tipus concrets (com els interface del Java). Les classes poden requerir operacions d'altres classes esmentades com a context necessari (en el Java s'esmentarien a la clàusula extends) establint la jerarquia de subtipatge de comportament. 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 un context de requeriments per a les variables de tipus, addicionals als establerts a la signatura.

Vegeu exemple

Genèrics

Els mòduls genèrics, paramètrics en tipus, d'altres llenguatges, aquí prenen la forma de classes multiparàmetre. Vegeu #Estructures TAD genèriques.

Coŀleccions heterogènies

Les llistes són de tipus homogenis. Per encabir elements de tipus divers per un tractament comú (poder-hi aplicar una mateixa operació), cal caracteritzar-los amb un tipus existencial que admeti un component de tipus divers tal que implementi la classe corresp. a la operació.

Variables

Haskell disposa de variables globals IORef's similars a les ref del ML Estàndard, i variables STRef's d'àmbit local per a actualitzacions destructives.

Per al cas de concurrència amb baldes (blocant), les variables MVar (amb monitor) que es buiden en consultar-les, ofereixen una triple funcionalitat de variables amb accés sincronitzat, bústia d'un sol element i semàfor binari. Per al cas de cues, Chan i BoundedChan són cues amb blocatge.

Per a la concurrència amb memòria transaccional per programari (STM), hi ha les variables TVar, TMVar i cues TChan.

Efectes coŀlaterals

La seqüenciació (precedència temporal) de computacions amb efectes coŀlaterals es pot obtenir amb tres abstraccions diferents.

• El TAD Mònada, on (>>=) lliga el resultat d'una acció amb una funció (amb possibles efectes) sobre el resultat precedent, mentre que (>>) encadena sense lligar resultats. Els blocs do constitueixen una sintaxi específica per als encadenaments de mònades.
• El TAD Applicative, permet combinar resultats individuals d'una cadena d'accions deslligades.

<source lang="haskell"> import Control.Applicative ((<*>)) import System.IO (hFlush, stdout)

data ElMeuT = ElMeuC Int String Double deriving (Eq, Show)

-- encadenat Applicative (<*>) -- fmap combina els resultats amb una funció (aquí el constructor ElMeuC) -- quina aritat ha de coincidir amb el nombre d'accions encadenades. llegeixElMeu :: () -> IO ElMeuT llegeixElMeu () = ElMeuC `fmap` llegeixNum () <*> llegeixStr () <*> llegeixNum ()

-- encadenats Mònada (>>) a acció, i (>>=) a funció del resultat precedent

llegeixStr () = getLine llegeixNum () = getLine >>= (return . read) -- el tipus s'ajusta en aplicar la funció

monàdic () = putStrLn "Entreu valors:" >> hFlush stdout >> llegeixElMeu () >>= print

main = monàdic () </source>

• El TAD Fletxa generalitza les Mònades i tracta totes les accions com un filtre, lligant cada resultat amb l'entrada del següent. Les clàusules proc en són una sintaxi específica. (exemple: Ent./Sort. amb fletxes de Kleisli)

En un encadenament (>>=) de Mònada, la funció de la dreta proporciona accés al resultat precedent, com a paràmetre formal, a totes les accions posteriors de la cadena (bloc do).

En un encadenament de filtres Fletxa, els resultats precedents que es vulguin disponibles posteriorment, s'han d'agrupar amb el resultat de l'acció actual en tupla2 a la sortida del filtre, i fer que el filtre subsegüent tracti l'entrada com a parell.

Composició d'efectes

Per a les mònades vegeu Transformadors de mònades.

L'equivalent per a les fletxes són els Arrow Functors. Vegeu doc. "Generalizing Monads to Arrows".

Lèxic

Haskell98 admet caràcters no anglosaxons als identificadors segons la codificació Unicode. S'admeten caràcters accentuats, la ç, l'apòstrof, el caràcter ŀ (ela geminada), si el podeu composar (AltGr+L al Linux), però no el punt volat (ang:mid dot) (·).

L'apòstrof també pot formar part del nom, per a un ús amb estil matemàtic

v, v', v''

, però també com a part interna d'un identificador.

A l'intèrpret GHCi sobre Linux/Ubuntu amb LANG=ca_ES.UTF-8:

 ghci     # a l'intèrpret les assignacions 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> print alçada
 1.5
 Prelude> let opinió = 2
 Prelude> let l'internauta=123
 Prelude> let coŀlegi = "abc"   -- amb ela geminada Unicode (AltGr+l al Linux)

La pragma {-# LANGUAGE UnicodeSyntax #-} permet la substitució de determinades seqüències per caràcters Unicode equivalents.

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 com a l'exemple més avall amb el paquet utf8-string.

Grafia

començant per minúscula

les variables i les variables de tipus

començant per guió baix

comodí '_', i també variables no utilitzades en la definició però esmentades per a documentació.

començant per majúscula

els altres identificadors han de començar per majúscula

començant per ':' (caràcter dos-punts)

constructors no alfanumèrics, per exemple:

• (:) constructor cons de llistes (ex.: cap : cua)
• (:+) constructor de nombres complexos (ex.: part_real :+ part_imag)
• (:.) constructors de dimensions i d'índexos per a vectors multidimensionals (ex.matriu 3x3: (Z :. 3 :. 3)) al paquet Repa

Sintaxi

comentaris

{-
 comentari multilínia
 {- comentari niuat
 -}
-}
-- comentari fins a fi de línia

comentaris d'autodocumentació

Comentaris per a ésser extractats a un resum mitjançant el programa haddock

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

-- | comentari en línies que precedeix una declaració
--   continuació del comentari

-- invocació per generar documentació en html (opció -h):

haddock -h fitxers.hs -o docdir

{- poden sortir missatges "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'' (ext.: .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

-}

definició de blocs

De dues maneres possibles:

• mitjançant claus {} i separant les instruccions per punt-i-coma
• segons el marge esquerre de la disposició (sagnat). Els punt-i-coma al final de línia es poden estalviar.

Identificadors

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)

• variables
• constructors (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

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 aquí

Funcions binàries en posició infix en expressions

Qualsevol funció de dos operands es pot emprar en posició infix (entremig) si es posa el seu nom entre cometes revesses, fetes amb la tecla de l'accent greu seguida de la tecla espai. En anglès s'hi refereixen per backquotes

mes x y = x + y

resultat = 4 `mes` 3

operador $

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 o el retorn són funcions polimòrfiques sense declaració de tipus, com s'explica a la ref.

• ($) té la menor de les precedències dels operadors i associativitat per la dreta.

f $ x = f x                

f $ g z $ x + y === f ( g z (x + y))  -- excepte si g no té declaració de tipus

Tipus

tipus bàsics i classes que implementen

Les classes de tipus no són com les classes de C++, que són classes d'objectes, sinó com els Interface de Java

classes i clàusula deriving

La clàusula deriving demana al compilador que derivi instàncies (implementacions) de classes bàsiques a partir de les representacions internes dels tipus. Aquestes classes són:

classe	context	descripció	operacions
	(requeriments de les variables)
Eq α		Igualable	(==) (/=)
Ord α	Eq α	Ordenable	(<), (<=), ..., (compare), (max), (min)
Enum α		Enumerable	(succ: successor) (pred: predecessor) (toEnum: des de sencer) (fromEnum: cap a sencer)
Ix α	Ord α	Que pot indexar	(range), (inRange), (rangeSize), (index: índex basat en 0)
Bounded α		Acotat	(minBound: cota inferior) (maxBound: cota superior)

Classes per a representació textual:

classe	descripció	operacions
Show α	Convertible en String	(show), (showList), (showsPrec).
Read α	Convertible des de String	(readList), (readsPrec)

• el mòdul Numèric proporciona un ventall més ampli de conversions entre text i nombres.

Classes de tipus numèrics:

classe	context	descripció	operacions
Num α		Numèric (operacions comunes a sencers, racionals i reals)	(+), (-), (*), (negate), (abs), (signum), (fromInteger)
Bits α	Num α	Operacions s/. bits	(.&. :i), (.|. :o), xor, complement, shift, rotate, ...
Real α	(Num α, Ord α)	Que implementa conversió a racional	(toRational)
Integral α	(Real α, Enum α)	Que implementa divisió sencera	(div), (mod), (quot: quocient), (rem: romanent), (toInteger: a sencer de precisió il·limitada)

-- quot i div són similars però difereixen en els valors negatius (quot parteix cap a zero)
quot (-5) 3 == -1 ---- div (-5) 3 == -2

• Classes per al suport de racionals i reals.

classe	context	descripció	operacions
Fractional α	Num α	Fraccionable	(/), (recip: recíproc), (fromRational)
RealFrac α	(Real α, Fractional α)	components / info sobre fraccions	(truncate), (round), (ceiling: menor sencer superior), (floor: major sencer inferior), (properFraction: fracció pròpia)
RealFloat α	(RealFrac α, Floating α)	components / info dels reals en coma flotant	(significand: normalitzat a l'interval [0.5 .. +1) * signe, (exponent: segons l'equació: r == (significand r) * (2 ^^ (exponent r))); 1 == 0.12 * 2^^1 -- no correspon a l'exponent de la notació científica (isNaN: és No-Numèric?), (isInfinite: resultat de sobreiximent)
Floating α	Fractional α	ops. en coma flotant logaritmes i trigonometria	(**: exponenciació), (exp), (log), (sqrt), (sin), (cos), (pi), ...

Els racionals no estan definits com a classe. Són en un mòdul a banda. El tipus està parametritzat pel tipus dels components.

• (Ratio a): Ops. dels racionals: (%: constructor) (numerator), (denominator), ..

Els reals de Coma fixa estan definits al mòdul Data.Fixed

GHC estén el mecanisme de derivació d'instàncies a algunes classes més. Vegeu ref.

Tipus

bàsics

tipus	constructors / àlies	mòdul	descripció
() -- Unit	()	Prelude	equival al "void" o buit del llenguatge C
Bool	True |False	Data.Bool
Ordering	LT|EQ| GT	Data.Ord
Char		Data.Char	Unicode
String	= [Char]	Data.Char Data.String	llista de caràcters

numèrics

tipus	context	constructors / àlies	mòdul	descripció
Int, Int<N>			Data.Int
Word, Word<N>			Data.Word
Integer			Prelude	Sencer de precisió il·limitada
Ratio t	Integral t		Data.Ratio
Rational		= Ratio Int	Data.Ratio
Float, Double			Prelude
Uni, Deci, Centi, Milli, Micro, Nano, Pico			Data.Fixed	Coma fixa de representació sencera valor = representació * resolució del tipus
Complex t	RealFloat t	= !t :+ !t	Data.Complex	amb prefix '!' d'avaluació estricta

altres

tipus	context	constructors / àlies	mòdul	descripció
(t1,t2,...,tn)		(,) (,,) (,,...,)	Data.Tuple	tupla
Maybe t		Nothing | Just x	Data.Maybe	dominis parcialment definits o paràm. opcionals
Either tipError tipResultat		Left error | Right resultat	Data.Either	Opció doble dret Right o tort Left , freq. usat per al resultat de func. parcialment definida amb info de l'error
IO tipResultat			System.IO	operacions d'entrada/sortida
IOError			System.IO.Error	Excepció en expressions IO
Exception			Control.OldException	tipus algebraic d'error del Haskell98 obsolet—la nova classe Exception permet construir excepcions de tipus definits per l'usuari.
SomeException e	Exception e		Control.Exception	nou tipus genèric de les excepcions

• classes que implementen (a banda de Eq, Show i Read)

	Ord	Enum	Ix	Bounded
() -- Unit	Sí	Sí	Sí	Sí
Bool	Sí	Sí	Sí	Sí
Ordering	Sí	Sí	Sí	Sí
Char	Sí	Sí	Sí	Sí

	Ord	Enum	Ix	Bounded	Num	Bits	Real	Integral	Fractional	RealFrac	RealFloat	Floating
Int, Int<N>, Word, Word<N>, Integer	Sí	Sí	Sí	Sí	Sí	Sí	Sí	Sí	No
Rational	Sí	Sí	No	No	Sí	No	Sí	No	Sí		No
Float, Double	Sí	Sí	No	No	Sí	No	Sí	No	Sí
Uni, Deci, Centi, Milli, Micro, Nano, Pico	Sí	Sí	No	No	Sí	No	Sí	No	Sí		No
Complex t	No	No	No	No	Sí	No	No	No	Sí	No	No	Sí

Vegeu també:

• contenidors

el domini condiciona el context algebraic

Hi ha tres operadors d'exponenciació !!

• (^) exponent natural (tipus sencer amb valor positiu, genera excepció si no és positiu), el domini d'aplicació ha d'implementar l'op. producte definida a Num, requeriment: (Num t)

 (^) :: (Num a, Integral b) => a -> b -> a
Prelude> let ex = -2
Prelude> :type 10 ^ ex
10 ^ ex :: Num a => a
Prelude> 2 ^ex
*** Exception: Negative exponent

• (^^) exponent sencer => l'exponent negatiu requereix que el domini d'aplicació implementi l'elem. invers del producte (recip: recíproc definit a Fractional), requeriment: (Fractional t)
• (**) exponent en coma flotant => l'exponenciació requereix exp i logBase definits a Floating

literals

Els literals numèrics no s'associen a un tipus (per la tinença o no del punt decimal) sinó a una classe (signatura) i les seves operacions.

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

ghci
Prelude> :type 1
1 :: (Num t) => t  -- tipus t tal que implementa la signatura de ''Num'' ( (+) (-) (*) i altres ops.)
                   --   la classe Num és la més genèrica (implementada per tots els tipus numèrics)
Prelude> :type 1.5
1.5 :: (Fractional t) => t   -- tipus t tal que implementa la signatura de ''Fractional''
                -- implementada per Float, Double, Rational, Uni, Deci, Centi, Milli, Micro, Nano, Pico

 -- mateixa variable de tipus en paràmetres diferents exigeix tipus idèntics
 -- l'operació (+) :: (Num a) => a -> a -> a   
 --     per la def., requereix el mateix tipus en ambdós operands i resultat
 Prelude> (1::Int) + 2   -- al 2 se li assigna el tipus de l'altre operand
 3
 Prelude> (1::Float) + 2
 3.0

 0x41  -- hexadecimal :: (Num t) => t
 0o377 -- octal :: (Num t) => t

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

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

conversions

• Des de Sencer

<source lang="haskell"> fromIntegral :: (Integral a, Num b) => a -> b

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 </source>

Les conversions entre Int i Word preserven la representació (no pas el signe).

• Des dels tipus que implementen la classe Real (matemàticament parlant, els reals inclouen a més dels pròpiament anomenats així, els sencers i els racionals). Són instància de Real els Float, Double, Int, IntN, Integer, Word, WordN, Racionals (Integral a => Ratio a), ...

<source lang="haskell"> realToFrac :: (Real a, Fractional b) => a -> b

fromRational :: Rational -> a

Prelude> realToFrac (1.0::Float) :: Double 1.0 Prelude> realToFrac (1.1234567890::Double) :: Float 1.1234568

1. incorporem el mòdul de coma fixa Data.Fixed

Prelude> :m +Data.Fixed Prelude Data.Fixed> realToFrac (1.5 ::Float) :: Centi 1.50

1. 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 0.6666667 </source>

tipus algebraics

enumeracions

Cal afegir-hi la clàusula deriving perquè el compilador instancii les operacions bàsiques per al tipus definit. <source lang="haskell">

data DiaSetm = Dl | Dm | Dc | Dj | Dv | Ds | Dg 
               deriving (Show, Eq, Ord, Enum, Bounded)

</source>

tipus producte

data TRectangle = Rectangle Int Int -- (Int * Int) amb constructor Rectangle

El constructor equival a una funció que retorna un element del tipus a partir dels components. De fet a GHC (amb l'extensió GADTs) es pot escriure <source lang="haskell">

data TRectangle where
         Rectangle :: Int -> Int -> TRectangle

</source>

Encaix dels paràmetres a partir del constructor

<source lang="haskell">

perímetre :: TRectangle -> Int
perímetre (Rectangle x y) = 2 * x * y

</source>

registres

Tipus producte amb noms de camps com a funcions accessores als components. No hi ha registres anònims (cal distingir-los pel constructor).

• (els noms dels camps pertanyen a l'espai de noms del mòdul i convé afegir-los-hi un prefix per evitar col·lisions)

<source lang="haskell">

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)

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

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

-- accedint per nom de camp 
nom = pNom x   

-- encaix posicional
(Persona nom _ _) = x

-- actualització
y = x {pAlçada=1.72}

-- encaix per nom -- p @ (Persona {pEdat = v_edat}) es llegeix: p com (Persona quina pEdat és v_edat)

aniversari p @ (Persona {pEdat = v_edat}) = p { pEdat = v_edat +1}

-- amb encaix simplificat {c} equival a {c = c} a GHC amb {-# LANGUAGE NamedFieldPuns #-}

aniversari p @ (Persona {pEdat}) = p { pEdat = pEdat +1}

-- NameFieldPuns també desdobla {camp} com a {camp = camp} a l'actualització (dreta de la def.)
estableixEdat pEdat p = p {pEdat} 

</source>

Per la sintaxi simplificada a GHC vegeu

tuples

tipus producte anònim amb constructors com: (,) ; (,,) ; ... . Ops. definides a Data.Tuple

 ()     -- la tupla buida és un valor del tipus Unit (el dels procs. que no retornen res)
      --         i també designa el tipus esmentat.

 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)

 -- encaix
 (primer, segon) = parell

tipus suma

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

<source 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 -- a GHC, aquest tipus ha passat al mòdul Control.OldException

= 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 TCoord = Double

-- estil algebraic data TPunt = Punt2D TCoord TCoord

            | Punt3D TCoord TCoord TCoord  
            deriving (Eq, Show) 

-- estil GADTs ( algebraic generalitzat) -- requereix pragma: {-# LANGUAGE GADTs #-} -- per cadascun dels constructors se'n descriu el tipus: data TPunt where

 Punt2D :: TCoord -> TCoord -> TPunt
 Punt3D :: TCoord -> TCoord -> TCoord -> TPunt
 deriving (Eq, Show)

p2D = Punt2D 2 4 p3D = Punt3D 4 6 8

-- encaix discriminant pel constructor

mòdul :: TPunt -> TCoord mòdul (Punt2D x y) = sqrt $ x^2 + y^2 mòdul (Punt3D x y z) = sqrt $ x^2 + y^2 + z^2 </source>

tipus polimòrfics

Amb variables de tipus (els ident. que comencen per minúscula):

-- el tipus Maybe : opcionalitat de valor per a funcions definides parcialment
data Maybe a   = Nothing | Just a deriving (Eq, Ord, Read, Show)

-- tipus recursius
data Arbre tip_node = Fulla tip_node | Branca (Arbre tip_node) (Arbre tip_node)

• tipus amb context. Aquesta construcció està subjecta a controvèrsia i potser s'eliminarà

-- tipus amb context restringint els tipus dels components
data (Eq a) => Conjunt a = ConjBuit | ConjElem a (Conjunt a)

àlies o sinònims de tipus

Els sinònims de tipus són com macros al nivell de tipus.

-- EBNF 'type' nom_de_tipus [' ' param { ' ' param}] '=' expressió_de_tipus

type String = [Char]
type LaMevaEstructura = (String, Int, Double)

sinònims paramètrics

El següent sinònim inclou paràmetres de tipus.

type LlistaNumerada a = [(Int, a)]
type Element t         -- #"Àlies de Tipus" associats a la classe

sinònims liberalitzats (extensió LiberalTypeSynonyms)

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

llistes

El tipus Llista amb constructors "[]" (llista buida, anomenat nil) i ":" (tip_elem * llista_elem, anomenat cons)

data [a] = []  |  a : [a]  deriving (Eq, Ord)

[]    -- llista buida
[1,2,3] -- valors homogenis
[a] -- en una decl. de tipus, llista d'elements de tipus a
[1,3..10] == [1, 3, 5, 7, 9]
[1,3..] == [1, 3, 5, 7, 9, ...  -- llista infinita
elem_cap : llista_cua   -- ':' és el constructor de llistes (en pos. infix)
llista !! posició—consulta element, el primer és llista!!0

iterate f x == [x, f x, f (f x), ...] -- llista infinita per aplicació reiterada d'una funció
repeat x               -- llista infinita per repetició
cycle xs—converteix la llista xs en circular—elem: pertinença a la llista
ésFeiner dia = dia `elem` [Dl, Dm, Dc, Dj, Dv]

Més operacions a contenidors

llista per comprensió

amb generadors i filtres separats per comes

s = [ x+y | x <- [0,2..], y <- [1,3..20], x^2 > 3, y `mod` 9 /= 0 ]

print $ take 5 s  -- imprimeix els primers

llista per comprensió monàdica

Vegeu-ho a Mònada_(programació_funcional)#Llista_per_comprensió_monàdica

llistes per comprensió a l'estil de SQL

Consultes a l'estil de SQL sobre generadors. Vegeu-ho a GHC

tires de text

-- el tipus String (cat: Cadena) é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\""

Vegeu exemple de cadenes com a vectors a #Cadenes de text més eficients

• Llegiu l'article "How to pick your string library in Haskell"

tipus amb allotjament linial

Per interfície

Vectors immutables

interfície (classe) IArray Vegeu #Vectors immutables del H98

Vectors mudables

interfície (classe) MArray Vegeu #Vectors més eficients

Vectors de tractament paral·lel (paral·lelisme de dades)

interfície (classe) PArray. (cada op. conclou havent avaluat tots els elements) Només a GHC.

Vectors amb allotjament contigu, per a ésser accedits des de mòduls forans (ex.lleng. C)

interfície Storable.

Immutables, per allotjament dels elements

data Ix idx => Array idx elem  -- Elements allotjats indirectament (encapsulats, avaluació tardana)
data Ix i => UArray i e -- Elements allotjats directament, (no encapsulats Unboxed, avaluació estricta)

Mudables, per implementació i allotjament

• En memòria global, a la mònada IO.

data IOArray i e   -- amb allotjament indirecte dels elements (encapsulats, avaluació tardana)
data IOUArray i e  -- amb allotjament directe dels elements (no-encapsulats: Unboxed, avaluació estricta)

• En memòria local, a la mònada ST.

data STArray s i e  -- amb allotjament indirecte dels elements (encapsulats)
data STUArray s i e -- amb allotjament directe dels elements (no-encapsulats)

classes de tipus

Les classes de tipus no són com les classes de C++, que són classes d'objectes, sinó com els Interface de Java.

Designen un conjunt d'operacions que els tipus han d'implementar mitjançant la instrucció instance. La instrucció class admet la implementació de mètodes per defecte, que les instàncies poden redefinir

<source lang="haskell">

class CForma t where

 perímetre :: t -> Double
 àrea :: t -> Double

type TRadi = Double type TCostat = Double

data TCercle = Cercle TRadi data TRectangle = Rectangle TCostat TCostat

instance CForma TCercle where

 perímetre (Cercle r) = 2 * pi * r
 àrea (Cercle r) = pi * r ^ 2

instance CForma TRectangle where

 perímetre (Rectangle x y) = 2 * (x + y)
 àrea (Rectangle x y) = x * y

</source>

Tipus existencial

És un mecanisme per poder acomodar objectes de tipus diferents que tinguin una interfície en comú i tractar-los col·lectivament.

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

(pseudocodi)
T = ∃x { v: x; f: (x -> Int); }   -- tipus 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

• El compilador GHC utilitza la paraula reservada forall (quantificador ∀), per als tipus existencials apel·lant a un isomorfisme.

• Altres compiladors de Haskell fan servir la paraula reservada exists com a quantificador existencial, el EHC/UHC segons la ref., i el JHC també, en comptes del forall del GHC.

<source lang="haskell">

-- la variable no ha d'aparèixer a l'esquerra del '='
data T = forall a. ConstructorT { v::a, f:: (a->Int)}

unValorIntT = ConstructorT { v = 1, f = identitat}
unValorFloatT = ConstructorT { v = 1.5, f = part_sencera}

-- afegint-li requeriments
data T = forall a (Ord a, Bounded a) => ConstructorT { v::a, f:: (a->Int)}

</source>

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

<source lang="haskell">

data TObj = forall a (Show a) => Obj a

exempleNumèric = Obj 1
exempleString = Obj "abc"

-- equivalent amb sintaxi GADTs, sense necessitat del quantificador
data TObj where
      Obj :: (Show a) => a -> TObj

</source>

Es fa servir a #Llistes homogènies d'elements amb components heterogenis

Expressions

funcions

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

• la repetició d'una variable de tipus, en la signatura, indica que el tipus ha de ésser clavat (el mateix) que el del paràmetre on apareix primer.

-- (el que ve abans de "=>" és el context de prerequisits dels tipus dels paràmetres)
ésApreciable :: (Ord a) => a -> a -> Bool    -- cal que el tipus ''a'' implementi "Ordenable"
ésApreciable llindar valor = valor >= llindar

Funcions d'ordre superior: quan algun dels paràmetres o el resultat és una funció <source lang="haskell"> flip  :: (a -> b -> c) -> b -> a -> c flip f x y = f y x </source>

Monomorfisme, polimorfisme i quantificadors explícits

Vegeu ref.

polimorfisme universal

El polimorfisme per defecte dels paràmetres de funcions és l' universal. 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).

<source lang="haskell">

-- declaracions idèntiques -- per a tot tipus a 
id :: a -> a     -- (tipus de 1er ordre)
id :: forall a . a -> a   -- amb quantificador universal explícit. (tipus de 1er ordre)

-- forall explícit als paràmetres
foo :: (forall a. a -> a) -> (Char,Bool)  -- funció amb tipus de 2on ordre (ang: rank-2 type)

</source> Vegeu també

• Rank-2 types, ($) and the Monomorphism restriction
• Extensió {-# LANGUAGE NoMonomorphismRestriction #-}
• Des de GHC 7.2 Monomorfisme als lligams locals (let|where), excepte que s'expliciti la generalització.

polimorfisme existencial

Els tipus dels paràmetres formals, condicionats per un context, defineixen el conjunt de tots aquells tipus que implementin, entre d'altres, les classes que el context requereix al paràmetre de tipus.

<source lang="haskell">

funció_sobre_tipus_ordenable_i_acotat :: (Ord a, Bounded a) => a -> a

</source>

Podríem formular el paràmetre formal de manera existencial definint el conjunt de tipus acceptat:

<source lang="haskell"> {-# LANGUAGE RankNTypes #-} import Control.Exception (ArithException(Overflow), throw, evaluate)

incr :: forall a. (Num a, Ord a, Bounded a) => a -> a incr x = if xIncrementat < x then throw Overflow

                            else xIncrementat
     where xIncrementat = x + 1

-- incrementa el més gran del tipus, per fer saltar l'excepció main = do

        res <- evaluate $ incr (maxBound::Int) 
        print res

</source>

encaixos de patrons

-- _ és el comodí
llargada [] = 0            -- [] patró constructor nil de llista buida.
llargada (_:xs) = 1 + llargada xs    -- (_:_) patró constructor cons com a (cap:cua)

--l'operador @ (as-pattern) com a variable @ patró unifica la variable i el terme encaixat al patró

descriuLlista ll @ (_:_) = "llista no buida: " ++ show ll

!! GHC no avisa quan els encaixos son incomplets (no exhaustius), 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 cal prefixar-los amb ~

Signatures de tipus als patrons

Totes les variables de patrons admeten signatures, quines variables de tipus han de pertànyer a l'àmbit limitat pel context.

<source lang="haskell">

 f :: forall a. [a] -> (Int, [a])
 f xs = (n, zs)
   where
     (ys::[a], n) = (reverse xs, length xs) -- OK
     zs::[a] = xs ++ ys                     -- OK

     Just (v::b) = ...  -- Not OK; b is not in scope

</source>

Guardes

<source lang="haskell">

signe x | x > 0  = 1
    | x == 0 = 0
    | otherwise = -1

</source>

Guardes amb encaix (ang: pattern guards)

Haskell2010 potencia les guardes amb la possibilitat d'incorporar una llista d'encaixos com les sub-clàusules de les llistes per comprensió. <source lang="haskell"> -- el símbol (<-) té un significat diferent del que té a la dreta de l'igual

     -- (on relaciona en una expr. monàdica, la variable de la func. anònima de l'acció encadenada)

-- en una guarda (<-) força l'encaix a l'esquerra d'una expressió equivalent a la part dreta. addLookup env var1 var2

  | Just val1 <- lookup env var1
  , Just val2 <- lookup env var2
      = val1 + val2
  | otherwise = ...

</source>

Lligams d'àmbit local

Vegeu "Let vs Where".

estil declaratiu (ús abans de la definició)

permet definir variables esmentades als patrons i guardes de la definició (a cada patró el seu where)

-- en una definició amb (=) o en una alternativa de case (amb (->))
    patró | guarda = expressió
              | guarda2 = expressió2 
    where declaracions_locals
    

estil imperatiu (definició abans de l'ús)

estableix àmbits successius permetent redefinir un mateix símbol si és en àmbits diferents

<source lang="haskell"> -- ghci Prelude>let x = 1 ; y = x in let x = y +1 in print x 2 -- resultat </source>

Als blocs do els subblocs let no duen la paraula reservada in al final.

<source lang="haskell"> -- ghci Prelude>do {let {x = 1; y = x } ; let {x = y +1} ; print x} 2 -- resultat </source>

Àmbit dinàmic - paràmetres implícits

Amb variables lligades a l'àmbit del procediment que fa la crida.

• Cal prefixar-ne les variables amb '?' i esmentar-les als requisits de context.
• Cal l'extensió de llenguatge {-# LANGUAGE ImplicitParams #-}. Vegeu ref.

<source lang="haskell"> {-# LANGUAGE ImplicitParams #-}

ambParàmetreVImplícit :: (?v :: Int) => Int -> Int ambParàmetreVImplícit x = ?v * x

cridaIntermèdia :: (?v :: Int) => Int cridaIntermèdia = ambParàmetreVImplícit 2

prova = let ?v = 2

       in cridaIntermèdia

main = print prova </source>

Alternatives if, case

<source lang="haskell"> -- if del haskell98 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

-- equivalent de if amb clàusules else_if dels lleng. imperatius case () of

   _ | condició1 -> expr1
     | condició2 -> expr2
     | otherwise -> expr3

-- Multiway if (desde GHC v. 7.6.1 !!) {-# LANGUAGE MultiWayIf #-} if | x == 0 -> [...]

  | x > 1     -> [...]
  | x < 0     -> [...]
  | otherwise -> [...]

</source>

Plegat -- iteracions a l'estil de for / foreach sense efectes col·laterals

L'operació foldl (foldLeft) permet acumular "transformacions reiterades sobre una estructura" amb una funció (a -> b -> a) i els valors d'una seqüència [b], de manera equivalent als bucles for de la prog. imperativa tradicional, per als casos sense efectes col·laterals. La funció equivaldria al nucli de la iteració.

<source lang="haskell"> -- essent acc l'estructura i [b] la llista de valors a iterar

foldl :: (acc -> b -> acc) -> acc -> [b] -> acc foldl op estructura [] = estructura foldl op estructInicial (x:xs) = foldl op (op estructInicial x) xs </source>

Vegeu també iteracions a espai constant de la pila amb plegat per l'esquerra estricte

L'operació mapAccumL de Data.List és una combinació de foldl i map. Permet transformar una llista amb una funció d'un acumulat: <source lang="haskell"> mapAccumL :: (acc -> b -> (acc, c)) -> acc -> [b] -> (acc, [c]) </source>

Expressions lambda com a funcions anònimes

La barra invertida, caràcter del teclat que més s'assembla a la lletra grega lambda, introdueix una funció anònima com a expressió.

 \ x y -> x + y

definició d'operadors

<source lang="haskell">

(++) :: [a] -> [a] -> [a]   -- concatenació de dues llistes
infixr 5 ++         -- associativitat dreta o esq. (infixr | infixl) o no (infix),
              -- i precedència de l'operador (per defecte infixl 9)
[]   ++ ys = ys       -- cas simple
(x:xs) ++ ys = x : (xs ++ ys) -- cas recursiu

</source> Respecte les precedències vegeu la ref.

operadors de funcions

( . ) composició: Punt envoltat d'espais, (sense espais el punt és el qualificador de noms importats)

f . g

($) aplicació normal (tardana). Permet estalviar parèntesis en aplicar operacions sobre el darrer paràmetre quan és una expressió (hi ha més d'un terme).

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.

(f $ g $ x + y) === f ( g (x + y))

-- exemple, en comptes de:  print ("el resultat és" ++ show result)
print $ "el resultat és" ++ show result

lectura de dreta a esquerra en la composició

En aplicar una composició de funcions (f . g . h) obj 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 el mateix a l'estil de flux de dades, definint un operador (per exemple (.$) com l'utilitzat per F# (|>) dit pipeline), associatiu per l'esquerra <source lang="haskell"> import Control.Exception (assert) import Control.Arrow ((>>>))

x .$ f = f x -- definició d'un operador binari (com (|>) a L'"F sharp")

       -- per defecte "infixl 9": associatiu per l'esquerra i màx. precedència

-- o també (.$) = flip ($)

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

prova0 = f (g (h obj)) -- pels aimants dels parèntesis (enyorats del LISP) prova1 = f $ g $ h obj -- estil aplicatiu prova2 = (f . g . h) obj -- estil funcional prova3 = (h >>> g >>> f) obj -- estil fletxa prova4 = obj .$ h .$ g .$ f -- estil navegació de dades (com a la O.O. obj.mètode),

                            --      havent definit l'operador (.$) com (|>) a L'"F sharp"

comprovació = all (== "0123") [prova0,prova1,prova2,prova3,prova4] main = do

        print prova0 ; print prova1
        print prova2 ; print prova3 ; print prova4

        assert comprovació $ print "són iguals"

</source>

Aplicació parcial

funció a partir d'una altra funció ometent el(s) darrer(s) paràmetre(s)

<source lang="haskell"> -- també

suma = (+)                -- lliga el nom 'suma' a l'op. binari (+)
suma3 = suma (3::Int)     -- :: Int -> Int        -- aplicació parcial
total = suma3 4        

</source>

Secció d'un operador infix

Aplicació parcial dels operadors infix. Vegeu ref. <source lang="haskell">

suma3 = (3+)           -- aplicació parcial de l'expressió

</source>

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

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

</source>

excepcions

Les excepcions només poden ser caçades "dins d'una expressió mònada o clàusula do"

catch

la clàusula catch té dos parametres, l'operació vetllada i el manipulador d'excepcions

Les excepcions del Haskell98 (tipus Exception) a GHC han passat al mòdul Control.OldException

<source lang="haskell"> -- excepcions del Haskell98. import Control.OldException

catch

 (evaluate (x/y) >>= print)
 (\excep -> case excep of
         ArithException ae | ae == DivideByZero -> print "divisió per zero"
         _ -> print ("excepció per " ++ show excep)
 )

</source>

Per a les excepcions noves de GHC (qualsevol tipus que implementi la classe Exception), són al mòdul Control.Exception

• Vegeu Glasgow Haskell Compiler#Excepcions de tipus definits per l'usuari

<source lang="haskell"> {-# LANGUAGE ScopedTypeVariables #-} import Prelude hiding (catch) {- 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

f = (evaluate expr) `catch` \ (excep :: ArithException) -> tracta_Arith excep

         `catch` \ (excep :: IOException)    -> tracta_IO excep
         `catch` \ (excep :: SomeException)  -> tracta_Altres excep

</source>

try

la clàusula try (assajar) no tracta les excepcions, les retorna en un tipus mixt

retorna en un tipus (Either tipusExcepció tipusResultat) "o bé Incorrecte amb l'excepció (constructor Left) o bé Correcte amb el resultat (constructor Right)"

<source 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 :: IO a -> IO (Either Exception a)

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

main = do

        let x = 0.0001 :: TipDada
            y = 0 :: TipDada
        result <- try (evaluate (x/y)) :: IO (Either ArithException TipDada)
        case result of
            Right valor -> putStrLn $ "correcte: " ++ show valor
            Left excep -> putStrLn $ "excepcio: " ++ show excep

</source>

• evaluate s'utilitza per sincronitzar l'avaluació de l'expressió en el context de la mònada IO

Amb TipDada == Micro (Coma fixa) l'excepció salta

excepcio: divide by zero

Amb TipDada == Double, no hi ha excepció (IEEE 754iDivisió entre zero), dóna:

correcte: Infinity

Funcions d'error

<source lang="haskell">

userError :: String -> IOError
userError missatge        -- construeix una excepció IOError de l'aplicació

</source>

Llançadors

 throw excep   -- llança excep dins el codi funcional
 throwIO excep  -- llança excep. dins la mònada IO (expressió IO o clàusula ''do''),
         --       garanteix l'ordre en operacions IO.
 ioError :: IOError -> IO a -- llança un IOError dins la mònada IO,
         --      exemple: ioError (userError missatge)
 annotateIOError :: IOError -> String -> Maybe Handle -> Maybe FilePath -> IOError
         -- afegeix localització i informacions a un IOError

Vegeu ref.

Errors irrecuperables d'estats inconsistents o resultat d'operacions no definides per als valors dels paràmetres.

 error missatge          -- genera una excepció ErrorCall

<source lang="haskell"> {-# LANGUAGE ScopedTypeVariables #-} import Prelude hiding (catch) import Control.Exception

llistaBuidada = drop 5 [1::Int,2,3]

main = (evaluate $ head llistaBuidada)

      `catch` \ (excep :: ErrorCall) -> putStrLn "les llistes buides no tenen cap!!"

</source>

Assercions, Precondicions i Postcondicions

assert avalúa la condició, i si és certa retorna el segon argument i ,si no, peta dient-nos on.

L'ús de l'opció d'optimització (-O ó -On |n>0) elimina les assercions del codi objecte.

assert condició expr --
     -- si Fals, genera l'excepció AssertionFailed indicant nom_del_fitxer i línia

per exemple: <source lang="haskell">

import Control.Exception (assert)

-- amb asserts de precond. i postcond. en diferents línies així sabrem quina peta

unaFunció p1 p2 = assert (precondició p1 p2)
                  $ assert (postcondició p1 p2 resultat) resultat 
 where
  resultat = ...

</source>

Vegeu també: Glasgow Haskell Compiler § Depuració. Afegint punts de control per detectar qui ha cridat l'asserció fallida

"No finalització": Símbol ⊥

Valor intern que indica que el programa acaba prematurament (s'encalla). per exemple l'última opció d'un case és sempre ⊥, que encalla el programa quan els encaixos no són exhaustius i no hi ha cap encaix vàlid per al patró.

En anglès s'anomena "bottom" (com a verb: fondejar, tocar fons, enfonsar, encallar!). En català es podria anomenar "aterratge" per assimilació al mateix símbol "terra" en l'electrònica.

undefined

valor ⊥ per explicitar el tipus d'una funció pendent d'implementar i poder així passar la compilació. Crida a la funció error.

identificador patrons = undefined :: tipus

excepcions en la gestió de recursos

Clàusules similars al try ... finally d'altres lleng.

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 la primera part es passa com a paràmetre a les altres dues.

<source lang="haskell">

bracket :: IO a ->    -- (adquisició de recurs), ex.: (openFile nom_fitxer mode) :: IO Handle
     (a -> IO b) ->  -- (alliberament del recurs), per ex.: hclose :: Handle -> IO ()
     (a -> IO c) ->  -- (computació amb el recurs), ex.: (\handle -> do {...}) :: Handle -> IO c
     IO c       -- retorna el resultat de la computació

</source>

exemple: bracket (openFile nom_fitxer mode) hClose computació_amb_el_descriptor_del_fitxer

A System.IO: withFile nom_fitxer mode = bracket (openFile nom_fitxer mode) hClose

   ús: withFile nom_fitxer ReadMode (\descriptor_del_fitxer ->
                     do {acció_amb_el_descriptor_del_fitxer})

finally

assegura l'exec. de la segona part malgrat excepcions en la primera

<source lang="haskell"> finally (computació) (coses_a_fer_en_acabar) -- se sol veure més en notació infix (computació) `finally` (coses_a_fer_en_acabar) </source>

onException

com finally però només en cas d'excepció, que és rellançada en acabar el segon bloc

Traçabilitat dins el codi funcional

El codi funcional no permet l'ús de print. Cal fer servir Debug.Trace.trace. Imprimeix el primer paràmetre, via unsafePerformIO i retorna el segon.

<source lang="haskell"> -- prova.hs import Debug.Trace (trace) -- trace :: String -> a -> a

quadrat x = resultat'

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

cub x = x * quadrat x

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

A partir de GHC v.7.4.1 hi ha també traceStack :: String -> a -> a que a més bolca la traça de crides si s'ha compilat amb opcions de perfilat.

Subtituïm trace per traceStack i ...

ghc --make -prof -fprof-auto-calls prova.hs
./prova
traça de quadrat de 2 és: 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

Efectes coŀlaterals

Les operacions d'efectes coŀlaterals (canvis d'estat, interaccions amb el món exterior) es formulen, principalment, mitjançant el TAD Mònada que assegura l'ordre de les operacions, indeterminat en Haskell, mitjançant l'encadenament.

En demanar, de manera tardana, el resultat d'un encadenament cada lligada (>>=) o (>>) requereix l'avaluació prèvia de l'operació precedent en la cadena, establint l'ordre seqüencial.

Les funcions del mòdul Control.Monad (forM_ llista acció, forever acció, replicateM_ n acció) fan la feina de les clàusules de control imperatiu (forEach, while true do ..., for i = 1 to n do ...) d'altres llenguatges.

Entrada / Sortida

Haskell modela l'entrada/sortida com una seqüència encadenada d'operacions, encapsulant els canvis d'estat d'accés a fitxers. Aquest model encaixa amb el concepte de mònada, 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 IO.

<source 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 -- tipus IO String
getLine >>= putStr        -- imprimeix línia introduïda -- tipus IO ()
putStr "polseu Intro" >> getLine >> putStrLn "Fet" >> return True    -- tipus IO Bool
return "abc" >>= putStrLn   -- estableix "abc" com a resultat monàdic i l'imprimeix tot seguit

-- >>= -- encadena aplicant la funció següent al resultat de l'operació precedent
-- >>  -- encadena sense passar resultats
-- return x  -- op. generadora d'una mònada que contindrà x quedant del tipus IO X
       -- no pressuposa retorn d'enlloc; per ex. (return 5) :: IO Int
-- fail missatge  -- dispara excepció en cas d'error en encaixar patrons dins una clàusula do
         -- i retorna l'element neutre de les operacions, ex. IO ()
         -- el tipus de l'excepció depèn de la instanciació de la mònada (IOError cas d'IO),

</source>

Blocs Do: notació especial de les expressions monàdiques

Encadenament de les instruccions d'un bloc. Vegeu mònada - Blocs Do

Clàusula let dins el bloc do

NO ens referim al let..in de les expressions. Sense l' in, permet assignar variables a expressions basades en resultats de computacions prèvies (instruccions precedents del mateix bloc), cosa que no es pot fer amb clàusules where (que es basen en variables definides al patró corresponent o àmbits precedents).

• amb '<-' s'obté el valor contingut dins la mònada de l'expressió

 variable "<-" expr_monàdica

 -- equival a encadenar amb la resta de línies passant el contingut
 expr_monàdica >>= \variable ->

• amb let v '=' s'obté el valor exacte de l'expressió (basada en resultats de computacions prèvies)
• les instruccions d'un bloc let poden ser mútuament recursives.

 "let" variable "=" expr {";" variable2 "=" expr2}

 -- té un efecte similar a encadenar de la següent manera
 (return expr) >>= \variable ->
   (return expr2) >>= \variable2 ->

• sense variables a passar les línies del bloc do s'encadenen amb (>>)

 do acció1
    acció2

 -- equival a
 acció1 >> acció2

<source lang="haskell">

main = do

    print "Entreu un mot: "
    x <- getLine
    print "Entreu-ne un altre: "
    y <- getLine

    let z = x ++ y
        w = z ++ "."   -- let introdueix un subbloc de lligams que cal aliniar (sagnat)

    putStrLn ("La concatenació és: " ++ show w)

</source>

Blocs do niuats

Per posar més d'una línia d'instruccions en una branca d'un "case" o d'un "if" cal agrupar-les dins un subbloc "do"

<source lang="haskell">

import System.IO (stdout, hFlush)

-- pels caràcters no anglosaxons a l'entrada/sortida, si versió GHC < 6.12 utilitzar paquet utf8-string
-- a partir de GHC >= 6.12.1 incorporarà la codificació de caràcters local del sistema
--              i no caldrà la substitució de funcions.

1. ifdef __GLASGOW_HASKELL__
2. if __GLASGOW_HASKELL__>=612

-- no substituir
msg = "ghc modern"

1. else

import Prelude hiding (putStr, putStrLn, getLine) -- amaguem les funcions predefinides no UTF8 que volem UTF8
import System.IO.UTF8 (putStr, putStrLn, getLine) -- cal haver instal·lat el paquet "utf8-string"
msg = "ghc antic"

1. endif

-- c_trencada = '\231'

main = do
    putStrLn msg
    putStr "Entreu lletres tot seguit: "
    hFlush stdout

    x <- getLine
    case x of
     lletra:_ -> do
            putStr "comença per "
            putStrLn [lletra]

1. endif

</source>

Compilant amb preprocés:

runhaskell -cpp prova.hs

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

<source lang="haskell">

import Control.Monad as Monad

main = do

    print "Farem l'eco fins que l'entrada sigui buida."
    catch(
     Monad.forever $ do           -- repetir indefinidament
       x <- getLine
       case x of
        [] -> ioError (userError "Línia buida") -- llança excepció per sortir del "forever"
        _ -> putStrLn x
     )
     (\excep -> print excep
     )

</source>

Recursivitat en els blocs do

Vegeu Mònada_(programació_funcional)#Recursivitat_en_els_blocs_do

Llistes homogènies d'elements amb components heterogenis

Vegeu. El #Tipus existencial permet definir tipus de dades 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 #-}

<source lang="haskell">

{-# LANGUAGE ExistentialQuantification #-}

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

-- la variable a del quantificador forall no ha d'aparèixer mai a l'esquerra del '='

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

xs :: [TObj]
xs = [Obj 1, Obj "foo", Obj 'c']

mostra :: [TObj] -> String
mostra [] = ""
mostra ((Obj x):xs) = show x ++ mostra xs  -- aplica al component x l'operació show
                                           -- de la classe Show que els components d'Obj implementen

</source>

Vegeu-ne l'exemple #Tipus existencial - Emulació del despatx dels mètodes virtuals de la O.O.

Vectors immutables del H98

La classe Array combinada amb la Ix (índexos), especificades en el Haskell98, implementen vectors immutables amb elements d'avaluació tardana.

<source lang="haskell">

-- vector d'una dimensió, s'inicialitza amb
--      les dimensions i una llista exhaustiva de parells (índex, valor)
import Array
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)
nou_v = 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]]

</source>

• per fer un vector amb índex de tipus enumerat cal que l'enumerat implementi la classe dels índexos Ix (A GHC: biblio. Data.Ix)

<source lang="haskell">

class Ord a => Ix a where
 range :: (a, a) -> [a]
 index :: (a, a) -> a -> Int
 inRange :: (a, a) -> a -> Bool
 rangeSize :: (a, a) -> Int

</source>

<source lang="haskell">

import Array
import Text.Printf
data DiaSetm = Dl | Dm | Dc | Dj | Dv | Ds | Dg
         deriving (Show, Eq, Ord, Enum, Ix) -- el compil. instancia Ix
encàrrecs :: Array DiaSetm Int
encàrrecs = array (Dl,Dg) [(Dl,5),(Dm,6),(Dc,3),(Dj,7),(Dv,8),(Ds,3),(Dg,0)]
main = do
    printf "Per dimecres tinc %d encàrrecs\n" (encàrrecs!Dc)
    putStr "De Dl a Dg: "
              -- aplicació parcial de l'operació (!)
    putStrLn $ show $ map (encàrrecs!) $ range (Dl,Dg)

</source>

A part d'aquests vectors, que generen una còpia a cada actualització, n'hi ha d'altres de força més eficients. Entre aquests vegeu més avall #Vectors més eficients.

Canvis d'estat - Variables

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

La mònada IO caracteritza l'estat global de l'aplicació.

La mònada ST caracteritza un estat local permetent encapsular actualitzacions in situ dins de codi funcional pur.

La mònada STM (inicials de Software Transactional Memory) fa possible la sincronització d'accés a variables des de diferents fils d'execució, mitjançant les transaccions en memòria (similars a les de bases de dades)

Caldrà especificar el tipus de la mònada com a tipus resultat de l'expressió o bloc do.

Variables d'estat global no sincronitzades IORef

Amb les referències IORef, equivalents de les ref del ML Estàndard, com a efectes dins la mònada IO.

No és convenient utilitzar una mateixa IORef en diferents fils d'execució. Protegir-ne més d'una mitjançant atomicModifyIORef està desaconsellat (les MVar hi són més indicades).

<source 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ó

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

    putStr "Premeu intro:"
    hFlush stdout
    getLine     -- espera tecleig Intro i ignora el resultat del getLine
                -- sense variable (v <- getline),
                --    el bloc do composa 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

</source>

encapsulament d'efectes col·laterals (amb variables d'àmbit local STRef)

La mònada ST encapsula canvis d'estat dins de codi funcional pur i permet fer computacions amb actualitzacions in situ mitjançant referències STRef

en memòria local

• aplicant runST, en l'espai específic de l'estat del fil d'execució actual, encapsulant els efectes col·laterals de la computació. Cal especificar el tipus de la mònada com a (ST s tipusDelResultat) on la variable s, que indica la zona de memòria, es deixa lliure, indicant que és la del fil d'execució.

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

   a <- readSTRef ref_acc     -- llegeix l'acumulador
   writeSTRef ref_acc (f a 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 valor final de la mònada del bloc do

resultat = runST $ foldlST (+) 0 [1,2,3,4] -- runST aplica el bloc do en l'espai del fil actual

main = do
     putStrLn $ "total: " ++ show resultat

</source>

en memòria global

• fem operar la mònada ST en memòria global (RealWorld), especificant el tipus de la mònada com a (ST RealWorld tipusDelResultat), i stToIO passa el resultat a tipus (IO tipusDelResultat)

<source lang="haskell">

-- igual que a l'exemple anterior amb els següents canvis:

foldlST :: (a -> b -> a) -> a -> [b] -> ST RealWorld a

-- implementació igual que l'anterior

main = do
   resultat <- stToIO $ foldlST (+) 0 [1,2,3,4]
   putStrLn $ "total: " ++ show resultat

</source>

accés sincronitzat amb variables MVar (Mutable variable)

Vegeu-ho a Haskell concurrent

vectors mudables

Vegeu vectors d'elements d'allotjament directe

Mòduls

encapsulament

No hi ha doble especificació (interfície / implementació) per als mòduls. S'exporten els identificadors llistats a la clausula module, o tots si no hi ha llista.

module A(func1, tipus2, classe3, module B) where cos_del_mòdul

tipus opacs

L'elipsi (..) al costat d'un identificador de tipus exportat, exporta tots els identificadors interns com ara constructors o camps d'un registre o símbols d'enumeracions, o les operacions d'una classe.

• Es pot substituir l'el·lipsi per la llista dels que volem exportar.
• Si no els exportem, el tipus serà opac (només se'n podran manipular els valors per les operacions del seu tipus).

module A(
  func1,
  tipus2(..),                                       -- ho exporta tot
  tipus3,        -- tipus opac (no exporta constructors
                 --    ni accessors als camps en cas de ser registre)
  unAltreTipus( constructorA, constructorB),        -- només els esmentats
  classe4(..),                                      -- classe transparent
  unaAltraClasse( mètodeA, mètodeB),        -- classe que fa privats els mètodes que no publica
  module X                      -- reexporta aquells mòduls importats anomenats o reanomenats X
  ) where

import MòdulQ as X    -- el mateix àlies permet reexportar
                      --    el contingut de diversos mòduls de cop
import MòdulR as X
import MòdulS as X
...

importació

<source lang="haskell">

import ModulA hiding (id1, id2) -- hiding: importa els exportats, excepte els mencionats
import qualified ModulB as B  -- qualified: caldrà qualificar els símbols: B.ident
import ModulB as B [hiding (...] -- sense qualified: qualificació opcional
import ModulD (id1, id2, id3)  -- enumeració: importa només els especificats

</source>

importació d'instàncies

<source lang="haskell">

import ModulA () -- llista buida, per importar només les instàncies

</source>

• les instàncies visibles d'un mòdul s'exporten sempre; qualsevol importació del mòdul les importa totes.

importacions especificant el paquet desitjat

Cal esmentar la pragma {-# LANGUAGE PackageImports #-}

<source lang="haskell"> import "nom_del_paquet" Nom_del_mòdul -- com ara: import "network" Network.Socket import qualified "network" Network.Socket as NS </source>

evitar la importació automàtica de les funcions predefinides (mòdul Prelude)

Cal esmentar la pragma {-# LANGUAGE NoImplicitPrelude #-}

Exemple: <source lang="haskell"> -- Per a l'exemple que substitueix l'entrada/sortida de tipus String per la de tipus Text module ElMeuPrelude (

 module PreludeMancat,
 putStr, putStrLn, getLine

) where

import Prelude as PreludeMancat hiding (putStr, putStrLn, getLine) import Data.Text.IO (putStr, putStrLn, getLine) </source> ús: <source lang="haskell"> -- no importis el Prelude que ja tinc el meu. {-# LANGUAGE NoImplicitPrelude #-} module ... where import ElMeuPrelude ... </source>

espai de noms de mòdul jeràrquic

El mòdul per nom "A.B.C" correspon al fitxer A / B / C.{hs,lhs,x,..}. En compilar, el senyal -i<dirs> indica a GHC la llista de directoris base de la recerca dels fonts

És corrent reanomenar els noms jeràrquics amb un nom curt <source lang="haskell">

import qualified Control.Monad.ST.Strict as ST

</source>

mòduls amb referències mútues (mútuament recursius)

Vegeu-ho a Glasgow Haskell Compiler#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).

Exemple senzill. (System.Environment no té en compte la codif. local, vegeu comentari):

<source lang="haskell"> -- per una lectura correcta (dels caràcters no anglosaxons) de la línia 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)

           (arg:_) -> do
                        printf "el primer param. és: %s\n" arg
                        exitSuccess

</source>

En l'execució, 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 en cas d'haver d'afegir, tot seguit, paràmetres pel programa

arrencada amb opcions

Per afegir opcions a la línia de comandes vegeu l'enllaç.

<source lang="haskell">

import System.Environment (getProgName, getArgs) -- a Linux System.Environment.UTF8 import System.Exit (exitSuccess, exitWith, ExitCode(..)) import System.Console.GetOpt

import Data.Maybe( fromMaybe ) import Text.Printf (printf)

-- tipus per a les opcions de línia de comanda (anomenades també senyals, en ang.: flags) data Flag = FVersio | FEntrada String | FSortida String | FArgLliure String

             deriving (Eq, Show)

opcions :: [OptDescr Flag] opcions = [

         -- opció curta, opció llarga, descriptor, missatge d'ajuda
         -- amb paràmetres obligatoris (ReqArg), opcionals (OptArg), o sense (NoArg)
 Option ['V'] ["versió"]  (NoArg FVersio) "mostra versió",
 Option ['i'] ["entrada"] (ReqArg FEntrada "FILE") "entrada requereix un nom de fitxer",
 Option ['o'] ["sortida"] (OptArg creaFlagSortidaAmbValorPerOmissió "FILE") "sortida"
]

-- fromMaybe valorPerOmissió valorOpcional -- retorna el contingut de l'opcional o, en cas de Nothing, el valorPerOmissió

creaFlagSortidaAmbValorPerOmissió :: Maybe String -> Flag creaFlagSortidaAmbValorPerOmissió ms = FSortida ( fromMaybe "sortida_per_defecte" ms )

-- embolcalla els arg. lliures com a flags per un tractament unificat argQueNoEsOpció :: String -> Flag argQueNoEsOpció arg = FArgLliure arg

msg_com = "Ús: nom_prog [OPCIÓ ...]"

processa flags = do

                 print flags
                 exitSuccess

error_als_args nom_prog msgs_error = do

   printf "%s error als paràmetres\n" nom_prog
   putStrLn $ concat msgs_error ++ usageInfo msg_com opcions
   exitWith $ ExitFailure 1  -- sortir amb el codi de finalització

main = do

nom_prog <- getProgName
args <- getArgs
case getOpt (ReturnInOrder argQueNoEsOpció) opcions args of
  -- cas de manca d'errors (llista buida al 3er de la tupla)
  (flagsCorrectes, [],   [])  -> processa flagsCorrectes
  -- altrament
  (_,   _,    msgs_error)  -> error_als_args nom_prog msgs_error

</source>

funcions i tipus predefinits i biblioteques bàsiques

El mòdul de funcions predefinides és coneix com a "Prelude". Vegeu Prelude estàndard. Prelude del GHC.

Les API's de les biblioteques bàsiques són aquí

Podeu consultar a quins mòduls pot pertànyer un identificador mitjançant el cercador de l'API del Haskell Hayoo

Precisió dels tipus bàsics

Vegeu-ho a GHC#Precisió dels tipus bàsics

Estructures TAD genèriques

L'equivalent dels mòduls genèrics d'altres llenguatges (paramètrics en tipus), es concreta afegint variables de tipus a les classes com a paràmetres o bé com a tipus associats (famílies de tipus).

Els paràmetres de tipus que depenen d'altres paràmetres es poden expressar mitjançant

• o bé amb dependències funcionals
• o bé amb famílies de tipus associades a la classe, com a funció dels paràmetres de tipus de la mateixa, amb instruccions type (sinònims) o data, quin valor de tipus cal definir en instanciar la classe.

Amb classes multiparàmetre i dependències funcionals

A les classes multiparàmetre, quan hi ha paràmetres dependents, s'hi poden especificar dependències funcionals (restriccions en les relacions entre els paràmetres). Això comporta algunes ambigüitats.

La sintaxi de les dependències funcionals és:

| tip_col -> tip_elem , ..

indicant que una instància del tipus tip_col determina una única instància del tipus tip_elem.

<source lang="haskell"> {-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies, FlexibleInstances #-}

class Col_leccio tip_col tip_elem | tip_col -> tip_elem where

nova_col :: tip_col
inserta :: tip_elem -> tip_col -> tip_col
és_membre :: tip_elem -> tip_col -> Bool

-- per a tip_col = [tip_elem]

instance Eq tip_elem => Col_leccio [tip_elem] tip_elem where

nova_col     = []
inserta elt xs = elt : xs
és_membre elt []  = False
és_membre elt (x:xs)
 | elt == x  = True
 | otherwise  = és_membre elt xs

main = do

    let v1 = inserta 1 $ inserta 2 $ nova_col::[Int]
    print $ és_membre 2 v1
    print $ és_membre 5 v1

--

</source>

"Àlies de Tipus" associats a la classe

Nou. A partir de GHC 6.10.1. es pot reconvertir els paràmetres dependents en #famílies de tipus associades a la classe, (indexades pels paràmetres-de-la-classe), mitjançant "àlies de tipus" (clàusula type), solucionant els problemes d'ambigüitat de les dependències funcionals.

GHC admet declaracions type i data abstractes a les classes, concretables a la instanciació de les classes. Vegeu presentació i tipus associats a Famílies de tipus(Tipus indexats per tipus)

De l'exemple anterior, el tipus tip_elem determinat funcionalment per tip_col, passa a especificar-se type Element tip_col.

<source lang="haskell"> {-# LANGUAGE TypeFamilies #-}

class Col_leccio tip_col where

 type Element tip_col   -- àlies de tipus associat, amb param. tip_col
             -- llegit "Element de tip_col" o Element funció de tip_col
             -- és abstracte (sense def. "= ...") ; pendent de concretar a la instància.
 nova_col :: tip_col            
 inserta :: Element tip_col -> tip_col -> tip_col
 és_membre  :: Element tip_col -> tip_col -> Bool

-- per a tip_col = [tip_elem]

instance Eq tip_elem => Col_leccio [tip_elem] where

 type Element [tip_elem] = tip_elem     -- instància de (Element tip_col)

 nova_col = []
 inserta elt xs = elt : xs
 és_membre elt []  = False
 és_membre elt (x:xs)
   | elt == x  = True
   | otherwise  = és_membre elt xs

-- definició de l'op. pipeline de l'F# (.$) = flip ($)

main = do

 let v1 = (nova_col :: [Float])
          .$ inserta 2
          .$ inserta 1.5

 print $ és_membre 2 v1
 print $ és_membre 5 v1
 --

</source>

Imitant els functors de ML

Vegeu "Mòduls de primera al Haskell". i Functors a OCaml

• Amb classes i tipus associats i canviant l'agregació de llista a vector:

 cabal install vector   -- instal·lar paquet ''vector'' per a l'exemple

<source lang="haskell"> {-# LANGUAGE TypeFamilies, MultiParamTypeClasses, FlexibleInstances #-}

import Data.Vector as Vector

class Set tip_conjunt where -- signatura del model de Conjunt

 type Element tip_conjunt        -- Element és funció de tipconjunt

 buit :: tip_conjunt
 afegeix :: Element tip_conjunt -> tip_conjunt -> tip_conjunt
 enLlista :: 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
 buit = Vector.empty
 afegeix = \x xs -> Vector.cons x $ Vector.filter (/= x) xs
 enLlista = 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

ok = enLlista $ afegeix 1 conj_buit

---

-- Ampliació amb noves funcions

class (Set tip_conjunt) => SetHelp tip_conjunt where -- signatura noves funcions

 type ElementBis tip_conjunt       

 afegeixLlista :: tip_conjunt -> [ElementBis tip_conjunt] -> tip_conjunt

instance Eq tip_elemt => SetHelp (Vector tip_elemt) where -- estructura complementària

 type ElementBis (Vector tip_elemt) = tip_elemt

 afegeixLlista conjunt llista = Vector.foldr afegeix conjunt (Vector.fromList llista)

ok2 = enLlista $ afegeixLlista conj_buit [1,2]

main = do

       print ok
       print ok2

</source>

Temes avançats

Tipus de Dades Algebraics Generalitzats (GADTs)

Admeten diversificar el tipus de dades retornat. Vegeu Cal esmentar l'opció de compilació -XGADTs o la pragma equivalent {-# LANGUAGE GADTs #-}

• El guany és el refinament de tipus en fer l'encaix de patrons.

<source lang="haskell">

{-# LANGUAGE GADTs #-}

data Terme a where -- amb GADTs, els constructors no cal

                         --      que tornin tots el tipus definit
 Literal  :: Int -> Terme Int               -- tipus (Terme Int)
 Successor :: Terme Int -> Terme Int            -- tipus (Terme Int)
 EsZero   :: Terme Int -> Terme Bool           -- tipus (Terme Bool)
 SiCondició :: Terme Bool -> Terme a -> Terme a -> Terme a -- tipus (Terme a)
 Parell   :: Terme a -> Terme b -> Terme (a,b)      -- tipus (Terme (a,b))

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

</source>

newtype: tipus derivats

newtype permet fer abstracció d'un tipus preexistent mitjançant un nou tipus, sobre el qual podem definir noves operacions, o publicar-ne només una part (vegeu subsecció).

newtype defineix la nova abstracció mitjançant una estructura d'un sol component, en forma de registre. De fet els registres funcionen com els tipus producte posicionals amb els noms de camps com a funcions d'accés.

Queda definida una relació entre ambdós tipus. El constructor del registre constitueix una aplicació del domini del tipus del component al nou, i la funció accessora (nom del camp) constitueix l'aplicació inversa com es mostra a l'exemple.

• Caldrà però re-instanciar-ne les classes que el compilador no pugui derivar automàticament (clàusula deriving) (H98: especifica la derivació de Eq, Ord, Enum i Bounded). GHC permet ampliar aquesta llista com s'esmenta a la propera secció.

<source lang="haskell"> -- Sensor acotat

import Control.Exception (throw, ArithException( Overflow, Underflow))

newtype TSensor = Sensor {int_Des_De_Sensor :: Int} deriving (Eq, Ord, Show)

 -- un registre d'un sol camp defineix dues operacions de conversió de tipus inverses l'una de l'altra
 --    Sensor         :: Int -> TSensor    -- constructor
 -- int_Des_De_Sensor :: TSensor -> Int    -- inversa del constructor

-- Acotació instance Bounded TSensor where

 minBound = Sensor (-30)
 maxBound = Sensor 50

sumaAcotada :: TSensor -> TSensor -> TSensor

sumaAcotada x y | resultat > maxBound = throw Overflow

               | resultat < minBound = throw Underflow
               | otherwise = resultat
where
   resultat = Sensor (i + j)
   i = int_Des_De_Sensor x
   j = int_Des_De_Sensor y

valor = Sensor (-25) `sumaAcotada` Sensor (-10) main = print valor

</source>

etiquetar tipus bàsics

• newtype també pot servir per redefinir un tipus publicant (clàusula deriving) només una part de les operacions de l'original mitjançant les classes respectives:

GHC permet derivar automàticament les instàncies de més classes que el H98 (no totes) del tipus original al nou, per no haver de redefinir-les, especificant-les a la clàusula deriving, sempre que haguem esmentat l'extensió {-# LANGUAGE GeneralizedNewtypeDeriving #-}

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

-- fent que el compilador discrimini diferents elements que es poden comptar

newtype TPomes = Pomes Int deriving (Eq, Show, Ord, Num) newtype TPeres = Peres Int deriving (Eq, Show, Ord, Num)

valor = Pomes 2 + Peres 3 -- sumem TPomes i TPeres, error de tipus !! </source> dóna l'error:

  Couldn't match expected type `TPomes'
      against inferred type `TPeres'

Vegeu també

• "Keyword arguments in Haskell" (cat: "pas de paràmetres etiquetat per evitar errors de transposició de paràmetres")
• DrIFT Preprocessador de Haskell que automatitza la instanciació de classes no suportades pels compiladors a la clàusula "Deriving"
• Data.Derive Alternativa a DrIFT amb alguns avantatges. Manual.

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 Fletxes més avall

<source 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] }

--  Filtre  :: (a -> [b]) -> TFiltre   -- constructor
--  runFiltre :: TFiltre -> (a -> [b])   -- inversa_del_constructor

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

</source>

Fletxes

Efectes col·laterals basats en filtres. Vegeu Fletxa (programació funcional).

Vegeu i l'exemple sobre XML.

Compiladors que suporten Fletxes: GHC, Hugs

kind

És una restricció de tipus per als tipus, que dóna lloc a una nova categoria, que defineix un conjunt de tipus, així com els tipus defineixen un domini de valors.

El kind es pot definir, o bé amb una màscara, o bé com un conjunt de restriccions de context (kind Constraint).

La màscara té a veure amb l'aritat del tipus (nombre de paràmetres de tipus) explicitant el kind dels paràmetres d'ordre superior entre parèntesis.

expressió de tipus	kind	comentari
(Int -> Double) -> Int -> Double	(* -> *) -> * -> *	quan un dels paràmetres és una funció (ordre superior)
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 a un tipus, tenim un tipus d'aritat 0

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". Requereix extensió {-# LANGUAGE KindSignatures #-}

• Promoció de tipus: GHC facilita automàticament la promoció de tipus a Kinds i de constructors a constructors de Kind, amb l'extensió DataKinds.

<source lang="haskell"> data Nat = Zero | Succ Nat

-- és promogut a:

Nat :: BOX Zero :: Nat Succ :: Nat -> Nat </source>

<source 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)

</source>

kind Constraint

kind que defineix el conjunt de tipus per les restriccions de context que han de complir.

Hi ha 3 menes de restriccions:

• implementació de classe, com a (Show a)
• paràmetres implícits, com a (?x::Int) -- cal l'extensió ImplicitParams
• requeriment d'igualtat, com a (a ~ T b) -- amb l'extensió TypeFamilies o GADTs

A partir de GHC 7.4, un conjunt de restriccions adopta la categoria de kind Constraint i se li pot assignar un àlies.

<source lang="haskell"> (Show a, Read a) :: Constraint (?x::Int) :: Constraint (a ~ Int) :: Constraint

-- els podem assignar un àlies

type Textualitzable a = (Show a, Read a)

viaString :: Textualitzable a => a -> a viaString = read . show </source>

Famílies de tipus

Són una generalització dels tipus associats a les classes, i permeten una diversificació de l'estructura en instàncies per tipus de l'índex, així com les classes admeten una diversificació del comportament també en instàncies per tipus.

Designen un conjunt de tipus mitjançant un constructor de la família, i una variable anomenada l'índex i, opcionalment, una especificació de #kind, l'ordre del tipus.

Vegeu ref. Requereix l'extensió de llenguatge TypeFamilies. <source lang="haskell"> {-# LANGUAGE TypeFamilies, FlexibleInstances #-}

-- família de llistes data family XList t

-- instància de llista XList per al tipus Char data instance XList Char = XCons Char (XList Char) | XNil

                          deriving (Eq, Show)

-- instància de llista 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

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

</source> L'especificació de kind permet conèixer els paràmetres de tipus que cal afegir-hi: <source 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 </source> Quan la família es defineix en una classe, la instància de la família es defineix ensems amb la instància de la classe, llavors la paraula reservada instance seria redundant i no s'hi posa. <source 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 -> (Element t, t)

instance Pila [a] where

 type Element [a] = a    -- instància de la família de tipus
 buida = []
 apila = (:)  -- cons
 ésBuida = null
 daltIDesapila [] = error "daltIDesapila: error llista buida!"
 daltIDesapila (x : resta) = (x, resta)

</source>

Noves extensions als tipus

Vegeu novetats de GHC 7.4.1

tipus dependents de valors

Vegeu Glasgow_Haskell_Compiler#Tipus_dependents_de_valors

Afinant el rendiment

Modes d'avaluació d'expressions

Una expressió en HNF o WHNF possibilita diferir l'avaluació dels components no estrictes (sense prefix '!') de les estructures (data) que conté, mentre que en Forma Normal els components de les estructures estan completament avaluats.

Head Normal Form

La reducció a HNF d'una expressió deixa en suspens l'avaluació dels components de les dades.

Una expressió està en HNF si no té expressions beta-reduïbles Beta-Redexes en posició frontal (paràmetre actual substituïble en l'abstracció lambda). Els constructors no són substituïbles com a paràmetres i aturen l'avaluació HNF.

seq avalua a HNF

Weak Head Normal Form

La reducció a WHNF d'una expressió que conté funcions lambda, deixa en suspens l'avaluació del cos de les lambdes, a banda de deixar en suspens l'avaluació dels components de les dades.

Una expressió està en WHNF si està en HNF o és una abstracció lambda.

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

• Un Constructor, eventualment aplicat a expressions no reduïdes dels components
• Una funció aplicada a menys arguments del que correspon a la seva aritat
• Una abstracció lambda

evaluate de Control.Exception s'aplica en les computacions amb efectes col·laterals (tipus mònada) per forçar l'avaluació (a WHNF) d'una expressió.

Forma Normal

Una expressió està en forma normal si no s'hi poden aplicar més reduccions.

La classe NFData del paquet deepseq (a partir de GHC 7.4.1 forma part del conjunt bàsic de biblioteques de GHC) proposa una funció rnf (Reduce to Normal Form) per reduir les expressions que comencen per un constructor (tipus algebraics), avaluant a forma normal les expressions dels components.

Avaluació estricta explícita

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

Aplicació estricta (Crida per valor)

A les expressions amb l'operador d'aplicació estricta ($!) com a alternativa de ($) d'avaluació tardana.

f $! x = x `seq` (f x)  
-- (seq) avalua el primer operand (a HNF) i retorna el segon

Aplicació estricta a Forma Normal

($!!) amb dos signes '!' avalua l'operand amb deepseq a Forma Normal

f $!! x = x `deepseq` (f x)    -- cal que el tipus de 'x' implementi la classe NFData

Estrictesa als components dels tipus de dades

<source lang="haskell"> data T = C !T1 !T2 ... </source> Quan en una definició de tipus de dades es prefixa el tipus del component amb '!' l'avaluació de l'aplicació del constructor a una expressió (redex) corresponent al component es fa amb ($!) i si no hi ha el prefix '!' es fa amb ($).

Vegeu Eficiència i rendiment en tipus de dades

Estrictesa als paràmetres formals

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

f !x !y = 2 * x * y         -- avalua estrictament els paràmetres actuals (a WHNF)!

Estrictesa als patrons d'encaix

Lligams amb avaluació estricta a les variables dels patrons

let !v = expr   ...      -- avalua estrictament l'expressió (amb (seq))
let (!x, !y) = (exprX, exprY)   -- avalua les expr. dels components de l'encaix

foldl': iteracions amb plegat per l'esquerra estricte

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

<source lang="haskell">

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

</source>

<source lang="haskell"> import Data.List (foldl, foldl')

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

-- versió estricta, avaluació primerenca foldl' op estructInicial (x:xs) = let aplega_x = op estructInicial x

                                 in aplega_x `seq` foldl' op aplega_x xs

-- (seq) avalúa el primer operand i retorna el segon -- si el tipus de aplega_x és algebraic (conté constructors (aturen l'avaluació))) -- caldrà utilitzar deepseq (que avalua a forma normal) en comptes de seq </source>

Treballar a espai constant de la pila

El llibre RealWorldHaskell esmenta que (seq) avalua a WHNF (redueix substituint tots els paràmetres aplicables de la funció més externa, però no en redueix el cos) i s'atura en els contructors (no en redueix les expressions dels components). Degut a això, per treballar a espai constant de la pila, si operem sobre una estructura de tipus algebraic (amb Constructors), caldria avaluar completament l'acumulador, o bé marcant estrictesa explícita als tipus dels components acumuladors (prefix !) o bé amb deepseq a #Forma Normal en comptes de seq.

-- o bé: (data T = C !T1 !T2 ...)   -- '!' als comp. del tipus de l'acumulador (les expr. seran avaluades amb ($!))
-- o bé: op !acc y = op' acc y    -- avaluació a HNF de l'acumulador 
-- o bé: op acc y = acc `deepseq` op' acc y    -- avaluació a forma normal de l'acumulador (paquet ''deepseq'')

Estrictesa en les crides recursives

Vegeu "Recursivitat final al Haskell".

• La "recursivitat final mòdulo cons" (quan la crida recursiva és en el component d'una dada que es retorna) correspon a recursivitat diferida expressament.

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

Allotjament directe o Unboxed (No encapsulat)

Allotjament directe (unboxed) dels valors de tipus escalars

GHC designa els tipus escalars amb allotjament directe del valor, afegint un signe # al darrera: Int#, Float#, Double#

Cal, però, especificar la pragma d'extensió de llenguatge {-# LANGUAGE MagicHash #-} per poder afegir el # als identificadors.

Encapsulat o boxed: Sense # els objectes contenen un punter a una "càpsula" que és una estructura en memòria dinàmica amb valor, descripció del tipus, etc.

En cas de vectors, pot estalviar un nivell d'adreçament en els valors i millorar el rendiment del programa.

Hi ha però restriccions, entre d'altres, no es poden emprar valors unboxed (sense descripció de tipus) a les funcions polimòrfiques.

Literals unboxed: 4# 3.2# 'c'#

De unboxed a boxed:

• el tipus de 4# és Int# ;

• Amb el constructor I# de GHC.Exts, el tipus de (I# 4#) és Int

Vegeu i el farragós exemple següent:

<source lang="haskell"> {-# LANGUAGE MagicHash #-} import GHC.Exts (Int#, Int (I#)) import GHC.Prim ((*#),(-#), (==#), (>#))

fact_rf :: Int# -> Int# -> Int# fact_rf acum n

 | n ==# 0# = acum
 | n ># 0# = fact_rf (acum *# n) (n -# 1#)

imprimeix :: Int# -> IO () imprimeix unboxed_int = do

  putStrLn $ "resultat " ++ show (I# unboxed_int) -- de unboxed a boxed aplicant el constructor

main = do

 let !(I# unboxed_int) = 5::Int   -- de boxed a unboxed per encaix (requereix estrictesa(!))
 imprimeix $ fact_rf 1# unboxed_int

</source>

La pragma UNPACK aporta una optimització similar.

<source lang="haskell"> data T = T {-# UNPACK #-} !Float

          {-# UNPACK #-} !Float

</source>

tuples unboxed per al retorn de múltiples valors

Les tuples unboxed

(# a, b #)

són un capítol a part i s'utilitzen per retornar més d'un valor alhora, sense allotjar la tupla a la memòria dinàmica. Cal especificar l'extensió de lleng. UnboxedTuples i l'opció -fobject-code (codi nadiu, doncs a codi intermedi (bytecode) no compila).

<source lang="haskell"> -- fitxer tuples-no-encapsulades.hs {-# OPTIONS_GHC -fobject-code #-} {-# LANGUAGE UnboxedTuples #-}

f x y = (# x+1, y-1 #) -- retorn amb tupla no encapsulada

g x = case f x x of

   (# a, b #) -> a + b  -- obrim la tupla per encaix del patró (# ... #)

main = do

    let y = g 5
    putStr "y = "
    print y

</source>

Compilació i exec.

ghc—make tuples-no-encapsulades.hs
./tuples-no-encapsulades

Vectors més eficients

Vectors mudables i amb allotjament directe (no encapsulat) dels elements.

Als vectors d'elements no encapsulats (Unboxed) no cal passar-los els elements amb el sufix #

• En memòria local amb la mònada (ST s a) i tipus del vector: (STUArray s tipus_de_l_índex tipus_de_l_element).

el tipus de l'índex ha d'implementar la classe Ix igual que els vectors de la def. del 98.

<source lang="haskell">

import Control.Monad.ST import Data.Array.ST

obtenirParell :: ST s (Int, Int) -- a la mònada (ST s a) (param. s lliure === allotjament local) obtenirParell = do

    -- vector de sencers unboxed STUArray amb índex sencer (1 a 10) inicialitzat a 37

    -- 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) -- :: entre parèntesis el contingut de la mònada
    a <- readArray arr 1
    writeArray arr 1 64
    b <- readArray arr 1
    return (a,b)

main = do

    let x = runST obtenirParell
    print x

</source>

• En memòria global amb la mònada IO i tipus del vector: (IOUArray tipus_de_l_índex tipus_de_l_element)

<source lang="haskell">

import Data.Array.IO

obtenirParell :: IO (Int, Int) obtenirParell = do

    -- vector de sencers unboxed IOUArray amb índex sencer (1 a 10) inicialitzat a 37

    -- 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)
       a <- readArray arr 1
       writeArray arr 1 64
       b <- readArray arr 1
       return (a,b)

main = obtenirParell >>= print

</source>

Cadenes de text més eficients

Amb cadenes implementades com a vector i no com a llista.

• amb vectors de caràcters de 16 bits (UTF16) definits a la biblioteca "text"

<source lang="haskell">

1. if __GLASGOW_HASKELL__>=612

import System.IO (stdout, hFlush)

-- amaguem les funcions predefinides per a String que volem Text (vector de UTF16)
-- 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
text2 = pack "comença per "

main = do
    putStr text1
    hFlush stdout

    x <- getLine
        case uncons x of          -- uncons :: Text -> Maybe (Char, Text)
         Just (lletra, _resta) -> do
                        putStr text2
                        putStrLn $ singleton lletra  -- singleton :: Char -> Text

         Nothing -> putStrLn $ pack "entrada buida"

1. else

 #error "no provat en versions anteriors"

1. endif

</source>

compilant amb preprocés

runhaskell -cpp prova.hs

L'extensió OverloadedStrings permet fer servir literals de tipus String com a valors de tipus que n'implementin la conversió, instanciant la classe IsString.

Especialització d'operacions sobrecarregades

L'especialització es fa servir per millorar el rendiment en les operacions sobrecarregades, quan es fan servir molt amb un tipus concret. Cal especificar la pragma SPECIALIZE.

<source lang="haskell">

factorial :: (Num a, Ord a) => a -> a factorial 0 = 1 factorial n

| n > 0 = factorial_rf 1 n
| otherwise = error "n no pot ser negatiu"
where
       factorial_rf acum n 
             | n == 1 = acum
             | n > 1  = factorial_rf (acum * n) (n-1)

{-# SPECIALIZE factorial :: Int -> Int #-} {-# SPECIALIZE factorial :: Integer -> Integer #-}

</source>

-- en detectar el compilador el tipus esmentat a la pragma, genera versions no sobrecarregades, més eficients, de la funció.

Biblio ràpida de contenidors

A GHC.

Problemàtiques

El problema de la manca d'informació de situació en les petades

Quan una funció definida parcialment, crida la funció error, el programa peta oferint, escassament, el missatge de la funció error, sense més pistes. A partir de GHC 7.4.1 s'ha incorporat, només quan es compila amb opcions de perfilat, un sistema de pila de crides, amb bolcat en cas d'excepció.

Exposició i alternatives a GHC.

El problema de les configuracions

L'accés, des del codi funcional, a variables globals carregades en temps d'execució es pot abordar des de diverses perspectives, cap d'elles plenament satisfactòria.

• Amb la mònada Reader que proporciona accés a variables d'entorn d'un entorn canviant. Desavantage: no-accessible des del codi funcional, caldrà, llavors, passar-lo com a paràmetre.
  • Intent de sol·lució mitjançant paràmetres implícits: Desavantatge: cal propagar el paràmetre implícit a totes les declaracions de tipus de les rutines intermèdies.
• Accedint via unsafePerformIO, assegurant-se bé que l'escriptura de les variables ha estat avaluada ("the unsafePerformIO hack"). Desavantatge: hi ha el risc que les ops. no s'efectuïn en l'ordre correcte si no se'n controla bé l'avaluació.
• Altres sistemes més sofisticats:
  • Segons Joachim-Breitner
  • Segons Oleg Kiseliov i Chung-chieh Shan

Una soŀlució: El hack unsafePerformIO

hack, en informàtica, segons la viqui. anglesa vol dir "sol·lució poc elegant però que permet sortir del pas", aquí en diríem "un pedaç".

unsafePerformIO és la porta del darrera de la mònada IO. Permet accedir a variables globals des del codi funcional, però l'ordre de les ops. dependrà del moment que se n'avaluï el thunk corresponent. (Vegeu "IO inside: The dark side of the IO Monad".) <source lang="haskell"> unsafePerformIO :: IO a -> a </source>

• per emprar amb seguretat unsafePerformIO en el codi funcional, cal que l'acció no-funcional mantingui la idempotència (no tingui efectes col·laterals i sigui independent de l'entorn).

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

-- funció de unit () per evitar la memoització de les crides sense paràmetres {-# NOINLINE llegeix #-} llegeix :: () -> Int llegeix _ = unsafePerformIO $ readIORef intRef

llegeix_100_cops :: () -> [Int] llegeix_100_cops _ = replicate 100 $ llegeix ()

main = do

       -- cal que l'escriptura sigui avaluada 
       --    que no sigui part d'un càlcul amb resultat NO requerit
       writeIORef intRef 42
       print $ llegeix_100_cops ()
       writeIORef intRef 30
       print $ llegeix_100_cops ()

</source>

El problema del sobreiximent de la pila (Stack overflow)

L'ús del "plegat per l'esquerra estricte" foldl' no garanteix que es treballi a espai constant de la pila.

En cas de funcions amb recursivitat final,

• les expressions (o variables definides localment) en la crida recursiva generen thunks pendents d'avaluar, que s'apilen mentre no s'arriba al cas no recursiu.
• l'avaluació estricta (amb '!' BangPatterns (a WHNF)) en els paràmetres acumuladors tampoc ho garanteix, si l'avaluació es topa amb un constructor.

Vegeu "Stack overflow" al HaskellWiki i la secció #Avaluació estricta explícita (treballar a espai constant de la pila). També "Retainer profiling" per investigar "Perquè l'avaluació d'un objecte és retinguda"

La soŀlució més fàcil és que el tipus de l'acumulador algebraic estigui definit estricte (prefix '!') en tots els seus components.

Altrament el paquet deepseq aporta funcions d'avaluació a #Forma Normal que sobrepassen les limitacions de seq. El paquet deepseq-th facilita la derivació d'instàncies NFData, només per als tipus algebraics. Altrament caldrà instanciar-la manualment, definint la funció rnf de manera que per cada constructor n'avaluï tots els components.

<source lang="haskell"> -- deepseq: versió de seq que avalua també els components -- dels tipus de dades, si aquests instancien NFData, -- derivable, si el tipus és algebraic, amb el paquet deepseq-th. deepseq :: NFData a => a -> b -> b </source>

El problema de les fugues de memòria

Vegeu enllaços "Memory leaks", "Space leak zoo"

Vegeu també: "GHC: Perfilant l'ús de memòria".

Exemples

Encapsulament estil O.O.

Cercant una aproximació funcional (amb immutabilitat) a l'encapsulament de la orientació a objectes i simulació d'herència de propietats del component: <source lang="haskell"> -- Sigui un TipusEspecialitzat en forma de registre -- que conté un component amb nom de camp super -- propagarem una Propietat del tipus del super

instance PropietatDelSuper TipusEspecialitzat where

 getProp TipusEsp_Constructor1 {super} = getProp super
 setProp p1 p2 obj @ TipusEsp_Constructor1 {super} = obj {super = setProp p1 p2 super}

</source>

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

<source lang="haskell"> data TPunt2D = Punt2D { x,y ::Int} -- especialització estructural per composició data TPunt3D = Punt3D { punt2D :: TPunt2D, z :: Int} </source>

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)

amb especialització de comportament per classes de tipus (interfícies)

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

</source> <source lang="haskell"> -- fitxer ClassesBasadesEnPropietats.hs -- Especialització per Interfícies -- -- En estar desacoblades dels tipus de dades data -- no caldrà repetir-ne els mètodes a les instàncies -- module ClassesBasadesEnPropietats (IFun2D(..), IFun3D(..)) where

import ClassesPropietats

-- funcionalitat 2D

class (PropXY t) => IFun2D t where

 desplaça2D :: Int -> Int -> t -> t
 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
 desplaça3D dx dy dz punt = setZ (z+dz) $ desplaça2D dx dy punt
   where
     z = getZ punt

</source>

• (IFun2D t) requereix (PropXY t)
• (IFun3D t) requereix (IFun2D t, PropZ t)

<source lang="haskell"> -- fitxer Punt2D.hs per al tipus TPunt2D {-# LANGUAGE NamedFieldPuns #-} -- sintaxi de l'encaix de registres simplificada module Punt2D (TPunt2D, nouPunt2D) where

import ClassesPropietats import ClassesBasadesEnPropietats

data TPunt2D = Punt2D { x,y ::Int} deriving (Eq, Show)

-- generadors nouPunt2D :: Int -> Int -> TPunt2D nouPunt2D x y = Punt2D { x, y} -- {x} equival a {x=x} amb l'extensió NamedFieldPuns -- o també amb inicialització posicional -- nouPunt2D = Punt2D

-- propietats instance PropXY TPunt2D where

 getXY (Punt2D {x,y}) = (x, y)
 setXY x y p = p { x, y}    -- {x, y} al cos equival a {x = x, y = y}

instance IFun2D TPunt2D -- incorpora funcionalitat 2D </source> <source lang="haskell"> -- fitxer Punt3D.hs per al tipus TPunt3D {-# LANGUAGE NamedFieldPuns #-} -- sintaxi de l'encaix de registres simplificada module Punt3D (TPunt3D, nouPunt3D) where

import ClassesPropietats import ClassesBasadesEnPropietats

import Punt2D (TPunt2D) import qualified Punt2D as P2D

-- definició de (.$) (estil flux de dades) com (|>) a l'F# (F sharp) (.$) = flip ($)

data TPunt3D = Punt3D { punt2D :: TPunt2D, z :: Int} deriving (Eq, Show)

-- generador nouPunt3D :: Int -> Int -> Int -> TPunt3D nouPunt3D x y z = Punt3D { punt2D = P2D.nouPunt2D x y, z}

-- propietats instance PropXY TPunt3D where

 getXY (Punt3D {punt2D}) = getXY punt2D
 setXY x y punt @ (Punt3D {punt2D}) = punt {punt2D = punt2D .$ setXY x y}

instance PropZ TPunt3D where

 getZ (Punt3D {z}) = z    -- a l'encaix {z} equival a {z = z}
 setZ z punt = punt {z}   -- al cos també, {z} equival a {z = z}

-- funcionalitat addicional instance IFun2D TPunt3D -- incorpora funcionalitat 2D instance IFun3D TPunt3D -- incorpora funcionalitat 3D </source>

prova:

<source lang="haskell"> -- fitxer Main.hs module Main where

import ClassesPropietats import ClassesBasadesEnPropietats import Punt2D import Punt3D

-- definició de (.$) (com l'op. (|>) pipeline de F#) estil navegació de dades. (.$) = flip ($)

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

</source>

execució

runhaskell Main

especialització d'implementacions amb instanciació genèrica

Separant la implementació del subtipatge (especialització d'interfícies). Vegeu ref. "OOP vs type classes"

La relació de requeriment en l'especialització per classes es converteix en una relació d'implicació en l'especialització per instàncies, fent innecessària la instanciació particular de cada tipus. <source lang="haskell"> -- Amb classes + instanciació particular a cada tipus class (PropXY t) => IFun2D t where ... -- (IFun2D t) requereix (PropXY t)

-- Amb classes + instanciació genèrica instance (PropXY t) => IFun2D t where ...

 -- per tant, per tot tipus t tal que (PropXY t), també implementa (IFun2D t)
 --   dit d'altra manera, a partir d'aquí: (PropXY t) implica (IFun2D t)

</source>

Modificacions a l'anterior exemple (caldran les extensions de llenguatge FlexibleInstances, UndecidableInstances): <source lang="haskell"> -- fitxer ClassesBasadesEnPropietats.hs -- -- Especialització entre instàncies -- {-# LANGUAGE FlexibleInstances, UndecidableInstances #-} module ClassesBasadesEnPropietats (IFun2D(..), IFun3D(..)) where

import ClassesPropietats

-- funcionalitat 2D

class IFun2D t where

 desplaça2D :: Int -> Int -> t -> t
     

instance (PropXY t) => IFun2D t where

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

-- funcionalitat 3D

class IFun3D t where

 desplaça3D :: Int -> Int -> Int -> t -> t
     

instance (IFun2D t, PropZ t) => IFun3D t where

 desplaça3D dx dy dz punt = setZ (z+dz) $ desplaça2D dx dy punt
   where
     z = getZ punt

</source>

• (PropXY t) implica (IFun2D t)
• (IFun2D t, PropZ t) implica (IFun3D t)
• caldrà eliminar les declaracions d'instàncies IFun2D i IFun3D dels fitxers Punt2D.hs i Punt3D.hs, que es basen en mètodes per defecte de les classes, que aquí ja no hi són.

-- fitxer Punt2D.hs

instance IFun2D TPunt2D

-- fitxer Punt3D.hs

instance IFun2D TPunt3D

instance IFun3D TPunt3D

execució, amb el mateix resultat:

runhaskell Main

Tipus existencial - Emulació del despatx dels mètodes virtuals de la O.O.

Vegeu ref. El tipus existencial (designen un cjt de tipus amb característiques pròpies) dóna sol·lució al tractament de col·leccions heterogènies incorporant els elements heterogenis com a components amb quantificació existencial (caracteritzats per implementar, com a mínim, classes de tipus específiques), sense trencar la homogeneïtat de les llistes.

<source lang="haskell"> module Forma (CForma(..)) where

class CForma t where

 perímetre :: t -> Double
 àrea :: t -> Double
 nom :: t -> String

</source>

<source lang="haskell"> module Cercle (TCercle, cercleNou) where

import Forma (CForma(..))

type TRadi = Double

data TCercle = Cercle TRadi deriving (Eq, Show)

cercleNou :: TRadi -> TCercle cercleNou = Cercle

instance CForma TCercle where

 perímetre (Cercle r) = 2 * pi * r
 àrea (Cercle r) = pi * r ^ 2
 nom _ = "Cercle"

</source>

<source lang="haskell"> module Rectangle (TRectangle, rectangleNou) where

import Forma (CForma(..))

type TCostat = Double

data TRectangle = Rectangle TCostat TCostat deriving (Eq, Show)

rectangleNou :: TCostat -> TCostat -> TRectangle rectangleNou = Rectangle

instance CForma TRectangle where

 perímetre (Rectangle x y) = 2 * (x + y)
 àrea (Rectangle x y) = x * y
 nom _ = "Rectangle"

</source> <source lang="haskell">

-- fitxer existquant.hs
{-# LANGUAGE ExistentialQuantification #-}

import Forma (CForma(..)) import Cercle (cercleNou) import Rectangle (rectangleNou)

import Control.Monad as Monad import Text.Printf

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

-- llista de valors del tipus existencial

formes :: [TForma] formes = [Forma (cercleNou 2.4), Forma (rectangleNou 3.1 4.4)]

-- definició de (.$) com l'operador pipeline (|>) de l'F# (estil flux de dades)

(.$) = flip ($)

-- forM_ mapeja sequencialment als elems. de la llista una func.
--                  amb efectes col·laterals de tipus mònada (m tipResultat), descartant resultats.

main = do

 Monad.forM_ formes $ \forma -> do
     printf format (forma .$ nom) (forma .$ perímetre) (forma .$ àrea)
 where    
   format = "Forma %s, perímetre %.2f, àrea %.2f\n"    

</source>

runhaskell existquant.hs

dóna la següent sortida:

Forma Cercle, perímetre 15.08, àrea 18.10
Forma Rectangle, perímetre 15.00, àrea 13.64

Entrada / Sortida amb descriptor regionalitzat

withFile / withBinaryFile (de System.IO) obre el fitxer, en passa el descriptor a la funció que executa l'entrada/sortida (Handle -> IO r) i, en retornar el control o en cas d'excepció, tanca el fitxer alliberant recursos. Basat en la clàusula bracket a la secció #excepcions.

• Evita l'ús del descriptor "handle" (mànec) del fitxer més enllà del retorn (recurs circumscrit a l'àmbit o "regionalitzat").

Vegeu també mònades per a l'allotjament de recursos en regions apilades

<source 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ó com a resultat 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 la func. que retorna tipus mònada als arguments, descartant resultat
     _ -> Monad.mapM_ processa_nom_fitxer args

-- fi de prova.hs

</source>

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

Concurrència simple amb MVars - Productor-consumidor

Vegeu-ho a Haskell concurrent

Cues d'entrada (Chan) - Client-servidor

Vegeu exemple a Haskell concurrent

Paral·lelisme de tasques - Compilació per a processadors multicor

Només a GHC. Vegeu Glasgow Haskell Compiler#Paral·lelisme de tasques - Compilació per a processadors multicor.

Concurrència condicionada amb TVars - Mònada STM - Memòria transaccional

Vegeu exemple a Haskell concurrent

Exemples de Fletxes (filtres amb efectes col·laterals)

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)

Quasi-Quotations: Plantilles per a expressions, patrons, tipus i declaracions

Vegeu Glasgow_Haskell_Compiler#Quasi-Quotations

Paraŀlelisme

Vegeu Glasgow_Haskell_Compiler#Paral·lelisme de tasques - Compilació per a processadors multicor

Amb Estratègies

Vegeu Glasgow_Haskell_Compiler#Estratègies

Amb la mònada Par

Vegeu Haskell_concurrent#Encadenament de càlculs simultanis - la mònada Par

Amb paraŀlelisme de dades DPH

Vegeu QuickSort amb Data Parallel Haskell

Gestor de paquets de biblioteques i aplicacions

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

Aquest gestor es diu Cabal i utilitza arxius de descripció de paquets amb l'extensió ".cabal". Vegeu "Com crear un paquet"

El nom del paquet consta de nom-versió, per ex. shakespeare-css-1.0.1.2, on la versió major són els dos primers components numèrics i la versió menor és el tercer. L'API d'un paquet s'identifica per la versió major.menor (tres components numèrics).

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

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

El rebost oficial de biblioteques i aplicacions és el Hackage

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

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

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

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

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

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

--constraint="nom_biblio < versió" o --constraint=nom_biblio==versió (l'API s'identifica per 3 components de la versió)
exemples (les cometes només fan falta si hi ha espais o bé
           símbols de redirecció de l'intèrpret de comandes {<,>}):
cabal install QuickCheck --constraint=BiblioDeLaQualDepen==2.3.4.*

• a partir de cabal-install v.1.16 cabal admet paraŀlelisme en l'instaŀlació

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

Conflictes de dependències

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

Entorn aïllat (sandboxed) de desenvolupament amb cabal-dev

cabal-dev crea un dipòsit de biblioteques específic del projecte en el subdirectori ./cabal-dev

els executables queden al directori ./cabal-dev/bin

es pot reutilitzar un mateix dipòsit, creant el subdirectori ./cabal-dev com enllaç a un altre directori cabal-dev, per exemple:

ln -s $HOME/webs/yesod/cabal-dev cabal-dev

cabal-dev com a prefix, passa el dir. dels dipòsits a d'altres comandes:

cabal-dev ghc-pkg list

Resolució multi-projecte amb cabal-meta

cabal-meta permet la resolució conjunta de dependències, en la instaŀlació conjunta de diversos subprojectes i paquets (del hackage o de directoris locals o bé remots (git)) especificats en un o més fitxers sources.txt adreçats en arbre, on cada línia pot contenir un directori de projecte local, remot (git/http), paquet del hackage, o subllista sources.txt:

• cas de començar per '.' o bé '/': directori de subprojecte cabal (seguit d'opcions), o bé directori que conté un altre fitxer "sources.txt" de subllista. (les opcions són flags per al cabal)
• cas de prefix "git:", "https", "http": gitLocation gitBranca? opció*, és a dir, projecte recuperable amb git (sistema de control de versions distribuït)(les opcions són flags per al cabal)
• altrament: paquet-del-hackage opció*

ús: cabal-meta --dev install (especificant --dev segueix les directrius de cabal-dev en dipòsits i instal·lació d'executables.

Creació del fitxer de projecte .cabal

El fitxer de projecte .cabal està relacionat un a un amb la carpeta que el conté.

cabal init

interroga l'usuari a la cònsola de comandes i genera un esquelet de projecte que caldrà editar posteriorment per afegir-hi els noms dels fonts i els paquets dels quals depèn.

leksah

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

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

cabal clean       -- neteja tots els fitxers generats per la compilació
  -- ''cabal-dev'' treballa sobre un rebost de biblioteques específic del projecte
  --         caldrà incorporar la subcarpeta cabal-dev/bin a la var. PATH 
cabal-dev install     -- configura, compila, relliga i instal·la al rebost del projecte
cabal install -- configura, compila, relliga i instal·la al rebost de l'entorn d'usuari

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

Eines relacionades amb el gestor de projectes

cabal-dev

versió de cabal que crea un dipòsit de biblioteques específic del projecte que es desenvolupa, per evitar conflictes amb els paquets de biblioteques de l'usuari. Vegeu ampliació a GHC#Eines.

cabal-meta

instaŀla (amb cabal-dev cas de --dev), en una sola comanda (resolució conjunta de dependències) diversos paquets (del hackage o de directoris locals o bé remots (git)) especificats en un o més fitxers sources.txt encadenats en arbre. Vegeu ampliació a GHC#Eines.

cabal-ghci

engega ghci preparant-lo per a proves del projecte, amb camins i extensions de llenguatge obtinguts del fitxer de projecte .cabal

cabal-progdeps

llista les dependències en un directori de projecte

yackage

servidor de rebost "hackage" local per a desenvolupament

The Haskell Platform

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

Entorns de desenvolupament i altres eines

hlint

Aquí analitzador de codi amb suggerències de millora. Avisa de construccions redundants i proposa alternatives al codi.

Leksah

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

eclipseFP

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

Visual Haskell 2005

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

ThreadScope

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

hpc (haskell program coverage)

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

hp2any

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

hgettext

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

Implementacions

Vegeu

GHC ("Glasgow Haskell Compilation System")

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

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

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

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

Hugs

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

nhc98

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

UHC / EHC

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

YHC

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

JHC

Jhc Haskell Compiler Compilador de John Meacham. (Opinió sobre JHC)

LHC

LHC Haskell Compiler Projecte derivat del JHC.

Extensions de noms de fitxer

Vegeu enllaç

.hs

Haskell source

.lhs (Literate haskell source)

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

• o bé dins un doc. de text, prefixant les línies de codi amb '>' (estil rastre d'ocell)
• o bé dins un doc. LaTeX situant el codi entre \begin{code} i \end{code} Vegeu lhs2tex

.cabal

descripció de paquet Cabal

.x

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

.lx

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

.y

doc. d'entrada per al generador d'analitzadors gramaticals Happy (de l'estil del yacc) (genera *.hs)

.ly

doc. Happy literari (a l'estil del .lhs)

.gh

preprocessador Generic Haskell

.gc

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

.chs

doc. d'entrada al convertidor c2hs

.hsc

doc. d'entrada al convertidor hsc2hs

Plataformes, aspectes

plataformes virtuals

sobre Xen

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

sobre LLVM (Low Level Virtual Machine)

• GHC pot compilar via LLVM per aprofitar-ne les optimitzacions. Comproveu-hi les "Plataformes suportades"

sobre JVM

• Frege: llenguatge quasi Haskell adaptat als tipus de dades i entorn del Java que funciona sobre el JDK de Java-7.
• LambdaVM: Rerefons JVM per al compilador GHC
• UHC Jazy: Rerefons JVM per al compilador UHC. (implementació parcial).

sobre JavaScript

• Yrc2Js: Rerefons a Javascript del compilador YHC.
• UHC: Rerefons (en desenvolupament) de l' "Utrecht Haskell Compiler"

sobre CLR

• Rerefons CLR del compilador UHC

Altres plataformes

A sistemes d'Apple (Mac OS, iOS)

• IPhone al HaskellWiki (anglès) Recursos i suport per treballar amb Haskell a l'IPhone.
• Haskell al Mac (anglès)
• Haskell en un projecte Cocoa-Xcode (anglès)
• HOC: A Haskell to Objective-C Binding (anglès)

Dialectes del Haskell

DDC (The Disciplined Disciple Compiler)

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

OOHaskell

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

O'Haskell

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

Timber

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

Hume

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

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

CAL

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

Jaskell

llenguatge sobre la Java VM, funcional i d'avaluació tardana, força diferent en sintaxi.

Frege

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

Relacionat

• Haskell concurrent
• Mònada (programació funcional)
• Fletxa (programació funcional)

• Compilador Haskell de Glasgow
• Intèrpret Hugs
• Frege (llenguatge de programació)

Enllaços externs

• Haskell - Lloc web oficial
• Gmane - Fòrums de Haskell (anglès)
• Haskellers.com (anglès) Punt de trobada de programadors en Haskell.
• Univ. de Girona -- Programació funcional - Haskell