define-advice, advise, defnadvice, advice-advise you name it

[Leo Liu <sdl.web@gmail.com>]

Hi folks,

Stefan has agreed to add a macro as follows:

   (defmacro define-advice (symbol args &rest body)
     "Define an advice and add it to function named SYMBOL.
   See `advice-add' and `add-function' for explanation on the
   arguments.  Note if NAME is nil the advice is anonymous;
   otherwise it is named `SYMBOL@NAME'.
   
   \(fn SYMBOL (WHERE LAMBDA-LIST &optional NAME DEPTH) &rest BODY)"
     (declare (indent 2) (doc-string 3) (debug (sexp sexp body)))
     (or (listp args) (signal 'wrong-type-argument (list 'listp args)))
     (or (<= 2 (length args) 4)
         (signal 'wrong-number-of-arguments (list 2 4 (length args))))
     (let* ((where         (nth 0 args))
            (lambda-list   (nth 1 args))
            (name          (nth 2 args))
            (depth         (nth 3 args))
            (props         (and depth `((depth . ,depth))))
            (advice (cond ((null name) `(lambda ,lambda-list ,@body))
                          ((or (stringp name) (symbolp name))
                           (intern (format "%s@%s" symbol name)))
                          (t (error "Unrecognized name spec `%S'" name)))))
       `(prog1 ,@(and (symbolp advice) `((defun ,advice ,lambda-list ,@body)))
          (advice-add ',symbol ,where #',advice ,@(and props `(',props))))))

`advise' is out because it is not in the `advice' namespace;
`defnadvice' is inferior to define-advice;
`advice-advise' is odd

So far we can accept define-advice but feel something lacking due to:

  given primitives "define-foo", "foo-add" and "foo-remove", it really
  sounds like the first defines something that you can then pass to the
  second and the third.

So does anyone have something that sounds advicey and macroish?

Thanks,
Leo