Binding

When we wish to bind a variable locally we can use let.

(let ((x 3))
  (+ x 4))

The scope of the binding of x is until the end of the let form.

Note the apparently extra pair of parens around the binding. That is to facilitate several bindings at once.

Reasons why we might like to introduce such bindings are

• to make our code more readable,
• to perform our computation in stages, or
• to compute once and use several times.

(defun roots (a b c)
  (let ((discriminant (- (* b b) (* 4 a c))))
    (values (/ (+ (- b) (sqrt discriminant)) (* 2 a))
            (/ (- (- b) (sqrt discriminant)) (* 2 a)))))

(roots 1 -3 2)

2.0 1.0

We can bind several variables.

(let ((x 3)
      (y 5))
  (* y (+ x 4)))

Note that the scope of the x binding in let does not include the y binding so we can not do this.

(let ((x 3)
      (y (+ x 2)))                        ; 
  (* y (+ x 4)))

The variable X is unbound.
  [Condition of type UNBOUND-VARIABLE]

For this kind of scope we can use let*

(let* ((x 3)
       (y (+ x 2)))
  (* y (+ x 4)))

With let* the scope of each binding includes all subsequent bindings.

Some Lisp functions return more than one value.

(floor 9 4)

We can bind multiple values using multiple-value-bind

(multiple-value-bind (quotient remainder)
    (floor 9 4)
  (format nil "The quotient is ~d and the remainder is ~d." quotient remainder))

The variables quotient and remainder are bound to the two values returned by floor.

Sometimes we want to destructure values. For example, we might have the list (3 4) and we wish to assign 3 to x and 4 to y. We can do this with destructuring-bind

(destructuring-bind (x y)
    '(3 4)
  (format nil "X is ~d and Y is ~d." x y))

Destructuring-bind is more flexible. In fact it can bind anything that can appear in a lambda list (i.e. in the argument list of a function definition). In fact, it is used for just that purpose.

(let ((y (cons (list 'alpha) '(1 2 3))))
  (destructuring-bind ((a &optional (b 'bee)) c d e)
      y
    (format t "~&Y: ~a~&" y)
    (format t "~&A: ~a, B: ~a, C: ~a, D: ~a, E: ~a.~&" a b c d e)))

As well as &optional it can also handle &key and some other more exotic terms.

There are times that we want to combine all of the above various kinds of bindings and even some others. For example, we might want to bind to slots of an object. The metabang-bind library covers all of these cases elegantly.

(ql:quickload :metabang-bind)

(use-package :metabang-bind)

Now we can use bind just as we use let*. That is to say, unlike let, we can use variables already bound in bind in subsequent bindings.

(defun roots (a b c)
  (bind ((discriminant (- (* b b) (* 4 a c)))
         (sqrt-discriminant (sqrt discriminant)))
    (values (/ (+ (- b) sqrt-discriminant) (* 2 a))
            (/ (- (- b) sqrt-discriminant) (* 2 a)))))

(roots 1 -3 2)

2.0 1.0

Bind also allows us to bind multiple values.

(bind (((:values quotient remainder) (floor 9 4)))
  (format nil "The quotient is ~d and the remainder is ~d." quotient remainder))

The quotient is 2 and the remainder is 1.

Note two things. On the one hand bind is shorter than multiple-value-bind but on the other we need to write more parens to indicate the :values