Version 1.4 of ais/ai-00437.txt

Unformatted version of ais/ai-00437.txt version 1.4
Other versions for file ais/ai-00437.txt

!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)
!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 (40)
!standard N (41)
!standard N (42)
!class presentation 05-10-17
!status Amendment 200Y 05-10-17
!status ARG Approved 10-0-1 05-11-19
!status work item 05-10-17
!status received 05-10-17
!priority High
!difficulty Easy
!subject Glossary updates for the Amendment
!summary
The Glossary is updated to add various new terms, and to improve the wording of others.
!question
Many of the definitions in the Glossary need updates for the Amendment.
!recommendation
(See summary.)
!wording
Replace N(1):
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.
Add after N(1):
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 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):
Category (of types). A category of types is a set of types with one or more common properties, such as primitive operations. A 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 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 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 for a composite type. It can control, for example, the bounds of a component of the type if the component 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 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 can be called as part of an expression.
Add after N(20):
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 can be used for defining recursive data structures.
Add after N(21):
Interface type. An interface type is a form of abstract tagged type which has 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 another type.
Replace N(23) by:
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 primitive operation. Operations may be marked explicitly as overriding or not overriding.
Add after N(25):
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:
Private extension. A private extension is a type that extends another type, with the additional properties hidden from its clients.
Replace N(30) by:
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 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 can only be called by a statement.
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 accessible only through one of its protected operations which synchronize concurrent access by multiple tasks.
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.
Add after N(37):
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.
Replace N(38) by:
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 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:
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 language-defined categories of types are also classes of types.
Replace N(42) by:
View. A view of an entity reveals some or all of the properties of the entity. A single entity may have multiple views.
!discussion
(See summary.)
!corrigendum N(01)
Replace the paragraph:
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.
by:
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.
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.
!corrigendum N(03)
Insert after the paragraph:
Aliased.
An aliased view of an object is one that can be designated by an access value. Objects allocated by allocators are aliased. Objects can also be explicitly declared as aliased with the reserved word aliased. The Access attribute can be used to create an access value designating an aliased object.
the new paragraph:
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.
!corrigendum N(04)
Insert after the paragraph:
Array type.
An array type is a composite type whose components are all of the same type. Components are selected by indexing.
the new paragraph:
Category (of types).
A category of types is a set of types with one or more common properties, such as primitive operations. A category of types that is closed under derivation is also known as a class.
!corrigendum N(06)
Replace the paragraph:
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.
by:
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)
Replace the paragraph:
Composite type.
A composite type has components.
by:
Composite type.
A composite type may have components.
!corrigendum N(12)
Delete the paragraph:
Definition.
All declarations contain a definition for a view of an entity. A view consists of an identification of the 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). In most cases, a declaration also contains the definition for the entity itself (a renaming_declaration is an example of a declaration that does not define a new entity, but instead defines a view of an existing entity (see 8.5)).
!corrigendum N(13)
Replace the paragraph:
Derived type.
A derived type is a type defined in terms of another type, which is the parent type of the derived type. Each class containing the parent type also contains the derived type. The derived type inherits properties such as components and primitive operations from the parent. A type together with the types derived from it (directly or indirectly) form a derivation class.
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 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 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)
Replace the paragraph:
Discriminant.
A discriminant is a parameter of a composite type. It can control, for example, the bounds of a component of the type if that 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.
by:
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 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 is called elaboration. Elaboration is one of the forms of execution.
!corrigendum N(17)
Insert after the paragraph:
Enumeration type.
An enumeration type is defined by an enumeration of its values, which may be named by identifiers or character literals.
the new paragraph:
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)
Insert after the paragraph:
Execution.
The process by which a construct achieves its run-time effect is called execution. Execution of a declaration is also called elaboration. Execution of an expression is also called evaluation.
the new paragraph:
Function.
A function is a form of subprogram that returns a result and can be called as part of an expression.
!corrigendum N(20)
Insert after the paragraph:
Generic unit.
A generic unit is a template for a (nongeneric) program unit; the template can be parameterized by objects, types, subprograms, and packages. An instance of a generic unit is created by a generic_instantiation. The rules of the language are enforced when a generic unit is compiled, using a generic contract model; additional checks are performed upon instantiation to verify the contract is met. That is, the declaration of a generic unit represents a contract between the body of the generic and instances of the generic. Generic units can be used to perform the role that macros sometimes play in other languages.
the new paragraph:
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 can be used for defining recursive data structures.
!corrigendum N(21)
Insert after the paragraph:
Integer type.
Integer types comprise the signed integer types and the modular types. A signed integer type has a base range that includes both positive and negative numbers, and has operations that may raise an exception when the result is outside the base range. A modular type has a base range whose lower bound is zero, and has operations with "wraparound" semantics. Modular types subsume what are called "unsigned types" in some other languages.
the new paragraph:
Interface type.
An interface type is a form of abstract tagged type which has 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 another type.
!corrigendum N(23)
Replace the paragraph:
Limited type.
A limited type is (a view of) a type for the assignment operation is not allowed. A nonlimited type is a (view of a) type for which the assignment operation is allowed.
by:
Limited type.
A limited type is a type for which copying (such as for an assignment_statement) is not allowed. A nonlimited type is a type for which copying is allowed.
!corrigendum N(24)
Insert after the paragraph:
Object.
An object is either a constant or a variable. An object contains a value. An object is created by an object_declaration or by an allocator. A formal parameter is (a view of) an object. A subcomponent of an object is an object.
the new paragraph:
Overriding operation.
An overriding operation is one that replaces an inherited primitive operation. Operations may be marked explicitly as overriding or not overriding.
!corrigendum N(25)
Insert after the paragraph:
Package.
Packages are program units that allow the specification of groups of logically related entities. Typically, a package contains the declaration of a type (often a private type or private extension) along with the declarations of primitive subprograms of the type, which can be called from outside the package, while their inner workings remain hidden from outside users.
the new paragraph:
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)
Replace the paragraph:
Private extension.
A private extension is like a record extension, except that the components of the extension part are hidden from its clients.
by:
Private extension.
A private extension is a type that extends another type, with the additional properties hidden from its clients.
!corrigendum N(30)
Replace the paragraph:
Private type.
A private type is a partial view of a type whose full view is hidden from its clients.
by:
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 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 can only be called by a statement.
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)
Replace the paragraph:
Protected type.
A protected type is a composite type whose components are protected from concurrent access by multiple tasks.
by:
Protected type.
A protected type is a composite type whose components are accessible only through one of its protected operations which synchronize concurrent access by multiple tasks.
!corrigendum N(36)
Insert after the paragraph:
Record type.
A record type is a composite type consisting of zero or more named components, possibly of different types.
the new paragraph:
Renaming.
A renaming_declaration is a declaration that does not define a new entity, but instead defines a view of an existing entity.
!corrigendum N(37)
Insert after the paragraph:
Scalar type.
A scalar type is either a discrete type or a real type.
the new paragraph:
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)
Replace the paragraph:
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.
by:
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.
A synchronized entity is one that will work 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)
Replace the paragraph:
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.
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.
!corrigendum N(41)
Replace the paragraph:
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 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.
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 language-defined categories of types are also classes of types.
!corrigendum N(42)
Replace the paragraph:
View.
(See Definition.)
by:
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
None needed.
!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