Irreal

Seven or eight years ago when Tim Visher was still producing his VimGolf in Emacs videos, one of his favorite tricks was using the full power of Emacs keyboard macros. Most Emacs users know about keyboard macros and can manage straightforward applications of them to perform a repetitive task. Visher, though, was a master and knew how to use them interactively to accomplish amazing things.

One of his tricks was to place a prompt for a query in the middle of a macro that would allow the user to perform some special action specific to the current item the macro was on (see this episode for example). I learned those methods at the time but because I seldom have need to use them, I’ve mostly forgotten about them.

Happily, Marcin Borkowski (mbork) recently posted an update to his previous post on keyboard macros that I wrote about last week. In his new post, he talks about pausing a macro and also about adding a query prompt that allows you to enter a recursive edit and perform an action unique to the current item. It’s really great to be reminded of this because while I may not need it often, when I do it’s extraordinarily useful. Take a look at Borkowski’s post for details on how to add a query to a macro. As I say, you probably won’t need it too often but when you do, you’ll be glad you now how.

UPDATE [2019-07-10 Wed 13:43]: Added link to Borkowski’s post.

Marcin Borkowski (mbork) has an interesting post on Emacs keyboard macros in the wild. He had a seemingly conventional repetitive editing task that he wanted to accomplish via Emacs keyboard macros but a few problems came up. It’s a nice example of solving small problems as they occur.

What really surprised me, though, was that Borkowski discovered a way of turning a function into a command without altering its source code. If you’re vague on the difference between a function and a command, it’s essentially that you can call a command with Meta+x <command-name> while a function can be called only from other Elisp code. The way to turn a function into a command is to add an interactive special form to the beginning of the function.

That means it’s easy to make an Emacs function into a command since we have access to the source code. But who wants to go mucking around with Emacs source code, especially if it’s a temporary change? It turns out that there’s an easier way. Although this is documented at the “interactive” link above, it came as a surprise to me. Indeed, the documentation notes dryly that “This feature is seldom used.”

Take a look at Borkowski’s post to see how it’s done. It’s dead simple and a nice technique to have in your Emacs toolbox even if you seldom use it.

Extremeaxe5 has a question:

Hardcore emacs users, what rules do you use to separate what you do from within emacs / what you do outside of e https://t.co/TwgxVlW89k #Emacs

— Emacs BOT (@emacsbot) July 2, 2019

For me the answer is simple. If I can do it in Emacs, I do do it in Emacs. Actually, that’s not quite right. I suppose I could browse the Web from Emacs but that just doesn’t work well enough to make it worthwhile most of the time. Other than Web browsing I can’t think of anything that I could do in Emacs that I’m not doing in Emacs.

Mike Zamansky has his own answer: “If I can do it better in Emacs I use Emacs. Otherwise, I use Emacs.” Many other commenters agree.

The reasons for staying within Emacs as much as possible are well known and I’ve written about them before. The big ones for me are avoiding context switches and leveraging my Emacs muscle memory. Emacs über alles isn’t for everyone, of course, but has become a way of life for many of us. I’ve come to feel vaguely uncomfortable if I find myself entering text outside of Emacs.

If you’ve been paying attention to the Emacs scene, you may have heard about Polymode, a package that lets you have two or more active major modes associated with a buffer. The first question to occur to many is, “Why would I want that?”

Not to worry, the incomparable Mickey is here to explain it all. There are, it turns out, legitimate use cases for multiple major modes in a single buffer. I’m an old-timey, backend sort of guy so I’ve been spared having to deal with those use cases but for those not so fortunate, Polymode can be a real win.

The basic idea is that you want to deal with two (or more) different languages in the same buffer—Mickey uses the example of Python and SQL. The indentation and font-locking are, of course, different for the two languages and you’d like Emacs to do the right thing automatically. That’s what Polymode does. It detects where one language leaves off and another starts and adjusts the operative major mode accordingly. A configuration that handles a given set of languages is called a “polymode.”

The bad news is that although there are, apparently, a few polymodes already written, by and large you’re going to have to write your own for most things. The good news is that writing a new polymode is pretty simple and generally takes just a few lines. Mickey’s post shows how it’s done by creating a Python/SQL polymode. Doubtlessly, more prebuilt polymodes will start to appear once the package starts getting traction.

If the need for this or the ideas behind it are unclear to you, take a look at Mickey’s post. As usual, he does an excellent job of explaining everything. As a bonus, if you’re not British, you may, like me, learn a new word: bijou. How can you lose?