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

--- ai12s/ai12-0111-1.txt	2020/12/04 07:59:28	1.23
+++ ai12s/ai12-0111-1.txt	2021/05/30 00:35:09	1.24
@@ -1,4 +1,4 @@
-!standard 5.5.1(8/3)                              19-02-18  AI12-0111-1/11
+!standard 5.5.1(8/3)                              21-05-28  AI12-0111-1/12
 !standard 5.5.1(9/3)  
 !standard 5.5.1(10/3)  
 !standard 5.5.2(12/3) 
@@ -31,9 +31,9 @@
 !summary
 
 Add a nested package Stable within each Container package, which
-provides a *stabilized view* of an underlying regular (unstable) container.
+provides a *stabilized view* of an underlying ordinary (unstable) container.
 Such stable containers have no operations that change their shape, and
-the stabilization "lock" on the underlying regular container need only
+the stabilization "lock" on the underlying ordinary container need only
 be set once when the view is created, and released when the view goes
 away.
 
@@ -250,7 +250,7 @@
    provides a type Stable.Vector that represents
    a /stable/ vector, which is one that cannot grow and shrink. Such a
    vector can be created by calling the To_Vector or Copy functions, or
-   by establishing a /stabilized view/ of a regular Vector.
+   by establishing a /stabilized view/ of an ordinary Vector.
 
    The subprograms of package Containers.Vectors that have a parameter 
    or result of type Vector are included in the nested package Stable 
@@ -267,17 +267,17 @@
      view since no such operations are included. Thus tampering checks are
      not needed for a stable view.
 
-   The operations of this package are equivalent to those for regular
+   The operations of this package are equivalent to those for ordinary
    Vectors, except that no tampering checks are performed on stable 
    Vectors. If a stable
    vector is declared with the Base discriminant designating a
-   pre-existing regular vector, the stable vector represents a
-   stabilized view of the underlying regular vector, and any operation
-   on the stable vector is reflected on the underlying regular vector.
+   pre-existing ordinary vector, the stable vector represents a
+   stabilized view of the underlying ordinary vector, and any operation
+   on the stable vector is reflected on the underlying ordinary vector.
    While a stabilized view exists, any operation that tampers with
    elements performed on the underlying vector is prohibited. The
    finalization of a stable vector that provides such a view removes
-   this restriction on the underlying regular vector Redundant[(though
+   this restriction on the underlying ordinary vector Redundant[(though
    some other restriction might exist due to other concurrent iterations
    or stabilized views)].
 
@@ -373,7 +373,7 @@
    provides a type Stable.List that represents
    a /stable/ list, which is one that cannot grow and shrink. Such a
    list can be created by calling the Copy functions, or
-   by establishing a /stabilized view/ of a regular List.
+   by establishing a /stabilized view/ of an ordinary List.
 
    The subprograms of package Containers.Doubly_Linked_Lists that have a 
    parameter or result of type List are included in the nested package Stable 
@@ -390,17 +390,17 @@
      not needed for a stable view. For this reason, the Generic_Sorting
      generic is omitted completely.
 
-   The operations of this package are equivalent to those for regular
+   The operations of this package are equivalent to those for ordinary
    Doubly_Linked_Lists, except that no tampering checks are performed 
    on stable lists.
    If a stable list is declared with the Base discriminant designating a
-   pre-existing regular list, the stable list represents a
-   stabilized view of the underlying regular list, and any operation
-   on the stable list is reflected on the underlying regular list.
+   pre-existing ordinary list, the stable list represents a
+   stabilized view of the underlying ordinary list, and any operation
+   on the stable list is reflected on the underlying ordinary list.
    While a stabilized view exists, any operation that tampers with
    elements performed on the underlying list is prohibited.  The
    finalization of a stable list that provides such a view removes
-   this restriction on the underlying regular list Redundant[(though
+   this restriction on the underlying ordinary list Redundant[(though
    some other restriction might exist due to other concurrent iterations
    or stabilized views)].
 
@@ -438,7 +438,7 @@
    The nested package Stable provides a type Stable.Map that represents
    a /stable/ map, which is one that cannot grow and shrink. Such a
    map can be created by calling the Copy functions, or
-   by establishing a /stabilized view/ of a regular Map.
+   by establishing a /stabilized view/ of an ordinary Map.
 
    The subprograms of the map package that have a parameter 
    or result of type Map are included in the nested package Stable 
@@ -455,17 +455,17 @@
      view since no such operations are included. Thus tampering checks are
      not needed for a stable view.
 
-   The operations of this package are equivalent to those for regular
+   The operations of this package are equivalent to those for ordinary
    Hashed_Maps, except that no tampering checks are performed on 
    stable maps. If a stable
    map is declared with the Base discriminant designating a
-   pre-existing regular map, the stable map represents a
-   stabilized view of the underlying regular map, and any operation
-   on the stable map is reflected on the underlying regular map.
+   pre-existing ordinary map, the stable map represents a
+   stabilized view of the underlying ordinary map, and any operation
+   on the stable map is reflected on the underlying ordinary map.
    While a stabilized view exists, any operation that tampers with
    elements performed on the underlying map is prohibited. The
    finalization of a stable map that provides such a view removes
-   this restriction on the underlying regular map Redundant[(though
+   this restriction on the underlying ordinary map Redundant[(though
    some other restriction might exist due to other concurrent iterations
    or stabilized views)].
 
@@ -609,7 +609,7 @@
    The nested package Stable provides a type Stable.Set that represents
    a /stable/ set, which is one that cannot grow and shrink. Such a
    set can be created by calling the Copy functions, or
-   by establishing a /stabilized view/ of a regular Set.
+   by establishing a /stabilized view/ of an ordinary Set.
 
    The subprograms of package the set package that have a parameter 
    or result of type Set are included in the nested package Stable 
@@ -630,17 +630,17 @@
      view since no such operations are included. Thus tampering checks are
      not needed for a stable view.
 
-   The operations of this package are equivalent to those for regular
+   The operations of this package are equivalent to those for ordinary
    maps, except that no tampering checks are performed on 
    stable sets. If a stable
    set is declared with the Base discriminant designating a
-   pre-existing regular set, the stable set represents a
-   stabilized view of the underlying regular set, and any operation
-   on the stable set is reflected on the underlying regular set.
+   pre-existing ordinary set, the stable set represents a
+   stabilized view of the underlying ordinary set, and any operation
+   on the stable set is reflected on the underlying ordinary set.
    While a stabilized view exists, any operation that tampers with
    elements performed on the underlying set is prohibited.  The
    finalization of a stable set that provides such a view removes
-   this restriction on the underlying regular set Redundant[(though
+   this restriction on the underlying ordinary set Redundant[(though
    some other restriction might exist due to other concurrent iterations
    or stabilized views)].
 
@@ -793,7 +793,7 @@
    The nested package Stable provides a type Stable.Tree that represents
    a /stable/ tree, which is one that cannot grow and shrink. Such a
    tree can be created by calling the Copy functions, or
-   by establishing a /stabilized view/ of a regular Tree.
+   by establishing a /stabilized view/ of an ordinary Tree.
 
    The subprograms of package Containers.Multiway_Trees that have a 
    parameter or result of type Tree are included in the nested package Stable 
@@ -809,16 +809,16 @@
      view since no such operations are included. Thus tampering checks are
      not needed for a stable view.
 
-   The operations of this package are equivalent to those for regular
+   The operations of this package are equivalent to those for ordinary
    trees, except that no tampering checks are performed on 
    stable trees. If a stable tree is declared with the Base discriminant
-   designating a pre-existing regular tree, the stable tree represents a
-   stabilized view of the underlying regular tree, and any operation
-   on the stable tree is reflected on the underlying regular tree.
+   designating a pre-existing ordinary tree, the stable tree represents a
+   stabilized view of the underlying ordinary tree, and any operation
+   on the stable tree is reflected on the underlying ordinary tree.
    While a stabilized view exists, any operation that tampers with
    elements performed on the underlying tree is prohibited. The
    finalization of a stable tree that provides such a view removes
-   this restriction on the underlying regular tree Redundant[(though
+   this restriction on the underlying ordinary tree Redundant[(though
    some other restriction might exist due to other concurrent iterations
    or stabilized views)].
 
@@ -5110,6 +5110,36 @@
 or not it is considered tampering with elements. (But I think all forms 
 do tamper with elements.)
 
-
 ***************************************************************
 
+From WG 9 review #78.
+
+A.18.2(237.1/5):
+
+"...regular Vector". I guess this is OK but to elderly British ears the word 
+regular is probably normally used only in conjunction with movements of the 
+bowel. But it has crept into common or garden British English over the years
+so that what were once marked as Standard packets of Cornflakes are now marked
+as Regular. The existing RM 2012 (as opposed to AARM) only uses regular in 
+one place in Appendix C. However, the new wonderful Stable Containers have 
+inserted regular in lots of places. I suppose one might say ordinary or 
+normal. But I assume regular is perfectly acceptable.
+
+---
+
+I asked Tucker Taft about this one, and he replied:
+
+Both "regular" and "normal" have additional meanings ("normal" means 
+"perpendicular" in some contexts, and "regular" means to obey certain rules,
+such as "regular expressions"). So "ordinary" sounds good. We talk about 
+"ordinary fixed point" so clearly we have used the term in other contexts in 
+the RM to mean "plain vanilla," so "ordinary vectors" seems fine.
+
+---
+
+Since Tucker and I agree that "ordinary" would be better, I replaced "regular"
+with "ordinary" in these paragraphs (five sets). This was treated as an 
+Editorial Review on AI12-0111-1. (Some the AI supporting text also was changed
+accordingly.)
+
+***************************************************************