2 ms·
> future Lisps are expected and encouraged That's right. There are two reasons that Common Lisp never got revised: 1. AI winter hit and the money dried up
by lisper 10y ago
> future Lisps are expected and encouraged
That's right. There are two reasons that Common Lisp never got revised:
1. AI winter hit and the money dried up
2. Common Lisp as it stood when it was first released turned to be a very (very!) good design, in particular because it's almost infinitely flexible. You can implement almost anything within CL because you have control over every part of the code-processing process. You can modify the lexer by making new readtables, and you can change the way the AST is processed by writing macros. There is almost nothing you can't do in CL. (There are a very few things you really can't do without changing the standard, but even those are generally possible using vendor-specific extensions, or by making small tweaks to an implementation.)
FWIW, here's my take on bringing CL into the 21st century:
https://github.com/rongarret/ergolib https://github.com/rongarret/ergolib
and the beginning of an associated book:
https://github.com/rongarret/BWFP https://github.com/rongarret/BWFP
> is there something inherent in Lisp that favors fewer namespaces
Not really. It's pretty easy to make a Lisp2 act like a Lisp1 when you want it to (https://news.ycombinator.com/item?id=12801372 https://news.ycombinator.com/item?id=12801372). Much harder to go the other way.
- nabla9 10y ago>You can implement almost anything within CL because you have control over every part of the code-processing process. Almost. There is one big missing piece. Standard code walker. If CL had standard code walker that could correctly walk trough any piece of standard CL code, it would implement fully the promise of Lisp and you could build almost anything on top of it with ease.
- lisper 10y agoTrue, but 1) there are open-source code-walkers that do a pretty good job, 2) many implementations expose their internal code walker in one way or another and 3) you can do somewhere between 90 and 99% of what you'd want to do with a code walker using MACROLET. My pet peeve is that ((...) ...) is a syntax error, so you can't implement Scheme in Common Lisp without violating the standard. But see http://www.flownet.com/ron/lisp/combination-hook.lisp http://www.flownet.com/ron/lisp/combination-hook.lisp for an example of how easy it is to hack at least one implementation to support this.
- dreamcompiler 10y agoThe lack of mandatory tail calls and call/cc also make implementing Scheme in CL hard, although the former is actually present in most mainstream implementations. Various flavors of continuations can be implemented with macros, but they require coding changes and are not as general as Scheme continuations.
- ScottBurson 10y agoIt's not the only thing I would add, but I agree. The other two pieces I wish had been standardized are coroutines, and the internal syntax used by backquote.
- netsettler 10y agoWe tried to do a standard code walking / macro introspection thing but it had much detail we realized we were going to get wrong, so we backed out of it rather than freeze something bad. It's appropriate to a level 2 standard, just as the MOP was.