!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)

@drepl
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.
@dby
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)

@drepl
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.
@dby
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)

@drepl
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).
@dby
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)

@dinsa
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.
@dinst
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)

@drepl
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.
@dby
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)

@drepl
Significant changes originating in Amendment 1 are incorporated:
@dby
Significant changes in this edition are:

!corrigendum 0.3(57.3/3)

@drepl
@xbullet<Support for program text is extended to cover the entire ISO/IEC 
10646:2003 repertoire. Execution support now includes the 32-bit character set. 
See subclauses 2.1, 3.5.2, 3.6.3, A.1, A.3, and A.4.>
@dby
@xbullet<Improved support for parallel execution is provided via the
introduction of parallel loops, parallel blocks, parallel container
iteration, and parallel reduction.>

!corrigendum 0.3(57.4/3)

@drepl
@xbullet<The object-oriented model has been improved by the addition of an 
interface facility which provides multiple inheritance and additional 
flexibility for type extensions. See subclauses 3.4, 3.9, and 7.3. An 
alternative notation for calling operations more akin to that used in other 
languages has also been added. See subclause 4.1.3.>
@dby
@xbullet<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.>

!corrigendum 0.3(57.5/3)

@drepl
@xbullet<Access types have been further extended to unify properties such as 
the ability to access constants and to exclude null values. See clause 3.10. 
Anonymous access types are now permitted more freely and anonymous 
access-to-subprogram types are introduced. See subclauses 3.3, 3.6, 3.10, and 
8.5.1.>
@dby
@xbullet<Pre and Post aspects may now be specified for access-to-subprogram
types and for generic formal subprograms; a postcondition for the default
initialization of a type may be specified using the new
Default_Initial_Condition aspect.>

!corrigendum 0.3(57.6/3)

@drepl
@xbullet<The control of structure and visibility has been enhanced to permit 
mutually dependent references between units and finer control over access from 
the private part of a package. See subclauses 3.10.1 and 10.1.2. In addition, 
limited types have been made more useful by the provision of aggregates, 
constants, and constructor functions. See subclauses 4.3, 6.5, and 7.5.>
@dby
@xbullet<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.>

!corrigendum 0.3(57.7/3)

@drepl
@xbullet<The predefined environment has been extended to include additional 
time and calendar operations, improved string handling, a comprehensive 
container library, file and directory management, and access to environment 
variables. See subclauses 9.6.1, A.4, A.16, A.17, and A.18.>
@dby
@xbullet<More flexible uses of static expressions are supported via the
introduction of static expression functions along with fewer
restrictions on static strings.>

!corrigendum 0.3(57.8/3)

@drepl
@xbullet<Two of the Specialized Needs Annexes have been considerably enhanced:>
@dby
@xbullet<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.>

!corrigendum 0.3(57.9/2)

@ddel
@xinbull<The Real-Time Systems Annex now includes the Ravenscar profile for 
high-integrity systems, further dispatching policies such as Round Robin and
earliest Deadline First, support for timing events, and support for control 
of CPU time utilization. See subclauses D.2, D.13, D.14, and D.15.>

!corrigendum 0.3(57.10/3)

@ddel
@xinbull<The Numerics Annex now includes support for real and complex vectors 
and matrices as previously defined in ISO/IEC 13813:1997 plus further basic 
operations for linear algebra. See subclause G.3.>

!corrigendum 0.3(57.11/3)

@drepl
@xbullet<The overall reliability of the language has been enhanced by a 
number of improvements. These include new syntax which detects accidental
overloading, as well as pragmas for making assertions and giving better 
control over the suppression of checks. See subclauses 6.1, 11.4.2, and 11.5.>
@dby
@xbullet<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.>

@xbullet<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.>

@xbullet<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.>
    
@xbullet<A shorthand is provided, using the token '@', to refer to the
target of an assignment statement in the expression defining its new value.>

@xbullet<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.>

@xbullet<Support for lightweight iteration is added via the introduction of
procedural iterators.>

@xbullet<Support for the map-reduce programming strategy is added via the
introduction of reduction expressions.>

@xbullet<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.>

@xbullet<Predefined packages supporting arbitrary-precision integer and real
arithmetic are provided.>

@xbullet<The Jorvik profile is introduced to support hard real-time
applications that need to go beyond the restrictions of the Ravenscar profile.>

!corrigendum 0.3(57.12/3)

@ddel
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)

@ddel
The following significant changes with respect to the 1995 edition as amended 
by Amendment 1 are incorporated:

!corrigendum 0.3(57.14/3)

@ddel
@xbullet<New syntax (the aspect specification) is introduced to enable 
properties to be specified for various entities in a more structured 
manner than through pragmas. See subclause 13.1.1.>

!corrigendum 0.3(57.15/4)

@ddel
@xbullet<The concept of assertions introduced in the 2005 edition is extended with the 
ability to specify preconditions and postconditions for subprograms, and 
invariants for private types and interfaces. The concept of constraints in
defining subtypes is supplemented with subtype predicates that enable 
subsets to be specified other than as simple ranges. These properties are 
all indicated using aspect specifications. See subclauses 3.2.4, 6.1.1, and 
7.3.2.>

!corrigendum 0.3(57.16/4)

@ddel
@xbullet<New forms of expressions are introduced. These are if expressions, case 
expressions, quantified expressions, and expression functions, and raise
expressions. As well as being useful for programming in general by avoiding 
the introduction of unnecessary assignments, they are especially valuable in 
conditions and invariants since they avoid the need to introduce auxiliary 
functions. See subclauses 4.5.7, 4.5.8, 6.8, and 11.3. Membership tests are
also made more flexible. See subclauses 4.4 and 4.5.2.>

!corrigendum 0.3(57.17/3)

@ddel
@xbullet<A number of changes are made to subprogram parameters. Functions may now have 
parameters of all modes. In order to mitigate consequent (and indeed existing)
problems of inadvertent order dependence, rules are introduced to reduce 
aliasing. A parameter may now be explicitly marked as aliased and the type of 
a parameter may be incomplete in certain circumstances. See subclauses 3.10.1,
6.1, and 6.4.1.>

!corrigendum 0.3(57.18/3)

@ddel
@xbullet<The use of access types is now more flexible. The rules for accessibility and 
certain conversions are improved. See subclauses 3.10.2, 4.5.2, 4.6, and 8.6. 
Furthermore, better control of storage pools is provided. See subclause 
13.11.4.>

!corrigendum 0.3(57.19/3)

@ddel
@xbullet<The Real-Time Systems Annex now includes facilities for defining domains of 
processors and assigning tasks to them. Improvements are made to scheduling 
and budgeting facilities. See subclauses D.10.1, D.14, and D.16.>

!corrigendum 0.3(57.20/3)

@ddel
@xbullet<A number of important improvements are made to the standard library. These 
include packages for conversions between strings and UTF encodings, and 
classification functions for wide and wide wide characters. 
Internationalization is catered for by a package giving locale information. 
See subclauses A.3, A.4.11, and A.19. The container library is extended to 
include bounded forms of the existing containers and new containers for 
indefinite objects, multiway trees, and queues. See subclause A.18.>

!corrigendum 0.3(57.21/3)

@ddel
@xbullet<Finally, certain features are added primarily to ease the use of containers, 
such as the ability to iterate over all elements in a container without 
having to encode the iteration. These can also be used for iteration over 
arrays, and within quantified expressions. See subclauses 4.1.5, 4.1.6, 5.5.1, 
and 5.5.2.>



!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.]

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