Classwide Parameter?

Classwide Parameter?

[matthias_k]

Hiya,

I have experimented a little, and I can't really figure out what I need 
classwide parameters for. Consider this code:

package Shape_Pkg is
    type Shape is abstract tagged null record;
    procedure Draw (obj: Shape);
end;

package Circle_Pkg is
    type Circle is new Shape with null record;
    procedure Draw (obj: Circle);
end;

...

procedure Test is
    c: Circle;
begin
    Draw( c ); -- calls Circle_Pkg.Draw
end Test;

------------

Now, if I change Shape_Pkg.Draw's formal parameter to Shape'Class, 
what's the difference? In both cases it's legal to call Draw on a Circle.

- Matthias

Re: Classwide Parameter?

[Matthew Heaney]

matthias_k <nospam@digitalraid.com> writes:

> I have experimented a little, and I can't really figure out what I need
> classwide parameters for.

Class-wide objects dispatch their primitive operations.  The call is
dynamically bound, not statically bound.


> Consider this code:
> 
> package Shape_Pkg is
>     type Shape is abstract tagged null record;
>     procedure Draw (obj: Shape);  -- try adding "is abstract" here
> end;
> 
> package Circle_Pkg is
>     type Circle is new Shape with null record;
>     procedure Draw (obj: Circle);
> end;
> 
> ...
> 
> procedure Test is
>     c: Circle;
> begin
>     Draw( c ); -- calls Circle_Pkg.Draw
> end Test;
> 
> ------------
> 
> Now, if I change Shape_Pkg.Draw's formal parameter to Shape'Class,
> what's the difference? In both cases it's legal to call Draw on a
> Circle.

The call to draw in your example above is statically bound.  A better
way to see what's going on is to do this:

procedure Test_Draw (S : Shape'Class) is -- class-wide type
begin
   Draw (S);  -- call is dynamically bound
end;

We can now rewrite your example:

procedure Test is
   C : Circle;
begin
   Test_Draw (C);  --will call Circle_Pkg.Draw
end;


A better example is adding different types that derive from Shape ("are
in the Shape class," in Ada-speak):

procedure Test is
   C : Circle;
   S : Square;
   T : Triangle;
begin
   Test_Draw (C);  --will call Circle_Pkg.Draw
   Test_Draw (S);  --calls Square_Pkg.Draw
   Test_Draw (T);  --calls Triangle_Pkg.Draw
end;

Re: Classwide Parameter?

[matthias_k]

Thanks for that answer. However, I'm still having problems (I have 
rewritten the code to be in one single package now):

<snip>
package Graphics is

    type Shape is abstract tagged null record;
    procedure Draw (Obj: Shape'Class);

    type Circle is new Shape with record
       Radius: Float;
       Center: Float;
    end record;
    procedure Draw (Obj: Circle);

    type Square is new Shape with record
       Size: Float;
    end record;
    procedure Draw (Obj: Square);

end;
</snip>

Now, what I want is to have different implementations of the Draw method 
for each Subtype. However, if I run this program:

<snip>
with Graphics;
use Graphics;

procedure Demo is
    type Reference is access all Shape'Class;
    Object: Reference;
begin
    Object := new Circle;
    Draw( Object.all );

    Object := new Square;
    Draw( Object.all );
end;
</snip>

The Shape's Draw method is always called here but it shouldn't. No late 
binding happens. I have tried to make it abstract, but it didn't even 
compile then. What's wrong?

- Matthias

Re: Classwide Parameter?

[Simon Wright]

matthias_k <nospam@digitalraid.com> writes:

> Thanks for that answer. However, I'm still having problems (I have
> rewritten the code to be in one single package now):
> 
> <snip>
> package Graphics is
> 
>     type Shape is abstract tagged null record;
>     procedure Draw (Obj: Shape'Class);

Replace this with 
   procedure Draw (Obj : Shape) is abstract;
as in

package Graphics is

    type Shape is abstract tagged null record;
    procedure Draw (Obj: Shape) is abstract;

    type Circle is new Shape with record
       Radius: Float;
       Center: Float;
    end record;
    procedure Draw (Obj: Circle);

    type Square is new Shape with record
       Size: Float;
    end record;
    procedure Draw (Obj: Square);

end;
with Ada.Text_IO; use Ada.Text_IO;
package body Graphics is

   procedure Draw (Obj: Circle) is
   begin
      Put_Line ("circle");
   end Draw;

   procedure Draw (Obj: Square) is
   begin
      Put_Line ("square");
   end Draw;

end Graphics;
with Graphics;
use Graphics;
procedure Demo is
    type Reference is access all Shape'Class;
    Object: Reference;
begin
    Object := new Circle;
    Draw( Object.all );

    Object := new Square;
    Draw( Object.all );
end;

(use gnatchop)

which said

   smaug.pushface.org[2]$ gnatmake demo
   gcc -c demo.adb
   gcc -c graphics.adb
   gnatbind -x demo.ali
   gnatlink demo.ali
   smaug.pushface.org[3]$ ./demo
   circle
   square
   smaug.pushface.org[4]$ 



If you say
    type Reference is access all Shape'Class;
then your procedure
    procedure Draw (Obj: Shape'Class);
is bound to get called, since A_Reference.all is a Shape'Class.

-- 
Simon Wright                               100% Ada, no bugs.

Re: Classwide Parameter?

[Brian May]

>>>>> "matthias" == matthias k <nospam@digitalraid.com> writes:

    matthias> The Shape's Draw method is always called here but it
    matthias> shouldn't. No late binding happens. I have tried to make
    matthias> it abstract, but it didn't even compile then. What's
    matthias> wrong?

Hmmm.. I find it curious that code will even compile. I guess when Ada
has to match a Shape'Class type against these procedures:

    procedure Draw (Obj: Shape'Class);
    procedure Draw (Obj: Circle);
    procedure Draw (Obj: Square);

It isn't ambiguous, even if the shape happens to be a circle or a
square.

I find this case interesting, with your code, too:

procedure Demo is
    C : Circle;
begin
    Draw(C);
end;

Here it replies that the call to draw is ambiguous, because
it doesn't know if it should call:

    procedure Draw (Obj: Shape'Class);

or
    procedure Draw (Obj: Circle);

because both could apply equally.

I found this confusing at first, I would have thought using
"Shape'Class" is the correct way of doing it, as you want explicitly
allow any type of Shape to get passed through. However, this isn't how
Ada supports inheritance.

In order to try and understand how this works better, I once wrote
test code that tested every possible situation. I suggest other
interested people do the same thing. Unfortunately, my hard disk died
since then :-(, but the lessons remained.

Consider the following (dodgy) code:

package Graphics is
    type Shape is abstract tagged null record;
    procedure Draw (Obj: Shape);
    procedure Draw_Class (Obj: Shape'Class);

    type Circle is new Shape with record
       Radius: Float;
       Center: Float;
    end record;
    procedure Draw (Obj: Circle);
    procedure Draw_Class (Obj: Circle);

    type Square is new Shape with record
       Size: Float;
    end record;
end;

My way of "visualizing" the above code (not sure if this is
technically correct), is the compiler sees the "Shape" type, and
associates two methods, "Draw" and "Draw_Class".

The compiler continues, and process the "Circle" class, and sees that
the same two functions have been redefined. Nothing more to do.

It then sees the Square type, and realizes that functions have not
been redefined. As such, it will turn/copy/inherent/whatever this
function:

    procedure Draw (Obj: Shape);

into

    procedure Draw (Obj: Square);

So now you effectively have:

package Graphics is
    type Shape is abstract tagged null record;
    procedure Draw (Obj: Shape);
    procedure Draw_Class (Obj: Shape'Class);

    type Circle is new Shape with record
       Radius: Float;
       Center: Float;
    end record;
    procedure Draw (Obj: Circle);
    procedure Draw_Class (Obj: Circle);

    type Square is new Shape with record
       Size: Float;
    end record;
    procedure Draw (Obj: Square); -- is the same as Draw (Obj: Shape)
end;

It doesn't do the same thing for Draw_Class, perhaps it is clever
enough to realize it isn't needed. So in the above code,
Draw_Class(MyCircle) would be ambiguous, but Draw_Class(MySquare)
wouldn't be.

In summary, there are times you might want to use 'class for procedure
parameters, but not for procedures that can be overloaded in child
types, as the compiler already does everything for you.

Some of my analogies confuse people (instead of making it more clear),
lets hope this helps...
-- 
Brian May <bam@snoopy.apana.org.au>

Re: Classwide Parameter?

[Matthew Heaney]

matthias_k <nospam@digitalraid.com> writes:

> Thanks for that answer. However, I'm still having problems (I have
> rewritten the code to be in one single package now):
> 
> <snip>
> package Graphics is
> 
>     type Shape is abstract tagged null record;
>     procedure Draw (Obj: Shape'Class);

Get rid of this operation.  It's a "class-wide" operation (like a static
method in C++), and hence the operation isn't primitive for the type
(and therefore doesn't dispatch).

Re: Classwide Parameter?

[Dmitry A. Kazakov]

On Mon, 11 Oct 2004 19:08:24 +0200, matthias_k wrote:

> Thanks for that answer. However, I'm still having problems (I have 
> rewritten the code to be in one single package now):
> 
> <snip>
> package Graphics is
> 
>     type Shape is abstract tagged null record;
>     procedure Draw (Obj: Shape'Class);
>
>     type Circle is new Shape with record
>        Radius: Float;
>        Center: Float;
>     end record;
>     procedure Draw (Obj: Circle);
> 
>     type Square is new Shape with record
>        Size: Float;
>     end record;
>     procedure Draw (Obj: Square);
> 
> end;
> </snip>
> 
> Now, what I want is to have different implementations of the Draw method 
> for each Subtype.

This means that the base should declare Draw as a method. [In Ada terms it
should be a primitive operation. ] Class-wide is NOT a primitive operation.
When you declare Shape abstract, then what is abstract there? Presumably
Draw, which should be overridden (implemented) by each concrete derived
type. This all means that Shape.Draw should be at least primitive:

  procedure Draw (Obj: Shape);

Very likely it should also be abstract:

  procedure Draw (Obj: Shape) is abstract;

---
Class-wide subprograms come into consideration only if you want and are
able to write something valid for *all* derived types. This something is
said to be defined on the class rooted in the given type. For example,
Shape'Class is rooted in Shape. Now imagine that your Shape also has a
primitive operation Flip, then you can write a class-wide procedure
Flip_n_Draw which will be able to Flip and then Draw anything derived from
Shape:

   type Shape is abstract tagged ...
   -- The methods:
   procedure Draw (Obj : Shape) is abstract;
   procedure Flip (Obj : in out Shape) is abstract;
   -- The class-wides:
   procedure Flip_n_Draw (Obj : in out Shape'Class);

   procedure Flip_n_Draw (Obj : in out Shape'Class) is
   begin
      Flip (Obj); -- Dispatches to an appropriate Flip
      Draw (Obj); -- Dispatches to an appropriate Draw
   end Flip_n_Draw;

Because Flip_n_Draw is class-wide it is valid for *any* type derived from
Shape. Once you have an object of Circle, Rectangle, whatsoever, you can
use Flip_n_Draw with it, without any further coding. The only thing you
have to do is to implement the "methods" of Shape.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de

Re: Classwide Parameter?

[matthias_k]

Matthew Heaney wrote:
> matthias_k <nospam@digitalraid.com> writes:
> 
> 
>>Thanks for that answer. However, I'm still having problems (I have
>>rewritten the code to be in one single package now):
>>
>><snip>
>>package Graphics is
>>
>>    type Shape is abstract tagged null record;
>>    procedure Draw (Obj: Shape'Class);
> 
> 
> Get rid of this operation.  It's a "class-wide" operation (like a static
> method in C++), and hence the operation isn't primitive for the type
> (and therefore doesn't dispatch).
> 
> 

Oha? I thought it would be analogous to 'virtual' in C++, not static.
If I leave out the method completely, then this is not what I know as 
'Inheritance' anymore.
Shape is supposed to be an abstract base class, which -declares- (not 
necessarily -defines-) a common interface for its subtypes. The code I 
posted may not reflect this too well, it's just samplecode.
I doubt -any- dynamic binding will happen when completely leaving out 
Shape's Draw method.

And btw.: What does dispatch mean? :) Is that the Ada term for dynamic 
binding?

- Matthias

Re: Classwide Parameter?

[Martin Krischik]

matthias_k wrote:

> Thanks for that answer. However, I'm still having problems (I have
> rewritten the code to be in one single package now):
> 
> <snip>
> package Graphics is
> 
>     type Shape is abstract tagged null record;
>     procedure Draw (Obj: Shape'Class);

You want an abstract method not a class wide procedure:

procedure Draw (Obj: Shape) is abstract;

> 
>     type Circle is new Shape with record
>        Radius: Float;
>        Center: Float;
>     end record;
>     procedure Draw (Obj: Circle);
> 
>     type Square is new Shape with record
>        Size: Float;
>     end record;
>     procedure Draw (Obj: Square);
> 
> end;
> </snip>
> 
> Now, what I want is to have different implementations of the Draw method
> for each Subtype. However, if I run this program:
> 
> <snip>
> with Graphics;
> use Graphics;
> 
> procedure Demo is
>     type Reference is access all Shape'Class;
>     Object: Reference;
> begin
>     Object := new Circle;
>     Draw( Object.all );
> 
>     Object := new Square;
>     Draw( Object.all );

Only use pointer in Ada if you realy need to:

Test_1:
declare 
     Object: Shape'Class := Circle'(Radius => 10.0, Center => 10.0);
begin
   Draw( Object);
end

Test_2:
declare 
     Object: Shape'Class := Square'(Size => 10.0);
begin
   Draw( Object);
end

> end;

> </snip>
> 
> The Shape's Draw method is always called here but it shouldn't. No late
> binding happens. I have tried to make it abstract, but it didn't even
> compile then. What's wrong?
> 
> - Matthias

-- 
mailto://krischik@users.sourceforge.net
http://www.ada.krischik.com

Re: Classwide Parameter?

[matthias_k]

> Ah! I -totally- misunderstood the meaning of 'class. I thought it makes 
> a method 'virtual' in C++ speaking, therefore allow subclasses to 
> override it and being called dynamically.
> 
> Thanks for clearing up.

If you ask why the hell I thought that:

[quoted from "Big Online Book of Linux Ada Programming" 
(http://www.vaxxine.com/pegasoft/homes/11.html#11.3)]

Ada 	                          Description 	        C Equivalent
[...]
'class 	                          Class-wide type 	virtual <-- !
[...]

Re: Classwide Parameter?

[Martin Krischik]

matthias_k wrote:

> Matthew Heaney wrote:
>> matthias_k <nospam@digitalraid.com> writes:
>> 
>> 
>>>Thanks for that answer. However, I'm still having problems (I have
>>>rewritten the code to be in one single package now):
>>>
>>><snip>
>>>package Graphics is
>>>
>>>    type Shape is abstract tagged null record;
>>>    procedure Draw (Obj: Shape'Class);
>> 
>> 
>> Get rid of this operation.  It's a "class-wide" operation (like a static
>> method in C++), and hence the operation isn't primitive for the type
>> (and therefore doesn't dispatch).

"static" would be a function in the same package but without any X or
X'Class parameter. It's more like non virtual function.

> Oha? I thought it would be analogous to 'virtual' in C++, not static.

I did the same mistake in the beginning. In Ada all operations defined in
the same package as the class are virtual.

> If I leave out the method completely, then this is not what I know as
> 'Inheritance' anymore.
> Shape is supposed to be an abstract base class, which -declares- (not
> necessarily -defines-) a common interface for its subtypes. The code I
> posted may not reflect this too well, it's just samplecode.
> I doubt -any- dynamic binding will happen when completely leaving out
> Shape's Draw method.

you need:

procedure Draw (Obj: Shape) is abstract;

which

> And btw.: What does dispatch mean? :) Is that the Ada term for dynamic
> binding?

That's right.

Martin

-- 
mailto://krischik@users.sourceforge.net
http://www.ada.krischik.com

Re: Classwide Parameter?

[Matthew Heaney]

matthias_k <nospam@digitalraid.com> writes:

> Matthew Heaney wrote:
> > matthias_k <nospam@digitalraid.com> writes:
> >
> >>Thanks for that answer. However, I'm still having problems (I have
> >>rewritten the code to be in one single package now):
> >>
> >><snip>
> >>package Graphics is
> >>
> >>    type Shape is abstract tagged null record;
> >>    procedure Draw (Obj: Shape'Class);
> > Get rid of this operation.  It's a "class-wide" operation (like a
> > static
> > method in C++), and hence the operation isn't primitive for the type
> > (and therefore doesn't dispatch).
> >
> 
> Oha? I thought it would be analogous to 'virtual' in C++, not static.

I should have said: "change the type from Shape'Class to Shape, and
optionally declare the operation as abstract."

In Ada, you don't need to say "virtual".  An operation for a type is
"primitive" whenever it has the type as a parameter or return type, and
the operation is declared in the same package as the type.

To make a "static" method in Ada, declare the parameter as T'Class.


> And btw.: What does dispatch mean? :) Is that the Ada term for dynamic
> binding?

Yes.

Re: Classwide Parameter?

[Dmitry A. Kazakov]

On Tue, 12 Oct 2004 10:14:57 +0200, matthias_k wrote:

>> Ah! I -totally- misunderstood the meaning of 'class. I thought it makes 
>> a method 'virtual' in C++ speaking, therefore allow subclasses to 
>> override it and being called dynamically.
>> 
>> Thanks for clearing up.
> 
> If you ask why the hell I thought that:
> 
> [quoted from "Big Online Book of Linux Ada Programming" 
> (http://www.vaxxine.com/pegasoft/homes/11.html#11.3)]
> 
> Ada 	                          Description 	        C Equivalent
> [...]
> 'class 	                          Class-wide type 	virtual <-- !
> [...]

Well, it is not that wrong as it appears. Keep in mind:

       subroutines
      /          \
primitive       non-primitive
(override)       (overload)
[can dispatch]    /      \
             specific   class-wide

    objects
   /       \
specific   class-wide [can dispatch]

The page you refer tells about *objects*. T'Class object in Ada has the
functionality of the first (prefix) actual parameter of a virtual function
in C++ (what "this" points to). Both dispatch:
---------------------------
class X
{
public :
   virtual void Foo (); // "Primitive in Ada"
};
X& Object = ...;

X.Foo (); // This dispatches
---------------------------
type X is tagged ...
procedure Foo (Object : X); -- "Virtual in C++"

   Object : X'Class := ...; -- Note X'Class!!
begin
   Foo (Object); -- This dispatches
---------------------------
In this sense X'Class is an "equivalent" of virtual.

But. C++ pretends X and X'Class be same types, so it is forced to dispatch
and re-dispatch everywhere and every time. In this sense any C++ function
is a kind of "class-wide" (except for ctor/dtor) in any of its X& or X*
parameters when they are used within in the prefix form:

friend void Baz (X& Object)
{
   Object.Foo (); // This dispatches, Baz is "class-wide"?
   Baz (Object);  // But this does not, Baz is not "class-wide"?
}

Anyway, the equivalence chart should include all combinations of types of
objects and subroutines + parameter positions because of that nasty prefix
notation in C++.

Roughly, when in Ada a class-wide object meets a primitive operation it is
an equivalent of C++'s call to a virtual function through its first
parameter. Ada's class-wide subroutines are equivalent to C++'s friend
functions, non-virtual functions, functions with explicit parameters etc,
when the parameter is a reference or a pointer to some C++ class. Ada's
specific subroutines are equivalent to C++ functions having a parameter,
which type/class does not have virtual functions.

Honestly it is wasting time to search for meaningful analogies! (:-))
Fortunately in Ada it is quite simple. The mantra is:

It dispatches IFF a class-wide object meets a specific parameter of a
primitive operation.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de