clojure.core/sorted-map-by

View this page on ClojureDocs

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

([comparator & keyvals])

keyval => key val Returns a new sorted map with supplied mappings, using the supplied comparator. If any keys are equal, they are handled as if by repeated uses of assoc.

Examples

by gstamp on 2010-10-13 ▶

; The basic function requires discrete elements, and cannot accept a ; pre-existing map: (sorted-map-by > 1 "a", 2 "b", 3 "c") {3 "c", 2 "b", 1 "a"} ; We can use the syntax "(sorted-map >)" to create an empty sorted map that sorts ; in reverse order (i.e. the opposite of "(sorted-map)"). It we can then fill ; it using (into ...) with a pre-existing map: (into (sorted-map-by >) {1 :a 2 :b 3 :c} ) {3 :c, 2 :b, 1 :a} ; This two are the same (into (sorted-map-by <) {1 :a 2 :b 3 :c} ) {1 :a, 2 :b, 3 :c} (into (sorted-map) {1 :a 2 :b 3 :c} ) {1 :a, 2 :b, 3 :c}

by defiantt on 2012-03-09 . May have evaluation errors. ▶

;; If you wish to sort the map according to the values, instead of by keys ;; the following code WILL NOT WORK! This is because the map values are not unique. (let [results {:A 1 :B 2 :C 2 :D 5 :E 1 :F 1}] (into (sorted-map-by (fn [key1 key2] (compare (get results key2) (get results key1)))) results)) => {:D 5, :C 2, :A 1} ;; To make sure that the sorting works, we can make sure that the comparator ;; works on unique values (let [results {:A 1 :B 2 :C 2 :D 5 :E 1 :F 1}] (into (sorted-map-by (fn [key1 key2] (compare [(get results key2) key2] [(get results key1) key1]))) results)) => {:D 5, :C 2, :B 2, :F 1, :E 1, :A 1} ;; See this article for more details: https://clojure.org/guides/comparators

by aarkerio on 2020-03-31 ▶

;; Ordering using nested values (def rows {:45 {:ordnen 5} :55 {:ordnen 8} :66 {:ordnen 3} :68 {:ordnen 90} :13 {:ordnen 1}}) (into (sorted-map-by (fn [key1 key2] (compare (get-in rows [key1 :ordnen]) (get-in rows [key2 :ordnen])))) rows) {:13 {:ordnen 1}, :66 {:ordnen 3}, :45 {:ordnen 5}, :55 {:ordnen 8}, :68 {:ordnen 90}}

by ejschoen on 2020-05-05 . May have evaluation errors. ▶

;; Note that when querying values from the map, the comparator will be called, ;; and must work on values that are not keys in the map: (get (into (sorted-map-by (fn [a b] (println a b) (compare a b))) {"a" 1 "b" 2})) "c") b a c a c b => nil ;; If the comparator looks into an auxiliary data structure for a comparison ;; value, ensure that the comparator can handle a missing value in that data ;; structure: (let [other {"a" 10 "b" 1} m (into (sorted-map-by (fn [a b] (< (get other a) (get other b)))) {"a" 1 "b" 2})] (println (get m "a")) (println (get m "b")) (println (get m "c"))) 1 2 NullPointerException clojure.lang.Numbers.ops (Numbers.java:1013)

Note by noisesmith

an unstable sorting function will give nonsense results:

user=> (into (sorted-map-by (fn [_ _] (rand-int Integer/MAX_VALUE))) [[:a 0] [:a 1] [:a 2]])

{:a 0, :a 1, :a 2}

### Note by elias94

As previously noted, using an unstable sorting function could lead to unexpected results and hard to find bug. The `PersistentTreeMap` object returned by `sorted-map-by`, stores the `comparator` function and will reuse it in consecutive operations as `assoc`.

(def ord [:a :b :c])
(def m (into (sorted-map-by (fn [a b] 
                              (compare (.indexOf ord a) 
                                       (.indexOf ord b))))  
             {:a 1 :b 2 :c 3}))
(assoc m :d 4) ; => {:d 4, :a 1, :b 2, :c 3}
(-> (assoc m :d 4)
    (assoc :e 5)) ; => {:d 5, :a 1, :b 2, :c 3} WRONG


[Source reference](https://github.com/clojure/clojure/blob/master/src/jvm/clojure/lang/PersistentTreeMap.java#L28)



## See also



  clojure.core/sorted-map (5)


  clojure.core/subseq (0)


  clojure.core/rsubseq (0)


  clojure.core/sorted-set-by (2)


  clojure.core/compare (3)


  clojure.core/comparator 





---

Content from [the matching ClojureDocs page](https://clojuredocs.org/clojure.core/sorted-map-by), with authors
credited on each contribution.