Side effects

[Andre van Tonder <andre@xxxxxxxxxxxxxxxxx>]

The SRFI does not currently specify how side effects during expansion are 
treated.  This was not relevant for syntax-rules, but does make a difference
in a procedural macro system.

I am particularly interested in cases where a common strategy may involve 
repeating the same expansion step, or only partially expanding an expression,
typically to determine if it is a definition.

In the following example:

  (define-syntax foo
    (let ((count 0))
      (lambda (s)
        (set! count (+ 1 count))
        count)))

  (define-syntax bar
    (let ((count 0))
     (lambda (s)
      (set! count (+ count 1))
      (syntax-case s ()
       ((_ x) (with-syntax ((count count))
                (syntax (list count (foo) x)))))))

  (let ()
    (define x (foo))
    (bar x))

the result could be any of:

 - (1 1 2)

   If the first non-definition (bar x) in the let is expanded atomically
   as soon as it is encountered.

 - (1 2 1)

   If the first non-definition (bar x) is expanded only far enough to
   determine if it is a definition before expanding the RHS of the
   define.

 - (2 2 1)

   If we do as in the previous case, but do not save the partially
   expanded (bar x), instead re-expanding it from the beginning
   after the definitions are all expanded (I have seen implementations
   that do this).

This seems academic, but I do think the differences could conceivably lead to 
difficulties in macros that rely on side effects to register compile-time 
information, as in record or object systems.  For example, if BAR were
a record definition, I would probably feel most comfortable if I could rely on 
the expression being epanded atomically (the first behaviour above).

Regards
Andre