clojure.core/sorted-map

View this page on ClojureDocs

Type: function Added: Clojure 1.0 Examples: 8 Runnable: 5

([& keyvals])

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

Examples

by gstamp on 2010-08-02 ▶

;; Sorted maps are sorted by their keys, not their values. (sorted-map :z 0, :a 28, :b 35) {:a 28, :b 35, :z 0} (into (sorted-map) {:a 2 :b 1}) {:a 2, :b 1} ;; (sorted-map ...) is equivalent in behavior to (sorted-map-by compare ...) ;; where compare is Clojure's default comparator function clojure.core/compare ;; For a map sorted by values, see the priority-map data structure: ;; https://github.com/clojure/data.priority-map ;; For a map sorted by the order that key/value pairs were added, ;; see array-map ;; Another sorted map variant is the ordering-map: ;; https://github.com/clj-commons/useful/blob/dc5cdebf8983a2e2ea24ec8951fbb4dfb037da45/src/flatland/useful/map.clj#L243-L245 ;; If you deal with many large maps where the keys are all integers, and ;; want a faster data structure for those, see int-map: ;; https://github.com/clojure/data.int-map

by phreed on 2015-01-23 ▶

; 'seq' can be used to turn a map into a list of vectors ; notice how the list is built in the sorted order as with vectors. (seq (into (sorted-map) {:key1 "value1" :key2 "value2"})) ;;=> ([:key1 "value1"] [:key2 "value2"])

by chrismurrph on 2015-11-08 ▶

; sorting on integer keys ; also notice how each pair becomes a `MapEntry` ('key' 'val') (into (sorted-map) [[23 :x] [17 :y]]) ;;=> {17 :y, 23 :x}

by fasiha on 2016-03-12 . May have evaluation errors. ▶

;; clojure doesn't have a `sorted-map?` function to distinguish a sorted-map ;; from a regular map. use `instance?`: (def unremarkable-map {:k1 "v1" :k2 "v2"}) (def very-remarkable-map (into (sorted-map) unremarkable-map)) (instance? clojure.lang.PersistentTreeMap unremarkable-map) ;;=> false (instance? clojure.lang.PersistentTreeMap very-remarkable-map) ;;=> true ;; This works because: (type unremarkable-map) ;;=> clojure.lang.PersistentArrayMap (PersistentHashMap if many key-val-pairs) (type very-remarkable-map) ;;=> clojure.lang.PersistentTreeMap ;; Clojure does have a `sorted?` predicate so you could define `sorted-map?` (def sorted-map? (every-pred map? sorted?))

by ertugrulcetin on 2019-07-31 ▶

;; Sort hash map by it's keys (def data {"k" 11 "z" 12 "a" 13 "d" 14 }) (into (sorted-map) (sort-by first (seq data))) ;;=> {"a" 13, "d" 14, "k" 11, "z" 12}

by dupuchba on 2021-01-13 . May have evaluation errors. ▶

;; (from previous comment) clojure doesn't have a `sorted-map?` function to distinguish a sorted-map ;; from a regular map. use `instance?`: ;;You can indeed check if the sorted-map is an instance of a clojure.lang.PersistentTreeMap but it won't work for cljs/cljc code. ;; +1 for the use of `map?` and `sorted?` (and (sorted? m) (map? m))

by CapableWeb on 2022-10-10 . May have evaluation errors. ▶

;; In ClojureScript, no exception gets thrown if you pass it a map ;; rather than keyvals, leading to potentially unexpected data ;; In Clojure (1.11.1): (sorted-map {:b 1 :a 2}) ;; Execution error (IllegalArgumentException) at user/eval1 (REPL:1). ;; No value supplied for key: {:b 1, :a 2} ;; In ClojureScript (1.8.40): (sorted-map {:b 1 :a 2}) ;; => {{:b 1, :a 2} nil} ;; ^ is a sorted map, containing the passed in map as the key, with nil as the value ;; What you probably want instead, as illustrated by the other examples: (into (sorted-map) {:b 1 :a 2}) ;; => {:a 2, :b 1}

by hoodr on 2023-05-26 ▶

;; sorted-map requires that all keys are of the same type, otherwise the default ;; clojure compare will throw a ClassCastException when attempt to get/insert (sorted-map :b "bar" :a "foo") ;;=> {:a "foo" :b "bar"} (sorted-map "b" "bar" :a "foo") ;;=> Execution error (ClassCastException) at user/eval1 (REPL:1). ;;=> class java.lang.String cannot be cast to class clojure.lang.Keyword ;; In addition, if you attempt to access keys of a different type from those ;; that exist in the sorted-map you'll also get a ClassCastException from the ;; default compare fn (def m (sorted-map :b "bar" :a "foo")) (get m :a) ;;=> "foo" (get m :b) ;;=> "bar" (get m "a") ;;=> Execution error (ClassCastException) at user/eval1 (REPL:1). ;; class java.lang.String cannot be cast to class clojure.lang.Keyword ;; If you find yourself in a situation where you cannot guarantee the type of ;; the key to lookup, you will need to write a custom compare fn and use ;; sorted-map-by to have the same behavior as PersistentArrayMap and avoid an ;; exception being thrown. (def p (sorted-map-by (fn [a b] (try (compare a b) (catch Exception _ 1))) :b "bar" :a "foo")) (get p :a) ;;=> "foo" (get p "a") ;;=> nil

Note by huahaiy

If transient operations are needed for sorted-map, use data.avl instead of this built-in one.

See also

• clojure.core/sorted-map-by (2)
• clojure.core/subseq (0)
• clojure.core/rsubseq (0)
• clojure.core/sorted-set (3)
• clojure.core/array-map (3)
• clojure.core/hash-map (3)
• clojure.core/sorted? (1)
• clojure.core/compare (3)

---

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