embark VS marginalia

embark. The one I always struggle to explain, so instead go read u/karthink's wonderful blog post about it! Prodded by u/minad-emacs, I just released version 1.0! 🎉

using embark, you need to set a keybind to embark, then use the ripgrep normally, when the minibuffer returns the results, call the embark via keybind and use embark-export, that is bind to E, then embark will create a buffer with the results from minibuffer

There seems to be some problem with straight not correctly installing or updating compat. See these issues on Marginalia and Embark where straight seems to not install Compat.

Surfingkeys looks pretty similar (though I have yet to try it); I'm just describing the experience poorly. You press f, little labels show up on the links (I called this "listing the links"), and you then press the keys on the label (the "select from" part). Probably me using the open in new tab command F (as opposed to open in current tab command f) did not help.

Not saying it's a bad experience. I find it's quite nice if I'm currently looking at the correct link so I can get the letters from the label easily.

It's just a different paradigm. If I didn't know what a link was, I wouldn't know that I could press f to open the link selection. This means I can't select a link unless I had a "select unknown" button, and then use that to inspect it.

Select unknown can be done with the keyboard: Emacs' embark[^1] is a good example of it. You use search/arrows to go to an interesting piece of text (e.g something underlined), run embark, and it lists all the potential things you can do with it (e.g open in external browser, or download an archived copy). It's just that keyboard UIs do not tend to be geared around it.

That though is the sort of thing the mouse is good at: you see something interesting, you prod it to see what you can do with it.

Say you saw a phrase you didn't understand in the browser. Currently, with a mouse you'd highlight it, right click, and then select the search with search engine option. With keyboard you'd open the search engine, and enter the phrase. Both get you to the same place.

Now if we extend the mouse to have a "I would like to know idioms better" option. You could just select the phrase, right click, and a definition could be there waiting for you next to the context menu. It could even be there on hover.

With the keyboard though, you'd generally run an "I would like to know idioms better" command. This would then ask you which idiom on the page would you like to understand. You then select it, and presto. A faster version could potentially have idiom meanings show up the moment you ran the command by a similar hover effect (or just listing all discovered idioms in a popup etc).

One of the differences here though is that from the mouse you still have a list of actions on the text open, so maybe if you liked the definition you could then copy the phrase.

This certainly could be done from the keyboard UI: just have it list other applicable commands that could be run on the selection generated from the command that searched for phrases. No reason why it could not then spawn something asking if you wanted to "(c)opy, c(u)t" etc like the context menu.

But that is only visible because there was a phrase you didn't know. If you didn't know that there was a command to define phrases, you wouldn't have found out. In theory you could have commands register everything they could act on, and then have another command let the user select an interactive thing, and list the commands that registered for it. I think that would be overwhelming though, as something like a dictionary command would register for every word.

Ultimately the mouse is just different then the keyboard, and I think that discarding it because you majorily use a keyboard is missing the interesting potential of having a tool that can interrogate arbitrary things on your screen.

[1]: https://github.com/oantolin/embark

It also comes with “batteries included,” containing several integrations with noteworthy packages, in particularEmbark, that you can take advantage of for nimbly interacting with your configs and clusters.

I have a cheap way to do this involving Embark and Consult: use consult-imenu as an embark action on an identifier. (You need consult-imenu here because it flattens the imenu hierarchy). Say you bind embark-act to C-., then you can put point on an identifier and type C-. C i and embark will run consult-imenu for you, type the identifier at the minibuffer prompt automatically, and if there is a single matching item, press RET for you too. (If more than one item matches, then you must select among them and press RET.)

I use embark and one of the options it gives on find-file is to open it via sudo (C-. s for me, and I think that's default bindings). So I would browse to the host at /ssh::/etc/foo/bar.conf and rather than just opening it hit C-. s.

I dunno—I like how Vertico+Counsel feel. I'm not sure how good the support for Orderless and Embark are in Ivy, but I really like how those packages compose so nicely with the Vertico+Consult ecosystem.

IV) Might there be a way to implement changing the sort order while the completing-read prompt is active? Or might it be a good idea to abandon completing-read completely for this and other features, like live editing? I am aware that some of this can be accomplished with Embark. Org tables and some other Emacs table libraries also go some way in this direction. The dream would be to have citar-like dynamic table construction + filtering + selection and Excel-like sorting + editing. Is anyone aware of any other package that goes into this direction?

Check out marginalia[1]. Whenever you press M-x, it will pop up a buffer showing all the commands (with most recent ones on top) along with their keybindings and a brief description of what they do.

Embark[2] is also cool. It will show all the possible commands relevant to where the cursor is at that moment. I bind it to C-c a.

[1] https://github.com/minad/marginalia

Then there is Marginalia which is IMO essential

marginalia. Informative annotations for minibuffer completion candidates, co-written with u/minad-emacs.

Wow, interesting that my response is getting down voted. It seems not enough that I give away my work for free. Nevertheless I appreciate support from the community, as other Emacs package developers. The support is actually helpful. To clarify, publishing my configuration would translate into quite a bit of work, requiring separation of private and public bits.

marginalia for extra info in the minibuffer

There seems to be some problem with straight not correctly installing or updating compat. See these issues on Marginalia and Embark where straight seems to not install Compat.

Note that I contribute to Emacs core itself from time to time but the process is discussion-heavy and thus time consuming. If you are familiar with the completing-read API, you may know the annotation-function of completion tables. The name already tells that this function just adds annotations to the completion candidates. The Marginalia package (written by /u/oantolin and me) provides such annotations. A similar function is the group-function, which groups candidates in subsets and adds titles above the subsets. I wrote the patch which added this feature to Emacs. It is now supported by default completion, Icomplete, Vertico and maybe other UIs. The initial implementation was done in the earlier Selectrum package, and a little later in Vertico.

At the end of the year, I am happy to announce the stable Vertico 1.0 and Marginalia 1.0 releases. Vertico is a minimalist, yet flexible and responsive vertical completion UI. Marginalia provides helpful annotations for many completion contexts. Both packages have been solid for a while but I rather let things mature slowly. These releases finally put the stamp "stable" on these two packages. I expect the other members of the package suite to follow soon after. Both packages have been updated recently to support the newest Emacs 29 features. They are compatible with Emacs 27, 28 and the upcoming 29.

I) I started out trying to implement this using marginalia, like the consult commands, but quickly concluded that this wasn't the way to go here... please correct me if I'm wrong and there is more from these packages I could make use of. I also try to make use of as much of the citar codebase as possible, but have found it difficult so far: a lot seems too specific for bibliographic entries.

I can't find anything that seems to discuss them in detail, but Marginalia is a package that applies them widely in completion. And here is a simple example for customized file completion.