Variable references in lisp

Question

Another newbie (Common) LISP question:

Basically in most programming languages there's a mean for functions to receive references to variables instead of just values, that is, passing by reference instead of passing by value. Let's say, for the sake of simplicity, I want to write a LISP function that receives a variable and increases the value of the variable by one:

(defun increase-by-one (var)
  (setf var (+ var 1)))

Now obviously the problem is that this function only increases the value of the copy of the variable on the stack, not the actual original variable. I've also tried to achieve the effect by using macros without much success, although I have this feeling that using macros is the right way to go.

I hit this wall all the time in LISP and I'm sure there must be a way around it or maybe there's a completely different approach to this problem in LISP I haven't thought about? How are things like this are done in LISP?

EDIT: Multiple people has suggested using incf. I only used this example to demonstrate the problem in a simple way, I wasn't actually looking for reimplementing incf. But thanks for the suggestions anyway.

Answer 1

With lexical scope one does not have access to variables that are not in the current scope. You also cannot pass lexical variables to other functions directly. Lisp evaluates variables and passes the values bound to these variables. There is nothing like first-class references to variables.

Think functional!

(let ((a 1))
  (values (lambda (new-value)
            (setf a new-value)) 
          (lambda () a)))

above returns two functions. One can read the variable, another one can write the variable.

Let's call the first function writer and the second one reader.

(defun increase-by-one (writer reader)
   (funcall writer (1+ (funcall reader))))

So, to do what you want, the code needs a) be in the scope or b) have access to functions that are in the scope.

Also the variable could be global.

(defvar *counter* 1)

(defun increase-by-one (symbol)
  (set symbol (1+ (symbol-value symbol))))
  ; note the use of SET to set a symbol value

(increase-by-one '*counter*)

This works for global variables that are represented by a symbol. It does not work for lexical variables - these are not represented by a symbol.

There is also a macro INCF that increases a 'place' (for example a variable).

(incf a)

But a is the variable in the current scope.

(defun foo (a)
  (incf a))  ; increases the local variable a

The limit is seen here:

(defun foo (var)
  (add-one-some-how var))

(let ((a 1))
   (foo something-referencing-a))

There is no way to pass a direct reference of a to FOO.

The only way is to provide a function. We also have to rewrite FOO, so that it calls the provided function.

(defun foo (f)
  (funcall f 1))   ; calls the function with 1

(let ((a 1))
   (foo (lambda (n)
          (setf a (+ a n)))))
   ;; passes a function to foo that can set a

Answer 2

While Common Lisp supports a functional programming style, that is not its general focus (Scheme, while not purely functional, is much closer). Common Lisp supports a completely imperative style of programming very well.

If you find you need to write code like that, the usual solution is a macro:

(defmacro increase-by-one (var)
  `(setf ,var (+ ,var 1)))

This allows you to write code like:

(increase-by-one foo)

which will be expanded into:

(setf foo (+ foo 1))

before it is compiled.

Answer 3

Macros are probably what you want, because they don't evaluate their arguments, so if you pass a variable name, you get a variable name, not its value.

INCF does exactly what you want, so if you google "defmacro incf" you'll find a whole bunch of definitions for this, some of which are even close to being correct. :-)

Edit: I was suggesting INCF not as an alternative to writing your own, but because it does what you want, and is a macro so you can easily find source code for it, e.g., ABCL or CMUCL.

Answer 4

Of course, in Lisp you can make your own way make variable references, if you want to. The simplest approach is like this:

(defstruct reference getter setter)

(defmacro ref (place)
  (let ((new-value (gensym)))
    `(make-reference :getter (lambda () ,place)
                     :setter (lambda (,new-value)
                               (setf ,place ,new-value)))))

(defun dereference (reference)
  (funcall (reference-getter reference)))

(defun (setf dereference) (new-value reference)
  (funcall (reference-setter reference) new-value))

And then you can use it:

(defun increase-by-one (var-ref)
  (incf (dereference var-ref)))

(defun test-inc-by-one (n)
  (let ((m n))
    (increase-by-one (ref m))
    (values m n)))

(test-inc-by-one 10) => 11, 10

Answer 5

I think you are missing out on one of the key concepts of functional programming - you are not supposed to change the state of objects once they have been created. Changing something via a reference violates that.

Answer 6

As a beginner I came here to figure out how to do what should be a trivial procedure in any language. Most of the solutions posted above did not work properly, may have been more complicated than what was needed, or different implementations. Here is a simple solution for SBCL:

(defmacro inc-by-num (var num)
           (set var (+ (eval var) num)))

Apparently you cannot use setf b/c it restricts the scope whereas set doesn't. Also you may need to use eval before var if you get an "argument X is not a number" error.