Eschewing Zshell for Emacs Shell

A shell is a command-driven REPL. You type in a command and view the results, type in another command…rinse and repeat. Fine until you type something you expect to have a few lines, but if it responds with hundreds of lines, you redo the command and pipe it through less.

But with EShell, you don’t need to bother with a pager, since if you received too much information, hit C-c C-p which jumps you to the top of the last command, and then C-v your way down. Or better yet, just search for what you want. EShell means every command goes through the Emacs pager.

To be even cooler, try the Plan 9-like approach using the Eshell smart display, where you automatically begin at the top of the command until you type a non-cursor-movement key.

The Emacs Shell has a few other advantages:

• Since it is written in Emacs Lisp, it has the same shell behavior between different operating systems.
• Along with access to all your scripts and programs, you also have access to Emacs functions … write your shell scripts in Lisp? Sure!
• Craft and extend your shell experience.

Eshell’s primary disadvantage shows when a program attempts to control the terminal.¹

While you might have tried EShell in the past, I doubt you inhaled and noticed its uniqueness. Let’s level up…

Since my workflow is driven from Emacs, shells are temporary. I pop out to a shell for a few commands, and then return to my work. When I say pop out to the shell, I use the following function which creates a buffer-specific window in the lower third portion and start Eshell (which picks up that buffer’s directory).

(defun eshell-here ()
  "Opens up a new shell in the directory associated with the
current buffer's file. The eshell is renamed to match that
directory to make multiple eshell windows easier."
  (interactive)
  (let* ((parent (if (buffer-file-name)
                     (file-name-directory (buffer-file-name))
                   default-directory))
         (height (/ (window-total-height) 3))
         (name   (car (last (split-string parent "/" t)))))
    (split-window-vertically (- height))
    (other-window 1)
    (eshell "new")
    (rename-buffer (concat "*eshell: " name "*"))

    (insert (concat "ls"))
    (eshell-send-input)))

(global-set-key (kbd "C-!") 'eshell-here)

My function, x exits that shell and closes that window.

(defun eshell/x ()
  (insert "exit")
  (eshell-send-input)
  (delete-window))

EShell is a Lisp REPL. The following works as you’d expect from such a REPL:

$ (message "hello world")
"hello world"

However, in a shell, we care more for simplicity and speed of typing that we do for semantic clearness, so we can, in this case, drop the parens with the same results:

$ message "hello world"
"hello world"

Functions that begin with eshell/ are available in Eshell without the prefix, so calling the eshell/echo function makes the shell experience less surprising:

$ echo "hello world"
"hello world"

If you put it in parens, you need to give it the full name:

$ (eshell/echo "hello world")
"hello world"

What about types? In a normal shell, everything is a string, but EShell has a foot in both worlds:

$ echo hello world
("hello" "world")

A list of two strings. However, you can NOT attempt to pass that echo to car… at least not directly:

$ car echo hello world

Returns an error, as does:

$ car (list hello world)

You see, once you bring in parens, you also bring in syntactic specific-ness, so you would need to do this:

$ car (list "hello" "world")

EShell has a listify that converts its arguments to a list of strings:

$ listify hello world
("hello" "world")

But if you want to pass that data to something like car, you need to surround it in curly braces, which is EShell’s way of saying, call some shell-like-goodness, but return it like Lisp:

$ car { listify hello world }
hello

Upon a cursory review, it appears little difference between a simple list and using listify, as under certain circumstance, they have the same behavior:

$ listify hello world
("hello" "world")

$ list hello world
("hello" "world")

$ listify 1 2 3
(1 2 3)

$ list 1 2 3
(1 2 3)

$ list "hello world"
(#("hello world" 0 11
   (escaped t)))

$ listify "hello world"
(#("hello world" 0 11
   (escaped t)))

However, I got the following message from David, who said:

The difference between listify and a ’list’ appears to be that calling listify on a list will not nest it in another list, e.g.

(eshell/listify '(1 2 3)) ;; => (1 2 3), a list with 3 elements
(list '(1 2 3)) ;; => ((1 2 3)), a list with one element

Seems useful for a context where input may be a list, or not.

As the documentation says,

Since Eshell is just an Emacs REPL(1), it does not have its own scope, and simply stores variables the same you would in an Elisp program.

Running printenv only displays the environment variables:

$ setenv A "hello world"
$ getenv A
"hello world"

Use the setq to assign normal, Emacs variables:

$ setq B hello world
$ echo $B
hello
$ setq B "hello world"
$ echo $B
hello world

Preface with a $, you can access any Emacs variable:

$ echo $recentf-max-menu-items
25

Keep in mind that environment variables over-shadow Emacs variables:

$ setenv C hello
$ setq C goodbye
$ echo $C
hello

Finally, you can source Eshell variables from a file:

$ cat blah.eshell
setq FOO 42
setq BLING "bongy"

$ . blah.eshell
42
bongy

$ echo $FOO
42

$ echo $BLING
bongy

Executing a series of commands on each matching file is a standard use case for shells. While you could use a Lisp-like dolist, EShell attempts to give you a similar shell-like syntax:

$ for file in *.org {
  echo "Upcasing: $file"
  mv $file $file(:U)
}

The (:U) converts the contents before it to upper case format. It is a modifier, and I’ll babble on about this in the next section (since this is one of Eshell’s best feature).

I find it interesting to note that *.org gives the for loop a list to iterate over, but if there is more than one argument, a list is created, as in:

$ for i in 1 2 3 4 { echo $i }

Passing more than one list flattens them into one list, so the following works as you expect:

$ for file in emacs* zsh* { ... }

If all you were doing was renaming a single file, or changing access permissions on all files in a directory, you’d hardly need a flexible shell, as dired or even Finder is sufficient for those tasks. A shell comes in handy when selecting a subset of files based on a pattern, and EShell really shines here, because of its filters (that it stole from Zshell’s modifiers):

$ ls -al *.mp3(U)   # Show songs I own

The *.mp3 part is just a normal globbing pattern we all know and love, but the (U) part further filters the selection. In this case limiting the selection to files you own.

The help for this feature is available in the shell, so type the following:

$ eshell-display-predicate-help
$ eshell-display-modifier-help

While you may have seen the predicates before (since they are similar to ZShell’s), the coolest part is that you can write some ELisp code to add your own predicates and modifiers.

Of course the real beauty of EShell is the Emacs integration, for instance, using highlight-regexp to colorize key words from expected output, or piping the results to an Emacs buffer:

$ ls -al > #<buffer some-notes.org>

And then issue a C-c | on that results to create an org-mode table you can continue to manipulate.

While the Eshell is baked into Emacs, and requires no customization, I have made a few improvements that may be helpful to others.