CVS difference for ai12s/ai12-0330-1.txt

Differences between 1.6 and version 1.7
Log of other versions for file ai12s/ai12-0330-1.txt

--- ai12s/ai12-0330-1.txt	2019/05/17 05:34:01	1.6
+++ ai12s/ai12-0330-1.txt	2020/11/21 04:57:46	1.7
@@ -1,6 +1,7 @@
-!standard N(0)                                      19-05-16  AI12-0330-1/03
+!standard N(0)                                      20-11-20  AI12-0330-1/04
 !class Amendment 19-04-05
 !status Amendment 1-2012 19-05-09
+!status work item 20-11-20
 !status ARG Approved 11-0-0  19-05-09
 !status work item 19-04-05
 !status received 19-03-08
@@ -24,6 +25,10 @@
 
 !wording
 
+[Editor's note: These changes were applied to Draft 27 of the Ada 202x RM, 
+even though they have not yet been approved, in order that that draft be as
+accurate as possible.]
+
 Modify 9(1/5) to italicize "logical thread of control":
 
 The execution of an Ada program consists of the execution of one or more 
@@ -37,66 +42,75 @@
 Add the following Glossary entries:
 
 Aggregate
-A construct used to define a value of a composite type by specifying the
-values of the components of the type.
+An aggregate is a construct used to define a value of a composite type by 
+specifying the values of the components of the type.
 
 Attribute
-A characteristic or property of an entity that can be queried, and in some 
-cases specified.
+An attribute is a characteristic or property of an entity that can be queried,
+and in some cases specified.
 
-Container Aggregate
-A construct used to define a value of a type that represents a collection 
-of elements, by explicitly specifying the elements in the collection.
+Container aggregate
+A container aggregate is a construct used to define a value of a type that 
+represents a collection of elements, by explicitly specifying the elements 
+in the collection.
 
 Check
-A test made during execution to determine whether a language rule has been 
-violated.
+A check is a test made during execution to determine whether a language rule 
+has been violated.
 
 Default Initial Condition
-A property that holds for every default-initialized object of a given type.
+A default initial condition is a property that holds for every 
+default-initialized object of a given type.
 
 Iterator Filter
-A construct that is used to restrict the elements produced by an iteration 
-to those for which a boolean condition evaluates to True.
+An iterator filter is a construct that is used to restrict the elements 
+produced by an iteration to those for which a boolean condition evaluates
+to True.
 
 Logical Thread of Control
-An activity within the execution of a program that can proceed in parallel 
-with other activities of the same task, or of separate tasks.
+A logicial thread of control is an activity within the execution of a program 
+that can proceed in parallel with other activities of the same task, or of 
+separate tasks.
 
 Master
-The execution of a construct that includes waiting for tasks and finalization 
-of objects associated with the master, prior to leaving the construct.
+A master is the execution of certain constructs. Each object and task is 
+associated with a master. When a master is left, associated objects are 
+finalized and associated tasks are awaited.
+
+Nominal subtype
+The nominal subtype of a view of an object is the subtype specified when the 
+view is defined.
 
 Operational Aspect
-An aspect that indicates a logical property of an entity, such as the 
-precondition of a subprogram, or the procedure used to write a given type of 
-object to a stream.
+An operational aspect is an aspect that indicates a logical property of an 
+entity, such as the precondition of a subprogram, or the procedure used to 
+write a given type of object to a stream.
 
 Parallel Construct
-An executable construct that defines multiple activities of a single task that 
-can proceed in parallel, via the execution of multiple logical threads of 
-control.
+A parallel construct is an executable construct that defines multiple 
+activities of a single task that can proceed in parallel, via the execution
+of multiple logical threads of control.
 
 Reduction Expression
-An expression that defines how to map or transform a collection of values into 
-a new set of values, and then summarize the values by applying an operation 
-to reduce the set to a single value.
+A reduction expression is an expression that defines how to map or transform a
+collection of values into a new set of values, and then summarize the values 
+by applying an operation to reduce the set to a single value.
 
 Representation Aspect
-An aspect that indicates how an entity is mapped onto the underlying hardware, 
-for example the size or alignment of an object.
+A representation aspect is an aspect that indicates how an entity is mapped 
+onto the underlying hardware, for example the size or alignment of an object.
 
 Stable Property
-A characteristic associated with objects of a given type that is preserved by 
-many of the primitive operations of the type.
+A stable property is a characteristic associated with objects of a given type 
+that is preserved by many of the primitive operations of the type.
 
 Subunit
-A body of a program unit that can be compiled separately from its enclosing 
-program unit.
+A subunit is a body of a program unit that can be compiled separately from its 
+enclosing program unit.
 
 Suppress
-A request to the implementation to disable a run-time check for a portion of 
-the text of a program.
+To suppress a check is to give a request to the implementation to disable a 
+run-time check for a portion of the text of a program.
 
 !discussion
 
@@ -525,5 +539,390 @@
 Sent: Friday, May 17, 2019  12:25 AM
 
 Gotcha.
+
+***************************************************************
+
+From: Brad Moore
+Sent: Sunday, September 27, 2020  4:53 PM
+
+[Part of his AARM review - Editor.]
+
+7.6.1 Completion and Finalization
+----------------------------------
+
+In AARM 3.c.1/5, it is unclear what term is associated with the glossary entry.
+We should be consistent with other entries, which start by mentioning the term.
+
+3.c.1/5
+"Glossary entry: {A master is the}[The] execution of a construct that 
+includes waiting for tasks and finalization of objects associated with the 
+master, prior to leaving the construct."
+
+***************************************************************
+
+From: Randy Brukardt
+Sent: Wednesday, November 4, 2020  11:08 PM
+
+None of the new glossary entries were written in this form (see Annex N).
+Perhaps they should have been, but I don't see much point in changing only one, 
+and the reviewer of the Glossary (Tullio) didn't complain. The AARM note 
+glossary entries don't have much value, and are just a left-over of the way
+the Ada 95 tools were put together.
+
+If you want to propose a replacement for AI12-0330-1, please do.
+
+***************************************************************
+
+From: Brad Moore
+Sent: Thursday, November 5, 2020  5:35 PM
+
+Its not too important to me either, just that I think it might be confusing for
+the reader, in general, to not mention the term that is being defined.
+
+If others want to chime in that agree with my suggestion for the glossary 
+entries, I'd be happy to work on a replacement for AI12-0330-1. If nobody feels 
+this is necessary, I'm OK with withdrawing my comment. 
+
+***************************************************************
+
+From: Tucker Taft
+Sent: Thursday, November 5, 2020  6:24 PM
+
+I would agree that it is confusing to have a glossary entry in the AARM 
+without an obvious subject.
+
+***************************************************************
+
+From: Jeff Cousins
+Sent: Friday, November 6, 2020  3:01 AM
+
+I am very keen that we should have more glossary entries and that they should 
+be in a straightforward "An xyz is a ..." form. I find some of the definitions 
+in the RM, such as nominal subtype, too oblique for my understanding.
+
+***************************************************************
+
+From: Randy Brukardt
+Sent: Friday, November 6, 2020  6:37 PM
+
+>I am very keen that we should have more glossary entries and that they 
+>should be in a straightforward "An xyz is a ..." form.
+
+Ahem, most of the glossary entries in AI12-0330-1 were provided by some guy 
+named Jeff Cousins (see !appendix, mail of May 7, 2019) and they're not in 
+that form. Perhaps I should have noticed that they were not quite like the 
+older entries, but I can't think of *everything*.
+
+>I find some of the definitions in the RM, such as nominal subtype, too 
+>oblique for my understanding.
+
+Go right ahead and propose additional glossary entries. I don't think it hurts 
+to have more of those (not sure how many people use the Glossary, but even if 
+it is only a handful, it's probably worth improving).
+
+Perhaps coordinate with Brad.
+
+***************************************************************
+
+From: Jeff Cousins
+Sent: Wednesday, November 11, 2020  2:27 PM
+
+Mmm...
+
+Mechanically making changes, the new definitions would be:
+
+Aggregate
+A{n aggregate is a} construct used to define a value of a composite type by 
+specifying the values of the components of the type.
+ 
+Attribute
+A{n attribute is a} characteristic or property of an entity that can be 
+queried, and in some cases specified.
+ 
+Check
+A{ check is a} test made during execution to determine whether a language rule 
+has been violated.
+ 
+Default Initial Condition
+A{ default initial condition is a} property that holds for every 
+default-initialized object of a given type.
+ 
+Iterator Filter
+A{n iterator filter is a} construct that is used to restrict the elements 
+produced by an iteration to those for which a boolean condition evaluates to 
+True.
+ 
+Logical Thread of Control
+A{ logical thread of control is a}n activity within the execution of a program 
+that can proceed in parallel with other activities of the same task, or of 
+separate tasks.
+ 
+Master
+{A master is t}[T]he execution of a construct that includes waiting for tasks 
+and finalization of objects associated with the master, prior to leaving the 
+construct.
+ 
+Operational Aspect
+A{n operational aspect is a}n aspect that indicates a logical property of an 
+entity, such as the precondition of a subprogram, or the procedure used to 
+write a given type of object to a stream.
+ 
+Parallel Construct
+A{ parallel construct is a}n executable construct that defines multiple 
+activities of a single task that can proceed in parallel, via the execution 
+of multiple logical threads of control.
+ 
+Reduction Expression
+A{ reduction expression is a}n expression that defines how to map or 
+transform a collection of values into a new set of values, and then summarize 
+the values by applying an operation to reduce the set to a single value.
+ 
+Representation Aspect
+A{ representation aspect is a}n aspect that indicates how an entity is mapped 
+onto the underlying hardware, for example the size or alignment of an object.
+ 
+Stable Property
+A{ stable property is a} characteristic associated with objects of a given 
+type that is preserved by many of the primitive operations of the type.
+ 
+Subunit
+A{ subunit is a} body that can be compiled separately from its enclosing 
+program unit.
+ 
+Suppress
+To{ suppress is to} turn off a run-time check.
+ 
+
+For nominal subtype,  I suppose something like:
+
+ďThe nominal subtype of an object is the effective subtype after supplying 
+any range constraints (for an unconstrained array subtype) or discriminants
+(if not defaulted) at the time the object is declared.Ē
+
+though Iíve tripped over the meaning of nominal subtype so many times, thatís 
+why Iíd like someone else to define it.
+
+***************************************************************
+
+From: Tucker Taft
+Sent: Wednesday, November 11, 2020  2:46 PM
+
+>For nominal subtype,  I suppose something like:
+>
+>ďThe nominal subtype of an object is the effective subtype after supplying 
+>any range constraints (for an unconstrained array subtype) or discriminants
+>(if not defaulted) at the time the object is declared.Ē
+
+Hmmm... That doesn't match my personal definition.
+
+>though Iíve tripped over the meaning of nominal subtype so many times, thatís 
+>why Iíd like someone else to define it.
+
+Let me try;
+
+  The nominal subtype of a view of an object is the subtype specified when the 
+  view is defined.
+
+***************************************************************
+
+From: Jeff Cousins
+Sent: Wednesday, November 11, 2020  3:26 PM
+
+Thanks Tuck.
+
+I was thinking, probably incorrectly, that in:
+
+type Vector is array (Integer range <>) of Float;
+Object : Vector (1 .. 3);
+
+the nominal subtype of Object is:
+
+array (Integer range 1 .. 3) of Float;
+
+***************************************************************
+
+From: Tucker Taft
+Sent: Saturday, November 14, 2020  8:06 AM
+
+No, the nominal subtype is simply "Vector(1..3)".  I am curious what gave you 
+the impression it was more complicated than that.
+
+***************************************************************
+
+From: Jeff Cousins
+Sent: Sunday, November 15, 2020  7:22 AM
+
+Oh, itís my misunderstanding, ďnominalĒ can mean several things, such as allís 
+well for a rocket launch, but I when I hear the word itís normally in a 
+pejorative context where something is masquerading as something else.
+
+What would you call the anonymous subtype
+
+array (Integer range 1 .. 3) of Float;
+
+in my example?
+
+***************************************************************
+
+From: Tucker Taft
+Sent: Sunday, November 15, 2020  7:40 AM
+
+>Oh, itís my misunderstanding, ďnominalĒ can mean several things, such as allís 
+>well for a rocket launch, but I when I hear the word itís normally in a 
+>pejorative context where something is masquerading as something else.
+
+Interesting.  We used the term in contrast with "actual" -- the nominal subtype 
+is the subtype "named" in the declaration, whereas for a composite object, the
+*actual* subtype might be something else (more constrained than the nominal 
+subtype).  But you are right, in many contexts the term "nominal" means 
+trivially small, or a potentially misleading use of some other term (e.g.
+"The decision was nominally independent but ...").
+
+>What would you call the anonymous subtype
+>
+>array (Integer range 1 .. 3) of Float;
+>
+>in my example?
+
+Good question.  I suppose it would be "an anonymous array subtype that has the 
+same component subtype and index constraint as the named array subtype."  I 
+don't know of any use of such a notion in Ada.  You can convert from such an
+anonymous subtype to the given named subtype, but there are many anonymous 
+subtypes that are convertible to the given named subtype, because array 
+conversion permits sliding as well as a change in the type of the index.  In 
+any case, that anonymous subtype has no connection with the notion of 
+"nominal" subtype.
+
+***************************************************************
+
+From: Bob Duff
+Sent: Sunday, November 15, 2020  9:42 AM
+
+I think the "masquerading"/"misleading" meaning is correct. When you say
+
+    X : String := "Hello";
+
+it looks like the subtype of X is String, but that's fake news.
+The subtype of X is *actually* String(1..5).
+
+***************************************************************
+
+From: Randy Brukardt
+Sent: Wednesday, November 11, 2020  5:17 PM
+
+>Master
+>{A master is t}[T]he execution of a construct that includes waiting for tasks 
+>and finalization of objects associated with the master, prior to leaving the 
+>construct.
+
+This definition seems circular(as it mentions master in it) and is more 
+confusing than helpful. When it starts talking about an execution, it makes
+it seem like these are fully dynamic things that can occur anywhere, while 
+in fact they are associated with particular syntactic constructs. So I view
+them as a "thing" that gets entered and left related to the execution of 
+particular constructs.
+
+That's important since most of the uses (accessibility, finalization) describe 
+a master as a thing, not an execution. It would be extremely confusing to 
+refer to a master as a kind of verb.
+
+Maybe something more like:
+
+   A master is entered and left by the execution of particular constructs. 
+   Each object and task is associated with a master. When a master is left,
+   associated tasks are awaited and objects finalized.
+
+***************************************************************
+
+From: Jean-Pierre Rosen
+Sent: Wednesday, November 11, 2020  11:57 PM
+
+Hmmm... This does not say what a master /is/. Maybe:
+
+A master is an executable construct or entity. Each object and task is 
+associated with a master. When a master is left, associated tasks are 
+awaited and objects finalized.
+
+("construct or entity" comes from 7.6.1(3/2))
+
+***************************************************************
+
+From: Tullio Vardanega
+Sent: Thursday, November 12, 2020  2:15 AM
+
+This one def works for me.
+
+***************************************************************
+
+From: Jeff Cousins
+Sent: Thursday, November 12, 2020  12:17 PM
+
+Iím happy for it to be reworded as itís not obvious.  Personally I prefer 
+JPRís proposal to Randyís as it is a straightforward ďA master is ...Ē rather
+than a description of what happens to a master.
+
+For the record:
+
+My original words were derived from Ada 2012 TC 1 7.6.1 (1), which says:
+
+A master is the execution of a construct that includes finalization of local 
+objects after it is complete (and after waiting for any local tasks ...)
+
+which I think is where the confusion that Randy talks about begins.
+
+My proposal of 2019/05/07 was:
+
+Master
+The execution of a construct that includes the finalization of local objects 
+(after completion but before leaving).
+ 
+Annex N of Ada 202x draft 26, presumably an edit of this, says:
+
+Master.
+The execution of a construct that includes waiting for tasks and finalization 
+of objects associated with the master, prior to leaving the construct.
+
+Randyís proposal of 2020/11/11 says:
+
+A master is entered and left by the execution of particular constructs. Each 
+object and task is associated with a master. When a master is left, associated
+tasks are awaited and objects finalized.
+
+JPR then proposed:
+
+A master is an executable construct or entity. Each object and task is
+associated with a master. When a master is left, associated tasks are
+awaited and objects finalized.
+
+***************************************************************
+
+From: Randy Brukardt
+Sent: Thursday, November 12, 2020  12:39 PM
+
+One would hope that a glossary entry was clearer than the formal definition, 
+not just a direct restating of it. If someone has trouble understanding the 
+definition, they might turn to the glossary for help -- repeating the same 
+words will not give any help.
+
+J-P's definition is fine by me.
+
+***************************************************************
+
+From: Tucker Taft
+Sent: Thursday, November 12, 2020  1:03 PM
+
+> One would hope that a glossary entry was clearer than the formal definition, 
+> not just a direct restating of it. If someone has trouble understanding the 
+> definition, they might turn to the glossary for help -- repeating the same 
+> words will not give any help.
+
+Perhaps, but saying something completely different doesn't really help either.
+My sense is the glossary is mostly just capturing the definitions that are 
+already in the RM, but in a central place.  I don't think we need to work too
+hard to expand the definition, if the RM one is fairly clear.
+
+> J-P's definition is fine by me.
+
+Fine by me as well.
 
 ***************************************************************

Questions? Ask the ACAA Technical Agent