Clojure

Versiunea actuală a paginii nu a fost încă examinată de colaboratori experimentați și poate diferi semnificativ de versiunea revizuită la 17 martie 2021; verificările necesită 6 modificări .
Clojure
Clasa de limba funcțional , multi- paradigma
Aparut in 2007
Autor Hickey bogat
Dezvoltator Hickey, Richard
Extensie de fișier .clj, .cljs, .cljc, .ednsau.cljr
Eliberare 1.11.1 ( 5 aprilie 2022 )
Tip sistem dinamic, strict
A fost influențat Lisp , ML , Haskell , Erlang [1] , Prolog , Scheme , Java , Ruby [2]
influențat Elixir
Licență Licență publică Eclipse
Site-ul web clojure.org
 Fișiere media la Wikimedia Commons

Clojure (pronunțat închidere [ˈklōZHər]) este un dialect modern al Lisp , un limbaj de programare de uz general, cu suport pentru dezvoltarea interactivă, care încurajează programarea funcțională și facilitează multithreadingul . Clojure rulează pe platformele JVM și CLR . Clojure se distinge prin filozofia „codului ca date” ( homoicon ) și sistemul dezvoltat de macrocomenzi Lisp .

Traducatorul Clojure este distribuit gratuit în condițiile Licenței Publice Eclipse .

Filosofie

Rich Hickey a proiectat Clojure ca un Lisp modern pentru programare funcțională cu integrare în platforma Java , concepută pentru a sprijini concurența . [3]

Sintaxă

Ca orice alt Lisp, sintaxa lui Clojure se bazează pe expresii S , care sunt traduse în structuri de date de către parser înainte de compilare . Analizorul Clojure acceptă, pe lângă listele obișnuite, sintaxa literală pentru tablouri asociative , seturi și vectori , trecând toate aceste structuri de date către compilator . Cu alte cuvinte, compilatorul Clojure nu numai că compilează structuri de date de listă, dar acceptă direct toate tipurile specificate.

Deși Clojure este o extensie a versiunii originale a Lisp , nu este compatibil cu Lisp, adică un program din oricare dintre versiunile moderne de Lisp (cu posibilă excepție a celei mai scurte, mai primitive și, în plus, special alese). exemple) sau deloc translatorul Clojure va trece, sau nu se va executa corect. Diferențele față de versiunile comune ale Lisp sunt enumerate pe site-ul web [4] . Iată câteva dintre ele:

Macro -uri

Sistemul macro Clojure este foarte asemănător cu sistemul său macro Common Lisp , cu două excepții:

Caracteristicile limbii

Exemple

salut lumea :

( println „Bună lume!” )

Generator de numere de serie unic sigur pentru fire:

( lasă [i ( atom 0 ) ] ( defn generate-unique-id "Returnează un ID numeric diferit pentru fiecare apel." [] ( swap! i inc )))

O subclasă anonimă java.io.Writercare nu scoate nimic și o macrocomandă folosită pentru a reduce la tăcere toate rezultatele din ea:

( def bit-bucket-writer ( proxy [java.io.Writer] [] ( scrie [buf] nil ) ( close [] nil ) ( flush [] nil ))) ( defmacro noprint „Evaluează expresiile date, dezactivând toate *ieșirile* pe ecran.” . [& forms] ` ( legare [*out* bit-bucket-writer] ~@forms )) ( noprint ( println „Bună ziua, nimeni!” ))

10 fire care manipulează o structură de date comună, care constă din 100 de vectori, fiecare conținând 10 numere unice (inițial consecutive). Fiecare fir selectează în mod repetat două poziții aleatorii în doi vectori aleatori și schimbă valorile acestora. Toate modificările vectorului au loc într-o singură tranzacție folosind sistemul de memorie tranzacțional clojure . Prin urmare, chiar și după 1000 de iterații, nu se pierd numere în fiecare dintre fire.

( defn run [nvecs nitems nthreads niters] ( lasă [vec-refs ( vec ( hartă ( comp ref vec ) ) ( partiționați nitem ( interval ( * nvecs nitems ))))) swap #( let [v1 ( rand-int nvecs ) v2 ( rand-int nvecs ) i1 ( rand-int nitems ) i2 ( rand-int nitems ) ] ( dosync ( let [temp ( nth @ ( vec-refs v1 ) i1 ) ] ( alter ( vec-refs v1 ) assoc i1 ( nth @ ( vec-refs v2 ) i2 )) ( alter ( vec-refs v2 ) assoc i2 temp )))) raportul #( do ( prn ( map deref vec-refs )) ( println "Distinct:" ( count ( distinct ( aplica concat ( hărți deref vec-refs )))))) ] ( raport ) ( dorun ( aplica pcalls ( repetă nthreads #( dotimes [_ niters] ( swap ))))) ( raport ))) ( alerga 100 10 10 100000 )

Rezultatul exemplului anterior:

( [0 1 2 3 4 5 6 7 8 9] [10 11 12 13 14 15 16 17 18 19] ... [990 991 992 993 994 995 996 997 998 999:] 100 Distinc . ( [382 318 466 963 619 22 21 273 45 596] [ 808 639 804 471 394 904 952 75 289 778] ... [ 484 216 622 139 216 622 139 2 5 1 2 5 2 5 2 5 2 5 2 5 2 5 2 5

Vezi și

Note

  1. Rich Hickey. Cărți care au influențat Clojure (link indisponibil) (30 iunie 2009). Consultat la 11 septembrie 2009. Arhivat din original la 18 aprilie 2012. 
  2. Programare Clojure . Consultat la 30 aprilie 2013. Arhivat din original pe 21 mai 2015.
  3. Motivație (link în jos) . Hickey bogat . clojure.org. Consultat la 17 octombrie 2008. Arhivat din original la 18 aprilie 2012. 
  4. Diferențele dintre Clojure și Lisp . Preluat la 23 octombrie 2017. Arhivat din original la 8 iulie 2019.

Literatură

Link -uri

In rusa