Lambda the Ultimate

I hear Ocaml and Logix have some support for these things.

A lisp relative

Oddly enough, there are some projects that help you create syntax extensions for Java. There's a thread about it here.

I recently posted a forum topic about Logix, a "multi-language programming system" whic supports dynamic syntax extension. Previously discussed on LtU here as well. Apparently Nemerle also supports syntax extension (although I haven't actually looked at it yet). And let's not forget OCaml, which allows syntax extension via Camlp4 (unless you don't consider the application of a pre-processor to be "native" extension).

... is Maude which uses its equational rewriting logic to implement a more interesting extensible mixfix parser.

The ones that expose their compilers, that is.

The key, though (and one most language systems, including Lisp systems, don't get right), is that after one mods the language, the debugger should also be modded so that debugging can be done at the same syntactic level as the code that the user writes at. Smalltalk, as it generally has the debugger source available, is very good for this. Most Lisp systems don't have their debugger code exposed so it's pretty hard to hack in to anything other than the primitive level (which sometimes seems as troublesome, after I've written a good compile-level transform, as if after I added some syntax to a C compiler I needed to have the user to debug that syntax at the assembly level).

I do think that each language that separates AST generation and bytecode compilation and provides an API to ASTs should be appropriate. I digged into the Python std lib and found a function called list2ast() ( and the converse ast2list() ) converting a nested list of certain objects into an AST ( and reverse ) that can be compiled into Python bytecode. Since there are pure Python parsers that parse a grammar into an AST only changes in the grammar file and AST->AST transformers are needed to extend the language ( and a few other files of the std-lib for convenience ). I don't know about Ruby internals that seems to be your favourite language in the moment but I would try to figure out if something similar is possible without touching any one of the C-sources of the interpreter.

Tcl allows syntactic extension in that it does very little of its own parsing beyond basic tokenization. This leaves individual commands with a very free hand to implement new syntax (within scripts passed to that command). This is used e.g. by the critcl extension, which allows direct embedding of C code into Tcl:

critcl::cproc quadruple {int i} int {
    return i * 4;    /* this is C code */
}

I believe there are similar extensions for Perl, but I don't know whether they look as integrated as critcl code does. You can also override [source] if you want to try global syntax alterations, but I prefer the per-command approach, as it at least delimits the scope of the new syntax somewhat. Tcl lacks a really good parser framework, though, so most syntax extension is fairly conservative.

Pop-11 provides a full interface to the workings of its incremental compiler as a suite of library procedures, alowing unlimited syntax extension (and wholesale modification). From the comp.lang.pop FAQ:

Because Poplog incremental compiler facilities are available in a suite of Pop-11 procedures which compile code incrementally to a powerful general purpose virtual machine, it is not hard to develop new languages or extensions to old ones. This is how Common Lisp, Prolog and ML are implemented in Poplog, and many people have implemented various extensions to Pop-11 and other languages based on Pop-11.

Forth is lower level than Lisp, but extensibility is the name of the game.

No one's mentioned it yet, I think.

You'll want to have a look at Pliant at its new home. Lispy underneath, but quite a developed syntax on top. He manages to have most of his cake, and eat it too.

Might as well mention Rebol again. Extending the language by creating new "dialects" is a major part of Rebol.