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