Exit completion when only one candidate is left?

[gtms]

I recently started using consult after years of using ivy. I am mostly happy with the swap, but there's a bit of functionality I haven't been able to replace from my previous configuration. It's a little function that implements this idea with ivy-read:

(defun me/bookmark-headlong (bookmark)
    "Jump headlong to BOOKMARK.

Only bookmarks with a colon in their name are offered for
completion.  Calls `ivy-done' automatically when completion
candidates have been narrowed down to one."
    (interactive
     (let ((collection
            (progn
              (require 'bookmark)
              (seq-filter
               (apply-partially #'string-match ":")
               (bookmark-all-names)))))
       (list (ivy-read "Headlong to: "
                       collection
                       :require-match t
                       :history 'bookmark-history
                       :initial-input "^"
                       :sort #'string<
                       :update-fn (lambda ()
                                    (and ivy--old-cands
                                         (null (cdr ivy--old-cands))
                                         (ivy-done)))
                       :re-builder #'ivy--regex
                       :caller #'me/bookmark-headlong))))
    (bookmark-jump bookmark))

There are two features here I can't seem to reenact with consult--read/completing-read:

  1. The ability to pass a function to sort the collection offered for completion (I've played with the metadata alist and programmed completion to no avail, and passing the sort function to consult--read does not seem to work);
  2. The ability to pass an "update function" to be run each time the candidate list is re-displayed.  This is what allows for completion to exit when only one candidate is left.

Is there any way to implement this with consult/completing-read?

[minad]

I suggest to implement this on the level of the completion UI. For example in Vertico you could add an after advice to vertico--update and check if only a single candidate is left.

[gtms]

Not the user facing option I was looking for but thank you for your input.

[minad]

You can also use the :state argument of consult--read, but it is the wrong tool to implement the "headlong" feature. The completion UI is the better place to implement this.

EDIT: Hmm, however the state function is only called on candidate selection change but doesn't have direct access to all the candidates. So repeating myself, it seems that the only and correct place to implement this easily is in the UI.

[oantolin]

Passing a :sort keyword argument to consult--read should definitely work. What exactly went wrong when you tried it? (Bear in mind that the completion style can resort, as can the completion UI; for example flex resorts candidates to but "better" matches higher, and Vertico does too to put recently used candidates higher.)

[gtms]

This:

(consult--read (bookmark-all-names) :sort #'string<)

does not sort the completion candidates lexicographically. I then search the doc string for consult--read and find this:

SORT should be set to nil if the candidates are already sorted.

The user is left wondering. Compare with ivy-read, which does as it says.

[oantolin]

I apologize, I misremembered what consult--read's sort option does. You don't pass it a function, just a boolean. You need to sort in the completion table's metadata, as in Oleh's code you posted below. I'm sorry for the mix up.

[minad]

The :sort option is only there to enable/disable UI sorting. The following is more efficient:

(consult--read (seq-sort-by #'identity #'string< (bookmark-all-names)) :sort nil)

[oantolin]

Does that need a :sort nil in the consult--read call, @minad?

[gtms]

@oantolin yes it does, which makes things even more confusing for the user. How many symbols are to be passed to the keyword?
@minad perhaps that docstring is in need of some clarification?

[oantolin]

You can headlongify any minibuffer completion session for any "Emacs-compliant" completion UI as follows:

(defun headlong ()
  "Make the current minibuffer completion exit when there is 1 candidate."
  (add-hook 'after-change-functions
            (lambda (&rest _)
              (let* ((all (completion-all-completions
                           (minibuffer-contents)
                           minibuffer-completion-table
                           minibuffer-completion-predicate
                           (max 0 (- (point) (minibuffer-prompt-end)))))
                     (last (last all)))
                (when last (setcdr last nil))
                (when (and all (null (cdr all)))
                  (delete-minibuffer-contents)
                  (insert (car all))
                  (exit-minibuffer))))
            nil t))

This should work with default completion, Vertico and Icomplete (but I did not test extensively). Just call headlong from the minibuffer at the start of the completion session, minibuffer-with-setup-hook can be handy for that. Try this for example:

(minibuffer-with-setup-hook #'headlong (call-interactively #'find-file))

[minad]

@oantolin Your headlong function works for me.

[oantolin]

(If you are concerned about eficiency, @minad's suggestion of doing the headlongifying at the completion UI level is much better since you can avoid recomputing all completions.)

[gtms]

Thanks Daniel & Omar, but this is not really helping to fix my issue :(

I went back to the original headlong functionality written by Oleh in 2015, and this works:

(defun headlong-bookmark-jump (bookmark)
    "Jump to BOOKMARK headlong."
    (interactive
     (progn
       (require 'headlong)
       (require 'bookmark)
       (list (headlong-with
              (completing-read "Headlong to: "
                               (presorted-completion-table
                                (sort (bookmark-all-names) #'string<))
                               nil t)))))
    (bookmark-jump bookmark))

  (defun presorted-completion-table (completions)
    "Collection function for `completing-read'.

Prevent `completing-read' from sorting COMPLETIONS."
    (lambda (string pred action)
      (if (eq action 'metadata)
          `(metadata (display-sort-function . ,#'identity))
        (complete-with-action action completions string pred))))

Provided vertico-mode is off . . .

[minad]

The function given by @oantolin in #859 (comment) works as expected for me. If a single candidate matches, it will submit that.

[gtms]

Can you help me figure out a top level form that would let me complete bookmarks headlong with it? Seems like we're nearly there . . .

[oantolin]

I'm on my phone so I haven't tested it but it should be something like this, @gtms:

(minibuffer-with-setup-hook #'headlong
  (consult--read (seq-sort-by #'identity #'string< (bookmark-all-names)) :sort nil))

[gtms]

@oantolin sweet! It works :)

For the sake of completness:

(defun bookmark-jump-headlong (bookmark)
  "Jump to BOOKMARK headlong."
  (interactive
   (progn
     (require 'bookmark)
     (list (minibuffer-with-setup-hook #'headlong
             (consult--read
              (seq-sort-by #'identity #'string< (bookmark-all-names))
              :sort nil)))))
  (bookmark-jump bookmark))

@minad & @oantolin: many thanks to both of you for your feedback & congrats on the superb work :)