CVS difference for ai12s/ai12-0313-1.txt

Differences between 1.1 and version 1.2
Log of other versions for file ai12s/ai12-0313-1.txt

--- ai12s/ai12-0313-1.txt	2019/02/08 02:33:50	1.1
+++ ai12s/ai12-0313-1.txt	2019/02/23 03:17:25	1.2
@@ -1,4 +1,4 @@
-!standard 0.3(57.21/3)                                  19-02-07  AI12-0313-1/00
+!standard 0.3(57.21/3)                                  19-02-22  AI12-0313-1/01
 !class presentation 19-02-07
 !status work item 19-02-07
 !status received 19-02-07
@@ -14,48 +14,189 @@
 !question
 
 The Language Changes section in the Introduction is for Ada 2012. It needs
-to be replaced, right? (Hell Yes.)
+to be replaced, right? (Yes.)
 
-[Editor's note: Fix the non-standard response here before approving. :-)]
-
 Similarly, the Design Goals and Language Summary in the Introduction should 
-be updated, right?
+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 2020 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.  
 
-Delete Introduction (57.1/3-57.22/3).
+In Language Changes:
 
-Insert after Introduction (57.22/3):
+Replace the whole "Language Changes" section with the following:
 
-This International Standard replaces the third edition of 2012. It modifies 
+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. 
+language.  
 
-** Rest TBD.
+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 non-scalar 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 short-hand 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.
+
+  - 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):
 
-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)
+
+ * 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)
 
 
-** Rest TBD.
+!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
 

Questions? Ask the ACAA Technical Agent