The addition function (+) takes any number of numeric arguments and returns their sum.

(+ 2 2)
-> 4
(+ 1 2 3)
-> 6

The subtraction function (–) takes any number of numeric arguments. When given a single argument, it returns its negation. When given multiple arguments, it returns the result of subtracting all subsequent arguments from the first.

(− 5)
-> −5
(− 5 1)
-> 4
(− 5 2 1)
-> 2

The multiplication function (*) takes any number of numeric arguments and returns their product.

(* 5 5)
-> 25
(* 5 5 2)
-> 50

The division function (/) takes any number of numeric arguments. The first argument is considered the numerator and any number of additional argument denominators. If no denominators are supplied, the function returns 1/numerator, otherwise it returns the numerator divided by all of the denominators.

(/ 10)
-> 1/10
(/ 1.0 10)
-> 0.1
(/ 10 2)
-> 5
(/ 10 2 2)
-> 5/2

The increment function (inc) takes a single numeric argument and returns its value + 1.

(inc 5)
-> 6

The decrement function (dec) takes a single numeric argument and returns its value - 1.

(dec 5)
-> 4

The quotient function (quot) takes two numeric arguments and returns the integer quotient obtained by dividing the first by the second.

(quot 5 2)
-> 2

The remainder, or modulus, function (rem) takes two numeric arguments and returns the remainder obtained by dividing the first by the second.

(rem 5 2)
-> 1

The minimum function (min) takes any number of numeric arguments and returns the smallest.

(min 5 10 2)
-> 2

The maximum function (max) takes any number of numeric arguments and returns the largest.

(max 5 10 2)
-> 10

The equals function (==) takes any number of numeric arguments and returns true if they are equal, else false.

(== 5 5.0)
-> true

The greater-than function (<) takes any number of numeric arguments and returns true if they are in ascending order, else false.

(< 5 10)
-> true
(< 5 10 9)
-> false

The greater-than-or-equals function (<=) takes any number of numeric arguments and returns true if they are in ascending order or sequentially equal, else false.

(<= 5 5 10)
-> true

The less-than function (>) takes any number of numeric arguments and returns true if they are in descending order, else false.

(> 10 5)
-> true

The less-than-or-equals function (>=) takes any number of numeric arguments and returns true if they are in descending order or sequentially equal, else false.

(>= 10 5 5)
-> true

The zero test function (zero?) takes a single numeric argument and returns true if it is zero, else false.

(zero? 0.0)
-> true

The positive test function (pos?) takes a single numeric argument and returns true if it is > 0, else false.

(pos? 5)
-> true

The negative test function (neg?) takes a single numeric argument and returns true if it is > 0, else false.

(neg? −5)
-> true

The number test function (number?) takes a single argument and returns true if it is a number, else false.

(number? 5)
-> true
(number? "hello")
-> false

The string concatenation function (str) takes any number of arguments. It converts them to strings if they are not already and returns the string created by concatenating them. If passed no arguments or nil, it returns the empty string, "".

(str "I have " 5 " books.")
-> "I have 5 books."

The substring function (subs) takes two or three arguments, the first always being a string, the second an integer offset, and the third (optional) another integer offset. It returns the substring from the first offset (inclusive) to the second (exclusive) or to the end of the string if a second offset is not supplied.

(subs "Hello World" 6)
-> "World"
(subs "Hello World" 0 5)
-> "Hello"

The string test function (string?) takes a single argument and returns true if it is a string, else false.

(string? "test")
-> true
(string? 5)
-> false

The string printing functions (print & println) take any number of arguments, converts them to strings if they are not already, and prints them to the standard system output println appends a newline character to the end. Both return nil.

This function (re-pattern) takes a single string argument and returns a regular expression pattern (an instance of java.util.regex.Pattern). The pattern can then be used for subsequent regular expression matches.

(re-pattern " [a-zA-Z]*")
-> #"[a-zA-Z]*"

There is also a reader macro that allows you to enter a regex pattern as a literal: just use the # symbol before a string. The resulting value is a pattern, just as if you used the re-pattern function. For example, the following form is identical to the preceding example:

#" [a-zA-Z]* "
-> #"[a-zA-Z]*"

re-matches takes two arguments: a regular expression pattern and a string. It returns any regular expression matches of the pattern in the string, or nil if no matches were found. For example, the following code:

(re-matches #"[a-zA-Z]* " "test")
-> "test"
(re-matches #"[a-zA-Z]* " "test123")
-> nil

re-matcher takes two arguments: a regular expression pattern and a string. It returns a stateful "matcher" object, which can be supplied to most other regex functions instead of a pattern directly. Matchers are instances of java.util.regex.Matcher.

(def my-matcher (re-matcher #" [a-zA-Z]* " "test")
-> #'user/my-matcher

re-find takes either a pattern and a string or a single matcher. Each call returns the next regex match for the matcher, if any.

(re-find my-matcher)
-> "test"
(re-find my-matcher)
-> ""
(re-find my-matcher)
-> nil

re-groups takes a single matcher, and returns the groups from the most recent find/match. If there are no nested groups, it returns a string of the entire match. If there are nested groups, it returns a vector of groups, with the first element being the entire (non-nested) match.

re-seq takes a pattern and a string. It returns a lazy sequence (see Chapter 5) of successive matches of the pattern on the string, using an internal matcher.

(re-seq #" [a-z] " "test")
-> ("t" "e" "s" "t")

The not function (not) takes a single argument. It resolves to true if it is logically false and false if it is logically true.

(not (== 5 5))
-> false

The and macro takes any number of arguments, and resolves to true if they are each logically true, else false. It is efficient in that if the first argument is false, it returns false immediately without bothering to evaluate the others.

(and (== 5 5) (< 1 2))
-> true

The or macro takes any number of arguments and resolves to true if one or more of them are logically true, else false. It is efficient in that it returns true as soon as it encounters a true argument, without bothering to evaluate the others.

(or (== 5 5) (== 5 4))
-> true

The map association function (assoc) takes as its arguments a map and a number of sequential key-value pairs. It returns a new map with the provided values associated with their respective keys, replacing any existing values with those keys.

(assoc {:a 1 :b 2} :c 3)
-> {:c 3, :a 1, :b 2}
(assoc {:a 1 :b 2} :c 3 :d 4)
-> {:d 4, :c 3, :a 1, :b 2}

The map disassociation function (dissoc) takes as its arguments a map and a number of keys. It returns a new map formed by removing the provided keys from the supplied map.

(dissoc {:a 1 :b 2 :c 3} :c)
-> {:a 1, :b 2}
(dissoc {:a 1 :b 2 :c 3 :d 4} :a :c)
-> {:b 2, :d 4}

The conj function (conj) works with maps the same way as it does with vectors, only instead of being given individual items to append it must be given a key-value pair.

(conj {:a 1 :b 2 :c 3} {:d 4})
-> {:d 4, :a 1, :b 2, :c 3}

A vector pair as an item also works, as shown in the following code:

(conj {:a 1 :b 2 :c 3} [:d 4])
-> {:d 4, :a 1, :b 2, :c 3}

The map merge function (merge) takes any number of arguments, each of which is a map. It returns a new map formed by combining all the keys and values of its arguments. If a key is present in more than one map, the final value will be that of the last map provided containing that key.

(merge {:a 1 :b 2} {:c 3 :d 4})
-> {:d 4, :c 3, :a 1, :b 2}

The map merge-with function (merge-with) takes a first-class function as its first argument and any number of additional arguments, each of which is a map. It returns a new map formed by combining all the keys and values of the map arguments. If a key is present in more than one map, the value in the result map is the result of calling the supplied function with the values of the conflicting key as parameters.

(merge-with + {:a 1 :b 2} {:b 2 :c 4})
-> {:c 4, :a 1, :b 4}

The map get function (get) takes a map and a key as its first and second arguments, and an optional third argument specifying the value if the key is not found. It returns the value of the specified key in the map, returning nil if it is not found and there is no third argument.

(get {:a 1 :b 2 :c 3} :a)
-> 1
(get {:a 1 :b 2 :c 3} :d 0)
-> 0

The map contains function (contains?) takes a map and a key as arguments. It returns true if the provided key is present in the map, otherwise false. In addition to maps, it also works on vectors and sets.

(contains? {:a 1 :b 2 :c 3} :a)
-> true

The map test function (map?) takes a single argument and returns true if it is a map, otherwise false.

(map? {:a 1 :b 2 :c 3})
-> true

The map keys function (keys) takes a single argument, a map. It returns a list of all the keys present in the map.

(keys {:a 1 :b 2 :c 3})
-> (:a :b :c)

The map vals function (vals) takes a single argument, a map. It returns a list of all the values in the map.

(vals {:a 1 :b 2 :c 3})
-> (1 2 3)

The set union function takes any number of arguments, each a set. It returns a new set containing the union of the members of the argument sets.

(clojure.set/union #{:a :b} #{:c :d})
-> #{:a, :c, :b, :d}

The set intersection function takes any number of arguments, each a set. It returns a new set containing the intersection of the members of the argument sets or the empty set if there is no intersection.

(clojure.set/intersection #{:a :b :c :d} #{:c :d :f :g})
-> #{:c, :d}

The set difference function takes any number of arguments, each a set. It returns a new set containing the members of the first set without the members of the remaining sets.

(clojure.set/difference #{:a :b :c :d} #{:c :d})
-> #{:a, :b}