Path: ...!news.nobody.at!weretis.net!feeder8.news.weretis.net!newsfeed.xs3.de!nntp-feed.chiark.greenend.org.uk!ewrotcd!.POSTED.chiark.greenend.org.uk!not-for-mail
From: Mark Wooding <markw@distorted.org.uk>
Newsgroups: comp.lang.lisp
Subject: Re: on racket and other Lisps
Date: Thu, 30 May 2024 15:20:50 +0100
Message-ID: <86ikyv8jp9.fsf.markw@stratocaster.distorted.org.uk>
References: <87h6juklf3.fsf@yaxenu.org>
	<bbnepi1ir89f3t7ck6lbspn3uqns10jk56@4ax.com>
	<v335jg$8pci$1@dont-email.me>
Mime-Version: 1.0
Content-Type: text/plain
Injection-Info: chiark.greenend.org.uk; posting-host="chiark.greenend.org.uk:93.93.131.173";
	logging-data="14339"; mail-complaints-to="abuse@chiark.greenend.org.uk"
User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/24.5 (gnu/linux)
Cancel-Lock: sha1:BK9w6k2KtzVaEsCedp9zqYfOC90=
Originator: markw@stratocaster.unsafe.distorted.org.uk ([172.29.199.9])
Bytes: 6338
Lines: 132

"B. Pym" <No_spamming@noWhere_7073.org> writes:

> On 1/4/2024, George Neuner wrote:
>
> > Racket is derived from Scheme (which also is NOT Lisp).
>
> The following code snippet runs under both Gauche Scheme and
> SBCL, and the output is identical:
>
[...]
>
> Does this tend to prove that Scheme is not a Lisp?

I think you're looking in the wrong place.

One of Lisp's most obvious defining features is its homoiconicity.  This
wasn't always appreciated.  Lisp 2 wanted an Algoloid surface syntax; I
don't know how this would have worked, but probably it would have
abandoned homoiconicity, and I probably wouldn't think of it as a Lisp.

Lisp, as we understand it now, starts out by defining a syntax for
literal data: symbols, numbers, strings, arrays, and, of course, cons
cells and lists.  As a next step, it defines semantics for a subset of
these data items as a programming language.  The result is a language
which is particularly good at thinking about itself.

One standard feature of Lisp languages is the special operator `quote'.
In a properly homoiconic Lisp, `quote' is /trivial/: if X is any datum,
then the result of evaluating (quote X) is X itself.

(Aside: am I alone in thinking that (quote X Y ... Z) ought to be
defined, and equivalent to (values (quote X) (quote Y) ... (quote Z))?)

This is not true in Scheme.  The R4RS appendix introduced a hygienic
macro system which is incompatible with homoiconicity as demonstrated
through `quote'.  For example:

        (define-syntax demo
          (syntax-rules ()
            ((_ form)
             (begin (write (quote form)) (newline) form))))

        (let ((x 1))
          (let-syntax ((whoops
                        (syntax-rules ()
                          ((_ y)
                           (let ((x 2))
                             (demo (values y x)))))))
            (whoops x)))
        ; -| (values x x)
        ; => 1 2

If we're to believe `quote', then the form being evaluated is
(values x x), which should return two copies of the same value.  But it
actually returns two different values -- how can this be?

Maybe `write' isn't up to the job and the two `x' symbols in that list
aren't actually the same.

        (define-syntax inspect
          (syntax-rules ()
            ((_ (expr . vals) form . body)
             (let ((expr (quote form)))
               (call-with-values (lambda () form) (lambda vals . body))))))

        (let ((x 1))
          (letrec ((show (lambda (which what x)
                           (display which)
                           (write-char #\space)
                           (display what)
                           (display " = ")
                           (write x)
                           (newline)))
                   (compare (lambda (what whats x y)
                              (show "first" what x)
                              (show "second" what y)
                              (display whats)
                              (display #\space)
                              (display (if (eq? x y) "equal" "unequal"))
                              (newline)))
                   (report (lambda (expr a b)
                             (compare "argument" "arguments"
                                      (cadr expr) (caddr expr))
                             (compare "value" "values"
                                      a b)
                             (values a b))))
            (let-syntax ((gotcha
                          (syntax-rules ()
                            ((_ y)
                             (let ((x 2))
                               (inspect (expr a b) (values y x)
                                 (report expr a b)))))))
              (gotcha x))))
        ; -| first argument = x
        ; -| second argument = x
        ; -| arguments equal
        ; -| first value = 1
        ; -| second value = 2
        ; -| values unequal
        ; => 1 2

That seems conclusive: `eq?' thinks that the two `x's are the same
symbol, but they sure don't behave the same.

Of course, what's going on here is that Scheme's hygienic macros don't
see /symbols/: they see /identifiers/ which maintain additional
information about which scope they're bound in, and `quote' strips this
information away.  Which means that `quote' is nontrivial, and Scheme is
heteroiconic.

I think R3RS Scheme was a Lisp.  However, the report describes
expression syntax in terms of /characters/ rather than in terms of
Scheme data items which, in retrospect, should have been seen as a
warning.

> Those who program in CL (COBOL-Like) are using the Loop language,
> which is not a dialect of Lisp.  Furthermore, they are forcing those
> who read their code to learn the Loop language.

Nobody forces you to use `loop' in Common Lisp, and it's not like it's
particularly hard to read.  I could understand if the hill you wanted to
die on was Common Lisp's `format' syntax (though I'm a fan, and you'll
have to prise `format' out of my cold, dead hands), but `loop' is just
not that big a deal.

About the only thing it has which isn't obviously available elsewhere is
a means for building lists efficiently in order.

> Let's just say that Scheme is a better Lisp than CL (COBOL-Like) is.

No.  Scheme is not a Lisp.

-- [mdw]