Tipurile de baza:
·
Bool – valori logice
Contine
valorile logice False si True.
·
Char – caractere
Contine toate caracterele
disponibile de la tastatura precum ‘a’, ‘_’, ‘V’, precum si un numar
de caractere de control precum ‘\n’, ‘\t’.
·
String – siruri de caractere
Acest tip contine toate
secventele de caractectere, precum “abc”, “1+2=3” si sirul vid “”.
·
Int – numere intregi intre -231 si 231 -1
·
Integer – numere intregi cu precizie
infinita
·
Float - single-precision
floating-point numbers
Tipul lista:
·
Secventa(chiar si infinita) de elemente de acelasi tip:
§
[True, False, False] :: [Bool]
§
[‘a’,’b’,’c’,’d’] :: [Char]
§
[“unu”, “doi”, “trei”] :: String
·
[[]] este diferita de []
·
nu exista restrictii asupra tipurilor ce pot forma liste!
§
[[‘a’, ‘b’], [‘a’, ‘c’, ‘d’]] :: [[Char]]
·
3:(2:(1:[])) , lista construita cu ‘cons’.
·
datorita evaluarii tarzii listele infinite sunt posibile in
Haskell.
Tipul uplu:
·
secventa finita de componente, posibil de tipuri diferite:
§
(False, True) :: (Bool, Bool)
§
(False, ‘a’, True) :: (Bool, Char, Bool)
§
(“Yes”, True, ‘a’) :: (String, Bool, Char)
·
numarul de componente dintr-un uplu se numeste aritate
·
uple de aritate 1 precum (False) nu sunt permise deoarece intra
in conflict cu folosirea parantezelor pentru a forta ordinea unei evaluari. Ex.
(1+2)*3
·
tipul unui uplu ii denota aritatea
§
(Bool, Bool) ulpu de aritate 2
§
(String, Bool, Char) ulpu de aritate 3
·
nu exista restrictii asupra tipurilor ce pot forma uple:
§
(’a’, (False, ’b’)) :: (Char, (Bool , Char))
§
([’a’, ’b’], [False, True ]) :: ([Char ], [Bool ])
Tipul functie:
·
functia este o mapare de la argumente de un tip la rezultate de alt
tip.
·
T1 -> T2 este
tipul tuturor functiilor ce mapeaza argumente de tipul T1 la
rezultate de tipul T2:
§
isDigit::Char->Bool
§
and::[Bool]->Bool
·
nu exista restrictia ca functiile sa fie totale (sa fie definite
ptr orice argument valid). Functia de biblioteca tail
nu e definita ptr lista vida.
·
In Haskell e standard ca functiile sa fie precedate de declaratia
de tip, care e verificata la compilare cu cea obtinuta prin type inference.
·
functiile cu mai multe argumente se pot defini in 2 feluri:
o
“impachetand” argumentele in uple sau liste:
§
add :: (Int, Int) -> Int
add (x,y) = x + y
§
sum :: [Int] -> Int
sum x:xs = x + sum xs
o
prin functii Curry (metoda nativa Haskell):
§
sunt functii ce intorc alte functii
§
add’ :: Int->(Int->Int)
add’ x y = x + y
§
declaratia functiei ar fi identica chiar si fara paranteze, fiind
asociativa la dreapta.
§
definitia functiei e asociativa la stanga:
o
((add’ x ) y) = add’ x y
§
in afara de cazurile in care trimiterea parametrilor sub forma de
uple e strict necesara, toate functiile in Haskell cu parametri multipli sunt
definite ca functii curry.
Tipuri polimorfice:
·
functiile pot fi definite pentru mai multe tipuri: functia length trebuie sa poata fi aplicata pe orice tip de
lista!
·
este posibil prin definirea functiei pe tipuri variabile:
§
length :: [a] -> Int
§
head :: [a] -> a
§
id :: a -> a
§
fst :: (a,b) -> a
·
variabilele de tip incep prin litere mici si se noteaza de
obicei: a, b, c
·
un tip ce contine unul sau mai multe tipuri/variabile de tip se
numeste polimorfic.
Tipuri supraincarcate:
·
operatorii +, -, *, ^ se aplica mai
multor tipuri
·
tipul acestora contine variabile de tip supuse unor constrangeri
de clasa ce se scriu sub forma:
§
C a unde C
este numele clasei si a variabila de tip
§
(+) :: Num a => a-> a->a
adica pentru orice tip a, instanta a clasei Num, functia (+) are
tipul a->a->a
·
acestea se numesc tipuri supraincarcate
No comments:
Post a Comment