在定义的函数中包装Clojure Atom不会更新

Question

Not sure what is going on here, but I have this code, where the map function successfully executes in my repl without being wrapped in a defined function:

(def dogs '({:name "scout" :age 5} {:name "rux" :age 3} {:name "fenley" :age 2}))

(def ages (atom {:above-four '() :below-four '()}))

(map
    #(if (> (get-in % [:age]) 4)
         (swap! ages update-in [:above-four] merge %)
         (swap! ages update-in [:below-four] merge %)) dogs)

@ages
=> {:above-four ({:name "scout", :age 5}), :below-four ({:name "fenley", :age 2} {:name "rux", :age 3})}

Yet, when I define the map function as such:

(def ages (atom {:above-four '() :below-four '()}))

(def dogs '({:name "scout" :age 5} {:name "rux" :age 3} {:name "fenley" :age 2}))

(defn test-dogs []
    (map
    #(if (> (get-in % [:age]) 4)
         (swap! ages update-in [:above-four] merge %)
         (swap! ages update-in [:below-four] merge %)) dogs)
         @ages)

I get the following result:

=> {:above-four (), :below-four ()}

I'm very confused, because this function taken straight from the Clojure docs works just fine:

(def m1 (atom {:a "A" :b "B"}))

(defn update-m1 []
    (swap! m1 assoc :a "Aaay")
    @m1)

=> {:a "Aaay", :b "B"}

Answer 1

Because test-dogs uses map , it returns a lazy sequence . The elements of lazy sequences aren't realized until they're needed.

The problem with your set up is you're trying to use map to run a side effect (the call to swap! ; an impure action), and never actually use the result of map . Because you never request results from map , the mapping function containing swap! never runs.

By using mapv (which returns a non-lazy vector), or doseq (which is meant to carry out side effects):

(doseq [dog dogs]
  (let [k (if (> (:age dog) 4)
                :above-four
                :below-four)]

     (swap! ages update k merge dog))) 

You can force the side effects to run.

I cleaned up the code a bit. The -in versions you were using were unnecessary; as was the the call to get-in . I also got rid of the redundant calls to swap! .

Note though that at least in your example, use of atom s is entirely unnecessary. Even if you have a more complicated use case, make sure their use is justified. Mutable variables just aren't as common in languages like Clojure.