Multimetody v Clojure aneb polymorfismus bez použití OOP

14. 4. 2016

Doba čtení: 22 minut

Líbí se vám článek?
Podpořte redakci

Programovací jazyk Clojure obsahuje podporu pro tvorbu a volání takzvaných multimetod. Ty se odlišují především mechanismem dynamického výběru konkrétní metody v čase běhu aplikace.

Obsah

1. Multimetody v Clojure aneb polymorfismus bez použití OOP

2. Problém typický pro třídní OOP: je kružnice speciálním případem elipsy?

3. Multimetody

4. První varianta funkce heading

5. Nedostatky první verze

6. První vylepšení – rozlišení typu parametru předaného funkci heading

7. Definice multimetody a k ní příslušné výběrové (dispatch) funkce

8. Volání multimetody na základě zjištěného typu parametru

9. Implicitní metoda

10. Hierarchie typů a způsob řešení „kolizí“

11. Programátorem zvolená preference metod

12. Finální varianta multimetody heading

13. Odkazy na předchozí části tohoto seriálu

14. Odkazy na Internetu

1. Multimetody v Clojure aneb polymorfismus bez použití OOP

V diskusi, která se vedla (resp. přesněji řečeno stále ještě s poněkud menší frekvencí vede) pod článkem Recenze knihy Functional Thinking (Paradigm over syntax), zaznělo mj. i několik zajímavých názorů, které se poměrně úzce dotýkají problematiky polymorfismu, tj. poněkud zjednodušeně řečeno technologie způsobu výběru konkrétní funkce či metody, která se má v daném kontextu zavolat. Pojem „polymorfismus“ se v oblasti programovacích jazyků používá pro popis hned několika navzájem odlišných vlastností nějakého jazyka či jeho běhového prostředí, což někdy může vést ke zbytečným nedorozuměním, zvláště když se přesně nespecifikuje, který druh polymorfismu má pisatel vlastně na mysli. V mnoha programovacích jazycích podporujících objektově orientované programování (navíc založené na použití tříd) se pod pojmem „polymorfismus“ většinou automaticky myslí takzvaný podtypový polymorfismus neboli subtype polymorphism.

Podtypový polymorfismus se dále může dělit na polymorfismus statický a dynamický. U statického polymorfismu o výběru volané metody rozhoduje již překladač, který většinou do vytvářeného strojového kódu přímo umístí instrukce pro volání konkrétní funkce či metody (její adresu). Někdy se pod tento pojem poněkud nepřesně zahrnuje i přetížení funkcí. Naopak dynamický podtypový polymorfismus (v řeči OOP tedy jen „polymorfismus“) je typicky založený na pozdní vazbě – late binding – a tabulce virtuálních metod). Pokud však termín „polymorfismus“ použije vývojář používající nějaký jazyk podporující funkcionální programování, bude mít pravděpodobně na mysli polymorfismus parametrický, tedy technologii, kterou si alespoň stručně vysvětlíme v navazujících kapitolách. Aby nebylo zmatků v pojmenování málo, můžeme se setkat i s označením runtime polymorphism, což může být buď podtypový dynamický polymorfismus nebo parametrický dynamický polymorfismus :-)

2. Problém typický pro třídní OOP: je kružnice speciálním případem elipsy?

Podtypový polymorfismus pravděpodobně není nutné vývojářům, kteří tento článek čtou, podrobně představovat, protože v mainstreamových programovacích jazycích založených na objektově orientovaném programování s třídami je použit právě tento druh polymorfismu. V praxi to může znamenat, že vývojář definuje hierarchii tříd s tím, že se výběr konkrétní metody, která se má zavolat, může provést až v čase běhu aplikace, a to na základě typu objektu, jehož metoda se volá. Obecně totiž platí, že překladač nemusí mít k dispozici informaci o přesném typu objektu, a to právě na základě hierarchie tříd, kdy potomek může nahradit předka. I přes značné rozšíření podtypového polymorfismu v OOP jazycích se však v některých případech nevyhneme některým problémům, typicky problému nazývanému problém kružnice-elipsa (Circle-ellipse problem). Zkuste se nad tímto problémem sami chvíli zamyslet a zjistit, proč použití klasické třídní hierarchie a objektů s měnitelným stavem („se settery“) nutně vede k problémům:

class Ellipse implements Shape {
}
 
class Circle extends Ellipse {
}

versus:

class Circle implements Shape {
}
 
class Ellipse extends Circle {
}

versus:

class Circle implements Shape {
}
 
class Ellipse implements Shape {
}

Ostatně velmi podobný typ problému byl popsán v již zmíněné diskusi (poněkud sofistikovanější to bude například při snaze o vytvoření hierarchie tříd číselných typů – reálná vs komplexní čísla apod.). Právě tyto kategorie problémů je možné poměrně elegantně vyřešit použitím multimetod, které nejsou svázány s hierarchií tříd.

Poznámka: tvrzení z předchozích odstavců nutně neznamená, že OOP je
ve všech případech špatný koncept; pouze by mělo být patrné, že při modelování
objektů z reálného světa musíme být velmi obezřetní k tomu, zda se ve
vytvářeném modelu neporušuje nějaký základní předpoklad, nebo zda naopak nějaký
předpoklad zbytečně nepřidáváme (u zmíněného problému kružnice-elipsa se
například základní nedostatky relativně snadno obejdou zákazem změny stavu, což
je ostatně typický přístup používaný ve funkcionálním programování).

3. Multimetody

Programovací jazyk Clojure vývojářům taktéž nabízí možnost tvorby polymorfních metod, ovšem samotný princip výběru volané metody v čase běhu aplikace nezávisí na použité třídní hierarchii: namísto běžných metod (deklarovaných typicky v rámci tříd) je totiž v Clojure možné deklarovat takzvané multimetody. Ty se skládají ze dvou částí – definice defmulti, v níž je multimetoda pojmenovaná a navíc je zde zmíněna takzvaná výběrová (dispatch) funkce, a následně z libovolného počtu definic defmethod, na něž se můžeme dívat jako na definice běžných funkcí, ovšem doplněných o kontext určující, za jakých okolností se tato konkrétní funkce tvořící část multimetody zavolá. Před popisem konkrétního způsobu zápisu multimetod si však uveďme reálný příklad, který nám ukáže, kdy je vhodné multimetody použít (v praxi však zjistíte, že se v naprosté většině případů bez multimetod a tím pádem i polymorfismu můžete obejít, minimálně v dynamicky typovaném jazyce Clojure).

4. První varianta funkce heading

Předpokládejme, že ve vyvíjené aplikaci potřebujeme vytvořit funkci (prozatím skutečně běžnou funkci) nazvanou heading. Tato funkce vypíše na standardní výstup hodnotu svého parametru, ovšem navíc tuto hodnotu od ostatních zpráv z obou stran vizuálně oddělí. První – a jak uvidíme dále, i poměrně naivní – implementace této funkce může vypadat velmi jednoduše a přímočaře. Připomeňme si jen, že *out* je objekt typu java.io.Writer, který je běžně navázaný na System.out. Můžeme tedy směle volat metodu java.io.Writer.write(), ovšem s využitím Java interop:

(defn heading
    [anything]
    (.write *out* "-----------------\n")
    (.write *out* anything)
    (.write *out* "\n-----------------\n"))

První test této funkce dopadne vcelku uspokojivě:

user=> (heading "xyzzy")
-----------------
xyzzy
-----------------

5. Nedostatky první verze

Zdá se, že funkce heading pracuje uspokojivě za předpokladu, že jí předáme parametr typu řetězec. Co se však stane u parametrů jiných typů? Můžeme si to jednoduše vyzkoušet:

user=> (heading 42)
-----------------
*
-----------------

Zde se číselná hodnota převedla na ASCII znak s kódem 42.

user=> (heading nil)
 
-----------------
NullPointerException   java.io.PrintWriter.write (PrintWriter.java:443)

Zde nejenže funkce nepracuje spolehlivě, ale navíc v programu vygenerovala výjimku.

user=> (heading [1 2 3])
 
-----------------
IllegalArgumentException No matching method found: write for class java.io.PrintWriter  clojure.lang.Reflector.invokeMatchingMethod (Reflector.java:80)
 
user=> (heading {:first 1 :second 2})
 
-----------------
IllegalArgumentException No matching method found: write for class java.io.PrintWriter  clojure.lang.Reflector.invokeMatchingMethod (Reflector.java:80)

Pro odlišné parametry, než je řetězec či celé číslo, taktéž namísto výpisu dojde k vyhození výjimky; což pravděpodobně programátory, kteří budou naši funkci chtít použít ve svých aplikacích, moc nepotěší.

6. První vylepšení – rozlišení typu parametru předaného funkci heading

Pokusme se nyní funkci heading vylepšit, a to stále bez použití multimetod. Jedním z možných řešení (ke kterému se prosím v praxi moc často neuchylujte :-) je založeno na explicitním rozvětvení provedeného na základě zjištěného typu parametru. Využijeme zde čtveřici prediktorů nazvaných nil?, string?, number? a vector?, samozřejmě je však možné provést rozšíření i na další typy, s nimiž se v programovacím jazyce Clojure můžete setkat. Bylo by například pěkné automaticky dereferovat atomy apod.:

(defn heading
    [anything]
    (.write *out* "-----------------\n")
    (cond (nil?    anything) (.write *out* "nothing")
          (string? anything) (.write *out* anything)
          (number? anything) (.write *out* (str anything))
          (vector? anything) (.write *out* (clojure.string/join " " anything)))
    (.write *out* "\n-----------------\n"))

Funkce se nám prodloužila, takže se podívejme na to, jak si obstojí při testování:

user=> (heading "xyzzy")
-----------------
xyzzy
-----------------
 
user=> (heading 42)
-----------------
42
-----------------
 
user=> (heading nil)
-----------------
nothing
-----------------
 
user=> (heading [1 2 3])
-----------------
1 2 3
-----------------
 
user=> (heading {:first 1 :second 2})
-----------------
-----------------

Vidíme, že v posledním případě, tj. při předání mapy, se mezi označené řádky nic nevypíše, což je však v pořádku, protože jsme v makru nedeklarovali žádnou větev else. Úprava je snadná:

(defn heading
    [anything]
    (.write *out* "-----------------\n")
    (cond (nil?    anything) (.write *out* "nothing")
          (string? anything) (.write *out* anything)
          (number? anything) (.write *out* (str anything))
          (vector? anything) (.write *out* (clojure.string/join " " anything))
          :else              (.write *out* "I'm confused"))
    (.write *out* "\n-----------------\n"))

7. Definice multimetody a k ní příslušné výběrové (dispatch) funkce

Výše uvedené řešení není zcela ideální, protože se v něm vlastně snažíme o ruční (ad-hoc) implementaci polymorfismu. Podívejme se tedy, jak by bylo možné využít multimetody. Víme již, že jejich definice je rozdělena minimálně do dvou částí – defmulti a defmethod. V definici defmulti je multimetoda pojmenována a navíc je zde specifikována takzvaná výběrová (dispatch) funkce:

(defmulti heading dispatch-fn)

Při volání multimetody je nejprve zavolána dispatch funkce s tím, že její návratová hodnota je následně použita pro výběr konkrétní funkce/metody, která se má zavolat (v třídním OOP, jaké je například implementováno v Javě, vlastně dispatch funkce odpovídá výrazu this). V našem konkrétním případě potřebujeme, aby dispatch funkce zjistila typ parametru a nějakým způsobem tento typ vrátila. Naivní implementace může vypadat například takto:

(defn dispatch-fn
    [anything]
    (cond (nil?    anything) :nil
          (string? anything) :string
          (number? anything) :number
          (vector? anything) :vector))

Následuje definice jednotlivých variant multimetody. Povšimněte si, že defmethod se vlastně podobá běžné definici funkce s využitím defn, ovšem s tím rozdílem, že za jménem multimetody ještě následuje hodnota, která je při volání multimetody párována s výsledkem dispatch funkce. Toto „párování“ (dynamic dispatching) za nás provede interpret a překladač automaticky, ostatně podobně automaticky je tomu v OOP jazycích (poznámka – hodnota může být libovolná, klidně zde můžeme použít mapu, vektor, záznam atd.):

(defmethod heading :nil
    [val]
    (.write *out* "-----------------\n")
    (.write *out* "nothing")
    (.write *out* "\n-----------------\n"))
 
(defmethod heading :string
    [val]
    (.write *out* "-----------------\n")
    (.write *out* val)
    (.write *out* "\n-----------------\n"))
 
(defmethod heading :number
    [val]
    (.write *out* "-----------------\n")
    (.write *out* (str val))
    (.write *out* "\n-----------------\n"))
 
(defmethod heading :vector
    [val]
    (.write *out* "-----------------\n")
    (.write *out* (clojure.string/join " " val))
    (.write *out* "\n-----------------\n"))

Volání multimetody se nijak neliší od volání běžné funkce (to je právě na multimetodách pěkné), takže si pusťme do testování:

user=> (heading nil)
-----------------
nothing
-----------------
 
user=> (heading "xyzzy")
-----------------
xyzzy
-----------------
 
user=> (heading 42)
-----------------
42
-----------------
 
user=> (heading nil)
-----------------
nothing
-----------------
 
user=> (heading [1 2 3])
-----------------
1 2 3
-----------------

Zajímavá situace nastane ve chvíli, kdy použijeme parametr neznámého typu:

user=> (heading {:first 1 :second 2})
 
IllegalArgumentException No method in multimethod 'heading' for dispatch value: null  clojure.lang.MultiFn.getFn (MultiFn.java:160)

I tento problém však lze snadno vyřešit, jak ostatně uvidíme v dalších kapitolách.

8. Volání multimetody na základě zjištěného typu parametru

Naši multimetodu heading je možné vylepšit, a to hned několika způsoby. Například namísto uživatelsky definované dispatch funkce můžeme v tomto případě použít vestavěnou funkci nazvanou jednoduše class, která dokáže v runtime (za běhu aplikace) detekovat typ svého argumentu. Ostatně se sami podívejme, jak tato funkce pracuje (povšimněte si, že pro nil se vrátí taktéž typ nil):

user=> (class nil)
nil
 
user=> (class "xyzzy")
java.lang.String
 
user=> (class 42)
java.lang.Long
 
user=> (class 42.0)
java.lang.Double
 
user=> (class [1 2 3])
clojure.lang.PersistentVector
 
user=> (class (range 10))
clojure.lang.LazySeq

První část definice multimetody se nám tedy zjednoduší na jeden jediný řádek, protože nebudeme definovat žádnou dispatch funkci:

(defmulti heading class)

Druhá část definice multimetody (jednotlivé konkrétní metody) se od první verze příkladu odlišují hodnotou použitou pro spárování (dynamic dispatching):

(defmethod heading nil
    [val]
    (.write *out* "-----------------\n")
    (.write *out* "nothing")
    (.write *out* "\n-----------------\n"))
 
(defmethod heading String
    [val]
    (.write *out* "-----------------\n")
    (.write *out* val)
    (.write *out* "\n-----------------\n"))
 
(defmethod heading Number
    [val]
    (.write *out* "-----------------\n")
    (.write *out* (str val))
    (.write *out* "\n-----------------\n"))
 
(defmethod heading clojure.lang.IPersistentVector
    [val]
    (.write *out* "-----------------\n")
    (.write *out* (clojure.string/join " " val))
    (.write *out* "\n-----------------\n"))

Opět si novou variantu multimetody otestujme:

user=> (heading nil)
-----------------
nothing
-----------------
 
user=> (heading "xyzzy")
-----------------
xyzzy
-----------------
 
user=> (heading 42)
-----------------
42
-----------------
 
user=> (heading nil)
-----------------
nothing
-----------------
 
user=> (heading [1 2 3])
-----------------
1 2 3
-----------------

Vše vypadá (zdánlivě) v pořádku!

9. Implicitní metoda

Když jsme se snažili o implementaci ad-hoc polymorfismu s využitím makra cond, bylo možné použít větev else pro ty případy, pro které neexistovala speciální větev. Podobnou vlastnost podporují i multimetody, a to při použití hodnoty :default. Pokud naši multimetodu z předchozí kapitoly rozšíříme o další metodu ve tvaru:

(defmethod heading :default
    [anything]
    (.write *out* "-----------------\n")
    (.write *out* "I'm confused!")
    (.write *out* "\n-----------------\n"))

…budeme moci bez problémů metodu zavolat a předat jí množinu, mapu apod.:

user=> (heading {:first 1 :second 2})
-----------------
I'm confused!
-----------------

Pokuste se o něco podobného například v Javě…

10. Hierarchie typů a způsob řešení „kolizí“

Ve skutečnosti nám však ještě zbývá vyřešit minimálně jeden problém. Řekněme, že požadavek na multimetodu heading byl rozšířen – pokud se jí předá vektor, má být vypsán v hranatých závorkách, pokud sekvence nebo jiná kolekce, pak se mají použít závorky kulaté. Zdánlivě se nejedná o nic složitého, takže by řešení mohlo vypadat třeba takto:

(defmulti heading class)
 
(defmethod heading nil
    [val]
    (.write *out* "-----------------\n")
    (.write *out* "nothing")
    (.write *out* "\n-----------------\n"))
 
(defmethod heading String
    [val]
    (.write *out* "-----------------\n")
    (.write *out* val)
    (.write *out* "\n-----------------\n"))
 
(defmethod heading Number
    [val]
    (.write *out* "-----------------\n")
    (.write *out* (str val))
    (.write *out* "\n-----------------\n"))
 
(defmethod heading clojure.lang.IPersistentVector
    [val]
    (.write *out* "-----------------\n")
    (.write *out* "[")
    (.write *out* (clojure.string/join " " val))
    (.write *out* "]")
    (.write *out* "\n-----------------\n"))
 
(defmethod heading java.util.Collection
    [val]
    (.write *out* "-----------------\n")
    (.write *out* "(")
    (.write *out* (clojure.string/join " " val))
    (.write *out* ")")
    (.write *out* "\n-----------------\n"))
 
(defmethod heading :default
    [anything]
    (.write *out* "-----------------\n")
    (.write *out* "I'm confused!")
    (.write *out* "\n-----------------\n"))

První testování však nedopadne příliš dobře:

(heading [1 2 3])
user=> (heading [1 2 3])
 
IllegalArgumentException Multiple methods in multimethod 'heading' match dispatch value:
class clojure.lang.PersistentVector -> interface java.util.Collection and interface
clojure.lang.IPersistentVector, and neither is preferred
clojure.lang.MultiFn.findAndCacheBestMethod (MultiFn.java:182)

Runtime programovacího jazyka Clojure nám celkem jasně sděluje, že pro daný typ (vektor) našel hned dvě metody, které může použít. A vzhledem k tomu, že se v multimetodách nepoužívá (a ani nemůže používat) hierarchie tříd, je runtime zmatený a namísto hádání, která metoda je danému typu „nejblíže“, raději vyhodí výjimku.

11. Programátorem zvolená preference metod

Vzhledem k tomu, jakou volnost mají programátoři při konstrukci multimetod, nás pravděpodobně příliš nepřekvapí, že i preference jednotlivých metod tvořících multimetodu je volitelná. Používá se zde deklarace prefer-method, které se musí předat jak identifikátor multimetody (heading), tak i specifikace, která metoda (resp. přesněji řečeno která hodnota vrácená dispatch funkcí) bude mít přednost. V tomto máme jasno – pokud je multimetodě předán vektor, nechť je vypsán jako vektor ve hranatých závorkách, zatímco ostatní kolekce nechť jsou vypsány v kulatých závorkách:

(prefer-method heading clojure.lang.IPersistentVector java.util.Collection)

Vše si samozřejmě otestujeme:

user=> (heading [1 2 3])
-----------------
[1 2 3]
-----------------
 
user=> (heading '(1 2 3))
-----------------
(1 2 3)
-----------------
 
user=> (heading (range 10))
-----------------
(0 1 2 3 4 5 6 7 8 9)
-----------------

Poznámka: v deklaraci prefer-method se vždy
specifikují jen dvě hodnoty, přičemž první hodnota je preferována, ovšem nic
nám nebrání použít více těchto deklarací a vytvořit si tak vlastní
„hierarchii“

12. Finální varianta multimetody heading

Na závěr tohoto článku si ještě uveďme úplnou definici multimetody heading. Namísto uživatelsky definované dispatch funkce je použita funkce class implementovaná v základní knihovně, multimetoda správně (bez vyhození výjimky) reaguje na neznámý typ parametru a u vektorů je jasně rozlišeno, která část multimetody se má zavolat:

(defmulti heading class)
 
(defmethod heading nil
    [value]
    (.write *out* "-----------------\n")
    (.write *out* "nothing")
    (.write *out* "\n-----------------\n"))
 
(defmethod heading String
    [value]
    (.write *out* "-----------------\n")
    (.write *out* value)
    (.write *out* "\n-----------------\n"))
 
(defmethod heading Number
    [value]
    (.write *out* "-----------------\n")
    (.write *out* (str value))
    (.write *out* "\n-----------------\n"))
 
(defmethod heading clojure.lang.IPersistentVector
    [value]
    (.write *out* "-----------------\n")
    (.write *out* "[")
    (.write *out* (clojure.string/join " " value))
    (.write *out* "]")
    (.write *out* "\n-----------------\n"))
 
(defmethod heading java.util.Collection
    [value]
    (.write *out* "-----------------\n")
    (.write *out* "(")
    (.write *out* (clojure.string/join " " value))
    (.write *out* ")")
    (.write *out* "\n-----------------\n"))
 
(defmethod heading :default
    [anything]
    (.write *out* "-----------------\n")
    (.write *out* "I'm confused!")
    (.write *out* "\n-----------------\n"))
 
(prefer-method heading clojure.lang.IPersistentVector java.util.Collection)