What is the difference between 1 and '1 in Lisp?

Question

I had never really thought about whether a symbol could be a number in Lisp, so I played around with it today:

> '1
1
> (+ '1 '1)
2
> (+ '1 1)
2
> (define a '1)
> (+ a 1)
2

The above code is scheme, but it seems to be roughly the same in Common Lisp and Clojure as well. Is there any difference between 1 and quoted 1?

Answer 1

Quoting prevents expressions from being evaluated until later. For example, the following is not a proper list:

(1 2 3)

This is because Lisp interprets 1 as a function, which it is not. So the list must be quoted:

'(1 2 3)

When you quote a very simple expression such as a number, Lisp effectively does not alter its behavior.

See Wikipedia: Lisp.

Answer 2

Numbers are self-evaluating objects. That's why you don't have to worry about quoting them, as you do with, say, lists.

A symbol can be made from any string. If you want the symbol whose name is the single character 1, you can say:

(intern "1")

which prints |1|, suggesting an alternate way to enter it:

'|1|

Answer 3

In Common Lisp, '1 is shorthand for (QUOTE 1). When evaluated, (QUOTE something) returns the something part, unevaluated. However, there is no difference between 1 evaluated and 1 unevaluated.

So there is a difference to the reader: '1 reads as (QUOTE 1) and 1 reads as 1. But there is no difference when evaluted.

Answer 4

In Lisp, the apostrophe prevents symbols to be evaluated. Using an apostrophe before a number is not forbidden, it is not necessary as the numbers represent themselves. However, like any other list, it automatically gets transformed to an appropriate function call. The interpreter considers these numbers coincide with their value.

Answer 5

As has been pointed out, there is no difference, as numbers evaluate to themselves. You can confirm this by using eval:

(eval 1)  ;=> 1

This is not limited to numbers, by the way. In fact, in Common Lisp, most things evaluate to themselves. It's just that it's very rare for something other than numbers, strings, symbols, and lists to be evaluated. For instance, the following works:

(eval (make-hash-table))  ;equivalent to just (make-hash-table)

Answer 6

Well, they are in fact very different. '1 is however precisely the same as (quote 1). (car ''x) evaluates to the symbol 'quote'.

1 is an S-expression, it's the external representation of a datum, a number 1. To say that 1 is a 'number-object' or an S-expression to enter that object would both be acceptable. Often it is said that 1 is the external representation for the actual number object.

(quote 1) is another S-expression, it's an S-expression for a list whose first element is the symbol 'quote' and whose second element is the number 1. This is where it's already different, syntactic keywords, unlike functions, are not considered objects in the language and they do not evaluate to them.

However, both are external representations of objects (data) which evaluate to the same datum. The number whose external representation is 1, they are however most certainly not the same objects, the same, code, the same datum the same whatever, they just evaluate to the very same thing. Numbers evaluate to themselves. To say that they are the same is to say that:

(+ 1 (* 3 3))

And

(if "Strings are true" (* 5 (- 5 3)) "Strings are not true? This must be a bug!")

Are 'the same', they aren't, they are both different programs which just happen to terminate to the same value, a lisp form is also a program, a form is a datum which is also a program, remember.

Also, I was taught a handy trick once that shows that self-evaluating data are truly not symbols when entered:

(let ((num 4))
  (symbol? num) ; ====> evaluates to #f
  (symbol? 'num) ; ====> evaluates to #t
  (symbol? '4) ; ====> evaluates to #f
  (symbol? '#\c) ; #f again, et cetera
  (symbol? (car ''x)) ; #t
  (symbol? quote) ; error, in most implementations
)

Self evaluating data truly evaluate to themselves, they are not 'predefined symbols' of some sorts.