M Jared Finder <mfinder@digipen.edu> wrote:
+---------------
| Wade Humeniuk wrote:
| > As for lexical variables I find it more likely that the creators of Scheme
| > created and developed versions of Lisp with lexical vars before developing
| > Scheme.  It is really doubtful that Scheme was "just born from the head
| > of Zeus".  The real progenitor or lexical vars was the long line of Lisps
| > created from the initial Lisp.  Lisp influenced Algol, Algol influenced 
| > Lisp, Frank influenced John, and on, and on, and on....
| 
| Of course Scheme didn't come out of nowhere, but there has to be some 
| Lisp that can claim to be the first Lisp with lexical variables.  Why 
| couldn't that Lisp be Scheme?
+---------------

Why speculate? You can just go to the R5RS itself
<http://www.schemers.org/Documents/Standards/R5RS/>
and see what they say:

    Introduction
    ...
    Scheme was the first major dialect of Lisp ... to use a single
    lexical environment for all variables...

Or better, the Gabriel and Steele paper, "The Evolution of Lisp"
<http://dreamsongs.com/NewFiles/Hopl2.pdf> [77 pages], says:

    The dialect of Lisp known as Scheme was originally an attempt by
    Gerald Jay Sussman and Guy Steele during Autumn 1975 to explicate
    for themselves some aspects of Carl Hewitt s theory of actors as
    a model of computation.
    ...
    Using MacLisp as a working environment, they decided to construct
    a tiny Lisp interpreter and then add the necessary mechanisms for
    creating actors and sending messages. The toy Lisp would provide
    the necessary primitives for implementing the internal behavior of
    primitive actors.

    Because Sussman had just been studying Algol [Naur, 1963], he
    suggested starting with a lexically scoped dialect of Lisp.
    It appeared that such a mechanism would be needed anyway for
    keeping track of acquaintances for actors.

But it also notes that:

    Lisp370 supported both special binding and lexical binding, as well
    as closures over both lexical and special variables, using a technique
    similar to spaghetti stacks. Jon L White spent calendar year 1977 at
    Yorktown Heights working on Lisp370 and then returned to MIT; his
    experience at IBM had some in uence on subsequent MacLisp development
    and on the NIL dialect.

And from the "uncut" version <http://dreamsongs.com/NewFiles/HOPL2-Uncut.pdf>
(a draft of a longer version of the HoPL paper that was never published,
see <http://dreamsongs.com/Essays.html>):

    Scheme was one of the first languages to have taken seriously
    the implications of lexical scoping (as opposed to local scoping,
    which had been in use in Lisp compilers for almost a decade) and
    first-class functions. Namely, Scheme correctly treated closures
    a closure is a function along with the local environment within
    which it was de ned. Furthermore, it embraced the Actor model of
    computation in the sense that function calling could be treated
    as a jump to a procedure rather than as a call to a procedure
    that would return.

Really, "The Evolution of Lisp" [either/both version(s)] is probably
what you want to read if you care about this. It contains a *lot* more
about the history of lexical scoping in Lisp than mentioned above...


-Rob

-----
Rob Warnock			<rpw3@rpw3.org>
627 26th Avenue			<URL:http://rpw3.org/>
San Mateo, CA 94403		(650)572-2607