clojure.core/compare

View this page on ClojureDocs

Type: function Added: Clojure 1.0 Examples: 9 Runnable: 3

([x y])

Comparator. Returns a negative number, zero, or a positive number when x is logically 'less than', 'equal to', or 'greater than' y. Same as Java x.compareTo(y) except it also works for nil, and compares numbers and collections in a type-independent manner. x must implement Comparable

Examples

by shockbob on 2011-08-17 ▶

;; various examples ;; comparing vectors of different sizes does not work as you may expect ;; the longer vector is always "greater" regardless of contents (compare [0 1 2] [0 1 2]) 0 (compare [1 2 3] [0 1 2 3]) -1 (compare [0 1 2] [3 4]) 1 (compare nil [1 2 3]) -1 (compare [1 2 3] nil) 1 (compare [2 11] [99 1]) -1 (compare "abc" "def") -3 (compare "abc" "abd") -1

by nwallace on 2016-03-20 ▶

;; number comparisons give results of either 1, 0 or -1 (compare 1 0) ;; => 1 (compare 1 1) ;; => 0 (compare 1 2) ;; => -1 (compare 1 3) ;; => -1 ;; string comparisons give results of the distance between the first characters (compare "B" "A") ;; => 1 (compare "B" "B") ;; => 0 (compare "B" "C") ;; => -1 (compare "AA" "ZZ") ;; => -25

by ercliou on 2017-03-27 . May have evaluation errors. ▶

(compare true false) ;;=> 1 (compare false true) ;;=> -1 (compare true true) ;;=> 0 (compare false false) ;;=> 0

by jafingerhut on 2019-01-27 . May have evaluation errors. ▶

;; `compare` is the default comparator for sorting with `sort` and ;; `sort-by`, for ordering the elements of a `sorted-set`, and for ;; ordering the keys of a `sorted-map`. ;; See https://clojure.org/guides/comparators for advice on writing ;; your own custom comparators. ;; As for all 3-way comparators, compare takes two arguments `x` and ;; `y`. It returns an int (i.e. a Java 32-bit Integer) that is ;; negative if `x` should come before `y`, positive if `x` should come ;; after `y`, or 0 if they are equal. ;; `compare` works for many types of values, ordering values as ;; follows. ;; Numbers are sorted in increasing numeric order, returning 0 if two ;; numbers are numerically equal by `==`, even if `=` returns false (sort [22/7 2.71828 ##-Inf 1 55 3N]) (##-Inf 1 2.71828 3N 22/7 55) ;; Regular sets use `=` for detecting duplicates, so all of the ;; numbers in this example are considered distinct elements. Numbers ;; in different "categories" (integer & ratio, floating point, ;; BigDecimal) are never `=` to each other. (set [1.5 1.5M 3/2]) #{1.5 3/2 1.5M} ;; Sorted sets use `compare` for detecting duplicates, which is more ;; like `==` for determining when numbers have the same numeric value ;; regardless of "category", so all of the numbers in this example are ;; considered equal. Thus only the first one is added. (sorted-set 1.5 1.5M 3/2) #{1.5} ;; An oddity: (compare ##NaN x) and (compare x ##NaN) returns 0 (equal) for any ;; number x, including ##NaN, but (== ##NaN x) and (== x ##NaN) returns false (== 1 ##NaN) false (compare 1 ##NaN) 0 (== ##NaN ##NaN) false (compare ##NaN ##NaN) 0

by jafingerhut on 2019-01-27 . May have evaluation errors. ▶

;; Strings are sorted in lexicographic order, aka dictionary order ;; (http://en.wikipedia.org/wiki/Lexicographical_order) by their ;; representation as sequences of UTF-16 code units. This is ;; alphabetical order (case-sensitive) for strings restricted to the ;; ASCII subset. See Java documentation of String's `compareTo` ;; method for additional details on `String` comparison. ;; https://docs.oracle.com/javase/8/docs/api/java/lang/String.html#compareTo-java.lang.String- (sorted-set "aardvark" "boo" "a" "Antelope" "bar") #{"Antelope" "a" "aardvark" "bar" "boo"} ;; Symbols are sorted by their representation as strings, sorting ;; first by their namespace name, and if they are in the same ;; namespace, then by their name. If no namespace is included, those ;; symbols will be sorted before any symbol with a namespace. (sorted-set 'user/foo 'clojure.core/pprint 'bar 'clojure.core/apply 'user/zz) #{bar clojure.core/apply clojure.core/pprint user/foo user/zz} ;; Keywords are sorted similarly to symbols. (sorted-map :map-key 10, :amp [3 2 1], :blammo "kaboom") {:amp [3 2 1], :blammo "kaboom", :map-key 10}

by jafingerhut on 2019-01-27 . May have evaluation errors. ▶

;; Vectors are sorted by their length first, from shortest to longest, ;; then lexicographically among equal-length vectors. (sort [[-8 2 5] [-5 -1 20] [1 2] [1 -5] [10000]]) ([10000] [1 -5] [1 2] [-8 2 5] [-5 -1 20])

by jafingerhut on 2019-01-27 . May have evaluation errors. ▶

;; All Java types implementing the `Comparable` interface such as ;; characters, booleans, `File`, `URI`, and `UUID` are compared via ;; their `compareTo` methods. ;; https://docs.oracle.com/javase/8/docs/api/java/lang/Comparable.html (import '(java.util UUID)) java.util.UUID (def u1 (UUID. 5 10)) #'user/u1 (def u2 (UUID. 5 17)) #'user/u2 (def u3 (UUID. 10 0)) #'user/u3 u1 #uuid "00000000-0000-0005-0000-00000000000a" u2 #uuid "00000000-0000-0005-0000-000000000011" u3 #uuid "00000000-0000-000a-0000-000000000000" (sort [u3 u2 u1]) (#uuid "00000000-0000-0005-0000-00000000000a" #uuid "00000000-0000-0005-0000-000000000011" #uuid "00000000-0000-000a-0000-000000000000") ;; `nil` can be compared to all values above, and is considered less ;; than anything else. (sort [:ns2/kw1 :ns2/kw2 :ns1/kw2 :kw2 nil]) (nil :kw2 :ns1/kw2 :ns2/kw1 :ns2/kw2)

by jafingerhut on 2019-01-27 . May have evaluation errors. ▶

;; `compare` throws an exception if given two values whose types are ;; "too different", e.g. it can compare integers, longs, and doubles ;; to each other, but not strings to keywords or keywords to symbols. ;; It cannot compare lists, sequences, sets, or maps at all. ;; See https://clojure.org/guides/comparators for advice on writing ;; your own custom comparators. (sort [5 "a"]) Execution error (ClassCastException) at java.lang.String/compareTo (String.java:111). java.lang.Long cannot be cast to java.lang.String (sort [:foo 'bar]) Execution error (ClassCastException) at java.util.TimSort/countRunAndMakeAscending (TimSort.java:355). clojure.lang.Keyword cannot be cast to clojure.lang.Symbol (sort [#{1 2} #{2 4}]) Execution error (ClassCastException) at java.util.TimSort/countRunAndMakeAscending (TimSort.java:355). clojure.lang.PersistentHashSet cannot be cast to java.lang.Comparable (sort [{:a 1 :b 3} {:c -2 :d 4}]) Execution error (ClassCastException) at java.util.TimSort/countRunAndMakeAscending (TimSort.java:355). clojure.lang.PersistentArrayMap cannot be cast to java.lang.Comparable (sort [[1 2] '(3 4)]) Execution error (ClassCastException) at java.util.TimSort/countRunAndMakeAscending (TimSort.java:355). clojure.lang.PersistentList cannot be cast to java.lang.Comparable (sort [[1 2] (seq [3 4])]) Execution error (ClassCastException) at java.util.TimSort/countRunAndMakeAscending (TimSort.java:355). clojure.lang.PersistentVector$ChunkedSeq cannot be cast to java.lang.Comparable

by uosl on 2020-07-27 ▶

;; You can reverse the sort order returned by `compare` by swapping its arguments. #(compare %2 %1) (sort #(compare %2 %1) [3 2 4 1]) (4 3 2 1) ;; Source: https://clojure.org/guides/comparators#_reverse_order

Note by glts

It is clear what compare does, but how do you turn its output into an answer to questions like ‘is x less than y’ or ‘is x greater than or equal to y’?

While the numeric < <= = >= > provide that answer in Boolean form right away, with compare a second step is required.

((juxt < <= = >= >) 2 3)
;;=> [true true false false false]

Here is a listing of the same relations using compare:

((juxt (comp neg? compare)
       (comp not pos? compare)
       (comp zero? compare)
       (comp not neg? compare)
       (comp pos? compare))
 "2" "3")
;;=> [true true false false false]

See also

• clojure.core/sort-by (5)
• clojure.core/sorted-set-by (2)
• clojure.core/sorted-map-by (2)
• clojure.core/== (5)

---

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