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

[Robert A Duff <bobduff@world.std.com>]

"Ken Garlington" <Ken.Garlington@computer.org> writes:

> "Robert A Duff" <bobduff@world.std.com> wrote in message
> news:wccofutg3ku.fsf@world.std.com...
> : "Ken Garlington" <Ken.Garlington@computer.org> writes:
> :
> : > More generally, of course, there are rational numbers that are not
> exactly
> : > representable as floating point numbers, so I don't see why a compiler
> : > should accept x/y as a floating-point literal.
> :
> : You misunderstand my point.
> 
> No, I just disagree with it.

With all respect, I must insist that:  No, you don't disagree, you
misunderstand.  ;-) ;-)

You misunderstand what I mean by "literal" (which is exactly what the
Ada RM means by "literal", too).

> : Of course x/y is not a literal.
> : My claim is that you shouldn't have to write ".0" on a floating point
> : literal that happens to be an integer.  That is,
> :
> :     X: Float := 0;
> :     Y: Float := 1/2;
> :
> : should be legal.
> 
> But if 1/2 is not a literal, then what is it?

Certainly 1/2 is not a literal.  Not in Ada, and not by me.

>... CW would say that it is a
> division operation involving two integers; why should the result be a
> floating-point number?

I would say, it's a division operation involving two *literals*
(where literal implies no particular type).
The interpretation of those literals should be resolved by the context.

>... If we are to have implicit casts of integers to
> floating point values, why not then permit the more general:
> 
> Y : Float := ferble;
> 
> where "ferble" is a function that returns an integer (or, for that matter,
> any fixed-point) type?

Why not?  Because it makes no sense.  Converting type Standard.Integer
to Standard.Float probably makes no sense.  But implicitly converting
"1" to (say) Float *does* make sense.  I was only talking about
literals.

Note that Ada always converts literals to some particular type.

Note also that I'm not advocating all manner of implicit conversions.
Certainly no implicit conversions that might lose information.

> For that matter, why not Y : Float := "one half"; as you suggested
> (unintentionally) in a separate post?

You got me there!  ;-)

> In general, I'm not a fan of DWIM compilers (PL/M being a favorite example
> of mine).

Agreed (in general).

- Bob