Funkcionální programování - Ad-hoc polymorfismus

Funkcionální programování
Ad-hoc polymorsmus
Petr Pudlák
21. prosince 2011
Petr Pudlák ()
Funkcionální programování
21. prosince 2011
1 / 17
Ad-hoc polymorsmus
Osnova
1
Ad-hoc polymorsmus
2
Literatura
Ad-hoc polymorsmus
Motivace
Chceme denovat specické implementace polymorfních funkcí r·zn¥
pro r·zné typy.
Nap°íklad na r·zných typech bude r·zn¥ denována rovnost £i
uspo°ádání.
P°íklad:
Funkce
sort :: (Ord α) ⇒ [α] → [α]
sort tak není úpln¥ polymorfní
v prom¥nné
α.
M·ºeme dosadit pouze takový typ, pro který umíme porovnávat
hodnoty.
2/17
Ad-hoc polymorsmus
Typové t°ídy
Typová t°ída
je unární relace
1 na ADT.
ADT, které pat°í do relace dané ur£itou typovou t°ídou, nazýváme její
instance.
Typová t°ída denuje, jaké funkce musí být denovány pro její
instance.
Typové t°ídy se v Haskellu dají aplikovat na typové výrazy r·zných
druh· (nejen
∗).
Ke kaºdé typové t°íd¥ p°íslu²í druh odpovídající
odvozenému druhu její prom¥nné.
1
3/17
Roz²í°ení Haskellu pak dovolují i n-ární relace, a dal²í modikace.
Ad-hoc polymorsmus
P°íklady I
class Eq a where
(≡) :: a → a → Bool
(6≡) :: a → a → Bool
class (Eq a) ⇒ Ord a where
compare :: a → a → Ordering
(<)
:: a → a → Bool
(>)
:: a → a → Bool
(>)
:: a → a → Bool
(6)
:: a → a → Bool
max
:: a → a → a
min
:: a → a → a
class Bounded a where
minBound :: a
maxBound :: a
4/17
Ad-hoc polymorsmus
P°íklady II
Netriviální druhy
5/17
class Functor f where
fmap :: (a → b) → f a → f b
class Monad m where
(>>=) :: m a → (a → m b) → m b
(>>) :: m a → m b → m b
return :: a → m a
fail :: String → m a
class Monad m ⇒ MonadPlus m where
mzero :: m a
mplus :: m a → m a → m a
class Category cat where
id
:: cat a a
(◦)
:: cat b c → cat a b → cat a c
Ad-hoc polymorsmus
Výchozí výrazy pro denované funkce
V denici typových t°íd mohou mít jednotlivé funkce výchozí denice.
Ty mohou být vzájemn¥ rekurzivní.
Nap°íklad:
class Eq a where
(≡) :: a → a → Bool
x ≡ y = ¬ (x 6≡ y )
(6≡) :: a → a → Bool
x 6≡ y = ¬ (x ≡ y )
Implementátor si pak m·ºe vybrat pro implementaci pouze jednu z t¥chto
funkcí.
Pro zajímavost: Vý²e uvedené implementace lze zapsat i bez prom¥nných:
(≡) = (¬◦) ◦ (6≡)
(6≡) = (¬◦) ◦ (≡)
6/17
Ad-hoc polymorsmus
Instance typových t°íd
Pro zvolený ADT pak denujeme, jak jsou funkce typové t°ídy
implementovány pro tento ADT.
Implementace m·ºe být op¥t vázána podmínkami na jiné typové t°ídy.
Vznikají pak implikace tvaru: Pokud je pro typ a denována rovnost,
je denována rovnost i pro seznamy typu a.
Nap°íklad:
instance Functor [ ] where
f ‘fmap ‘ [ ]
= []
f ‘fmap ‘ (x : xs ) = (f x ) : (f ‘fmap ‘ xs )
instance Eq a ⇒ Eq ([ ] a) where
[]
≡ []
= True
(x : xs ) ≡ (y : ys ) = (x ≡ y ) ∧ (xs ≡ ys )
≡
= False
-- funkce /= je implementovana pomoci == v denice tridy
7/17
Ad-hoc polymorsmus
Implementace slovníkem
Poprvé tento zp·sob popsal [1].
P°i odvozování typ· si v kontextu type checker udrºuje informaci,
které výrazy musí implementovat které t°ídy, aby bylo moºno korektn¥
pouºít jednotlivé funkce z typových t°íd.
Kaºdá funkce deklarovaná v programu, jejíº typ nese podmínky
typových t°íd, bude p°eklada£em transformována na funkci, která má
pro kaºdou takovou podmínku skrytý parametr, který v sob¥ nese
implementace funkcí dané typové t°ídy.
V míst¥, kde je funkce pouºita na konkrétní datové typy, se do
parametr· doplní odpovídající implementace.
8/17
Ad-hoc polymorsmus
Implementace slovníkem p°íklad
Funkce
elem :: (Eq a) ⇒ a → [ a ] → Bool
bude p°i p°ekladu nahrazena
funkcí:
elem :: (a → a → Bool , a → a → Bool ) → a → [ a ] → Bool
elem (eq , notEq ) = elem0
where elem0 [ ]
= False
elem0 x (y : ys ) = (x ‘eq ‘ y ) ∨ (elem0 x ys )
9/17
Ad-hoc polymorsmus
Automatické odvození instancí algebraických datových typ·
U algebraických datových typ· se v mnoha p°ípadech implementují
typové t°ídy stále stejným zp·sobem.
Haskell umoº¬uje automatické odvození instancí p°i denici t¥chto
typových t°íd:
Eq , Ord , Enum, Bounded , Show
P°íklad:
data Maybe a = Nothing | Just a
deriving (Eq , Show , Read )
10/17
a
Read .
Ad-hoc polymorsmus
P°íklad typové prom¥nné netriviálního druhu I
Pomocí typových t°íd
import Data.Monoid
import Data.Foldable (Foldable , foldMap )
import qualied Data.Foldable as F
data TreeList t a = Nil | a :> (t (TreeList t a))
inxr 5 :>
Na instancích
11/17
Foldable
lze postupn¥ obsah datové struktury poskládat do
Ad-hoc polymorsmus
P°íklad typové prom¥nné netriviálního druhu II
Pomocí typových t°íd
jedné výsledné hodnoty. Jedna z (více moºných) denic toto skládání
denuje pomocí
Monoid u:
instance Foldable t ⇒ Foldable (TreeList t ) where
-- foldMap :: (Monoid t) => (a -> t) -> TreeList t a -> m
foldMap f = fm
where
fm Nil
= mempty
fm (x :> xs ) = (f x ) ‘mappend ‘ (foldMap fm xs )
Funkce, která po£ítá po£et prvk· seznamu za p°edpokladu, ºe v¥tvící typ je
Foldable :
count :: (Foldable t ) ⇒ TreeList t a → Int
count = getSum ◦ foldMap (const (Sum 1))
Seznamy:
12/17
Ad-hoc polymorsmus
P°íklad typové prom¥nné netriviálního druhu III
Pomocí typových t°íd
newtype Id a = Id { unid :: a }
deriving (Eq , Show )
instance Foldable Id where
foldMap f (Id x ) = f x
type List a = TreeList Id a
exampleList = 1 :> Id (2 :> Id (3 :> Id Nil ))
Binární stromy:
data Pair a = Pair { pairL :: a, pairR :: a }
deriving (Eq , Show )
instance Foldable Pair where
foldMap f (Pair x y ) = f x ‘mappend ‘ f y
type BinTree a = TreeList Pair a
13/17
Ad-hoc polymorsmus
P°íklad typové prom¥nné netriviálního druhu IV
Pomocí typových t°íd
exampleBinTree =
"a" :> Pair
("ab" :> (Pair Nil Nil ))
("ac" :> (Pair
Nil
("acd" :> Pair Nil Nil )
)
)
n-ární
stromy (instance pro Foldable [] je denována v modulu Foldable):
type NTree a = TreeList [ ] a
exampleNTree =
0.0 :>
[−1.0 :> [ ]
14/17
Ad-hoc polymorsmus
P°íklad typové prom¥nné netriviálního druhu V
Pomocí typových t°íd
, −0.5 :> [ ]
, 0.5 :> [ ]
, 1.0 :> [ 3 :> [ ]]
]
15/17
Literatura
Osnova
1
Ad-hoc polymorsmus
2
Literatura
Literatura
Doporu£ená £etba
http:
//www.haskell.org/haskellwiki/The_Monad.Reader/Issue3/
Functional_Programming_vs_Object_Oriented_Programming
16/17
Literatura
Literatura I
[1]
17/17
P. Wadler and S. Blott.
?How to make ad-hoc polymorphism less ad
hoc? In: Proceedings of the 16th ACM SIGPLAN-SIGACT symposium
on Principles of programming languages. ACM. 1989, pp. 6076. URL:
http://homepages.inf.ed.ac.uk/wadler/topics/typeclasses.html.