V dnešní části seriálu o vlastnostech programovacího jazyka Java i JVM se již naposledy budeme zabývat popisem makrosystému programovacího jazyka Clojure. Popíšeme si některá makra, která vývojáři tvořící aplikace v jazyce Clojure využívají v podstatě každý den, i když si někdy neuvědomují, že volají makra a nikoli běžné funkce či speciální formy.
1. Programovací jazyk Clojure 17: využití standardních maker v praxi
5. Univerzální podmíněné provádění příkazů s využitím makra cond
6. Makro while další poněkud skrytá „nefunkcionální“ řídicí konstrukce
7. Makro dotimes: další příklad použití tail rekurze v praxi
8. Idiom with-* používaný v programovacích jazycích odvozených od LISPu
V dnešní části seriálu o programovacím jazyce Java i o virtuálním stroji Javy (JVM) dokončíme popis makrosystému jazyka Clojure postaveného nad JVM. V předchozích dvou částech tohoto seriálu jsme si řekli, jakým způsobem jsou makra aplikována (ještě před pokusem o vyhodnocení formy) a na několika demonstračních příkladech jsme si ukázali tvorbu vlastních uživatelských maker, při jejichž zápisu jsme používali takzvaná reader makra nazvaná „syntax-quote“ (zapisováno pomocí zpětného apostrofu), „unqote“ (zapisováno znakem tilda před symbolem) a „unquote-splicing“ (zapisováno znakem tilda následovaného zavináčem). Ovšem i přes možnost použití těchto znaků se speciálním významem je tvorba uživatelských maker poměrně složitá záležitost, protože jejich tvůrci musí zajistit správnou funkci makra i v různých mezních případech – makro je například zavoláno bez parametrů, jeho parametrem jsou jen prázdné závorky namísto očekávaného seznamu příkazů atd.
Nicméně makrosystém programovacího jazyka Clojure je možné využít i bez toho, aby musel vývojář vytvářet svá vlastní uživatelská makra – může totiž využít sadu maker dodávanou jako takřka nedílnou součást samotného Clojure. Některá dále popisovaná makra jsou totiž definována v souboru core.clj, jenž obsahuje definice zcela základních funkcí i maker, bez nichž by v podstatě nebylo možné prakticky používat smyčku REPL (teoreticky by to možné sice bylo, ale čitelnost takto vytvořených programů by nebyla vysoká). U všech dále popisovaných maker bude uvedena i jejich definice, protože právě na příkladu standardních maker se můžeme přiučit nejenom to, jak se mají vyvářet uživatelská makra, ale dozvíme se i základní informace o interní struktuře smyčky REPL. Taktéž si ukážeme některé idiomy používané v mnoha LISPovských programovacích jazycích (v samotném LISPu, Scheme atd.). Například se zmíníme o idiomu (Javisté by možná řekli „o návrhovém vzoru“) with-, jenž lze použít v mnoha místech aplikace, zejména tam, kde se pracuje s externím zdrojem (nebo naopak cílem) dat.
V navazujících kapitolách budou popsána následující standardní makra:
Jedno z nejjednodušších standardních maker definovaných v souboru core.clj se jmenuje comment. Jméno tohoto makra velmi přesně vystihuje, k čemu může být využíváno: do makra comment je totiž možné uzavřít prakticky libovolnou část programu, která bude makrem „sežrána“ (samozřejmě v čase načítání forem) a nebude tedy docházet k pokusu o vyhodnocení takto obaleného bloku. Jedinou podmínkou, kterou musí vývojář používající makro comment v každém případě dodržet, je nutnost vybalancování pravých a levých kulatých závorek v bloku, který je makrem comment obalen. Důvod je prostý – objekt reader totiž musí mít možnost určit, kde volání makra comment končí. Definice tohoto makra je skutečně velmi jednoduchá, protože makro comment očekává libovolné množství parametrů ([& body]), které nejsou žádným způsobem dále použity ani vyhodnocovány, protože tělo makra je prázdné:
; zdrojový kód makra comment
(defmacro comment
"Ignores body, yields nil"
{:added "1.0"}
[& body])
Na druhém řádku definice makra comment je zapsána dokumentace (obdoba Javadocu), na řádku třetím pak metadata o tom, kdy bylo toto makro do jazyka Clojure přidáno. Následuje příklad použití makra comment, který asi nepotřebuje další podrobnější vysvětlení:
; zakomentování formy user=> (comment (println "Hello world!")) nil ; expanze makra comment je vždy stejná: ; ... transformuje jakoukoli formu na nil user=> (macroexpand-1 '(comment (println "Hello world!"))) nil ; zakomentování volání jednoduché funkce user=> (comment (* (6 7))) nil ; zakomentovat lze i volání neexistující funkce ; ... nedojde k chybě, protože se vyhodnocení neuskuteční user=> (comment (foo 6 7)) nil ; pozor si musíme dát pouze na správné vybalancování závorek ; ... zde přebývá pravá složená závorka user=> (comment (println "Hello world!"))) nil RuntimeException Unmatched delimiter: ) clojure.lang.Util.runtimeException (Util.java:170) user=>
Ve zdrojových kódech aplikací vytvářených v programovacím jazyce Clojure můžeme velmi často narazit na volání maker nazvaných when a when-not. Těmto makrům se předává podmínka zapsaná jako forma (tedy výraz) a poté tělo složené z libovolně dlouhé sekvence forem (příkazů). Obě makra se převedou na vyhodnocení prvního předaného výrazu s tím, že pokud je výraz vyhodnocen na hodnotu true u makra when či naopak na hodnotu false u makra when-not, budou zbývající výrazy vyhodnoceny v takovém pořadí, v jakém jsou zadány. Proč se však vlastně tato makra v praxi používají namísto přímého využití speciální formy if? Je to jednoduché – ve speciální formě if je možné uvést pouze jeden příkaz („tělo podmínky“) vyhodnocený jen tehdy, pokud je hodnota předané podmínky rovna true. Pokud programátor potřebuje uzavřít do podmínky větší množství příkazů, použije právě makra when a when-not, kde se tělo podmínky (seznam výrazů) automaticky uzavírá speciální formou do, která zajistí jejich sekvenční provedení. Navíc se při použití when-not vyhne případné nutnosti negování výrazu (podmínky):
; zdrojový kód makra when
(defmacro when
"Evaluates test. If logical true, evaluates body in an implicit do."
{:added "1.0"}
[test & body]
(list 'if test (cons 'do body)))
; zdrojový kód makra when-not
(defmacro when-not
"Evaluates test. If logical false, evaluates body in an implicit do."
{:added "1.0"}
[test & body]
(list 'if test nil (cons 'do body)))
Opět si ukážeme jednoduché příklady použití, včetně expanze maker:
; definice funkce, kterou v makrech when a when-not použijeme user=> (defn greater-than? [x y] (> x y)) #'user/greater-than?
; příklad použití makra when ; (povšimněte si, že návratovou hodnotou "do" ; je návratová hodnota posledního příkazu) user=> (when (greater-than? 2 1) (print 2) (print ">") (print 1)) 2>1nil ; expanze makra when vypadá následovně: user=> (macroexpand-1 '(when (greater-than? 2 1) (print 2) (print ">") (print 1))) (if (greater-than? 2 1) (do (print 2) (print ">") (print 1))) user=>
Makro when-not generuje výraz využívající speciální formu if se třemi parametry: podmínkou, „větví if“ a „větví else“, přičemž „větev if“ obsahuje prázdné tělo – hodnotu nil:
; příklad použití makra when-not user=> (when-not (greater-than? 2 1) (print 2) (print ">") (print 1)) nil ; expanze makra when-not ; (je zde patrné, že se jako druhý parametr speciální ; formy "if" předává vždy nil) user=> (macroexpand-1 '(when-not (greater-than? 2 1) (print 2) (print ">") (print 1))) (if (greater-than? 2 1) nil (do (print 2) (print ">") (print 1))) user=>
Makra when a when-not popsaná v předchozí kapitole nejsou jedinými standardními makry, které do programovacího jazyka Clojure přidávají další řídicí konstrukce (alespoň z pohledu programátora). Dalším takovým dosti často používaným makrem je makro nazvané if-not, jehož význam je již ze samotného názvu tohoto makra zřejmý – jedná se o negaci funkcionality speciální formy if. Připomeňme si, že speciální formu if lze volat se dvěma či třemi parametry. Pokud je tato forma zavolána s dvojicí parametrů, je první parametr chápán jako podmínka a druhý parametr (jenž samozřejmě musí být platnou formou) je vyhodnocen pouze tehdy, pokud je první parametr vyhodnocen na true. V případě, že je speciální forma if zavolána se třemi parametry, slouží poslední parametr jako náhrada „větve else“, ovšem opět se musí jednat pouze o jediný výraz, což je omezení speciální formy if. Toto omezení se v praxi obchází využitím maker when a when-not (viz předchozí kapitolu).
Zatímco těla všech tří maker, s nimiž jsme se seznámili v předchozí dvojici kapitol, byla velmi jednoduchá, je tělo makra if-not již poněkud komplikovanější, a to ze dvou důvodů. První důvod spočívá v tom, že uživatel toto makro bude moci volat se dvěma či třemi parametry, tudíž je nutné vytvořit „multimakro“ s dvojicí těl (multimakro se zapisuje stejným způsobem jako multifunkce – pro každý počet parametrů je zapsáno zvláštní tělo funkce/makra). Druhý důvod větší složitosti makra if-not je způsoben použitím reader maker „syntax-quote“ (zpětný apostrof) a „unquote“ (tilda), díky nimž lze makro zapsat formou šablony, což je doporučovaný způsob zápisu maker, s nímž jsme se podrobněji seznámili v předchozí části tohoto seriálu:
; zdrojový kód makra if-not
(defmacro if-not
"Evaluates test. If logical false, evaluates and returns then expr,
otherwise else expr, if supplied, else nil."
{:added "1.0"}
([test then]
`(if-not ~test ~then nil))
([test then else]
`(if (not ~test) ~then ~else)))
Dodejme jen, že test, then a else nejsou v tomto případě žádná klíčová slova, ale pouze názvy parametrů předávaných makru if-not při jeho volání (názvy parametrů nesmí být quotovány, proto jsou před nimi zapsány tildy).
Jednoduchý příklad použití tohoto makra:
user=> (if-not (zero? (- 1 1)) (println "nenulovy vysledek")) nil user=> (if-not (zero? (- 2 1)) (println "nenulovy vysledek")) nenulovy vysledek nil ; díky použití syntax-quote se rozepíše funkce not na plný název user=> (macroexpand '(if-not (zero? (- 2 1)) (println "nenulovy vysledek"))) (if (clojure.core/not (zero? (- 2 1))) (println "nenulovy vysledek") nil) user=>
Při popisu standardních maker jazyka Clojure nesmíme zapomenout na makro cond, které je nedílnou součástí mnoha programovacích jazyků odvozených od LISPu. Důvod pro tuto oblibu cond (ať již se jedná v konkrétní implementaci jazyka o makro či naopak o speciální formu) je prostý: v původním návrhu programovacího jazyka LISP byl tento jazyk kromě smyčky REPL doplněn o sedm základních funkcí a dvě speciální formy: atom, car, cdr, cond, cons, eq, quote, lambda a label.
Existence smyčky REPL a těchto sedmi speciálních forem/funkcí skutečně stačila pro vytvoření plnohodnotného (i když zpočátku ne příliš praktického) programovacího jazyka. V případě Clojure je situace vlastně zcela opačná, protože základní speciální formou používanou pro konstrukci podmínek, je speciální forma if, z níž je relativně snadné vytvořit makro cond. U některých implementací LISPu je tomu přesně naopak – základní speciální formou je zde cond a if je implementován jako makro.
Vraťme se však k makru cond použitém v programovacím jazyku Clojure. Toto makro akceptuje libovolný počet dvojic test-příkaz. Jednotlivé testy (jde samozřejmě o výrazy – formy) se postupně vyhodnocují a v případě, že se vyhodnotí na hodnotu true, vrátí makro cond hodnotu vyhodnoceného příkazu. V opačném případě se vyhodnotí další test atd. Pokud se ani jeden test nevyhodnotí na logickou hodnotu true, vrátí toto makro hodnotu nil. U makra cond je zajímavé prostudovat jeho stavbu, protože zde najdeme jak test na počet předávaných parametrů (musí být sudý, neboť jde vždy o dvojice test-příkaz), tak i rekurzi. Při rekurzivním volání makra se mu předají všechny původní parametry kromě prvních dvou (přesněji řečeno kromě první dvojice test-příkaz). Zkuste se sami zamyslet nad tím, kdy přesně k rekurzi dochází:
(defmacro cond
"Takes a set of test/expr pairs. It evaluates each test one at a
time. If a test returns logical true, cond evaluates and returns
the value of the corresponding expr and doesn't evaluate any of the
other tests or exprs. (cond) returns nil."
{:added "1.0"}
[& clauses]
(when clauses
(list 'if (first clauses)
(if (next clauses)
(second clauses)
(throw (IllegalArgumentException.
"cond requires an even number of forms")))
(cons 'clojure.core/cond (next (next clauses))))))
Na příkladu použití makra cond je patrné, že velmi efektivním způsobem dokáže nahradit jak příkaz switch-case, tak i sekvenci příkazů if-elseif-elseif-else, které se mnohdy nevyhneme v jiných programovacích jazycích. Zajímavé je zde i použití :else, což je keyword (ty se zapisují s dvojtečkou před symbolem). Využívá se zde faktu, že if :keyword … vždy povede k vyhodnocení těla speciální formy if; ovšem skalní LISPaři pravděpodobně v poslední větvi cond použijí namísto testu přímo hodnotu true (v LISPu jen T):
; definice funkce, v níž je využito makro cond
(defn znamka
[body]
(cond
(>= body 95) "A"
(>= body 80) "B"
(>= body 70) "C"
(>= body 60) "D"
(>= body 50) "E"
:else "F"))
; test funkce znamka
user=> (znamka 0)
"F"
; test funkce znamka
user=> (znamka 50)
"E"
; test funkce znamka
user=> (znamka 90)
"B"
; test funkce znamka
user=> (znamka 100)
"A"
; složitější příklad
user=> (map znamka (range 0 101 10))
("F" "F" "F" "F" "F" "E" "D" "C" "B" "B" "A")
user=>
Dalším standardním makrem, o němž se v dnešním článku zmíníme, je makro nazvané while. Asi správně uhodnete, že toto makro iterativně spouští (či lépe řečeno postupně vyhodnocuje) nějaké tělo smyčky, a to tak dlouho, dokud platí, že výraz zapsaný za while se vyhodnotí na pravdivostní hodnotu true. Povšimněte si, že se opět tiše předpokládá, že tělo smyčky bude mít nějaký vedlejší efekt jenž způsobí změnu hodnoty výrazu smyčky while (nejedná se tedy z pohledu funkcionálního programátora o příliš šťastně vytvořenou konstrukci). Typickým vedlejším efektem je nastavení hodnoty nějaké lokální či globální proměnné. Pravděpodobně taktéž uhodnete, jak je makro while interně implementováno – musí se v něm použít rekurze a to dokonce tail rekurze, která je v programovacím jazyce Clojure představována dvojicí loop-recur. Jak loop tak i recur jsou speciální formy tvořící základní jazykové konstrukce využitelné programátorem:
; definice makra while
(defmacro while
"Repeatedly executes body while test expression is true. Presumes
some side-effect will cause test to become false/nil. Returns nil"
{:added "1.0"}
[test & body]
`(loop []
(when ~test
~@body
(recur))))
Demonstrační příklad bude asi dosti netypický:
user=> (while (> (Math/random) 0.1) (println "Stale pocitam")) Stale pocitam Stale pocitam Stale pocitam Stale pocitam Stale pocitam Stale pocitam Stale pocitam Stale pocitam Stale pocitam nil user=>
Expanze výše vypsané „smyčky while“ vypadá takto:
user=> (macroexpand-1 '(while (> (Math/random) 0.1) (println "Stale pocitam")))
(clojure.core/loop
[]
(clojure.core/when (> (Math/random) 0.1)
(println "Stale pocitam") (recur)))
; (výstup byl zarovnán ručně)
user=>
V některých typech aplikací může být poměrně užitečné použít makro nazvané jednoduše a přitom příhodně dotimes, které dokáže předaný výraz (formu) opakovat n krát. Přitom toto makro může v každé iteraci (opakování) nastavit zvolenou lokální proměnnou na aktuální hodnotu počitadla, přičemž se hodnota počitadla v první iteraci vždy nastavuje na nulu a v poslední iteraci dosahuje zadaného počtu opakování-1. Vzdáleně tedy můžeme toto makro považovat za ekvivalent programové smyčky for i in range(n): v programovacím jazyku Python či ekvivalent k počítané smyčce for (int i = 0; i<n; i++) známé z céčka (zde bez možnosti mít lokální proměnnou jako počitadlo), C++, Javy atd. Vzhledem k tomu, že se předpokládá, že forma – tělo smyčky – předaná makru dotimes bude mít nějaký vedlejší efekt, nejedná se sice o čistě funkcionální přístup, nicméně makro dotimes může být skutečně velmi užitečné, například při práci s poli (jejich použití v aplikaci je většinou diktováno snahou o dosažení větší efektivity programu).
; definice makra dotimes je na první pohled dosti komplikovaná
; (povšimněte si použití makra when uvnitř definice jiného makra)
(defmacro dotimes
"bindings => name n
Repeatedly executes body (presumably for side-effects) with name
bound to integers from 0 through n-1."
{:added "1.0"}
[bindings & body]
; kontroly
(assert-args
(vector? bindings) "a vector for its binding"
(= 2 (count bindings)) "exactly 2 forms in binding vector")
; vlastní výkonné tělo makra
; využívající dvojici lokálních proměnných i a n
(let [i (first bindings)
n (second bindings)]
`(let [n# (long ~n)]
(loop [~i 0]
(when (< ~i n#)
~@body
(recur (unchecked-inc ~i)))))))
Příklad použití makra dotimes jsme si již v tomto seriálu ukazovali:
(dotimes [i 10]
(dotimes [j 10]
(print (* (inc i) (inc j)) "\t"))
(println))
A zde je již výsledek práce tohoto skriptu (poslední nil je návratovou hodnotou makra dotimes):
1 2 3 4 5 6 7 8 9 10 2 4 6 8 10 12 14 16 18 20 3 6 9 12 15 18 21 24 27 30 4 8 12 16 20 24 28 32 36 40 5 10 15 20 25 30 35 40 45 50 6 12 18 24 30 36 42 48 54 60 7 14 21 28 35 42 49 56 63 70 8 16 24 32 40 48 56 64 72 80 9 18 27 36 45 54 63 72 81 90 10 20 30 40 50 60 70 80 90 100 nil
Na expanzi výrazu:
(dotimes [i 10] (println i))
je patrné použití lokálních symbolů s jedinečným jménem:
user=> (macroexpand-1 '(dotimes [i 10] (println i)))
(clojure.core/let [n__4220__auto__ (clojure.core/long 10)]
(clojure.core/loop
[i 0]
(clojure.core/when (clojure.core/< i n__4220__auto__)
(println i)
(recur (clojure.core/unchecked-inc i)))))
; (výstup byl zarovnán ručně)
user=>
Při tvorbě reálných aplikací v programovacím jazyku Clojure se poměrně často setkáme s následujícím problémem: máme za úkol otevřít nějaký zdroj dat (databázi, soubor…), přečíst z tohoto zdroje data a posléze zdroj dat opět zavřít. Dalším praktickým problémem je nastavení přesnosti a zaokrouhlovacího režimu pro objekty typu BigDecimal, provedení nějaké matematické operace a následně obnovení původní přesnosti a zaokrouhlovacího režimu. Všechny tyto problémy tedy vyžadují, aby se provedla nějaká nastavovací operace, která většinou mění prostředí programu, posléze se provede vlastní výpočet/sekvence příkazů a nakonec se obnoví původní prostředí programu. Takto chápané operace se v programovacím jazyce Clojure poměrně často implementují s využitím maker, jejichž název začíná na with-. Příkladem může být makro with-precision pro dočasnou změnu přesnosti a zaokrouhlovacího režimu pro objekty typu BigDecimal (viz předchozí text):
user=> (with-precision 1 (/ 1M 3)) 0.3M user=> (with-precision 2 (/ 1M 3)) 0.33M user=> (with-precision 10 (/ 1M 3)) 0.3333333333M user=>
Příkladem takto pojatého makra je poměrně užitečné standardní makro with-out-str, které dokáže „zachytit“ všechna volání funkcí print a println. Řetězce, které by se pomocí těchto funkcí normálně vypsaly na standardní výstup, jsou namísto využity jako návratová hodnota makra:
user=> (with-out-str (print "Hello ") (print "world") (print '!)) "Hello world!" user=> (def vystup (with-out-str (print "Hello ") (print "world") (print '!))) #'user/vystup user=> vystup "Hello world!" user=>
Jak již bylo řečeno v úvodním odstavci, pracují makra with- takovým způsobem, že dočasně změní prostředí programu. Nejinak je tomu i v případě makra with-out-str, kde se dočasně změní objekt navázaný na symbol *out*, jenž představuje standardní výstup, neboli v řeči Javy System.out. Symbol *out* je při provádění příkazů předaných makru přesměrován na novou instanci objektu java.io.StringWriter, který je po provedení těla převeden na řetězec s využitím funkce str:
(defmacro with-out-str
"Evaluates exprs in a context in which *out* is bound to a fresh
StringWriter. Returns the string created by any nested printing
calls."
{:added "1.0"}
[& body]
`(let [s# (new java.io.StringWriter)]
(binding [*out* s#]
~@body
(str s#))))
Jediným neznámým symbolem je zde binding, což je další makro, které dokáže dočasně (v rámci provádění těla) navázat na nějaký symbol jinou hodnotu.
Root.cz (www.root.cz)
Informace nejen ze světa Linuxu. ISSN 1212-8309
Copyright © 1998 – 2018 Internet Info, s.r.o. Všechna práva vyhrazena. Powered by Linux.
