Is there normal "set" function (not special form) in Scheme language?

Question

Is there normal "set" function (not special form) in Scheme language or some way to implement it?

I'd like to write code something like:

(map (lambda (var)
       (set var 0))
     '(a b c))

which could assign a value (here it is '0') to variables from list (here they are 'a', 'b' and 'c').

Answer 1

A function call just evaluates a series of instructions in an extended environment, the environment in particular is that of definition extended with its function parameters, this is prety much the case in any language...

If you do this:

(define (my-set var val)
   (set! var val))

you will bind the value of val to var, but only within the scope of the current call on my-set. The reason you cannot write such function has to do with the nature of scheme itself, var is a pointer to whatever you pass in the function, but set! will make this pointer point to something else (still within the scope of my-set). my-set could work if we had some sort of mechanism of using actual pointers, as some low lever languages allow. But scheme does not...

Note that scheme goes very well with the functional programming style as well as recursion, so if you have a need for a function as you described, you are probably "doing something wrong"... :)

You can, however, do this:

(define my-list (list 1 2 3))
(define (my-set a-list a-value)
  (set-car! my-list a-value))

> (my-set my-list 4)
> my-list
(4 2 3)

this works since a-list is a pointer to a cons-cell, set-car! will modify the contents of a cons-cell, but not affect the pointer to which.

Answer 2

No. And to see why there isn't consider something like this:

(define (mutant var val)
  (let ((x 1))
    (set var val)
    x))

Now, what should (mutant 'x 3) return? If it should return 3, then:

• set can't be a function since it needs access to the lexical environment of mutant;
• any kind of reasonable compilation of this function is not possible.

If you want set to be a function then catastrophe follows. Consider this definition:

(define (mutant-horror f)
  (let ([x 3])
    (f)
    x))

Now, you would think that this can be optimised to this:

(define (mutant-horror f)
  (f)
  3)

But it can't. Because you might call it like this:

(mutant-horror (λ () (set 'x 3)))

or, more generally, you might call it with a function which, somewhere eventually in some function called indirectly from it might end up saying (set 'x 3).

This means that no binding can ever be optimised at all, which is a disaster. It's also at least very close to meaning lexical scope is not possible: if as well as set, a function called get exists, which retrieves the binding of a symbol, then you have, essentially, dynamic scope. That in turn makes things like tail-call elimination at least difficult and probably impossible (in fact set probably does this on its own).

Reasons like this are why even very old Lisps, where things like set did exist and did superficially work, actually made special exemptions for compiled code, where set didn't work (see for instance the Lisp 1.5 programmer's manual (PDF link), appendix D. This divergence between the semantics of compiled and interpreted code is one of the things that later Lisps and Lisp-related languages such as CL and Scheme did away with.

---

If instead you want something like Common Lisp's semantics, where the equivalent thing

(defun mutant (var val)
  (let ((x 1))
    (set var val)
    x))

Would return 1 (unless x was a globally (see below) special variable, in which case it might return something else) and as a side-effect modify the value cell of whatever symbol was named by var (which might be x), then, well, Scheme has no notion of that at all, and that's a good thing on the whole.

Note that a modified version of the function will also work for locally special variables:

(defun mutant/local-special (a b)
  (let ((x 1))
    (declare (special x))
    (set a b)
    x))

But in this case you always know there's a special binding happening because you can always see the declaration.

Answer 3

When you write something like

(map (lambda (var)
       (set var 0))
     '(a b c))

my first thought was that you try to accumulate unordered sets of the form ( (a 0) (b 0) (c 0) ).

You cannot implement your own setter for any of the internal data structures that are provided by the language as this would mean to write a scheme function to modify some data structures that is implemented in C. For the data structures implemented in C you need to provide setters written in C -- supposing the lower language is C.

If you want to implement your own setter you either

-- check how the data structure in implmented, and if it's implemented in scheme you will undestand how to modify it

-- define your own data structure using already existing data structures and define setters for it.

A setter that mutates the data structure contains a ! at the end of its name, such as set!, append!, etc.