Differences between Common Lisp and Scheme lexical closures

Question

In Common Lisp I can evaluate the following snippet of code (in SBCL) without being signalled any syntax error:

(let ((x 0))
   (defun my-incf (y)
     (setf x (+ x y)))
   (defun my-decf (y)
     (setf x (- x y))))
MY-DECF

CL-USER> (my-incf 1)
1
CL-USER> (my-incf 1)
2
CL-USER> (my-decf 1)
1
CL-USER> (my-decf 1)
0

When I try to evaluate a corresponding Scheme snippet of code (in DrRacket):

(let ((x 0))
  (define (my-incf y)
    (set! x (+ x y)))
  (define (my-decf y)
    (set! x (- x y))))

it signals a syntax error.

begin (possibly implicit): no expression after a sequence of internal definitions in: (begin (define (my-incf y) (set! x (+ x y))) (define (my-decf y) (set! x (- x y))))

Does anybody know the reason why this cannot be done in Scheme?

You would need to look at the syntax definition of LET in DrRacket. The Common Lisp example is valid, but I would not use it in my code. — Rainer Joswig, Jun 27 '13 at 00:05
I would use CLOS instead. Using above makes debugging harder and it prevents the DEFUN form being recognized as a function definition by the compiler. Inside LET the DEFUN is no longer a top-level form. — Rainer Joswig, Jun 27 '13 at 10:02
@Rainer Joswig Could you explain with more detail how you would use CLOS to implement the code above? — Paulo Tomé, Jun 27 '13 at 10:40
isn't that obvious? X is a slot in a CLOS instance. The functions then are methods. — Rainer Joswig, Jun 27 '13 at 11:23
Incidentally, concerning the similarity of what you're doing to what you could do with CLOS, Scheme was originally invented as a language in which to explore object-oriented ideas--presumably using techniques analogous to those described below. — Mars, Jun 28 '13 at 07:02
I wouldn't necessarily use OOP to solve a simple problem of a module with a global variable. The problem of the functions not being toplevel forms can be solved with `(defvar *counter* 0)` and having the functions refer to `*counter*`. The OOP approach applies if the module screams "I should really be an object that supports multiple instantiation, and all these globals should be my instance variables". If you don't anticipate the need for multiple instantiation, or any benefits from inheritance and such, stick with globals. Dynamic vars are the "Common Lispy" way to do globals. — Kaz, Jun 28 '13 at 18:51

C. K. Young · Accepted Answer · 2013-06-26T23:53:55.743

You can't define top-level bindings outside of the top-level, in Scheme. (And inside of a let is definitely outside of the top-level---what you had, instead, was internal definitions, which are not exported to the top-level.) However, using define-values, you can still do what you need to do:

(define-values (my-incf my-decf)
  (let ((x 0))
    (values (lambda (y)
              (set! x (+ x y))
              x)
            (lambda (y)
              (set! x (- x y))
              x))))

However, you can still use internal definitions, to make your code more readable:

(define-values (my-incf my-decf)
  (let ((x 0))
    (define (my-incf y)
      (set! x (+ x y))
      x)
    (define (my-decf y)
      (set! x (- x y))
      x)
    (values my-incf my-decf)))

Best of both worlds. :-) In this case, the values sends the internal my-incf and my-decf definitions to the outer define-values, which is where the real top-level definition happens.

As a teacher that I had said to me once: "Scheme is a modern Lisp". — Paulo Tomé, Jun 28 '13 at 08:03

uselpa · Answer 2 · 2013-06-27T09:42:16.830

Chris' solution is what I would use in this case, but here's another one in the spirit of "Let over Lambda" which can come in handy if you increase the number of operations on x:

(define inc-dec
  (let ((x 0))
    (lambda (msg y)
      (case msg
        ((incf) (set! x (+ x y)))
        ((decf) (set! x (- x y)))
        (else (error "wot?")))
      x)))


(inc-dec 'incf 1)
(inc-dec 'incf 1)
(inc-dec 'decf 1)
(inc-dec 'decf 1)

score 0 · Answer 3 · answered Jun 28 '13 at 07:05

0

Less elegant, but very simple: Define top-level variables, then set! or setf them to lambdas from inside the let, depending on whether it's Scheme or CL.

answered Jun 28 '13 at 07:05

Mars

8,689
2
42
70

Differences between Common Lisp and Scheme lexical closures

3 Answers3