Re: Static typing (Was Re: Better support for garbage collection)

[Brian Rogoff <bpr@shell5.ba.best.com>]

On Mon, 19 Mar 2001, Robert A Duff wrote:
> Brian Rogoff <bpr@shell5.ba.best.com> writes:
> > I don't understand what you mean. Are you complaining about the fact that 
> > '0' is an int, for instance?
> 
> Yes.  I think there should be many integer types (as in Ada),
> so it makes no sense to say that '0' is an 'int' just because it looks
> like an int.  The type of '0' is determined by context in Ada,
> and I like that.

Yes, I like that too. MLs kind of suck compared to Ada when it comes to 
scalars. Of course, since MLs don't have overloading (yes, SML has some 
fixed overloading but that's worse than no overloading IMO) you can't
really expect them to handle scalars as well. Even to get something like a 
Positives or Naturals you have to roll them yourself using the module
system. 

> One thing I don't like in Ada is that '0' can't be a Float.
> After all, when I write the rational number "one half" on
> a piece of paper, I can write something like "1/2", and everybody knows
> what I mean.  I don't write "1.0/2.0" -- the ".0" is superfluous.

Hmmm, that one never bothered me, but now that you mention it. 

> Another thing I don't like is that if I write (for example), an
> exact-rational-arithmetic package in Ada, I can't use literals --
> literals are only allowed for the built-in kinds of types.

Yes, *that* is a problem. There are quite a few places in Ada where I'd 
like to make user defined types have capabilities of builtins, but can't. 
It's also the case that if you wanted to make an STL inspired library have 
Ada-like iteration (over a range say) rather than C/C++ like iteration you
are also stuck. 

> All of the above points are related: the context should determine the
> type of a literal.  Then, after overload resolution has determined the
> type of a literal, there should be a compile-time check that it is of
> the right form -- the form should not *determine* the type.  Eg, if the
> type of 1.2 turns out to be Integer, that should be illegal.  If the
> type of 1.2 could be either Integer or Float, that should be ambiguous
> and therefore illegal, whereas in Ada, it chooses Float.

OK, I'm convinced. Maybe this next generation language should be named 
"Grace" or "Hopper" ;-)

-- Brian