Irreal

John Kitchin is back with another in his series of videos comparing Python and Elisp programming. This time it’s about writing Elisp functions. Earlier, Kitchin made a video discussing how to write Python functions. This video is a followup that reimplements the Python functions in Elisp following the original implementation strategy as closely as possible.

The video mostly focuses on handling the function arguments. The canonical Elisp function using defun is pretty straightforward. You call the function by specifying each of the arguments listed in the function definition with the possible exception of optional arguments. There are no keywords. Keywords can be included if you use cl-defun to define the function. That enables certain Common Lisp additions including keywords.

At one point, Kitchin wants to test if every value of a list of boolean values is t. The natural way of doing that is

(apply #'and list-of-booleans)

but that doesn’t work because and is a macro, not a function. Kitchin couldn’t remember how to do it and ended up using the -all? predicate from the Dash library. I couldn’t remember either but I did remember writing about it years ago. It turns out that it was 10 years ago so no wonder I didn’t remember. You can read that post for a discussion of the issues and the standard Elisp way of performing an and or or on a sequence of values.

Kitchin says he’s trying to get his viewers to the point where they can begin writing their own Elisp applications. The video is 26 minutes so you’ll need to schedule some time but as always with Kithcin’s content, it’s worth your time.

John Kitchen has important things to do so naturally he’s procrastinating. That’s probably bad for him but it’s good for us because he has another Elisp video up. This one considers various ways of iterating in Elisp. Earlier, he had posted a video on iteration in Python and this video considers the corresponding idioms in Elisp.

To me, the most general (non-recursive) iteration technique in Lisp is the do statement. It’s so powerful that you can do significant work even with an empty body. It’s powerful but not exactly transparent. Kitchin mostly focuses on the cl-loop macro. It’s natural and seems to translate amazingly well into Python even though Elisp predates Python by many years.

I’ve never been able to warm up to the loop macro but Kitchen’s demonstration of its use is more persuasive than any polemic could be. Take a look at the video to see it in action. It can do all sorts of things in a natural way much as Python does with list comprehensions.

Kitchin also considers using while. You can specify an ending condition or you can exit from the while by throwing an exception. That’s Lisp’s version of the break verb in other languages’ version of while.

The other iteration method that I use a lot that Kitchin doesn’t mention is the dolist macro. It’s sort of like a list comprehension but easier to use. In those situations where Kitchin uses cl-loop, I’d be inclined to use dolist. Still, Kitchin makes a good case for cl-loop and has encouraged me to spend a bit of time getting more comfortable with it.

The video is just short of 24 minutes so you’ll have to put some time aside for it but as usual with Kitchin’s videos, it’s worth it.

One of the things we programmers do all the time is to build strings of the sort

In a survey of 342 programmers, 312 preferred Emacs.

where the two numbers and the string “Emacs” are variables. If, like me, you have multiple decades of C experience, the first thing you think of is printf. In C, you would render the above string as

(printf "In a survery of %d programmers, %d preferred %s",
 survey_total, editor_total, editor_type);

This idiom is so well established that you seldom see it done any other way.

Emacs Lisp has a direct analogue called format. Those of us permanently imprinted with the printf pattern seldom think of doing it any other way but Elisp offers several other methods of producing such strings.

John Kitchin has just posted a very nice video that considers several ways of formatting strings. He admits that he usually reaches first for format but some of the other methods he considers make the code more readable.

He looks at six ways of formatting strings:

1. format
2. format-spec
3. f-string
4. s-string
5. mustache
6. templatel

The first two are built in and the others are contributed functions. My years of C have permanently warped my brain so I stick to format almost all the time. If you like to make your code a little less opaque, you might want to give the others a try. The video is a good demonstration of their use.

The video is just over 22 and a half minutes so you’ll need to schedule some time. As usual with Kitchin’s videos, you learn things you probably didn’t know so it’s definitely worthwhile spending a few minutes with it.