6 Macros

What's in This Set of Notes ?

Quote
Quasiquote
Macros
Macros in MIT Scheme
Simple Increment Macro
Iff ... then ... else ... endif Macro

6.1 Quote

Semantics:

(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)

Numerical constants, string constants, character constants, and boolean constants evaluate "to themselves"; they need not be quoted.

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

6.2 Quasiquote

(quasiquote <template>)

Semantics:

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 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 must 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 - an append operation

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

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

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

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)

6.3 Macros

Give us syntactic abstraction
Provide a way to introduce new syntactic forms with new evaluation rules to Scheme and hide how they are implemented
Programmer defined special forms
Simplify and regularize repeated patterns in a program
Perform transformations that help make programs more efficient
Possible macros

(WHILE (> x 10)
        (display x)
        (display " ")
        (set! x (- x 1))
ENDWHILE)

(BLOCK a-block-name
        (if (= x 10)
            (return 10)
            (display "hello"))
ENDBLOCK)

(FOR (i=0) (i < 10) (+ i 1)
(display i)
ENDFOR)

6.4 Macros in MIT Scheme

The interpreter interprets a language called "Scode".
The syntaxer (invoked with the procedure SYNTAX) translates list structure representing Scheme expressions to Scode.
The syntaxer is guided in this process by a structure called a "syntax table", which defines the transformations between various special forms and Scode.
A list whose first element is not a keyword defined in the syntax table is assumed to be a procedure application, and is translated accordingly.
Individual symbols are assumed to represent variable references.

The basic operations on syntax tables are:

If no PARENT-SYNTAX-TABLE argument is given, then the value of MAKE-SYNTAX-TABLE is a new, empty syntax table. The usual argument to this procedure is the variable SYSTEM-GLOBAL-SYNTAX-TABLE, which contains all of the standard syntactic keywords: LAMBDA, IF, COND, BEGIN, etc.

The expander must be a procedure taking S-expressions as input and producing Scode. For convenience there is a macro called MACRO
Similar to LAMBDA which wraps the body of the expander in the appropriate code to translate into Scode. For example,

adds a new keyword (FOO) to <some syntax table> with the obvious meaning.

Note that the expression producing the expander is evaluated in the same environment where the whole expression is evaluated, since SYNTAX-TABLE-DEFINE is not a special form keyword.

The recommended way of extending syntax tables is to have a bunch of SYNTAX-TABLE-DEFINE expressions in a file, and this file can be loaded into any appropriate environment.

6.5 Simple Increment Macro

(define (my-incr-helper form)
(list 'set! form (list '+ 1 form)))

(syntax-table-define system-global-syntax-table 'my-incr
(macro (arg) (my-incr-helper arg)))

(my-incr i) => results in i being set to 2

6.6 Iff ... then ... else ... endif Macro

Helper Procedures

(define (objects-after anObject aList)
         (if (null? aList)
              '()
              (if (equal? (car aList) anObject)
                   (cdr aList)
                   (objects-after anObject (cdr aList)))))
(define (objects-before anObject aList)
         (if (null? aList)
              '()
              (if (equal? (car aList) anObject)
                   '()
                   (cons (car aList)
                            (objects-before anObject (cdr aList))))))

(define (iff-helper args)
    ; it is useful to include the followin line if you want to see what your helper function is processing
     ;(display args)
     (let ((predicate (car args))
                  (true-part (between 'then 'else args))
                  (false-part (between 'else 'endif args)))
        `(if ,predicate ,@true-part ,@false-part)))

Macro Definition

Macro Testing

(iff-helper iff-test)
=> (if (< i 10) (display "x < 10") (display "x >= 10"))

(eval (iff-helper iff-test) (the-environment))
=> x < 10

(iff (< i 10) then (display "x < 10") else (display "x >= 10") endif)
=> x < 10