CVS difference for ais/ai-00437.txt

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

--- ais/ai-00437.txt	2005/10/18 06:22:10	1.1
+++ ais/ai-00437.txt	2005/10/31 05:16:38	1.2
@@ -1,17 +1,24 @@
 !standard N         (01)                               05-10-17  AI95-00437/01
 !standard N         (03)
+!standard N         (04)
 !standard N         (08)
 !standard N         (12)
 !standard N         (13)
 !standard N         (15)
+!standard N         (17)
+!standard N         (19)
 !standard N         (20)
 !standard N         (21)
 !standard N         (23)
 !standard N         (24)
 !standard N         (25)
+!standard N         (29)
 !standard N         (30)
+!standard N         (33)
 !standard N         (36)
+!standard N         (37)
 !standard N         (38)
+!standard N         (41)
 !standard N         (42)
 !class presentation 05-10-17
 !status Amendment 200Y 05-10-17
@@ -37,23 +44,38 @@
 
 !wording
 
+Replace N(1):
+
+This Annex contains informal descriptions of some terms used in this
+International Standard. The index provides references to more formal
+definitions.
+
+
 Add after N(1):
 
-Abstract type. An abstract type is a tagged type intended for use as ancestor
-of other types, but which it not allowed to have objects of its own.
+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.
 
 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.
 
+Add after N(4):
+
+Category (of types). A category of types is a set of types with
+one or more common properties, such as their primitive operations. A
+category of types that is closed under derivation is also known as
+a class.
+
+
 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, while any others are
+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
@@ -70,11 +92,25 @@
 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.
 
+Elaboration. The process by which a declaration has its run-time effect
+is called elaboration. Elaboration is one of the forms of execution.
+
+Add after N(17):
+
+Evaluation. The process by which an expression has its run-time effect
+is called evaluation. Evaluation is one of the forms of execution.
+
+Add after N(19):
+
+Function. A function is a form of subprogram that returns a result and is used
+as part of an expression.
+
 Add after N(20):
 
-Incomplete type. An incomplete type is a incomplete view of a type whose
-complete view is given elsewhere. Incomplete types are valuable for defining
-recursive data structures.
+Incomplete type. An incompete 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
+structures.
 
 Add after N(21):
 
@@ -92,31 +128,72 @@
 
 Add after N(24):
 
-Overriding operation. Overriding operation. An overriding operation is one that
-replaces an inherited operation. Operations may be marked explicitly as
-overriding or not overriding.
+Overriding operation. An overriding operation is one that replaces an inherited
+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 any type, including an
-interface type.
+definition of the derived type. The parent type can be almost any specific
+type, including an interface type.
+
+Replace N(29) by:
+
+Private extension. A private extension is a type that extends another type,
+with the additional properties hidden from its clients.
+
+Replace N(30) by:
 
-Add after N(30):
+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.
 
+Procedure. A procedure is a form of subprogram that does not return a result
+and is called by a statement standing alone.
+
 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.
 
+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]
+
 Add after N(36):
 
 Renaming. A renaming_declaration is a declaration that does not define a new
-entity, but instead defines a view of an existing entity (see 8.5).
+entity, but instead defines a view of an existing entity.
+
+Add after N(37):
 
-Add after N(38):
+Subprogram. A subprogram is a section of program that can be executed in
+various contexts. It is invoked by a subprogram call that may qualify the
+effect of the subprogram through the passing of parameters. There are two forms
+of subprograms; functions, which return values, and procedures, which do not.
 
-Synchronized type. A synchronized type is a task type or a protected type.
+Replace N(38) by:
 
+Subtype. A subtype is a type together with a constraint and/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.
+
+Replace N(41) by:
+
+Type. Each object has a type. A type has an associated set of values, and a set
+of primitive operations which implement the fundamental aspects of its
+semantics. Types are grouped into categories. Most categories of types form
+classes of types.
+
 Replace N(42) by:
 
 View. A view consists of an identification of an entity (the entity of the
@@ -130,13 +207,16 @@
 
 !corrigendum N(01)
 
-@dinsa
+@drepl
 This Annex contains informal descriptions of some terms used in this
 International Standard. To find more formal definitions, look the term up in
 the index.
-@dinst
+@dby
+This Annex contains informal descriptions of some terms used in this
+International Standard. The index provides references to more formal definitions.
+
 @b<Abstract type.> An abstract type is a tagged type intended for use as
-ancestor of other types, but which it not allowed to have objects of its own.
+an ancestor of other types, but which is not allowed to have objects of its own.
 
 !corrigendum N(03)
 
@@ -150,6 +230,17 @@
 derived type, its parent type or one of its progenitor types or one of their
 ancestors.
 
+!corrigendum N(04)
+
+@dinsa
+@b<Array type.> An array type is a composite type whose components are all of
+the same type. Components are selected by indexing.
+@dinst
+@b<Category (of types).> A category of types is a set of types with
+one or more common properties, such as their primitive operations. A
+category of types that is closed under derivation is also known as
+a @i<class>.
+
 !corrigendum N(12)
 
 @ddel
@@ -174,7 +265,7 @@
 @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, while any others are
+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
@@ -197,6 +288,28 @@
 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.
 
+@b<Elaboration.> The process by which a declaration has its run-time effect
+is called elaboration. Elaboration is one of the forms of execution.
+
+!corrigendum N(17)
+
+@dinsa
+@b<Enumeration type.> An enumeration type is defined by an enumeration of its
+values, which may be named by identifiers or character literals.
+@dinst
+@b<Evaluation.> The process by which an expression has its run-time effect
+is called evaluation. Evaluation is one of the forms of execution.
+
+!corrigendum N(19)
+
+@dinsa
+@b<Execution.> The process by which a construct achieves its run-time effect is
+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.
+
 !corrigendum N(20)
 
 @dinsa
@@ -210,9 +323,10 @@
 generic. Generic units can be used to perform the role that macros sometimes
 play in other languages.
 @dinst
-@b<Incomplete type.> An incomplete type is a incomplete view of a type whose
-complete view is given elsewhere. Incomplete types are valuable for defining
-recursive data structures.
+@b<Incomplete type.> An incompete 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
+structures.
 
 !corrigendum N(21)
 
@@ -249,9 +363,9 @@
 @fa<allocator>. A formal parameter is (a view of) an object. A subcomponent of
 an object is an object.
 @dinst
-@b<Overriding operation.> Overriding operation. An overriding operation is one
-that replaces an inherited operation. Operations may be marked explicitly as
-overriding or not overriding.
+@b<Overriding operation.> An overriding operation is one that replaces an
+inherited operation. Operations may be marked explicitly as overriding or not
+overriding.
 
 !corrigendum N(25)
 
@@ -263,19 +377,46 @@
 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 any type, including an
-interface type.
+definition of the derived type. The parent type can be almost any specific
+type, including an interface type.
+
+!corrigendum N(29)
 
+@drepl
+@b<Private extension.> A private extension is like a record extension, except
+that the components of the extension part are hidden from its clients.
+@dby
+@b<Private extension.> A private extension is a type that extends another type,
+with the additional properties hidden from its clients.
+
+
 !corrigendum N(30)
 
-@dinsa
+@drepl
 @b<Private type.> A private type is a partial view of a type whose full view is
 hidden from its clients.
-@dinst
+@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.
+
+@b<Procedure.> A procedure is a form of subprogram that does not return a
+result and is called by a @fa<statement> standing alone.
+
 @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.
 
+!corrigendum N(33)
+
+@drepl
+@b<Protected type.> A protected type is a composite type whose components are
+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.
+
 !corrigendum N(36)
 
 @dinsa
@@ -283,17 +424,49 @@
 named components, possibly of different types.
 @dinst
 @b<Renaming.> A @fa<renaming_declaration> is a declaration that does not define
-a new entity, but instead defines a view of an existing entity (see 8.5).
+a new entity, but instead defines a view of an existing entity.
 
-!corrigendum N(38)
+!corrigendum N(37)
 
 @dinsa
+@b<Scalar type.> A scalar type is either a discrete type or a real type.
+@dinst
+@b<Subprogram.> A subprogram is a section of program that can be executed in
+various contexts. It is invoked by a subprogram call that may qualify the
+effect of the subprogram through the passing of parameters. There are two forms
+of subprograms; functions, which return values, and procedures, which do not.
+
+!corrigendum N(38)
+
+@drepl
 @b<Subtype.> A subtype is a type together with a constraint, 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.
-@dinst
-@b<Synchronized type.> A synchronized type is a task type or a protected type.
+@dby
+@b<Subtype.> A subtype is a type together with a constraint and/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.
+
+!corrigendum N(41)
 
+@drepl
+@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<classes>. The types of a given
+class share a set of primitive operations. {closed under derivation} Classes
+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,
+and a set of @i<primitive operations> which implement the fundamental aspects
+of its semantics. Types are grouped into @i<categories>. Most categories of
+types form @i<classes> of types.
+
 !corrigendum N(42)
 
 @drepl
@@ -310,4 +483,159 @@
 
 !appendix
 
+From: John Barnes
+Sent: Thursday, October 27, 2005  1:44 PM
+
+We had a BSI meeting last week and one topic discussed was terminology (this
+arose because I explained that we were nearly done and working on the
+glossary).
+
+It seems that Ada has a rather short list of terms defined compared with
+some languages and Jeff Cousins was actioned to suggest what might be
+misssing.
+
+His lists are below. It is indeed odd that the glossary doesn't
+define subprogram, procedure and function. I cannot get excited about many
+others.
+
+----- Original Message -----
+From: "Cousins, Jeff"
+
+>
+> Hello.  I was asked at the recent panel meeting to suggest some more items
+> for the glossary, as the "ad hoc" on terminlogy has shown the Ada standard
+> to be rather thin on definitions compared with some other ISO language
+> standards.
+>
+> Fairly basic terms, but defined for some other languages, sometimes
+> differently from how Ada uses them:
+>
+> actual parameter
+> file
+> formal parameter
+> function
+> in parameter
+> out parameter
+> in out parameter
+> (It's interesting that documentation of the Win32 interface on Microsoft's
+> MSDN site annotates the parameters with [in] and [out], making the C look
+> like Ada).
+> parameter
+> procedure
+> subprogram
+>
+>
+> More Ada-specific terms.  An even longer list could be produced by trawling
+> through the index, this was obtained partly by looking at the definitions
+> for other languages to see the kind thing that they bothered to define, and
+> partly by looking at a sample of AIs for well-used terms.  I was surprised
+> to find that several terms frequently used in the AIs don't even appear in
+> the index, never mind the glossary:
+>
+> abstract subprogram
+> abstract type
+> access discriminant
+> accessibility level
+> access parameter
+> access valaue
+> aggregate
+> allocator
+> block (statement)
+> body
+> child package
+> child unit
+> completion
+> declarative part
+> dispatching operation
+> elaboration
+> entry
+> freezing
+> incomplete (type, view)
+> instance
+> interface
+> library level
+> named association
+> overload
+> override
+> positional association
+> primitive routine
+> private part
+> protected action
+> rendezvous
+> scope
+> spec
+> storage element
+> stream
+> task entry
+> variant record
+> variant part
+> view conversion
+>
+>
+> Terms which are un-defined though can be inferred easily enough from other
+> definitions, mostly compounds of terms that are defined, or instances of
+> types that are defined:
+>
+> access-to-object
+> access-to-subprogram
+> anonymous ...
+> array
+> discriminated type
+> generic body
+> generic formal type
+> generic parameter
+> generic spec
+> generic subprogram
+> record
+> tag
+> task
+
 ****************************************************************
+
+From: Randy Brukardt
+Sent: Thursday, October 27, 2005  1:44 PM
+
+> We had a BSI meeting last week and one topic discussed was terminology (this
+> arose because I explained that we were nearly done and working on the
+> glossary).
+>
+> It seems that Ada has a rather short list of terms defined compared with
+> some languages and Jeff Cousins was actioned to suggest what might be
+> misssing.
+
+That's a misinterpretation. The Glossary is an informal guide to terminology;
+the actual definitions are buried in the text of the Standard.
+
+Ada has many, many terms defined. But it doesn't have a definitions section.
+
+> His lists are below. It is indeed odd that the glossary doesn't
+> define subprogram, procedure and function. I cannot get excited about many
+> others.
+
+I suspect that terms with "obvious" definitions were left out. It's the same
+reason that we dropped "definition" from the Glossary -- it has a meaning very
+close to the English one, so why bother?
+
+I agree that "subprogram", "function", and "procedure" probably ought to be
+defined, because we don't use them quite like other languages.
+
+I think that "actual (parameter)" and "formal (parameter)" might make sense,
+too. These have fairly technical descriptions.
+
+I've been wondering if "category (of types)" needs an entry, too - it's broader
+than a class. (This is a new term, see 3.2(2) and 3.4(1)).
+
+Jeff's second list has a few things that really need to be here too:
+"elaboration" (what the heck is that?? :-), "child unit", "freezing" come to
+mind. Possibly "private part" and "visible part", too. We're *always* talking
+about these, they're not obvious, and this is the place for such things. Now
+that we have "overriding", perhaps we should have the counterpoint
+"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/
+
+Jeff's last list seems redundant with things that are defined already.
+
+****************************************************************
+

Questions? Ask the ACAA Technical Agent