Clojure Q&A - Recent questions tagged maps

`merge-with` doesn´t treat pair (vectors of 2) the same way `merge` does

Thu, 01 May 2025 11:25:20 +0000

;; merge
(merge {:a :b} [:a :c]) ;=> {:a :c}

;; merge-with
(merge-with (fn [_ x] x) {} {:a :b} [:a :c])
;; => class clojure.lang.Keyword cannot be cast to class java.util.Map$Entry

I think this happens because merge-with eventually calls seq on the "Map", expecting to get a "Map Entry" from which then it can extracts key and value, and fails when receiving a Vector, because seq will just yield one element at a time:

(key (first (seq {:a :c}))) ;; => :a
(key (first (seq [:a :c])))
;; => class clojure.lang.Keyword cannot be cast to class java.util.Map$Entry

I think it is justified to expect that (partial merge-with (fn [_ x] x)) should behave exactly as merge and my proposal is to make it happen, if what I described makes sense.

Thank you!

Gather all keys and values of nested map that satisfies some condition

Thu, 07 Nov 2024 21:38:20 +0000

Hi,
From a nested map, I'd like to build a map that saves all key - value pairs whose keys satisfy some conditions.
I'm using babashka.
Tried some different solutions, but I'm not able to retrieve all pairs.

The first one, using (I think) a more functional approach j-h5.

    #!/usr/bin/env bb
    
    ; expected output: {"k23" {"k231" "v231"} "k24" "v24"}
 (def j {"k1" "v1" "k2" {"k21" "v21" "k22" "v22" "k23" {"k231" "v231"} "k24" "v24"} "k3" "v3"})
(println j)

(println "Doing j-h5")
(defn j-h5 [s mymap]
  (let [first-k (first (first s))
        first-v (second (first s)) ]
    (cond 
      (empty? s) nil
      (or (= "k23" first-k) (= "k24" first-k))
      (do 
        (assoc mymap first-k first-v)
        (when (and ( map? first-v) (seq first-v))
            (println  (str "doing recursion1 when k:" first-k "  and v:" first-v))
            (recur first-v mymap))
        )
      (map? first-v)
            (do 
              (println  (str "doing recursion2 when k:" first-k "  and v:" first-v))
              (recur first-v mymap))
      :else (recur (rest s) mymap) 
      )))

(j-h5 j {})

; mymap defined outside of function   
(println "Doing j-h1")
(def  mymap {})
(defn j-h1 [s]
  (let [first-k (first (first s))
        first-v (second (first s)) ]
    (cond 
      (empty? s) mymap
      (or (= "k23" first-k) (= "k24" first-k))
      (do 
        (assoc mymap first-k first-v)
        (when (and ( map? first-v) (seq first-v))
            (println  (str "doing recursion1 when k:" first-k "  and v:" first-v))
            (recur first-v))
        )
      (map? first-v)
            (do 
              (println  (str "doing recursion2 when k:" first-k "  and v:" first-v))
              (recur first-v))
      :else (recur (rest s)) 
      )))

(j-h1 j)

How can this be fixed?

Apply two functions to a collection and to another that is a transformation of the other one

Tue, 22 Oct 2024 22:13:46 +0000

Hi,

The challenge is to get the server name part of a collection of strings of fully qualified domain names.
From: ["server1.oo.com" "s2.ee.com"]
To: ["server1" "s2"]

I can do this to a single element as:

(subs "server1.oo.com" 0 (str/index-of "server1.oo.com" \.))

(subs "server1.oo.com" 0 (#(str/index-of % \.) "server1.oo.com"))

But nested #() functions seem not to be possible.

(#(subs % 0 (#(str/index-of % \.) "server1.oo.com")) "server1.oo.com")

returns an error.

When using the collection, something like this works:

(let 
  [s-col ["server1.oo.com" "s2.ee.com"]]   
  (map #(subs % 0 5) s-col))

But, how can I use the (str/index-of % \.) instead of that hard-coded 5?
All my attempts were unsuccessful.

destructuring corner case: [& {:as key-vals}]

Wed, 03 Jul 2024 11:49:12 +0000

I don't find the behavior of the following expression documented.
Can someone either point me to the documentation, or I request
that the documentation be updated to warn about this caveat.

https://clojure.org/guides/destructuring

((fn [& {:as key-vals}] key-vals) :a 100 :b 200) ;; case 1
(let [[& {:as key-vals}] '(:a 100 :b 200)] key-vals) ;; case 2

These both evaluate to a map {:a 100 :b 200). However, the following evaluate to nil rather than an empty map.

((fn [& {:as key-vals}] key-vals) ) ;; case 3
(let [[& {:as key-vals}] ()] key-vals)  ;; case 4

The tag https://clojure.org/guides/destructuring#_keyword_arguments does not exactly say what happens in these cases; however, intuitively I'd expect that key-vals should be a map in all 4 cases. Instead it is a map in the first to cases, but is nil in cases 3 and 4. I'd expect cases 3 and 4 to each evaluate to an empty map.

Cheshire parse-string coerce keys to keywords

Wed, 06 Mar 2024 18:06:15 +0000

Just learning Clojure. I have the following json string:

(def json "{\"a\": 1, \"b\": \"val\", \"c\": {\"D/E\": [1, 2, 3]}}}")

If the key-fn param is true in the Cheshire parse-string call I got the following map:

(def parsed-json (cheshire/parse-string json true))
;; ==> {:a 1, :b "val", :c #:D{:E [1 2 3]}}
(type parsed-json)
;; => clojure.lang.PersistentArrayMap
(type (:c parsed-json))
;; => clojure.lang.PersistentArrayMap

How can I access the [1 2 3] array? I don't understand what is #:D here, and how I can access :E.

Run a task parallely to delete tags

Sun, 04 Jun 2023 23:21:53 +0000

(defn- find-story-ids-by-tag [tag-id]

(map :id (db-content-tag/read-contents-by-tag-id (config/db-spec) tag-id)))

(defn- update-story [txn publisher-id story-id tag-id]
(let [{:keys [published-json]} (db-content/find-by-id txn story-id)

    updated-tags (filter (fn [tag] (not= (:id tag) tag-id)) (:tags published-json))
    _ (db-story/update-published-json-without-timestamps txn publisher-id story-id (assoc published-json :tags updated-tags))]
(log/info {:message "[TAG-DELETION] Updated Story Tags in Published JSON"
           :publisher-id publisher-id
           :tag-id tag-id
           :story-id story-id
           :updated-tags-json updated-tags})))

(defn- delete-tag [publisher-id tag-id]
(let [associated-content-ids (find-story-ids-by-tag tag-id)]

(transaction/with-transaction
  [txn (config/db-spec)]
  (do
    (when (seq associated-content-ids)
      (do
        (doseq [story-id associated-content-ids]
          (update-story txn publisher-id story-id tag-id))
        (db-content-tag/delete-batch-by-tag txn tag-id associated-content-ids)
        (log/info {:message "[TAG-DELETION] Deleted from Content Tag"
                   :publisher-id publisher-id
                   :tag-id tag-id
                   :story-ids associated-content-ids})))
    (db-tag/delete txn publisher-id tag-id)
    (log/info {:message "[TAG-DELETION] Deleted Tag"
               :publisher-id publisher-id
               :tag-id tag-id})))))

(defn run [publisher-id tag-ids]
(comment run 123 [4 5 6])
(try

(do
  (log/info {:message "[TAG-DELETION] started"
             :publisher-id publisher-id
             :tag-ids tag-ids})
  (doseq [tag-id tag-ids] (if (db-tag/find-by-id (config/db-spec) publisher-id tag-id)
                            (delete-tag publisher-id tag-id)
                            (log/info {:message "[TAG-DELETION] Tag Not Found"
                                       :publisher-id publisher-id
                                       :tag-id tag-id})))
  (log/info {:message "[TAG-DELETION] completed"
             :publisher-id publisher-id
             :tag-ids tag-ids}))
(catch Exception e
  (log/exception e {:message "[TAG-DELETION] errored"
                    :publisher-id publisher-id
                    :tag-ids tag-ids}))))

If I have less than 100 tags this works, but say I have 100 000 tags it is very time consuming. How to modify this code which can run in parallel and takes less time? Currently the task uses seq for both deleting and updating the story

filter with multiple lists on params

Wed, 22 Mar 2023 12:44:02 +0000

Map, Filter and Reduce are very common in functional programming.
Out of all languages that has those functions, only clojure has the capability to add multiple lists on map. for instance- (map + lst1 lst2) which is the most useful thing!

But why isn't it possible to do the same with Filter? for example-

(filter (fn [a1 b1] (pos? (+ a1 b1))) [1 2 3] [-2 4 0])

will result in "Wrong number of args(3) passed to clojure.core/filter".
I assume there is a reason for which it is not a common practice, but I find it hard to understand why.

Thanks!

submap? - recursively check if one map is contained in another

Thu, 09 Mar 2023 19:24:33 +0000

(submap? m1 m2) recursively checks if m1 is contained in m2

Usage:

(deftest submap
  (is (submap? {} {}))
  (is (not (submap? {:k 1} {})))
  (is (submap? {:k 1} {:k 1 :j 2}))
  (is (submap? {:k {:kk 1}} {:k {:kk 1 :j 2}}))
  (is (not (submap? {:k {:kk 1}} {:j 2}))))

This need often arises in tests, where you want to check if the map returned by function-under-test has a certain shape and while assuming an open world - i.e. you want to ignore any additional keys so that changing function-under-test doesn't break the tests:

;; BAD: doesn't assume open world
(is (= {:k :v} (function-under-test)))

;; BAD: not expressive
(is (= :v (:k (function-under-test))))

;; BAD: not expressive, need to write :k twice
(is (= {:k :v} (select-keys (function-under-test) [:k])))

;; GOOD: expressive
(is (submap? {:k :v} (function-under-test)))

Implementations already exist in many codebases (400+ hits on Github code search). Examples:

https://github.com/clojure/tools.deps/blob/ecc80420c1b734b384f7a42df91684cdbc37ddc6/src/test/clojure/clojure/tools/deps/util.clj#LL12-L25C18

https://github.com/ptaoussanis/encore/blob/96547700c03a5e81d784bcc9253980d7355f2f2b/src/taoensso/encore.cljc#L2071

Addition/Multiplication operations on loop

Sat, 10 Dec 2022 05:55:32 +0000

Hi!
It's me again. I followed up on the previous answers that have been posted on my questions to do another operation but I don't get exactly what I want.
Here's the situation:

My first table (products) looks like : (product_name price)
([1 (candies 6.5)] [2 (sweets 1.75)]
[3 (jam 2.99)] [4 (gum 1.25)])

My first table (products) looks like : (customer_name product_name quantity)
([1 (Sara candies 3)] [2 (Joe jam 3)]
[3 (Sara gum 1)])

What I'm trying to do is if i type for example Sara, I'll get the sum of the sales made by Sara, which means: (36.5 + 11.25) = $20.75 (in this case)

I'm fine for the input part (I get the name of the customer as an input from the terminal)
However, my code:

(defn sales_prices_with_cond [name_cus] (map
 (fn [y z]
   (if (= (str name_cus) (str (nth (first z) 1)))
   list (* (Double. (nth (second y) 1)) (Integer/parseInt (nth (second z) 2))))
   )
products 
sales))
(println (reduce + sales_prices_with_cond "Sara"))

Gives me the sum of ALL the sales*quantities. It's like the condition is skipped or maybe not well written ...
I also tried with (some) and got the same result...

Please Help :') .

Map destructuring works on singleton lists

Thu, 10 Nov 2022 08:15:43 +0000

(let [{x :x} '({:x "foo"})] x)
;; => "foo"

Cast to Map$Entry Exception When Trying to (Into {}) After Sequence Operations

Sun, 08 May 2022 09:17:12 +0000

Is it intended behavior to get this exception :

class clojure.lang.Keyword cannot be cast to class java.util.Map$Entry

on this piece of code :

(def a [["Active" :Transit-RLC "Active"]])

(->> a
     (transduce
       (comp 
             (map drop-last)
             (map reverse))
       conj [])
     (into {}))

changing the transducer to (map (-> [(second %) (first %)]) solves the issue.
Thanks

Common patterns for optional fields interact poorly with spec

Tue, 15 Feb 2022 21:48:34 +0000

I do lots of work with spec, and a frequent problem that I run into is in constructing a spec'ed object that is a map with optional fields.

A common pattern looks like this:

(assoc {::required-field :value}
       ::optional-field (when some-condition
                          :optional-value))

There is a significant issue with this pattern however: if ::optional-field is on a spec/keys :opt field that is non-nilable, then every object that excludes the optional field will be invalid according to that spec because it will have a nil value instead of omitting the key.

The alternative to this approach is to use something like cond-> as seen below:

(cond-> {::required-field :value}
  some-condition (assoc ::optional-field :optional-value))

This pattern is far from the only usage of cond->, but it appears fairly frequently. I see this pattern as detrimental because it requires the condition to be surfaced all the way at the top here, and there cannot be a way for some function used to produce :optional-value to abort via nil punning while still producing a valid value without requiring additional flow control and local bindings.

A more flexible solution to this problem uses if-some, but this solution is verbose and becomes unwieldy when multiple optional fields need to be included at once, as can be seen below.

(let [m {::required-field :value}
      m (if-some [v (produces-optional-value)]
          (assoc m ::optional-field v)
          m)
      m (if-some [v (produces-other-value)]
          (assoc m ::other-field v)
          m)]
  m)

One solution to this problem is the function assoc-some, which is like assoc, but when given a nil value it elides the key. This function is provided in medley, and sees some use.

The above unwieldy example would, with assoc-some, look like this:

(assoc-some {::required-field :value}
            ::optional-field (produces-optional-value)
            ::other-field (produces-other-value))

This is likely not the only solution to this problem, but I think it is a problem worth considering.

An example of another instance where the named solution wouldn't work, but that appears to follow more or less the same pattern is this code in farolero, which would be solved by a parallel function (that I have not yet found an implementation of in the wild besides my own) update-some which will update a key with a new value, and if that value is nil will remove the key.

Can js/BigInt be used as a map key in ClojureScript?

Fri, 13 Aug 2021 02:19:31 +0000

js/BigInt supports equality testing (= (js/BigInt 4) (js/BigInt 4)) is true so I expected to be able to use it as a key in a map (I don't know what hash function is used for the lookup)
However I see some unexpected behaviour:

(get {0 0 1 1 2 2 3 3 (js/BigInt 4) 4 5 5 7 7 8 8} (js/BigInt 4))

returns 4 as expected, but

(get {0 0 1 1 2 2 3 3 (js/BigInt 4) 4 5 5 7 7 8 8 9 9} (js/BigInt 4))

returns nil

This was tested using Firefox or Safari as the javascript engine.

Is this a bug or was I just lucky that it worked for maps with less than 10 entries?

Thanks

No metadata on clojure 1.9 map literals

Wed, 23 Jun 2021 07:40:15 +0000

Maps written using the new #:default.namespace{,,,} syntax don't get file positions attached as metadata.

Given this setup code

(require '[clojure.tools.reader :as reader])
(require '[clojure.tools.reader.reader-types :as reader-types])

(defn sample [s]
  (with-open [r (java.io.StringReader. s)]
    (meta (reader/read (reader-types/indexing-push-back-reader (reader-types/push-back-reader r) 1)))))

this edn literal fails to get parsed with positional metadata

(sample "#:ns{ :key :val }") ; => nil

unlike those two, which get their positional metadata as expected

(sample "{ :key :val }")     ; => {:line 1, :column 1, :end-line 1, :end-column 14}
(sample "{ :ns/key val }")   ; => {:line 1, :column 1, :end-line 1, :end-column 16}

How do I update map elements conditionally?

Mon, 20 Jul 2020 05:59:14 +0000

I have some code that's massaging a data structure from one format to another (SVG hiccup attributes to CLJFX attributes). The format are quite similar but when an attribute is present I need to occasionally futz with it a bit. For instance, maybe I need to (read-string ..) a string into a number, or update a keyword so it's spelled a bit different, etc.

Right now my code is of the form

(-> svg-attributes
  (update :stroke #(case %
                     nil :black
                     "none" :black
                     (if (= \# %)
                       %
                       (keyword %))))
  (update :fill #(case %
                   nil "transparent"
                   "none" "transparent"
                   (if (= \# %)
                     %
                     (keyword %))))
  (update :points #(case %
                     nil []
                     [] []
                     (map read-string (-> %
                                          (clojure.string/split #"[ ,]")))))
  (update :stroke-width #(case %
                           nil 1.0
                           %))
  (update :stroke-dasharray #(case %
                               nil []
                               (map read-string (-> %
                                                    (clojure.string/split #"[ ,]")))))
  (clojure.set/rename-keys {:stroke-dasharray :stroke-dash-array})
  (update :font-size #(case %
                        nil 10
                        "none" 10
                        %))))

The issue is that I keep having to catch the nil case and jamming in some defaults... which works most of the time.. but I'd rather skip updating when there is nothing to update.

I saw this question, which is quite similar: https://ask.clojure.org/index.php/8387/how-to-avoid-nil-values-in-maps

Is the idiomatic solution to do a (cond-> with a (some? (:somekeyword %)) on each line ? I feel like I'm not reaching for the right tool here! Maybe someone can give me a better suggestion :)

Is there a better way to create random groups out of multiple collections of different sizes?

Thu, 28 May 2020 19:49:37 +0000

I am writing a slack bot that can take a group of people and the office that they work for and then break them into n random groups, making sure to mix the two offices together.

I have a few functions that do this just fine, but I am wondering if there is a more "Clojure" way to do this? I am still trying to break out of my object-oriented habits so any suggestions are very welcome.

My thought for this approach was to treat this like a deck of cards and deal the people out into each resulting group until I run out of people in an office, then move to the next one until I run out of offices then return my result.

(defn split 
  "split by office then shuffle
   result is sorted by size"
  [coll]
  (->> (sort-by :office coll)
       (partition-by :office)
       (sort-by count)
       (map shuffle)))

(defn conj-in 
  "inserts an item into a collection's child"
  [coll idx itm]
    (assoc coll idx (conj (nth coll idx) itm)))

(defn split-into-groups
  [coll]
  (let [sorted (split coll)]
    (loop [pool    (rest sorted)
           hand    (first sorted)
           result  (into [] (take @ngroups (repeat [])))
           idx     0]
      
      (if (not-empty hand)
        (let [next (first hand)]
          (recur pool
                 (rest hand)
                 (conj-in result idx next)
                 (mod (inc idx) @ngroups)))
        
        (if (not-empty pool)
          (recur (rest pool)
                 (first pool)
                 result
                 idx)
          
          result)))))

is there a version of pr-str that emit full versions of qualified keywords in maps instead of short forms?

Fri, 10 Apr 2020 07:54:25 +0000

Something like {:foo/bar 1} instead of #:foo{:bar 1}
I need to debug some edn and it's impossible to jump to the desired keywords if they're in the short forms.

What is keywords for clj used for? What do they actually mean and do?

Fri, 27 Mar 2020 09:04:53 +0000

I learned about keywords a while back, but Im not sure what they are actually used for outside of for keys in maps. Are there other uses for keywords outside of maps?

Also what do they actually mean and do?