🚀 go-pugleaf

In article <5811@lanl.gov> jlg@lanl.gov (Jim Giles) writes:
> From article <7101:Nov1008:51:4590@kramden.acf.nyu.edu>, by brnstnd@kramden.acf.nyu.edu (Dan Bernstein):
> > I believe that arrays should be a much more fundamental part of the
> > language, and that pointers and arrays should be much more cleanly
> > separated than they are in C. You know I hold this opinion. [...]
> No, I _don't_ know that you hold this opinion.

You did say in one article something like ``in fact, it was quite clear
that [some allusion to me] does not believe this.'' The belief you were
referring to was the general belief that pointers somehow make arrays
redundant.

Then you suddenly turn about and accuse me of believing exactly the same
thing. That's disgusting.

> This is the first
> time you have explicitly stated it.

Outside of e-mail, perhaps, but I've implied it enough times.

> In previous articles, I always held the features I support as
> a unified group (and you _seemed_ to attack them as such).

Sorry if it came across that way. By the ``Giles Gaggle'' I only mean
the higher-level features: lists (you say ``sequences''), Lists (you say
``recursive data structures''), etc. Their common feature is that they
can be implemented on top of structs, arrays, and pointers. It would be
silly to have only two of the basic three, since the third cannot be
implemented in terms of them.

> When you
> make a statement about the features I support (that you collectively
> call the "Giles Gaggle"), I naturally assume that you are referring
> to _all_ of them.

You support function calls. Do you think I was attacking function calls?
Obviously not.

> I would still have disagreed, of course.  I see no reason that arrays
> should be singled out as the only higher-level construct to be present
> and still inefficiently simulate all the others with pointers.

Arrays are at the same level as pointers and structs. None of the
features can be implemented in full generality in terms of the other
features. Implementing pointers in terms of arrays, for instance, loses
dynamic allocation. Implementing arrays in terms of the others loses
memory space. And so on.

---Dan