TL;DR: They are different; use
list when in doubt.
A rule of thumb: use
list whenever you want the arguments to be evaluated;
quote “distributes” over its arguments, so
'(+ 1 2) is like
(list '+ '1 '2). You’ll end up with a symbol in your list, not a function.
An in-depth look at
In Scheme and Racket,
list are entirely different things, but since both of them can be used to produce lists, confusion is common and understandable. There is an incredibly important difference between them:
list is a plain old function, while
quote (even without the special
' syntax) is a special form. That is,
list can be implemented in plain Scheme, but
quote cannot be.
list function is actually by far the simpler of the two, so let’s start there. It is a function that takes any number of arguments, and it collects the arguments into a list.
> (list 1 2 3) (1 2 3)
This above example can be confusing because the result is printed as a
quoteable s-expression, and it’s true, in this case, the two syntaxes are equivalent. But if we get slightly more complicated, you’ll see that it is different:
> (list 1 (+ 1 1) (+ 1 1 1)) (1 2 3) > '(1 (+ 1 1) (+ 1 1 1)) (1 (+ 1 1) (+ 1 1 1))
What’s going on in the
quote example? Well, we’ll discuss that in a moment, but first, take a look at
list. It’s just an ordinary function, so it follows standard Scheme evaluation semantics: it evaluates each of its arguments before they get passed to the function. This means that expressions like
(+ 1 1) will be reduced to
2 before they get collected into the list.
This behavior is also visible when supplying variables to the list function:
> (define x 42) > (list x) (42) > '(x) (x)
x gets evaluated before getting passed to
quote, things are more complicated.
list is just a function, it can be used just like any other function, including in higher-order ways. For example, it can be passed to the
map function, and it will work appropriately:
> (map list '(1 2 3) '(4 5 6)) ((1 4) (2 5) (3 6))
list, is a special part of Lisps. The
quote form is special in part because it gets a special reader abbreviation,
', but it’s also special even without that. Unlike
quote is not a function, and therefore it does not need to behave like one—it has rules of its own.
A brief discussion of Lisp source code
In Lisp, of which Scheme and Racket are derivatives, all code is actually made up of ordinary data structures. For example, consider the following expression:
(+ 1 2)
That expression is actually a list, and it has three elements:
- the number
- the number
All of these values are normal values that can be created by the programmer. It’s really easy to create the
1 value because it evaluates to itself: you just type
1. But symbols and lists are harder: by default, a symbol in the source code does a variable lookup! That is, symbols are not self-evaluating:
> 1 1 > a a: undefined cannot reference undefined identifier
As it turns out, though, symbols are basically just strings, and in fact we can convert between them:
> (string->symbol "a") a
Lists do even more than symbols, because by default, a list in the source code calls a function! Doing
(+ 1 2) looks at the first element in the list, the
+ symbol, looks up the function associated with it, and invokes it with the rest of the elements in the list.
Sometimes, though, you might want to disable this “special” behavior. You might want to just get the list or get the symbol without it being evaluated. To do this, you can use
The meaning of quotation
With all this in mind, it’s pretty obvious what
quote does: it just “turns off” the special evaluation behavior for the expression that it wraps. For example, consider
quoteing a symbol:
> (quote a) a
quoteing a list:
> (quote (a b c)) (a b c)
No matter what you give
quote, it will always, always spit it back out at you. No more, no less. That means if you give it a list, none of the subexpressions will be evaluated—do not expect them to be! If you need evaluation of any kind, use
Now, one might ask: what happens if you
quote something other than a symbol or a list? Well, the answer is... nothing! You just get it back.
> (quote 1) 1 > (quote "abcd") "abcd"
This makes sense, since
quote still just spits out exactly what you give it. This is why “literals” like numbers and strings are sometimes called “self-quoting” in Lisp parlance.
One more thing: what happens if you
quote an expression containing
quote? That is, what if you “double
> (quote (quote 3)) '3
What happened there? Well, remember that
' is actually just a direct abbreviation for
quote, so nothing special happened at all! In fact, if your Scheme has a way to disable the abbreviations when printing, it will look like this:
> (quote (quote 3)) (quote 3)
Don’t be fooled by
quote being special: just like
(quote (+ 1)), the result here is just a plain old list. In fact, we can get the first element out of the list: can you guess what it will be?
> (car (quote (quote 3))) quote
If you guessed
3, you are wrong. Remember,
quote disables all evaluation, and an expression containing a
quote symbol is still just a plain list. Play with this in the REPL until you are comfortable with it.
> (quote (quote (quote 3))) ''3 (quote (1 2 (quote 3))) (1 2 '3)
Quotation is incredibly simple, but it can come off as very complex because of how it tends to defy our understanding of the traditional evaluation model. In fact, it is confusing because of how simple it is: there are no special cases, there are no rules. It just returns exactly what you give it, precisely as stated (hence the name “quotation”).
Appendix A: Quasiquotation
So if quotation completely disables evaluation, what is it good for? Well, aside from making lists of strings, symbols, or numbers that are all known ahead of time, not much. Fortunately, the concept of quasiquotation provides a way to break out of the quotation and go back into ordinary evaluation.
The basics are super simple: instead of using
quasiquote. Normally, this works exactly like
quote in every way:
> (quasiquote 3) 3 > (quasiquote x) x > (quasiquote ((a b) (c d))) ((a b) (c d))
quasiquote special is that is recognizes a special symbol,
unquote appears in the list, then it is replaced by the arbitrary expression it contains:
> (quasiquote (1 2 (+ 1 2))) (1 2 (+ 1 2)) > (quasiquote (1 2 (unquote (+ 1 2)))) (1 2 3)
This lets you use
quasiquote to construct templates of sorts that have “holes” to be filled in with
unquote. This means it’s possible to actually include the values of variables inside of quoted lists:
> (define x 42) > (quasiquote (x is: (unquote x))) (x is: 42)
Of course, using
unquote is rather verbose, so they have abbreviations of their own, just like
` (backtick) and
, (comma). With those abbreviations, the above example is much more palatable.
> `(x is: ,x) (x is: 42)
One final point: quasiquote actually can be implemented in Racket using a rather hairy macro, and it is. It expands to usages of
cons, and of course,
Appendix B: Implementing
quote in Scheme
list is super simple because of how “rest argument” syntax works. This is all you need:
(define (list . args) args)
quote is a lot harder—in fact, it’s impossible! It would seem totally feasible, since the idea of disabling evaluation sounds a lot like macros. Yet a naïve attempt reveals the trouble:
(define fake-quote (syntax-rules () ((_ arg) arg)))
We just take
arg and spit it back out... but this doesn’t work. Why not? Well, the result of our macro will be evaluated, so all is for naught. We might be able to expand to something sort of like
quote by expanding to
(list ...) and recursively quoting the elements, like this:
(define impostor-quote (syntax-rules () ((_ (a . b)) (cons (impostor-quote a) (impostor-quote b))) ((_ (e ...)) (list (impostor-quote e) ...)) ((_ x) x)))
Unfortunately, though, without procedural macros, we can’t handle symbols without
quote. We could get closer using
syntax-case, but even then, we would only be emulating
quote’s behavior, not replicating it.
Appendix C: Racket printing conventions
When trying the examples in this answer in Racket, you may find that they do not print as one would expect. Often, they may print with a leading
', such as in this example:
> (list 1 2 3) '(1 2 3)
This is because Racket, by default, prints results as expressions when possible. That is, you should be able to type the result into the REPL and get the same value back. I personally find this behavior nice, but it can be confusing when trying to understand quotation, so if you want to turn it off, call
(print-as-expression #f), or change the printing style to “write” in the DrRacket language menu.