Irreal

Yesterday, I wrote about generating a 10 × 10 multiplication table in Emacs Lisp. The solution I gave involved using the dolist macro with a list of the numbers 1–10 like this

(dolist (r '(1 2 3 4 5 6 7 8 9 10)) ...)

That’s a little contrived and obviously doesn’t scale well but I couldn’t find a better way. Fortunately jpkotta knew just what to do. He suggested using number-sequence so that the solution becomes

(dolist (r (number-sequence 1 10))
  (dolist (c (number-sequence 1 10))
    (insert (format "%2d " (* r c))))
  (insert "\n"))

As I said in the previous post, none of this is very important so it wouldn’t be worth the followup post except that number-sequence is essentially like the Python range function (number-sequence includes its upper bound while range doesn’t) so together dolist and number-sequence provide a nice Elisp idiom for operating on a sequence of numbers. Thus a construct such as

for x in range(i,j):
    do_something(x)

in Python could be rendered as

(dolist (x (number-sequence i j))
  (do-something x))

in Emacs Lisp. That’s a handy thing to know and I thought it was worth a followup so that jpkotta’s wisdom didn’t get lost in the comments.

Xah Lee saw my post about Tim Visher’s video on building a multiplication table in Emacs and decided to experiment. Visher’s video was in the context of VimGolf where the goal was to build the table in the minimum number of keystrokes. Lee wasn’t interested in building the table in the minimum number of keystrokes; he wanted to see how you could do it in various programming languages. He gives solutions in Emacs Lisp, Python, and Perl. That was interesting but then he says

Lisp is a bit verbose for this kinda thing due to the nested syntax.
But you can write it in perl, python, ruby, bash, or any dynamic lang
quickly, and press a button to have emacs call it and insert the
result.

To a Lisper like me this is a challenge that can’t go unanswered. Therefore I started to think about how I could code this concisely with Emacs Lisp. My first thought was to use the dotimes macro but that starts with 0, which complicates things. Then I realized that since we only needed to deal with the numbers 1–10, I could just use dolist like this

(dolist (r '(1 2 3 4 5 6 7 8 9 10))
  (dolist (c '(1 2 3 4 5 6 7 8 9 10))
    (insert (format "%2d " (* r c))))
  (insert "\n"))

Now put the point at the beginning of the next line, type 【Ctrl+x Ctrl+e】 and the table is inserted into the buffer.

None of this is of any importance, of course, but it is fun and instructive. My solution can be criticized on the grounds that it’s really a Common Lisp solution but it does work in Emacs due to the cl.el package. It’s also slightly objectionable to have to list the numbers explicitly but I couldn’t think of a better way. Leave a comment if you have a nicer solution.

Update: Added link to Xah Lee’s post.

I was watching another of Tim Visher’s VimGolf videos in which he builds a multiplication table by the clever use of keyboard macros. What got my attention, however, was his use of the function eval-and-replace that evaluates the sexp preceding the point and replaces it with its value. This seemed like a useful thing to be able to do but as Visher explained, eval-and-replace is part of the Emacs Starter Kit and not part of Emacs itself.

I have a fairly large init.el that I’ve developed over time and therefore never installed the starter kit even though I’ve heard good things about it. Rather than hunt up the starter kit to get the function, I just rolled my own:

(defun eval-and-replace (value)
  "Evaluate the sexp at point and replace it with its value"
  (interactive (list (eval-last-sexp nil)))
  (kill-sexp -1)
  (insert (format "%S" value)))

The eval-last-sexp in the interactive declaration evaluates the sexp and passes its value to eval-and-replace. Then the (kill-sexp -1) deletes the sexp from the buffer. Finally the value is inserted into the buffer with the insert function.

I originally wrote the function using a let to capture the value of the sexp instead of using the interactive declaration but this seemed a bit shorter and I wanted to use an expression in the interactive declaration, as I wrote about here, to fix the idea in my mind.

I can see all sorts of uses for eval-and-replace. As a trivial example, suppose I want to say 2²³=8388608 but I don’t remember the value of 2²³. I could switch over to my calculator buffer to make the calculation and then cut and paste it to my text or I can just write

2^23=(expt 2 23)

and call eval-and-replace to put the value in the text for me.

I’ve added eval-and-replace to my init.el so that I’ll have it available the next time I have a need for it.