Re: Syntax for tagged record types and class types

["Samuel A. Mize" <smize@magellan.bgm.link.com>]

Mats Weber wrote:
> 
> Matthew Heaney wrote:
> 
> > I'm not dogmatic about the "pure" object-oriented syntax, ie
> >
> > declare
> >    O : T;
> > begin
> >    O.Op (A);
> > end;
> >
> > though I do think it's pretty hip.
> 
> So do I. And if tasks and protected types provide that kind of notation,
> why should this not also be true for other constructs ?
> 
> > What would be cool is to have a selector abstraction, to give you that for
> > free, ie
> >
> > type Stack is ...;
> >
> > selector Top (S : Stack) return Item;
> >
> > So that I could do this:
> >
> > declare
> >    The_Stack : Stack;
> > begin
> >    The_Item := The_Stack.Top;
> > ...
> 
> That's why I proposed to use package types in my thesis (at
> <http://lglwww.epfl.ch/Team/MW/Ada-Extensions/Ada-Extensions.html>).

I haven't read your thesis, so I can't address any other benefits of this
proposal.  However, you can get the prefix notation in Ada 95, by using a
generic package.

Of course, you don't want to duplicate all the procedures (especially
if using a compiler like GNAT that does macro-expand-type generics!),
so you would write your "package type" as a base package and an
export-view generic package.  This gives you the prefix notation.

It's a bit more work.  If you frequently want this notation, you
should be able to write a preprocessor (I'd use a perl script) to
generate the generic from the base package.

I haven't compiled this example, but it shows the general idea:

    --------------------------------------------------------------
    package Stack_Base is -- typical Ada abstract data type
        type Stack_Type is ...
        function Top (S: Stack_Type) return Item;
        procedure Push (S: Stack_Type; X : in Item);
    end Stack_Base;

    --------------------------------------------------------------
    package body Stack_Base is
    -- left as an exercise for the reader

    --------------------------------------------------------------
    generic
    package Stack is
        function Top return Item;
        Procedure Push (X: in Item);
        pragma Inline (Top, Push);
    end Stack;

    --------------------------------------------------------------
    with Stack_Base; use Stack_Base;
    package body Stack is
        S: Stack_Type;

        function Top return Item is
        begin
            return Top (S);
        end Top;

        procedure Push (X: in Item) is
        begin
            Push (S, X);
        end Push;
    end Stack;

Then you use Stack:

    declare
        package S is new Stack;
        I: Item;
    begin
        S.Push (I);
        if S.Top /= I then ...


> > While we're at it, maybe we can throw in real constructors, too.  We can
> > solve the "problem" with limited types,  by allowing a constructor to be
> > called in the declarative region.  That way limited types wouldn't have to
> > be definate, or go on the heap unnecessarily.
> 
> My proposal for constructors goes like this:
> 
> package type T is
>    procedure new (X : Integer; Y : Float);   -- Note: new is a keyword
>    ...
> end T;
> 
> ...
> 
> Object : T(X => 5, Y => 3.14);

In the Stack example above, we would have in Stack_Base:

    procedure Initialize (S: Stack_Type; X : Integer; Y : Float);

and in the generic spec of Stack:

    generic
       X: Integer;
       Y: Float;
    package Stack is...

and in the body of Stack, in the elaboration section:

    begin
       Initialize (S, X, Y);
    end Stack;

As you say,
> the elaboration of the object declaration creates the object and then
> calls the procedure new with the given parameters.

(replace "object declaration" with "package instantiation.")

> Class types provided this way (any of the above 3 syntax) do not specify
> the mode of the implicit parameter of the class type. This has the nice
> side effect that a function can modify the object on which it is
> applied, which would be very useful in cases like the random number
> generator discussed in another thread.

You can do this by using a procedure in the base package:

    procedure Top (S: in out Stack; I: out Item);

and using that in a function call in the generic:

    function Top return Item is
       I: Item;
    begin
       Top (S, I);
       return I;
    end Top;

Arguments against this approach:
- it's more work
- it doesn't provide other benefits of package types

Arguments in favor of it:
- it provides prefix syntax
- you can do it today in Ada 95

Sam Mize

--
-- Samuel Mize           (817) 619-8622               "Team Ada"
-- Hughes Training Inc.  PO Box 6171 m/s 400, Arlington TX 76005