Tagged type abuse

Tagged type abuse

[Natasha Kerensikova]

Hello,

I find myself using more and more tagged types for reasons that have
nothing to do with tagging, mostly the prefix notations (when it helps
readability and when a function call is conceptually accessing a record
element but with a hidden concrete implementation) and the passing by
reference.

However, I still feel guilty about it, like I'm abusing a feature
unrelated to what I wish to accomplish.

What would you recommend to appease such feelings?
Sacrificing prefix notation readability on types that have no business
being tagged?
Trying to be more pragmatic and use tools (and language features) for any
purpose at which they end up being useful, even unintended?


Natasha

Re: Tagged type abuse

[Dmitry A. Kazakov]

On Thu, 18 Dec 2014 11:26:58 +0000 (UTC), Natasha Kerensikova wrote:

> What would you recommend to appease such feelings?

That all types should have been tagged anyway (meaning: has T'Class with a
type tag stored in it).

> Sacrificing prefix notation readability on types that have no business
> being tagged?

I think that prefix notation was a language design bug. As such it has
nothing to do with the type being tagged or having a class.

Prefix notation should have been an implementation of an abstract record
member of some subprogram type.

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

Re: Tagged type abuse

[Jeffrey Carter]

On 12/18/2014 04:26 AM, Natasha Kerensikova wrote:
> 
> I find myself using more and more tagged types for reasons that have
> nothing to do with tagging, mostly the prefix notations (when it helps
> readability and when a function call is conceptually accessing a record
> element but with a hidden concrete implementation) and the passing by
> reference.
> 
> However, I still feel guilty about it, like I'm abusing a feature
> unrelated to what I wish to accomplish.
> 
> What would you recommend to appease such feelings?

There are three reasons I use tagged types:

1. To obtain finalization

2. To avoid explicit pointers in self-referential types

3. To obtain Object.Operation notation

-- 
Jeff Carter
"If you think you got a nasty taunting this time,
you ain't heard nothing yet!"
Monty Python and the Holy Grail
23

Re: Tagged type abuse

[Randy Brukardt]

"Jeffrey Carter" <spam.jrcarter.not@spam.not.acm.org> wrote in message 
news:m6v154$r9t$1@dont-email.me...
> On 12/18/2014 04:26 AM, Natasha Kerensikova wrote:
>>
>> I find myself using more and more tagged types for reasons that have
>> nothing to do with tagging, mostly the prefix notations (when it helps
>> readability and when a function call is conceptually accessing a record
>> element but with a hidden concrete implementation) and the passing by
>> reference.
>>
>> However, I still feel guilty about it, like I'm abusing a feature
>> unrelated to what I wish to accomplish.
>>
>> What would you recommend to appease such feelings?
>
> There are three reasons I use tagged types:
>
> 1. To obtain finalization
>
> 2. To avoid explicit pointers in self-referential types
>
> 3. To obtain Object.Operation notation

I think that Jeff is saying that not everyone thinks dynamic dispatching is 
relevant. But tagged types still can be useful.

Note that in pre-2012 Ada, you needed to use tagged types get "=" to work 
right vis-a-vis composition. (Ada 2012 extended that to all record types, 
which of course means that some programs that expect the wrong answer will 
break. But in most cases, the change will fix bugs rather than create them.)

I don't use dynamic dispatching much (outside of Claw anyway), but I 
sometimes use inheritance to inherit implementations (rather than having to 
duplicate them all over, with the corresponding maintenance headache).

I'd probably use tagged types to get prefix notation, but I'd have to 
implement it in Janus/Ada first. :-)

Anyway, I wouldn't worry about it. Tagged types cost about the same as 
regular record types (the only difference is the waste of space for the tag, 
which only matters for tiny records) unless you use T'Class. So do what 
makes you program work better.

(We couldn't make cursors in the containers be tagged, thus you can't use 
prefixed notation to do various reading operations on the containers. One 
more reason out of many that I think every container operation should have 
had a container parameter. [Another reason is that preconditions make much 
more sense if the container passed to an operation has a name.] But of 
course there is as many container designs as there are programmers --  
perhaps more -- and the big value was picking one. There is no way it could 
have been perfect for every use anyway.)

                                            Randy.

Re: Tagged type abuse

[Michael B.]

Am 19.12.2014 um 00:10 schrieb Randy Brukardt:
> Note that in pre-2012 Ada, you needed to use tagged types get "=" to work
> right vis-a-vis composition. (Ada 2012 extended that to all record types,
> which of course means that some programs that expect the wrong answer will
> break. But in most cases, the change will fix bugs rather than create them.)

Could you be more specific on that?

Re: Tagged type abuse

[Randy Brukardt]

"Michael B." <michaelb@example.com> wrote in message 
news:m716fq$91n$1@speranza.aioe.org...
> Am 19.12.2014 um 00:10 schrieb Randy Brukardt:
>> Note that in pre-2012 Ada, you needed to use tagged types get "=" to work
>> right vis-a-vis composition. (Ada 2012 extended that to all record types,
>> which of course means that some programs that expect the wrong answer 
>> will
>> break. But in most cases, the change will fix bugs rather than create 
>> them.)
>
> Could you be more specific on that?

The case in question is the operator used in a composed "=". That is, what 
operator is used to compare components of a type in some non-limited 
composite type.

In Ada 83-2005, untagged record types compose using a reimergence of 
predefined "=" (the user-defined "=" is ignored in that case). That was not 
changed in Ada 95 because of compatibility concerns. But the problem wasn't 
going away, and having an aspect to do the right thing made no sense and 
having an aspect to do the wrong thing helps no-one (the code would have to 
be modified, but if you can do that, you might as well fix it). So we just 
changed it. We think that 99% of the time, people would rather have the 
user-defined "=" used (why else would you have defined it?)

                                Randy.

Re: Tagged type abuse

[Michael B.]

Sounds like a reasonable change. Thanks for clarifying.

Regards,

Michael


On 12/20/14 01:07, Randy Brukardt wrote:
> In Ada 83-2005, untagged record types compose using a reimergence of
> predefined "=" (the user-defined "=" is ignored in that case). That was not
> changed in Ada 95 because of compatibility concerns. But the problem wasn't
> going away, and having an aspect to do the right thing made no sense and
> having an aspect to do the wrong thing helps no-one (the code would have to
> be modified, but if you can do that, you might as well fix it). So we just
> changed it. We think that 99% of the time, people would rather have the
> user-defined "=" used (why else would you have defined it?)