Quoting - MIT/GNU Scheme 7.7.91
Description: MIT/GNU Scheme 7.7.91

Next: Conditionals, Previous: Assignments, Up: Special Forms

### 2.6 Quoting

This section describes the expressions that are used to modify or prevent the evaluation of objects.

— special form: quote datum

> `(quote` datum`)` evaluates to datum. Datum may be any external representation of a Scheme object (see External Representations). Use `quote` to include literal constants in Scheme code.

>               (quote a)                               =>  a
>               (quote #(a b c))                        =>  #(a b c)
>               (quote (+ 1 2))                         =>  (+ 1 2)

> `(quote` datum`)` may be abbreviated as `'`datum. The two notations are equivalent in all respects.

>               'a                                      =>  a
>               '#(a b c)                               =>  #(a b c)
>               '(+ 1 2)                                =>  (+ 1 2)
>               '(quote a)                              =>  (quote a)
>               ''a                                     =>  (quote a)

> Numeric constants, string constants, character constants, and boolean constants evaluate to themselves, so they don't need to be quoted.

>               '"abc"                                  =>  "abc"
>               "abc"                                   =>  "abc"
>               '145932                                 =>  145932
>               145932                                  =>  145932
>               '#t                                     =>  #t
>               #t                                      =>  #t
>               '#\a                                    =>  #\a
>               #\a                                     =>  #\a

— special form: quasiquote template

> “Backquote” or “quasiquote” expressions are useful for constructing a list or vector structure when most but not all of the desired structure is known in advance. If no commas appear within the template, the result of evaluating ```template is equivalent (in the sense of `equal?`) to the result of evaluating `'`template. If a comma appears within the template, however, the expression following the comma is evaluated (“unquoted”) and its result is inserted into the structure instead of the comma and the expression. If a comma appears followed immediately by an at-sign (@), then the following expression shall evaluate to a list; the opening and closing parentheses of the list are then “stripped away” and the elements of the list are inserted in place of the comma at-sign expression sequence.

>               `(list ,(+ 1 2) 4)                       =>  (list 3 4)

>               (let ((name 'a)) `(list ,name ',name))   =>  (list a 'a)

>               `(a ,(+ 1 2) ,@(map abs '(4 -5 6)) b)    =>  (a 3 4 5 6 b)

>               `((foo ,(- 10 3)) ,@(cdr '(c)) . ,(car '(cons)))
>                                                        =>  ((foo 7) . cons)

>               `#(10 5 ,(sqrt 4) ,@(map sqrt '(16 9)) 8)
>                                                        =>  #(10 5 2 4 3 8)

>               `,(+ 2 3)                                =>  5

> Quasiquote forms may be nested. Substitutions are made only for unquoted components appearing at the same nesting level as the outermost backquote. The nesting level increases by one inside each successive quasiquotation, and decreases by one inside each unquotation.

>               `(a `(b ,(+ 1 2) ,(foo ,(+ 1 3) d) e) f)
>                    =>  (a `(b ,(+ 1 2) ,(foo 4 d) e) f)

>               (let ((name1 'x)
>                     (name2 'y))
>                  `(a `(b ,,name1 ,',name2 d) e))
>                    =>  (a `(b ,x ,'y d) e)

> The notations ```template and (`quasiquote` template) are identical in all respects. `,`expression is identical to `(unquote` expression`)` and `,@`expression is identical to `(unquote-splicing` expression`)`.

>               (quasiquote (list (unquote (+ 1 2)) 4))
>                    =>  (list 3 4)

>               '(quasiquote (list (unquote (+ 1 2)) 4))
>                    =>  `(list ,(+ 1 2) 4)
>                    i.e., (quasiquote (list (unquote (+ 1 2)) 4))

> Unpredictable behavior can result if any of the symbols `quasiquote`, `unquote`, or `unquote-splicing` appear in a template in ways otherwise than as described above.