Providing name only to sub-module?

Questions & Answers
,
11

The scope “on the parentheses” of the (submod "..") form is used for the imported bindings. This distinction is important so that the binding for submod still comes from the macro definition site, in case the usual binding isn't available at the use site.

Here's a worked-out example:

#lang racket

(require syntax/parse/define)

(define-syntax-parser with-examples
  [(_ body ...)
   #:with racket/base (datum->syntax this-syntax #'racket/base)
   #:with submod.. (datum->syntax this-syntax (list #'submod #'".."))
   #'(module* all-defns #f
       (provide (all-from-out submod..))
       (module* compile-time-exec #f
         (require (for-syntax racket/base
                              submod..))
         (begin-for-syntax
           body ...)))])

(define n 42)

(with-examples
 (displayln n))

I also changed to use this-syntax instead of binding and using #'with-examples: that would allow some other macro that would expand to with-examples to work like the (submod "..") case.

I'm not sure if there's a way to do this or not, and I've only skimmed the rest of this thread (so I'm likewise not getting into whether it should check syntax-local-context or syntax-local-lift-module-end-declaration or something to work multiple times).

But one thing to note is that (require (submod "..")) imports the identifiers exported by the parent module, potentially shadowing un-exported identifiers with the same names. The most common example is contracts:

#lang racket
(define (buggy-generate-string)
  'not-a-string)
(provide (contract-out
          [buggy-generate-string
           (-> string?)]))
(module* implicit #f
  (provide implicit)
  (define (implicit)
    (buggy-generate-string)))
(module* explicit #f
  (require (submod ".."))
  (provide explicit)
  (define (explicit)
    (buggy-generate-string)))
(module* main racket
  (require (submod ".." implicit))
  (require (submod ".." explicit))
  `([implicit ,(implicit)]
    [explicit ,(with-handlers ([exn:fail? values])
                 (explicit))]))