Re: why Ada type casting is different from other languages? newType(value) vs. (newType)value

["Randy Brukardt" <randy@rrsoftware.com>]

"Georg Bauhaus" <rm.dash-bauhaus@futureapps.de> wrote in message 
news:53c25e58$0$6665$9b4e6d93@newsspool3.arcor-online.net...
...
> I have read plausible justifications for the choice of type conversion 
> syntax
> of both Ada and C. But conceptually, I think that C++ has found a better
> solution. It is more Ada like, perhaps, whenever C++ suggests to 
> explicitly
> state the intent:
>
>    static_cast<float>(i + j)
>
> seems pretty clear (even when it might be unnecessary). Ada's and C's
> overloading of round brackets for several different things might be
> tempting at first, but the temptation ceases once ease of understanding
> the differences is considered more important.

But the question here is whether a detailed understanding of the differences 
is necessary the vast majority of the time. In Ada, at least, that's 
typically not necessary. One simply thinks of anything of the form 
"name(args)" as a named mapping from "args" to some result type. Assuming 
one is looking at existing code that already compiles (which is typically 
the case when one is trying to understand an expression [if you just wrote 
it, you hopefully still remember what you meant, and hopefully no one is 
checking in code that doesn't compiler], you usually don't need to know the 
exact types involved.

And if you do, in a language like Ada you need to look up every name 
involved and try to figure out which declaration is involved. Hopefully you 
have an IDE to do it, because it's never fun with just text tools. And 
that's true for type conversions (finding the location of the declaration 
can be unpleasant if there are a lot of use clauses and withs) as well as 
functions and arrays (since objects can be the results of parameterless 
functions and possibly hidden by nesting).

My point being, that knowing that something is a type conversion or an array 
indexing only helps a little. And they're really ways of looking at the same 
thing (a mapping) -- something that Dmitry likes to call an interface.

                              Randy.