Obsah
1. Tvorba skutečných aplikací programů v programovacím jazyce Clojure
4. Role a vlastnosti funkcí ve funkcionálních programovacích jazycích
5. Vytvoření uživatelských funkcí
6. Zjednodušená deklarace funkcí, funkce s více aritami
7. Programové smyčky ve funkcionálních jazycích? Nikoli, spíše rekurze!
8. Možné problémy s rekurzí a řešení těchto problémů – tail rekurze
1. Tvorba skutečných aplikací v programovacím jazyce Clojure
V předchozí části seriálu o programovacím jazyce Java i o vlastnostech virtuálního stroje tohoto jazyka jsme dokončili popis způsobu zápisu všech čtyř typů forem, z nichž se skládají všechny zdrojové kódy napsané v programovacím jazyce Clojure. Taktéž jsme si řekli, že s využitím takzvaných složených forem je možné zapsat jak kolekce (v Clojure především seznamy, vektory, množiny, mapy – asociativní pole), tak i volání funkcí, protože způsob zápisu volání funkcí odpovídá v Clojure – a taktéž v LISPu či Scheme – zápisu seznamu, přičemž první prvek seznamu v tomto případě představuje jméno funkce (resp. přesněji řečeno symbol navázaný na funkci) a další prvky seznamu jsou (po vyhodnocení) volané funkci předány jako její parametry. Připomeňme si také, že kromě složených forem bylo nutné programovací jazyk Clojure vybavit i takzvanými speciálními formami, které jsou obecně zpracovávány odlišným způsobem – většinou se například nevyhodnocují jejich parametry.
Jen pro malé připomenutí si v této kapitole uvedeme několik demonstračních příkladů, na nichž bude ukázán způsob použití složených forem (seznamů, vektorů, množin a map) a taktéž speciálních forem, přesněji řečeno prozatím jen speciální formy if.
Základní složenou formou je seznam (list), což ostatně nebude velkým překvapením, neboť Clojure je potomek jazyka LISP, jehož název je odvozen od sousloví „LISt Processing“. V následujícím příkladu je vytvořen seznam obsahující další seznamy (zde se vlastně jedná o nevyvážený binární strom). Apostrof před seznamem musí být uveden z toho důvodu, aby se celý zápis nechápal jako volání funkce navázané na symbol 1. Taková funkce totiž neexistuje a ani existovat nemůže, neboť jméno symbolu nemůže začínat číslicí:
user=> '(1 (2 (3 (4 5)))) (1 (2 (3 (4 5))))
Následuje ukázka zápisu vektoru. Vzhledem k tomu, že v případě vektorů lze velmi efektivně přistupovat k jeho prvkům pomocí indexů, podobají se vektory javovskému typu pole/array:
user=> [ [1 2 3] [4 5 6] [7 8 9]] [[1 2 3] [4 5 6] [7 8 9]]
Všechny kolekce lze samozřejmě různým způsobem kombinovat; například zde je uveden vektor seznamů:
user=> [ '(:jedna :dva) '(:tri :ctyri) '(:pet :sest) ] [(:jedna :dva) (:tri :ctyri) (:pet :sest)]
Mapa, popř. též asociativní pole, se v reálných aplikacích používá poměrně často, neboť odstraňuje některé nevýhody seznamů i vektorů:
user=> {:prvni 1, :druhy 2}
{:druhy 2, :prvni 1}
Zbývají nám již jen množiny:
user=> #{"toto" "je" "mnozina"}
#{"mnozina" "toto" "je"}
Příklad volání funkcí * (součin) a + (součet):
user=> (* (+ 1 2 3) (+ 3 4)) 42
Příklad použití speciální formy if:
; na základě podmínky se vyhodnotí (a vrátí jako výsledek) ; buď řetězec "mensi" nebo "vetsi" (if (< 1 2) "mensi" "vetsi") "mensi"
V tomto případě je zaručeno, že se na základě podmínky – tedy prvního parametru speciální formy if – vyhodnotí buď druhý parametr nebo třetí parametr, nikoli však oba parametry současně. Právě z tohoto důvodu je if implementován jako speciální forma a nikoli jako běžná složená forma – funkce.
2. Speciální forma def
První speciální formou, s níž se dnes seznámíme, je speciální forma nazvaná def. Ta se většinou používá k navázání libovolné hodnoty (například čísla, pravdivostní hodnoty, řetězce, seznamu a jak uvidíme dále, tak i funkce) na symbol. Méně časté je použití této speciální formy k pouhému vytvoření symbolu. V případě, že Clojure vyhodnotí („spustí“) tuto speciální formu, dojde k vytvoření nové globální proměnné v aktuálně nastaveném jmenném prostoru (nejde tedy o skutečnou globální proměnnou, ale o proměnnou identifikovatelnou přes jmenný prostor – viz dále) a k inicializaci této proměnné. Pokud již globální proměnná stejného jména existuje, dojde k „přepisu“ její hodnoty. Ve skutečnosti však stará hodnota nemusí přestat existovat, protože může být navázána na další proměnné. Navíc je možné pomocí nepovinného parametru k proměnné přiřadit i dokumentační řetězec; jak se to dělá, si ukážeme v jednom demonstračním příkladu.
Poznámka: Clojure nám sice bez jakéhokoli varování umožní změnit hodnotu globální proměnné s využitím formy def, ovšem v praxi se tento obrat nedoporučuje používat, protože změna těchto proměnných obecně není ve vícevláknových programech bezpečná a programová změna globálních proměnných je z tohoto důvodu považována za špatný návyk. Naproti tomu manuální změna je možná a někdy i nutná.
Podívejme se nyní na demonstrační příklady, na nichž je ukázán základní způsob použití speciální formy def:
Vytvoření nové globální proměnné nazvané message a její použití ve funkci println (co tato funkce dělá pravděpodobně není zapotřebí podrobně vysvětlovat :-):
user=> (def message "Hello world") #'user/message user=> (println message) Hello world nil
Vytvoření globálních proměnných x a y s jejich inicializací pomocí číselného literálu. Posléze se vytvoří třetí globální proměnná nazvaná answer a naplní se výsledkem vyhodnocené formy (* x y). Následně je hodnota globální proměnné answer vytištěna, protože jméno proměnné se vždy vyhodnotí na její hodnotu:
user=> (def x 6) #'user/x user=> (def y 7) #'user/y user=> (def answer (* x y)) #'user/answer user=> answer 42
Jak jsme se již řekli v úvodním odstavci této kapitoly, je možné ke globální proměnné přiřadit i takzvaný dokumentační řetězec:
user=> (def answer "Odpoved na otazku o ... vesmiru, zivote a vubec" 42) #'user/answer
Tento dokumentační řetězec lze kdykoli zobrazit s využitím makra doc:
user=> (doc answer) ------------------------- user/answer Odpoved na otazku o ... vesmiru, zivote a vubec
Bližší informace o tomto makru podá samozřejmě příkaz:
(doc doc) ------------------------- clojure.repl/doc ([name]) Macro Prints documentation for a var or special form given its name
3. Jmenné prostory
V předchozí kapitole jsme se poprvé explicitně zmínili o takzvaných jmenných prostorech. Jmenné prostory byly do programovacího jazyka Clojure přidány zejména z toho důvodu, že použití globálních symbolů je v reálných programech velmi nebezpečné a to zejména proto, že jiná část programu, která může být klidně vytvořena i jiným vývojářem, může nechtěně předeklarovat již existující globální symbol. Co je ještě horší – tato předeklarace nemusí nutně vést k okamžité chybě při práci s programem (ideálně při jeho testování), ale může se projevit až při určité shodě okolností – podle všeobecně platného zákona tedy ve chvíli, kdy se aplikace předvádí šéfovi či zákazníkovi :-). Připomeňme si, že mezi globální symboly patří i symboly představující jména funkcí, takže je asi představitelné, co by se stalo, kdyby nějaká importovaná knihovna náhodou obsahovala funkci pojmenovanou stejně, jako funkce vytvořená programátorem vyvíjené aplikace. Jmenné prostory proto představují jeden z možných způsobů, jak tento problém poměrně elegantně vyřešit.
My jsme se již vlastně s jedním jmenným prostorem setkali v textech vypisovaných smyčkou REPL, i když jsme si prozatím nevysvětlili, že se skutečně jedná o jmenný symbol. Při používání smyčky REPL je totiž jméno aktuálního jmenného prostoru vypisováno jako součást výzvy (prompt):
user=>
V programovacím jazyku Clojure je možné vytvořit takřka libovolný počet jmenných prostorů a posléze se mezi těmito jmennými prostory přepínat, tj. lze zvolit, který jmenný prostor bude jmenným prostorem aktuálním. Pro tuto činnost se používá makro nazvané ns:
(ns název_jmenného_prostoru)
Podívejme se nyní na jednoduchý demonstrační příklad, v němž jsou vytvořeny dvě globální proměnné nazvané answer. Každé proměnné je přiřazena jiná hodnota a každá proměnná tudíž musí být uložena v jiném jmenném prostoru. Povšimněte si taktéž toho, jak se změní výzva (prompt) při přepnutí aktuálního jmenného prostoru:
; vytvoření globální proměnné umístěné ve jmenném prostoru "user" user=> (def answer 42) #'user/answer ; jméno proměnné se vyhodnotí na hodnotu proměnné user=> answer 42 ; vytvoření nového jmenného prostoru nazvaného "novy" user=> (ns novy) nil ; lze v tomto jmenném prostoru vyhodnotit (=najít) proměnnou answer? novy=> answer CompilerException java.lang.RuntimeException: Unable to resolve symbol: answer in this context, compiling:(NO_SOURCE_PATH:0) ; vytvoření nové globální proměnné ve jmenném prostoru "novy" novy=> (def answer "?") #'novy/answer ; její hodnotu nyní můžeme získat (vyhodnotit), aniž by došlo k chybě novy=> answer "?" ; přepnutí jmenného prostoru novy=> (ns user) nil ; nyní je opět viditelná první globální proměnná se jménem answer user=> answer 42
Ve skutečnosti však nejsou jednotlivé jmenné prostory od sebe izolovány, takže se můžeme odkazovat na symbol umístěný v jiném jmenném prostoru pomocí zápisu jmenný_prostor/symbol. Ostatně i kvůli podpoře tohoto způsobu zápisu není možné použít znak / ve jméně žádného symbolu (znaky * či – je však možné použít, což se taktéž často děje, protože – se používá pro oddělení jednotlivých slov v názvu symbolu a hvězdička je podle konvencí používána pro konstanty). Podívejme se nyní na způsob využití zápisu jmenný_prostor/symbol:
; přepnutí jmenného prostoru user=> (ns user) nil ; proměnná z aktuálního jmenného prostoru user=> answer 42 ; proměnná z jiného jmenného prostoru user=> novy/answer "?" ; přepnutí jmenného prostoru user=> (ns novy) nil ; proměnná z aktuálního jmenného prostoru novy=> answer "?" ; proměnná z aktuálního jmenného prostoru novy=> novy/answer "?" ; proměnná z jiného jmenného prostoru novy=> user/answer 42
4. Role a vlastnosti funkcí ve funkcionálních programovacích jazycích
V dnešním článku se budeme zabývat především popisem tvorby uživatelských funkcí v programovacím jazyku Clojure. Připomeňme si, že Clojure patří mezi funkcionální jazyky, které se kromě dalších zajímavých vlastností vyznačují i tím, že funkce jsou v nich zpracovávány prakticky stejným způsobem, jako jiné hodnoty, například celá čísla či řetězce. Pro tuto vlastnost funkcionálních programovacích jazyků se většinou používá termín first-class functions, ale již méně často se vysvětluje, co vlastně tento termín v daném programovacím jazyku znamená. Ukažme si pro začátek, jakým způsobem se vlastně pracuje s běžnými hodnotami, a to nikoli ve funkcionálním jazyku, ale v jazyku objektově orientovaném – v Javě. V následujícím demonstračním příkladu je použita celočíselná hodnota 42, která je využita hned několika různými způsoby:
public class Test {
int testMethod(int param) {
// hodnotu je možné uložit do proměnné (navázat na jméno)
int i = 42;
// hodnotu je možné použít ve výrazu
// (zde není na žádné jméno navázána)
int j = param * i * 42;
// hodnotu je možné předat volané metodě (funkci)
j += Math.max(42, param);
// hodnotu je možné vrátit při ukončení metody (funkce)
return 42;
}
public static void main(String[] args) {
// hodnotu je možné předat jako parametr metody (funkce)
new Test().testMethod(42);
}
}
Tento způsob práce s hodnotami mají prakticky všichni programátoři zažitý a vlastně je vůbec nepřekvapuje. Již menší množství vývojářů je však seznámeno s tím, že ve funkcionálních jazycích je možné namísto slova hodnota použít i slovo funkce, protože funkce jsou, jak již víme, v těchto jazycích plnohodnotnými hodnotami. S vědomím toho, jak se s hodnotami zacházelo v předchozím demonstračním příkladu a toho, že ve funkcionálních jazycích lze s funkcemi pracovat stejně jako s jinými hodnotami, tedy lze říci, že funkce mají mj. i tyto vlastnosti:
- Funkce mohou být vytvořeny kdykoli v čase běhu programu (runtime). To, jak je funkce v runtime přeložena, je již interní záležitostí daného programovacího jazyka.
- Funkce mohou být uloženy do proměnné (resp. přesněji řečeno navázány na jméno proměnné) či mohou být uloženy do jakékoli datové struktury (seznam funkcí, vektor funkcí atd.)
- Funkce mohou být předány jako parametr do jiné funkce.
- Funkce může být vrácena ve formě návratové hodnoty jiné funkce.
- Jméno sice není součástí funkce, ovšem funkce může být na jméno (symbol) navázána. Toto je pravděpodobně jedna z nejvíce matoucích vlastností funkcionálních jazyků, protože z jazyků procedurálních jsme zvyklí na to, že funkce vždy má jméno, které je v naprosté většině případů známé již v době překladu. U jazyků funkcionálních (popř. jazyků hybridních) se však velmi často používají funkce beze jména, neboli funkce anonymní.
5. Vytvoření uživatelských funkcí
Již známe alespoň základní vlastnosti funkcí v Clojure, jak se však funkce v tomto programovacím jazyku skutečně definují? Pro vytvoření nové bezejmenné (tj. anonymní) funkce se používá speciální forma nazvaná fn, které se v tom nejjednodušším případě předá vektor obsahující jména parametrů, za nímž je uveden seznam, jenž představuje tělo funkce (znalci LISPu patrně znají formu lambda, která má podobný význam). Samozřejmě, že v těle funkce je možné použít symbolická jména jejích parametrů a návratovou hodnotou funkce je hodnota získaná vyhodnocením těla funkce. Speciální forma fn při použití ve smyčce REPL vypíše řetězec, který reprezentuje interní identifikátor funkce – jinými slovy na tento řetězec můžeme v naprosté většině případů zapomenout, protože se s ním přímo nepracuje. Ukažme si tedy způsob deklarace funkce se dvěma parametry pojmenovanými x a y, která vypočítá a vrátí součin těchto parametrů:
user=> (fn [x y] (* x y)) #<user$eval46$fn__47 user$eval46$fn__47@1697b67>
Co se vlastně stalo? Vytvořili jsme novou funkci, která však nebyla přiřazena k žádnému symbolu (tj. nebyla „pojmenována“) ani jsme tuto funkci nikde nezavolali. Výše uvedený zápis je tedy prakticky stejně užitečný, jako prosté zapsání jakékoli hodnoty nebo symbolu na vstup smyčky REPL. Pokud by se funkce měla zavolat, lze použít nám již známý zápis ve tvaru seznamu – již víme, že prvním parametrem vyhodnocovaného seznamu (není před ním apostrof!) je funkce a dalšími prvky pak parametry této funkce:
user=> ((fn [x y] (* x y)) 6 7) 42
Sice je pěkné, že jsme dokázali funkci zavolat s předáním parametrů, ovšem mnohdy (ne vždy!) je nutné funkci „pojmenovat“, přesněji řečeno ji přiřadit k symbolu. My vlastně již víme, jak se to dělá, protože funkce jsou hodnotami a pro přiřazení symbolu k hodnotě se používá speciální forma def. Tudíž následující zápis je sice zdlouhavý, ale zcela korektní:
user=> (def multiply (fn [x y] (* x y))) #'user/multiply
Předchozím příkazem jsme vytvořili novou funkci a navázali ji na symbol, tudíž došlo k jejímu pojmenování. Nyní je již možné funkci zavolat s využitím navázaného symbolu. Samozřejmě se zde opět využívá nám již známý zápis ve tvaru seznamu:
user=> (multiply 7 8) 56
6. Zjednodušená deklarace funkcí, funkce s více aritami
Vzhledem k tomu, že se uživatelské funkce v reálných programech vytváří a současně i pojmenovávají velmi často, vznikla potřeba nahradit zápis (def název (fn parametry (tělo))) něčím kratším, ideálně i s použitím menšího množství závorek. Pro tyto účely vzniklo makro se jménem defn, které se až na malé detaily podobá LISPovskému zápisu defun. Při použití makra defn se v tom nejjednodušším případě předávají tři parametry: název nově vytvářené funkce, vektor obsahující jména parametrů funkce a konečně seznam představující tělo této funkce. Naši funkci multiply tedy můžeme vytvořit a současně i pojmenovat následujícím způsobem:
user=> (defn multiply [x y] (* x y)) #'user/multiply
A ihned ji můžeme použít:
user=> (multiply 6 7) 42
Zbývá jen dodat, že nově vytvořená funkce je polymorfní vzhledem k typům parametrů, protože se její chování liší v závislosti na tom, jaké hodnoty jsou funkci v čase běhu programu předány. Ukažme si to na příkladech tří typů numerických hodnot: celých čísel, zlomků a hodnot typu BigDecimal:
user=> (multiply 6 7) 42 user=> (multiply 1/2 1/3) 1/6 user=> (multiply 10000000M 2000000M) 20000000000000M user=>
V programovacím jazyku Clojure lze vytvářet i funkce s proměnným počtem parametrů (ukážeme si příště) a s proměnnou aritou. Jen pro zajímavost se nyní podívejme na způsob, jakým se vytvoří funkce multiply, kterou lze volat s jedním parametrem, se dvěma parametry popř. alternativně se třemi parametry. Tělo této funkce je pokaždé odlišné:
user=> (defn multiply ([x] (* x x)) ([x y] (* x y)) ([x y z] (* x y z))) #'user/multiply
Výše popsaný způsob zápisu není moc čitelný, proto si ještě jednou funkci multiply rozepíšeme tak, jak je to v Clojure/LISPu zvykem:
(defn multiply
([x]
(* x x))
([x y]
(* x y))
([x y z] (* x y z)))
Vidíme, že vektor parametrů i těla jednotlivých variant jsou uloženy ve zvláštním seznamu.
Můžeme se pustit do testování:
; volání varianty funkce multiply s jedním parametrem user=> (multiply 6) 36 ; volání varianty funkce multiply se dvěma parametry user=> (multiply 6 7) 42 ; volání varianty funkce multiply se třemi parametry user=> (multiply 6 7 8) 336 ; použití čtyř parametrů povede k chybě při pokusu o vyhodnocení formy user=> (multiply 6 7 8 9) ArityException Wrong number of args (4) passed to: user$multiply clojure.lang.A Fn.throwArity (AFn.java:437)
7. Programové smyčky ve funkcionálních jazycích? Nikoli, spíše rekurze!
Dostáváme se k další, možná poněkud kontroverzní vlastnosti programovacího jazyka Clojure. Tento jazyk totiž, podobně jako mnohé další programovací jazyky, preferuje rekurzi před masivním používáním programových smyček. Jsou pro to samozřejmě dobré důvody, jak teoretické, tak i praktické (opět jde o paralelní výpočty). Ve skutečnosti je však Clojure jazykem orientovaným na praktické použití, takže ve skutečnosti obsahuje „nefunkcionální“ smyčku while (samozřejmě nejde o příkaz, ale v tomto případě o makro), popř. o ryze „funkcionální“ makro for používané při zpracování seznamů. Toto makro je všestranné a současně i velmi užitečné, proto se s ním příště seznámíme podrobněji. Vraťme se však k rekurzi. V Clojure lze většinou použít přímý zápis rekurze, tj. v těle vytvářené funkce se může objevit volání této funkce. Zcela typickým příkladem rekurzivní funkce je funkce pro výpočet faktoriálu, jejíž jednoduchá varianta (neochráněná před všemi typy vstupů) může vypadat takto:
user=> (defn fact [n] (if (<= n 1) 1 (* n (fact (- n 1))))) #'user/fact
Pokud jste se – stejně jako já – ztratili v závorkách, použijeme místo málo čitelného one-lineru strukturovanější zápis, kde je zřejmé, jak je funkce vytvořena:
(defn fact
[n]
(if (<= n 1)
1
(* n (fact (- n 1)))))
Ihned můžeme provést jednoduchý test:
user=> (fact 0) 0 user=> (fact 1) 1 user=> (fact 10) 3628800
Faktoriál se však nemusí počítat pouze s celými čísly reprezentovanými interně jako hodnoty typu int. Můžeme využít i již vícekrát zmíněného faktu, že Clojure dokáže provádět výpočty i s hodnotami, které v programovacím jazyku Java odpovídají instancím tříd java.math.BigInteger a java.math.BigDecimal. Můžeme se například pokusit vypočítat 100!. Zde je již nutné v Clojure použít za konstantou znak M, aby se výpočet neprováděl pouze s čísly typu int:
user=> (fact 100M) 93326215443944152681699238856266700490715968264381621468592963895217599993229915 608941463976156518286253697920827223758251185210916864000000000000000000000000M
Přílišnému nadšení nad tím, jak jednoduše nyní můžeme počítat faktoriál z libovolně velkého čísla, však nepodléhejme, protože například již pro 10000! dojde k nepříjemnému překvapení:
user=> (fact 10000M) StackOverflowError clojure.lang.PersistentHashMap$BitmapIndexedNode.index (Per sistentHashMap.java:510)
Důvodem vedoucím ke vzniku této chyby i způsobem její nápravy se budeme zabývat v následující kapitole.
8. Možné problémy s rekurzí a řešení těchto problémů – tail rekurze
Důvod, proč předchozí volání funkce fact skončilo s chybou, spočívá v tom, že došlo k přeplnění zásobníku při rekurzivním volání. Na zásobník se totiž musí ukládat parametry předávané volané funkci a taktéž body návratu (zjednodušeně řečeno návratové adresy). Aby k přetečení zásobníku nedocházelo, můžeme naši funkci fact upravit tak, aby se využívalo takzvané tail rekurze. Velmi zjednodušeně řečeno je tail rekurze použita tehdy, pokud je posledním příkazem nějaké funkce příkaz pro rekurzivní volání té samé funkce. V tomto případě se nemusí na zásobník nic ukládat a namísto toho se prostě provede skok. V Clojure se však musí tail rekurze zapsat explicitně, což má své přednosti i zápory (podle mě převažují přednosti, protože již ze zápisu programu je zcela zřejmé, kdy k tail rekurzi skutečně dojde).
Na základě informací, které jsme se dozvěděli v předchozím textu, se tedy pokusme upravit původní čistě rekurzivní způsob zápisu funkce pro výpočet faktoriálu takovým způsobem, aby bylo možné využít tail rekurzi. Funkci je nutné upravit tak, aby jejím posledním příkazem bylo opět volání fact – u původní verze tomu tak nebylo, protože posledním příkazem bylo násobení. První pokus o úpravu spočívá v zavedení akumulátoru výsledku:
(defn fact
[n acc]
(if (<= n 1)
acc
(fact (- n 1) (* acc n))))
Zápis můžeme zjednodušit náhradou (- n 1) za (dec n):
(defn fact
[n acc]
(if (<= n 1)
acc
(fact (dec n) (* acc n))))
Ovšem stále je zde jeden problém – z původní funkce s jedním parametrem se nyní stala funkce, jíž je nutné předávat i druhý parametr, který navíc musí být nastavený na jedničku. Náprava je prostá a spočívá v použití funkce fact s volitelnou aritou (popř. by bylo možné vytvořit pomocnou funkci, ovšem mě se následující zápis líbí více, protože se zbytečně nevytváří pomocné funkce):
(defn fact
([n]
(fact n 1))
([n acc]
(if (<= n 1)
acc
(fact (dec n) (* acc n)))))
Výše uvedená funkce již může využívat tail rekurze, ovšem jak jsme si již řekli, je nutné tail rekurzi zapsat explicitně. Proto i zde dojde k chybě při přetečení zásobníku (na rozdíl od mnoha LISPů):
user=> (fact 10000M) StackOverflowError clojure.lang.PersistentHashMap$BitmapIndexedNode.index (Per sistentHashMap.java:510)
Explicitní zápis rekurze spočívá ve využití speciální formy recur, která se zapíše přesně do místa, kde má k tail rekurzi (=skoku) dojít:
(defn fact
([n]
(fact n 1))
([n acc]
(if (<= n 1)
acc
(recur (dec n) (* acc n)))))
Pokud máte dostatek paměti a trpělivosti, můžete zadat tento příkaz a zjistit, zda dojde či nedojde k přetečení zásobníku:
user=> (fact 10000M)
Mohlo by se zdát, že by překladač programovacího jazyka Clojure snad bylo možné zmást a použít recur jako náhradu skoku kdekoli. Ve skutečnosti si však překladač hlídá, zda je recur použito správně:
(defn fact
[n]
(if (<= n 1)
1
(* n (recur (- n 1)))))
CompilerException java.lang.UnsupportedOperationException: Can only recur from t
ail position, compiling:(NO_SOURCE_PATH:24)
Pokud vám použití rekurze či tail rekurze z nějakého důvodu vadí, vězte, že ve skutečně velkém množství případů je řešením použití již zmíněného makra for, které si představíme příště.
9. Odkazy na Internetu
- Clojure home page
http://clojure.org/downloads - Clojure – Functional Programming for the JVM
http://java.ociweb.com/mark/clojure/article.html - Clojure quick reference
http://faustus.webatu.com/clj-quick-ref.html - 4Clojure
http://www.4clojure.com/ - ClojureDoc
http://clojuredocs.org/ - Clojure (Wikipedia EN)
http://en.wikipedia.org/wiki/Clojure - Clojure (Wikipedia CS)
http://cs.wikipedia.org/wiki/Clojure - Riastradh's Lisp Style Rules
http://mumble.net/~campbell/scheme/style.txt - Dynamic Languages Strike Back
http://steve-yegge.blogspot.cz/2008/05/dynamic-languages-strike-back.html - Scripting: Higher Level Programming for the 21st Century
http://www.tcl.tk/doc/scripting.html - Java Virtual Machine Support for Non-Java Languages
http://docs.oracle.com/javase/7/docs/technotes/guides/vm/multiple-language-support.html - New JDK 7 Feature: Support for Dynamically Typed Languages in the Java Virtual Machine
http://java.sun.com/developer/technicalArticles/DynTypeLang/ - JSR 223: Scripting for the JavaTM Platform
http://jcp.org/en/jsr/detail?id=223 - JSR 292: Supporting Dynamically Typed Languages on the JavaTM Platform
http://jcp.org/en/jsr/detail?id=292 - Java 7: A complete invokedynamic example
http://niklasschlimm.blogspot.com/2012/02/java-7-complete-invokedynamic-example.html - InvokeDynamic: Actually Useful?
http://blog.headius.com/2007/01/invokedynamic-actually-useful.html - A First Taste of InvokeDynamic
http://blog.headius.com/2008/09/first-taste-of-invokedynamic.html - Java 6 try/finally compilation without jsr/ret
http://cliffhacks.blogspot.com/2008/02/java-6-tryfinally-compilation-without.html - An empirical study of Java bytecode programs
http://www.mendeley.com/research/an-empirical-study-of-java-bytecode-programs/ - Java quick guide: JVM Instruction Set (tabulka všech instrukcí JVM)
http://www.mobilefish.com/tutorials/java/java_quickguide_jvm_instruction_set.html - The JVM Instruction Set
http://mpdeboer.home.xs4all.nl/scriptie/node14.html - Control Flow in the Java Virtual Machine
http://www.artima.com/underthehood/flowP.html - Root.cz: Využití komprimovaných ukazatelů na objekty v JVM
http://www.root.cz/clanky/vyuziti-komprimovanych-ukazatelu-na-objekty-v-nbsp-jvm/ - Root.cz: JamVM aneb alternativa k HotSpotu nejenom pro embedded zařízení a chytré telefony
http://www.root.cz/clanky/jamvm-aneb-alternativa-k-hotspotu-nejenom-pro-embedded-zarizeni-tablety-a-chytre-telefony/ - The JavaTM Virtual Machine Specification, Second Edition
http://java.sun.com/docs/books/jvms/second_edition/html/VMSpecTOC.doc.html - The class File Format
http://java.sun.com/docs/books/jvms/second_edition/html/ClassFile.doc.html - javap – The Java Class File Disassembler
http://docs.oracle.com/javase/1.4.2/docs/tooldocs/windows/javap.html - javap-java-1.6.0-openjdk(1) – Linux man page
http://linux.die.net/man/1/javap-java-1.6.0-openjdk - Using javap
http://www.idevelopment.info/data/Programming/java/miscellaneous_java/Using_javap.html - Examine class files with the javap command
http://www.techrepublic.com/article/examine-class-files-with-the-javap-command/5815354 - BCEL Home page
http://commons.apache.org/bcel/ - BCEL Manual
http://commons.apache.org/bcel/manual.html - Byte Code Engineering Library (Wikipedia)
http://en.wikipedia.org/wiki/BCEL - Java programming dynamics, Part 7: Bytecode engineering with BCEL
http://www.ibm.com/developerworks/java/library/j-dyn0414/ - Bytecode Engineering
http://book.chinaunix.net/special/ebook/Core_Java2_Volume2AF/0131118269/ch13lev1sec6.html - BCEL Tutorial
http://www.smfsupport.com/support/java/bcel-tutorial!/ - ASM Home page
http://asm.ow2.org/ - Seznam nástrojů využívajících projekt ASM
http://asm.ow2.org/users.html - ObjectWeb ASM (Wikipedia)
http://en.wikipedia.org/wiki/ObjectWeb_ASM - Java Bytecode BCEL vs ASM
http://james.onegoodcookie.com/2005/10/26/java-bytecode-bcel-vs-asm/ - Bytecode Outline plugin for Eclipse (screenshoty + info)
http://asm.ow2.org/eclipse/index.html - aspectj (Eclipse)
http://www.eclipse.org/aspectj/ - Aspect-oriented programming (Wikipedia)
http://en.wikipedia.org/wiki/Aspect_oriented_programming - AspectJ (Wikipedia)
http://en.wikipedia.org/wiki/AspectJ - EMMA: a free Java code coverage tool
http://emma.sourceforge.net/ - Cobertura
http://cobertura.sourceforge.net/ - FindBugs
http://findbugs.sourceforge.net/ - GNU Classpath
www.gnu.org/s/classpath/ - Java VMs Compared
http://bugblogger.com/java-vms-compared-160/ - JSRs: Java Specification Requests – JSR 223: Scripting for the Java Platform
http://www.jcp.org/en/jsr/detail?id=223 - Scripting for the Java Platform
http://java.sun.com/developer/technicalArticles/J2SE/Desktop/scripting/ - Scripting for the Java Platform (Wikipedia)
http://en.wikipedia.org/wiki/Scripting_for_the_Java_Platform - Java Community Process
http://en.wikipedia.org/wiki/Java_Specification_Request - Java HotSpot VM Options
http://www.oracle.com/technetwork/java/javase/tech/vmoptions-jsp-140102.html - Great Computer Language Shootout
http://c2.com/cgi/wiki?GreatComputerLanguageShootout - Java performance
http://en.wikipedia.org/wiki/Java_performance - Trying the prototype
http://mail.openjdk.java.net/pipermail/lambda-dev/2010-August/002179.html - Better closures (for Java)
http://blogs.sun.com/jrose/entry/better_closures - Lambdas in Java: An In-Depth Analysis
http://www.infoq.com/articles/lambdas-java-analysis - Class ReflectiveOperationException
http://download.java.net/jdk7/docs/api/java/lang/ReflectiveOperationException.html - Scala Programming Language
http://www.scala-lang.org/ - Run Scala in Apache Tomcat in 10 minutes
http://www.softwaresecretweapons.com/jspwiki/run-scala-in-apache-tomcat-in-10-minutes - Fast Web Development With Scala
http://chasethedevil.blogspot.cz/2007/09/fast-web-development-with-scala.html - Top five scripting languages on the JVM
http://www.infoworld.com/d/developer-world/top-five-scripting-languages-the-jvm-855 - Proposal: Indexing access syntax for Lists and Maps
http://mail.openjdk.java.net/pipermail/coin-dev/2009-March/001108.html - Proposal: Elvis and Other Null-Safe Operators
http://mail.openjdk.java.net/pipermail/coin-dev/2009-March/000047.html - Java 7 : Oracle pushes a first version of closures
http://www.baptiste-wicht.com/2010/05/oracle-pushes-a-first-version-of-closures/ - Groovy: An agile dynamic language for the Java Platform
http://groovy.codehaus.org/Operators - Better Strategies for Null Handling in Java
http://www.slideshare.net/Stephan.Schmidt/better-strategies-for-null-handling-in-java - Control Flow in the Java Virtual Machine
http://www.artima.com/underthehood/flowP.html - Java Virtual Machine
http://en.wikipedia.org/wiki/Java_virtual_machine - ==, .equals(), compareTo(), and compare()
http://leepoint.net/notes-java/data/expressions/22compareobjects.html - New JDK7 features
http://openjdk.java.net/projects/jdk7/features/ - Project Coin: Bringing it to a Close(able)
http://blogs.sun.com/darcy/entry/project_coin_bring_close - CloseableFinder source code
http://blogs.sun.com/darcy/resource/ProjectCoin/CloseableFinder.java - Joe Darcy blog about JDK
http://blogs.sun.com/darcy - Java 7 – more dynamics
http://www.baptiste-wicht.com/2010/04/java-7-more-dynamics/ - New JDK 7 Feature: Support for Dynamically Typed Languages in the Java Virtual Machine
http://java.sun.com/developer/technicalArticles/DynTypeLang/index.html
ČLÁNKY DO MAILU