From mboxrd@z Thu Jan 1 00:00:00 1970 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on polar.synack.me X-Spam-Level: X-Spam-Status: No, score=0.7 required=5.0 tests=BAYES_00,INVALID_MSGID, PDS_OTHER_BAD_TLD autolearn=no autolearn_force=no version=3.4.4 X-Google-Language: ENGLISH,ASCII-7-bit X-Google-Thread: 103376,d1df6bc3799debed X-Google-Attributes: gid103376,public From: "Samuel A. Mize" Subject: Re: Syntax for tagged record types and class types Date: 1997/05/22 Message-ID: <3384A4EA.167E@magellan.bgm.link.com>#1/1 X-Deja-AN: 243150198 References: <3.0.32.19970423164855.00746db8@mail.4dcomm.com> <5kl9qc$g4d@bcrkh13.bnr.ca> <5kmek2$9re@bcrkh13.bnr.ca> <33727FA5.5C7A@sprintmail.com> <3374C19F.15FE@sprintmail.com> <3376CF85.3E15@sprintmail.com> <33828299.2A3@world.std.com> <33830D58.6D8F@elca-matrix.ch> Organization: PSI Public Usenet Link Newsgroups: comp.lang.ada Date: 1997-05-22T00:00:00+00:00 List-Id: 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 > ). 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