Re: The Red Language

[Brian Rogoff <bpr@shellx.best.com>]

On Fri, 12 Sep 1997, Robert A Duff wrote:
> No underscores in numeric literals.  I really like Ada's ability to say
> 1_000_000, rather than 1000000, and I don't understand why many people
> on't use it.  Red doesn't allow it.

Yes, its little details like this that I really like about Ada.

> Parameter passing semantics is nailed down.  (E.g. the programmer
> chooses whether pass-by-ref-read-only vs. pass-by-copy-read-only is
> used.)

This sounds interesting.

> Weaker overload resolution rules (than Ada).  Eg no top-down resolution,
> except in limited cases.  Function result types not considered for
> resolution.  But enum lits can be overloaded (and there's no pretense
> that they're functions).

> More user-defineable stuff.  Like literal notation, array indexing and
> slicing notation, dot-selection notation, etc.  One can redefine the
> meaning of case statements and for loops, for a given type.

This also sounds very nice. Frequently Ada proponents argue that such
capabilities hinder readability, but one could argue that overloading and 
use clauses similarly hinder readability. I prefer to think about
readability in the context of a good programmer, in whose hands these 
features would lead to more readable programs (IMO of course). In
particular, I'd like to have user definable infix operators for such things 
as convolution, morphological operations on images (erosion, dilation,
etc.) and also the ability to redefine array indexing to create associative 
arrays and such.

> No named-notation parameters.

This is a feature I miss very much when I'm not using Ada, as I use named 
parameters quite a bit and feel it contributes greatly to readability.

> Generics: Capsules and subprograms can be generic, but so can types.
> Generic instantiation is implicit.  (See recent thread arguing about the
> readability of such a feature.  The examples in the Red manual look
> pretty readable to me, in this regard.)

I was beginning to think I was the only person who liked Ada and thought
this way :-). I certainly think a little bit of optional implicit
instantiation reduces clutter and leads to more readable code. I reject the 
argument that it can lead to an unreadable mess in the same way I'd reject 
a similar argument about use clauses or overloading.

-- Brian