(DEFINE (DRIVER-LOOP-1 ENV FORM)
(COND ((ATOM FORM)
(DRIVER-LOOP ENV (PRINT (EVAL FORM ENV))))
((EQ (CAR FORM) 'DEFINE)
(DRIVER-LOOP (BIND (LIST (CAADR FORM))
(LIST (LIST '&PROCEDURE
(CDADR FORM)
(CADDR FORM)
ENV))
ENV)
(PRINT (CAADR FORM))))
(T (DRIVER-LOOP ENV (PRINT (EVAL FORM ENV))))))
For DRIVER-LOOP see Figure 1.
For BIND see Figure 3.
For EVAL see Figure 7.
Figure 8
Modified Driver Loop for Lexically Scoped LAMBDA-notation
It doesn't work. This patch does put the finishing touch on the preservation of referential transparency. It does it so well, that each new definition can only refer to previously defined names! We have lost the ability to make forward references. We can't redefine a procedure which had a bug in it and expect old references to use the new definition. In fact, we cannot use DEFINE to make a recursive procedure. {Note Y-Operator} The &PROCEDURE-object for each defined procedure contains an environment having only the previously defined procedures.
We are finally confronted with the fact that we have been seeking the impossible. We have tried to attain complete referential transparency (in the expectation that modularity would be enhanced), while trying also to retain the notion of an incremental, interactive top-level loop for reading definitions. But the very existence of such a top level inherently constitutes a violation of referential transparency. A piece of code can be read in which refers to an as yet undefined identifier (the name of a procedure, for example), and then later a definition for that identifier read in (thereby altering the meaning of the reference).
If we stubbornly insist on maintaining absolute referential transparency in our language, we are forced to eliminate the incremental top level loop. A program must be constructed monolithically. We must read in all our procedure definitions at once, close them all together, and then take one or more shots at running them. (This is the way many Algol implementations work; development of large systems can be very difficult if parts cannot be separately constructed and compiled.) We are forced to give up interactive debugging, because we cannot redefine erroneous procedures easily. We are forced to give up incremental compilation of separate modules.
