!standard 0.3(57.21/3)                                  19-04-09  AI12-0313-1/03
!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, 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 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 support
    other sorts of types, via the new Integer_Literal, Real_Literal, and
    String_Literal aspects.

  - 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 which 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.

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

!ASIS

None needed.

!ACATS test

No ACATS tests needed.

!appendix

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