Why Lisp macros are cool, a Perl perspective (2005)

A voice from a simpler time. Had me laughing.

mjd rocks but 2005 was before I made custom keywords in perl "work" on CPAN, and even further before people who were competent to do so obsoleted my horrific proof of concept hack with perl core features in 5.14/5.16 - which have since allowed many cool things such as http://p3rl.org/Future::AsyncAwait

Lisp macros are, of course, still cool, and this is why I got into this sort of hackery in the first place.

Anyway, when reading the code, you're safe in assuming "=3D" is just a single plain old equal sign. In the "quoted-printable" encoding scheme the two characters following an equal sign are the hex value of the intended character. In effect, equal signs need to be escaped using the "=3D" sequence.

This drove me a little nuts as I was reading and trying to code switch between the assorted languages used in the examples.

On a related note, https://www.youtube.com/watch?v=e1T7WbKox6s is very much worth watching.

But, most people are happy with just typing and copy pasting stuff around. They don't care. I've shown them before and after macro refactoring code comparisons and they just stare blankly, they don't see the point.

They code stuff like this on a daily basis:

    Var stuff() As Stuff
    stuff.Add(New Stuff("foo"))
    stuff.Add(New Stuff("bar"))
    stuff.Add(New Stuff("baz"))

One thing that helped greatly with that is the “defer” statement. It lets you defer a section of code to the end of the current scope. Which means you now have compile time access to the entire current scope.

We’re writing a compiler for custom ML hardware using MLIR. MLIR has the concept of a current insertion point when you’re building an AST.

emacs users will know where I’m going with this.

We now have a save_excursion macro which stores the current cursor, then resets it at the end of the scope automatically. So when you’re building a loop or an if statement, you normally have to call (pseudocode):

  make loop
  set cursor to loop body
  make statements inside the loop
  set cursor to “after loop body”

  make loop
  save_excursion();
  make statements inside the loop

The “make loop” part is actually so long that our linter breaks it onto several lines. But after making a macro for it, it looks like:

   affine_for(loop, idx, 0, n, 1);
   make statements inside the loop

Boom, now the work is cut by 50%. Two lines of code. Technically it went from three to one, and it’s far more readable.

The usual lisp disciplinary rules apply. You need to be familiar with variable capture, and how to make variable names at compile time. (In C++ I use a UNIQ(x) macro, which gives me a unique name for x. You can capture it into a #define by making a second #define and passing UNIQ(x) into it. So in practice most macros like save_excursion become two #defines, since you have to reference the unique name of the variable to store the cursor.)

I don’t know if it’s common. I assume not. Most lispers are rightly allergic to C++. But most lispers also lose the benefits of working in a team setting — so in practice, porting as much benefit from lisp to other languages is the biggest win of all. And that requires you to learn lisp. (Interested readers should look up the Blub Paradox, then move on to studying On Lisp.)

Perl encourages idiomatic programming styles which make collaboration difficult. I'm the eng mgr of a team which writes (among other things) Perl for big data processing applications and none of our programmers understand code the others have written without extensive (measured in weeks rather than days) analysis. I've never encountered the problem to this extent on Java code bases.