How to call other macros from a Chicken Scheme macro?

Question

I'm trying to move from Common Lisp to Chicken Scheme, and having plenty of problems.

My current problem is this: How can I write a macro (presumably using define-syntax?) that calls other macros?

For example, in Common Lisp I could do something like this:

(defmacro append-to (var value)
 `(setf ,var (append ,var ,value)))

(defmacro something-else ()
 (let ((values (list))
  (append-to values '(1)))))

Whereas in Scheme, the equivalent code doesn't work:

(define-syntax append-to
 (syntax-rules ()
  ((_ var value)
   (set! var (append var value)))))

(define-syntax something-else
 (syntax-rules ()
  ((_)
   (let ((values (list)))
    (append-to values '(1))))))

The append-to macro cannot be called from the something-else macro. I get an error saying the append-to "variable" is undefined.

According to all the information I've managed to glean from Google and other sources, macros are evaluated in a closed environment without access to other code. Essentially, nothing else exists - except built-in Scheme functions and macros - when the macro is evaluated. I have tried using er-macro-transformer, syntax-case (which is now deprecated in Chicken anyway) and even the procedural-macros module.

Surely the entire purpose of macros is that they are built upon other macros, to avoid repeating code. If macros must be written in isolation, they're pretty much useless, to my mind.

I have investigated other Scheme implementations, and had no more luck. Seems it simply cannot be done.

Can someone help me with this, please?

Doing anything more complex than `syntax-rules` macros is non-standard Scheme, so while what you want to do is quite possible in many *specific* Schemes, the way to do it will likely vary wildly between them. If you want to ask this sort of question, it’d probably be better to pick a specific Scheme implementation and ask about how to replicate it in that. — Alexis King, Aug 08 '16 at 01:47
@AlexisKing Thanks, I have modified my question to focus more on one implementation. — Sod Almighty, Aug 08 '16 at 03:40
I don't quite understand the question. Maybe you can give a Common Lisp example that you're unable to get to work with CHICKEN? — sjamaan, Aug 08 '16 at 06:28

score 4 · Accepted Answer · edited May 23 '17 at 12:33

It looks like you're confusing expansion-time with run-time. The syntax-rules example you give will expand to the let+set, which means the append will happen at runtime.

syntax-rules simply rewrites input to given output, expanding macros until there's nothing more to expand. If you want to actually perform some computation at expansion time, the only way to do that is with a procedural macro (this is also what happens in your defmacro CL example).

In Scheme, evaluation levels are strictly separated (this makes separate compilation possible), so a procedure can use macros, but the macros themselves can't use the procedures (or macros) defined in the same piece of code. You can load procedures and macros from a module for use in procedural macros by using use-for-syntax. There's limited support for defining things to run at syntax expansion time by wrapping them in begin-for-syntax.

See for example this SO question or this discussion on the ikarus-users mailing list. Matthew Flatt's paper composable and compilable macros explains the theory behind this in more detail.

The "phase separation" thinking is relatively new in the Scheme world (note that the Flatt paper is from 2002), so you'll find quite a few people in the Scheme community who are still a bit confused about it. The reason it's "new" (even though Scheme has had macros for a long long time) is that procedural macros have only become part of the standard since R6RS (and reverted in R7RS because syntax-case is rather controversial), so the need to rigidly specify them hasn't been an issue until now. For more "traditional" Lispy implementations of Scheme, where compile-time and run-time are all mashed together, this was never an issue; you can just run code whenever.

To get back to your example, it works fine if you separate the phases correctly:

(begin-for-syntax
  (define-syntax append-to
    (ir-macro-transformer
      (lambda (e i c)
        (let ((var (cadr e))
              (val (caddr e)))
          `(set! ,var (append ,var ,val)))))) )

(define-syntax something-else
  (ir-macro-transformer
    (lambda (e i c)
      (let ((vals (list 'print)))
        (append-to vals '(1))
        vals))))

(something-else) ; Expands to (print 1)

If you put the definition of append-to in a module of its own, and you use-for-syntax it, that should work as well. This will also allow you to use the same module both in the macros you define in a body of code as well as in the procedures, by simply requiring it both in a use and a use-for-syntax expression.

That was a very useful reply, thanks. So... kinda like [this](http://pastebin.com/weP9GnR1) then? — Sod Almighty, Aug 08 '16 at 14:06
Yep. However, in that particular example you don't need to use an er-macro-transformer of course. That's only required if you need to perform side-effects or want to construct identifiers or constants at compile-time. (in cases where you only need to pattern-match and rearrange input expressions, you can just use `syntax-rules`) — sjamaan, Aug 08 '16 at 17:02

How to call other macros from a Chicken Scheme macro?

1 Answers1