Subject: Re: IS(O-)Lisp status?
From: Erik Naggum <>
Date: 1996/07/22
Newsgroups: comp.lang.lisp
Message-ID: <>

[Marc Wachowitz]

|   How's the status/development of ISO standardization for Lisp?

according to ISO procedure, there is no development at all at this time,
and very little to be expected before final approval.  after that, the
process is called "technical corrigenda" and "amendments", either of which
options should not be exercised lightly.

ISO/IEC DIS 13816 "Information technology -- Programming languages, their
environments and system software interfaces -- LISP" is under balloting as
an International Standard.  voting began on 1996-05-23 and terminates on
1996-09-23.  during this time, there is to be no activity, except to handle
incoming comments.  after the termination of the voting, negative votes and
other comments must be handled; suggested and required editorial changes
are made; then it is published.  no substantial changes may be made without
a second DIS stage.  this is very, very unlikely.

|   Is there going to be a newer version in near future?

the ISO procedure allows revision of standards every five years.  if errors
are discovered, there is of course room for fixing them.  there is also
room for additions.

I have but one serious gripe with ISO Lisp at this time.  (the body of the
standard uses the name "ISLisp", but the cover reads "LISP", a discrepancy
that must be resolved; I prefer to call it "ISO Lisp" until publication.)

my gripe concerns the special form `dynamic'.  it is used to access a
dynamic variable ("special" in the usual terminology).  (dynamic foo) means
the _dynamic_ variable _foo_.  the setter is (setf (dynamic foo) ...), and
the global defining macro is (defdynamic foo ...).  these are perfectly OK
to me.  however, the `let'-binding is done wrong.  instead of enabling the
programmer to decide whether any given variable is dynamic or not by using
`foo' or `(dynamic foo)' as needed, a special form `dynamic-let' is
introduced.  since the Common Lisp `declare' is not found in ISO Lisp, the
programmer cannot specify the dynamic nature of a variable except through
cumbersome `dynamic-let' forms outside the other binding forms.  if this
had been done right, IMNSHO, `let' and all its friends would take a
"variable name specification" instead of just a name.  (this is akin to
Common Lisp's "function name specification", allowing `foo' and `(setf
foo)' as function names.)  e.g., where ISO Lisp now requires

    (dynamic-let ((foo 1))
      (let ((bar 2))

I would like to see

    (let* (((dynamic foo) 1)
	   (bar 2))

NOTE: there is no `dynamic-let*', so you may have to nest `dynamic-let's to
get the effect of what should have been `dynamic-let*'.

ISO Lisp did away with most of the other binding forms (do, do*, dolist,
dotimes), preferring the more Algol-like looping construct `while', which
_undoubtedly_ will make it more popular with the hordes, so we won't have
the "problem" of introducing `dynamic-do' and friends, but this variant
treatment of the namespace/property/whatever specifier `dynamic' is still
an anomaly that should be fixed.

now, why would I want to have a uniform treatment of something that will be
used only once?  I don't think `dynamic' is the last of the variant forms
or properties of variables we will see.  since ISO Lisp is intended to be
easier in the foreign function interface department than most other Lisps,
(that's how I read it, anyway) it would make sense to use language-specific
properties on the variables.  e.g., if there's a global C variable `gargle',
how does one refer to it?  one way is to provide "indirection" through a
Lisp variable whose references get magically transformed into references to
the global C variable.  another is to make `gargle' a variable of a new and
different kind, and say `(foreign gargle)' just like one would say
`(dynamic gargle)' to refer that other special namespace/property/whatever.

such an open-ended definition of what a "variable name" is would afford
much needed latitude in extending ISO Lisp into special environments and
could have several uses besides language interfaces.  e.g., reading and
writing a memory-mapped I/O register requires a variable to be declared
"volatile" in C, and so does a variable that is shared among processes or
modified by interrupts.  lacking a `declare' mechanism, I think such a
general mechanism would make ISO Lisp succeed in areas where Lisp is now
being disregarded due to prejudice.  such a general mechanism would _also_
allow ISO Lisp to be compiled into other languages that support such things
without loss of expressive power or programmer convenience.

NOTE: ISO Lisp should not attempt define any of these extended variable
forms, but should also not prohibit their addition by an implementation
that needs them, such as it does by defining an entirely new and non-
orthogonal `dynamic-let' form.

(not that I'm anywhere near _happy_ with `while' and `for'.)