[PATCH] emacs: When completing tags, offer each tag once

classic Classic list List threaded Threaded
6 messages Options
David Edmondson David Edmondson
Reply | Threaded
Open this post in threaded view
|

[PATCH] emacs: When completing tags, offer each tag once

When prompting for one or more tags to add or remove to/from one or
more threads, ensure that the set of tags offered for completion
contains no duplicates.

Some completion packages (e.g. selectrum) will include every member of
the offered list, resulting in the same tag being indicated as a
possibility several times.
---
 emacs/notmuch.el | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/emacs/notmuch.el b/emacs/notmuch.el
index 26efcccd..ceec5b5d 100644
--- a/emacs/notmuch.el
+++ b/emacs/notmuch.el
@@ -572,12 +572,20 @@ thread."
 (defun notmuch-search-get-tags (&optional pos)
   (plist-get (notmuch-search-get-result pos) :tags))
 
+(defun notmuch-search-uniq-tags (tags)
+  (let (result)
+    (mapc (lambda (tag)
+    (unless (member tag result)
+      (push tag result)))
+  tags)
+    result))
+
 (defun notmuch-search-get-tags-region (beg end)
   (let (output)
     (notmuch-search-foreach-result beg end
       (lambda (pos)
  (setq output (append output (notmuch-search-get-tags pos)))))
-    output))
+    (notmuch-search-uniq-tags output)))
 
 (defun notmuch-search-interactive-tag-changes (&optional initial-input)
   "Prompt for tag changes for the current thread or region.
--
2.29.2
_______________________________________________
notmuch mailing list -- [hidden email]
To unsubscribe send an email to [hidden email]
David Bremner-2 David Bremner-2
Reply | Threaded
Open this post in threaded view
|

Re: [PATCH] emacs: When completing tags, offer each tag once

David Edmondson <[hidden email]> writes:
>  
> +(defun notmuch-search-uniq-tags (tags)
> +  (let (result)
> +    (mapc (lambda (tag)
> +    (unless (member tag result)
> +      (push tag result)))
> +  tags)
> +    result))

I leave elisp style to others...

Is there some bound on the length of tags? Otherwise this seems like
it's potentially a bit slow?

d
_______________________________________________
notmuch mailing list -- [hidden email]
To unsubscribe send an email to [hidden email]
David Edmondson David Edmondson
Reply | Threaded
Open this post in threaded view
|

Re: [PATCH] emacs: When completing tags, offer each tag once

On Monday, 2021-02-01 at 11:49:36 -04, David Bremner wrote:

> David Edmondson <[hidden email]> writes:
>>  
>> +(defun notmuch-search-uniq-tags (tags)
>> +  (let (result)
>> +    (mapc (lambda (tag)
>> +    (unless (member tag result)
>> +      (push tag result)))
>> +  tags)
>> +    result))
>
> I leave elisp style to others...

Me too :-)

> Is there some bound on the length of tags? Otherwise this seems like
> it's potentially a bit slow?

No, there isn't any bound. I'd be surprised to see lists longer than low
tens of elements.

For similar functionality the dash library provides `-distinct', which
uses a lookup table if there are more than 32 elements in the list,
claiming that this is the break-point for the hash based approach to be
faster.

I'm a bit loath to just re-implement that. Am I allowed to depend on
dash? (I'd guess not, but figured that it's worth asking.)

dme.
--
Why stay in college? Why go to night school?
_______________________________________________
notmuch mailing list -- [hidden email]
To unsubscribe send an email to [hidden email]
Tomi Ollila-2 Tomi Ollila-2
Reply | Threaded
Open this post in threaded view
|

Re: [PATCH] emacs: When completing tags, offer each tag once

On Mon, Feb 01 2021, David Edmondson wrote:

> On Monday, 2021-02-01 at 11:49:36 -04, David Bremner wrote:
>
>> David Edmondson <[hidden email]> writes:
>>>  
>>> +(defun notmuch-search-uniq-tags (tags)
>>> +  (let (result)
>>> +    (mapc (lambda (tag)
>>> +    (unless (member tag result)
>>> +      (push tag result)))
>>> +  tags)
>>> +    result))
>>
>> I leave elisp style to others...
>
> Me too :-)
>
>> Is there some bound on the length of tags? Otherwise this seems like
>> it's potentially a bit slow?
>
> No, there isn't any bound. I'd be surprised to see lists longer than low
> tens of elements.
>
> For similar functionality the dash library provides `-distinct', which
> uses a lookup table if there are more than 32 elements in the list,
> claiming that this is the break-point for the hash based approach to be
> faster.
>
> I'm a bit loath to just re-implement that. Am I allowed to depend on
> dash? (I'd guess not, but figured that it's worth asking.)

list-packages doesn't tell whether dash is from elpa or from melpa --
nevertheless so far notmuch hasn't even required anything from elpa,
so I'd default to 'no'.

Anyway, I'd guess this is fast enough for the vast majority of the
specific use cases of this feature (dash is more generic(?)), and there
are worse hiccups elsewhere (although such is never an excuse to make
other code slow).

Tomi

>
> dme.
> --
> Why stay in college? Why go to night school?
_______________________________________________
notmuch mailing list -- [hidden email]
To unsubscribe send an email to [hidden email]
David Bremner-2 David Bremner-2
Reply | Threaded
Open this post in threaded view
|

Re: [PATCH] emacs: When completing tags, offer each tag once

Tomi Ollila <[hidden email]> writes:

> On Mon, Feb 01 2021, David Edmondson wrote:
>
>> On Monday, 2021-02-01 at 11:49:36 -04, David Bremner wrote:
>>
>>> David Edmondson <[hidden email]> writes:
>>>>  
>>>> +(defun notmuch-search-uniq-tags (tags)
>>>> +  (let (result)
>>>> +    (mapc (lambda (tag)
>>>> +    (unless (member tag result)
>>>> +      (push tag result)))
>>>> +  tags)
>>>> +    result))
>>>
>>> I leave elisp style to others...
>>
>> Me too :-)
>>
>>> Is there some bound on the length of tags? Otherwise this seems like
>>> it's potentially a bit slow?
>>
>> No, there isn't any bound. I'd be surprised to see lists longer than low
>> tens of elements.
>>
>> For similar functionality the dash library provides `-distinct', which
>> uses a lookup table if there are more than 32 elements in the list,
>> claiming that this is the break-point for the hash based approach to be
>> faster.

Maybe delete-dups (subr.el) would be useful here? It is destructive, but
even with a copy (if needed), it should still be faster.

d
_______________________________________________
notmuch mailing list -- [hidden email]
To unsubscribe send an email to [hidden email]
Tomi Ollila-2 Tomi Ollila-2
Reply | Threaded
Open this post in threaded view
|

Re: [PATCH] emacs: When completing tags, offer each tag once

On Tue, Feb 02 2021, David Bremner wrote:

>
> Maybe delete-dups (subr.el) would be useful here? It is destructive, but
> even with a copy (if needed), it should still be faster.

I looked the implementation of delete-dups. In case of >100 elements, it
uses hash table for checking duplicates. less than 101 elements and
the code is

      (let ((tail list))
        (while tail
          (setcdr tail (delete (car tail) (cdr tail)))
          (setq tail (cdr tail))))))

It took me a bit of time to understand, but then I got it:

* delete all elements that match car of tail in the list of (cdr tail)
* set tail to cdr of tail
* redo until tail exhausted

setcdr and delete are built-in functions implemented in c code

(and copy-sequence, unsurprisingly, is implemented in c (if needed))

>
> d

Tomi
_______________________________________________
notmuch mailing list -- [hidden email]
To unsubscribe send an email to [hidden email]