History and development process
Design philosophy
Rich Hickey developed Clojure because he wanted a modernLanguage overview
Clojure runs on therecur
keyword. For Extensible Data Notation
Extensible Data Notation, or edn, is a subset of the Clojure language intended as a data transfer format. It can be used to serialize and deserialize Clojure data structures, and Clojure itself uses a superset of edn to represent programs. edn is used in a similar way totrue
, false
* strings: "foo bar"
* characters: \c
, \tab
* symbols: name
* keywords: :key
* integers: 123
* floating point numbers: 3.14
* lists: (a b 42)
* vectors: b 42/code>
* maps:
* sets: #
* nil: nil
(a null-like value)
In addition to those elements, it supports extensibility through the use of ''tags'', which consist of the character #
followed by a symbol. When encountering a tag, the reader passes the value of the next element to the corresponding handler, which returns a data value. For example, this could be a tagged element: #myapp/Person
, whose interpretation will depend on the appropriate handler of the reader.
This definition of extension elements in terms of the others avoids relying on either convention or context to convey elements not included in the base set.
Alternative platforms
The primary platform of Clojure is Java
Java (; id, Jawa, ; jv, ꦗꦮ; su, ) is one of the Greater Sunda Islands in Indonesia. It is bordered by the Indian Ocean to the south and the Java Sea to the north. With a population of 151.6 million people, Java is the world's mo ...
, but other target implementations exist. The most notable of these is ClojureScript, which compiles to ECMAScript
ECMAScript (; ES) is a JavaScript standard intended to ensure the interoperability of web pages across different browsers. It is standardized by Ecma International in the documenECMA-262
ECMAScript is commonly used for client-side scripti ...
3, and ClojureCLR, a full port on the .NET platform, interoperable with its ecosystem. A survey of the Clojure community with 1,060 respondents conducted in 2013 found that 47% of respondents used both Clojure and ClojureScript when working with Clojure. In 2014 this number had increased to 55%, in 2015, based on 2,445 respondents, to 66%. Popular ClojureScript projects include implementations of the React REACT or React may refer to:
Science and technology
* REACT (telescope), a telescope at Fenton Hill Observatory, New Mexico, US
Computing
* React (JavaScript library) , a JavaScript library for building user interfaces, from Facebook
** React Nat ...
library such as Reagent, re-frame, Rum, and Om.
Other Implementations
Other implementations of Clojure on different platforms include:
* Babashka, Native Clojure scripting language leveraging GraalVM native image an
Small Clojure Interpreter
* CljPerl, Clojure atop Perl
Perl is a family of two high-level, general-purpose, interpreted, dynamic programming languages. "Perl" refers to Perl 5, but from 2000 to 2019 it also referred to its redesigned "sister language", Perl 6, before the latter's name was offic ...
* ClojureCLR, Clojure on CLR, the .Net virtual machine.
* ClojureDart,
Extend Clojure's reach
to mobile & desktop apps b
porting Clojure to Dart and Flutter
* Clojerl, Clojure on BEAM, the Erlang virtual machine
* clojure-py, Clojure in pure Python
* ClojureRS, Clojure on Rust
Rust is an iron oxide, a usually reddish-brown oxide formed by the reaction of iron and oxygen in the catalytic presence of water or air moisture. Rust consists of hydrous iron(III) oxides (Fe2O3·nH2O) and iron(III) oxide-hydroxide (FeO( ...
* ClojureScript, Compiler fo
Clojure that targets JavaScript
It emit
JavaScript code compatible with the advanced compilation
mode of th
Google Closure optimizing compiler
* Ferret, compiles to self-contained C++11 that can run on microcontrollers
* jank, Clojure compatible language with gradual typing that is hosted in C++ on top of an LLVM-based JIT
* Joker, an interpreter and linter written in Go
* Las3r, a subset of Clojure that runs on the ActionScript
ActionScript is an object-oriented programming language originally developed by Macromedia Inc. (later acquired by Adobe). It is influenced by HyperTalk, the scripting language for HyperCard. It is now an implementation of ECMAScript (meaning ...
Virtual Machine (the Adobe Flash Player platform)
* Pixie, Clojure-inspired Lisp dialect written in RPython
* Rouge, Clojure atop YARV in Ruby
A ruby is a pinkish red to blood-red colored gemstone, a variety of the mineral corundum ( aluminium oxide). Ruby is one of the most popular traditional jewelry gems and is very durable. Other varieties of gem-quality corundum are called ...
Popularity
With continued interest in functional programming, Clojure's adoption by software developers using the Java platform has continued to increase. The language has also been recommended by software developers such as Brian Goetz, Eric Evans, James Gosling, Paul Graham, and Robert C. Martin. ThoughtWorks, while assessing functional programming languages for their Technology Radar, described Clojure as "a simple, elegant implementation of Lisp on the JVM" in 2010 and promoted its status to "ADOPT" in 2012.
In the "JVM Ecosystem Report 2018" (which was claimed to be "the largest survey ever of Java developers"), that was prepared in collaboration by Snyk and Java Magazine, ranked Clojure as the 2nd most used programming language on the JVM for "main applications". Clojure is used in industry by firms such as Apple
An apple is an edible fruit produced by an apple tree (''Malus domestica''). Apple trees are cultivated worldwide and are the most widely grown species in the genus '' Malus''. The tree originated in Central Asia, where its wild ancest ...
, Atlassian, Funding Circle, Netflix
Netflix, Inc. is an American subscription video on-demand over-the-top streaming service and production company based in Los Gatos, California. Founded in 1997 by Reed Hastings and Marc Randolph in Scotts Valley, California, it offers a ...
, Nubank
Nubank is a Brazilian neobank and the largest fintech bank in Latin America. Its headquarters are located in São Paulo, Brazil. The company also has engineering offices in Berlin, Germany, Buenos Aires, Argentina, and an office in Mexico City, ...
, Puppet
A puppet is an object, often resembling a human, animal or mythical figure, that is animated or manipulated by a person called a puppeteer. The puppeteer uses movements of their hands, arms, or control devices such as rods or strings to move ...
, and Walmart
Walmart Inc. (; formerly Wal-Mart Stores, Inc.) is an American multinational retail corporation that operates a chain of hypermarkets (also called supercenters), discount department stores, and grocery stores from the United States, headquarter ...
as well as government agencies such as NASA
The National Aeronautics and Space Administration (NASA ) is an independent agency of the US federal government responsible for the civil space program, aeronautics research, and space research.
NASA was established in 1958, succeedin ...
. It has also been used for creative computing, including visual art, music, games, and poetry.
Tools
Tooling for Clojure development has seen significant improvement over the years. The following is a list of some popular IDEs and text editor
A text editor is a type of computer program that edits plain text. Such programs are sometimes known as "notepad" software (e.g. Windows Notepad). Text editors are provided with operating systems and software development packages, and can be ...
s with plug-ins that add support for programming in Clojure:
* Atom
Every atom is composed of a nucleus and one or more electrons bound to the nucleus. The nucleus is made of one or more protons and a number of neutrons. Only the most common variety of hydrogen has no neutrons.
Every solid, liquid, gas, a ...
, with Chlorine
* Emacs
Emacs , originally named EMACS (an acronym for "Editor MACroS"), is a family of text editors that are characterized by their extensibility. The manual for the most widely used variant, GNU Emacs, describes it as "the extensible, customizable, ...
, with CIDER
* IntelliJ IDEA
IntelliJ IDEA is an integrated development environment (IDE) written in Java for developing computer software written in Java, Kotlin, Groovy, and other JVM-based languages. It is developed by JetBrains (formerly known as IntelliJ) and is av ...
, with Clojure-Kit or Cursive (a free license is available for non-commercial
A non-commercial (also spelled noncommercial) activity is an activity that does not, in some sense, involve commerce, at least relative to similar activities that do have a commercial objective or emphasis. For example, advertising-free community ...
use)
* Light Table
* Vim, with fireplace.vim, vim-iced, or Conjure (Neovim only)
* Visual Studio Code, with Calva or Clover
In addition to the tools provided by the community, the official Clojure CLI CLI may refer to:
Computing
* Call Level Interface, an SQL database management API
* Command-line interface, of a computer program
* Command-line interpreter or command language interpreter; see List of command-line interpreters
* CLI (x86 instr ...
tools have also become available on Linux
Linux ( or ) is a family of open-source Unix-like operating systems based on the Linux kernel, an operating system kernel first released on September 17, 1991, by Linus Torvalds. Linux is typically packaged as a Linux distribution, whi ...
, macOS
macOS (; previously OS X and originally Mac OS X) is a Unix operating system developed and marketed by Apple Inc. since 2001. It is the primary operating system for Apple's Mac computers. Within the market of desktop and la ...
, and Windows
Windows is a group of several proprietary graphical operating system families developed and marketed by Microsoft. Each family caters to a certain sector of the computing industry. For example, Windows NT for consumers, Windows Server for se ...
since Clojure 1.9.
Features by example
The following examples can be run in a Clojure REPL such as one started with the Clojure CLI tools or an online REPL such as one available on REPL.it.
Simplicity
Because of its strong emphasis on simplicity, Clojure programs typically consist of mostly functions and simple data structures (i.e., lists, vectors, maps, and sets):
;; A typical entry point of a Clojure program:
;; `-main` function
(defn -main ; name
args; (variable) parameters
(println "Hello, World!")) ; body
Programming at the REPL
Like other Lisps, one of Clojure's iconic features is interactive programming at the REPL. Note that, in the following examples, ;
starts a line comment and ;; =>
indicates the expected output:
; define a var
(def a 42)
;; => #'user/a
; call a function named `+`
(+ a 8)
;; => 50
; call a function named `even?`
(even? a)
;; => true
; define a function that returns the remainder of `n` when divided by 10
(defn foo (rem n 10))
;; => #'user/foo
; call the function
(foo a)
;; => 2
; print the docstring of `rem`
(doc rem)
;; =>
-------------------------
clojure.core/rem
( um div
remainder of dividing numerator by denominator.
; print the source of `rem`
(source rem)
;; =>
(defn rem
"remainder of dividing numerator by denominator."
um div (. clojure.lang.Numbers (remainder num div)))
Names at runtime
Unlike other runtime environments where names get compiled away, Clojure's runtime environment is easily introspectable using normal Clojure data structures:
; define a var
(def a 42)
;; => #'user/a
; get a map of all public vars interned in the `user` namespace
(ns-publics 'user)
;; =>
; reference the var via `#'` (reader macro) and
; its associated, namespace-qualified symbol `user/a`
#'user/a
;; => #'user/a
; de-reference (get the value of) the var
(deref #'user/a)
;; => 42
; define a function (with a docstring) that
; returns the remainder of `n` when divided by 10
(defn foo "returns `(rem n 10)`" (rem n 10))
;; => #'user/foo
; get the metadata of the var `#'user/foo`
(meta #'user/foo)
;; =>
Code as data (homoiconicity)
Similar to other Lisps, Clojure is homoiconic
In computer programming, homoiconicity (from the Greek words ''homo-'' meaning "the same" and ''icon'' meaning "representation") is a property of some programming languages. A language is homoiconic if a program written in it can be manipulated ...
(also known as "code as data"). In the example below, we can see how to write code that modifies code itself:
; call a function (code)
(+ 1 1)
;; => 2
; quote the function call
; (turning code into data, which is a list of symbols)
(quote (+ 1 1))
;; => (+ 1 1)
; get the first element on the list
; (operating on code as data)
(first (quote (+ 1 1)))
;; => +
; get the last element on the list
; (operating on code as data)
(last (quote (+ 1 1)))
;; => 1
; get a new list by replacing the symbols on the original list
; (manipulating code as data)
(map (fn orm (case form
1 'one
+ 'plus))
(quote (+ 1 1)))
;; => (plus one one)
Expressive operators for data transformation
The threading macros (->
, ->>
, and friends) can syntactically express the abstraction of piping a collection of data through a series of transformations:
(->> (range 10)
(map inc)
(filter even?))
;; => (2 4 6 8 10)
This can also be achieved more efficiently using transducers:
(sequence (comp (map inc)
(filter even?))
(range 10))
;; => (2 4 6 8 10)
Thread-safe management of identity and state
A thread-safe Thread safety is a computer programming concept applicable to multi-threaded code. Thread-safe code only manipulates shared data structures in a manner that ensures that all threads behave properly and fulfill their design specifications without un ...
generator of unique serial numbers (though, like many other Lisp dialects, Clojure has a built-in gensym
function that it uses internally):
(def i (atom 0))
(defn generate-unique-id
"Returns a distinct numeric ID for each call."
[]
(swap! i inc))
Macros
An anonymous subclass of java.io.Writer
that doesn't write to anything, and a macro using it to silence all prints within it:
(def bit-bucket-writer
(proxy ava.io.Writer[]
(write [buf] nil)
(close [] nil)
(flush [] nil)))
(defmacro noprint
"Evaluates the given `forms` with all printing to `*out*` silenced."
[& forms]
`(binding [*out* bit-bucket-writer]
~@forms))
(noprint
(println "Hello, nobody!"))
;; => nil
Language interoperability with Java
Clojure was created from the ground up to embrace its host platforms as one of its design goals and thus provides excellent language interoperability Language interoperability is the capability of two different programming languages to natively interact as part of the same system and operate on the same kind of data structures.
There are many ways programming languages are interoperable with on ...
with Java:
; call an instance method
(.toUpperCase "apple")
;; => "APPLE"
; call a static method
(System/getProperty "java.vm.version")
;; => "12+33"
; create an instance of `java.util.HashMap` and
; add some entries
(doto (java.util.HashMap.)
(.put "apple" 1)
(.put "banana" 2))
;; =>
; create an instance of `java.util.ArrayList` and
; increment its elements with `clojure.core/map`
(def al (doto (java.util.ArrayList.)
(.add 1)
(.add 2)
(.add 3)))
(map inc al)
;; => (2 3 4)
; show a message dialog using Java Swing
(javax.swing.JOptionPane/showMessageDialog
nil
"Hello, World!")
;; => nil
Software transactional memory
10 threads manipulating one shared data structure, which consists of 100 vectors each one containing 10 (initially sequential) unique numbers. Each thread then repeatedly selects two random positions in two random vectors and swaps them. All changes to the vectors occur in transactions by making use of Clojure's software transactional memory system:
(defn run
vecs nitems nthreads niters (let > (* nvecs nitems)
(range)
(into [">ec-refs
(->> (* nvecs nitems)
(range)
(into [(comp (partition-all nitems)
(map vec)
(map ref))))
swap
#(let [v1 (rand-int nvecs)
v2 (rand-int nvecs)
i1 (rand-int nitems)
i2 (rand-int nitems)]
(dosync
(let [tmp (nth @(vec-refs v1) i1)]
(alter (vec-refs v1) assoc i1 (nth @(vec-refs v2) i2))
(alter (vec-refs v2) assoc i2 tmp))))
report
#(->> vec-refs
(into [] (comp (map deref)
(map (fn [v] (prn v) v))
cat
(distinct)))
(count)
(println "Distinct:"))]
(report)
(->> #(dotimes niters(swap))
(repeat nthreads)
(apply pcalls)
(dorun))
(report)))
(run 100 10 10 100000)
;; =>
1 2 3 4 5 6 7 8 9 0 11 12 13 14 15 16 17 18 19 ...
90 991 992 993 994 995 996 997 998 999Distinct: 1000
82 318 466 963 619 22 21 273 45 596 08 639 804 471 394 904 952 75 289 778 ...
84 216 622 139 651 592 379 228 242 355Distinct: 1000
nil
See also
* List of JVM languages
This list of JVM Languages comprises notable computer programming languages that are used to produce computer software that runs on the Java virtual machine (JVM). Some of these languages are interpreted by a Java program, and some are compi ...
* List of CLI languages
* Comparison of programming languages
Programming languages are used for controlling the behavior of a machine (often a computer). Like natural languages, programming languages follow the rules for syntax and semantics.
There are thousands of programming languages and new ones are c ...
References
Further reading
*
*
*
*
*
*
*
*
*
*
*
*
*
External links
*
{{Authority control
2007 software
Articles with example Clojure code
Cross-platform free software
Cross-platform software
Dynamic programming languages
Dynamically typed programming languages
Extensible syntax programming languages
Functional languages
High-level programming languages
JVM programming languages
Lisp (programming language)
Lisp programming language family
Multi-paradigm programming languages
Programming languages
Programming languages created in 2007
Scripting languages
Software using the Eclipse license
Source-to-source compilers