Jak jsme vás již informovali ve zprávičce, vyšla minulý týden nová verze programovacího jazyka Clojure. Některé změny se týkají základních knihoven, další pak optimalizací pro dosažení vyššího výkonu při překladu zdrojových kódů do bajtkódu JVM. Právě těmito změnami se budeme zabývat v dnešním článku.
1. Novinky v Clojure verze 1.8.0
2. Instalace Clojure 1.8.0 bez použití nástroje Leiningen
3. Spuštění interaktivního REPLu
4. Instalace Clojure 1.8.0 s použitím nástroje Leiningen
5. Spuštění interaktivního REPLu
6. Rozšíření repertoáru funkcí ve jmenném prostoru clojure.string
11. Použití REPLu přístupného přes socket
12. Další vylepšení v Clojure 1.8.0
13. Odkazy na předchozí části tohoto seriálu
Před týdnem, konkrétně dne 19.1.2016, byla vydána nová verze programovacího jazyka Clojure. Jak jsme vás již informovali ve zprávičce, jedná se o verzi 1.8.0. Nutno říci, že tato verze vlastně není příliš přelomová a už vůbec ne revoluční, což může znamenat to, že se programovací jazyk Clojure dostává do stabilní fáze vývoje, kdy by radikální změny byly vnímány spíše negativně. V rámci Clojure 1.8.0 došlo k přidání pěti nových a užitečných funkcí do jmenného prostoru clojure.string, dále je možné se připojit k interaktivní smyčce REPL přes k tomu vytvořený socket (což je sice zdánlivě malá změna, která má však poměrně dalekosáhlé praktické důsledky) a taktéž byl optimalizován překlad zdrojových kódů napsaných v jazyce Clojure do bajtkódu JVM. Na tomto místě je ještě vhodné dodat, že před vydáním Clojure 1.8.0 byl do standardních knihoven dodán jmenný prostor clojure.async, což již JE poměrně závažné vylepšení, kterému se kvůli jeho důležitosti budeme věnovat v samostatném článku.
Nejprve si ukažme, jakým způsobem je možné na vývojový počítač nainstalovat programovací jazyk Clojure verze 1.8.0 v případě, že z nějakého důvodu nechcete používat nástroj Leiningen. Pro naprostou většinu projektů je sice doporučováno Leiningen použít, ovšem mohou existovat situace, kdy to není možné. V těchto situacích postačuje stáhnout již připravený zip archiv obsahující jak samotný jazyk Clojure (překladač do bajtkódu, runtime i vlastní smyčku REPL), zdrojové kódy Clojure, tak i základní knihovny. Celý archiv je dostupný na adrese http://repo1.maven.org/maven2/org/clojure/clojure/1.8.0/clojure-1.8.0.zip, takže nejprve použijeme wget pro jeho stažení do lokálního adresáře:
wget http://repo1.maven.org/maven2/org/clojure/clojure/1.8.0/clojure-1.8.0.zip --2016-01-24 10:17:27-- http://repo1.maven.org/maven2/org/clojure/clojure/1.8.0/clojure-1.8.0.zip Resolving repo1.maven.org (repo1.maven.org)... 185.31.17.209 Connecting to repo1.maven.org (repo1.maven.org)|185.31.17.209|:80... connected. HTTP request sent, awaiting response... 200 OK Length: 5017209 (4,8M) [application/zip] Saving to: "clojure-1.8.0.zip" 100%[=====================================================================================================>] 5 017 209 908KB/s in 5,9s 2016-01-24 10:17:33 (837 KB/s) - "clojure-1.8.0.zip" saved [5017209/5017209]
Dále je nutné archiv rozbali, což lze provést přímo v pracovním adresáři
unzip clojure-1.8.0.zip Archive: clojure-1.8.0.zip creating: clojure-1.8.0/ creating: clojure-1.8.0/src/ creating: clojure-1.8.0/src/script/ creating: clojure-1.8.0/src/jvm/ ... ... ... inflating: clojure-1.8.0/clojure-1.8.0-slim.jar inflating: clojure-1.8.0/clojure-1.8.0.jar inflating: clojure-1.8.0/pom.xml inflating: clojure-1.8.0/build.xml inflating: clojure-1.8.0/readme.txt inflating: clojure-1.8.0/changes.md inflating: clojure-1.8.0/clojure.iml inflating: clojure-1.8.0/epl-v10.html
Nejdůležitější je pro nás nyní především soubor nazvaný clojure-1.8.0/clojure-1.8.0.jar obsahující všechny součásti interpretru a překladače jazyka Clojure, včetně REPLu a základních knihoven.
Poznámka: pro běh Clojure (libovolné verze) je samozřejmě zapotřebí mít nainstalováno JRE (Java Runtime Environment), podobně jako pro spuštění dalších javovských aplikací. Postačuje jak verze 7, tak i novější verze 8. Já jsem v dnešním článku vše testoval na verzi 7 (konkrétně na OpenJDK 1.7.0_79, tj. build JRE má číslo 7u79), a to především z toho důvodu, že na produkčních systémech je tato verze pravděpodobně používána častěji, než JDK/JRE 8.
Spuštění interaktivní smyčky REPL, v níž mnoho programátorů tráví při tvorbě aplikací nejvíce času, se provede velmi jednoduše:
cd clojure-1.8.0 java -jar clojure-1.8.0.jar Clojure 1.8.0 user=>
Ve skutečnosti má takto „primitivně“ spuštěný REPL několik nevýhod, a to především absenci historie příkazové řádky. Tento nedostatek nahradíme nástrojem nazvaným příhodně readline wrapper, který dokáže historii příkazů zachovat a kdykoli vyvolat klávesovými zkratkami známými například z BASHe. Pokud chcete readline wrapper při vývoji a testování s využitím REPL použít (což je v tomto případě pro praktické použití takřka nezbytné), nainstalujte si nejprve balíček nazvaný rlwrap a posléze spusťte REPL jazyka Clojure následujícím způsobem:
cd clojure-1.8.0 rlwrap java -jar clojure-1.8.0.jar Clojure 1.8.0 user=>
Instalace Clojure verze 1.8.0 s využitím nástroje Leiningen je velmi jednoduchá. Nejprve vytvoříme nový projekt, a to příkazem:
lein new app clojure8-test Generating a project called clojure8-test based on the 'app' template.
Po zadání tohoto příkazu by se měl vytvořit adresář obsahující strukturu nového projektu:
.
├── doc
│ └── intro.md
├── LICENSE
├── project.clj
├── README.md
├── resources
├── src
│ └── clojure8_test
│ └── core.clj
└── test
└── clojure8_test
└── core_test.clj
6 directories, 6 files
Podívejme se nyní na obsah projektového souboru nazvaného project.clj. Ten může vypadat takto:
(defproject clojure8-test "0.1.0-SNAPSHOT"
:description "FIXME: write description"
:url "http://example.com/FIXME"
:license {:name "Eclipse Public License"
:url "http://www.eclipse.org/legal/epl-v10.html"}
:dependencies [[org.clojure/clojure "1.6.0"]]
:main ^:skip-aot clojure8-test.core
:target-path "target/%s"
:profiles {:uberjar {:aot :all}})
Označenou část projektového souboru změníme takovým způsobem, aby se namísto verze 1.5.0, 1.6.0 či 1.7.0 používala verze 1.8.0:
(defproject clojure8-test "0.1.0-SNAPSHOT"
:description "FIXME: write description"
:url "http://example.com/FIXME"
:license {:name "Eclipse Public License"
:url "http://www.eclipse.org/legal/epl-v10.html"}
:dependencies [[org.clojure/clojure "1.8.0"]]
:main ^:skip-aot clojure8-test.core
:target-path "target/%s"
:profiles {:uberjar {:aot :all}})
Následně stačí uložit novou verzi projektového souboru a na příkazové řádce zadat příkaz pro stažení všech knihoven a balíčků, na nichž projekt závisí:
lein deps Retrieving org/clojure/clojure/1.8.0/clojure-1.8.0.pom from central Retrieving org/clojure/clojure/1.8.0/clojure-1.8.0.jar from central
Z vypsaných zpráv je zřejmé, že skutečně došlo ke stažení nové verze jazyka Clojure. Standardně se interpretry Clojure ukládají do adresáře ~/.m2/repository/org/clojure/clojure, který může obsahovat i několik verzí interpretu. To je ve skutečnosti celkem běžné, protože mnoho knihoven má ve svém popisu (projektovém souboru) uvedenou právě nějakou starší verzi. Podívejme se, jak struktura výše zmíněného adresáře vypadá na počítači, který je aktivně používán pro vývoj v jazyce Clojure:
~/.m2/repository/org/clojure/clojure/
├── 1.2.1
│ ├── clojure-1.2.1.jar
│ ├── clojure-1.2.1.jar.sha1
│ ├── clojure-1.2.1.pom
│ ├── clojure-1.2.1.pom.sha1
│ └── _maven.repositories
├── 1.3.0
│ ├── clojure-1.3.0.pom
│ ├── clojure-1.3.0.pom.sha1
│ └── _maven.repositories
├── 1.4.0
│ ├── clojure-1.4.0.pom
│ ├── clojure-1.4.0.pom.sha1
│ └── _maven.repositories
├── 1.5.1
│ ├── clojure-1.5.1.jar
│ ├── clojure-1.5.1.jar.sha1
│ ├── clojure-1.5.1.pom
│ ├── clojure-1.5.1.pom.sha1
│ └── _maven.repositories
├── 1.6.0
│ ├── clojure-1.6.0.jar
│ ├── clojure-1.6.0.jar.sha1
│ ├── clojure-1.6.0.pom
│ ├── clojure-1.6.0.pom.sha1
│ └── _maven.repositories
├── 1.7.0
│ ├── clojure-1.7.0.jar
│ ├── clojure-1.7.0.jar.sha1
│ ├── clojure-1.7.0.pom
│ ├── clojure-1.7.0.pom.sha1
│ └── _maven.repositories
├── 1.7.0-RC1
│ ├── clojure-1.7.0-RC1.pom
│ ├── clojure-1.7.0-RC1.pom.sha1
│ └── _maven.repositories
└── 1.8.0
├── clojure-1.8.0.jar
├── clojure-1.8.0.jar.sha1
├── clojure-1.8.0.pom
├── clojure-1.8.0.pom.sha1
└── _maven.repositories
8 directories, 34 files
V případě Clojure verze 1.8.0 vznikl při instalaci adresář s pěticí souborů, přičemž pro vývoj, ladění i spouštění programů se používá pouze Java archiv uvedený na prvním místě:
ls -l ~/.m2/repository/org/clojure/clojure/1.8.0 total 3564 -rw-r--r-- 1 tester tester 3622815 led 24 10:14 clojure-1.8.0.jar -rw-r--r-- 1 tester tester 40 led 24 10:14 clojure-1.8.0.jar.sha1 -rw-r--r-- 1 tester tester 8547 led 24 10:14 clojure-1.8.0.pom -rw-r--r-- 1 tester tester 40 led 24 10:14 clojure-1.8.0.pom.sha1 -rw-r--r-- 1 tester tester 180 led 24 10:14 _maven.repositories
Poznámka: samotný projekt je možné bez obav smazat, protože jeho jedinou úlohou bylo nainstalovat Clojure 1.8.0 do adresáře ~/.m2 a otestovat REPL (viz další kapitolu).
Spuštění interaktivní smyčky REPL je v případě použití projektu používajícího nástroj Leiningen velmi snadné. Postačuje pouze v adresáři s projektem zadat příkaz lein repl:
lein repl
nREPL server started on port 47224 on host 127.0.0.1 - nrepl://127.0.0.1:47224
REPL-y 0.3.5, nREPL 0.2.6
Clojure 1.8.0
OpenJDK 64-Bit Server VM 1.7.0_79-b14
Docs: (doc function-name-here)
(find-doc "part-of-name-here")
Source: (source function-name-here)
Javadoc: (javadoc java-object-or-class-here)
Exit: Control+D or (exit) or (quit)
Results: Stored in vars *1, *2, *3, an exception in *e
clojure8-test.core=>
Tato forma smyčky REPL programátorům nabízí mnohem více možností, než „klasická“ minimalisticky pojatá smyčka REPL, která je součástí interpretru Clojure. K dispozici je historie příkazů, lze přistupovat ke speciálním symbolům *1, *e atd. Právě tuto smyčku použijeme v dalším textu při vysvětlování nových možností Clojure 1.8.0.
Do jmenného prostoru clojure.string bylo přidáno pět nových funkcí, které se používají pro test, zda nějaký řetězec obsahuje zadaný podřetězec a popř. na jaké pozici se tento podřetězec nachází. První tři funkce vrací hodnotu true či false, proto se jedná o takzvané „predikáty“, jejichž jména podle ustanovených jmenných konvencí končí znakem otazník. Další dvě funkce vrací index nalezeného podřetězce popř. hodnotu nil, pokud se nalezení nepodařilo. Podívejme se na tabulku s novými funkcemi:
| # | Funkce | Stručný popis |
|---|---|---|
| 1 | starts-with? | test, zda řetězec začíná zadaným podřetězcem |
| 2 | ends-with? | test, zda řetězec končí zadaným podřetězcem |
| 2 | includes? | test, zda řetězec obsahuje zadaný podřetězec |
| 3 | index-of | vrátí první výskyt znaku v řetězci popř. nil |
| 4 | last-index-of | vrátí poslední výskyt znaku v řetězci popř. nil |
Tyto funkce byly přidány primárně z toho důvodu, aby byly dostupné i v ClojureScriptu. Programátoři používající předchozí verzi jazyka Clojure se museli uchýlit k použití metod třídy java.lang.String. Skutečně, nové funkce jsou částečně s těmito metodami shodné:
| # | Funkce | Odpovídající metoda třídy java.lang.String |
|---|---|---|
| 1 | starts-with? | .startsWith |
| 2 | ends-with? | .endsWith |
| 2 | includes? | .contains |
| 3 | index-of | .indexOf |
| 4 | last-index-of | .lastIndexOf |
Ve skutečnosti však existuje několik rozdílů mezi novými funkcemi a odpovídajícími javovskými metodami. Především funkce lze zavolat i v tom případě, kdy jejich prvním parametrem není řetězec ale například číslo či objekt. Nejprve je tato reference automaticky převedena na řetězec a posléze je funkce zavolána, což v případě metod pochopitelně není možné (přesněji řečeno v Javě jakožto OO jazyku založeném na třídách to není možné). Druhý rozdíl je v praxi důležitější: funkce index-of a last-index-of v případě, že podřetězec nebyl nalezen, vrací speciální hodnotu nil, zatímco metody String.indexOf a String.lastIndexOf vrací ve stejném případě hodnotu –1 (za to můžeme „vděčit“ rigidnímu typovému systému Javy a taktéž striktnímu rozlišování mezi primitivními typy a referenčními typy). Ostatně, hodnota nil je praktičtější, protože ji lze použít přímo v rozhodovacích konstrukcích, kde má stejný význam jako pravdivostní hodnota false.
Vyzkoušejme si nyní výše uvedenou pětici funkcí na demonstračních příkladech zadávaných přímo do interaktivní smyčky REPL. Nejdříve REPL spustíme:
lein repl
nREPL server started on port 51457 on host 127.0.0.1 - nrepl://127.0.0.1:51457
REPL-y 0.3.5, nREPL 0.2.6
Clojure 1.8.0
OpenJDK 64-Bit Server VM 1.7.0_79-b14
Docs: (doc function-name-here)
(find-doc "part-of-name-here")
Source: (source function-name-here)
Javadoc: (javadoc java-object-or-class-here)
Exit: Control+D or (exit) or (quit)
Results: Stored in vars *1, *2, *3, an exception in *e
Nyní načteme všechny funkce, makra a symboly definované ve jmenném prostoru clojure.string, přičemž namísto nutnosti zadávání plného jména tohoto prostoru si zvolíme pouze kratší alias str (vůbec přitom nevadí, že dojde ke „kolizi“ s funkcí str, protože jméno modulu a jméno funkce se vždy bude uvádět v jiném kontextu):
clojure8-test.core=> (require '[clojure.string :as str]) nil
Navážeme symbol s na řetězec „Hello world!“:
clojure8-test.core=> (def s "Hello world!") #'clojure8-test.core/s
Konečně se můžeme pustit do testování nových řetězcových funkcí:
; nalezení prvního výskytu znaku "o" clojure8-test.core=> (str/index-of s "o") 4 ; nalezení prvního výskytu podřetězce "wo" clojure8-test.core=> (str/index-of s "wo") 6 ; pokud se podřetězec nenalezne, vrací se hodnota nil, nikoli -1: clojure8-test.core=> (str/index-of s "xxx") nil ; hledání výskytu znaku od určité pozice clojure8-test.core=> (str/index-of s "o" 4) 4 ; hledání výskytu znaku od určité pozice clojure8-test.core=> (str/index-of s "o" 5) 7 ; pokud se podřetězec nenalezne, vrací se hodnota nil, nikoli -1: clojure8-test.core=> (str/index-of s "o" 10) nil ; hledání posledního výskytu znaku clojure8-test.core=> (str/last-index-of s "o") 7 ; hledání posledního výskytu podřetězce clojure8-test.core=> (str/last-index-of s "wo") 6 ; hledání posledního výskytu podřetězce, opět se může vracet nil clojure8-test.core=> (str/last-index-of s "foo") nil ; tato funkce vrací true či false v závislosti na tom, zda je nalezen podřetězec clojure8-test.core=> (str/includes? s "wor") true ; tato funkce vrací true či false v závislosti na tom, zda je nalezen podřetězec clojure8-test.core=> (str/includes? s "xyzzy") false ; tato funkce vrací true či false v závislosti na tom, zda je na začátku nalezen podřetězec clojure8-test.core=> (str/starts-with? s "H") true ; tato funkce vrací true či false v závislosti na tom, zda je na začátku nalezen podřetězec clojure8-test.core=> (str/starts-with? s "x") false ; tato funkce vrací true či false v závislosti na tom, zda je na začátku nalezen podřetězec clojure8-test.core=> (str/starts-with? s "Hello") true ; tato funkce vrací true či false v závislosti na tom, zda je na konci nalezen podřetězec clojure8-test.core=> (str/ends-with? s "!") true ; tato funkce vrací true či false v závislosti na tom, zda je na konci nalezen podřetězec clojure8-test.core=> (str/ends-with? s "x") false ; tato funkce vrací true či false v závislosti na tom, zda je na konci nalezen podřetězec clojure8-test.core=> (str/ends-with? s "world!") true
Některé specialitky:
; velmi častá chyba při použití funkce contains?, kterou nelze na řetězce použít ; nová funkce includes? doufejme nesprávné použití contains? omezí ; (mnoho programátorů si myslí, že contains? je nejhůře pojmenovanou funkcí v Clojure vůbec :-) clojure8-test.core=> (contains? s "o") ; numerická hodnota je převedena na řetězec, v němž se pak hledá znak clojure8-test.core=> (str/includes? 1234 "3") true ; výsledek funkce je převeden na řetězec, v němž se pak hledá znak clojure8-test.core=> (str/includes? (* 6 7) "4") true
Pokud vám z nějakého důvodu nevyhovuje nutnost specifikace jmenného prostoru clojure.string či jeho aliasu str, je možné provést i následující operaci, která všechny symboly ze jmenného prostoru clojure.string umístí do aktivního jmenného prostoru (se všemi důsledky, ostatně se podívejte na překrytí některých jmen):
clojure8-test.core=> (require '[clojure.string :refer :all]) WARNING: reverse already refers to: #'clojure.core/reverse in namespace: clojure8-test.core, being replaced by: #'clojure.string/reverse WARNING: replace already refers to: #'clojure.core/replace in namespace: clojure8-test.core, being replaced by: #'clojure.string/replace nil
Nyní je již možné funkce volat bez přidání aliasu na začátek:
clojure8-test.core=> (includes? s "world") true clojure8-test.core=> (starts-with? s "H") true clojure8-test.core=> (starts-with? s "x") false clojure8-test.core=> (ends-with? s "!") true
Poměrně důležitou a především pak praktickou novinkou ve verzi 1.8.0 je zahrnutí jednoduchého a na systémové prostředky nenáročného socket serveru, který může být při startu aplikace spuštěn a na určeném portu (či portech) může čekat na vzdálené připojení, typicky k interaktivní smyčce REPL. Díky této nové vlastnosti je například možné se prakticky kdykoli připojit k již běžící aplikaci, provést ladění, zjištění aktuálního vytížení aplikace, aplikovat změnu programového kódu některé funkce či změnu hodnoty proměnné (například atomu), a to bez nutnosti restartu aplikace a navíc bez nutnosti nějakým způsobem přistupovat ke standardnímu vstupu, výstupu a chybovému výstupu, který je ke smyčce REPL přiřazen. V následující kapitole si ukážeme typické použití serveru.
To, zda se server spustí či nikoli, je ovlivněno existencí vlastnosti nazvané clojure.server.{jméno-serveru}, kde se do poslední části jména vlastnosti musí zadat jednoznačný identifikátor. Díky tomu, že se do jména vlastnosti zadává i uživatelsky volitelná část, je možné spustit dokonce i větší množství serverů, které se budou lišit jak svými porty (na nichž čekají na požadavky), tak i svými jmény (či dalšími vlastnostmi). Jméno vlastnosti tedy může vypadat takto:
clojure.server.repl1
Hodnotou vlastnosti je řetězec obsahující mapu (ve smyslu jazyka Clojure), která může obsahovat tyto klíče:
| # | Klíč | Vyžadováno? | Výchozí hodnota | Význam |
|---|---|---|---|---|
| 1 | :address | ne | × | IP adresa nebo hostname |
| 2 | :port | ano | × | port, na němž server bude čekat na požadavky |
| 3 | :accept | ano | × | která funkce se použije pro příjem požadavků, typicky clojure.core.server/repl |
| 4 | :args | ne | () | další argumenty předávané funkci specifikované v :accept |
| 5 | :server-daemon | ne | true | pokud je nastaveno na true (výchozí hodnota), nebude vlákno serveru bránit ukončení aplikace |
| 6 | :client-deamon | ne | true | dtto pro klienta (pro REPL nevýznamné) |
| 7 | :bind-err | ne | true | pokud je nastaveno na true (výchozí hodnota), bude se i chybový výstup posílat klientovi |
Příklad specifikace vlastnosti nazvané clojure.server.repl při spouštění JVM:
-Dclojure.server.repl="{:port 5555 :accept clojure.core.server/repl}"
Spuštění JVM s interpretrem jazyka Clojure může vypadat takto:
java -Dclojure.server.repl="{:port 5555 :accept clojure.core.server/repl}" -jar clojure-1.8.0.jar
Obrázek 1: V horním terminálu je spuštěn interpret Clojure i se serverem. V dolním terminálu se přes telnet připojujeme k serveru a získáme tak vlastní smyčku REPL se samostatným nastavením, ovšem s přístupem ke všem symbolům,které jsou v interpretru dostupné. Nové symboly zde lze i vytvářet a ovlivňovat tak běžící aplikaci.
Dokonce je možné si spustit dva či více serverů, například:
java -Dclojure.server.repl1="{:port 5555 :accept clojure.core.server/repl}" -Dclojure.server.repl2="{:port 5556 :accept clojure.core.server/repl}" -jar clojure-1.8.0.jar
Každý server samozřejmě musí používat jiný port, na němž čeká na požadavky od klientů.
Obrázek 2: Zde došlo ke spuštění dvou serverů, k nimž jsem se ihned po jejich vytvoření připojil.
Obrázek 3: Po skončení aplikace jsou klienti násilně odpojeni, protože jsme nikde nespecifikovali, že má server běžet v režimu démona.
Jak jsme si již řekli v předchozí kapitole, je většina symbolů (ve všech jmenných prostorech) pro hlavní část aplikace i pro vlákno, v němž je implementován server, shodné, lze k nim přistupovat, měnit je atd. Existuje však několik objektů, které musí mít odlišnou hodnotu. Jedná se samozřejmě o vstupní a výstupní proudy reprezentované symboly *in*, *out* a *err*. Pokud se uživatel připojí k aplikaci přes socket (na kterém poslouchá server), samozřejmě očekává, že tyto symboly budou nastaveny takovým způsobem, že vstup i výstup bude prováděn přes socket a ne přes standardní vstup a výstup navázaný na terminál, v němž byla aplikace spuštěna. Dalším speciálním symbolem je clojure.core.server/*session*, na nějž je navázána mapa obsahující například tyto hodnoty:
{:server "repl", :client "1"}
Vidíme zde jméno serveru, tj. poslední část jména příslušné vlastnosti) a identifikaci klienta. Pro hlavní smyčku REPL tento symbol neexistuje.
Podívejme se nyní na dosti umělý demonstrační příklad, na němž si ukážeme použití smyčky REPL. V tomto příkladu se v nekonečné smyčce postupně (konkrétně v sekundových intervalech) zvyšuje hodnota atomu o jedničku. Celý příklad může vypadat takto:
(def counter (atom 0))
(doseq [i (range)]
(reset! counter i)
(Thread/sleep 1000))
Nejprve spustíme interpret jazyka Clojure:
java -Dclojure.server.repl="{:port 5555 :accept clojure.core.server/repl}" -jar clojure-1.8.0.jar
Načteme a spustíme výše uvedený příklad, který jsme si předtím uložili do souboru nazvaného test.clj:
(load-file "test.clj")
Nyní se hlavní smyčka REPL „odmlčí“, protože vyhodnocuje nekonečnou sekvenci a v sekundových intervalech nastavuje atom nazvaný counter na hodnotu, kterou má aktuální prvek této sekvence.
V novém terminálu se k aplikaci přihlásíme přes server očekávající požadavky na portu číslo 5555:
telnet localhost 5555 Trying 127.0.0.1... Connected to localhost. Escape character is '^]'.
A ihned si můžeme vypsat aktuální hodnotu uloženou do atomu counter:
user=> @counter 16 user=> @counter 21
Po násilném ukončení aplikace (Ctrl+C) se ukončí i sezení spuštěné přes Telnet:
user=> Connection closed by foreign host.
Další zajímavé vylepšení jazyka Clojure bylo vyřešeno v rámci CLJ-1263. Jedná se o interní optimalizaci využívanou při volání funkcí, kdy se namísto relativně složité dereference, načtení „univerzálního“ rozhraní IFn a zavolání instrukce invokeinterface používá jediná instrukce invokevirtual, což je rychlejší. Typicky se tato optimalizace využívá pro funkce označené tagem :^static, ideálně ještě s určením datových typů všech parametrů funkce i její návratové hodnoty – v tomto případě je funkce přeložena prakticky stejným způsobem, jako plně typovaná Javovská metoda.
