Re: replacing a function with another one

[lee]

Michael Heerdegen <michael_heerdegen@web.de> writes:

> Michael Heerdegen <michael_heerdegen@web.de> writes:
>
>> Because it's trivial.
>
> I have the feeling that this might sound strange - but it's true!  So,
> here is some pseudo code that shows, in a simplified manner, what
> defining an around advice with `advice-add' does:
>
> (defun my-add-around-advice (fun-to-advice advice)
>   (lexical-let ((oldfun (symbol-function fun-to-advice))
>               (function advice))
>     (fset fun-to-advice
>         (lambda (&rest r) (apply function oldfun r)))))
>           
> FUN-TO-ADVICE is the function to advice, ADVICE is the piece of advice
> you want to add.  Do you recognize the line I cite all the time?  It's
> what you get as resulting combined function.
>
> Actually, it's not pseudo code but fully functional.
>
> An example.  Let's define the faculty (a non-recursive version):
>
> (defun my-fac (n) (reduce '* (number-sequence 1 n)))
>
> Suppose we want to make it return the faculty of -n for negative
> integers n by adding an around advice (currently it returns 1 for negative
> arguments).  With the above simple implementation, you would do it
> like that:
>
> (my-add-around-advice
>  'my-fac
>  (lambda (orig-fun n) (funcall orig-fun (abs n))))
>
> Then, e.g.
>
>   (my-fac -5)
>
>     ==> 120

That sounds like a cryptic way to do the `callinstead' I just suggested
in my previous post :)

> Of course, you can't remove the advice with my simplified version, etc.

And advice-add is lacking what defadvice has with the ability to enable
and to disable the advice.


(callinstead orig-fn new-fn (orig-arg0..orig-argN) :named 
"removable-callinstead")

(callinstead-remove "removable-callinstead")

(callinstead-add "removable-callinstead")


> With `advice-add' you would do
>
> (advice-add 'my-fac :around
>   (lambda (orig-fun n) (funcall orig-fun (abs n))))
>
> Let's add another around advice that makes `my-fac' print the result in
> the echo area.  This time using a named function as advice:
>
> (defun my-fac--print-result-around-advice (orig-fun n)
>   "Print result in the echo area."
>   (let ((result (funcall orig-fun n)))
>     (message "The faculty of %d is %d" n result)
>     (sit-for 3)
>     result))
>
> (my-add-around-advice 'my-fac #'my-fac--print-result-around-advice)
>
> These are not very useful examples, but hopefully they show a bit how it
> works, and one can play with them.  You also see how to deal with
> arguments and the return value of the original function.
>
> The other advice types can be implemented similarly.

I still don´t understand how it works.  Here´s another example:


lexical-let is a Lisp macro in `cl.el'.

(lexical-let BINDINGS BODY)

Like `let', but lexically scoped.
The main visible difference is that lambdas inside BODY will create
lexical closures as in Common Lisp.


So what is that supposed to mean? `let' keeps driving me insane already
because it requires so many brackets.  Then finally, I do something like


    (let ((end-marker (concat "^" comment-start 
lsl-hi-lock-patterns-end-marker))
      ((marker-pos (re-search-forward end-marker (point-max) t))))
      (do-stuff))


and it doesn´t work because end-marker is undefined despite I just
defined it :(  So I have


    (let ((end-marker (concat "^" comment-start 
lsl-hi-lock-patterns-end-marker)))
      (let ((marker-pos (re-search-forward end-marker (point-max) t)))
      (do-something)))


instead ...


And in the end, I´m left with the unanswerable question of how to
intentionally returning something in particular from a function:


(defun lsl-get-patterns-from-file (file)
  "Read hi-lock-mode highlighting-patterns from a file and return
the patterns read."
  (with-current-buffer
      (find-file-noselect file)
    (goto-char (point-min))
    (let ((end-marker (concat "^" comment-start 
lsl-hi-lock-patterns-end-marker)))
      (let ((marker-pos (re-search-forward end-marker (point-max) t)))
        (when marker-pos
          (goto-char marker-pos)
          (previous-line)
          (end-of-line)
          (setq marker-pos (point))
          (goto-char (point-min))
          (message "reading hi-lock patterns from %s (%d..%d)"
                   (buffer-name)
                   (point-min) marker-pos)
          (let ((patterns nil))
            (while (< (point) marker-pos)
              (setq patterns (append (read (current-buffer)) patterns)))
            (setq patterns patterns)))))))


I need this function to return `patterns'.  Without the last line, it
seems to return nil because the setq is enclosed in the while.


This is what I made from the example implementation you made.  That
really got me somewhere, and I don´t need to use advices anymore.

Then I found I want to be able to edit the patterns.  Editing them is
easier when there is one pattern per line, so I made it write one per
line and then found that they are suddenly much more difficult to
read.  Finally I got it to read them, just to find out that the function
doesn´t return them.


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