Haskell Introducere, Liste, uplu, functii, tipuri polimorfice, supraincarcare.

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)          -- uplu de aritate 2
    (String, Bool, Char)  -- uplu 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:
    • “impachetand” argumentele in uple sau liste:

      add :: (Int, Int) -> Int
      add (x,y) = x + y
      
      sum :: [Int] -> Int
      sum x:xs = x + sum xs
      
    • 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:

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