Random Hacks: Why Hygienic Macros Rock

"Why Hygienic Macros Rock" by Scott

Tue, 15 Jul 2008 22:30:03 +0000

Daniel: Ok, thanks.

I’m acquainted with Forth. I read both Starting Forth and Thinking Forth a few days after posting the above comment, actually; I love the concatenative approach, though I find Forth a bit too low-level for my taste. (My favorite language is currently OCaml, so you can guess how I feel about working without any type system whatsover.) I’ve also looked a little at Factor, but not in depth.

That said, the source to a Forth interpreter in i386 assembly and Forth was one of the single most mind-blowing programming things I’ve ever read. When I saw that the interpreter had a bit for whether the code was being compiled or evaluated, and immediate functions could toggle it at runtime, everything suddenly made sense. So much flexibility emerging from so few constructs!

http://www.annexia.org/_file/jonesforth.s.txt

"Why Hygienic Macros Rock" by Daniel

Sun, 22 Jun 2008 21:47:00 +0000

I have actually read a lot about hygienic vs non-hygienic macros. I just cannot recall what blogs and sites I read them.

You might try smuglispweeny and lambda-the-ultimate blogs, though. And wikipedia.

The thing is, gensyms handles some of the stuff hygienic macros handle, but not all of the stuff. There are some complex cases which would require heroic efforts in LISP, and very prone to errors at that.

On the other hand, hygienic macros can access the runtime context, in a more verbose way.

So, really, they each can be used for the same things, with varied levels of complexity depending on the task. But let me advocate hygienic macros a bit here.

There once was a language called Forth. Forth was interesting in that not only it was written in itself, but all the internals were available to any programs written in it, and, furthermore, it could be changed at will. You could change the parser, for instance, or you could change how it performed compilation.

Needless to say, it was powerful in the way such languages are. The thing is… Forth lacked abstraction. Yes, you could change the compiler. But, of course, you’d have to know how the specific compiler you were changing worked—and I don’t mean simply dialect differences. The most famous Forth generated indirectly threaded code, quite a few generated directly threaded code, some generated subrouting threaded code, others generated bytecode, and others compiled directly to machine code.

So it was very powerful stuff, which had very little portability. Well, let’s be honest. It had no portability at all.

And here is the thing with non-hygienic macros… the programmers using someone’s macro also have to know how that macro works. Either that, or you add stuff to your macro until it is, effectively, hygienic.

So, by using hygienic macros, you guarantee a level of portability to them similar to library functions.

"Why Hygienic Macros Rock" by Eric

Fri, 20 Jun 2008 07:40:30 +0000

Scott: That’s a good question, and I don’t actually know the answer.

Most Scheme implementations take a distantly-related approach. They generally have two different hygenic macro systems:

A “low-level” macro system, which works roughly like LISP, but which provides hygiene by default, but also provides the ability to violate hygiene selectively. This tends to be a bit fiddly to use.
A “high-level” macro system, which is based on hygienic rewrite rules. This is very easy to use, and will work for nearly all common macros.

Of course, using the low-level macro system, you can easily implement Lisp-style non-hygienic macros.

The PLT people have recently added another very slick feature to the standard Scheme toolkit: The ability the selectively violate hygiene from inside rewrite rules, in a carefully controlled fashion. This is a really nice feature, and we’ve been using it at work with great success.

"Why Hygienic Macros Rock" by Scott

Thu, 19 Jun 2008 20:15:42 +0000

To what extent can hygienic macros be implemented in non- and vice versa? I’m more familiar with Emacs Lisp-style macros than CL or Scheme macros, but it seems like the hygiene involves automatically writing code with gensyms to avoid variable capture and other compile-time analysis. If one is implemented in terms of the other, it would probably make the most sense to have two different forms, e.g. hmacro for declaring hygienic macros, and macro for when you deliberately want to do things like variable capture.

Why Hygienic Macros Rock

Eric — Fri, 13 Sep 2002 00:00:00 +0000

I've recently been reading a lot of excellent essays on programming language design by Paul Graham. Paul and I agree about a number of things: (1) LISP is beautiful and powerful family of languages, even by modern standards, (2) all existing dialects of LISP are lacking a certain something, and (3) programmatic macros are a Good Idea.