Re: another way to shoot yourself in the foot?

[Robert A Duff <bobduff@shell01.TheWorld.com>]

"Jeffrey R. Carter" <spam.jrcarter.not@spam.acm.org> writes:

> Robert A Duff wrote:
>> Well, I don't think so, but anyway, this is the only way
>> return of limited types can make sense.  The Ada 83 way
>> (return is by copy, even for limited) is just wrong.
>> And the Ada 95 way (return by reference) is confusing
>> and nearly useless.
>
> I don't know about "nearly useless". The only thing you could do with a
> limited function result in Ada 95 (and Ada 83) was pass it to a
> subprogram or entry.

Not quite the "only" -- you could rename it.

> ...There are times when that is useful.

But in Ada 95, if you say:

    P(F(...));

where F returns limited, you are not passing a limited object,
but an implicit reference to some object that already existed before the
call to F.  You can do that more clearly by having F return
an access type.  I really think return-by-ref was a mistake.
Too bad we didn't think of it in 1992.  For that matter, too
bad JDI didn't think of it in 1980. ;-)

> The new way seems to be biased towards build in place for object
> initialization.

Well, there are only two ways a function call can be used: to initialize
a new object, or to update an existing object (i.e. on the right-hand
side of an assignment statement).  But don't forget there are a dozen or
so different ways of creating new objects (components, parameters,
parent parts of aggregates, etc).  All of these are allowed for
build-in-place function calls.  The only thing that's not allowed is the
assignment statement.

You can still say:

    P(F(...));

where F returns a limited type.  Yes, there's a new object being created
(the formal parameter of P), and F is being used to initialize that
object (in place!).  In Ada 2005, functions always return newly-created
objects, which I think is appropriate.

A couple more examples:

    X : Array_Of_Lim := (1..10 => F(...));

    if F(...).Flag then ...

The last one is pretty silly -- it creates a new limited object,
grabs a boolean flag out of it, and then throws the whole thing
away.

- Bob