[Top][All Lists]

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

Re: replacing a function with another one

From: lee
Subject: Re: replacing a function with another one
Date: Wed, 12 Mar 2014 15:48:46 +0100
User-agent: Gnus/5.13 (Gnus v5.13) Emacs/24.3.50 (gnu/linux)

Michael Heerdegen <address@hidden> writes:

> Michael Heerdegen <address@hidden> 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 

(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 
      ((marker-pos (re-search-forward end-marker (point-max) t))))

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

    (let ((end-marker (concat "^" comment-start 
      (let ((marker-pos (re-search-forward end-marker (point-max) t)))

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."
      (find-file-noselect file)
    (goto-char (point-min))
    (let ((end-marker (concat "^" comment-start 
      (let ((marker-pos (re-search-forward end-marker (point-max) t)))
        (when marker-pos
          (goto-char marker-pos)
          (setq marker-pos (point))
          (goto-char (point-min))
          (message "reading hi-lock patterns from %s (%d..%d)"
                   (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.

reply via email to

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