Go to the first, previous, next, last section, table of contents.

Lists and Quoting

Scheme allows you to write lists as literals using quoting. Just as you can write a literal boolean or number in your program, you can write a literal list if you use the special form quote.

Quote is a special form, not a procedure, because it doesn't evaluate its argument in the usual way. (Its argument is really just a literal representation of a data structure, which may look like a Scheme expression, but it isn't.)

For example, the expression (quote (1 2 3)) returns a pointer to a list (1 2 3), i.e., a sequence of cdr linked pairs whose car values are (pointers to) to 1, 2, and 3.

You can use quote expressions as subexpressions of other expressions, because they just return pointer values like anything else.

For example, the expression (define foo (quote (1 2 3))) defines (and binds) a variable foo, and initializes its binding with (a pointer to) a three-element list.

We can draw the resulting situation this way:

     +---+    +---+---+      +---+---+      +---+---+
 foo | *-+--->| * | *-+----->| * | *-+----->| * | * |
     +---+    +-+-+---+      +-+-+---+      +-+-+---+
                |              |              |
               \|/            \|/            \|/
                1              2              3

quote takes exactly one argument, and returns a data structure whose printed representation is the same as what you typed in as the argument to quote. Scheme does not evaluate the argument to quote as an expression--it just gives you a pointer to a data structure.

Note that quote does not generally construct a character string--it constructs a data structure that may be a list or tree or even an array. It's a very general quoting facility, much more powerful than the double quotes around character strings, which only construct string objects.

Scheme provides a cleaner way of writing quoted expressions, using the special single-quote character '. Rather than writing out (quote some-expression), you can just precede the quoted expression with the single-quote character. For example, we can write the same definition of foo as (define foo '(1 2 3)). You don't need a closing quote, because of Scheme's parenthesized prefix syntax--it can figure out where the quoted data structure ends.

One subtlety about quote is that a quote expression doesn't create a data structure every time it's called--evaluating the same expression many times may return many pointers to the same structure.

Consider the procedure definition

(define (foo)
   '(1 2 3))

The list (1 2 3) may be created when we define the procedure foo, and each time we call it, it may return a pointer to that same list. (Exactly what happens depends on the particular implementation of Scheme, but most work this way, for efficiency reasons. Evaluating the quote expression just fetches a pointer to a data structure that was created beforehand.)

For this reason, it's an error to modify a data structure returned from a quote form. Unfortunately, many Scheme systems don't detect this error, and will let you do it. If you want a new data structure each time, you should use a procedure like list, which always creates a new data structure. (list, which we'll discuss more later, is a standard Scheme procedure that takes any number of arguments, and creates a list of those items.)

For example, if we want the procedure foo to return a new list (1 2 3) every time, we can write

(define (foo)
   (list 1 2 3))

Go to the first, previous, next, last section, table of contents.