FP / Typové triedy a polymorfizmus

Skôr než začneme

Hľadanie indexu v štandardnej knižnici

elemIndex       :: Eq a => a -> [a] -> Maybe Int
elemIndex x      = findIndex (x==)

findIndex       :: (a -> Bool) -> [a] -> Maybe Int
findIndex p      = listToMaybe . findIndices p

findIndices     :: (a -> Bool) -> [a] -> [Int]
findIndices p xs = [ i | (x,i) <- zip xs [0..], p x]

Pokračovanie

listToMaybe :: [a] -> Maybe a
listToMaybe = foldr (const . Just) Nothing

const      :: a -> b -> a
const x _  =  x

Pokračovanie

listToMaybe :: [a] -> Maybe a
listToMaybe = foldr (\x acc -> (const . Just) x acc) Nothing

const      :: a -> b -> a
const x _  =  x

Pokračovanie

listToMaybe :: [a] -> Maybe a
listToMaybe = foldr (\x acc -> (const (Just x) acc) Nothing

const      :: a -> b -> a
const x _  =  x

Pokračovanie

listToMaybe :: [a] -> Maybe a
listToMaybe = foldr (const . Just) Nothing

const      :: a -> b -> a
const x _  =  x

Polymorfizmus

Typy polymorfizmu

• Ad-hoc polymorfizmus
• Parametrický polymorfizmus
• Polymorfizmus podtypov

Príklady

Ad-hoc polymorfizmus

Prekrývanie funkcií a operátorov

• Rovnaký názov funkcie pre rôzne typy
• Rozdielne správanie

int times(int x, int y) {
    return x * y;
}
String times(int n, String s) {
    return StringUtils.repeat(s, n);
}

Parametrický polymorfizmus

Typové parametre

• Generické typy a funkcie
• Typové premenné
• Príklad:
  • class List<T> (Java)
  • data List a (Haskell)

Polymorfizmus podtypov

Podtypy

• Operácie pre nadtyp je možné použiť aj pre podtypy
• Implementácia môže byť rozdielna

Liskov substitution principle

Subtype Requirement: Let ⁠$\phi(x)$⁠ be a property provable about objects ⁠$x$⁠ of type T. Then ⁠$\phi(y)$⁠ should be true for objects ⁠$y⁠$ of type S where S is a subtype of T.

Inheritance ≠ subtyping

• Dedičnosť – podtyp + zdieľanie implementácie
• Rozhranie – podtyp bez dedičnosti
• Mixin – zdieľanie implementácie bez podtypov

Haskell?

Haskell

• Parametrický polymorfizmus
• Polymorfizmus podtypov
• Ad-hoc polymorfizmus?

Typové triedy

Typové triedy

• Ad-hoc polymorfizmus
• Metóda – funkcia, ktorú je možné použiť na rôzne typy
• Trieda – množiny typov, na ktoré je možné použiť skupinu metód
• Inštancia – implementácia metód pre konkrétny typ
• Pre každý typ rozdielna implementácia

class Show a where
    show :: a -> String

instance Show Bool where
    show True  = "True"
    show False = "False"

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

instance Eq Point where 
    (Point x1 y1) == (Point x2 y2)  =  x1 == x2 && y1 == y2
    a /= b  =  not (a == b)

Predvolená implementácia

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

Príklad

elem :: ?
elem x []     = False
elem x (y:ys) = x==y || (elem x ys)

Typ?

elem :: a -> [a] -> Bool
elem x []     = False
elem x (y:ys) = x==y || (elem x ys)

Kontext

elem :: (Eq a) => a -> [a] -> Bool
elem x []     = False
elem x (y:ys) = x==y || (elem x ys)

Kontext inštancie

instance Eq a => Eq (List a) where
    Nil == Nil              =  True
    Cons x xs == Cons y ys  =  x == y && xs == ys
    _ == _                  =  False

Dedičnosť

class (Eq a) => Ord a where
    compare              :: a -> a -> Ordering 
    (<), (<=), (>=), (>) :: a -> a -> Bool
    max, min             :: a -> a -> a

Haskell vs Java

• Typová trieda pripomína rozhranie
• Rozdiely:
  • Definícia inštancie oddelená od definície typu
  • Typová trieda nie je typom (no subtyping)

Nie elem :: Eq -> [Eq] -> Bool,
ale elem :: (Eq a) => a -> [a] -> Bool

Implementácia inštancie

• Minimálna úplná definícia
• Požadované vlastnosti
• Príklad: Ord

Štandartné typové triedy pre čísla

• Num: +, -, *
• Integral: div, mod
• Fractional: /
• Floating: sin, cos

Ďalšie štandartné typové triedy

• Enum: succ, pred, [n .. m]
• Show: show
• Read: read

Typové triedy vyššieho rádu

class Functor f where
    fmap :: (a -> b) -> f a -> f b

instance Functor List where
  fmap op Nil       = Nil
  fmap op (Cons x xs) = Cons (op x) (fmap op xs)

• f nie je konkrétny typ, ale typový koštruktor

Druhy (kinds)

• Typy typov
• :k
• Int :: * — konkrétny typ
• Maybe :: * -> * — typový konštruktor
• Either :: * -> * -> *
• List :: * -> *
• List Int :: *

Functor

class Functor f where
    fmap :: (a -> b) -> f a -> f b

instance Functor List where
  fmap op Nil       = Nil
  fmap op (Cons x xs) = Cons (op x) (fmap op xs)

Ďalšie typové triedy

• Monad … neskôr
• Foldable: foldr, foldl

elem v skutočnosti

class Foldable t where
    ...
    elem :: Eq a => a -> t a -> Bool
    elem = any . (==)
    ...

elem x xs = any (\y -> y == x) xs
elem x = any (\y -> y == x)
elem x = any (==x)
elem x = any ((==) x)
elem x = (any . (==)) x
elem = any . (==)

Automatické odvodenie

data Shape = Circle Point Double
           | Rectangle Point Point
           deriving (Eq, Ord, Show)

Niekde inde?

Rust

trait Show {
    fn show(&self) -> String;
}

impl Show for bool {
    fn show(&self) -> String {
        if *self { "true" } else { "false" }.to_string()
    }
}

A tiež

• Swift (protocols)
• C++ (concepts)

Typy v jazyku Haskell

• Bez hierarchie typov
• Namiesto toho
  • viacero konštruktorov
  • typové triedy