[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

loop macro

    I don't understand the general topic of discussion here.  This Maryland
    FOR macro hasn't a dime's worth of difference from Zetalisp LOOP.  The
    differences are trifling.   I thought the issue with LOOP vs. CL was not
    one of trivial differences between a large number of Interlisp-like loop
    macros, but rather one of whether we wanted such a thing, extremely
    non-lispy, however useful, to some tastes, in the language.

There are a couple of issues here.  One is whether we want something
like the Loop macro added to the Common Lisp standard; the other is
whether anyone has a portable LOOP package that can be used as an
add-on.  On the former issue, there seem to be three schools of thought:

1. We don't need such a thing.  DO and related constructs do the job
just fine without adding a lot of extra hair.

2. The Lisp Machine's LOOP facility is essential for high-efficiency
programming and should be added to Common Lisp.  (Discussions of
actually doing this usually get derailed by someone saying "..but there
are some problems with the current LOOP system, so everyone should wait
until we've figured out what the ultimate best thing is.")

3. The functionality of LOOP is fine, modulo some small details, but the
cute English-like syntax should be replaced with something more Lispy.
Specifically, parentheses should be used to group the arguments
controlling the various major options rather than doing this with
connecting words like "by", "until", and "whereas".  People in this
group feel pretty strongly that the little pseudo-sentences people end
up writing in the LOOP syntax are extremely confusing and promote bad
style.  Things that aren't English shouldn't look like English.

I used to be in group 1, but have now moved to group 3.  I don't think
there are very many people left who actually favor option 1.  A year or
so ago I proposed that we try to compromise with a scheme that basically
implements proposal 3, but with English-like LOOP syntax available as an
alternative syntax (a simple one-to-one mapping) for people who like
that kind of stuff.  This suggestion went nowhere, and I haven't seen
any activity on the iteration mailing list since then.  Deadlock, and
position 1 wins by default.

So much for standardizing on one of these things.  The more recent
discussion was, I think, sparked by somebody's desire to move some
Loop-infested code from Zetalisp to a vanilla Common Lisp.  While I
don't want to see us standardize on the Loop syntax, I must admit that
having a portable, compatible Loop package would make a lot of people's
lives easier as they move code from one system to another.  So the
question of how close the Maryland code was to the current Zetalisp
stuff was of some immediate practical interest.

-- Scott