Newsgroups: comp.lang.scheme
Path: cantaloupe.srv.cs.cmu.edu!das-news2.harvard.edu!news2.near.net!news.mathworks.com!news.alpha.net!uwm.edu!spool.mu.edu!agate!darkstar.UCSC.EDU!news.hal.COM!decwrl!netcomsv!netcom.com!netcom9!vanmeule
From: vanmeule@netcom9.netcom.com (Andre van Meulebrouck)
Subject: Re: A proposal for #f and '() in the GNU extension language
In-Reply-To: lux@rio.heidelbg.ibm.com's message of 26 Oct 1994 13:11:42 GMT
Message-ID: <VANMEULE.94Oct28023823@netcom9.netcom.com>
Sender: vanmeule@netcom.com (Andre van Meulebrouck)
Organization: NETCOM On-line services
References: <GUNTER.94Oct25171012@netcom9.netcom.com> <38lkie$ius@kaa.heidelbg.ibm.com>
Date: Fri, 28 Oct 1994 09:38:23 GMT
Lines: 58

lux@rio.heidelbg.ibm.com (Wolfgang Lux) writes:

>The distinction between #f and '() is not just a distinction between
>two different values like 1 and 2; it plays a crucial rule with
>conditionals. If #f and '() are different values (as they are in most
>current Scheme implementations :-), then only #f counts as boolean
>value false in conditionals, while the empty list will be taken as a
>true value. 

Hate to sound like a purist but I have never liked the fact that
anything other than #f counts as #t in a boolean context.  To me that
is type incoherent (and I'm *not* big on typing a la ML, but golly!
Why be sloppy about such things?).

I would love to see booleans require #f and #t and anything else
should raise an error.  If you were to implement these things in
lambda calculus that's how they would behave.  If Scheme wasn't so
loose with typing that's how they should behave...any other behavior
seems slippery and requires you to either memorize a list of quirks or
have a Scheme Revised^n Report handy at all times.  Yuk.  I'd rather
be able to refer to my intutions about typing behavior and formal
systems on typing.

The upside here is that as a programmer you don't have to make use of
such items of permissive behavior.  (I.e. you're free to adhere to
much stricter practices than the Scheme standard demands.)

Further, I'm not fond of the treatment of () in Scheme.  To me this is
a constant that one should *never* be required to quote.  And its data
type should be type list (I view it as a constant list and not as an
atom).

On all these questions my first thought is always "How would it be
coded it in lambda calculus?" and I think that's a wonderful guide in
these matters.

I suppose however that these things will forever be a matter of
"religious" debate and will never be agreed on in the foreseeable
future. 

I also think many of these issues reflect the thinking of a language
that has latent typing and hasn't ever had to deal with the rigors of
typing that languages like ML have had to deal with; instead of being
decided on by referring to formal systems that deal with types, they
just get decided on by arbitrary "religious" sentiments that LISP
programmers happen to have, and whoever wields the most influence at
Scheme committee meetings.

I don't mean to start a religous debate/war/jihad--I just wanted to
interject a different way of looking at these matters.

Here's to a brighter (and more formal) future!  =:0)

Cheers!
-- 
+------------------------------------------------------------------------+
| Andre van Meulebrouck.  For personal data:  finger vanmeule@netcom.com |
+------------------------------------------------------------------------+
