OK, thanks for the tip about atoms. I hadn't dug into the var/atom/ref/agent docs. I should have before commenting.

What I was looking for can be done with atoms, and is made more like traditional lisp mutation by defining a "st!" (or maybe "zet!" is a better name).

    (defn st! [atm v]
      (swap! atm (fn [_] v)))

Now making ordinary lisp clojures is reasonable:

    (def fns
      (let [c (atom 0)]
        {:add (fn [x] (st! c (+ @c x))) 
 	:mlt (fn [x] (st! c (* @c x)))}))

    > ((get fns :add) 3)
    3
    > ((get fns :add) 3)
    6
    > ((get fns :mlt) -5)
    -30

Though I sure could do without the calls to 'atom' and @. Referencing and dereferencing is for C programmers. Maybe using swap! directly is better after all.

    (def fns
         (let [c (atom 0)]
           {:add (fn [x] (swap! c #(+ % x)))
    	    :mlt (fn [x] (swap! c #(* % x)))}))