Sparse key maps garbage?

Sparse key maps garbage?

[Lennart Borgman (gmail)]

If you do

 (defvar my-sparse-map (make-sparse-keymap))
 (define-key my-sparse-map [f4] nil)

then there will be an entry with f4 in my-sparse-keymap. I do not think
that is used for anything. Is it? Should it be there?

Re: Sparse key maps garbage?

[Stefan Monnier]

> If you do

>  (defvar my-sparse-map (make-sparse-keymap))
>  (define-key my-sparse-map [f4] nil)

> then there will be an entry with f4 in my-sparse-keymap. I do not think
> that is used for anything. Is it? Should it be there?

Actually, IIRC it's (been) used at some places to create a place holder
in the keymap which is later on replaced with the actual binding.
But I do wonder why you care,


        Stefan


PS: Some other issues have to do with the delicate treatment of nil
bindings w.r.t inheritance: a nil binding will hide any other binding in
the parent(s).

Re: Sparse key maps garbage?

[Lennart Borgman (gmail)]

Stefan Monnier wrote:
>> If you do
> 
>>  (defvar my-sparse-map (make-sparse-keymap))
>>  (define-key my-sparse-map [f4] nil)
> 
>> then there will be an entry with f4 in my-sparse-keymap. I do not think
>> that is used for anything. Is it? Should it be there?
> 
> Actually, IIRC it's (been) used at some places to create a place holder
> in the keymap which is later on replaced with the actual binding.
> But I do wonder why you care,

I was looking a bit at how to undefine a key, for example at
local-unset-key. So what I really wondered was how do you undefine a
key? Is there a standard way to do that?

> PS: Some other issues have to do with the delicate treatment of nil
> bindings w.r.t inheritance: a nil binding will hide any other binding in
> the parent(s).
> 

Re: Sparse key maps garbage?

[Stefan Monnier]

>>> If you do
>> 
>>> (defvar my-sparse-map (make-sparse-keymap))
>>> (define-key my-sparse-map [f4] nil)
>> 
>>> then there will be an entry with f4 in my-sparse-keymap. I do not think
>>> that is used for anything. Is it? Should it be there?
>> 
>> Actually, IIRC it's (been) used at some places to create a place holder
>> in the keymap which is later on replaced with the actual binding.
>> But I do wonder why you care,

> I was looking a bit at how to undefine a key, for example at
> local-unset-key. So what I really wondered was how do you undefine a
> key? Is there a standard way to do that?

Depends how you define "un define a key".  Binding it to nil is such
a way.  Binding it to `undefined' is another.  Removing the binding from
the keymap is yet another (one that does not come with a ready-to-use
function for it).


        Stefan

Re: Sparse key maps garbage?

[Lennart Borgman (gmail)]

Stefan Monnier wrote:
> Depends how you define "un define a key".  Binding it to nil is such
> a way.  Binding it to `undefined' is another.  Removing the binding from
> the keymap is yet another (one that does not come with a ready-to-use
> function for it).


I am thinking of the last case. Shouldn't there be one for this case?
Using exactly the same parameters as define-key (minus the binding)?

Re: Sparse key maps garbage?

[Stefan Monnier]

>> Depends how you define "un define a key".  Binding it to nil is such
>> a way.  Binding it to `undefined' is another.  Removing the binding from
>> the keymap is yet another (one that does not come with a ready-to-use
>> function for it).

> I am thinking of the last case. Shouldn't there be one for this case?
> Using exactly the same parameters as define-key (minus the binding)?

What do you need it for?


        Stefan

Re: Sparse key maps garbage?

[Lennart Borgman (gmail)]

Stefan Monnier wrote:
>>> Depends how you define "un define a key".  Binding it to nil is such
>>> a way.  Binding it to `undefined' is another.  Removing the binding from
>>> the keymap is yet another (one that does not come with a ready-to-use
>>> function for it).
> 
>> I am thinking of the last case. Shouldn't there be one for this case?
>> Using exactly the same parameters as define-key (minus the binding)?
> 
> What do you need it for?


I have no need for it now. It just came to my mind because Xah asked how
to undow a (define-key map [remap ...] ...) binding.

You can do that of course, but having an undefine-key make the data
abstraction (is it called so?) better.

Re: Sparse key maps garbage?

[Stefan Monnier]

>>>> Depends how you define "un define a key".  Binding it to nil is such
>>>> a way.  Binding it to `undefined' is another.  Removing the binding from
>>>> the keymap is yet another (one that does not come with a ready-to-use
>>>> function for it).
>> 
>>> I am thinking of the last case. Shouldn't there be one for this case?
>>> Using exactly the same parameters as define-key (minus the binding)?
>> 
>> What do you need it for?

> I have no need for it now.

Thought so.  That's the reason why it doesn't exist.

> It just came to my mind because Xah asked how
> to undow a (define-key map [remap ...] ...) binding.

The answer is: (define-key map [remap ...] nil).

If you're worried that this will not quite undo it (i.e. in the case
that map's parent already had a [remap ...] binding), then you need to
do something like:

   (setq orig-map map)
   (setq map (make-sparse-keymap))
   (set-keymap-parent map orig-map)
   (define-key map [remap ...] ...))

so that you can undo the binding(s) with

   (setq map orig-map)     

> You can do that of course, but having an undefine-key make the data
> abstraction (is it called so?) better.

`undo' is not the same as `undefine-key'.


        Stefan

Re: Sparse key maps garbage?

[Lennart Borgman (gmail)]

Stefan Monnier wrote:
>>>>> Depends how you define "un define a key".  Binding it to nil is such
>>>>> a way.  Binding it to `undefined' is another.  Removing the binding from
>>>>> the keymap is yet another (one that does not come with a ready-to-use
>>>>> function for it).
>>>> I am thinking of the last case. Shouldn't there be one for this case?
>>>> Using exactly the same parameters as define-key (minus the binding)?
>>> What do you need it for?
> 
>> I have no need for it now.
> 
> Thought so.  That's the reason why it doesn't exist.
> 
>> It just came to my mind because Xah asked how
>> to undow a (define-key map [remap ...] ...) binding.
> 
> The answer is: (define-key map [remap ...] nil).
> 
> If you're worried that this will not quite undo it (i.e. in the case
> that map's parent already had a [remap ...] binding), then you need to
> do something like:
> 
>    (setq orig-map map)
>    (setq map (make-sparse-keymap))
>    (set-keymap-parent map orig-map)
>    (define-key map [remap ...] ...))
> 
> so that you can undo the binding(s) with
> 
>    (setq map orig-map)     

What Xah wanted was to remove some (define-key map [remap ...] ...)
bindings in an existing map. (Some map in cua-mode.)

This can not be done as above since you do not know for sure where that
keymap variable is used. You have to use your knowledge of the data
structures for sparse keymaps.

>> You can do that of course, but having an undefine-key make the data
>> abstraction (is it called so?) better.
> 
> `undo' is not the same as `undefine-key'.

Re: Sparse key maps garbage?

[Stefan Monnier]

> What Xah wanted was to remove some (define-key map [remap ...] ...)
> bindings in an existing map. (Some map in cua-mode.)

And why didn't he want to use (define-key map [remap ...] nil)?


        Stefan

Re: Sparse key maps garbage?

[Lennart Borgman (gmail)]

Stefan Monnier wrote:
>> What Xah wanted was to remove some (define-key map [remap ...] ...)
>> bindings in an existing map. (Some map in cua-mode.)
> 
> And why didn't he want to use (define-key map [remap ...] nil)?

Not sure what he did. And I did not test but I thought that one above
would end remapping to something like 'ignore.