Rebind key and save/reuse previous bound function

Rebind key and save/reuse previous bound function

[Joe Riel]

Is there a clean way save the function bound to a key
so that a new function can be created that is bound
to the same key, does something, then executes the
original bound function?   


-- 
Joe Riel

Re: Rebind key and save/reuse previous bound function

[Joe Riel]

On Thu, 29 Oct 2015 21:45:51 -0700
Joe Riel <joer@san.rr.com> wrote:

> Is there a clean way save the function bound to a key
> so that a new function can be created that is bound
> to the same key, does something, then executes the
> original bound function?   

key-binding will do what I described, and is probably what
theyI'll use, but what I think I really want
is something more akin to substitute-key-definition, but
which, rather than substituting a function, returns the
original function.  Does that exist?


-- 
Joe Riel

Re: Rebind key and save/reuse previous bound function

[Emanuel Berg]

Joe Riel <joer@san.rr.com> writes:

> The function key-binding will do what I described,
> and is probably what I'll use, but what I think
> I really want is something more akin to
> substitute-key-definition, but which, rather than
> substituting a function, returns the original
> function. Does that exist?

Instead of verbalizing this in half-baked terms of
techno-techno-technology, it'll be much easier for you
and us to understand and help if you just say what you
want to *do*.

I.e.:

    1. You are looking at Emacs.

    2. Your fingertips are at keys a, s, d, f
       and j, k, l, ;

    3. Your shoulders are relaxed (OK now, sorry :)

    4. What is it at this moment that you want to
       *do*, that you cannot?

Of course, feel free to speculate how to solve the
problem. Even if the theorizing is wrong it is still
better than doing nothing and if you put it into words
that will benefit the thought process and you will
look up information in doing so, *and* people won't
hesitate to tell you if you are wrong, which is
helpful to you and everyone else reading the post.

But before you do any of that, please do answer
question 4 or else the good intentions/activity will
much rather come to nothing.

And the beat goes on...  ((d[-_-]b))

-- 
underground experts united
http://user.it.uu.se/~embe8573

Re: Rebind key and save/reuse previous bound function

[Joe Riel]

On Thu, 29 Oct 2015 21:45:51 -0700
Joe Riel <joer@san.rr.com> wrote:

> Is there a clean way save the function bound to a key
> so that a new function can be created that is bound
> to the same key, does something, then executes the
> original bound function?   


The function key-binding will do what I described, and is probably
what I'll use, but what I think I really want is something more akin
to substitute-key-definition, but which, rather than substituting a
function, returns the original function.  Does that exist?


-- 
Joe Riel

RE: Rebind key and save/reuse previous bound function

[Doug Lewan]

That sounds like 'advice' to me. 
Try  info "(elisp) Advising Functions"  for details.
It begins with the following text that sounds like what you want
    The "advice" feature lets you add 
    to the existing definition of a function,....
-- 
,Doug
Douglas Lewan
Shubert Ticketing
(201) 994-4335

Nonfirstorderizability. It's a thing.


> -----Original Message-----
> From: help-gnu-emacs-bounces+dougl=shubertticketing.com@gnu.org
> [mailto:help-gnu-emacs-bounces+dougl=shubertticketing.com@gnu.org] On
> Behalf Of Joe Riel
> Sent: Friday, 2015 October 30 00:46
> To: Help GNU Emacs
> Subject: Rebind key and save/reuse previous bound function
> 
> Is there a clean way save the function bound to a key
> so that a new function can be created that is bound
> to the same key, does something, then executes the
> original bound function?
> 
> 
> --
> Joe Riel
> 

Re: Rebind key and save/reuse previous bound function

[John Mastro]

Joe Riel <joer@san.rr.com> wrote:
>
> Is there a clean way save the function bound to a key
> so that a new function can be created that is bound
> to the same key, does something, then executes the
> original bound function?

I don't think there's anything built-in that does exactly what you
describe, but there are a few alternatives for doing it and all are
pretty simple.

Something like this would probably be the most direct translation of
your description:

    (defun define-before (map key cmd)
      (let ((old (lookup-key map key)))
        (define-key map key
          (if (null old)
              cmd
            (lambda ()
              (interactive)
              (call-interactively cmd)
              (call-interactively old))))))

    (define-before global-map (kbd "C-n")
      (lambda ()
        (interactive)
        (message "Going to the next line!")))

However, I think using "before advice" is a nicer solution for this,
because it integrates well with `describe-function'.

    (defun my-next-line-advice (&rest args)
      (message "Going to the next line!"))

    (advice-add 'next-line :before #'my-next-line-advice)

The arguments your advice function receives will be the same as those
for the original function you're advicing, if any. Check the
documentation for `add-function' for a description of all the different
kinds of advice and what arguments the advicing function receives.

-- 
john

Re: Rebind key and save/reuse previous bound function

[Joe Riel]

On Sat, 31 Oct 2015 13:22:29 -0700
John Mastro <john.b.mastro@gmail.com> wrote:

> Joe Riel <joer@san.rr.com> wrote:
> >
> > Is there a clean way save the function bound to a key
> > so that a new function can be created that is bound
> > to the same key, does something, then executes the
> > original bound function?
> 
> I don't think there's anything built-in that does exactly what you
> describe, but there are a few alternatives for doing it and all are
> pretty simple.
> 
> Something like this would probably be the most direct translation of
> your description:
> 
>     (defun define-before (map key cmd)
>       (let ((old (lookup-key map key)))
>         (define-key map key
>           (if (null old)
>               cmd
>             (lambda ()
>               (interactive)
>               (call-interactively cmd)
>               (call-interactively old))))))
> 
>     (define-before global-map (kbd "C-n")
>       (lambda ()
>         (interactive)
>         (message "Going to the next line!")))
> 
> However, I think using "before advice" is a nicer solution for this,
> because it integrates well with `describe-function'.
> 
>     (defun my-next-line-advice (&rest args)
>       (message "Going to the next line!"))
> 
>     (advice-add 'next-line :before #'my-next-line-advice)
> 
> The arguments your advice function receives will be the same as those
> for the original function you're advicing, if any. Check the
> documentation for `add-function' for a description of all the different
> kinds of advice and what arguments the advicing function receives.

Thanks.  Another user also suggested using advice.
I followed that advice 8-).



-- 
Joe Riel

Re: Rebind key and save/reuse previous bound function

[Emanuel Berg]

Joe Riel <joer@san.rr.com> writes:

> Thanks. Another user also suggested using advice.
> I followed that advice 8-).

I'd say, if your ads are that poor, it is a vice
using them.

*rumbling laughter*

:)

-- 
underground experts united
http://user.it.uu.se/~embe8573