Re: Disallowing Pre-Defined Operations

[claveman@cod.nosc.mil (Charles H. Sampson)]

In article <8ao2mm$ib7$1@nnrp1.deja.com>,
Robert Dewar  <robert_dewar@my-deja.com> wrote:
>In article <8ang7v$peo$1@newpoisson.nosc.mil>,
>  claveman@fern.com (Charles H. Sampson) wrote:
>> James S. Rogers wrote:
>> >Why not simply declare the type private or limited private,
>then provide
>> >your
>> >own versions for all the required operators?
>>
>>      Because, as I said in my original post, the types are
>inherently
>> numeric and I don't want to lose the ability to use numeric
>literals.
>
>
>Exactly! quite reasonable, and that is why the easy to use
>and understand ABSTRACT feature has been provided to exactly
>meet your needs here.

     But it doesn't exactly meet my needs, Robert.  I don't even think 
it's correct to say that it comes close to meeting my needs.  It does 
come close in the sense that if I try to use an abstract operation, most 
of the time I'll get a close to meaningful error message at compile 
time.  However it fails to exactly meet my needs by a long shot when it 
comes to concept.

     To summarize, I want some way to say that a pre-defined operation 
doesn't exist, that any attempt to write the operation is an error, just 
like attempting to write Float ** Float.  The problem with the ABSTRACT 
approach is that it actually defines the operation, making it exist, but 
declares that it is not callable.  That can give rise to ambiguities, as 
I illustrated in another post in this thread.  For what I want, there 
can't be such ambiguities because one of the two operations that play a 
role when an abstract declaration is used doesn't exist.  I want a 
situation where any user would be as puzzled as I briefly was, where he 
would say, "How can that be ambiguous?  Time_Type - Time_Type can only 
produce a Delta_Time_Type value." 

     For all I know, the abstract approach can cause problems other than 
ambiguities as well.

     The behavior of generics is even further away from what I want.  I 
haven't verified it myself yet, but several people in this thread have 
said that an abstract operation reverts to non-abstract in a generic 
instantiation.  For an operation that has been disallowed, there is 
nothing to revert to.  The programmer has told the compiler that the 
operation has no meaning.  To give it a meaning as a side effect of an 
instantiation makes no sense conceptually. 

     It might be that the units proposal that has been mentioned in this 
thread would satisfy me.  I'm going to try to check it out today.  At 
present, however, Ada is logically deficient and has been since the be-
ginning.  We are allowed to override pre-defined operations for our nu-
meric types, we are allowed to define meanings for operations that have 
no meaning, but we are not allowed to do the last logical step, to say 
that a pre-defined operation has no meaning.

				Charlie

--
******

     For an email response, my user name is "sampson" and my host
is "spawar.navy.mil".