PROGRAMARE FUNCȚIONALĂ

Curs 7

Introducere în Haskell ‘98

prin exemple
Dan V. Popa
Clase de prioritate a operatorilor
Operatorii standard sunt grupaţi în 10 clase
de prioritate – astfel Haskell stabileşte
corect ordinea operaţiilor dintr-o expresie;
Cu ajutorul operatorilor standard se pot defini
alţi operatori, de exemplu operatorul ++
pentru concatenarea a două liste este
definit cu ajutorul operatorului cons “:”
Pentru operatorii definiţi de utilizator trebuie
precizat nivelul de prioritate şi tipul de
asociere!
e.g. infixr 5 <operator>
Numele operatorului infixat trebuie să
înceapă cu caracterul ‘:’.
Clase de prioritate a operatorilor
Verifică!
R9 . Verifică!
> :t (^) > :m +Data.Ratio
L9 !! > :t (^^) simplifying Data.Ratio> 16 % 12
R8 ^ ^^ ** > :t (**) of fractions Data.Ratio> ☺
L7 * / `quot` `rem` `div` `mod` %
L6 + -
∈ ∉
R5 :
R4 == /= <= < >= > `elem` `notElem`
R3 &&
R2 ||
L1 >> >>= -- operatori pentru scrierea operaţiilor dintr-o monadă
R1 =<< -- operatori pentru scrierea operaţiilor dintr-o monadă
R0 $ $! `seq`
Problemă
[DVPopa]

Să se definească o funcţie care

primeşte ca parametru un string de
cifre şi calculează valoarea întregului
format cu cifrele respective.
Compunerea tipurilor.
Constructori de tip predefiniţi
Matematic
f : Z → Z, f(x) = x + 1
Haskell
f :: Integer -> Integer, f x = x+1
 f este o entitate de tipul Integer -> Integer
 tipul Integer -> Integer este un tip compus
 simbolul -> este un constructor de tip – defineşte
un nou tip (tipul unei funcţii) prin îmbinarea a
două tipuri
Observaţie. Alţi constructori de tip sunt:
 [ ] – pentru definirea listelor şi
 ( ) – pentru definirea tuplelor
Compunerea tipurilor.
Constructori de tip predefiniţi
e.g. Operator de însumare. Se cere suma valorilor unei
funcţii pe un interval dat:
max

∑ f ( x)
x = min

f :: Integer -> Integer

f x = x+1

sigma :: Integer -> Integer -> (Integer -> Integer ) -> Integer
sigma min max f | min == max = f min
| min < max = (f min) + (sigma (min + 1) max f)
| min > max = 0

Discuţie despre funcţia sigma...

Compunerea tipurilor.
Constructori de tip predefiniţi
Apeluri WinGHCi:

Main> (\x -> x+1) 1

2
Main> (\x -> x * x) 5
25
Main> (\x y -> x+y) 2 3
5
Main> (\g x -> g x) f 1
2
Main> sigma 1 4 (\x -> 2)
8
Main> sigma 1 4 (\x -> x * x)
30
Compunerea tipurilor.
Constructori de tip definiţi de utilizator
Una din soluţiile cele mai folosite de utilizator pentru
definirea unui nou tip de date foloseşte tipul
reuniune.
Tipurile reuniune sunt tipuri de date utilizator dotate cu
mai mulţi constructori de date. Pot exista mai multe
feluri de date, fiecare cu constructorul ei şi ele sunt
toate incluse în acelaşi tip reuniune.
Caracterul specific pentru “reuniunea” de constructori
de date este ‘|’.

Constructorii de tip definiţi de utilizator sunt daţi de

identificatori scrişi cu majusculă (pentru a îi deosebi
de funcţii).
Compunerea tipurilor.
Constructori de tip definiţi de utilizator
e.g. Constructor pentru tipul de date Ziua

data Ziua = Luni | Marti | Miercuri | Joi | Vineri | Sambata | Duminica

maine :: Ziua -> Ziua

maine Luni = Marti
maine Marti = Miercuri

data2str :: Ziua -> String

data2str Luni = "Luni"
data2str Marti = "Marti“

Observaţie. Constructorii de tip definiţi de utilizator sunt

scrişi cu majusculă (pentru a îi deosebi de funcţii).
Compunerea tipurilor.
Constructori de tip definiţi de utilizator

Apeluri WinGHCi:

Main>maine Luni
<interactive>:1:0:
No instance for (Show Ziua)
arising from a use of `print' at <interactive>:1:0-9
Possible fix: add an instance declaration for (Show Ziua)
In a stmt of an interactive GHCi command: print it
Main>data2str (maine Luni)
"Marti"
(0.00 secs, 0 bytes)
Main>
Tipuri sinonime
Tipurile sinonime se introduc în Haskell pentru a
simplifica scrierea tipurilor.
Definirea tipurilor sinonime constă în asocierea unui
nume sugestiv pentru un tip de date
complex/complicat deja definit, dar care este folosit
des în aplicaţie.
Cuvântul rezervat care introduce sinonimul este type.
e.g.
type String = [Char]
type Persoana = (Nume, Adresa)
type Nume = String
type Adresa = Necunoscuta | Adresa String
Exemplul 1
[Daumé, page 48]
data Triple a b c = Triplet a b c

tripleFst :: Triple a b c -> a

tripleFst (Triplet x y z) = x

tripleSnd :: Triple a b c -> b

tripleSnd (Triplet x y z) = y

tripleThrd :: Triple a b c -> c

tripleThrd (Triplet x y z) = z
-------------------------------------------------------------------------------------------
data – introduce un tip de date
Triple – numele tipului de date
a b c – variabile tip – parametrii tipului de date Triple
Triplet – constructorul de date pentru tipul Triple
Exemplul 1
[Daumé, page 48]
data Triple a b c = Triplet a b c

tripleFst :: Triple a b c -> a

tripleFst (Triplet x y z) = x
--------------------------------------------------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------------------------------------------------------------------------
---------------------------

> tripleFst (Triplet 1 2 3)

> tripleFst (Triplet ‘1’ 2 3)
> :t tripleFst
> :t tripleFst (Triplet ‘1’ 2 3)
> tripleFst (Triplet (\x -> x+1) 2 3)
> tripleFst (Triplet (\x -> x+1) 2 3) ☺
Exemplul 2
[Hutton, ex. 6, Chap. 12]

Define appropriate versions of the library functions

repeat, take, replicate
for the following type of binary trees
data Tree a = Leaf | Node (Tree a) a (Tree a)

-----------------------------------------------------------------------------------
data – introduce un tip de date
Triple – numele tipului de date
a b c – variabile tip – parametrii tipului de date Triple
Triplet – constructorul de date pentru tipul Triple