Re: on racket and other Lisps

"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]