Are incremental Macro definition possible?

Question

I often find the following type of incremental definition useful:

(define (foo) (display "bar"))
(foo)
;prints bar
(define foo (let ((bar foo))
              (lambda ()
                (display "foo")
                (bar))))

(foo)
;prints foobar

How do I preform this type of incremental definition with macros? I could not get let-syntax to provide the same functionality.

Currently I use plt scheme, but would like to see answers in different lisp implementations as well.

Edit:

Naively I would want to do the following:

(define-syntax foo
  (syntax-rules ()
    ((_) (display "bar"))))

(define-syntax foo
  (let-syntax ((old-foo (syntax-rules () ((_) (foo)))))
    (syntax-rules ()
      ((_) (begin
             (display "foo")
             (old-foo))))))

Translation of naive macros to working plt scheme macros:

(require-for-syntax scheme/base) 
(define-syntax foo
  (syntax-rules ()
    [(foo) (display "bar")]))
(define-syntax foo
  (let ([old (syntax-local-value #'foo)])
    (lambda (stx)
      #`(begin #,((syntax-rules ()
               [(_) (begin (display "foo"))]) stx)
             #,(old #'(_))))))
(foo)

If I am missing a better method let me know.

Answer 1

I do not think that you can do something like this with macros. I also do not see any point in trying.

Please note that macros are not just some functions with extra magic! Macros are something different altogether.

Perhaps you are looking for something like method combinations in Common Lisp?

Answer 2

With macros doing this you are on the way to create the hardest to maintain software on the planet.

Edit: in Common Lisp it is possible. I can't remember that I have ever seen it used in source code.

Adding behavior to functions or macros is often called 'advise' or 'advice' in the Common Lisp community. Some 'advise' tools have also the ability to advise macros.