Clojure’s standard library, i.e. the clojure.* namespaces, provide a
ton of general-purpose functionality for writing robust, maintainable
applications.
Getting a handle on all the functionality you’ll want to use can be a
little daunting at first, especially if you’re coming from
object-oriented languages like Java, Ruby, or Python, where behavior
is grouped using classes. In Clojure, namespaces are used to group
similar behavior and state, and we’ve outlined a few of the core
namespaces to help you find what you’re looking for.
We have a
page listing all functions, macros, and other vars in Clojure’s core library
as well.
The largest of the core namespaces, clojure.core provides the bulk of the functionality
you’ll be using to build Clojure programs.
There are too many core functions to feature here, but take a look at the
quickref to get a breakdown by conceptual arena.
A Clojure library providing facilities for async programming and communication.
Core.async is not provided as part of Clojure’s standard distribution, and must be included as a dependency.
Core.logic is not provided as part of Clojure’s standard distribution, and must be included as a dependency.
clojure.core.server contains functions to expose the Clojure environment through a socket connection and across network boundaries. If the property -Dclojure.server.repl="{:port 8881 :accept clojure.core.server/repl}" is present when the JDK starts, Clojure will start the related socket server (or more than one) on the specified port. The API in the namespace allows to do this programmatically.
Extensible Data Notation is a subset of the Clojure language used as a
data transfer format, designed to be used in a similar way to JSON or
XML.
At some point in your adventures in Clojure land, you’ll want to
deserialize some clojure data structures from a string, and you’ll
want to use clojure.edn/read or
clojure.edn/read-string for that. Do not
use the read-* functions in clojure.core to deserialize untrusted Clojure code, as they can be unsafe.
Pretty printing utility, really nice for looking at larger-ish data structures. See pprint.
Functions for working on sets (#{1 2 3 4}) in all the ways you’d expect, e.g. calculating the intersection of two sets, and testing if one set is a subset of another.
Provides most standard string manipulation and processing function
that you’d expect in any general-purpose programming language.
In Clojure and ClojureScript strings are represented using the native
platform implementation, and can be directly manipulated,
e.g. (.toLowerCase "FOO") ;=> "foo". The clojure.string namespace
gives you the ability to manipulate strings in an idiomatic way:
(clojure.string/lower-case "FOO") ;=> "foo".
Something to keep in mind is most (all?) of these functions take the
string to act on as the first parameter, lending themselves well for
use with the single-thrush operator (->)
, as in this contrived example:
(require '[clojure.string :as str])(-> " .LIRpa ni yAD dloc thgIrb a sAw Ti "
str/reverse
str/trim
str/lower-case
(str/replace #“\s+” " ")
str/capitalize);;=> “It was a bright cold day in april”
Provides basic facilities for unit testing Clojure code.
Functional tree editing and manipulation. One of the core benefits of using Clojure is that you mostly work with immutable data structures. This, in turn, seems to make your programs easier to build and maintain.