Problem Eliminating constructors

Problem Eliminating constructors

[Victor Porton]

package A is

  type A_Type is tagged
    record
      X: Integer;
    end;
    
  function Create(X: Integer) return A_Type; -- guess what is the body
  
end A;

Then I have

type B_Type is new A.A_Type with
  record
    Y: Integer;
  end;

Compiler requires me to override Create as the return type changes.
But it is meaningless as now I need Create with two parameters
instead of one.

What to do?

Maybe there are a wau to make "function Create(X: Integer) return 
A_Type" not a primitive operation so that compiler will not more
request to override it?

Or maybe just move declaration of this func out of package A?

Re: Problem Eliminating constructors

[John English]

Victor Porton wrote:
> 
> package A is
> 
>   type A_Type is tagged
>     record
>       X: Integer;
>     end;
> 
>   function Create(X: Integer) return A_Type; -- guess what is the body
> 
> end A;
> 
> Then I have
> 
> type B_Type is new A.A_Type with
>   record
>     Y: Integer;
>   end;
> 
> Compiler requires me to override Create as the return type changes.
> But it is meaningless as now I need Create with two parameters
> instead of one.
> 
> What to do?

Take Create out of package A and make it a child of the package:

  function A.Create(X: Integer) return A.A_Type is ...;

Now Create will no longer be a primitive operation of A_Type since
it isn't declared in the same package spec, but you can refer to
it in exactly the same way (except you would need "with A.Create"
to be able to call it).

-----------------------------------------------------------------
 John English              | mailto:je@brighton.ac.uk
 Senior Lecturer           | http://www.it.bton.ac.uk/staff/je
 Dept. of Computing        | ** NON-PROFIT CD FOR CS STUDENTS **
 University of Brighton    |    -- see http://burks.bton.ac.uk
-----------------------------------------------------------------

Re: Problem Eliminating constructors

[Victor Porton]

In article <3E281F79.A309AD5E@brighton.ac.uk>,
	John English <je@brighton.ac.uk> writes:
> Victor Porton wrote:
>> 
>> package A is
>> 
>>   type A_Type is tagged
>>     record
>>       X: Integer;
>>     end;
>> 
>>   function Create(X: Integer) return A_Type; -- guess what is the body
>> 
>> end A;

[skip]

>> Compiler requires me to override Create as the return type changes.
>> But it is meaningless as now I need Create with two parameters
>> instead of one.
>> 
>> What to do?
> 
> Take Create out of package A and make it a child of the package:
> 
>   function A.Create(X: Integer) return A.A_Type is ...;
> 
> Now Create will no longer be a primitive operation of A_Type since
> it isn't declared in the same package spec, but you can refer to
> it in exactly the same way (except you would need "with A.Create"
> to be able to call it).

Also it does not work if A is a subpackage (as it really is). I would 
need also to make A a child package instead what would force me to do 
complete restructurization of the packages tree.

Re: Problem Eliminating constructors

[Simon Wright]

porton@ex-code.com (Victor Porton) writes:

> package A is
> 
>   type A_Type is tagged
>     record
>       X: Integer;
>     end;
>     
>   function Create(X: Integer) return A_Type; -- guess what is the body

Could you make Create return A_Type'Class? (it means you probably have
to initialize at creation:

  declare
     My_B : A.A_Type'Class := B.Create (...);

> end A;

Re: Problem Eliminating constructors

[Rodrigo García]

Victor Porton wrote:
> package A is
> 
>   type A_Type is tagged
>     record
>       X: Integer;
>     end;
>     
>   function Create(X: Integer) return A_Type; -- guess what is the body
>   
> end A;
> 
> Then I have
> 
> type B_Type is new A.A_Type with
>   record
>     Y: Integer;
>   end;
> 
> Compiler requires me to override Create as the return type changes.
> But it is meaningless as now I need Create with two parameters
> instead of one.
> 
> What to do?

   You do not need a constructor for this simple case. This will create 
an A_Type object and initialize X to value 5.

   declare
      My_A : A.A_Type := (X => 5);

Similarly, this will create a B_Type object with X=5 and Y=6.

   declare
      My_B : B_Type := (X => 5, Y => 6);

Alternatively, you can use discriminants as well:

   type A_Type (I : Integer) is tagged
      record
         X : Integer := I;
      end record;

And then:

   type B_Type (J : Integer; K : Integer) is new A_Type (I => J) with
      record
        Y : Integer := K;
      end record;

With this solution, you are forced to provide initial values in the 
creation.

Rodrigo

Re: Problem Eliminating constructors

[Victor Porton]

In article <3E2BDFD8.4070805@epfl.ch>,
	Rodrigo Garc�a <rodrigo.garcia@epfl.ch> writes:
> Victor Porton wrote:
>> package A is
>> 
>>   type A_Type is tagged
>>     record
>>       X: Integer;
>>     end;
>>     
>>   function Create(X: Integer) return A_Type; -- guess what is the body
>>   
>> end A;
>> 
>> Then I have
>> 
>> type B_Type is new A.A_Type with
>>   record
>>     Y: Integer;
>>   end;
>> 
>> Compiler requires me to override Create as the return type changes.
>> But it is meaningless as now I need Create with two parameters
>> instead of one.
>> 
>> What to do?
> 
>    You do not need a constructor for this simple case. This will create 
> an A_Type object and initialize X to value 5.
> 
>    declare
>       My_A : A.A_Type := (X => 5);
[skip]

Oh, Rodrigo, I oversimplified the real situation. Initialization with
just aggregates is possible only in the example, really I need namely
constructor functions.

Well, currently I switched to initialization by calling a procedure.

It would be nice if Ada0X would allow to make a primitive operation
non-virtual.

E.g. we can introduce "pragma Freeze(TYPE)".

Re: Problem Eliminating constructors

[Dmitry A. Kazakov]

On Tue, 21 Jan 2003 02:07:29 +0500, porton@ex-code.com (Victor Porton)
wrote:

>In article <3E2BDFD8.4070805@epfl.ch>,
>	Rodrigo Garc�a <rodrigo.garcia@epfl.ch> writes:
>> Victor Porton wrote:
>>> package A is
>>> 
>>>   type A_Type is tagged
>>>     record
>>>       X: Integer;
>>>     end;
>>>     
>>>   function Create(X: Integer) return A_Type; -- guess what is the body
>>>   
>>> end A;
>>> 
>>> Then I have
>>> 
>>> type B_Type is new A.A_Type with
>>>   record
>>>     Y: Integer;
>>>   end;
>>> 
>>> Compiler requires me to override Create as the return type changes.
>>> But it is meaningless as now I need Create with two parameters
>>> instead of one.
>>> 
>>> What to do?
>> 
>>    You do not need a constructor for this simple case. This will create 
>> an A_Type object and initialize X to value 5.
>> 
>>    declare
>>       My_A : A.A_Type := (X => 5);
>[skip]
>
>Oh, Rodrigo, I oversimplified the real situation. Initialization with
>just aggregates is possible only in the example, really I need namely
>constructor functions.

Ada has constructor function. IMO what it does need is user-defined
contructors. However, most of Ada people do not share my opinion. In
any case (your statement below) constructors always *covariant*.

>Well, currently I switched to initialization by calling a procedure.
>
>It would be nice if Ada0X would allow to make a primitive operation
>non-virtual.

It is pretty dangerous, so there has to be a strong rationale for this
(i.e. to allow contravariant parameters). In your case, you could make
Create class-wide, if you want to overload it:

 function Create (X : Integer) return A_Type'Class;
   -- creates A_Type

function Create (X, Y : Integer) return B_Type'Class;
   -- creates B_Type

---
Regards,
Dmitry Kazakov
www.dmitry-kazakov.de

Re: Problem Eliminating constructors

[Martin Krischik]

On Tue, 21 Jan 2003 10:44:37 +0100, Dmitry A. Kazakov wrote:

> It is pretty dangerous, so there has to be a strong rationale for this
> (i.e. to allow contravariant parameters). 

True. The amount of times where a missing "virtual" drove me insane in C++
is uncounted.

With Regards

Martin

-- 
Martin Krischik
mailto://Martin@krischik.com
http://www.krischik.com

Re: Problem Eliminating constructors

[Rodrigo García]

Victor Porton wrote:
> In article <3E2BDFD8.4070805@epfl.ch>,
> 	Rodrigo Garc�a <rodrigo.garcia@epfl.ch> writes:
> 
>>Victor Porton wrote:
>>
>>>package A is
>>>
>>>  type A_Type is tagged
>>>    record
>>>      X: Integer;
>>>    end;
>>>    
>>>  function Create(X: Integer) return A_Type; -- guess what is the body
>>>  
>>>end A;
>>>
>>>Then I have
>>>
>>>type B_Type is new A.A_Type with
>>>  record
>>>    Y: Integer;
>>>  end;
>>>
>>>Compiler requires me to override Create as the return type changes.
>>>But it is meaningless as now I need Create with two parameters
>>>instead of one.
>>>
>>>What to do?
>>
>>   You do not need a constructor for this simple case. This will create 
>>an A_Type object and initialize X to value 5.
>>
>>   declare
>>      My_A : A.A_Type := (X => 5);
> 
> [skip]
> 
> Oh, Rodrigo, I oversimplified the real situation. Initialization with
> just aggregates is possible only in the example, really I need namely
> constructor functions.

   I see... Have you tried with controlled types?

Rodrigo

Re: Problem Eliminating constructors

[Stephen Leake]

porton@ex-code.com (Victor Porton) writes:

> It would be nice if Ada0X would allow to make a primitive operation
> non-virtual.
> 
> E.g. we can introduce "pragma Freeze(TYPE)".

How is this better than a nested package?

package Foo is
   type Base is tagged private;

   package Constructors is
       function New_Base (Params : in ...) return Base;
   end Constructors;

private
   type Base is ...;

end Foo;

'New_Base' is not a primitive operation of Base, therefore it is not
dispatching.

I'm not clear why you want a subprogram that is primitive but not
dispatching. 

-- 
-- Stephe

Re: Problem Eliminating constructors

[Victor Porton]

In article <3E2D3245.2060903@epfl.ch>,
	Rodrigo Garc�a <rodrigo.garcia@epfl.ch> writes:
>>>Victor Porton wrote:
>>>
>> Oh, Rodrigo, I oversimplified the real situation. Initialization with
>> just aggregates is possible only in the example, really I need namely
>> constructor functions.
> 
>    I see... Have you tried with controlled types?

Do you mean to use type discriminants by Initialize procedure?

I suspect this is a size overhead in current compilers (Gnat 3.14/3.15 
for me).

Re: Problem Eliminating constructors

[Rodrigo García]

Victor Porton wrote:
> In article <3E2D3245.2060903@epfl.ch>,
> 	Rodrigo Garc�a <rodrigo.garcia@epfl.ch> writes:
> 
>>>>Victor Porton wrote:
>>>>
>>>
>>>Oh, Rodrigo, I oversimplified the real situation. Initialization with
>>>just aggregates is possible only in the example, really I need namely
>>>constructor functions.
>>
>>   I see... Have you tried with controlled types?
> 
> 
> Do you mean to use type discriminants by Initialize procedure?

   Yes, that's the idea.

> I suspect this is a size overhead in current compilers (Gnat 3.14/3.15 
> for me).

   Well, I implemented our simple example with and without controlled 
types and it is not a significant overhead.

   In my opinion, the use of controlled types is the only "standard" 
(and the cleanest) way that Ada proposes for constructors/destructors.

Rodrigo

Re: Problem Eliminating constructors

[Victor Porton]

In article <u8yxe5yv2.fsf@nasa.gov>,
	Stephen Leake <Stephen.A.Leake@nasa.gov> writes:
> porton@ex-code.com (Victor Porton) writes:
> 
>> It would be nice if Ada0X would allow to make a primitive operation
>> non-virtual.
>> 
>> E.g. we can introduce "pragma Freeze(TYPE)".
> 
> How is this better than a nested package?
> 
> package Foo is
>    type Base is tagged private;
> 
>    package Constructors is
>        function New_Base (Params : in ...) return Base;
>    end Constructors;
> 
> private
>    type Base is ...;
> 
> end Foo;

Very simple: I more like syntax without this additional package
as it is antinatural.

Re: Problem Eliminating constructors

[Stephen Leake]

porton@ex-code.com (Victor Porton) writes:

> In article <u8yxe5yv2.fsf@nasa.gov>,
> 	Stephen Leake <Stephen.A.Leake@nasa.gov> writes:
> > porton@ex-code.com (Victor Porton) writes:
> > 
> >> It would be nice if Ada0X would allow to make a primitive operation
> >> non-virtual.
> >> 
> >> E.g. we can introduce "pragma Freeze(TYPE)".
> > 
> > How is this better than a nested package?
> > 
> > package Foo is
> >    type Base is tagged private;
> > 
> >    package Constructors is
> >        function New_Base (Params : in ...) return Base;
> >    end Constructors;
> > 
> > private
> >    type Base is ...;
> > 
> > end Foo;
> 
> Very simple: I more like syntax without this additional package
> as it is antinatural.

It's perfectly "natural" in Ada, since it is the only way to do it. It
may not feel "natural" if you are used to some other language.

Is there any other problem with it, that "pragma Freeze (Type)" would
fix? 

-- 
-- Stephe

Re: Problem Eliminating constructors

[Grein, Christoph]

> package A is
> 
>   type A_Type is tagged
>     record
>       X: Integer;
>     end;
>     
    package Avoid_Primitiveness is
>     function Create(X: Integer) return A_Type; -- guess what is the body
    end Avoid_Primitiveness;
>   
> end A;
> 
> Then I have
> 
> type B_Type is new A.A_Type with
>   record
>     Y: Integer;
>   end;
> 
> Compiler requires me to override Create as the return type changes.
> But it is meaningless as now I need Create with two parameters
> instead of one.
> 
> What to do?
> 
> Maybe there are a wau to make "function Create(X: Integer) return 
> A_Type" not a primitive operation so that compiler will not more
> request to override it?
> 
> Or maybe just move declaration of this func out of package A?