Lambda the Ultimate

...what Chris is working on...

Gotta take the young ones to see Matrix Revolutions tonight, so i'll have to procrastinate a bit longer on the posting. :-)

Cute trick, huh?

I'll be sure to report something more substantial after the conference later in the month!

PS: Is LtU as slow for everybody else as it is for me?

The protocol lets Emacs evaluate code in the Lisp process, command the debugger (possibly recursively), redirect I/O streams, and various other things all at the same time. Throughout all this, Emacs and Lisp need to remain properly synchronized. In the Emacs code we have formalized this into a (macro-supported) state-machine, such that if an illegal transition is attempted the user gets a buffer explaining that they've found a bug and plenty of diagnostic information.

This debugging feature has been extremely useful. In the past week two users have reported protocol-violation errors which we could immediately attribute to out-of-sync Emacs/Lisp code versions. Without nice error reportage, it would surely take a lot of to'ing and fro'ing to figure out what's wrong. This is the most use I've had out of assertions in quite a while :-)

BTW, the state machine code is perhaps an interesting case for our previous discussion of macros. On the one hand, Lisp macros helped us to very neatly code the state machine. On the other hand, if we had real coroutines it probably wouldn't have been worth creating a new formalism in the first place.

(That code is actually not the latest, it's just the last "rewrote it, now it looks right" snapshot, and is much simpler.)

int store_nlmsg(struct sockaddr_nl *who, struct nlmsghdr *n, void *arg)
{
        struct nlmsg_list **linfo = (struct nlmsg_list**)arg;
        struct nlmsg_list *h;
        struct nlmsg_list **lp;
 
        h = malloc(n->nlmsg_len+sizeof(void*));
        if (h == NULL)
                return -1;
 
        memcpy(&h->h, n, n->nlmsg_len);
        h->next = NULL;
 
        for (lp = linfo; *lp; lp = &(*lp)->next) /* NOTHING */;
        *lp = h;
 
        ll_remember_index(who, n, NULL);
        return 0;
}
...
        if (rtnl_dump_filter(&rth, store_nlmsg, &linfo, NULL, NULL) < 0) {
                fprintf(stderr, "Dump terminated\n");
                exit(1);
        }

Orca

Not sure I would agree with regard to modern C++. Combined with STL I think you can come up with a much higher-level implementation of fold. Not that it would match Haskell, but still ...

Orca