Re: The old "Object.Method" syntax debate

[aek@vib.usr.pu.ru (Alexander Kopilovitch)]

Robert I. Eachus wrote:
>I really don't like the idea of allowing the Object.Operation format to
>Ada.  Yeah, the compilers can usually figure it out understand it. But
>the potential confusion with component notation is going to confuse
>experienced Ada users.  (And eventually other O-O language users when
>the actually run into component references.

I agree that there may be those troubles with this notation, but there are
significant gains also. Potential confusion with component is one side of
this change, but another side is abstraction step for the concept of component.
In other words, there are cases where it is significant to know that a member
of composite type is really represented by corresponding data element; but
there are plenty of cases where flexibility is more desirable, that is, our
layer should not depend on whether that member actually has consolidated
reprepsentation in memory or it is computed on demand.
  Real problem with this "object notation" for operations in Ada is that there
is no clear understanding where this notation is for good and where it is for
evil. AI-252 mentions "controlling" object, and yes, there are plenty of cases
where we really have some controlling object, and in those cases that "object
notation" often are justified (after all, in such cases this notation actually
carries useful information, explicitly pointing out at the controlling object).
But unfortunately there is very big "grey zone" where controlling objects are
doubtful, and there are many cases without natural controlling objects at all.

>Since the language currently allows defining attributes which are
>procedures or functions, why not use the apostrophe notation?  Now the
>meaning of Object'Operation is clear, even when it is actually
>Object'Length or whatever.  Probably need a rule about overloading
>predefined attributes, but that shouldn't be such a big deal.  (They
>would be non-overridable declarations in scope.)

I think that it would be wrong to take away that exclusive privilege --
to introduce attributes -- from the language designers and compiler vendors.
The name space for attributes is too important language resource, it should
not be given out freely for general use.
  How about another character instead of apostrophe (or dot) for user-defined
attributes? For example, there is quite popular # (read "join" for this purpose):
 Object#Operation 
("controlling object" somehow associates with "base" -:)


Alexander Kopilovitch                      aek@vib.usr.pu.ru
Saint-Petersburg
Russia