Re: Syntax-Case macro that selects the N-th element from a list

[Taylan Kammer <taylan.kammer@gmail.com>]

On 05.04.2021 13:30, Dr. Arne Babenhauserheide wrote:
> Hi,
> 
> In dryads-wake I need selection of the element in a list in a macro from
> user-input. Currently I have multiple macros, and the correct one (which
> strips the non-selected choices) is selected in a simple cond:
> 
> (define-syntax-rule (Choose resp . choices)
>    "Ask questions, apply consequences"
>    (cond
>     ((equal? resp 1) ;; resp is user-input. It is a natural number.
>      (Respond1 choices))
>     ((equal? resp 2)
>      (Respond2 choices))
>     ((equal? resp 3)
>      (Respond3 choices))
>     (else
>      #f)))
> 
> For this however I have three syntax-case macros:
> 
> (define-syntax Respond1
>   (lambda (x)
>     (syntax-case x ()
>       ((_ ((question consequences ...) choices ...))
>         #`(begin
>            (respond consequences ...)))
>       ((_ (choices ...))
>         #`(begin #f)))))
> 
> (define-syntax Respond2
>   (lambda (x)
>     (syntax-case x ()
>       ((_ (choice choices ...))
>         #`(begin
>            (Respond1 (choices ...))))
>       ((_ (choices ...))
>         #`(begin #f)))))
> 
> (define-syntax Respond3
>   (lambda (x)
>     (syntax-case x ()
>       ((_ (a b choices ...))
>         #`(Respond1 (choices ...)))
>       ((_ (choices ...))
>         #`(begin #f)))))
> 
> 
> I would like to get rid of those three definitions and replace them by
> at most two (one that strips N initial list entries, and Respond1).
> 
> I cannot move to procedures, because I have code that must be executed
> only during final processing, and when I evaluate any of the
> consequences (as it happens with procedure-arguments), then the timing
> of the code execution does not match anymore. So I must absolutely do
> this in macros.
> 
> 
> I’ve tried to get that working, but all my tries failed. Is there a way
> and can you show it to me?
> 
> This is a minimal working example. The output should stay the same,
> except for part 4, which needs this change to work (see at the bottom),
> but I would like to:
> 
> - replace Respond2 and Respond3 by something recursive, so resp can have
>   arbitrary high values (not infinite: max the length of the options) and
> - replace the cond-clause by a call to the recursive macro.
> 
> (define-syntax-rule (respond consequence consequence2 ...)
>   (begin
>     (write consequence)
>     (when (not (null? '(consequence2 ...)))
>       (write (car (cdr (car `(consequence2 ...))))))))
> 
> (define-syntax Respond1
>   (lambda (x)
>     (syntax-case x ()
>       ((_ ((question consequences ...) choices ...))
>         #`(begin
>            (respond consequences ...)))
>       ((_ (choices ...))
>         #`(begin #f)))))
> 
> (define-syntax Respond2
>   (lambda (x)
>     (syntax-case x ()
>       ((_ (choice choices ...))
>         #`(begin
>            (Respond1 (choices ...))))
>       ((_ (choices ...))
>         #`(begin #f)))))
> 
> (define-syntax Respond3
>   (lambda (x)
>     (syntax-case x ()
>       ((_ (a b choices ...))
>         #`(Respond1 (choices ...)))
>       ((_ (choices ...))
>         #`(begin #f)))))
> 
> 
> (define-syntax-rule (Choose resp . choices)
>    "Ask questions, apply consequences"
>    (cond
>     ((equal? resp 1)
>      (Respond1 choices))
>     ((equal? resp 2)
>      (Respond2 choices))
>     ((equal? resp 3)
>      (Respond3 choices))
>     (else
>      #f)))
> 
> 
> (display "Choose 1: should be bar:")
> (Choose 1 (foo 'bar) (foo 'war 'har) (foo 'mar) (foo 'tar))
> (newline)
> (display "Choose 2: should be warhar:")
> (Choose 2 (foo 'bar) (foo 'war 'har) (foo 'mar) (foo 'tar))
> (newline)
> (display "Choose 3: should be mar:")
> (Choose 3 (foo 'bar) (foo 'war 'har) (foo 'mar) (foo 'tar))
> (newline)
> (display "Choose 4: should be tar:")
> (Choose 4 (foo 'bar) (foo 'war 'har) (foo 'mar) (foo 'tar))
> (newline)
> (display "Choose 5: should be #f:")
> (Choose 5 (foo 'bar) (foo 'war 'har) (foo 'mar) (foo 'tar))
> (newline)
> 
> 
> Best wishes,
> Arne
> 

Is there a reason you want to separate 'choose' from the various
'respondN' macros?  That seems superfluous to me.

And if the number of choices is limited, you don't even need to use
procedural macros.  The following works:

;; Note: I like using the notation <foo> for template variables.
;; Feels highly intuitive to me.

(define-syntax choose
  (syntax-rules ()
    ((_ 1 <c1> <rest> ...)
     (respond <c1>))
    ((_ 2 <c1> <c2> <r> ...)
     (respond <c2>))
    ((_ 3 <c1> <c2> <c3> <r> ...)
     (respond <c3>))
    ((_ 4 <c1> <c2> <c3> <c4> <r> ...)
     (respond <c4>))
    ((_ 5 <c1> <c2> <c3> <c4> <c5> <r> ...)
     (respond <c5>))
    ((_ <r> ...) #f)))

You could also leave out the final clause and thus let it be an implicit
syntax error, or explicitly invoke 'syntax-error' with an explanation.

But if you want to support an arbitrary numbers of choices, the
following procedural macro will do it:

(define-syntax choose
  (lambda (stx)
    (syntax-case stx ()
      ((_ <n> . <choices>)
       (let* ((n (syntax->datum #'<n>))
              (choice-list (syntax->datum #'<choices>))
              (choice-datum (list-ref choice-list (- n 1)))
              (choice-stx (datum->syntax #'<choices> choice-datum)))
         #`(respond #,choice-stx))))))

I've written a very trivial explanation of syntax-case usage here, in
case anyone struggles as I did at first:

http://taylanub.github.io/doc/syntax-case-example.scm.txt


Hope that helps!

- Taylan