GNU Readline for Better Productivity on the Command Line

There are (at least) 3 ways to do this:

- `term` and `ansi-term` act as terminal emulators; they run a normal shell, like bash, and act much like e.g. `xterm`. You can even use curses-based programs. I don't use this as I find it quite clunky, since normal Emacs navigation and editing doesn't work (since the key combos would conflict with those used by the shell and applications).

- `eshell` is the opposite extreme: it's a shell which you use instead of bash and friends. It has nice features like piping to a buffer, running Elisp (if that's what you're into) and (my favourite) using TRAMP to invoke SSH and sudo. I tend not to use it much other than for TRAMP. The most obvious problem is the limited support for piping.

- `shell` is half way between. It runs a normal shell like bash, but Emacs keeps control over the buffer. This means we can't use things like curses, but we can navigate and edit the buffer contents just like any other.

Emacs `shell` is my "default" terminal; I currently have 24 shell buffers open. For things like curses, I use a separate `st` window running DVTM.

As a bonus, we can actually use `shell` and TRAMP together: we first use TRAMP to connect somewhere, e.g. `/ssh:me@remote:/home/me` (we can do this using `cd` in `eshell`, or using `dired` mode, or whatever), then from there we invoke `shell`. We'll be dropped into a remote shell, just as if we'd run `ssh`, but Emacs will be able to do things like tab-completion for the remote system.

If I'm using bash on a machine I don't control, I can type "set -o vi" at the bash prompt to get the same thing temporarily, and that's usually the first thing I type.

I also like to use rlwrap[1] to get readline editing and command history on terminal apps that aren't readline aware and don't have history of their own.

Most of the time, though I spend in zsh, which is not readline-based but has its own readline-like capabilities. There I have ^R bound to reverse history search, and ^E to edit the current line in my $EDITOR.

In addition to this, I use fzy[2] (which I prefer over fzf[3]) to do fuzzy searches over my shell history with something like:

  history 0 | perl -p -E's/^\s*\S+\s*//' | sort -u | fzy --lines=$LINES

[2] - https://github.com/jhawthorn/fzy/

[3] - https://github.com/junegunn/fzf

[0] https://github.com/hanslub42/rlwrap

    ~/Library/KeyBindings/DefaultKeyBinding.dict

As an aside, personal opinion: the separation of Control and Command on macOS is the one thing I love as it makes for a very consistent interface whether I'm in a terminal or in an application.

[0]: https://github.com/ttscoff/KeyBindings

One of the first things I install on Windows.

For example: https://news.ycombinator.com/item?id=5086837

Both editline and readline are large, too large to be compiled into every program that could benefit from REPL.

The answer to the bloat is linenoise. Great project.

But then there are all the programs that already have the readline bloat compiled in. How to replace it with something smaller? Can this be done?

There is another editline, not NetBSD's editline. It may predate the web, as it was originally distributed via Usenet. I do not recall it ever being discussed on HN. I suspect the original author probably has an HN account.

From Github:

   *call compatible with GNU readline*

   small size (<30K)

   originally developed for older UNIX and Plan 9

   forked from Minix 3, not related to NetBSD editline

   does not rely on libtermcap/curses

socat can function as a replacement for rlwrap, something like:

   socat -t0 readline exec:q

Perceptually I find socat readline exits faster than rlwrap. The later always feels a bit sluggish. Same for libtecla's enhance.

Is there a linenoise-based replacement for rlwrap?

That should read CTRL-y to put back the command I just deleted.

The more emacsian way of saying that you removed a line segment from a buffer and put it on the clip-board is to say that you yank the line rather than you kill the line.