Simple Clojure clarification re: hashes / values - hash

Question

I'm just getting started with Clojure, trying to wrap my brain around functional/immutable programming.
My simple problem is this - I have a map with two values, which I want to transfer from one, to another (inside the same map). Can this be done with a simple function? Or do I have to get into refs and atoms?
e.g.
(def bucket {:volume 100 :rate 10 :poured 0})
How do I move volume to poured at rate?
(defn pour
[bucket]
?
)
; -> {:volume 90 :rate 10 :poured 10}

Answer 1

It's a bit of both. The bucket is a value and a function will take that value and produce a new value that is based on the original (and shared unchanged values):
user> (def bucket {:volume 100 :rate 10 :poured 0})
#'user/bucket
user> (assoc bucket
:volume (- (:volume bucket) (:rate bucket))
:poured (+ (:poured bucket) (:rate bucket)))
{:rate 10, :volume 90, :poured 10}
it leaves the original bucket in the var named bucket
user> bucket
{:rate 10, :volume 100, :poured 0}
so we can define a function on bucket values:
user> (defn pour [bucket]
(assoc bucket
:volume (- (:volume bucket) (:rate bucket))
:poured (+ (:poured bucket) (:rate bucket))))
#'user/pour
user> (pour bucket)
{:rate 10, :volume 90, :poured 10}
user> bucket
{:rate 10, :volume 100, :poured 0}
This will be very useful when we want to express the idea of a bucket "identity". An identity carries values from state to state in a very useful way. I'll use an atom because I want synchronous updates to a single identiy/thing at a time.
user> (def bucket (atom {:volume 100 :rate 10 :poured 0}))
#'user/bucket
user> (swap! bucket pour)
{:rate 10, :volume 90, :poured 10}
user> (swap! bucket pour)
{:rate 10, :volume 80, :poured 20}
user> (swap! bucket pour)
{:rate 10, :volume 70, :poured 30}
and now our bucket is changing over time, and these changes are viable to everyone. It's worth noting that the function that produces the new values is totally independent of the fact that it's being used to change an atom and can be reused elsewhere. Some Clojurians refer to this as "simple"
Often you will want to compute values like "what is the result of pouring the bucket three times, which is nicely expressed by nesting each call to pour inside the next like so:
user> (pour (pour (pour bucket)))
{:rate 10, :volume 70, :poured 30}
This pattern is so common there is a two character macro to express it: ->
user> (-> bucket pour pour pour)
{:rate 10, :volume 70, :poured 30}
In practice I see clojure compose function via nesting and threadding much more often than through the mutable state sytems (atoms, refs, agents, vars)