What is ' (apostrophe) in Racket?

Question

I am a little confused about the meaning of the ' sign in racket. It appears to me that the same sign has different meanings. Look at 2 simple examples below:

list

Returns a newly allocated list containing the vs as its elements.

> (list 1 2 3 4)
'(1 2 3 4)

quote

Produces a constant value corresponding to datum (i.e., the representation of the program fragment) without its lexical information, source location, etc. Quoted pairs, vectors, and boxes are immutable.

> '(1 2 3 4)
'(1 2 3 4)

So my question is: Does the ' sign has 2 meanings (a symbol and a list) or are these the same data type and list actually returns a quoted constant value? If the second is the case why does this work:

> '(+ (- 2 13) 11)
'(+ (- 2 13) 11)

> (eval (list + (- 2 13) 11))
0

(also (eval '(+ (- 2 13) 11)) works and evaluates correctly to 0)

But this does not:

> (list + (- 2 13) 11)
'(#<procedure:+> -11 11)

> (eval '(#<procedure:+> -11 11))
. read: bad syntax `#<'

Related maybe: What is ' (apostrophe) in Lisp / Scheme?

Answer 1

You are confused by the default way of #lang racket of printing values, which differs from almost all the other interactive lisp environments. If you choose in DrRacket itself another language, for instance R5RS, you will discover that it prints:

> (list 1 2 3 4)
(1 2 3 4)

that is, the result of the operator list applied to the numbers 1 2 3 4 is to produce a list of those numbers, which is exactly the interpretation of (1 2 3 4).

So, the answer to What is ' (apostrophe) in Lisp / Scheme? is valid also for your case, and 'anything is just an abbreviation for (quote anything).

Answer 2

> is a sign of REPL - the Read-Eval-Print Loop.

First, whatever expression you've typed at the REPL prompt is read - converted to some internal abstract syntax tree representation. Then this internal representation of the typed-in expression is evaluated - i.e. its value is found. Then the result is printed.

When we type

> (list 1 2 3 4)

the typed-in expression is read as a nested structure, let's write it as

[LIST | [1 | [2 | [3 | [4 | NIL ]]]]]

according to the usual representation of lists as pairs of data and the rest of the list (here showing a pair of a and b as [a | b]).

Then the above structure is evaluated, and because its first element was LIST it causes the invocation of list with the arguments as specified, which causes a fresh list structure to be built, which can be represented as

[1 | [2 | [3 | [4 | NIL ]]]]

Then it is printed, usually as (1 2 3 4) but Racket chooses to print it as '(1 2 3 4). Incidentally, it can't be evaluated, because 1 can not be called.

Next, the quoted expression '(1 2 3 4), which is read as (quote (1 2 3 4)). It is converted into

[QUOTE | [ [1 | [2 | [3 | [4 | NIL ]]]] | NIL ]]

which, when evaluated (according to the evaluation rule for quote), returns the data it received. Which we represent as

[1 | [2 | [3 | [4 | NIL ]]]]

That's why the two are similar. Whether we build a new list containing 1, 2, 3, and 4; or we cause it to be created as part of read process, so it gets returned verbatim by quote; the result is the same.