Expressions

Let's look a bit more closely at expressions.

In Lisp, + is a function, and an expression like (+ 2 3) is a function call. When Lisp evaluates a function call it performs the following two steps:

• It evaluates the arguments, left to right. In this case the arguments are just the numbers 2 and 3, and these evaluate to themselves.
• The values of the arguments are passed to the procedure, in this case +, which returns 5.

Let's look at a more complicated example: (/ (- 7 1) (- 4 2)). The sequence is:

• Evaluate (- 7 1) giving 6
• Evaluate (- 4 2) giving 2
• Evaluate (/ 6 2) giving 3
• Return 3

Preventing evaluation: quote

Nearly all operators behave like this, but there are some special operators, called special forms, that behave differently. One is quote. Try

`> (quote (+ 2 3))(+ 2 3)`

The quote operator doesn't evaluate its argument - it simply returns it. It lets you tell Lisp to treat an expression as data, rather than something to be evaluated.

For convenience you can abbreviate (quote something) to 'something. Try:

```> '(+ 2 3)
(+ 2 3)```

The ' operator allows you to protect an expression from evaluation. Now try quoting one of the arguments, as in:

```> (list '(* 1 2) (* 3 4))
((* 1 2) 12)```

The quote stopped the first argument from being evaluated.

Evaluating expressions: eval

The opposite of quote is eval; it evaluates the expression passed as its argument. So:

```> (eval '(+ 2 3))
5```

Things that evaluate to themselves

A number evaluates to itself, so you don't need to quote it:

```> 12
12```

Likewise nil, or the empty list, both evaluate to nil:

```> ()
nil```

Exercise

1. Predict what the following Lisp expressions will give, and then check your answers by evaluating them:

`(list (list 2 3) (list 4 5))(list '(list 2 3) '(list 4 5))'(list (list 2 3) (list 4 5))`

Previous: Lists

Next: Defining functions