Question

Ok, this is a fairly basic question: I am following the SICP videos, and I am a bit confused about the differences between define, let and set!.

1) According to Sussman in the video, define is allowed to attach a value to avariable only once (except when in the REPL), in particular two defines in line are not allowed. Yet Guile happily runs this code

(define a 1)
(define a 2)
(write a)

and outputs 2, as expected. Things are a little bit more complicated because if I try to do this (EDIT: after the above definitions)

(define a (1+ a))

I get an error, while

(set! a (1+ a))

is allowed. Still I don’t think that this the only difference between set! and define: what is that I am missing?

2) The difference between define and let puzzles me even more. I know in theory let is used to bind variables in local scope. Still, it seems to me that this works the same with define, for instance I can replace

(define (f x)
    (let ((a 1))
        (+ a x)))

with

(define (g x)
    (define a 1)
    (+ a x))

and f and g work the same: in particular the variable a is unbound outside g as well.

The only way I can see this useful is that let may have a shorter scope that the whole function definition. Still it seems to me that one can always add an anonymous function to create the necessary scope, and invoke it right away, much like one does in javascript. So, what is the real advantage of let?

Answer 1

Do you mean (+ 1 a) instead of (1+ a) ? The latter is not syntactically valid.

Scope of variables defined by let are bound to the latter, thus

(define (f x)
  (let ((a 1))
    (+ a x)))

is syntactically possible, while

(define (f x)
  (let ((a 1)))
  (+ a x))

is not.

All variables have to be defined in the beginning of the function, thus the following code is possible:

(define (g x)
  (define a 1)
  (+ a x))

while this code will generate an error:

(define (g x)
  (define a 1)
  (display (+ a x))
  (define b 2)
  (+ a x))

because the first expression after the definition implies that there are no other definitions.

set! doesn’t define the variable, rather it is used to assign the variable a new value. Therefore these definitions are meaningless:

(define (f x)
  (set! ((a 1))
    (+ a x)))

(define (g x)
  (set! a 1)
  (+ a x))

Valid use for set! is as follows:

(define x 12)
> (set! x (add1 x))
> x
13

Though it’s discouraged, as Scheme is a functional language.