Clase de tipuri (Type-classes)

Scopul laboratorului:

• Familiarizarea studenților cu tipuri de clase
• Familiarizarea studenților cu constrângeri de tip

O clasă de tipuri (typeclass) este un fel de interfață care definește un comportament. Dacă un tip de date face parte dintr-o anume clasă de tipuri, atunci putem lucra pe tipul respectiv cu operațiile definite în clasă.

O clasă des întâlnită este clasa Eq. Orice tip care este o instanță a acestei clase poate fi comparat, utilizând funcțiile == și /=. Clasa Eq este definită mai jos. Observați sintaxa Haskell:

class Eq a where  
    (==) :: a -> a -> Bool  
    (/=) :: a -> a -> Bool  
    x == y = not (x /= y)  
    x /= y = not (x == y)  

Observăm că definițiile pentru == și /= depind una de cealaltă. Acest lucru ne ușurează munca atunci când vrem să înrolăm un tip acestei clase, pentru că trebuie să redefinim doar unul dintre cei doi operatori. Pentru a vedea cum lucrăm cu clase, vom defini un tip de date simplu și îl vom înrola în Eq:

data Color = Red | Green | Blue
 
instance Eq Color where
    Red == Red = True
    Green == Green = True
    Blue == Blue = True
    _ == _ = False

Am redefinit ==, iar definiția lui /= rămâne neschimbată (x /= y = not (x == y)), ceea ce e suficient ca să folosim ambii operatori.

*Main> Red == Red
True
*Main> Red /= Red
False

În laboratoarele trecute, analizând tipurile unor expresii, ați întâlnit notații asemănătoare:

Prelude> :t elem
elem :: (Eq a) => a -> [a] -> Bool

Partea de după => ne spune că funcția elem primește un element de un tip oarecare, a și o listă cu elemente de același tip și întoarce o valoare booleană.

(Eq a) precizează că tipul de date a trebuie să fie o instanță a clasei Eq și nu orice tip. De aceea se numește o constrângere de clasă (class constraint).

*Main> :t (\x -> x == 0)
(\x -> x == 0) :: (Eq a, Num a) => a -> Bool

O definiție posibilă a funcției elem este:

elem :: (Eq a) => a -> [a] -> Bool
elem _ [] = False
elem e (x:xs) = e == x || elem e xs

Ceea ce înseamnă că, odată înrolat tipul nostru clasei Eq, putem folosi, printre altele, și functia elem:

Prelude> elem Red [Blue, Green, Green, Red, Blue]
True

Să considerăm tipul de date polimorfic Either:

data Either a b = Left a | Right b

Țineți minte că Either nu este un tip, ci un constructor de tip. Either Int String, Either Char Bool etc. sunt tipuri propriu-zise.

O clasă utilă de tipuri este clasa Show, care oferă funcția show care primește un parametru și întoarce reprezentarea acestuia sub formă de șir de caractere.

show :: (Show a) => a -> String

Pentru a înrola tipul Either în clasa Show, vom folosi sintaxa:

instance (Show a, Show b) => Show (Either a b) where
    show (Left x) = "Left " ++ show x
    show (Right y) = "Right " ++ show y

Din cadrul ghci, puteți obține informații despre o clasă anume folosind comanda :info <typeclass> (:i <typeclass>):

Prelude> :info Ord
class Eq a => Ord a where
  compare :: a -> a -> Ordering
  (<) :: a -> a -> Bool
  (<=) :: a -> a -> Bool
  (>) :: a -> a -> Bool
  (>=) :: a -> a -> Bool
  max :: a -> a -> a
  min :: a -> a -> a
  {-# MINIMAL compare | (<=) #-}
        -- Defined in ‘GHC.Classes’
instance Ord a => Ord [a] -- Defined in ‘GHC.Classes’
instance Ord Word -- Defined in ‘GHC.Classes’
instance Ord Ordering -- Defined in ‘GHC.Classes’
instance Ord Int -- Defined in ‘GHC.Classes’
...

Putem observa mai multe informații utile:

• constrângerea de clasă Eq a => arată că un tip de date trebuie să fie membru al clasei Eq pentru a putea fi membru al clasei Ord.
• putem observa toate funcțiile și operatorii oferiți de clasa Ord: compare, <, <= etc.
• linia {-# MINIMAL compare | (<= ) #-} ne informează că e suficient să implementăm fie funcția compare, fie operatorul <=, pentru a putea utiliza toate funcțiile puse la dispoziție de clasa Ord (amintiți-vă de clasa Eq și cum /= rămânea definit în funcție de ==).
• linia – Defined in ‘GHC.Classes’ indică locul în care această clasă e definită. O căutare a numelui ne duce aici, unde putem observa implementarea clasei, exact așa cum este folosită în ghc.
• următoarele linii reprezintă o înșirare a tuturor tipurilor de date despre care ghci știe că sunt înrolate în clasa Ord, precum și unde se găsește această înrolare. E.g. prima linie arată că listele ce conțin elemente ordonabile sunt și ele ordonabile, comportament definit în GHC.Classes: https://github.com/ghc/ghc/blob/master/libraries/ghc-prim/GHC/Classes.hs#L330

1. În laboratorul anterior, ați definit un tip pentru a modela numerele naturale extinse cu un punct la infinit, precum și niște operații pe acestea. Dorim să facem implementarea elegantă, pentru a putea folosi operatori deja existenți (e.g. == pentru comparare) și pentru a putea folosi alte funcții existente care impun constrângeri de tip (e.g. Data.List.sort :: Ord a => [a] -> [a]). Astfel, ne dorim să înrolăm tipul de date în următoarele clase:

• Show (astfel încât să afișăm numerele fără a fi precedate de vreun nume de constructor, iar infinitul ca “Inf”)
• Eq
• Ord
• Num

2. Definiți un tip de date asociat următoarei gramatici:

   <expr> ::= <value> | <variable> | <expr> + <expr> | <expr> * <expr> 

unde o valoare poate avea orice tip.

3. Considerăm următorul constructor de tip:

type Dictionary a = [(String, a)]

care modeleaza dicționare - mapări de tip “nume-variabilă”-“valoare polimorfica”

Definiți funcția:

valueof :: Dictionary a -> String -> Maybe a

care intoarce valoarea asociata unui nume-variabilă, dintr-un dicționar

4. Definiți următoarea clasă:

class Eval t a where
    eval :: Dictionary a -> t a -> Maybe a

Spre deosebire de clasele prezentate în exemplele anterioare, care desemnează o proprietate a unui tip sau constructor de tip, Eval stabilește o relație între un constructor de tip t și un tip a. Relația spune că orice container de tip t a poate fi evaluat in prezența unui dicționar cu valori de tip a, la o valoare de tip Maybe a.

{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
 
class Eval t a where
    eval :: Dictionary a -> t a -> Result a

5. Înrolați Expr și Integer în clasa Eval. Care este semnificația evaluării?

6. Înrolați Expr și FIFO a în clasa Eval. Semnificația înmulțirii este concatenarea a două FIFO.

1. Ați definit, în laboratorul anterior, tipurile polimorfice List a și Tree a. Pentru le putea reprezenta, ați folosit implementarea implicită a funcției show, oferită de deriving (Show). Aceasta nu era însă o reprezentare citibilă.

Ne dorim să reprezentăm tipul listă, la fel ca cel existent în Haskell:

Prelude> show (Cons 1 (Cons 2 (Cons 3 Nil)))
[1,2,3]

(Pentru arbori există multe reprezentări posibile, puteți alege orice reprezentare preferați).

2. Înrolați aceleași tipuri în clasa Eq.

3. Implementați sortarea pentru List a, unde a e un tip oarecare înrolat în clasa Ord.

4. Implementați căutarea binară pentru Tree a, unde a e un tip oarecare înrolat în clasa Ord.

5. Înrolați tipurile de date List și Tree în clasa Functor.

• Type Classes and Overloading - Haskell wiki
• Typeclassopedia - Haskell wiki
• Typeclasses 101 - Learnyouahaskell
• Typeclasses 102 - Learnyouahaskell