[module lang mzscheme
  (provide displn (all-from mzscheme))
  (define displn (lambda l (map display l) (newline)))]

[module root lang
  (provide var mutate!)
  (define var '())
  (define (mutate! arg)
    (set! var (cons arg var)))
  (displn "invoking root mod")]

[module a lang
  (require root)
  (provide var mutate!)
  (displn "invoking a mod")
  (mutate! 'foo)
  (displn (list 'var var))]

[module b lang
  (provide var b-syntax-mutate! b-var-at-syntax)
  (require-for-syntax a)
  (require a)
  (displn "invoking b mod")
  (define-syntax b-syntax-mutate!
    (lambda (stx)
      (syntax-case stx ()
        ((_ FOO)
         (mutate! (cons 'b-s-m! (syntax-object->datum #'FOO)))
         #'FOO))))
  (mutate! 'b-exec-time)
  (b-syntax-mutate! 'b-read-time)
  (define-syntax b-var-at-syntax
    (lambda (stx) 
      (syntax-case stx ()
        [(_ FOO)
         #`(quote (FOO #,(datum->syntax-object #f var)))])))
  (define-syntax display-b-var
    (lambda (stx)
      (display (list 'display-var-from-b-mod var)) (newline)
      #'(quote b)))
  (display-b-var)]

[module c lang
  (provide var c-syntax-mutate! c-var-at-syntax)
  
  ;; This is not a dependency; just here to show the difference
  ;; syntax-invocation makes
  (require-for-syntax b) 
  
  (require-for-syntax a)
  (require a)
  (displn "invoking c mod")
  (define-syntax c-syntax-mutate!
    (lambda (stx)
      (syntax-case stx ()
        ((_ FOO)
         (mutate! (cons 'c-s-m! (syntax-object->datum #'FOO)))
         #'FOO))))
  (mutate! 'c-exec-time)
  (c-syntax-mutate! 'c-read-time)
  (define-syntax c-var-at-syntax
    (lambda (stx) 
      (syntax-case stx ()
        [(_ FOO)
         #`(quote (FOO #,(datum->syntax-object #f var)))])))
  (define-syntax display-c-var
    (lambda (stx)
      (display (list 'display-var-from-c-mod var)) (newline)
      #'(quote c)))
  (display-c-var)]

[module d mzscheme
  (provide var d-syn-var)
  (require b)
  (require c)
  (b-syntax-mutate! 'd-read-time-1)
  (c-syntax-mutate! 'd-read-time-2)
  (define (d-syn-var)
    (list (b-var-at-syntax d-of-b) (c-var-at-syntax d-of-c)))]
 
(require lang)
(require d)
(displn var)
(for-each displn (d-syn-var))