Overloading attributes

Overloading attributes

[Matt Borchers]

Why is it that one cannot overload the 'Image and 'Value attribute
similar to how we can overload 'Input, 'Output, 'Read, and 'Write?  I
think it would be nice to be able to do the following:

type FOO is ...;

function Image( f : FOO ) return String;
for FOO'Image use Image;

function To_Foo( s : String ) return FOO;
for FOO'Value use To_Foo;

Is there a reason that this is not allowed?  Why limit 'Image and
'Value to only scalar types.
Why expose a routine to "stringify" an object through the package
specification when a language construct already exists that could do
this?

I can also imagine how overloading 'Pred and 'Succ would be kinda nice
for link list traversals (and possibly other linked structures):

type A_FOO is access FOO;  --FOO has a field that points to next
record via pointer

function Succ( f : A_FOO ) return A_FOO;
for A_FOO'Succ use Succ;
--similar for 'Pred if it is a doubly linked list

x : A_FOO;
x := x'Succ;

Why expose a Next routine through the package specification when a
language construct already exists that can do this?

How about other Attributes like 'Pos, 'Val, 'First, 'Last, etc?  Could
they be overloaded on user-defined types?

Re: Overloading attributes

[Shark8]

On Nov 26, 5:13 pm, Matt Borchers <mattborch...@gmail.com> wrote:
> Why is it that one cannot overload the 'Image and 'Value attribute
> similar to how we can overload 'Input, 'Output, 'Read, and 'Write?  I
> think it would be nice to be able to do the following:
>
> type FOO is ...;
>
> function Image( f : FOO ) return String;
> for FOO'Image use Image;
>
> function To_Foo( s : String ) return FOO;
> for FOO'Value use To_Foo;
>
> Is there a reason that this is not allowed?  Why limit 'Image and
> 'Value to only scalar types.
> Why expose a routine to "stringify" an object through the package
> specification when a language construct already exists that could do
> this?
>
> I can also imagine how overloading 'Pred and 'Succ would be kinda nice
> for link list traversals (and possibly other linked structures):
>
> type A_FOO is access FOO;  --FOO has a field that points to next
> record via pointer
>
> function Succ( f : A_FOO ) return A_FOO;
> for A_FOO'Succ use Succ;
> --similar for 'Pred if it is a doubly linked list
>
> x : A_FOO;
> x := x'Succ;
>
> Why expose a Next routine through the package specification when a
> language construct already exists that can do this?
>
> How about other Attributes like 'Pos, 'Val, 'First, 'Last, etc?  Could
> they be overloaded on user-defined types?

You can write an function to replace 'Image, it's a rather a good
question you bring up because it can also be stated:
"why are 'Read & 'Write required to have an attribute definition
clause,
 but 'Image is not (in fact it is forbidden)?"

Re: Overloading attributes

[Yannick Duchêne (Hibou57)]

Le Sun, 27 Nov 2011 00:24:08 +0100, Shark8 <onewingedshark@gmail.com> a  
écrit:
> You can write an function to replace 'Image, it's a rather a good
> question you bring up because it can also be stated:
> "why are 'Read & 'Write required to have an attribute definition
> clause,
>  but 'Image is not (in fact it is forbidden)?"

Personal opinion: something similar to what I replied to Dmitry some days  
ago, about not blindly applying any schema to anything. A case by case  
investigation shows 'Read and 'Write are useful to persistent storage and  
can be used internally by the Ada runtime or standard library. Image is  
not, and is all in user space only. So there is no formal need to be able  
to say “for X'Image” use, because the runtime, nor the standard library,  
will never use it, and as only the user will access it, the user can as  
much define an “function Image (X : …) return String_Or_Whatever_Type;”.  
Similarly, the runtime will make use of Storage (via “new T”), so the  
’Storage attribute can be redefined by the user.

It's all a matter of “is this just toy or it this formally required ?”. A  
user re-definable Image attribute is not needed for the language, so it's  
up to the user to deal with it at user level.

P.S. I feel the sole use of 'Image I know, is for quick debugging output  
of something. Otherwise, if you need to write a text representation of an  
entity to some file, you should go with a custom procedure or function.

-- 
“Syntactic sugar causes cancer of the semi-colons.” [1]
“Structured Programming supports the law of the excluded muddle.” [1]
[1]: [Epigrams on Programming — Alan J. — P. Yale University]

Re: Overloading attributes

[anon]

In Ada, Overloading is allow for all attributes include programmers 
created attributes. But Adacore GNAT has decided a number of years 
ago to not allow programmers to create their attributes and has 
limited the overloading of standard attributes. 

While some may see this as cripping Ada others do not. Because 
except for those predefined by the Ada standard library which may 
be hidden, the programmer create attribute routine rather overloading 
or not must be visable to the package it is used in. So, its just as 
reasonable to call the attribute routine as any other routine.



Note: Other Ada compilers may or may not follow Adacore GNAT decision 
on this issue.

In <8ed87fee-166a-4be9-ae6c-4d0fbeb4788c@s6g2000vbc.googlegroups.com>, Matt Borchers <mattborchers@gmail.com> writes:
>Why is it that one cannot overload the 'Image and 'Value attribute
>similar to how we can overload 'Input, 'Output, 'Read, and 'Write?  I
>think it would be nice to be able to do the following:
>
>type FOO is ...;
>
>function Image( f : FOO ) return String;
>for FOO'Image use Image;
>
>function To_Foo( s : String ) return FOO;
>for FOO'Value use To_Foo;
>
>Is there a reason that this is not allowed?  Why limit 'Image and
>'Value to only scalar types.
>Why expose a routine to "stringify" an object through the package
>specification when a language construct already exists that could do
>this?
>
>I can also imagine how overloading 'Pred and 'Succ would be kinda nice
>for link list traversals (and possibly other linked structures):
>
>type A_FOO is access FOO;  --FOO has a field that points to next
>record via pointer
>
>function Succ( f : A_FOO ) return A_FOO;
>for A_FOO'Succ use Succ;
>--similar for 'Pred if it is a doubly linked list
>
>x : A_FOO;
>x := x'Succ;
>
>Why expose a Next routine through the package specification when a
>language construct already exists that can do this?
>
>How about other Attributes like 'Pos, 'Val, 'First, 'Last, etc?  Could
>they be overloaded on user-defined types?

Re: Overloading attributes

[J-P. Rosen]

Le 27/11/2011 04:36, anon@att.net a �crit :
> In Ada, Overloading is allow for all attributes include programmers 
> created attributes. 
please point me at the RM paragraphe that allows programmers created
attributes, I must have missed something!

-- 
---------------------------------------------------------
           J-P. Rosen (rosen@adalog.fr)
Adalog a d�m�nag� / Adalog has moved:
2 rue du Docteur Lombard, 92441 Issy-les-Moulineaux CEDEX
Tel: +33 1 45 29 21 52, Fax: +33 1 45 29 25 00

Re: Overloading attributes

[anon]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 2398 bytes --]

From time to time this forum has discussed the concept of the 
"attribute definition clause" (Representation Attributes). Some have 
even say it would cause an increase of 4_000 lines of code to be 
written to include this feature in a compiler.


From Ada 95 RM

13.3 Representation Attributes

2   attribute_definition_clause ::=
          for local_name'attribute_designator use expression;
        | for local_name'attribute_designator use name;


                               Legality Rules

5     (95)
5/1 (2005)

An attribute_designator is allowed in an attribute_definition_clause only
if this International Standard explicitly allows it, or for an
implementation-defined attribute if the implementation allows it.  Each
specifiable attribute constitutes an aspect of representation.

This clause does not forbid the creation of new attribute it only states 
that it is up to the implementation to allow it if the Standard does not 
explicitly allows it.

For instant, the implementation could say that the programmer can create 
new attributes for types created by the programmer only. Aka like the 
attribute "Image" (which is define for scalar objects), for a programmer 
defined record. Or the implementation could predefine a set of "attribute 
designators" that could be used by a programmer.


And for Ada 83, the complete syntax and implementation of must be 
documented in Appendix F for the allowed representation clauses.

So, Ada 83 allows the creation with just documentation. As for Standards 
Ada 95, Ada 2005 and Ada 2012 they started to limit the usage, but still 
allow with the implementation permission.

Which means that Ada can allow a programmer to create "Representation 
Attributes" aka "Attributes" with some limitations if the Standard
or the Implementation allows it.


In <jasnea$ac1$1@dont-email.me>, "J-P. Rosen" <rosen@adalog.fr> writes:
>Le 27/11/2011 04:36, anon@att.net a �crit :
>> In Ada, Overloading is allow for all attributes include programmers 
>> created attributes. 
>please point me at the RM paragraphe that allows programmers created
>attributes, I must have missed something!
>
>-- 
>---------------------------------------------------------
>           J-P. Rosen (rosen@adalog.fr)
>Adalog a d�m�nag� / Adalog has moved:
>2 rue du Docteur Lombard, 92441 Issy-les-Moulineaux CEDEX
>Tel: +33 1 45 29 21 52, Fax: +33 1 45 29 25 00

Re: Overloading attributes

[Yannick Duchêne (Hibou57)]

Le Sun, 27 Nov 2011 21:00:39 +0100, <anon@att.net> a écrit:

> From time to time this forum has discussed the concept of the
> "attribute definition clause" (Representation Attributes). Some have
> even say it would cause an increase of 4_000 lines of code to be
> written to include this feature in a compiler.
>
>
> From Ada 95 RM
>
> 13.3 Representation Attributes
>
> 2   attribute_definition_clause ::=
>           for local_name'attribute_designator use expression;
>         | for local_name'attribute_designator use name;
>
>
>                                Legality Rules
>
> 5     (95)
> 5/1 (2005)
>
> An attribute_designator is allowed in an attribute_definition_clause only
> if this International Standard explicitly allows it, or for an
> implementation-defined attribute if the implementation allows it.  Each
> specifiable attribute constitutes an aspect of representation.

You should have clearly marked where the quotation starts and where it  
ends. Actually, it ends here, and all of the following, is your personal  
wordings, not part at all of the standard.

> This clause does not forbid the creation of new attribute it only states
> that it is up to the implementation to allow it if the Standard does not
> explicitly allows it.
>
> For instant, the implementation could say that the programmer can create
> new attributes for types created by the programmer only. Aka like the
> attribute "Image" (which is define for scalar objects), for a programmer
> defined record. Or the implementation could predefine a set of "attribute
> designators" that could be used by a programmer.
>
>
> And for Ada 83, the complete syntax and implementation of must be
> documented in Appendix F for the allowed representation clauses.
>
> So, Ada 83 allows the creation with just documentation. As for Standards
> Ada 95, Ada 2005 and Ada 2012 they started to limit the usage, but still
> allow with the implementation permission.
>
> Which means that Ada can allow a programmer to create "Representation
> Attributes" aka "Attributes" with some limitations if the Standard
> or the Implementation allows it.

You could go far this way, even up to an Ada compiler understanding MS  
Quick Basic. Unfortunately for you, the standard also clearly state this:

> 1.1.3 Conformity of an Implementation with the Standard
> Implementation Requirements
> A conforming implementation shall:
> […]
> * Contain no variations except those explicitly permitted by this  
> International Standard,
> or those that are impossible or impractical to avoid given the  
> implementation's
> execution environment;

So you can forget about user defined attributes, unless you can quote the  
RM where it “explicitly permit” user defined attributes. At least, user  
defined attributes does not fall in the “impossible or impractical to  
avoid” case.

-- 
“Syntactic sugar causes cancer of the semi-colons.” [1]
“Structured Programming supports the law of the excluded muddle.” [1]
[1]: [Epigrams on Programming — Alan J. — P. Yale University]

Re: Overloading attributes

[Yannick Duchêne (Hibou57)]

Le Sun, 27 Nov 2011 21:34:42 +0100, Yannick Duchêne (Hibou57)  
<yannick_duchene@yahoo.fr> a écrit:
> So you can forget about user defined attributes, unless you can quote  
> the RM where it “explicitly permit” user defined attributes. At least,  
> user defined attributes does not fall in the “impossible or impractical  
> to avoid” case.
Well, I found it for you: a sentence at same place where implementation  
defined pragma are explicitly allowed.

> 1.1.3 Conformity of an Implementation with the Standard
> […]
> 17 An implementation conforming to this International Standard may  
> provideadditional attributes, library units, and pragmas.
Still does not talk about user defined attributes. Deducing “allow user  
defined attributes” from “allow implementation defined attributes”, seems  
dubious.

-- 
“Syntactic sugar causes cancer of the semi-colons.” [1]
“Structured Programming supports the law of the excluded muddle.” [1]
[1]: [Epigrams on Programming — Alan J. — P. Yale University]

Re: Overloading attributes

[J-P. Rosen]

Le 27/11/2011 21:00, anon@att.net a �crit :
> Which means that Ada can allow a programmer to create "Representation 
> Attributes" aka "Attributes" with some limitations if the Standard
> or the Implementation allows it.

Quoting from you own message:
> An attribute_designator is allowed in an attribute_definition_clause only
> if this International Standard explicitly allows it, or for an
> implementation-defined attribute if the implementation allows it.  Each
> specifiable attribute constitutes an aspect of representation.
Which is perfectly clear: the implementation can allow pretty much
anything /for its own implementation defined attributes/, but standard
attributes can be defined only when explicitely allowed by the standard
- and those are correctly implemented by GNAT. In no case can the
/programmer/ define attributes.

Please stop spreading FUD.
-- 
---------------------------------------------------------
           J-P. Rosen (rosen@adalog.fr)
Adalog a d�m�nag� / Adalog has moved:
2 rue du Docteur Lombard, 92441 Issy-les-Moulineaux CEDEX
Tel: +33 1 45 29 21 52, Fax: +33 1 45 29 25 00

Re: Overloading attributes

[anon]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 3520 bytes --]


Before I get to what "Randy Brukardt" an ARG member said, let me 
give you a little language lesson:

If a programmer write a program using Ada programmer is author of that 
Implementation aka program. If a programmer write a system (multiple Ada 
programs), the programmer is the author of that Implementation or System. 
And as the Implementation the Standard allows the author to create her/his 
own attributes for that Implementation.




From previous posts by "Randy Brukardt" <randy@rrsoftware.com>
                      Oct 28, 2009

Post 1:
> First, a historical question: Was there a proposal for user attributes
> that was considered for Ada 2005?

Not seriously. It had been rejected for Ada 95, and in general, we didn't
want to rehash that old ground. 

Post 2:
>When it was proposed for Ada 95, I griped about the implementation cost (as
>noted in my original message). Some other implementers agreed with me. When
>the scope reduction was applied to the Ada 9x proposal (the original
>language was just too large for the time, no one would ever have implemented
>it), things that were just "nice to haves" were removed (even if they were
>technically sound). This was in that category, so out it went. Same thing
>happened to conditional expressions and many other useful ideas.

>The reasoning hasn't changed, so I don't think we'll be revisiting that any
>time soon. 


Really!!!

Now, what Randy forgot was that "conditional expressions" have been added 
to GNAT starting in Ada 2005 and extended in Ada 2012. So, ARG does rehash 
that old ground. 

So, people are looking for "user defined attribute" to be reintroduce 
and added to Ada 2012 since it has not been formally voted on as a 
Standard yet (which will occur between 2012 and 2020). And if not added 
will be strongly requested from the Ada community for Ada 2020 Standard.

And others "nice to have" features that were once remove from the Ada 95 
Standard, will be requested or added back in Ada 2020.  Because it is 
Time, some may say

The problem is no Standard should allow the removal any feature from 
any updated Standard of a language, only allow some features to be 
optional for the author of the compiler. And if the compiler is 
constructed right it should be as easy as added addition library 
packages.

In <jaug0j$ph5$1@dont-email.me>, "J-P. Rosen" <rosen@adalog.fr> writes:
>Le 27/11/2011 21:00, anon@att.net a �crit :
>> Which means that Ada can allow a programmer to create "Representation 
>> Attributes" aka "Attributes" with some limitations if the Standard
>> or the Implementation allows it.
>
>Quoting from you own message:
>> An attribute_designator is allowed in an attribute_definition_clause only
>> if this International Standard explicitly allows it, or for an
>> implementation-defined attribute if the implementation allows it.  Each
>> specifiable attribute constitutes an aspect of representation.
>Which is perfectly clear: the implementation can allow pretty much
>anything /for its own implementation defined attributes/, but standard
>attributes can be defined only when explicitely allowed by the standard
>- and those are correctly implemented by GNAT. In no case can the
>/programmer/ define attributes.
>
>Please stop spreading FUD.
>-- 
>---------------------------------------------------------
>           J-P. Rosen (rosen@adalog.fr)
>Adalog a d�m�nag� / Adalog has moved:
>2 rue du Docteur Lombard, 92441 Issy-les-Moulineaux CEDEX
>Tel: +33 1 45 29 21 52, Fax: +33 1 45 29 25 00

Re: Overloading attributes

[Peter C. Chapin]

On 2011-11-28 04:11, anon@att.net wrote:

> If a programmer write a program using Ada programmer is author of that
> Implementation aka program.

When the standard says "implementation" it is talking about the Ada 
compiler and associated standard library, not programs written in Ada. 
The standard is referring to the implementation of the Ada language.

Peter

Re: Overloading attributes

[anon]

Where in the RM does it say that the compiler and RTL is the implementation?
As everyone says the Ada RM is the final word! And if it is not defined in 
the RM then the compiler and RTL are not the implementation, but are the 
tools for the implementation.

Compiler is tool for the programmers that allows a language to be used 
on a specific operating environment or system. Actually, if an high-level 
language compiler is written correctly, then the compiler itself is a 
finished partition even if additions are added or subtract from the 
language the compiler is not modified only re-compiled for the 
new system as they are created.

And as for the run-time libraries, well there are two major groups. The 
first is a set of library routines that links a language to the outside 
environment aka either the hardware like on a bareboard system or the 
parent program which can include the operating system.  The second set of 
library routines are common routines that are both useful and helpful
in writing an implementation. But no run-time libraries packages can be 
declared as a full implementation only a subpart of the implementation.


For Ludovic Brenta:

I know J-P Rosen is also a member of the ARG. But sometimes a person 
such as a member of the ARG can be so busy with a set of issues they are 
working on that the overlook others issue that may have faults. They 
should be grateful and note the fault for future reference when someone 
point them out.


In <rNudnaTdZOKn9U7T4p2dnAA@giganews.com>, "Peter C. Chapin" <PChapin@vtc.vsc.edu> writes:
>On 2011-11-28 04:11, anon@att.net wrote:
>
>> If a programmer write a program using Ada programmer is author of that
>> Implementation aka program.
>
>When the standard says "implementation" it is talking about the Ada 
>compiler and associated standard library, not programs written in Ada. 
>The standard is referring to the implementation of the Ada language.
>
>Peter

Re: Overloading attributes

[Mark Lorenzen]

On 29 Nov., 12:58, a...@att.net wrote:
> Where in the RM does it say that the compiler and RTL is the implementation?
> As everyone says the Ada RM is the final word! And if it is not defined in
> the RM then the compiler and RTL are not the implementation, but are the
> tools for the implementation.

I think that chapter 1.1.3 ("Conformity of an Implementation with the
Standard") pretty well describes the expectations for an
implementation. To me it's pretty obvious that the standard is talking
about the toolchain and the RTL.

Regards,

Mark L

Re: Overloading attributes

[anon]

As for RM 1.1.3 "Conformity of an Implementation with the Standard"

This is just a small list of errors within the GNAT system.
Lets see GNAT violates a number of paragraphs such as:

    2  Translate and correctly execute legal programs written in Ada,
       provided that they are not so large as to exceed the capacity of
       the implementation;

   15  A conforming implementation of this International Standard shall 
       produce for the execution of a given Ada program a set of 
       interactions with the external environment whose order and timing 
       are consistent with the definitions and requirements of this 
       International Standard for the semantics of the given program.

When the GNAT compiler see a raise statement like 

         raise Program_Error ;

instead of converting the routine into something like is 

         Raise_Exception ( Program_Error'Identity,
                           Integer'Image ( Line_Number ) ) ;
or maybe 

         Raise_Exception ( Program_Error'Identity,
                           "was explicit raise by <filename> at line" 
                           & Integer'Image ( Line_Number ) ) ;

it converts it to 

         RCheck_15 ( "<filename>", Line_number ) ;

that not translate and correctly. and the routines that must be 
executed may interfer with the program timing.


    5  Supply all language-defined library units required by this
       International Standard;

   16  An implementation that conforms to this Standard shall support 
       each capability required by the core language as specified.  In 
       addition, an implementation that conforms to this Standard may 
       conform to one or more Specialized Needs Annexes (or to none).  
       Conformance to a Specialized Needs Annex means that each 
       capability required by the Annex is provided as specified.

A number of packages in GNAT do not function as stated in the Standard 
an example is System.RPC and another is Ada.Asynchronous_Task_Control.

For the "Partition Communication Subsystem", Ada uses System.RPC which 
an older communication but is still in the RM and is still useful.

Also, since GNAT compiler can process a program for multi-environments 
it is required that all language-defined library units be fully 
functional so Ada.Asynchronous_Task_Control should be fully functional 
as well.

    6  Contain no variations except those explicitly permitted by this
       International Standard, or those that are impossible or
       impractical to avoid given the implementation's execution
       environment;

GNAT is always adding extra features that may or may not be in the 
next Standard version that can causes corruptions to occur with current 
Standard. Plus, there are a number of statements designs that are not 
functional like the "representation_clause" within the "Protected Units"


   10  The execution of certain code_statements (see 13.8); which 
       code_statements cause external interactions is implementation 
       defined.


While the System.Machine_Code package may be optional, but the coding of 
"code_statements" are not optional. GNAT does not allow "code_statements" 
of any kind. Actually the GNAT compiler does contains the code for 
processing a "code_statement" but it is deactivated.



Adacore GNAT compiler and RTL is one of two Ada leading Ada systems, the 
other is IBM/APEX system.  Since GNAT can not even meet the complete 
definition that is in "RM 1.1.3" that indicates that one or the other is 
corrupted or and should not be used.


This might expain one reason the Dod drop the mandated use of Ada.


In <f10225e5-d894-4ccb-924a-6cf741781fe4@t16g2000vba.googlegroups.com>, Mark Lorenzen <mark.lorenzen@gmail.com> writes:
>On 29 Nov., 12:58, a...@att.net wrote:
>> Where in the RM does it say that the compiler and RTL is the implementation?
>> As everyone says the Ada RM is the final word! And if it is not defined in
>> the RM then the compiler and RTL are not the implementation, but are the
>> tools for the implementation.
>
>I think that chapter 1.1.3 ("Conformity of an Implementation with the
>Standard") pretty well describes the expectations for an
>implementation. To me it's pretty obvious that the standard is talking
>about the toolchain and the RTL.
>
>Regards,
>
>Mark L

Re: Overloading attributes

[AdaMagica]

On 29 Nov., 12:58, a...@att.net wrote:
> Where in the RM does it say that the compiler and RTL is the implementation?
> As everyone says the Ada RM is the final word! And if it is not defined in
> the RM then the compiler and RTL are not the implementation, but are the
> tools for the implementation.
... Rest of all this nonsense skipped.

Do we really need to further reply to all this incredible junk?

Re: Overloading attributes

[Jeffrey Carter]

On 11/29/2011 09:16 AM, AdaMagica wrote:
>
> Do we really need to further reply to all this incredible junk?

I kill-filed anon long ago so I don't have to read this kind of junk. The only 
time I see anything it posts is when someone else replies to it.

-- 
Jeff Carter
"Crucifixion's a doddle."
Monty Python's Life of Brian
82

Re: Overloading attributes

[J-P. Rosen]

Le 29/11/2011 17:16, AdaMagica a �crit :
> ... Rest of all this nonsense skipped.
> 
> Do we really need to further reply to all this incredible junk?
Unfortunately yes.

Not for anon whose case is desperate, but because the news are archived
on many sites and then googled. People should be warned that this IS
nonsense.

-- 
---------------------------------------------------------
           J-P. Rosen (rosen@adalog.fr)
Adalog a d�m�nag� / Adalog has moved:
2 rue du Docteur Lombard, 92441 Issy-les-Moulineaux CEDEX
Tel: +33 1 45 29 21 52, Fax: +33 1 45 29 25 00

Re: Overloading attributes

[anon]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 2941 bytes --]

What up with the "Name Calling"!!!

I choose not to when "J-P. Rosen" basically called me a lier and worst 
with the usage of "FUD". And cutting down does not make what I say 
wrong it just means that you have no logical answer that would stand 
up in court. 

The problem is the RM uses to many words that have multiple meaning
under many conditions for computer science. This leads to a language 
corruption and death of that language which none of us wants that for 
Ada. So, instead of using these words like "implementations" the RM 
should clarify itself by using words which has only one meaning under 
computer science. And after 15 plus years from the creation of "Ada 95" 
and its two extensions ( 2005, 2012 ) it about time that the Ada 
community correct the wording in the RM before branching into "Ada 2020". 



Like in Ada's BNF the "attribute_designator" is not define. 

Clarification would be simple 

    attribute_designator ::= standard_attribute_designator
                           | compiler_provider_attribute_designator


    standard_attribute_designator ::=  Access    |  Access |  Address
                                     ... |  Write

        For functionally and examples of the all Standard attributes
        See Annex K Section: Standard.

        < list of provider restrictions to Standard attribute >

    compiler_provider_attribute_designator ::= 
                                  < complete list of provider_attributes >


Note: Each provider of a compiler shall edited the previous statement 
      and provide a complete list of all attributes. Then append
      Annex K Section: Provider section, to list the functionally and 
      give an example of each attribute provided created by the provider.





Addition to Annex N : Glossary ( to clarify the word "provider" )


  Provider:  An entity that one can receive the entity's version
             (author) Ada compiler and/or Run-Time Libraries.



Since "entity" is not commonly used in computer languages it does not 
need to be define.


And example of Providers 
   Adacore
   IBM
   RRSoftware
   ...

GCC and Linux (any version) is not a provider because they are not 
the author.  They only give another access to Adacore GNAT for a
OS and the edited source.



In <jb3pm8$ng9$1@dont-email.me>, "J-P. Rosen" <rosen@adalog.fr> writes:
>Le 29/11/2011 17:16, AdaMagica a �crit :
>> ... Rest of all this nonsense skipped.
>> 
>> Do we really need to further reply to all this incredible junk?
>Unfortunately yes.
>
>Not for anon whose case is desperate, but because the news are archived
>on many sites and then googled. People should be warned that this IS
>nonsense.
>
>-- 
>---------------------------------------------------------
>           J-P. Rosen (rosen@adalog.fr)
>Adalog a d�m�nag� / Adalog has moved:
>2 rue du Docteur Lombard, 92441 Issy-les-Moulineaux CEDEX
>Tel: +33 1 45 29 21 52, Fax: +33 1 45 29 25 00

Re: Overloading attributes

[J-P. Rosen]

Le 30/11/2011 12:06, anon@att.net a �crit :
> I choose not to when "J-P. Rosen" basically called me a lier and worst 
> with the usage of "FUD". And cutting down does not make what I say 
> wrong it just means that you have no logical answer that would stand 
> up in court. 
> 
In court I don't know (although courts generally use well recognized
experts, should the case happen, I bet they would get someone from the
ARG), but at least there is not a single post of yours that got support
from anyone else in this newsgroup.

-- 
---------------------------------------------------------
           J-P. Rosen (rosen@adalog.fr)
Adalog a d�m�nag� / Adalog has moved:
2 rue du Docteur Lombard, 92441 Issy-les-Moulineaux CEDEX
Tel: +33 1 45 29 21 52, Fax: +33 1 45 29 25 00

Re: Overloading attributes

[Yannick Duchêne (Hibou57)]

Le Wed, 30 Nov 2011 16:52:21 +0100, J-P. Rosen <rosen@adalog.fr> a écrit:

> Le 30/11/2011 12:06, anon@att.net a écrit :
>> I choose not to when "J-P. Rosen" basically called me a lier and worst
>> with the usage of "FUD". And cutting down does not make what I say
>> wrong it just means that you have no logical answer that would stand
>> up in court.
>>
> […] but at least there is not a single post of yours that got support
> from anyone else in this newsgroup.
Ones may note: not even from newbies (to complete the fact).


-- 
“Syntactic sugar causes cancer of the semi-colons.” [1]
“Structured Programming supports the law of the excluded muddle.” [1]
[1]: [Epigrams on Programming — Alan J. — P. Yale University]

Re: Overloading attributes

[Pascal Obry]

Le 30/11/2011 16:52, J-P. Rosen a �crit :
> In court I don't know (although courts generally use well recognized
> experts, should the case happen, I bet they would get someone from the
> ARG), but at least there is not a single post of yours that got support
> from anyone else in this newsgroup.

Sad but true. And I agree when you say that we have to respond to at
least point out all the non sense!

Courage!

Pascal.

-- 

--|------------------------------------------------------
--| Pascal Obry                           Team-Ada Member
--| 45, rue Gabriel Peri - 78114 Magny Les Hameaux FRANCE
--|------------------------------------------------------
--|    http://www.obry.net  -  http://v2p.fr.eu.org
--| "The best way to travel is by means of imagination"
--|
--| gpg --keyserver keys.gnupg.net --recv-key F949BD3B

Re: Overloading attributes

[Simon Wright]

"J-P. Rosen" <rosen@adalog.fr> writes:

> Le 30/11/2011 12:06, anon@att.net a écrit :
[bluster]
> In court I don't know (although courts generally use well recognized
> experts, should the case happen, I bet they would get someone from the
> ARG), but at least there is not a single post of yours that got support
> from anyone else in this newsgroup.

I don't think that's completely fair :-)

Although I have anon killfiled, I do occasionally read his (I think it
has to be 'his') posts, and every so often he says something sensible,
which is a huge surprise.

Not in this thread, though.

Re: Overloading attributes

[anon]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 2399 bytes --]

When a so called expert loses their cool and use bad language they lose 
their creditability in any court or discussion. So there is no need for 
anyone to lean a hand of aid or support.

Plus, for those people who would speak in behalf, why would they speak 
here now and become targets for bulling by the others who do not agree 
with my speech.

Of course most who were voicing their opinion were just upset because I 
was questioning the wisdom their Gods aka the ARG. 

And the courts also do not favor those who just blindly follow a group 
like ARG without questioning the groups wisdom from time to time. Or a 
group that does not accept criticism from the outside. And especially 
those groups that do not accept and truly evaluate input from that their 
community. If the ARG accepted input then it would be posted on a 
website for all to read and comment on that input. That way the ARG 
could judge the community desire for that request.

It also seams that you did not do your homework there are a few that 
support my posts in the newsgroup. Some even tried to help in prior 
posts, when a guy was cutting me down for what I saying. Then 
about three to six month later wikileaks shows up and verified what 
I was saying.

As a final word on this subject for now is what you should of done was 
ask a question instead of cutting some one down.  That way it could 
be resolve in a tactful way that other could see that the ARG as a 
group listen to the Ada community and their concerns for the future 
of Ada.


In <jb5jfi$c60$1@dont-email.me>, "J-P. Rosen" <rosen@adalog.fr> writes:
>Le 30/11/2011 12:06, anon@att.net a �crit :
>> I choose not to when "J-P. Rosen" basically called me a lier and worst 
>> with the usage of "FUD". And cutting down does not make what I say 
>> wrong it just means that you have no logical answer that would stand 
>> up in court. 
>> 
>In court I don't know (although courts generally use well recognized
>experts, should the case happen, I bet they would get someone from the
>ARG), but at least there is not a single post of yours that got support
>from anyone else in this newsgroup.
>
>-- 
>---------------------------------------------------------
>           J-P. Rosen (rosen@adalog.fr)
>Adalog a d�m�nag� / Adalog has moved:
>2 rue du Docteur Lombard, 92441 Issy-les-Moulineaux CEDEX
>Tel: +33 1 45 29 21 52, Fax: +33 1 45 29 25 00

Re: Overloading attributes

[Ludovic Brenta]

anon@att.net writes:
> When a so called expert loses their cool and use bad language they lose 
> their creditability in any court or discussion. So there is no need for 
> anyone to lean a hand of aid or support.

OK, I'm not an expert witness at court, to it is OK for me to lose my
cool.  You have just made me lose my cool.  And I do not worry for my
credibility because I have *proven* that I can *deliver*.

> Plus, for those people who would speak in behalf, why would they speak
> here now and become targets for bulling by the others who do not agree
> with my speech.

Nobody here agrees with your speech.

> Of course most who were voicing their opinion were just upset because
> I was questioning the wisdom their Gods aka the ARG.

I do not think of the ARG members as Gods.  I think of them as
intelligent people.  People who actually think before they write ISO
standards.

> And the courts also do not favor those who just blindly follow a group
> like ARG without questioning the groups wisdom from time to time. Or a
> group that does not accept criticism from the outside.

Yet another falsehood.  The ARG does accept criticism, that's what AIs
are for.  Dmitry here regularly criticizes the design of Ada and nobody
objects to that because his criticisms are the result of actual
thinking.  In contrast, what you write is not criticism, it is bullshit.

> And especially those groups that do not accept and truly evaluate
> input from that their community.

I for one have truly evaluated your input and I have decided that your
input is garbage.

> If the ARG accepted input then it would be posted on a website for all
> to read and comment on that input. That way the ARG could judge the
> community desire for that request.

Newsflash for the ignorant: that is already the case and has been for
decades; see http://www.ada-auth.org.

> It also seams that you did not do your homework there are a few that
> support my posts in the newsgroup.

Name one.  I dare you.

> Some even tried to help in prior posts, when a guy was cutting me down
> for what I saying. Then about three to six month later wikileaks shows
> up and verified what I was saying.

Given your track record of unsubstantiated claims I will not even bother
looking that up to disprove you.  The burden of proof is on you.

> As a final word on this subject for now is

You do not have the final word, because you have not proven that you are
worthy of having the final word.

>                                            what you should of done was
> ask a question instead of cutting some one down.  That way it could be
> resolve in a tactful way that other could see that the ARG as a group
> listen to the Ada community and their concerns for the future of Ada.

You are not capable of answering technical questions.  Why should an
expert like JP ask a technical question?  Especially to you?  Please do
*not* answer.  Your posts are 99% bullshit and 1% actual knowledge of
Ada, which other people are better able than you are to convey.

-- 
Ludovic Brenta.
Our perspective generates the enabler. 

Re: Overloading attributes

[Yannick Duchêne (Hibou57)]

Le Fri, 02 Dec 2011 20:34:10 +0100, Ludovic Brenta  
<ludovic@ludovic-brenta.org> a écrit:
>> If the ARG accepted input then it would be posted on a website for all
>> to read and comment on that input. That way the ARG could judge the
>> community desire for that request.
>
> Newsflash for the ignorant: that is already the case and has been for
> decades; see http://www.ada-auth.org.
And the direct pointer to the Ada Issues Database:
http://www.ada-auth.org/ais.html

-- 
“Syntactic sugar causes cancer of the semi-colons.” [1]
“Structured Programming supports the law of the excluded muddle.” [1]
[1]: Epigrams on Programming — Alan J. — P. Yale University

Re: Overloading attributes

[Randy Brukardt]

"Ludovic Brenta" <ludovic@ludovic-brenta.org> wrote in message 
news:87wrae22fh.fsf@ludovic-brenta.org...
> anon@att.net writes:
...
>> If the ARG accepted input then it would be posted on a website for all
>> to read and comment on that input. That way the ARG could judge the
>> community desire for that request.
>
> Newsflash for the ignorant: that is already the case and has been for
> decades; see http://www.ada-auth.org.

Not to mention Ada-Comment. The ARG has been taking input from the public 
longer than it (the ARG) has existed. The Ada-Comment list address is 
included in almost all editions of the Ada Standard since Ada 95 
(unfortunately, ISO doesn't let us put it into their versions), and there 
have been hundreds of comments posted there in that time. (And there were 
similar mechanisms for Ada 83, those used postal mail because the Internet 
was not yet in wide use then. Along with a similar mailing list during the 
development of Ada 9x; the ARG as we know it today started after Ada 9x was 
completed.)

We're well aware that there are some people that are unaware of all of these 
public channels, and we're going to try to do a better job in the future of 
publisizing them -- but that doesn't change the fact that these channels 
exist. The ARG does not work in a vacuum.

                                                 Randy.

Re: Overloading attributes

[Ludovic Brenta]

anon wrote on comp.lang.ada:
> Before I get to what "Randy Brukardt" an ARG member said, let me
> give you a little language lesson:

You should not try to teach the Ada language to Jean-Pierre, who is
also an ARG member.

> If a programmer write a program using Ada programmer is author of that
> Implementation aka program. If a programmer write a system (multiple Ada
> programs), the programmer is the author of that Implementation or System.
> And as the Implementation the Standard allows the author to create her/his
> own attributes for that Implementation.

Little language lesson for you: as Peter wrote, the "implementation"
is
the compiler and run-time library, not the "program".  In fact the
"implementation" is not necessarily written in Ada.

> From previous posts by "Randy Brukardt" <ra...@rrsoftware.com>
>                       Oct 28, 2009
>
> Post 1:
>
>> First, a historical question: Was there a proposal for user attributes
>> that was considered for Ada 2005?
>
> Not seriously. It had been rejected for Ada 95, and in general, we didn't
> want to rehash that old ground.
>
> Post 2:
>
>> When it was proposed for Ada 95, I griped about the implementation cost (as
>> noted in my original message). Some other implementers agreed with me. When
>> the scope reduction was applied to the Ada 9x proposal (the original
>> language was just too large for the time, no one would ever have implemented
>> it), things that were just "nice to haves" were removed (even if they were
>> technically sound). This was in that category, so out it went. Same thing
>> happened to conditional expressions and many other useful ideas.
>> The reasoning hasn't changed, so I don't think we'll be revisiting that any
>> time soon.
>
> Really!!!
>
> Now, what Randy forgot was that "conditional expressions" have been added
> to GNAT starting in Ada 2005 and extended in Ada 2012. So, ARG does rehash
> that old ground.

Another little language lesson: GNAT is not Ada.  Randy was talking
about
the Ada language definition, i.e. the ISO standard, i.e. the ARM.  You
are
talking about one particular implementation called GNAT, which Randy
does not
work on (in fact he works on another implementation of Ada).

And conditional expressions are not attributes.

> So, people are looking for "user defined attribute" to be reintroduce
> and added to Ada 2012 since it has not been formally voted on as a
> Standard yet (which will occur between 2012 and 2020). And if not added
> will be strongly requested from the Ada community for Ada 2020 Standard.

There are no user-defined attributes.  There are implementation-
defined
attributes.  Some nut not all attributes (some standard, some
implementation-defined) allow attribute definition clauses.  Sad but
true.

> And others "nice to have" features that were once remove from the Ada 95
> Standard, will be requested or added back in Ada 2020.  Because it is
> Time, some may say

That's off-topic but for the sake of your credibility, could you name
one such "nice to have" feature that has been removed from the Ada 95
Standard? (i.e. one that was present in Ada 83 but absent in Ada 95)

> J-P. Rosen writes:
>> Please stop spreading FUD.

+1

--
Ludovic Brenta.

Re: Overloading attributes

[Yannick Duchêne (Hibou57)]

Le Sun, 27 Nov 2011 00:13:17 +0100, Matt Borchers <mattborchers@gmail.com>  
a écrit:

> Why is it that one cannot overload the 'Image and 'Value attribute
> similar to how we can overload 'Input, 'Output, 'Read, and 'Write?  I
Because these are Intrinsic entities.

Also Shark8 gave you the answer and question is in return up to you: why  
not write a user (reusable) function or tagged type ?

-- 
“Syntactic sugar causes cancer of the semi-colons.” [1]
“Structured Programming supports the law of the excluded muddle.” [1]
[1]: [Epigrams on Programming — Alan J. — P. Yale University]

Re: Overloading attributes

[Dmitry A. Kazakov]

On Sat, 26 Nov 2011 15:13:17 -0800 (PST), Matt Borchers wrote:

> Why is it that one cannot overload the 'Image and 'Value attribute
> similar to how we can overload 'Input, 'Output, 'Read, and 'Write?

Because they are so broken that it does not make any sense to repair. Image
and Value should have been primitive operations and don't refer the
[sub]type.

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