CODEWITHSUNDEEP
schemelisp
samuelbrody1249
samuelbrody1249

Reputation: 4767

Understanding parentheticals on let

I'm having a hard time understanding the syntax of let vs some of the other statements. For example, a "normal" statement has one parentheses:

(+ 2 2)
$2 = 4

Yet the let statement has two:

(let ((x 2)) (+ x 2))
$3 = 4

Why is this so? I find it quite confusing to remember how many parentheses to put around various items.

Upvotes: 0

Views: 105

Answers (2)

Kaz
Kaz

Reputation: 58637

Firstly, note that let syntax contains two parts, both of which can have zero or more elements. It binds zero or more variables, and evaluates zero or more forms.

All such Lisp forms create a problem: if the elements are represented as a flat list, there is an ambiguity: we don't know where one list ends and the other begins!

(let <var0> <var1> ... <form0> <form1> ...)

For instance, suppose we had this:

(let (a 1) (b 2) (print a) (list b))

What is (print a): is that the variable print being bound to a? Or is it form0 to be evaluated?

Therefore, Lisp constructs like this are almost always designed in such a way that one of the two lists is a single object, or possibly both. In other words: one of these possibilities:

 (let <var0> <var1> ... (<form0> <form1> ...))

 (let (<var0> <var1> ...) (<form0> <form1> ...))

 (let (<var0> <var1> ...) <form0> <form1> ...)

Traditional Lisp has followed the third idea above in the design of let. That idea has the benefit that the pieces of the form are easily and efficiently accessed in an interpreter, compiler or any code that processes code. Given an object L representing let syntax, the variables are easily retrieved as (cadr L) and the body forms as (cddr L).

Now, within this design choice, there is still a bit of design freedom. The variables could follow a structure similar to a property list:

(let (a 1 b 2 c 3) ...)

or they could be enclosed:

(let ((a 1) (b 2) (c 3)) ...)

The second form is traditional. In the Arc dialect of Lisp designed Paul Graham, the former syntax appears.

The traditional form has more parentheses. However, it allows the initialization forms to be omitted: So that is to say if the initial value of a variable is desired to be nil, instead of writing (a nil), you can just write a:

;; These two are equivalent:
(let ((a nil) (b nil) (c)) ...) 
(let (a b c) ...)

This is a useful shorthand in the context of a traditional Lisp which uses the symbol nil for the Boolean false and for the empty list. We have compactly defined three variables that are either empty lists or false Booleans by default.

Basically, we can regard the traditional let as being primarily designed to bind a simple list of variables as in (let (a b c) ...) which default to nil. Then, this syntax is extended to support initial values, by optionally replacing a variable var with a (var init) pair, where init is an expression evaluated to specify its initial value.

In any case, thanks to macros, you can have any binding syntax you want. In more than one program I have seen a let1 macro which binds just one variable, and has no parentheses. It is used like this:

(let1 x 2 (+ x 2))  ->  4

In Common Lisp, we can define let1 very easily like this:

(defmacro let1 (var init &rest body)
  `(let ((,var ,init)) ,@body))

If we restrict let1 to have a one-form body, we can then write the expression with obsessively few parentheses;

(let1 x 2 + x 2)   ->  4

That one is:

(defmacro let1 (var init &rest form)
  `(let ((,var ,init)) (,@form)))

Upvotes: 4

Barmar
Barmar

Reputation: 782488

Remember that let allows you to bind multiple variables. Each variable binding is of the form (variable value), and you collect all the bindings into a list. So the general form looks like

(let ((var1 value1)
      (var2 value2)
      (var3 value3)
      ...)
  body)

That's why there are two parentheses around x 2 -- the inner parentheses are for that specific binding, the outer parentheses are for the list of all bindings. It's only confusing because you're only binding one variable, it becomes clearer with multiple variables.

Upvotes: 3

Related Questions