Macro id-memv??, workings of tripple dot

Macro id-memv??, workings of tripple dot

[Zelphir Kaltstahl]

Hello Guile Users,

I have another macro understanding question and I think I don't yet grasp all 
the usages of the ellipsis/tripple dot/... :

Again it is a macro from https://okmij.org/ftp/Scheme/assert-syntax-rule.txt. 
This time the id-memv macro, which I think I mostly understand, but have 
questions about:

~~~~
;; A macro-expand-time memv function for identifiers
;; id-memv?? FORM (ID ...) KT KF
;; FORM is an arbitrary form or datum, ID is an identifier.
;; The macro expands into KT if FORM is an identifier, which occurs
;; in the list of identifiers supplied by the second argument.
;; All the identifiers in that list must be unique.
;; Otherwise, id-memv?? expands to KF.
;; Two identifiers match if both refer to the same binding occurrence, or
;; (both are undefined and have the same spelling).
(define-syntax id-memv??
   (syntax-rules ()
     ((id-memv?? form (id ...) kt kf)
      (let-syntax ((test
                    ;; Putting the ID matched in the outer syntax-rules
                    ;; form, where it is flexible to stand for any
                    ;; identifier, into the literals list makes it so,
                    ;; that whatever was matched in the outer
                    ;; syntax-rules is now literally matched against in
                    ;; the inner syntax-rules.
                    (syntax-rules (id ...)
                      ;; If indeed FORM is the same identifier as ID,
                      ;; then the result is the continuation for the
                      ;; true case.
                      ((test id _kt _kf) _kt) ...
                      ((test otherwise _kt _kf) _kf))))
        ;; Pass the form to be checked to test.
        (test form kt kf)))))
~~~~

My question is: Do the ... in the case

((test id _kt _kf) _kt) ...

produce one case for each identifier in the list? I am guessing that this is 
what they do. However, they are mentioned as literals in the inner syntax-rules, 
so I was thinking the expansion will simply put literally three dots there, 
instead of understanding the three dots to mean "for each of the ids".

And also I still am unsure about whether the three dots work like this at all. 
When one puts the ... after a compound expression, that contains the thing, that 
the ... were after in the matching -- in this case they were after id, and id is 
contained in the compound expression (test id _kt _kf) _kt) -- does that make 
the compound expression be generated for each thing matched?

For example:

(id-memv?? c (a b c) #t #f)

would internally expand into the cases:

((test a _kt _kf) _kt) _kt)
((test b _kt _kf) _kt) _kt)
((test c _kt _kf) _kt) _kt)
((test otherwise _kt _kf) _kf)

?

But if this is the case, then I might be misunderstanding the Guile docs at 
https://www.gnu.org/software/guile/manual/html_node/Syntax-Rules.html:

"Instances of a pattern variable in the template must be followed by an ellipsis."

So maybe I am just trying to see things here.

Best regards,
Zelphir

repositories:https://notabug.org/ZelphirKaltstahl

Re: Macro id-memv??, workings of tripple dot

[Jean Abou Samra]

[-- Attachment #1: Type: text/plain, Size: 2398 bytes --]

> My question is: Do the ... in the case
> 
> ((test id _kt _kf) _kt) ...
> 
> produce one case for each identifier in the list?


Yes, they do.


> I am guessing that this is what they do. However, they are mentioned as literals in the inner syntax-rules,


No, they aren't. The (id ...) form is expanded by the outer syntax-rules
form, as part of expanding the id-memv?? macro. They don't remain in the
expanded result. For example, if you call

(id-memv?? foo (foo bar baz) kt kf)

the expansion will look like

(let-syntax ((test
              (syntax-rules (foo bar baz)
                ((test foo _kt _kf) _kf)
                ((test bar _kt _kf) _kf)
                ((test baz _kt _kf) _kf)
                ((test otherwise _kt _kf) _kf))))
  (test foo kt kf))


> so I was thinking the expansion will simply put literally three dots there, 
> instead of understanding the three dots to mean "for each of the ids".
> 
> And also I still am unsure about whether the three dots work like this at all.


They do.


> When one puts the ... after a compound expression, that contains the thing, that 
> the ... were after in the matching -- in this case they were after id, and id is 
> contained in the compound expression (test id _kt _kf) _kt) -- does that make 
> the compound expression be generated for each thing matched?


Yes, see:

(syntax->datum
 (with-syntax ((simple #'a)
               ((compound ...) #'(b c d))
               (((nested-compound ...) ...) #'((e f g) (h i j))))
   #'(((simple compound nested-compound) ...) ...)))

⇒ (((a b e) (a c f) (a d g)) ((a b h) (a c i) (a d j)))


> But if this is the case, then I might be misunderstanding the Guile docs at 
> https://www.gnu.org/software/guile/manual/html_node/Syntax-Rules.html:
> 
> "Instances of a pattern variable in the template must be followed by an ellipsis."

Note that this is talking about the patterns, not the syntax forms. But it
is slightly misleading: also in patterns it is perfectly possible to do
something like

(syntax->datum
 (with-syntax ((((a b) ...) #'((1 2) (3 4) (5 6))))
   #'((a ...) . (b ...))))

⇒ ((1 3 5) 2 4 6)

Note the pattern

((a b) ...)

An ellipsized pattern is recognized by the ellipsis, but it doesn't
need to follow a simple pattern variable, it can follow a nested
pattern.

Best,
Jean


[-- Attachment #2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 228 bytes --]

Re: Macro id-memv??, workings of tripple dot

[Zelphir Kaltstahl]

Hello Jean!

On 3/15/24 09:03, Jean Abou Samra wrote:
>> My question is: Do the ... in the case
>>
>> ((test id _kt _kf) _kt) ...
>>
>> produce one case for each identifier in the list?
>
> Yes, they do.
>
>
>> I am guessing that this is what they do. However, they are mentioned as literals in the inner syntax-rules,
>
> No, they aren't. The (id ...) form is expanded by the outer syntax-rules
> form, as part of expanding the id-memv?? macro. They don't remain in the
> expanded result. For example, if you call
>
> (id-memv?? foo (foo bar baz) kt kf)
>
> the expansion will look like
>
> (let-syntax ((test
>                (syntax-rules (foo bar baz)
>                  ((test foo _kt _kf) _kf)
>                  ((test bar _kt _kf) _kf)
>                  ((test baz _kt _kf) _kf)
>                  ((test otherwise _kt _kf) _kf))))
>    (test foo kt kf))
Aha! Of course! The inner syntax-rules is nothing special from the perspective 
of the outer syntax-rules! Somehow I saw it as something special and "evaluated 
from the inside out" in my head instead of from the "outside in", as I should 
have been doing. That makes a lot more sense now.
>> so I was thinking the expansion will simply put literally three dots there,
>> instead of understanding the three dots to mean "for each of the ids".
>>
>> And also I still am unsure about whether the three dots work like this at all.
>
> They do.
>
>
>> When one puts the ... after a compound expression, that contains the thing, that
>> the ... were after in the matching -- in this case they were after id, and id is
>> contained in the compound expression (test id _kt _kf) _kt) -- does that make
>> the compound expression be generated for each thing matched?
>
> Yes, see:
>
> (syntax->datum
>   (with-syntax ((simple #'a)
>                 ((compound ...) #'(b c d))
>                 (((nested-compound ...) ...) #'((e f g) (h i j))))
>     #'(((simple compound nested-compound) ...) ...)))
>
> ⇒ (((a b e) (a c f) (a d g)) ((a b h) (a c i) (a d j)))
That example is quite difficult to unpack for me, but I think I get it. Sort of. 
It is showing the reverse thing, not matching, but telling Guile what the match 
is. And then using that in an expression.
>> But if this is the case, then I might be misunderstanding the Guile docs at
>> https://www.gnu.org/software/guile/manual/html_node/Syntax-Rules.html:
>>
>> "Instances of a pattern variable in the template must be followed by an ellipsis."
> Note that this is talking about the patterns, not the syntax forms. But it
> is slightly misleading: also in patterns it is perfectly possible to do
> something like
>
> (syntax->datum
>   (with-syntax ((((a b) ...) #'((1 2) (3 4) (5 6))))
>     #'((a ...) . (b ...))))
>
> ⇒ ((1 3 5) 2 4 6)
OK, this is easier to understand. It tells Guile what values A and B will be and 
then uses A and B in another way. But still quite cool, that this is possible. 
Not sure where to use it yet.
> Note the pattern
>
> ((a b) ...)
>
> An ellipsized pattern is recognized by the ellipsis, but it doesn't
> need to follow a simple pattern variable, it can follow a nested
> pattern.
What do you mean by "follow a nested pattern"?
> Best,
> Jean
As before, thanks for the revelations!
Zelphir

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