non record limited type

non record limited type

[Mehdi Saada]

I saw by trying it, that one could give a limited view, of a non-limited non-record type like
type FOO is limited private;
private
type FOO is new INTEGER;
, which I wasn't sure of just by reading the RM. That's a cool feature indeed, but why isn't it possible to write also
type FOO is limited range 1..5; ?
or    type FOO is limited array (INTEGER range <>) limited INTEGER;
I wasn't sure either from reading, but I can't compile anything similar. I don't understand why the possibility of forbidding copying isn't allowed for non record type.

Also, another question: if only the public view is limited, what about the parameter passing ? Is it by reference or copy, when such copy are made in the body ? I would guess by copy, but I prefer to ask

Re: non record limited type

[Jere]

On Wednesday, February 21, 2018 at 10:58:18 AM UTC-5, Mehdi Saada wrote:
> 
> Also, another question: if only the public view is limited, what about the parameter passing ? Is it by reference or copy, when such copy are made in the body ? I would guess by copy, but I prefer to ask

I can't answer why on your first question, but on this one:
The RM in section 6.2 specifies how parameter passing is done based on the type.

http://www.ada-auth.org/standards/12rm/html/RM-6-2.html#I3382

Based on that, your limited private which is really an integer would still be
a by-copy-type.  I don't know the RM's intention but the wording suggests that
at least.  Note you can also used the "aliased" keyword in a function/procedure
signature to enforce an aliased variable which will be passed by reference
as well:

-- Object is passed by reference
procedure Do_Something(Object : aliased in out Some_Type);

Re: non record limited type

[Mehdi Saada]

> Based on that, your limited private which is really an integer would still be
> a by-copy-type.  I don't know the RM's intention but the wording suggests that
> at least.  Note you can also used the "aliased" keyword in a function/procedure
> signature to enforce an aliased variable which will be passed by reference
> as well: 
> -- Object is passed by reference
> procedure Do_Something(Object : aliased in out Some_Type);

Really ? Are you sure it "forces" the passing by reference ? But I remember clearly have read somewhere, most probably on this forum that it wasn't in Ada's philosophy to let one precise that, since it is an implementation detail, and that the compiler shall decide by himself.
I can imagine that in some contexts, for small objects, or in distributed systems (across computers ), it would make sense for the value to be copied locally, then when "return" is reached it could be pasted back.
That said, in most cases your opinion makes more sense indeed. But I don't think one could be "sure".

That said Though I suppose you're right, 

Re: non record limited type

[Jere]

On Wednesday, February 21, 2018 at 5:29:11 PM UTC-5, Mehdi Saada wrote:
> > Based on that, your limited private which is really an integer would still be
> > a by-copy-type.  I don't know the RM's intention but the wording suggests that
> > at least.  Note you can also used the "aliased" keyword in a function/procedure
> > signature to enforce an aliased variable which will be passed by reference
> > as well: 
> > -- Object is passed by reference
> > procedure Do_Something(Object : aliased in out Some_Type);
> 
> Really ? Are you sure it "forces" the passing by reference ? But I remember clearly have read somewhere, most probably on this forum that it wasn't in Ada's philosophy to let one precise that, since it is an implementation detail, and that the compiler shall decide by himself.

The rules are scattered about the RM, but if you look at the Ada2012 Rationale
document which was released with the RM:  
http://www.ada-auth.org/standards/rationale12.html

You will see it was a new feature added with the Ada2012 revision

Section 1.3.3
http://www.ada-auth.org/standards/12rat/html/Rat12-1-3-3.html
---------------------
An aliased parameter is always passed by reference and the accessibility 
rules are modified accordingly. This facility is used in a revision to 
the containers which avoids the need for expensive and unnecessary copying 
of complete elements when they are updated. The details will be given 
in Sections 4.2 and 6.3.



Section 4.2
http://www.ada-auth.org/standards/12rat/html/Rat12-4-2.html
---------------------
The other change in Ada 2012 concerning parameters is that they may be 
explicitly marked aliased thus

procedure P(X: aliased in out T; ... );

As a consequence within P we can write X'Access. Recall that tagged types 
were always considered implicitly aliased anyway and always passed by 
reference. If the type T is a by-copy type such as Integer, then adding 
aliased causes it to be passed by reference. (So by-copy types are not 
always passed by copy!)



Section 6.3
http://www.ada-auth.org/standards/12rat/html/Rat12-6-3.html
----------------------
The alert reader will note the inclusion of aliased for the parameter 
Container of the function Reference. As discussed in Section 4.2 on 
subprogram parameters, this ensures that the parameter is passed by 
reference (it always is for tagged types anyway); it also permits us 
to apply 'Access to the parameter Container within the function and to 
return that access value.

Re: non record limited type

[Jere]

On Wednesday, February 21, 2018 at 5:29:11 PM UTC-5, Mehdi Saada wrote:
> > Based on that, your limited private which is really an integer would still be
> > a by-copy-type.  I don't know the RM's intention but the wording suggests that
> > at least.  Note you can also used the "aliased" keyword in a function/procedure
> > signature to enforce an aliased variable which will be passed by reference
> > as well: 
> > -- Object is passed by reference
> > procedure Do_Something(Object : aliased in out Some_Type);
> 
> Really ? Are you sure it "forces" the passing by reference ? But I remember clearly have read somewhere, most probably on this forum that it wasn't in Ada's philosophy to let one precise that, since it is an implementation detail, and that the compiler shall decide by himself.

Also, if you look into the section of the RM that I linked you in my first
response, you will see that it is required to be that way

RM 6.2
http://www.ada-auth.org/standards/12rm/html/RM-6-2.html
----------------------------------------------------------
A parameter of a by-reference type is passed by reference, as is an 
explicitly aliased parameter of any type. Each value of a by-reference 
type has an associated object. For a parenthesized expression, 
qualified_expression, or type_conversion, this object is the one 
associated with the operand. For a conditional_expression, this 
object is the one associated with the evaluated dependent_expression.

Re: non record limited type

[Mehdi Saada]

... Splendid. Did you have to search for me, or merely recalled (!) ?
Anyway, I just learnt a lot, thanks a lot
Infos scattered like that aren't the easiest ones to gather...
Yet, we still wonder why "type FOO is limited INTEGER" is not legal. Would be useful.

Re: non record limited type

[Mehdi Saada]

... Splendid. Did you have to search for me, or merely recalled (!) ?
thanks a lot.

Re: non record limited type

[Randy Brukardt]

"Mehdi Saada" <00120260a@gmail.com> wrote in message 
news:6e384796-4a5f-449a-8bf7-3b8fe974b4fc@googlegroups.com...
...
>> -- Object is passed by reference
>> procedure Do_Something(Object : aliased in out Some_Type);
>
>Really ? Are you sure it "forces" the passing by reference ?

Yes, of course. It wouldn't make much sense to be able to save 'Access of a 
short-term local copy of the actual parameter -- you want the 'Access to 
directly access the actual object. (Recall the the original reason for 
"aliased" is to allow 'Access of the object. The rules for aliased 
parameters are a bit more complex, but the underlying issues are the same.)

Anyway, RM 6.2(10/4) specifically says: "A parameter of a by-reference type 
is passed by reference, as is an explicitly aliased parameter of any type."

                                  Randy.

Re: non record limited type

[Randy Brukardt]

"Mehdi Saada" <00120260a@gmail.com> wrote in message 
news:3a2e91d4-f563-4843-9c80-5a76732626d3@googlegroups.com...
>I saw by trying it, that one could give a limited view, of a non-limited 
>non-record type like
> type FOO is limited private;
> private
> type FOO is new INTEGER;
> , which I wasn't sure of just by reading the RM. That's a cool feature 
> indeed, but
> why isn't it possible to write also
> type FOO is limited range 1..5; ?
? Is it by reference or copy, when such copy are made in the body ? I would 
guess by copy, but I prefer to ask

The "limited private" rules stem from Ada 83, and thus exist for 
compatibility. (They work by implicitly making type limited.) The 
possibility of explicitly "limited" types is a much more recent innovation.

These types that become limited just because of "limited private" also have 
the nasty property of becoming non-limited when you can see the full 
declaration. This causes all kinds of semantic complications that we'd 
rather not repeat, so everything new requires declaring it limited 
explicitly and staying that way.

As to why there aren't limited elementary types (or limited array types, for 
that matter), no one has had any very compelling use for such a thing. 
Elementary types are by-copy, while explicitly limited types are 
by-reference types (see RM 6.2(7/3)). Generally, the "value" of a limited 
type includes the object identity in some sense, whereas values of 
elementary types are just values (the containing object being unimportant 
unless one is writing the value).

These sorts of things could be reconciled, but no one has offered any really 
compelling reasons to do so. And we don't generally do work just for the 
sake of doing it.

                                         Randy.

Re: non record limited type

[Jere]

On Wednesday, February 21, 2018 at 7:26:44 PM UTC-5, Mehdi Saada wrote:
> ... Splendid. Did you have to search for me, or merely recalled (!) ?
> thanks a lot.

A little of both.  I went to the RM index and did a search for 
"reference type" and it pointed right to 6.2.  I already knew it 
was in there some where (The Prego response [1]), I just had to 
search a bit to find out where.

[1] https://www.youtube.com/watch?v=2J87QekxQVI

Re: non record limited type

[Simon Wright]

Jere <jhb.chat@gmail.com> writes:

> http://www.ada-auth.org/standards/12rm/html/RM-6-2.html

The latest revision is at

http://www.ada-auth.org/standards/rm12_w_tc1/html/RM-TOC.html

Re: non record limited type

[Dmitry A. Kazakov]

On 22/02/2018 02:29, Randy Brukardt wrote:

> These types that become limited just because of "limited private" also have
> the nasty property of becoming non-limited when you can see the full
> declaration. This causes all kinds of semantic complications that we'd
> rather not repeat, so everything new requires declaring it limited
> explicitly and staying that way.

I don't see anything wrong with that, except for coupling to 
by-reference semantics. On/off visibility of the copying operation is 
all OK, it is just an operation. Parameter passing method is a different 
thing.

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

Re: non record limited type

[Jeffrey R. Carter]

On 02/22/2018 01:09 AM, Mehdi Saada wrote:
> Yet, we still wonder why "type FOO is limited INTEGER" is not legal. Would be useful.

For what?

-- 
Jeff Carter
"[A] brilliant military career that after thirty
years catapulted him to the rank of corporal."
Take the Money and Run
138

Re: non record limited type

[Dmitry A. Kazakov]

On 2018-02-22 17:45, Jeffrey R. Carter wrote:
> On 02/22/2018 01:09 AM, Mehdi Saada wrote:
>> Yet, we still wonder why "type FOO is limited INTEGER" is not legal. 
>> Would be useful.
> 
> For what?
    type Data is mod 2**16;
    type Hardware_Port is limited new Data;
    procedure Write (Port : Hardware_Port; Value : Data);

    Output : Hardware_Port;
    for Output 'Address use 16#0000_0010#;

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

Re: non record limited type

[Randy Brukardt]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message 
news:p6luqm$jb1$1@gioia.aioe.org...
> On 22/02/2018 02:29, Randy Brukardt wrote:
>
>> These types that become limited just because of "limited private" also 
>> have
>> the nasty property of becoming non-limited when you can see the full
>> declaration. This causes all kinds of semantic complications that we'd
>> rather not repeat, so everything new requires declaring it limited
>> explicitly and staying that way.
>
> I don't see anything wrong with that, except for coupling to by-reference 
> semantics. On/off visibility of the copying operation is all OK, it is 
> just an operation. Parameter passing method is a different thing.

Not to Ada: by-copy uses the assignment operation (which isn't quite the 
same thing as :=). Limited assignment is build-in-place only (for 
initialization purposes, another rule I know you hate). Probably could be 
different, but it would take extra work, and so far, there doesn't seem to 
be much need.

                                    Randy.

Re: non record limited type

[Dmitry A. Kazakov]

On 23/02/2018 00:24, Randy Brukardt wrote:
> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message
> news:p6luqm$jb1$1@gioia.aioe.org...
>> On 22/02/2018 02:29, Randy Brukardt wrote:
>>
>>> These types that become limited just because of "limited private" also
>>> have
>>> the nasty property of becoming non-limited when you can see the full
>>> declaration. This causes all kinds of semantic complications that we'd
>>> rather not repeat, so everything new requires declaring it limited
>>> explicitly and staying that way.
>>
>> I don't see anything wrong with that, except for coupling to by-reference
>> semantics. On/off visibility of the copying operation is all OK, it is
>> just an operation. Parameter passing method is a different thing.
> 
> Not to Ada: by-copy uses the assignment operation (which isn't quite the
> same thing as :=). Limited assignment is build-in-place only (for
> initialization purposes, another rule I know you hate). Probably could be
> different, but it would take extra work, and so far, there doesn't seem to
> be much need.

Right, but by-copy passing is not really assignment. It is a 
copy-constructor. When assignment finalizes the target, copy-constructor 
does not do anything. Ideally we should be able to disable ":=" while 
keeping by-copy passing. I can imagine use cases for short-lived smart 
pointers and iterators where I wanted no explicit copies made.

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