How do I conditionally update keys and values in a Clojure map based on the key name?

Question

I have a map and the keys are strings. If the key contains the word "kg" I want to multiply the value by 2.2 and then replace "kg" with "lb" in the key. I can't figure out how to iterate over the map in a way that I can conditionally update it.

Example map:

{"id" ("7215" "74777" "7219"),
 "weight-kg" ("150" "220" "530"),
 "time-seconds" ("1900" "2" "770")}

Desired output

{"id" ("7215" "74777" "7219"),
 "weight-lb" ("330" "485" "1168"),
 "time-seconds" ("1900" "2" "770")}

I've tried update, for map and reduce-kv. Project requirement is to not use the string library, which is why there is re-find. These are only attempts at changing the values. Since I can't change the values, I haven't attempted changing the keys.

(defn kg->lb [m k]
    (if (re-find #"kg" k)
      (map #(update m % * 2.2))))

(defn kg2->lb2 [m]
    (reduce-kv #(if (re-find #"kg" %)
                  (update % * 2.2)) {} m)

(map #(if (re-find #"kg" %)
        (update % * 2.2)) m)

(for [k (keys m)]
    (if (re-find #"kg" k)
      (update m k #(* % 2.2))))

Answer 1

I would do it a bit differently. First, I'd convert the strings to integers using the Java function Long/parseLong:

(ns tst.demo.core
  (:use demo.core tupelo.core tupelo.test)
  (:require
    [tupelo.core :as t]
    ))

(defn parse-vec-longs
  [v]
  (mapv #(Long/parseLong %) v))

(verify
  (is= (parse-vec-longs ["150" "220" "530"])
    [150 220 530]))

Then I would write the code to convert the kg vals to lb vals. At the end, just use dissoc to get rid of the kg data, then assoc to add in the new lb data:

(defn convert-kg-lb
  [data]
  (let-spy-pretty [kg-vals (get data "weight-kg")
                   lb-vals (mapv #(Math/round (* 2.2 %)) kg-vals)
                   result  (t/it-> data
                             (dissoc it "weight-kg")
                             (assoc it "weight-lb" lb-vals))]
    result))

(verify
  (let [data-str        {"id"           ["7215" "74777" "7219"]
                         "weight-kg"    ["150" "220" "530"]
                         "time-seconds" ["1900" "2" "770"]}
        data-parsed     (t/map-vals data-str #(parse-vec-longs %))
        expected-parsed {"id"           [7215 74777 7219]
                         "weight-kg"    [150 220 530]
                         "time-seconds" [1900 2 770]}
        expected-out    {"id"           [7215 74777 7219]
                         "weight-lb"    [330 484 1166]
                         "time-seconds" [1900 2 770]}
        result          (convert-kg-lb data-parsed)]
    (is= data-parsed expected-parsed)
    (is= (spyx-pretty result) (spyx-pretty expected-out))))

Normally, you'd also replace all the string keys with keywords as well, so "lb" => :lb.

Answer 2

Data:

(def data {"id"           ["7215" "74777" "7219"],
           "weight-kg"    ["150" "220" "530"],
           "time-seconds" ["1900" "2" "770"]})

Helper function to convert a string (kg amount) to string (lb amount):

(defn kg->lb [kg-string]
  (-> kg-string
      parse-long
      (* 2.2)
      int
      str))

The most important function is reduce-kv.

If you find "kg" in key, you will replace that with "lb" and map helper function over all values.

If you don't find "kg" in key, you will just assoc that entry without change.

(reduce-kv (fn [m k v]
             (if (re-find #"kg" k)
               (assoc m (str/replace k #"kg" "lb")
                        (map kg->lb v))
               (assoc m k v)))
           {} 
           data)

I think I passed Project requirement is to not use the string library, except for (str/replace k #"kg" "lb"), which you can replace with String/replace interop: (.replace k "kg" "lb").

EDIT: Solution with map and into:

(defn update-entry [[k v]]
  (if (re-find #"kg" k)
    [(.replace k "kg" "lb") (map kg->lb v)]
    [k v]))

(->> data
     (map update-entry)
     (into {}))

Transducer version:

(into {} (map update-entry) data)