Prefixed notation for non tagged types

[Jere <jhb.chat@gmail.com>]

On Monday, July 3, 2017 at 10:18:33 PM UTC-4, Randy Brukardt wrote:
> "Jere" wrote in message 
> > On Sunday, July 2, 2017 at 8:04:56 PM UTC-4, Randy Brukardt wrote:
> >> (3) Since prefixed notation does automatic dereferencing and referencing
> >> (that is, .all and 'Access), allowing it on all types caused levels of
> >> ambiguity (and potentially infinite regress). It was easier to just 
> >> define
> >> it on tagged types, which didn't have those issues. Perhaps it could have
> >> been made to work, but it was more work for a feature that already had
> >> significant opposition; probably it would have been dropped rather than
> >> getting more complicated. (Sound like a broken record??)
> >
> > Was there any consideration to having prefixed notation to
> > apply to all record types and add a way to denote that a private
> > type is a record type (there should be many ways to do that)?
> > We don't really need it on all types, just record types.
> 
> Not that I recall, but requiring an indication that a private type is 
> completed by a record seems like noise (99% of private types are completed 
> by some sort of record as it is). It would be better the other way around 
> (indicate when it is *not* completed by a record), but of course that would 
> be incompatible. Still seems best for Ada'Succ.
> 
>                                           Randy.

I know this is an old email chain, but I've been thinking about this
more recently.  For background, I asked if there could be a way to
denote that a private type was a record type, so that Prefixed notation
could be used on non tagged types.  Randy noted that since most private 
types were record types, it would just be noise.  I wanted to revisit
this thought.  Forgive me if there is a good way to split the chain.
I don't know how to do that.  

So with that in mind:
My inclination is that the noise is already there.  I generally like
prefixed notation (it is easier for me to discern what is going on
when I read it), so even though I don't really like providing extension
for a type, I find myself making types tagged just to get the
prefixed notation.  In essence, I am already adding noise.  I think
my suggestion is that the noise could be replaced.  Instead of
having to mark any type where I want that notation (I don't do
it to all types) as tagged, have some other method that allows for
the ada compiler to confirm the full view is a record but also allow
for the prefixed notation in partial public view.

I like to keep extension out of many types that I wante prefixed
notation on.  I don't want the baggage that tagged types come with
unless I am actually utilizing those features.  I'm sure there are
a ton of ways to do this:

1.  use the not keyword in conjunction with tagged:
type My_Type is not tagged limited private;

I don't like this at all but just saying it is an option.  I think
it conveys a confusing meaning to the type.

2.  new keyword
type My_Type is <new keyword> limited private;

I don't really like adding new keywords either...though the option is
there I guess.  Something like the "final" keyword that says it was
tagged but can no longer be extended or some keyword completely
unrelated to tagged-ness.

3.  change up record declarations to use "record" in the partial view:
type My_Type is limited private record;

My guess is this would be difficult for compiler writers though as 
record is used for starting a declaration block.

4.  maybe an aspect
type My_Type is limited private
with
   Prefixed_Notation => True;  -- or some other aspect name

Here I am unsure if this is a good fit or not.  I don't have a good
feel for the boundaries of what aspects should be used for.

5.  maybe an attribute
type My_Type is limited private;
for My_Type'Prefixed_Notation use True;  -- or some other name

Same thoughts as #4 but I feel even more strongly that this would
be odd.

Maybe some other options.  My key point is that there already exists
noise out there for this and it comes with features that the designer
may not want to expose in the process.  Maybe there is a better way
to handle it.  I realize that if the feature existed others that didn't
mark types tagged for prefix notation would possibly use it, but I think
that is more of an indication of why it should be explored further.

Anyone have any thoughts?