Irreal

I have long used 【Meta+p】 to recall previously entered information in the minibuffer. For example, when I’m editing Groff input it’s often convenient to typeset what I have so far to check that the result looks good or just to read what I’ve written without the markup. I do that by selecting the entire buffer with 【Ctrl+x h】, piping the buffer to groff with 【Meta+|】, and then specifying the command

groff -ms -pset -X | gxditview

It’s a pain to keep typing that so after the first time I just type 【Meta+p】 to bring up the pipeline again.

You can, of course, move forward in the minibuffer history with 【Meta+n】 but there are some other not so obvious ways of navigating the minibuffer. The command 【Meta+r】 regexp 【Return】 will search backward in the minibuffer history for the entry matching the regular expression regexp. Similarly, 【Meta+s】 regexp 【Return】 will search forward for the entry matching regexp. You can continue either of these searches to the next match with 【Meta+r Return】 or 【Meta+s Return】.

Finally, you can repeat the last echoed message with 【Ctrl+h e】

Summary

Update: 【Meta+s】 → 【Meta+n】 in summary

I’ve written a couple of times about Tim Visher’s VimGolf In Emacs series of videos. If you’re an Emacs user and haven’t taken a look at them yet, you should do so without delay. They are very informative and entertaining.

Now Mickey Petersen over at Mastering Emacs has gotten into the act. That makes me very happy because I really enjoy seeing how other Emacs users solve editing problems. I almost invariably learn something useful by watching or reading those solutions. Mickey’s take on the problems is a little different from Visher’s. He says up front that there’s no way Emacs is going to be as efficient in terms of keystrokes as Vim and instead he concentrates on finding a general—or as he says, technically correct—solution. By that he means a solution that works for bigger or smaller data. The problem with VimGolf solutions is that they tend to be crafted for the particular piece of data that’s being edited. That’s because in order to minimize keystrokes the solution has to be tailored to the specific data in the problem.

The problem that Mickey considers is to sort the following records into alphabetical order by people’s names.

## Directory
   * Smith, George
      - 1234 Avenue, New York, NY
   * Bailey, Stephen
      - 4545 Harbor Ln, Atlanta, GA
      - Phone: (412) 291-1238
   * Thomas, Brent
      - 1482 Mystic Oaks, Anaheim, CA
   * Grant, Jenny
      - 198 Circle Dr, Houston, TX
      - Phone: (213) 198-9842
      - Email: jenny.grant@gmail.com
   * Percy, Adam
      - 221 Jaguar Pkwy, Missoula, MT
   * Garfield, Misty
      - 5988 Apple Tree Ln, Memphis, TN
   * Parsons, Betty
      - Phone: (235) 523-2378
      - Email: bettyboop123@gmail.com
   * Sanders, Terry
      - Email: sanderst@yahoo.com
   * Smith, Pete
      - Phone: (294) 984-2938
   * Frost, Jennifer
      - 2498 Temple Terrace, Miami, FL
   * Matthews, Frank
      - 418 Happy Trail, Phoenix, AZ
      - Phone: (985) 129-2394
      - Email: frank@phoenixrealtors.net
   * Allen, Taylor
      - Email: allen.taylor@hotmail.com
   * McCullen, Sarah
      - 247 Hidden Elm, Seattle, WA
      - Phone: (288) 283-4568
   * Perkins, Mike
      - 992 Peartree Ln, Bowling Green, KY

Think for a second or two how you might do that in Emacs and then jump over to Mickey’s post to see how he leveraged the power of Org-mode to solve the problem. It’s a brilliant solution and with smex installed is probably competitive with the Vim solutions even without trying.

Back in September I wrote about using registers to open frequently accessed files. Shortly afterwards, someone recommended just saving my desktop with desktop-save-mode and I haven’t really used registers since. More recently, I started watching Tim Visher’s excellent VimGolf in Emacs videos. Video #4 talks about, among other things, saving window/frame configurations in registers that you can then jump to. That caught my imagination so I looked into the use and abuse of registers some more.

As the name suggests, registers can hold various types of objects. They can hold

• Positions
• Text
• Rectangles
• Window and Frame configurations
• Numbers
• File names

Each register has a single character name by which it can be accessed. Thus a register could be named 1, or a, or A, or Ctrl-a. Only Ctrl-g is off limits for obvious reasons.

Now let’s take a look at how they can be used. First up is saving positions. This can be handy if you want to repeatedly refer to, say, a function in one of the buffers. To save a position in register ρ you would put the point at the position you want to save and type 【Ctrl+x r Space ρ】. To return to that position from the same or another buffer you would type 【Ctrl+x r j ρ】. This works even if the buffer containing the position has been killed providing the buffer was associated with a file.

You can copy or move a region into register ρ with the command 【Ctrl+x r s ρ】 and insert it at point with the command 【Ctrl+x r i ρ】. That’s how I inserted the rho (ρ) into the text—I looked it up once and then copied it into register r so I didn’t have to keeping going through the ucs-insert routine.

If you give the 【Ctrl+x r s ρ】 command a prefix argument, it will delete the original region after copying it into the register.

There are two other less frequently used commands to store text to registers: 【Meta+x】 append-to-register 【Return】 ρ and 【Meta+x】 prepend-to-register 【Return】 ρ. These will append or prepend the region to the text already in register ρ. If you specify a prefix argument, the region will be erased after it is copied into the register.

You can copy a rectangle to register ρ with 【Ctrl+x r r ρ】 and insert it with 【Ctrl+x r i ρ】 as before. Just as with regions, specifying a prefix with the copy command will delete the original rectangle.

If you have a particular window configuration in the current frame your can save that configuration in register ρ with 【Ctrl+x r w ρ】 and you can later restore that configuration by jumping to it with 【Ctrl+x r j ρ】.

If you want to save the configuration of all frames and their windows in register ρ, use 【Ctrl+x r f ρ】.

Registers can also contain numbers. These numbers can be incremented, which make them useful for certain types of keyboard macros. To store N into register ρ, use 【Ctrl+u N Ctrl+x r n ρ】. To increment the number in register ρ by I use 【Ctrl+u I Ctrl+x r + ρ】.

You can insert the number in register ρ at point by using the usual insert command: 【Ctrl+x r i ρ】.

I’ve already dealt with storing file names in registers in the previous post linked above.

Summary

Mickey, over at Mastering Emacs, has a great post on Executing Shell Commands in Emacs and does his usual excellent job of explaining the fine points of his subject matter. I’ve written about some of this material here, but there’s lot of stuff I haven’t covered so you should definitely go read the post.

One of the things that was new to me was recursive minibuffers. What that means is that you can interrupt what you’re doing in the minibuffer to run some other command and then use it’s output in the original command. The need to do this doesn’t come up often—at least for me—but when it does it’s frustrating not to be able to do it. By default, the recursion is turned off but all you need do to enable it is to add

(setq enable-recursive-minibuffers t)

to your .emacs or init.el file.

Here’s a (slightly contrived) example of how you might use the capability. Suppose you’re one of those annoying bloggers who, unlike me, has a backlog of posts ready to publish and that you keep their file names in a file called scheduled. You want to load the top file into Emacs so that you can publish it with org2blog. You type 【Ctrl+x Ctrl+f】 to call find-file but realize you don’t know the first file on the list. You can load its name into the minibuffer for find-file (or ido-find-file) by typing 【Ctrl+u Meta+!】 and then head -1 scheduled. As Mickey explains, the output of most shell commands will have a newline at the end so you’ll need to delete it before pressing 【Return】.

Mickey gives another example of its use but I don’t want to step on his post by reiterating it here so, again, you should go read his post. If you have an interesting use case for this capability, leave a comment.