Clojure equality of collections with sequences

Question

I noticed that Clojure (1.4) seems to be happy to consider vectors equal to the seq of the same vector, but that the same does not apply for maps:

(= [1 2] (seq [1 2]))
=> true

(= {1 2} (seq {1 2}))
=> false

Why should the behaviour of = be different in this way?

Answer 1

Clojure's = can be thought of as performing its comparisons in two steps:

1. Check if the types of the things being compared belong to the same "equality partition", that is a class of types whose members might potentially be equal (depending on things like the exact members of a given data structure, but not the particular type in the partition);

2. If so, check if the things being compared actually are equal.

One such equality partition is that of "sequential" things. Vectors are considered sequential:

(instance? clojure.lang.Sequential [])
;= true

As are seqs of various types:

(instance? clojure.lang.Sequential (seq {1 2}))
;= true

Therefore a vector is considered equal to a seq if (and only if) their corresponding elements are equal.

(Note that (seq {}) produces nil, which is not sequential and compares "not equal" to (), [] etc.)

On the other hand, maps constitute an equality partition of their own, so while a hash map might be considered equal to a sorted map, it will never be considered equal to a seq. In particular, it is not equal to the seq of its entries, which is what (seq some-map) produces.

Answer 2

I guess this is because in sequences order as well as value at particular position matters where as in map the order of key/value doesn't matter and this difference between semantics causes this to work as shown by your sample code.

For more details have a look at mapEquals in file https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/APersistentMap.java

It checks if the other object is not map then return false.

Answer 3

user=> (seq {1 2})
([1 2])
user=> (type {1 2})
clojure.lang.PersistentArrayMap