eval-when not giving me what I hoped for

[Matt Wette]

I am trying to get a macro to expand at compile time using eval-when, but it’s not giving me what I expect:

(eval-when (expand) (make-regexp pat)) …

gets expanded to:

        (if #f #f)

I would like to see something like 

#<regexp 1098a2d40>

Any help would be appreciated. — Matt

I get the same (if #f #f) result whether I use (expand) or (compile).

Below is 

1) my macro (missing the helpers all-const-string? and rx-let)

2) the macro I use to compile to il-tree and then back to scheme 

3) the demo code 

4) the output from expand

=== my macro ==========================

(define-syntax regexp-case

  (lambda (x)

    (syntax-case x (else)

      ((_ str ((pat v ...) exp ...) ... (else else-exp ...))

       (with-syntax (((id ...) (generate-temporaries #'(pat ...))))

(all-const-string? #'(pat ...))

#'(let ((id (eval-when (expand) (make-regexp pat))) ...)

    (cond

     ((regexp-exec id str) =>

      (lambda (m) (rx-let m (v ...) exp ...)))

     ...

     (else else-exp ...)))))

      ((_ str ((pat v ...) exp ...) ...)

       (with-syntax (((id ...) (generate-temporaries #'(pat ...))))

(all-const-string? #'(pat ...))

#'(let ((id (eval-when (expand) (make-regexp pat))) ...)

    (cond

     ((regexp-exec id str) =>

      (lambda (m) (rx-let m (v ...) exp ...)))

     ...

     (else

      (scm-error #f "regexp-case"

 "no match found: ~S" (list str)

 #f)))))))))

=== the expand macro =======================

#:use-module (srfi srfi-11)

#:use-module (system base compile)

(define* (expand-form e #:key (opts '()))

  (let-values (((exp env) (decompile

                           (compile e #:from 'scheme

                                    #:to 'tree-il

                                    #:env (current-module))

                           #:from 'tree-il

                           #:to 'scheme

                           #:opts opts)))

    exp))

(define-syntax-rule (expand _expression_)

  (expand-form '_expression_))

=== orig test case ================

  (regexp-case str

    (("^([a-z]+)\\(([0-9]+)\\)$" v i)

     (list v i))

    (("^([a-z]+)$" v)

     (list v "1")))

=== output from expand =============

(let ((t-768 (if #f #f))

      (t-769 (if #f #f)))

  (let ((t (regexp-exec t-768 str)))

    (if t

      (let ((m t))

        (let ((v (match:substring m 1))

              (i (match:substring m 2)))

          (list v i)))

      (let ((t (regexp-exec t-769 str)))

        (if t

          (let* ((m t) (v (match:substring m 1)))

            (list v "1"))

          (scm-error

            #f

            "regexp-case"

            "no match found: ~S"

            (list str)

            #f))))))