Programs often need to refer to literal data values--data that you type directly into the program. In many languages, the only literals are fairly simple values like integers and strings. In Scheme, you can use simple literals or complicated ones that represent (pointers to) data structures like nested lists. Earlier, I showed how to create list literals using quoting.
You've probably noticed that the syntax of Scheme code and the
textual representation of Scheme data are very similar. So,
for example, (min 1 2) is a combination if it's viewed as code,
but it's also the standard textual representation of a list containing
the symbol min and the integers 1 and 2.
(A symbol is a data object that's sort of like a string, but with some special properties, which will be explained in the next chapter.)
The resemblance between code and data is no accident, and it can be very convenient, as later examples will show. It can be confusing, too, however, so it's important to know when you're looking at a piece of code and when you're looking at a piece of literal data.
The first thing to understand is quoting. In Scheme, the
expression (min 1 2) is a procedure call to min
with the arguments 1 and 2.
As I explained earlier, we can quote it by wrapping it in the special
form (quote...), however, and get a literal list
(min 1 2).
For example, the definition
(define foo (quote (min 1 2)))
defines and binds foo, initializing the binding with (a pointer
to) the list (min 1 2).
We can draw this situation this way:
+---+ +---+---+ +---+---+ +---+---+
foo | *-+--->| * | *-+----->| * | *-+----->| * | * |
+---+ +-+-+---+ +-+-+---+ +-+-+---+
| | |
\|/ \|/ \|/
min 1 2
Of course, as I explained earlier, we can use ' as a euphemism
for (quote ... )
We can define very complicated literals this way, if we want to. Here's a procedure that returns a nested list of nested lists of integers and booleans and symbols:
(define (fubar)
'(((1 two #f) (#t 3 four))
((five #f 6) (seven 8 #t))
((#f 9 10)) ((11 12 #f))))
that's a pretty useless procedure, but it's very convenient to just be able to type in printed representations of nested data structures and have Scheme construct them automatically for you. In most languages you'd have to do some fairly tedious hacking to construct a list like that. As we'll see in a later chapter, Scheme also supports quasiquotation, which lets you construct mostly-literal data structures, and create customized variations on them easily; quasiquotation will be discussed in a later chapter.