Modo idiomatico di "aggiornamento" di una determinata chiave in una mappa di Clojure?

Question

Supponiamo di avere una mappa che sembra qualcosa di simile:

(def m {:a {:foo "bar"}}) 

Ora vorremmo aggiornare la chiave: un in m con alcuni nuovi valori:

(def vs {:baz "qux"}) 

Se questo fosse Python potremmo fare qualcosa di simile:

>>> d = {'a': {'foo': 'bar'}} 
>>> d['a'].update({'baz': 'qux'}) 
>>> d 
{'a': {'foo': 'bar', 'baz': 'qux'}} 

Il più semplice Clojure equivalente che ho trovato è stato quello di definire una funzione come questa:

(defn update-key 
    " 
    Updates a given key `k` over a map `m` with a map of values `vs`. 
    " 
    [k m vs] 
    (assoc m k (merge (k m) vs))) 

che viene poi richiamato come:

(update-key :a m vs) 
; => {:a {:foo "bar" :baz "qux"}} 

Quindi la mia domanda è: Qual è il modo più idiomatica e corretta per ottenere la stessa funzionalità delle dicts update() metodo Python forniscono?

Answer 1

Penso che tu sia alla ricerca di assoc-in:

(def m {:a {:foo "bar"}}) 

(assoc-in m [:a :foo] "qux") 
; => {:a {:foo "qux"}} 

(assoc-in m [:a :baz] "qux") 
; => {:a {:foo "bar", :baz "qux"}} 

update-in è simile, e potrebbe essere la pena di guardare troppo. Questo potrebbe in realtà essere più vicino al tuo Python esempio:

(def m {:a {:foo "bar"}}) 
(def vs {:baz "qux"}) 

(update-in m [:a] merge vs) 
; => {:a {:foo "bar", :baz "qux"}} 

---

Aggiornamento:

Anche se la chiave è un valore variabile (non una fase di compilazione costante) è comunque possibile utilizzare sia update-in e assoc-in mettendo la variabile nel vettore:

(def m {:a {:foo "bar"}}) 
(def k' :baz) 
(def v' "qux") 

(assoc-in m [:a k'] v') 
; => {:a {:foo "bar", :baz "qux"}} 

Si può anche costruire il chiavi vettore programmaticamente:

(def m {:a {:foo "bar"}}) 
(def k' :baz) 
(def v' "qux") 

(let [ks (conj [:a] k')] 
    (assoc-in m ks v')) 
; => {:a {:foo "bar", :baz "qux"}}