clojure.core/=

View this page on ClojureDocs

Type: function Added: Clojure 1.0 Examples: 7 Runnable: 4

([x] [x y] [x y & more])

Equality. Returns true if x equals y, false if not. Same as Java x.equals(y) except it also works for nil, and compares numbers and collections in a type-independent manner. Clojure's immutable data structures define equals() (and thus =) as a value, not an identity, comparison.

Examples

by citizen428 on 2010-07-30 ▶

(= 1) true (= 1 1) true (= 1 2) false (= 1 1 1) true (= 1 1 2) false (= '(1 2) [1 2]) true (= nil nil) true (= (sorted-set 2 1) (sorted-set 1 2)) true ;; It should be noted that equality is not defined for Java arrays. ;; Instead you can convert them into sequences and compare them that way. ;; (= (seq array1) (seq array2))

by phreed on 2014-10-09 . May have evaluation errors. ▶

;; There are functional differences between = and == ;; = may introduce java autoboxing ;; true: (= 1) (= 1 1) (= 1/1, 2/2, 3/3, 4/4) (= :foo) (= nil anything) ; anything = nil ;; false: (= 1, 1.0, 1/1) ; differs from == (= 1 2) (= 1 \1) ; differs from == (= 1 "1") ; differs from ==

by phreed on 2014-12-18 . May have evaluation errors. ▶

;; If passed a single value (= x) the result is always true. (= 1) (= nil) (= false) (= true) (= {:a 1 :b2}) (= 'false) ;;=> true

by huahaiy on 2018-11-28 ▶

;; = can be used to compare the equality of nested Clojure data structures (= {:a [1 {1 2}] :b 'ok :c "string"} {:b 'ok :c "string" :a '(1 {1 2})}) ;;=> true

by huahaiy on 2018-11-28 ▶

;; See the Clojure Equality guide for more details: ;; https://clojure.org/guides/equality ;; One perhaps surprising case is comparing regular expressions. ;; In Clojure, regular expressions only equal one another if they are ;; the same object in memory, i.e. if (identical? x y) is also true. ;; Therefore, any data structure containing regular expression will ;; only be equal to one another if the corresponding regular expressions are ;; identical. ;; See https://dev.clojure.org/jira/browse/CLJ-1182 (= #"fav*" #"fav*") ;;=> false ;; Another exception is the special floating point value ##NaN for "Not a Number". ;; In Clojure on Java, this value is never equal to itself, and any collections ;; containing such "values" are never equal to any other collections, either: (= ##NaN ##NaN) ;;=> false (= [1 2 3 ##NaN] [1 2 3 ##NaN]) ;;=> false ;; There are a few other minor exceptions where clojure.core/= might behave in ;; ways that surprise you. You can find an article describing the known cases ;; for Clojure on Java here: https://clojure.org/guides/equality

by mars0i on 2022-02-18 . May have evaluation errors. ▶

;; You can test for a Java infinity, but there are quirks to know about. ;; Note particularly that Double/POSITIVE_INFINITY and Float/POSITIVE_INFINITY ;; are = and ==, but they are neither identical? nor .equals. However, the ;; value these Java objects return has the same representation, ##Inf, in ;; Clojure. Further, the literal ##Inf is parsed as something that is ;; .equals to Double/POSITIVE_INFINITY but not identical? to it. Similar ;; points hold for the Java NEGATIVE_INFINITY's and their Clojure ;; representation, ##-Inf. Double/POSITIVE_INFINITY ;;=> ##Inf Float/POSITIVE_INFINITY ;;=> ##Inf (= Double/POSITIVE_INFINITY Float/POSITIVE_INFINITY) ;;=> true (= ##Inf ##Inf) ;;=> true (== Double/POSITIVE_INFINITY Float/POSITIVE_INFINITY) ;;=> true (== ##Inf ##Inf) ;;=> true (identical? Double/POSITIVE_INFINITY Float/POSITIVE_INFINITY) ;;=> false (identical? ##Inf ##Inf) ;;=> true (.equals Double/POSITIVE_INFINITY Float/POSITIVE_INFINITY) ;;=> false (.equals ##Inf ##Inf) ;;=> true (identical? ##Inf Double/POSITIVE_INFINITY) ;;=> false (identical? ##Inf Float/POSITIVE_INFINITY) ;;=> false (.equals ##Inf Double/POSITIVE_INFINITY) ;;=> true (.equals ##Inf Float/POSITIVE_INFINITY) ;;=> false ;; (Tested with Clojure 1.10.3.)

by clojer on 2022-06-12 ▶

(= + +) true (= = =) true (= inc inc) true (= #() #()) false

Note by gstamp

There is a difference between "=" and "". For primitives you definitely want to use "" as "=" will result in a cast to the wrapped types for it's arguments.

This may not be the case come Clojure 1.3 (see [1])

[1] http://github.com/clojure/clojure/commit/df8c65a286e90e93972bb69392bc106128427dde

Note by domokato

= compares collections in a type-independent manner but not numbers, despite what the docs say. See examples above.

See also

• clojure.core/== (5)
• clojure.core/not= (3)
• clojure.core/identical? (3)

---

Content from the matching ClojureDocs page, with authors credited on each contribution.