Version 1.7 of ai12s/ai12-0313-1.txt

Unformatted version of ai12s/ai12-0313-1.txt version 1.7
Other versions for file ai12s/ai12-0313-1.txt

!standard 0.3(6/3)          21-03-08 AI12-0313-1/06
!standard 0.3(10)
!standard 0.3(31)
!standard 0.3(41/2)
!standard 0.3(57.1/3)
!standard 0.3(57.2/3)
!standard 0.3(57.3/3)
!standard 0.3(57.4/3)
!standard 0.3(57.5/3)
!standard 0.3(57.6/3)
!standard 0.3(57.7/3)
!standard 0.3(57.8/3)
!standard 0.3(57.9/3)
!standard 0.3(57.10/3)
!standard 0.3(57.11/3)
!standard 0.3(57.13/3)
!standard 0.3(57.14/3)
!standard 0.3(57.15/4)
!standard 0.3(57.16/4)
!standard 0.3(57.17/3)
!standard 0.3(57.18/3)
!standard 0.3(57.19/3)
!standard 0.3(57.20/3)
!standard 0.3(57.21/3)
!class presentation 19-02-07
!status Amendment 1-2012 19-04-09
!status ARG Approved 11-0-0 19-04-09
!status work item 19-02-07
!status received 19-02-07
!priority Low
!difficulty Easy
!subject Introduction for Ada 2020
!summary
A Language Changes section for Ada 2020 is added, and the Design Goals and Language Summary are updated for Ada 2020.
!question
The Language Changes section in the Introduction is for Ada 2012. It needs to be replaced, right? (Yes.)
Similarly, the Design Goals and Language Summary in the Introduction should be updated, right? (Yes.)
!response
(See Summary.)
!wording
In Design Goals:
Modify paragraph Intro(6/3):
Ada was originally designed with three overriding concerns: program reliability and maintenance, programming as a human activity, and efficiency. The 1995 revision to the language was designed to provide greater flexibility and extensibility, additional control over storage management and synchronization, and standardized packages oriented toward supporting important application areas, while at the same time retaining the original emphasis on reliability, maintainability, and efficiency. [This third edition provides] {Subsequent editions, including this fourth edition, have provided} further flexibility and add[s]{ed} more standardized packages within the framework provided by the 1995 revision.
Modify paragraph Intro(10):
No language can avoid the problem of efficiency. Languages that require over-elaborate compilers, or that lead to the inefficient use of storage or execution time, force these inefficiencies on all machines and on all programs. Every construct of the language was examined in the light of present implementation techniques. Any proposed construct whose implementation was unclear or that required excessive machine resources was rejected. {Parallel constructs were introduced to simplify making safe and efficient use of modern multicore architectures.}
In Language Summary, Data Types:
Modify Intro(31):
Every object in the language has a type, which characterizes a set of values and a set of applicable operations. The main {categories}[classes] of types are elementary types (comprising enumeration, numeric, and access types) and composite types (including array and record types).
In Language Summary, Other Facilities:
Add after paragraph Intro(41/2):
Aspect clauses can also be used to specify more abstract properties of program entities, such as the pre- and postconditions of a subprogram, or the invariant for a private type. Additional aspects are specifiable to allow user-defined types to use constructs of the language, such as literals, aggregates, or indexing, normally reserved for particular language-defined categories of types, such as numeric types, record types, or array types.
In Language Changes:
Replace the whole "Language Changes" section with the following:
This International Standard replaces the third edition of 2012. It modifies the previous edition by making changes and additions that improve the capability of the language and the reliability of programs written in the language.
Significant changes in this edition are:
- Improved support for parallel execution is provided via the
introduction of parallel loops, parallel blocks, parallel container iteration, and parallel reduction.
- More precise specification of subprogram interfaces is supported via
the new aspects Global, Global'Class, and Nonblocking. The Global aspects, in particular, help to determine whether two constructs can safely execute in parallel.
- Pre and Post aspects may now be specified for access-to-subprogram
types and for generic formal subprograms; a postcondition for a type's default initialization may be specified using the new Default_Initial_Condition aspect.
- The behavior of many predefined container operations is now more
precisely specified by using pre- and postcondition specifications instead of English descriptions; a restricted ("stable") view for most containers is introduced to support more efficient iteration.
- More flexible uses of static expressions are supported via the
introduction of static expression functions along with fewer restrictions on static strings.
- The Image attribute is supported for nonscalar types, and a
user-specifiable attribute Put_Image is provided, which determines the value of the Image attribute for a user-defined type.
- The use of numeric and string literals is generalized to allow their use
with other categories of types, via the new aspects Integer_Literal, Real_Literal, and String_Literal.
- Array and record aggregates are made more flexible: index parameters
are allowed in an array aggregate to define the components as a function of their array index; discriminants can be defined more flexibly within an aggregate for a variant record type.
- New types of aggregates are provided: delta aggregates to allow
the construction of a new object by incremental updates to an existing object; container aggregates to allow construction of an object of a container type by directly specifying its elements.
- A shorthand is provided, using the token '@', to refer to the
target of an assignment statement in the expression defining its new value.
- "Declare" expressions are provided that permit the definition and
use of local constants or renamings, to allow a large expression to be simplified by defining common parts as named entities.
- Support for lightweight iteration is added via the introduction of
procedural iterators.
- Support for the map-reduce programming strategy is added via the
introduction of reduction expressions.
- For constructs that use iterators of any sort, a filter may be specified
that restricts the elements produced by the iteration to those that satisfy the condition of the filter.
- Predefined packages supporting arbitrary-precision integer and real
arithmetic are provided.
- The Jorvik profile is introduced to support hard real-time
applications that need to go beyond the restrictions of the Ravenscar profile.
!discussion
Areas that probably ought to be covered (some things are in multiple categories):
* Parallel constructs (loops, blocks, reductions)
* Improved aggregates (delta aggregates, container aggregates, iterators in aggregates)
* Increased abstraction (user-defined literals, user-defined image, static expression functions, reductions)
* Additional contracts (default-initial-condition, nonblocking, global, stable-properties)
* Additional static error detection (conflict check policies, nonblocking, global)
* Additional expressiveness for expressions (declare expression, reductions)
* Improved readability (target symbol, null/single element aggregate notation [brackets!], simplified object renames)
* Real-time improvements (aspect Yield, new EDF, queue length control, profile Yorvik)
* other (object_size, Enum_Rep/Enum_Val)
!corrigendum 0.3(6/3)
Replace the paragraph:
Ada was originally designed with three overriding concerns: program reliability and maintenance, programming as a human activity, and efficiency. The 1995 revision to the language was designed to provide greater flexibility and extensibility, additional control over storage management and synchronization, and standardized packages oriented toward supporting important application areas, while at the same time retaining the original emphasis on reliability, maintainability, and efficiency. This third edition provides further flexibility and adds more standardized packages within the framework provided by the 1995 revision.
by:
Ada was originally designed with three overriding concerns: program reliability and maintenance, programming as a human activity, and efficiency. The 1995 revision to the language was designed to provide greater flexibility and extensibility, additional control over storage management and synchronization, and standardized packages oriented toward supporting important application areas, while at the same time retaining the original emphasis on reliability, maintainability, and efficiency. Subsequent editions, including this fourth edition, have provided further flexibility and added more standardized packages within the framework provided by the 1995 revision.
!corrigendum 0.3(10)
Replace the paragraph:
No language can avoid the problem of efficiency. Languages that require over-elaborate compilers, or that lead to the inefficient use of storage or execution time, force these inefficiencies on all machines and on all programs. Every construct of the language was examined in the light of present implementation techniques. Any proposed construct whose implementation was unclear or that required excessive machine resources was rejected.
by:
No language can avoid the problem of efficiency. Languages that require over-elaborate compilers, or that lead to the inefficient use of storage or execution time, force these inefficiencies on all machines and on all programs. Every construct of the language was examined in the light of present implementation techniques. Any proposed construct whose implementation was unclear or that required excessive machine resources was rejected. Parallel constructs were introduced to simplify making safe and efficient use of modern multicore architectures.
!corrigendum 0.3(31)
Replace the paragraph:
Every object in the language has a type, which characterizes a set of values and a set of applicable operations. The main classes of types are elementary types (comprising enumeration, numeric, and access types) and composite types (including array and record types).
by:
Every object in the language has a type, which characterizes a set of values and a set of applicable operations. The main categories of types are elementary types (comprising enumeration, numeric, and access types) and composite types (including array and record types).
!corrigendum 0.3(41/2)
Insert after the paragraph:
Aspect clauses can be used to specify the mapping between types and features of an underlying machine. For example, the user can specify that objects of a given type must be represented with a given number of bits, or that the components of a record are to be represented using a given storage layout. Other features allow the controlled use of low level, nonportable, or implementation-dependent aspects, including the direct insertion of machine code.
the new paragraph:
Aspect clauses can also be used to specify more abstract properties of program entities, such as the pre- and postconditions of a subprogram, or the invariant for a private type. Additional aspects are specifiable to allow user-defined types to use constructs of the language, such as literals, aggregates, or indexing, normally reserved for particular language-defined categories of types, such as numeric types, record types, or array types.
!corrigendum 0.3(57.1/3)
Replace the paragraph:
This International Standard replaces the second edition of 1995. It modifies the previous edition by making changes and additions that improve the capability of the language and the reliability of programs written in the language. This edition incorporates the changes from Amendment 1 (ISO/IEC 8652:1995:AMD 1:2007), which were designed to improve the portability of programs, interfacing to other languages, and both the object-oriented and real-time capabilities.
by:
This Ada Reference Manual replaces the edition of 2012. It modifies the previous edition by making changes and additions that improve the capability of the language and the reliability of programs written in the language.
!corrigendum 0.3(57.2/3)
Replace the paragraph:
Significant changes originating in Amendment 1 are incorporated:
by:
Significant changes in this edition are:
!corrigendum 0.3(57.3/3)
Replace the paragraph:
by:
!corrigendum 0.3(57.4/3)
Replace the paragraph:
by:
!corrigendum 0.3(57.5/3)
Replace the paragraph:
by:
!corrigendum 0.3(57.6/3)
Replace the paragraph:
by:
!corrigendum 0.3(57.7/3)
Replace the paragraph:
by:
!corrigendum 0.3(57.8/3)
Replace the paragraph:
by:
!corrigendum 0.3(57.9/2)
Delete the paragraph:
!corrigendum 0.3(57.10/3)
Delete the paragraph:
!corrigendum 0.3(57.11/3)
Replace the paragraph:
by:
!corrigendum 0.3(57.12/3)
Delete the paragraph:
In addition, this third edition makes enhancements to address two important issues, namely, the particular problems of multiprocessor architectures, and the need to further increase the capabilities regarding assertions for correctness. It also makes additional changes and additions that improve the capability of the language and the reliability of programs written in the language.
!corrigendum 0.3(57.13/3)
Delete the paragraph:
The following significant changes with respect to the 1995 edition as amended by Amendment 1 are incorporated:
!corrigendum 0.3(57.14/3)
Delete the paragraph:
!corrigendum 0.3(57.15/4)
Delete the paragraph:
!corrigendum 0.3(57.16/4)
Delete the paragraph:
!corrigendum 0.3(57.17/3)
Delete the paragraph:
!corrigendum 0.3(57.18/3)
Delete the paragraph:
!corrigendum 0.3(57.19/3)
Delete the paragraph:
!corrigendum 0.3(57.20/3)
Delete the paragraph:
!corrigendum 0.3(57.21/3)
Delete the paragraph:
!ASIS
None needed.
!ACATS test
No ACATS tests needed.
!appendix

[From Gary Dismukes' RM review (October 2020). These both have been treated as 
Editorial Review changes to this AI - Editor.]

57.11/5  The use of numeric and string literals is generalized to [support] 
{allow their use with} other sorts of types, via the new {aspects} 
Integer_Literal, Real_Literal, and String_Literal[ aspects].


57.15/5  Declare expressions are provided [which] {that} permit the definition 
and use of local constants or renamings, to allow an expression used within an 
aspect specification to be more concise and readable.

****************************************************************

From an informal review of the Introduction by John Barnes, March 7, 2021.

31   says “classes of types”. Maybe change that to categories of types. Not to 
be confused with the technical term classes. I changed my book to say 
categories in 2005

57.6/5   a stable view seems a bit technical. Sounds horsey. Maybe
just say a view of  or ???

57.11/5                “sorts of types” maybe categories 

57.15/5                not only in aspect specifications.
 But could just say ". to allow an expression to be both more concise 
and readable"

[These changes were made as editorial review fixes to this AI. - Editor.]

****************************************************************

Questions? Ask the ACAA Technical Agent