Re: another way to shoot yourself in the foot?

[Adam Beneschan <adam@irvine.com>]

On Jun 20, 3:05 am, christoph.gr...@eurocopter.com wrote:
> > --- Factory ads ---
> > with Named;
> > with Some;
>
> > package Factory is
> >    function Create(class: String; name: String) return
> > Named.Object'Class;
> > end Factory;
>
> > --- Factory.adb ---
>
> > with Ada.Strings.Fixed; use Ada.Strings.Fixed;
> > with Some;
>
> > package body Factory is
> >    --- this one is ugly, but in sake of simplicity ...
> >    function Create(class: String; name: String) return
> > Named.Object'Class is
> >    begin
> >       if Index(class, "Some") /= 0 then
> >          return Some.Create(name);
> >       end if;
> >       raise Program_Error with "Unknown class " & class;
> >    end;
> > end Factory;
>
> Since Some.Object is limited, Factory must construct in place. The
> normal return statement produces a copy

Not true.  If a function result is a limited type, a "return"
statement can be used with a function call.  The idea is that the
build-in-place would propagate.  For example, say you initialize an
object of a limited type:

  Obj : Limited_Type := Func3(Arg);

where Func3 has an extended return statement:

  return Result : Limited_Type do
    Result.Field1 := ... code to set up Result, etc.
  end return;

When this happens, I believe the effect is the same as if the code in
the extended return that sets up Result's components actually works
directly with Obj, at least semantically.  To implement this, the
address of Obj has to be passed to Func3 somehow so that Func3 can
work directly with Obj.

If, instead, you say

  Obj : Limited_Type := Func1(Something);

and Func1 does this:

  return Func2(Something_Else);

and Func2 does this:

  return Func3(Arg);

and Func3 works as above, then in effect the address of Obj gets
passed to Func1, which then propagates it to Func2, which propagates
it to Func3.  No copy (in Ada semantics) is involved.

Dmitry is right that if the language allowed this "return" to copy an
object of a limited type like this, it would be a serious language
design error, since that goes against the whole point of limited
types.  But, in fact, there is no such error.  The language is fine.

                            -- Adam