Antonio Menezes Leitao wrote:
> Edi Weitz <spamt...@agharta.de
> > (loop with scheme-char-seen-p = nil
> > for c across string
> > when (or (char-not-greaterp #\a c #\z)
> > (digit-char-p c)
> > (member c '(#\+ #\- #\.) :test #'char=))
> > do (setq scheme-char-seen-p t)
> > else return (and scheme-char-seen-p
> > (char= c #\:)))
> Lot's of extremely nice examples! And the last one even ends with a
> smile. I hope you can see it!
> Thanks a lot,
In other words, test whether the string begins with a
sequence composed of a-z, 0-9, or [.+-], followed
This is easily done with a simple regular expression.
> (regexp-match #px"^[a-z\\d.+-]+:" "abc:")
> (regexp-match #px"^[a-z\\d.+-]+:" "abc?")
> (regexp-match #px"^[a-z\\d.+-]+:" ":abc")
> (regexp-match #px"^[a-z\\d.+-]+:" "888:")
> (regexp-match #px"^[a-z\\d.+-]+:" "-:")
> (regexp-match #px"^[a-z\\d.+-]+:" ".:")
> (regexp-match #px"^[a-z\\d.+-]+:" "ABC:")
> (regexp-match #px"^[a-z\\d.+-]+:" "**:")
Of course, as a rule, users of CL (COBOL-Like) are
not familiar with regular expressions. As a rule,
they are computer illiterates who refuse to learn
anything besides their sacred scriptures, the CL
Hypertrophied Spec, and who actually pride themselves
on their ignorance.
Only the abysmally ignorant don't know about
regular expressions; even Microsoft Word lets
you do a regular expression search.
Here we saw one mindless worshipper of CL proudly
displaying his bloated, convoluted LOOPy code and
another typical worshipper of CL thanking him
CL truly attracts the worst "programmers" in the world.
COBOL-Like is definitely not a Lisp.
Here's what the experts say about COBOL Like:
"an unwieldy, overweight beast"
"did kill Lisp"
"ignores the basics of language design"
"the WORST thing that could possibly happen to LISP"
"not commercially viable"
"a significantly ugly language"
Guy L. Steele, Jr., July 1989:
I think we may usefully compare the approximate number of pages
in the defining standard or draft standard for several
Common Lisp 1000 or more
Fortran 77 430
Fortran 8x 300
Brooks and Gabriel 1984, "A Critique of Common Lisp":
Every decision of the committee can be locally rationalized
as the right thing. We believe that the sum of these
decisions, however, has produced something greater than its
parts; an unwieldy, overweight beast, with significant costs
(especially on other than micro-codable personal Lisp
engines) in compiler size and speed, in runtime performance,
in programmer overhead needed to produce efficient programs,
and in intellectual overload for a programmer wishing to be
a proficient COMMON LISP programmer.
Common Lisp did kill Lisp. Period. (just languages take a
long time dying ...) It is to Lisp what C++ is to C. A
monstrosity that totally ignores the basics of language
design, simplicity and orthogonality to begin with.
To this day I have not forgotten that Common Lisp killed
Lisp, and forced us to abandon a perfectly good system,
Paul Graham, May 2001:
A hacker's language is terse and hackable. Common Lisp is not.
The good news is, it's not Lisp that sucks, but Common Lisp.
Historically, Lisp has been good at letting hackers have their
way. The political correctness of Common Lisp is an aberration.
Early Lisps let you get your hands on everything.
A really good language should be both clean and dirty:
cleanly designed, with a small core of well understood and
highly orthogonal operators, but dirty in the sense that it
lets hackers have their way with it. C is like this. So were
the early Lisps. A real hacker's language will always have a
slightly raffish character.
Organic growth seems to yield better technology and richer
founders than the big bang method. If you look at the
dominant technologies today, you'll find that most of them
grew organically. This pattern doesn't only apply to
companies. You see it in sponsored research too. Multics and
Common Lisp were big-bang projects, and Unix and MacLisp
were organic growth projects.
Jeffrey M. Jacobs:
I think CL is the WORST thing that could possibly happen to LISP.
In fact, I consider it a language different from "true" LISP.
Common LISP is the PL/I of Lisps. Too big and too
incomprehensible, with no examination of the real world of
... The CL effort resembles a bunch of spoiled children,
each insisting "include my feature or I'll pull out, and
then we'll all go down the tubes". Everybody had vested
interests, both financial and emotional.
CL is a nightmare; it has effectively killed LISP
development in this country. It is not commercially viable
and has virtually no future outside of the traditional
One of the key issues that I consider distinguishes "Real
LISP" from Common LISP is indeed the strong committment to
the equivalence of data (meaning list structures) and code.
I consider this idea one of the foundations of "Real LISP",
and Common LISP intent is vague at best. InterLISP, for
example, still makes a declaration of this philosophy in the
manual, and it is still one of the keystones in the teaching
of LISP (although whether it should be when teaching Common
LISP is open to question).
Common Lisp is a significantly ugly language. If Guy and I
had been locked in a room, you can bet it wouldn't have
turned out like that.
Do you really think people in 1000 years want to be
constrained by hacks that got put into the foundations of
Common Lisp because a lot of code at Symbolics depended on
it in 1988?
Daniel Weinreb, 24 Feb 2003:
Having separate "value cells" and "function cells" (to use
the "street language" way of saying it) was one of the most
unfortunate issues. We did not want to break pre-existing
programs that had a global variable named "foo" and a global
function named "foo" that were distinct. We at Symbolics
were forced to insist on this, in the face of everyone's
knowing that it was not what we would have done absent
compatibility constraints. It's hard for me to remember all
the specific things like this, but if we had had fewer
compatibility issues, I think it would have come out looking
more like Scheme in general.
Daniel Weinreb, 28 Feb 2003:
Lisp2 means that all kinds of language primitives have to
exist in two versions, or be parameterizable as to whether
they are talking about the value cell or function cell. It
makes the language bigger, and that's bad in and of itself.