Check for character equality in clojure - clojure

Question

I'm new to clojure and trying to compare a list of characters and I've encountered some confusing behavior. Why is it difficult (impossible?) to compare the equality of a list of characters when it is straightforward to compare the concatenated string version?
(identical? (\A \T \C \G) (\A \T \C \G) )
; ClassCastException java.lang.Character cannot be cast to clojure.lang.IFn user/eval672
;(NO_SOURCE_FILE:1)
(identical? '(\A \T \C \G) '(\A \T \C \G) )
;false
;convert to string
(identical? "ATCG" "ATCG" )
;True

Answer 1

From the REPL:
user=> (doc identical?)
-------------------------
clojure.core/identical?
([x y])
Tests if 2 arguments are the same object
If you know Java programming language, then identical? is behaving like == operator in Java when dealing with references.
You can try this:
(= '(\A \T \C \G) '(\A \T \C \G) )
=> true
Again, in the REPL:
user=> (doc =)
-------------------------
clojure.core/=
([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.
So no, it is not impossible and definitely not difficult to compare the equality of lists in Clojure. REPL is your best friend.

Answer 2

As an addendum to #Chiron 's answer: you have three kinds of equality in Clojure.
Clojure Equality or Equivalence
= (and == for numbers) is specific to Clojure and is the one you'll use the most. It performs a type-independent value comparison, which means that numbers of the same category (integers vs decimals) and similar data structures (e.g. lists, vectors and sets or maps and sequences of pairs) can be equal under that definition. It works with pure Java types too.
(= 5 5N) ;; true
(import 'java.util.ArrayList)
(= '(:a :b)
(let [l (ArrayList.)
_ (.add l :a)
_ (.add l :b)]
l)) ;; true
Java Equality
All Clojure types are Java classes under the hood, so all non-nil Clojure entities implement .equals, and for most Clojure types it behaves just like = would. But it is a less type-blind comparison ; for instance, most Clojure numeric types are pure Java types and for all Java numeric types .equals is type-specific.
(.equals 5 5N) ;; false
Beware. There are many pitfalls in writing equality methods in Java. Many library developers fell.
Object Identity
identical? behaves just like Java's == operator which returns true if and only if both parameters are the same object instance ; it's "address in memory" equality, so the stricter tool available. But sometimes that's exactly what you need.
Regarding the behaviors you encountered:
(identical? '(\A \T \C \G) '(\A \T \C \G)) returns false because two distinct list instances are created in the compiled code (the same would happen with vector, map and set literals) ; as a consequence/counter-example, this will work:
(let [a '(A \T \C \G)]
(identical? a a))
The compiler doesn't see the two list literals as identical ; it only sees two parameters and compiles each of them as a new list, hence two distinct list instances. Their contents are the same at runtime, though, because these character literals are cached ; so are boolean literals and some (but not all) numeric literals:
(identical? \A \A)
(identical? true true)
(identical? 5 5) ;; Long
(identical? 0N 0N) ;; BigInt
(identical? (byte 6)
(byte 6))
(identical? (short 7)
(short 7))
(identical? (int 8)
(int 8))
(identical? (biginteger 9)
(biginteger 9))
(identical? (bigdec 10)
(bigdec 10))
Most type caches have limitations, though ; all of the following are not cached (and thus identical? returns false):
;; Java cache limitations
(identical? (char 128) ;; Characters with codepoint outside of 0..127
(char 128)) ;; i.e. non-"C0 Control/Basic Latin" Characters
(identical? 128 128) ;; Longs/Integers/Shorts outside of -128..127
(identical? 0. 0.) ;; Doubles and Floats are not cached
(identical? (biginteger 17)
(biginteger 17)) ;; BigIntegers outside of -16..16
(identical? (bigdec 11)
(bigdec 11)) ;; BigDecimals outside of 0..10
;; Clojure cache limitations
(identical? 1N 1N) ;; 0N is the only cached BigInt literal
(identical? 0M 0M) ;; BigDecimal literals are not cached
(identical? 1/2 1/2) ;; Ratios are not cached
;; Note that Ratio literals of the form X/1
;; and any other reducible to an integer
;; e.g. 10/10 are compiled as integer types
;; (Long/BigInt)
(identical? "ATCG" "ATCG" ) returns true because Clojure String literals are interned ; so are keywords:
(identical? :foo :foo)
;; but not symbol literals
(identical? 'foo 'foo) ;; false