Re: replacing a function with another one

[lee]

Michael Heerdegen <michael_heerdegen@web.de> writes:

> lee <lee@yun.yagibdah.de> 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
> called:
>
>   (lambda (&rest r) (apply FUNCTION OLDFUN r))

I can only guess what that is supposed to mean.  r is undefined, &rest
might be some sort of reference, why the old function is to be applied
is unknown, and where or what the advice is or how to add it doesn´t
show anywhere.  It is also not shown how to put anything actually around
the old function, i. e. how you do something, then call the existing
function, then do some more, which would be the purpose of an around
advice.

> 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.

The documentation doesn´t say that.  It seems to be supposed to call two
functions, one of them apparently being the existing one, the other one
unknown.

> 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 ad-do-it.

Why doesn´t the documentation just say that?

> In my example, FUNCTION is (lambda (f &rest args) ...),

But f and args are undefined.

> which means that f will be bound to OLDFUN, i.e. the original
> definition of `hi-lock-write-interactive-patterns',

But you are not applying something like the documentation would suggest
is needed.

> and args will be bound to r, which will be the list of arguments with
> which `hi-lock-write-interactive-patterns' gets called.

r? So that is something that isn´t defined or documented?  I tried to
look up r, without success other than finding out that it apparently is
neither a variable, nor a function.

>> >    (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
>
> (advice-add
>  'hi-lock-write-interactive-patterns :around
>  (lambda (f)
>    (let ((hi-lock-interactive-patterns
>         (append hi-lock-interactive-patterns
>                 hi-lock-file-patterns))))
>    (funcall f)))

How does that go along with the documentation?  The documentation says
"(lambda (&rest r) (apply FUNCTION OLDFUN r))", whatever that means.
You have (f) instead of (&rest r), and "(apply FUNCTION OLDFUN r)" is
missing.  And if f refers to the original function, why not use a before
advice instead?  And I thought "let" limits the scope of the variable to
what is between its brackets.

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

What if you want to use one of the 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 ...).

What when you use find-file-noselect and the file cannot be visited?
The documentation only says it returns the buffer, not what it returns
when it fails.


-- 
Knowledge is volatile and fluid.  Software is power.