My Emacs tweaking tends to go in waves. I keep an eye on the Emacs subreddit and the Doom Discord channel on a fairly regular basis, but I try not to jump on every cool new package I see discussed there. Every now and again though, I see something interesting which coincides with an itch to tinker with Emacs, and away I go… This time, it was reading discussions about a constellation of relatively new packages concerned with incrementally narrowing lists (and other related functions) that caught my eye. This sounds very niche, but for many people (me included) being presented with a list of things and being able to type to incrementally narrow the list and then select something is a core part of the Emacs UI. Since I use Doom, and it offers you an easy way to choose either Ivy or Helm, I had been using Ivy, for the sake of easy configuration. Both are fine packages, but having tried both, I preferred Ivy’s more minimal interface, and the fact that it used the minibuffer rather than a buffer for completions. However, it — and the related packages, Counsel and Swiper — are somewhat complex and difficult to get to grips with. I was also not using all the features that they provided, so was curious if I would enjoy using something even simpler. That’s why I tried out Selectrum.
The Selectrum README page on GitHub gives an admirably thorough and clear
explanation about the niche that it is trying to fill, and how it compares to
other similar packages. What I like about it is that it tries to stick as
closely as possible to using Emacs’ standard APIs, so that once you enable it,
many standard Emacs commands (like
find-file) automatically use Selectrum. It
also doesn’t try to do everything, so it really only provides incremental
narrowing, leaving sorting and filtering (and actions to operate on the selected
candidate) to other packages. This means that you have a bit more package
installation and configuration to do up front, but it also means that you can
pick and choose which elements you need and leave the others, so you end up with
a simpler system. I chose to use the following additional packages:
prescient.el sorts choices in a more intelligent way, remembering your recent
selections and bubbling those to the top of the list. It also enables you to
toggle on and off different ways of matching a candidate (for example by the
initial letter of each word, or by regular expression). I have found
to work very well in practice. It also works with Ivy and Helm and other
incremental narrowing packages, so you can use it even if you don’t use
consult works with any function that works with Emacs’ built-in
function (including Selectrum). It is intended as a rough replacement for
counsel, and provides some useful functions for searching a buffer interactively
for text, searching headlines (in Org or Markdown files, or any mode that
outline-mode). It has a very handy function
the name, it is a multi-purpose function which enables you to search and select
among a list of buffers, files and bookmarks by default, so you don’t need
separate commands to search each of those categories. If you do want to filter
the list because you know you are searching for a buffer, not a file, for
example, you can prefix your search with ‘b’ (or ‘f’ for file, or ’m’ for
bookmark). I’ve found this so handy that I have bound it to Doom’s SPC SPC
binding for easy access. I previously often found myself searching for a buffer
first, before realising that I needed to search for a file as the buffer
containing that file wasn’t yet open. This stops me having to think about the
distinction, but allows me to narrow the list if I am sure.
marginalia adds ‘annotations’ to some of the lists presented by Selectrum. For example, if you use M-x it can add key-bindings and also docstrings to the list of commands. Ivy did this too, and I found it extremely useful.
embark is the package I am least sure about whether I will keep, but it is
handy. It enables you to hit a key-binding when you have a candidate selected in
a list and apply some action to the item. It knows whether the item is a file or
buffer or some other item, so it presents a list of appropriate actions for
each, like opening a buffer in the other window, or renaming a file. There are
of course many other ways to achieve this in Emacs, but I find that the method
of selecting something first, then choosing how to act on it works well for me.
It is also really simple to add new actions, and I added one to jump to the
dired buffer for a file. That was as simple as the snippet below in my config.el
use-package if you are not using Doom):
(use-package! embark :after selectrum :bind (:map minibuffer-local-map ("C-o" . embark-act) ("C-S-o" . embark-act-noexit) :map embark-file-map ("j" . dired-jump)))
Is it better than Ivy/Counsel/Swiper?
This setup doesn’t do anything that that Ivy and friends didn’t. It does some
things a bit differently, and in ways I prefer. The
presents Org headings in a way I find much easier to navigate, for example.
I am going to stick with these packages because I find the smaller,
more focused packages easier to understand and configure, and potentially to
extend as I need.
The other impressive thing about them is that the authors of each of the packages are talking to each other and trying to make their packages as inter-operable as possible and also as simple and discrete as possible. The Marginalia package was extracted from the Consult and Embark packages (which are maintained by different people), to reduce the overlap between them and ensure that you can mix and match the different components like Lego bricks to build your ideal setup. I find this an admirable position, which helps to keep users’ options open and improve all the tools. I’m going to watch the development of all these packages with interest.