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

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.

Answer 2

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 3

What about let*?

(define foobar
    (let* ((foo (lambda () (display "foo")))
           (bar (lambda () (foo) (display "bar"))) )
            bar))

Answer 4

I think you could get this by using unhygienic macros, which I believe PLT Scheme supports. Then you would use exactly the same mechanisms as with regular functions, since the macros would be regular functions that happened to operate on S-expressions.

I don't know how to do this with hygienic macros, but I'm quite surprised you can't - I would consider asking on a PLT mailing list.

Answer 5

FWIW (and this is definitely not much, since this is pretty much an exercise in target practicing with your feet), here is how you would do this in PLT Scheme with only hygienic syntax-rules macros:

(define-syntax foo
  (syntax-rules ()
    [(foo x) (list 'x '= x)]))
(define-syntax foo
  (let ([old (syntax-local-value #'foo)])
    (compose (syntax-rules ()
               [(_ x ...) (list 'begin x ... 'end)])
             old)))
(printf ">>> ~s\n" (foo (+ 1 2)))

This will not work inside a module, only on the REPL -- and that is a good thing. It is possible to do something similar in modules too, but if you're going for that, you can just as well use procedural macros (aka syntax-case macros), with an identifier that is bound at the syntax level and `set!'-ing its value to extend it. Still not a great idea, and can still lead to eyes bleeding, but some people like to hurt themselves...

(Oh, and BTW -- even doing this is still completely unrelated to whether the macros in question are hygienic or not.)