Version 1.2 of ais/ai-00437.txt
!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
!comment This AI is not yet approved, but is included in the Amendment.
!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 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 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 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.
Replace N(15) by:
Discriminant. A discriminant is a parameter of 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
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 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):
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 a derived 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)
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.
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
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 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.
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 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
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).
!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 terms used in this
International Standard. The index provides references to more formal definitions.
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
derived type, its parent type or one of its progenitor types or one of their
ancestors.
!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 their primitive operations. A
category of types that is closed under derivation is also known as
a class.
!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 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.
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.
!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 of 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
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 is used
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 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)
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 a derived 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 view of) a type for which copying (such
as for an assignment_statement) is not allowed. A nonlimited type is a
(view of 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 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 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
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 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.
!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
protected from being accessed concurrently 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 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. 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)
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 categories of
types form classes of types.
!corrigendum N(42)
Replace the paragraph:
View. (See Definition.)
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).
!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