Re: trying to migrate to 1.6.60

[jldasch at 3-cities dot com (John L. Daschbach)]

In <m2vh8n54au.fsf@magnus.bothner.com>, on 10/04/99 
   at 12, Per Bothner <per@bothner.com> said:

As Per points out, he is correct in terms of R5RS, which is the proper
standard to be using.

I have for some time apparently used an interpretation based on the
implementations of scheme I use (scm and guile) and perhaps more
importantly my understanding of the philosophy of scheme, which I now
realize are incorrect.  I mistakenly understood scheme to treat values and
procedures as equals (which it does) and that there were only these two
distinctions made regarding how a construct was evaluated.  However R5RS
makes it clear that syntactic keywords are not variables and that the
macro system is responsible for defining new bindings of identifiers to
syntactic forms.  This applies equally, it appears, to the core syntactic
forms as well as any established via the define-syntax family.

To me part of the elegance of scheme is that it abstracted code at the
highest level possible.  Distinctions regarding the evaluation of code
depended only on the structure of the form being evaluated and the context
of evaluation.  It is now clear to me that although R4RS allowed
implementations to use identifiers bound to syntactic forms as variables
(but discouraged this) R5RS does not.  Thus once a syntactic keyword has
been defined (and it's clear that this applies to any syntactic keyword,
not just the core keywords) it can no longer be manipulated by the set!
and let family but must use the syntax family.  This means that a clear
distinction is made between forms which have a variable bound to a lambda
expression as the operator and forms which have a identifier bound to a
syntax as the operator.

If I import code into my program and wish to override or modify the
behavior of a form, I have to use conditional code to treat both
possibilities.  Further, I'm not sure right now the transformation can be
done at the top level since there is no set-syntax!  It can be worked
around, but the loss of symetry and elegance is problematic.  Having to
always consider whether a binding is a syntax or a lambda expression seems
to fly in the face of the ideas behind scheme.  

-John 

-- 
-----------------------------------------------------------
jldasch@3-cities.com  (John L. Daschbach)
-----------------------------------------------------------