[plt-scheme] to define, or to let

From: Richard Cleis (rcleis at mac.com)
Date: Sat Mar 20 23:59:29 EST 2004

If it matters to anyone, I am actually *learning* from this discussion.

For example:
"R5RS requires the interpreter to evaluate all the right-hand sides, 
assign them all to the left-hand variables."
This makes the issue clear to me.

Thanks very much.  Now y'all go have a beer; nay, three beers.


On Mar 20, 2004, at 9:49 PM, Eli Barzilay wrote:

>   For list-related administrative tasks:
>   http://list.cs.brown.edu/mailman/listinfo/plt-scheme
> On Mar 20, Bradd W. Szonye wrote:
>> Eli Barzilay wrote:
>>> I don't know (and certainly don't care) about C/C++ standards,
>>> their gurus, and their quiet or noisy changes.
>> What's up with the parochial tone?
> I'm just tired of this.  I obviously didn't say anything you didn't
> know about, you didn't say anything I didn't know about (except fot
> that C/C++ stuff, which I *really* don't care about).  My opinion is
> not surprising given the fact that there was a time where I had to
> choose an implementation, and I went with PLT.  Your opinion is also
> quite known by now.  This is now at the beginning of an opinion
> festival -- lots of texts, almost zero content.  Do you want to do
> that?
>> Quiet changes are a major risk factor for language implementors and
>> users. While you may reasonably not care about C/C++ stuff, and you
>> may not have heard about "quiet changes" before, it's quite foolish
>> to ignore wisdom from another community just because it's another
>> community.
> My community uses a standard that leaves important things open for
> implementations.  It is a standard that forces implementations to do
> such things, and indeed implementations do them and they usually do a
> very good job documenting such changes.
>>> Having said that, I don't see any quitness problem -- open up the
>>> MzScheme manual, and all places that have some extensions are
>>> clearly specified.
>> Just because it's documented doesn't mean that it isn't quiet.
>> Indeed, quiet changes normally *are* documented. A feature is
>> "quiet" when you can't tell whether it exists at compile time.  If
>> you don't notice it in the docs, you won't know about the problem
>> until it breaks at runtime.
> Strictly speaking, the following:
>   (defun foo (x) x)
> is valid at Scheme's compile time.
>>> It's easy -- search the help-desk for `foo', and if it is found in
>>> the R5RS and in the MzScheme manual, then this is probably an
>>> instance of standard behavior in R5RS and an extension discussed
>>> in MzScheme.  `letrec' will get you to where the extensions are
>>> defined.
>> That's missing the point. How will a user even know to look for the
>> extension?
> Because it is a user of *Scheme*.
>>> Is there anything "less quiet" that is needed? Is there any
>>> implementation that doesn't change things in a well-advertised
>>> way?
>> First, I wouldn't call the letrec extension "well-advertised." The
>> compiler doesn't report it at all,
> What should the compiler do?  Spit a warning?  That'll be as good as
> forbidding it, which is the whole point of an *extension*.
>> and the docs don't make any special note of it.
> It's under "local binding".  It is the only place where `letrec' is
> indexed.  What more do you want?
>>> Is there any implementation that does *exactly* R5RS, nothing
>>> more, nothing less? And the most important question: Is there any
>>> point in continuing this thread?
>> Definitely not, if you're only going to contribute this kind of
>> rant.  You obviously did not understand what "quiet change" means,
>> yet you went on for a screenful spewing bile at the idea, apparently
>> just because it came from the C/C++ community.
> You have things completely confused.  The reason I don't like this
> discussion is that it will lead nowhere.  When I wrote my reply I
> didn't care for the C/C++ community, and it might be surprising, but I
> still don't care about them -- yet this has nothing to do with the
> fact that this thread is leading nowhere.  You are talking in a forum
> that is dedicated to an implementation that has some intentional
> design decisions like the specified evaluation order and like this
> behavior of letrec.  By speaking in this forum against these
> intentional features you should expect similar reaction as posting a
> "Scheme is stupid, use Python" on c.l.l.
> Now, please don't refer to my posts as "bile", and to me typing as
> "spewing", unless you really want this discussion to deteriorate at
> such a high speed.
> -- 
>           ((lambda (x) (x x)) (lambda (x) (x x)))          Eli 
> Barzilay:
>                   http://www.barzilay.org/                 Maze is 
> Life!

Posted on the users mailing list.