Why don't people like lisp?

[prunesquallor at comcast.net]

ddarius at hotpop.com (Darius) writes:

>
> Changing the spec, eh?  Now I have to add state to a pure language as
> well as non-determinism.  So, some preliminaries; luckily I have them
> lying around, along with Hinze's backtracking monad. Knew they'd come
> in handy some time and now they're handy two times.

Sniff sniff....

Wait a second.  This isn't Python!

> Personally, I had the impression that you were advocating that macros
> let you easily extend Lisp without effectively writing a good chunk of
> compiler*, yet Screamer does this.  

Actually, I am advocating that macros supply a broad range of
advantages from tweaking some local syntax to rewriting a good chunk
of the compiler.

> So I don't find Screamer a particularly good example, especially
> coupled with the fact that it isn't a complete or seamless
> integration.

It isn't perfect by a long shot, but I like the example because it is
in use rather than something academic.

> So ranking them: Scheme's got us both beat hands-down.  call/cc
> let's you define (some of) the primitives in less than a page and
> the result is utterly seamless (with perhaps a few simple
> syntax-rules to thunkify things).

Seeing as I work for the PLT Scheme project, how could I object?

> I put Haskell second for this one.  The implementation is pretty
> simple, the interface is pretty clean and it's more or less normal
> monadic Haskell programming.

I'm not too familiar with Haskell, but laziness is interesting.

> CL/Screamer is third.  It probably wins for speed (it'd better!),
> but that isn't too surprising since it's basically a compiler for a
> non-deterministic lisp**.

Probably.  It is a good compromise.

> If I'm not mistaken Screamer implements local by searching the form
> for setf's and replacing them with it's own version, which makes me
> wonder what it does if the setf's aren't obvious (e.g. a compiled
> closure), I severely doubt it delivers on it's seeming promise of
> interopability (no doubt disclaimed in the documentation unless I'm
> mistaken), considering it works be redefining defun, among others,
> and translation to CPS and via a codewalker. Basically, I don't see
> writing the equivalent using Template Haskell for Haskell, or
> whatever for Python, or as an external tool being significantly more
> complicated than Screamer.  No word from the Pythonistas.

Well, I wouldn't `call out' a Python implementation that had the same
restrictions.