[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: replacing a function with another one

From: Michael Heerdegen
Subject: Re: replacing a function with another one
Date: Tue, 11 Mar 2014 01:03:10 +0100
User-agent: Gnus/5.13 (Gnus v5.13) Emacs/24.3.50 (gnu/linux)

lee <address@hidden> writes:

> > (advice-add
> >  'hi-lock-write-interactive-patterns :around
> >  ;; also include `hi-lock-file-patterns'
> >  (lambda (f &rest args)

> What does (f &rest args) do or mean?

>From the doc of `add-function', this is how :around advices FUNCTION are

  (lambda (&rest r) (apply FUNCTION OLDFUN r))

Note that the advice FUNCTION will be called with an additional (the
first) argument, which will be bound to the original function when the
advice is called.  This way, you have direct access to the original
function through that binding in your advice, and you can call it with
funcall or apply.  This "mechanism" is the replacement for the old

In my example, FUNCTION is (lambda (f &rest args) ...), which means that
f will be bound to OLDFUN, i.e. the original definition of
`hi-lock-write-interactive-patterns', and args will be bound to r, which
will be the list of arguments with which
`hi-lock-write-interactive-patterns' gets called.

> >    (apply f args)))
> f args?
> hi-lock-write-interactive-patterns doesn´t have any arguments.

So, the function will always be called without arguments, which means
that args will be bound to the empty list - no problem.

So why did I write it that way?  Because it works with any argument
list.  Instead of specifying the original argument list in the advice,
I just use  &rest args  and apply the original function to args when I
don't need to know the value of any argument.

Of course you can also write

 'hi-lock-write-interactive-patterns :around
 (lambda (f)
   (let ((hi-lock-interactive-patterns
          (append hi-lock-interactive-patterns
   (funcall f)))

But if some day `hi-lock-write-interactive-patterns' might become an
optional argument, this advice would raise an wrong number of arguments

> [1]: Another question:
> To get patterns from a separate file, I´m using find-file.  This is
> probably not very efficient:  I suspect that the file is actually loaded
> every time, with all what that implies.

No, Emacs doesn't do such things.  If the file is already found in a
buffer, this buffer will just be selected when you `find-file' the same
file again.

If you want to try this approach, you can use `find-file-noselect',
which returns the file's buffer (without selecting it) and assign it to
some variable foo.  Later, you can always just use
(with-current-buffer foo ...).



reply via email to

[Prev in Thread] Current Thread [Next in Thread]