Re: Macro for replacing a placeholder in an expression

[Zelphir Kaltstahl <zelphirkaltstahl@posteo.de>]

Hello Maxime!

Thank you for your quick response! (Mailing list saves me again! Yay!)

On 7/28/22 03:04, Maxime Devos wrote:
>
> On 28-07-2022 01:57, Zelphir Kaltstahl wrote:
>> scheme@(guile-user)> (define-syntax test
>>   (syntax-rules (lambda)
>>     [(_ (op args body* ...))
>>      ((test op) (test args) (test body* ...))]
>>
>>     [(_ thing1 thing2 things* ...)
>>      ((test thing1) (test thing2 things* ...))]
>>
>>     [(_ (thing))
>>      (thing)]
>>
>>     [(_ thing)
>>      thing]))
>> scheme@(guile-user)> (test (lambda (a) (+ a 1)))
>> While compiling expression:
>> Syntax error:
>> unknown file:798:0: lambda: invalid argument list in subform ((a)) of (test (a))
>> ~~~~
>>
>> There seems to be something about a template like (one-thing) that I do not 
>> understand or something completely different is going on. 
>
> Here's what happening:
>
> (test (lambda (a) (+ a 1))
>
> --> because  the 'test' in the beginning is a macro
>
> ((test lambda) (test (a)) (test (+ a 1))
>
> --> likewise
>
> (lambda (test (a)) (test (+ a 1))
>
> Now we end up with the 'lambda' macro. The lambda macro sees as argument list 
> (test (a)) and interprets 'test' as the first argument, but the second part 
> '(a)' is not an identifier so the lambda macro cannot do anything with that 
> and tells you that by saying: lambda: invalid argument list in ....

Ahhh now I get it! lambda is also a macro … I did not think of that.


>
> This seems the same issue as in 'Re: boiler plate class generation, writing 
> fresh variables with macros' to me but in a slightly different context
>
>> Syntax transformations in Scheme work from the outside to the inside, not the 
>> other way around, so you can't do things like this (define-class doesn't know 
>> what to do with this 'slot-machine' thing, it will reject it for not being a 
>> valid slot definition). However, you can define a syntax that generates the 
>> surrounding define-class and interprets things to insert the result of 
>> slot-matchine into a proper define-class form. 

And this explains the order of expansion! Something I've already been wondering 
about, what the order is or what the rules are.


> I consider a (in your case recursive, but in that case more like something 
> like syntax-map (which can be defined recursively in terms of syntax-case)) 
> syntax-case to be practical for this (more so than pure syntax-rules), see my 
> other response.

I aimed to do everything with syntax-rules, as the simplest means, but when 
writing the code I have, I hit the snag, that one could not have multiple 
ellipses at the same level of nesting in the patterns. After some thinking I 
found the solution to build up a temporary list, which then is of course 1 
deeper level of nesting, where I could then use ellipses again. I felt quite 
clever doing that trick. Maybe I could implement a syntax-map using that trick 
and then use syntax-map in my macro instead.

I have a question regarding syntax-case:

If I use it, does my code become less portable to other Schemes?

And regarding syntax-rules:

How portable are macros, which exclusively use syntax-rules?

>
> Greetings,
> Maxime

Thank you again for your help and explanations! Things are much clearer now!

Best regards,
Zelphir

-- 
repositories: https://notabug.org/ZelphirKaltstahl