4

My goal is to be able to apply a macro to an argument list in the same way the apply primitive procedure applies a procedure to an argument list.

The list will already be evaluated at the time of application of the macro, there is no way around that and that’s fine; I am wondering if there is any way to programmatically “splice” the list into the macro application (in the same sense as with unquote-splicing). The difficulty resides in that one cannot pass the macro identifier as an argument.

One use case would be

(apply and list)

which would be equivalent to

(not (memq #f list))

to see if there is a #f in list. Preferably this would be R7RS conformant.

One sort of hacky way would be (as suggested on reddit)

(eval (cons 'and list))

but this is not R7RS conformant, as eval must take an environment argument and it seems to me the standard doesn’t specify how to snatch the environment in effect at the call to eval.

Another half solution is the following, which only works if the list is given directly as a parenthesized sequence of values:

(syntax-rules ()
  ((_ identifier (val ...))
   (identifier val ...)))
Olius
  • 226
  • 1
  • 6

3 Answers3

2

I'm posting this as a partial answer I found to my own question, and I'll accept it in a few days if nothing new pops up.

The following works, but only if the macro to apply is contained in a library.

(import (scheme base)
        (scheme eval)
        (scheme write))

(define (apply-macro mac args . libs)
  (eval (cons mac args)
        (apply environment libs)))

(define list '(#f #t #t #t))

(display (apply-macro 'and      list  '(scheme base)))    ; => #f
(display (apply-macro 'and (cdr list) '(scheme base)))    ; => #t
Olius
  • 226
  • 1
  • 6
1

You can't do that; macros apply to syntax, transforming code fragments into other code fragments, not to values.

Even if you could do it, it would not be equivalent to applying and, since all the elements of list would be evaluated.

For instance, if you define the non-terminating procedure,

(define (forever) (forever))

then (and #f (forever)) is #f, but (apply and (list #f (forever))) would not terminate.

molbdnilo
  • 64,751
  • 3
  • 43
  • 82
  • 1
    The question was more about how to unpack the list and less about `and` itself which I gave as a (perhaps overemphasized) example. See my edits. – Olius Aug 18 '19 at 12:46
  • @Olius This answer is also more about why you can't do that than about `and` specifically – there is no list for you to "unpack". Your statement that "[t]he list will already be evaluated at the time of application of the macro" is simply not true; macros are applied prior to evaluation, and that is what there is no way around. – molbdnilo Aug 18 '19 at 14:09
0

You cannot do this without eval. You would need to implement a procedure version of AND.

The reason it's impossible is because macro expansion is one phase and evaluation is a later phase. The list is piece of dynamic data existing only in the later phase, so a macro cannot use that.

river
  • 1,028
  • 6
  • 16
  • Is there no way to do this even with `eval`? If it were possible to encapsulate the environment in effect at a given moment in the program execution and pass it to `eval`, the “hacky” example I gave would be satisfactory. – Olius Aug 18 '19 at 12:40
  • as you proved it can be done with eval. I will add a note about that to my answer. thanks! – river Aug 21 '19 at 14:40