CVS difference for ais/ai-00437.txt

Differences between 1.3 and version 1.4
Log of other versions for file ais/ai-00437.txt

--- ais/ai-00437.txt	2005/11/16 06:51:18	1.3
+++ ais/ai-00437.txt	2005/12/15 02:44:21	1.4
@@ -1,6 +1,7 @@
-!standard N         (01)                               05-11-15  AI95-00437/02
+!standard N         (01)                               05-11-22  AI95-00437/03
 !standard N         (03)
 !standard N         (04)
+!standard N         (06)
 !standard N         (08)
 !standard N         (12)
 !standard N         (13)
@@ -18,11 +19,12 @@
 !standard N         (36)
 !standard N         (37)
 !standard N         (38)
+!standard N         (40)
 !standard N         (41)
 !standard N         (42)
 !class presentation 05-10-17
 !status Amendment 200Y 05-10-17
-!comment This AI is not yet approved, but is included in the Amendment.
+!status ARG Approved  10-0-1  05-11-19
 !status work item 05-10-17
 !status received 05-10-17
 !priority High
@@ -46,9 +48,9 @@
 
 Replace N(1):
 
-This Annex contains informal descriptions of some terms used in this
+This Annex contains informal descriptions of some of the terms used in this
 International Standard. The index provides references to more formal
-definitions.
+definitions of all of the terms used in this International Standard.
 
 
 Add after N(1):
@@ -58,8 +60,10 @@
 
 Add after N(3):
 
-Ancestor. An ancestor of a type is the type itself or, in the case of a derived
-type, its parent type or one of its progenitor types or one of their ancestors.
+Ancestor. An ancestor of a type is the type itself or, in the case of a type
+derived from other types, its parent type or one of its progenitor types or one
+of their ancestors. Note that ancestor and descendant are inverse
+relationships.
 
 Add after N(4):
 
@@ -68,28 +72,39 @@
 category of types that is closed under derivation is also known as
 a class.
 
+Replace N(6):
+
+Class (of types). A class is a set of types that is closed under
+derivation, which means that if a given type is in the class, then all types
+derived from that type are also in the class. The set of types of a class share
+common properties, such as their primitive operations.
+
+Replace N(8):
 
+Composite type. A composite type may have components.
+
 Delete N(12).
 
 Replace N(13) by:
 
 Derived type. A derived type is a type defined in terms of one or more other
-types given in a derived type definition. The first type given is the parent
-type of the derived type and any others are
+types given in a derived type definition. The first of those types is the
+parent type of the derived type and any others are
 progenitor types. Each class containing the parent type or a progenitor type
 also contains the derived type. The derived type inherits properties such as
 components and primitive operations from the parent and progenitors. A type
 together with the types derived from it (directly or indirectly) form a
 derivation class.
 
-Descendant. A descendant of a type is any type of which the given type is an
-ancestor type. Note that a type is a descendant of itself.
+Descendant. A type is a descendant of itself, its parent and progenitor
+types, and their ancestors. Note that
+descendant and ancestor are inverse relationships.
 
 Replace N(15) by:
 
-Discriminant. A discriminant is a parameter of a composite type. It can
+Discriminant. A discriminant is a parameter for a composite type. It can
 control, for example, the bounds of a component of the type if the component
-type is an array type. A discriminant of a task type can be used to pass
+is an array. A discriminant for a task type can be used to pass
 data to a task of the type upon creation.
 
 Elaboration. The process by which a declaration has its run-time effect
@@ -102,14 +117,14 @@
 
 Add after N(19):
 
-Function. A function is a form of subprogram that returns a result and is used
-as part of an expression.
+Function. A function is a form of subprogram that returns a result and can be
+called as part of an expression.
 
 Add after N(20):
 
-Incomplete type. An incompete type gives a view of a type that reveals only
+Incomplete type. An incomplete type gives a view of a type that reveals only
 some of its properties. The remaining properties are provided by the full view
-given elsewhere. Incomplete types are valuable for defining recursive data
+given elsewhere. Incomplete types can be used for defining recursive data
 structures.
 
 Add after N(21):
@@ -118,23 +133,24 @@
 no components or concrete operations except possibly null procedures. Interface
 types are used for composing other interfaces and tagged types and thereby
 provide multiple inheritance. Only an interface type can be used as a
-progenitor of a derived type.
+progenitor of another type.
 
 Replace N(23) by:
 
-Limited type. A limited type is (a view of) a type for which copying (such as
-for an assignment_statement) is not allowed. A nonlimited type is a (view of a)
+Limited type. A limited type is a type for which copying (such as
+in an assignment_statement) is not allowed. A nonlimited type is a
 type for which copying is allowed.
 
 Add after N(24):
 
 Overriding operation. An overriding operation is one that replaces an inherited
-operation. Operations may be marked explicitly as overriding or not overriding.
+primitive operation. Operations may be marked explicitly as overriding or not
+overriding.
 
 Add after N(25):
 
-Parent. The parent type of a derived type is the first type mentioned in the
-definition of the derived type. The parent type can be almost any specific
+Parent. The parent of a derived type is the first type given in the
+definition of the derived type. The parent can be almost any kind of
 type, including an interface type.
 
 Replace N(29) by:
@@ -146,23 +162,22 @@
 
 Private type. A private type gives a view of a type that reveals only some of
 its properties. The remaining properties are provided by the full view given
-elsewhere. Private types are valuable for defining abstractions that hide
-unnecessary detail from a client.
+elsewhere. Private types can be used for defining abstractions that hide
+unnecessary details from a client.
 
 Procedure. A procedure is a form of subprogram that does not return a result
-and is called by a statement standing alone.
+and can only be called by a statement.
 
-Progenitor. A progenitor type of a derived type is one of the types mentioned
-in the definition of the derived type other than the first. A progenitor type
-is always an interface type.
+Progenitor. A progenitor of a derived type is one of the types given
+in the definition of the derived type other than the first. A progenitor
+is always an interface type. Interfaces, tasks, and protected types may also
+have progenitors.
 
 Replace N(33) by:
 
 Protected type. A protected type is a composite type whose components are
-protected from being acccessed concurrently by multiple tasks.
-
-[The existing wording is somewhat ambiguous - it appears that the tasks might
-be applying the protection. - ED]
+accessible only through one of its protected operations which synchronize
+concurrent access by multiple tasks.
 
 Add after N(36):
 
@@ -178,14 +193,20 @@
 
 Replace N(38) by:
 
-Subtype. A subtype is a type together with a constraint and/or null exclusion,
+Subtype. A subtype is a type together with a constraint or null exclusion,
 which constrains the values of the subtype to satisfy a certain condition.
 The values of a subtype are a subset of the values of its type.
 
 Synchronized. Informally, a synchronized entity is one that will work
-safely with multiple tasks at one time. A synchronized interface can be used
-with either a task or a protected type, while a synchronized tagged type is any
-of a tagged task type, tagged protected type, or a synchronized interface.
+safely with multiple tasks at one time. A synchronized interface can be an
+ancestor of a task or a protected type. Such a task or protected type is
+called a synchronized tagged type.
+
+Replace N(40) by:
+
+Task type. A task type is a composite type used to represent active entities
+which execute concurrently and which can communicate via queued task entries.
+The top-level task of a partition is called the environment task.
 
 Replace N(41) by:
 
@@ -196,10 +217,8 @@
 
 Replace N(42) by:
 
-View. A view consists of an identification of an entity (the entity of the
-view), plus view-specific characteristics that affect the use of the entity
-through that view (such as mode of access to an object, formal parameter names
-and defaults for a subprogram, or visibility to components of a type).
+View. A view of an entity reveals some or all of the properties of the
+entity. A single entity may have multiple views.
 
 !discussion
 
@@ -212,8 +231,9 @@
 International Standard. To find more formal definitions, look the term up in
 the index.
 @dby
-This Annex contains informal descriptions of some terms used in this
-International Standard. The index provides references to more formal definitions.
+This Annex contains informal descriptions of some of the terms used in this
+International Standard. The index provides references to more formal
+definitions of all of the terms used in this International Standard.
 
 @b<Abstract type.> An abstract type is a tagged type intended for use as
 an ancestor of other types, but which is not allowed to have objects of its own.
@@ -227,8 +247,9 @@
 attribute can be used to create an access value designating an aliased object.
 @dinst
 @b<Ancestor.> An ancestor of a type is the type itself or, in the case of a
-derived type, its parent type or one of its progenitor types or one of their
-ancestors.
+type derived from other types, its parent type or one of its progenitor types
+or one of their ancestors. Note that ancestor and descendant are inverse
+relationships.
 
 !corrigendum N(04)
 
@@ -241,6 +262,26 @@
 category of types that is closed under derivation is also known as
 a @i<class>.
 
+!corrigendum N(06)
+
+@drepl
+@b<Class.> A class is a set of types that is closed under derivation, which means
+that if a given type is in the class, then all types derived from that type are
+also in the class. The set of types of a class share common properties, such as
+their primitive operations.
+@dby
+@b<Class (of types).> A class is a set of types that is closed under
+derivation, which means that if a given type is in the class, then all types
+derived from that type are also in the class. The set of types of a class share
+common properties, such as their primitive operations.
+
+!corrigendum N(08)
+
+@drepl
+@b<Composite type.> A composite type has components.
+@dby
+@b<Composite type.> A composite type may have components.
+
 !corrigendum N(12)
 
 @ddel
@@ -263,17 +304,17 @@
 together with the types derived from it (directly or indirectly) form a
 derivation class.
 @dby
-@b<Derived type.> A derived type is a type defined in terms of one or more other
-types given in a derived type definition. The first type given is the parent
-type of the derived type and any others are
-progenitor types. Each class containing the parent type or a progenitor type
-also contains the derived type. The derived type inherits properties such as
-components and primitive operations from the parent and progenitors. A type
-together with the types derived from it (directly or indirectly) form a
-derivation class.
-
-@b<Descendant.> A descendant of a type is any type of which the given type is an
-ancestor type. Note that a type is a descendant of itself.
+@b<Derived type.> A derived type is a type defined in terms of one or more
+other types given in a derived type definition. The first of those types is the
+parent type of the derived type and any others are progenitor types. Each class
+containing the parent type or a progenitor type also contains the derived type.
+The derived type inherits properties such as components and primitive
+operations from the parent and progenitors. A type together with the types
+derived from it (directly or indirectly) form a derivation class.
+
+@b<Descendant.> A type is a descendant of itself, its parent and progenitor
+types, and their ancestors. Note that
+descendant and ancestor are inverse relationships.
 
 !corrigendum N(15)
 
@@ -283,9 +324,9 @@
 type is an array type. A discriminant of a task type can be used to pass
 data to a task of the type upon creation.
 @dby
-@b<Discriminant.> A discriminant is a parameter of a composite type. It can
+@b<Discriminant.> A discriminant is a parameter for a composite type. It can
 control, for example, the bounds of a component of the type if the component
-type is an array type. A discriminant of a task type can be used to pass
+is an array. A discriminant for a task type can be used to pass
 data to a task of the type upon creation.
 
 @b<Elaboration.> The process by which a declaration has its run-time effect
@@ -307,8 +348,8 @@
 called @i<execution>. Execution of a declaration is also
 called @i<elaboration>. Execution of an expression is also called @i<evaluation>.
 @dinst
-@b<Function.> A function is a form of subprogram that returns a result and is used
-as part of an expression.
+@b<Function.> A function is a form of subprogram that returns a result and
+can be called as part of an expression.
 
 !corrigendum N(20)
 
@@ -323,9 +364,9 @@
 generic. Generic units can be used to perform the role that macros sometimes
 play in other languages.
 @dinst
-@b<Incomplete type.> An incompete type gives a view of a type that reveals only
+@b<Incomplete type.> An incomplete type gives a view of a type that reveals only
 some of its properties. The remaining properties are provided by the full view
-given elsewhere. Incomplete types are valuable for defining recursive data
+given elsewhere. Incomplete types can be used for defining recursive data
 structures.
 
 !corrigendum N(21)
@@ -342,7 +383,7 @@
 no components or concrete operations except possibly null procedures. Interface
 types are used for composing other interfaces and tagged types and thereby
 provide multiple inheritance. Only an interface type can be used as a
-progenitor of a derived type.
+progenitor of another type.
 
 !corrigendum N(23)
 
@@ -351,9 +392,9 @@
 operation is not allowed. A nonlimited type is a (view of a) type for which the
 assignment operation is allowed.
 @dby
-@b<Limited type.> A limited type is (a view of) a type for which copying (such
+@b<Limited type.> A limited type is a type for which copying (such
 as for an @fa<assignment_statement>) is not allowed. A nonlimited type is a
-(view of a) type for which copying is allowed.
+type for which copying is allowed.
 
 !corrigendum N(24)
 
@@ -364,8 +405,8 @@
 an object is an object.
 @dinst
 @b<Overriding operation.> An overriding operation is one that replaces an
-inherited operation. Operations may be marked explicitly as overriding or not
-overriding.
+inherited primitive operation. Operations may be marked explicitly as
+overriding or not overriding.
 
 !corrigendum N(25)
 
@@ -376,8 +417,8 @@
 of primitive subprograms of the type, which can be called from outside the
 package, while their inner workings remain hidden from outside users.
 @dinst
-@b<Parent.> The parent type of a derived type is the first type mentioned in the
-definition of the derived type. The parent type can be almost any specific
+@b<Parent.> The parent of a derived type is the first type given in the
+definition of the derived type. The parent can be almost any kind of
 type, including an interface type.
 
 !corrigendum N(29)
@@ -398,15 +439,16 @@
 @dby
 @b<Private type.> A private type gives a view of a type that reveals only some
 of its properties. The remaining properties are provided by the full view given
-elsewhere. Private types are valuable for defining abstractions that hide
-unnecessary detail from a client.
+elsewhere. Private types can be used for defining abstractions that hide
+unnecessary details from a client.
 
 @b<Procedure.> A procedure is a form of subprogram that does not return a
-result and is called by a @fa<statement> standing alone.
+result and can only be called by a @fa<statement>.
 
-@b<Progenitor.> A progenitor type of a derived type is one of the types
-mentioned in the definition of the derived type other than the first. A
-progenitor type is always an interface type.
+@b<Progenitor.> A progenitor of a derived type is one of the types
+given in the definition of the derived type other than the first. A
+progenitor is always an interface type.
+Interfaces, tasks, and protected types may also have progenitors.
 
 !corrigendum N(33)
 
@@ -415,7 +457,8 @@
 protected from concurrent access by multiple tasks.
 @dby
 @b<Protected type.> A protected type is a composite type whose components are
-protected from being accessed concurrently by multiple tasks.
+accessible only through one of its protected operations which synchronize
+concurrent access by multiple tasks.
 
 !corrigendum N(36)
 
@@ -443,15 +486,26 @@
 the values of the subtype to satisfy a certain condition. The values of a
 subtype are a subset of the values of its type.
 @dby
-@b<Subtype.> A subtype is a type together with a constraint and/or null
+@b<Subtype.> A subtype is a type together with a constraint or null
 exclusion, which constrains the values of the subtype to satisfy a certain
 condition. The values of a subtype are a subset of the values of its type.
 
 @b<Synchronized.> A synchronized entity is one that will work
-safely with multiple tasks at one time. A synchronized interface can be used
-with either a task or a protected type, while a synchronized tagged type is any
-of a tagged task type, tagged protected type, or a synchronized interface.
+safely with multiple tasks at one time. A synchronized interface can be an
+ancestor of a task or a protected type. Such a task or protected type is
+called a synchronized tagged type.
+
+!corrigendum N(40)
 
+@drepl
+@b<Task type.> A task type is a composite type whose values are tasks, which
+are active entities that may execute concurrently with other tasks. The
+top-level task of a partition is called the environment task.
+@dby
+@b<Task type.> A task type is a composite type used to represent active
+entities which execute concurrently and which can communicate via queued task
+entries. The top-level task of a partition is called the environment task.
+
 !corrigendum N(41)
 
 @drepl
@@ -462,7 +516,7 @@
 are closed under derivation; that is, if a type is in a class, then all of its
 derivatives are in that class.
 @dby
-@b<Type.> Each object has a @i<type>. A type has an associated set of values,
+@b<Type.> Each object has a type. A @i<type> has an associated set of values,
 and a set of @i<primitive operations> which implement the fundamental aspects
 of its semantics. Types are grouped into @i<categories>. Most language-defined
 categories of types are also @i<classes> of types.
@@ -472,10 +526,8 @@
 @drepl
 @b<View.> (See @b<Definition>.)
 @dby
-@b<View.> A view consists of an identification of an entity (the entity of the
-view), plus view-specific characteristics that affect the use of the entity
-through that view (such as mode of access to an object, formal parameter names
-and defaults for a subprogram, or visibility to components of a type).
+@b<View.> A view of an entity reveals some or all of the properties of the
+entity. A single entity may have multiple views.
 
 !ACATS test
 
@@ -633,7 +685,7 @@
 "overloading" too. "Instance" (or "instantiation"), "completion", "library
 level", and "rendezvous" are also very common. "Aggregate", "allocator",
 "body", and "pragma" (Jeff missed that one) are important, too, but since they
-refer to syntax items, it seems a bit silly to put them in the Glossary/
+refer to syntax items, it seems a bit silly to put them in the Glossary.
 
 Jeff's last list seems redundant with things that are defined already.
 

Questions? Ask the ACAA Technical Agent