<html>
  <head>
    <meta content="text/html; charset=ISO-8859-1"
      http-equiv="Content-Type">
  </head>
  <body bgcolor="#FFFFFF" text="#000000">
    <div class="moz-cite-prefix">I think its explained here<br>
      <br>
      <meta http-equiv="content-type" content="text/html;
        charset=ISO-8859-1">
      <a
href="http://docs.racket-lang.org/reference/stx-patterns.html?q=ellipses#%28form._%28%28lib._racket/private/stxcase-scheme..rkt%29._syntax%29%29">http://docs.racket-lang.org/reference/stx-patterns.html?q=ellipses#(form._((lib._racket/private/stxcase-scheme..rkt)._syntax))</a><br>
      <br>
      at (ellipses stat-template), although I find the explanation
      confusing. Probably an example of (... ...) would be useful there.<br>
      <br>
      On 08/03/2012 09:51 PM, Nick Sivo wrote:<br>
    </div>
    <blockquote
cite="mid:[email protected]m"
      type="cite">
      <pre wrap="">Hi Jon,

Thanks, that works perfectly!

Did I miss that somewhere in the documentation?  I don't recall seeing
an example of it.

Best,
Nick

On Thu, Aug 2, 2012 at 11:55 PM, Jon Rafkind <a class="moz-txt-link-rfc2396E" href="mailto:rafkind@cs.utah.edu">&lt;rafkind@cs.utah.edu&gt;</a> wrote:
</pre>
      <blockquote type="cite">
        <pre wrap="">To match a literal ellipses in syntax-parse use #:literal [(ellipses ...)] and match on the term `ellipses', then to use a literal ellipses in the template use (... ...) instead of just ...

It looks like you only want the latter, so

(define-syntax (example stx)
  (syntax-parse stx
    [(_ name:id) #'(define-syntax (name stx)
                              (syntax-parse stx
                                 [(_ args (... ...)) #'(args (... ...)))])]))

On 08/02/2012 11:30 PM, Nick Sivo wrote:
</pre>
        <blockquote type="cite">
          <pre wrap="">Hi,

I'm trying to use ... in the inner macro of a macro defining macro,
but can't figure out the right way to escape it.

Here's a minimal (pointless) example:

(require (for-syntax syntax/parse))

(define-syntax (example stx)
  (syntax-parse
   stx
   ;#:literals (...) ; Doesn't help :(
   [(_ name:id)
    #'(define-syntax (name stx)
        (syntax-parse
         stx
         [(_ args ...) #'(args ...)]))]))

The goal is to have (example invisible) define a macro called
invisible that erases itself.

Any ideas?  The full code I'm trying to enable follows below if you'd
like more context.

Thanks,
Nick

#lang racket

(require (for-syntax syntax/parse)
         racket/splicing)

;;;
;;; Procedure Application
;;;

(define arc-nil #f)

(define-syntax (arc-#%app stx)
  (syntax-parse
   stx
   [(_ fn:expr arg:expr)
    #'(let ([efn fn])
        (cond [(procedure? efn) (#%app efn arg)]
              [(pair? efn) (#%app list-ref efn arg)]
              [(string? efn) (#%app string-ref efn arg)]
              [(hash? efn) (#%app hash-ref efn arg arc-nil)]
              [else (#%app efn arg)]))]
   [(_ fn:expr arg1:expr arg2:expr)
    #'(let ([efn fn])
        (if (hash? efn)
            ; Have to use the lamda in case arg2 is a function
            ; See hash-ref docs for more info
            (#%app hash-ref fn arg1 (lambda () arg2))
            (#%app fn arg1 arg2)))]
   [(_ args ...)
    #'(#%app args ...)]))

; This allows cross module mutation of globals
(define-syntax (declare-with-set-transformer stx)
  (syntax-parse
   stx
   ;#:literals (...) ; Doesn't help :(
   [(_ var:id)
    #'(declare-with-set-transformer var (gensym 'unintialized))]
   [(_ var:id init-val:expr)
    (let ([store-name (gensym (syntax-&gt;datum #'var))])
      #`(begin
          (define #,store-name init-val)
          (splicing-let ([set (lambda (val)
                                (set! #,store-name val))])
            (define-syntax var
              (make-set!-transformer
               (lambda (stx)
                 (syntax-case stx (set!)
                   [(set! id val) #'(set val)]
                   ; Uses Racket's #%app, which doesn't work for arc
                   [(id . args) #'(#,store-name . args)] ; function application
                   ; Obviously invalid syntax
                   ;[(id . args) #'(arc-#%app #,store-name . args)]
                   ; Errors because ... isn't recognized as a literal
                   ;[(id args ...) #'(arc-#%app #,store-name args ...)]
                   [id (identifier? #'id) #'#,store-name])))))))]))

; Demo of what I'm looking for
(define test (make-hash))
(hash-set! test 'key 'value)
(displayln (arc-#%app test 'key))

; Example of what doesn't work right now
(declare-with-set-transformer test2 (make-hash))
(hash-set! test2 'key 'value)
(displayln (test2 'key))
____________________
  Racket Users list:
  <a class="moz-txt-link-freetext" href="http://lists.racket-lang.org/users">http://lists.racket-lang.org/users</a>
</pre>
        </blockquote>
        <pre wrap="">
____________________
  Racket Users list:
  <a class="moz-txt-link-freetext" href="http://lists.racket-lang.org/users">http://lists.racket-lang.org/users</a>
</pre>
      </blockquote>
    </blockquote>
    <br>
  </body>
</html>