# Quasiquoting: `quasiquote` and `‘`

> +\[missing\] in \[missing\] also documents `quasiquote`.

The `quasiquote` form is similar to `quote`:

```racket
(quasiquote datum)
```

However, for each `(unquote expr)` that appears within the `datum`, the
`expr` is evaluated to produce a value that takes the place of the
`unquote` sub-form.

Example:

```racket
> (quasiquote (1 2 (unquote (+ 1 2)) (unquote (- 5 1))))
'(1 2 3 4)                                              
```

This form can be used to write functions that build lists according to
certain patterns.

Examples:

```racket
> (define (deep n)                                           
    (cond                                                    
      [(zero? n) 0]                                          
      [else                                                  
       (quasiquote ((unquote n) (unquote (deep (- n 1)))))]))
> (deep 8)                                                   
'(8 (7 (6 (5 (4 (3 (2 (1 0))))))))                           
```

Or even to cheaply construct expressions programmatically. \(Of course,
9 times out of 10, you should be using a macro to do this \(the 10th
time being when you’re working through a textbook like
[PLAI](http://www.cs.brown.edu/~sk/Publications/Books/ProgLangs/)\).\)

Examples:

```racket
> (define (build-exp n)                                       
    (add-lets n (make-sum n)))                                
> (define (add-lets n body)                                   
    (cond                                                     
      [(zero? n) body]                                        
      [else                                                   
       (quasiquote                                            
        (let ([(unquote (n->var n)) (unquote n)])             
          (unquote (add-lets (- n 1) body))))]))              
> (define (make-sum n)                                        
    (cond                                                     
      [(= n 1) (n->var 1)]                                    
      [else                                                   
       (quasiquote (+ (unquote (n->var n))                    
                      (unquote (make-sum (- n 1)))))]))       
> (define (n->var n) (string->symbol (format "x~a" n)))       
> (build-exp 3)                                               
'(let ((x3 3)) (let ((x2 2)) (let ((x1 1)) (+ x3 (+ x2 x1)))))
```

The `unquote-splicing` form is similar to `unquote`, but its `expr` must
produce a list, and the `unquote-splicing` form must appear in a context
that produces either a list or a vector. As the name suggests, the
resulting list is spliced into the context of its use.

Example:

```racket
> (quasiquote (1 2 (unquote-splicing (list (+ 1 2) (- 5 1))) 5))
'(1 2 3 4 5)                                                    
```

Using splicing we can revise the construction of our example expressions
above to have just a single `let` expression and a single `+`
expression.

Examples:

```racket
> (define (build-exp n)                                          
    (add-lets                                                    
     n                                                           
     (quasiquote (+ (unquote-splicing                            
                     (build-list                                 
                      n                                          
                      (λ (x) (n->var (+ x 1)))))))))             
> (define (add-lets n body)                                      
    (quasiquote                                                  
     (let (unquote                                               
           (build-list                                           
            n                                                    
            (λ (n)                                               
              (quasiquote                                        
               [(unquote (n->var (+ n 1))) (unquote (+ n 1))]))))
       (unquote body))))                                         
> (define (n->var n) (string->symbol (format "x~a" n)))          
> (build-exp 3)                                                  
'(let ((x1 1) (x2 2) (x3 3)) (+ x1 x2 x3))                       
```

If a `quasiquote` form appears within an enclosing `quasiquote` form,
then the inner `quasiquote` effectively cancels one layer of `unquote`
and `unquote-splicing` forms, so that a second `unquote` or
`unquote-splicing` is needed.

Examples:

```racket
> (quasiquote (1 2 (quasiquote (unquote (+ 1 2)))))                            
'(1 2 (quasiquote (unquote (+ 1 2))))                                          
> (quasiquote (1 2 (quasiquote (unquote (unquote (+ 1 2))))))                  
'(1 2 (quasiquote (unquote 3)))                                                
>                                                                              
(quasiquote (1 2 (quasiquote ((unquote (+ 1 2)) (unquote (unquote (- 5 1)))))))
'(1 2 (quasiquote ((unquote (+ 1 2)) (unquote 4))))                            
```

The evaluations above will not actually print as shown. Instead, the
shorthand form of `quasiquote` and `unquote` will be used: ` \(i.e., a
backquote\) and `,` \(i.e., a comma\). The same shorthands can be used
in expressions:

Example:

```racket
> `(1 2 `(,(+ 1 2) ,,(- 5 1)))
'(1 2 `(,(+ 1 2) ,4))         
```

The shorthand form of `unquote-splicing` is `,@`:

Example:

```racket
> `(1 2 ,@(list (+ 1 2) (- 5 1)))
'(1 2 3 4)                       
```