clojure: what's the equivalent of scheme's `set!`

Question

I'm trying to to the exercises of Structure and interpretation of computer programs in clojure. However, in multiple places it uses scheme's set! which changes the value of a variable inside a closure. eg

(define (stash x)
  ;; return a procedure which returns a value, which
  ;; you can change by providing an argument
  (lambda (nv-maybe)
    (if (null? nv-maybe)
        x
        (begin
          (set! x (car nv-maybe))
          x))))

I tried clojure's set! function, but it seems to work in a different way. What's the equivalent (or, closest alternative) of scheme's set! in clojure?

Can you clarify your question with an example of what you want? — Alan Thompson, Apr 15 '19 at 17:32
i want to rebind the parameter of the function to a new value. however, I get an error that it's immutable — blue_note, Apr 15 '19 at 17:42
I meant, please edit your question to add a code example of how you wished it would work, or how it works in Scheme. — Alan Thompson, Apr 15 '19 at 17:46
It sounds like the value should be in an `atom`, then you'd `reset!` the atom to change the value. We'd need more context though to be able to give a decent answer though. It would be best to avoid mutation altogether though if possible. — Carcigenicate, Apr 15 '19 at 17:54
@blue_note Again though, unless you *really* need mutation due to a callback or something, it's best to avoid it using `reduce` or `loop` or something. — Carcigenicate, Apr 15 '19 at 18:14
Two questions that are closely related but not duplicates: [How to increment by a number in Clojure?](https://stackoverflow.com/q/15647238/625403), [Keeping State in a Purely Functional Language](https://stackoverflow.com/q/6071151/625403) — amalloy, Apr 15 '19 at 23:01
@Carcigenicate I would be shocked if someone asking this question knew enough to be sure they can use `volatile` safely. I would very much prefer to recommend safe alternatives, and if someone knowledgeable does the profiling necessary to discover that atom-swapping is the bottleneck in their program, they'll be able to find `volatile` at that time. — amalloy, Apr 15 '19 at 23:04
@AlanThompson I have edited the question so that the procedure now does something useful (in Scheme). I don't know if I have enough karma for that edit to show up without being approved (I can see it, but I don't know if others can). — , Apr 16 '19 at 13:50

score 3 · Accepted Answer · answered Apr 16 '19 at 15:06

This exercise strikes me as a more than a bit contrived (OK, highly contrived). Here is how I would do it in Clojure (if I were forced to):

(ns tst.demo.core
  (:use demo.core tupelo.core tupelo.test) )

(defn new-stash
  "Saves an initial value and returns a function `stash` that can retrieve the 
   value via `(stash)`. Value can be mutated via `(stash <new-val>)` "
  [some-val]
  (let [local-state (atom some-val)]
    (fn
      ([] @local-state)
      ([new-val] (reset! local-state new-val)))))

(dotest
  (let [stash (new-stash 5)]
    ; stash saves the value 5
    (is= 5 (stash))
    (is= 5 (stash))

    ; mutate value in stash to 7
    (is= 7 (stash 7))
    (is= 7 (stash)) ; stash now contains 7
    (is= 7 (stash))))

Of course, the above is highly non-ideomatic Clojure code. Normally, you would just use an atom directly and avoid all of the closure junk:

(def stash (atom :uninitialized)) ; could use `nil`

(dotest
  (reset! stash 5) ; save the initial value
  ; stash saves the value 5
  (is= 5 @stash)
  (is= 5 @stash)

  ; mutate value in stash to 7
  (is= 7 (reset! stash 7))
  (is= 7 @stash) ; stash not contains 7
  (is= 7 @stash))

You could achieve the same result in other ways (by using a var, for example), but an atom is the simplest way of handling mutable state.

it is contrived. the book is essentially trying to emulate an assembly-like language in lisp. — blue_note, Apr 16 '19 at 15:10
The "closure junk" is a way to encapsulate the internal mutable state, I don't see anything wrong with that. — coredump, Apr 16 '19 at 15:15

amalloy · Answer 2 · 2019-04-17T05:45:36.073

Note: This answer is obsolete because the OP has edited the question to include the "why" that I asked for. I'm leaving it in place for context, but Alan Thompson's answer is much better for the current version of the question.

It depends on what you are mutating and why. In some Scheme styles, mutation is commonplace, and so you might ask "how do I mutate a thing in Clojure" because your Scheme algorithm involves mutation. A better question to ask is, "what is the right algorithm to solve this problem in Clojure". Asking very broad questions about very narrow code snippets will not be productive.

For example, your code snippet is actually not useful at all, because even in Scheme it is analogous to:

(define (f x)
  (lambda (newvalue) '()))

That is, the mutation of x is immaterial in your function, because it is impossible to ever read x! So, telling you the Clojure equivalent of this is not very interesting: it is simply

(defn f [x]
  (fn [newvalue] nil))

but of course this doesn't answer your real question. So the point is to back up: what is your real question? Why are you mutating this thing? Then responders can suggest the kind of mutation that bets fits your scenario, or (probably) an alternate approach that needs no mutation after all.

clojure: what's the equivalent of scheme's `set!`

2 Answers2