CVS difference for ai05s/ai05-0001-1.txt

Differences between 1.7 and version 1.8
Log of other versions for file ai05s/ai05-0001-1.txt

--- ai05s/ai05-0001-1.txt	2009/02/18 05:47:31	1.7
+++ ai05s/ai05-0001-1.txt	2009/06/08 06:51:58	1.8
@@ -1,4 +1,4 @@
-!standard  A.18(0/2)                                 09-02-16    AI05-0001-1/04
+!standard  A.18(0/2)                                 09-06-03    AI05-0001-1/05
 !class Amendment 05-10-24
 !status work item 06-03-15
 !status received 05-10-02
@@ -27,953 +27,768 @@
 
 !wording
 
-Package Containers
+A.4.9 String Hashing
 
-The library package Containers has the following additional declaration:
+Add the following declarations after A.4.9(11/2):
 
-  Capacity_Error : exception;
-
-
-Bounded Vector
-
-The language-defined generic package Containers.Bounded_Vectors
-provides a private type Vector and a set of operations. It provides
-the same operations as the package Containers.Vectors (see A.18.2),
-with the difference that internal storage is allocated statically.
-
-[ARG]
-
-Is that last sentence OK?
-
-[END ARG]
-
-Static Semantics
-
-The declaration of the generic library package
-Containers.Bounded_Vectors has the same contents as Containers.Vectors
-except:
-
-The package has Pure categorization.
-
-The container type is declared with a discriminant that specifies the
-capacity:
-
-   type Vector (Capacity : Count_Type) is tagged private;
-
-Add the following declarations after A.18.2(34/2):
+The library function Strings.Hash_Case_Insensitive has the following
+declaration:
 
-   procedure Assign (Target : in out Vector; Source : Vector);
+with Ada.Containers;
+function Ada.Strings.Hash_Case_Insensitive
+  (Key : String) return Containers.Hash_Type;
+pragma Pure (Ada.Strings.Hash_Case_Insensitive);
 
-   function Copy (Source : Vector; Capacity : Count_Type := 0)
-      return Vector;
+Returns an implementation-defined value which is a function of the value
+of Key, folded to lower case. If A and B are strings such that A equals
+B, Hash_Case_Insensitive(A) equals Hash_Case_Insensitive(B).
 
-Add the following after A.18.2(147/2):
+The library function Strings.Fixed.Hash_Case_Insensitive has the
+following declaration:
 
-   procedure Assign (Target : in out Vector; Source : Vector);
+with Ada.Containers, Ada.Strings.Hash_Case_Insensitive;
+function Ada.Strings.Fixed.Hash_Case_Insensitive (Key : String)
+   return Containers.Hash_Type renames Ada.Strings.Hash_Case_Insensitive;
+pragma Pure(Hash_Case_Insensitive);
 
-If Target denotes the same object as Source, the operation has no
-effect.  If Source length is greater than Target capacity,
-Reserve_Capacity is called with the Source length as the capacity.
-Each element of Source is then assigned to the matching element of
-Target.
+The generic library function Strings.Bounded.Hash_Case_Insensitive has
+the following declaration:
 
-   function Copy (Source : Vector; Capacity : Count_Type := 0)
-      return Vector;
+with Ada.Containers;
+generic
+   with package Bounded is
+          new Ada.Strings.Bounded.Generic_Bounded_Length (<>);
+function Ada.Strings.Bounded.Hash_Case_Insensitive
+  (Key : Bounded.Bounded_String) return Containers.Hash_Type;
+pragma Preelaborate(Hash_Case_Insensitive);
 
-Returns a vector whose elements match the active elements of Source.
-If Capacity is 0, then the vector capacity is the length of Source; if
-Capacity is equal to or greater than Source.Length, the vector
-capacity is at least the specified value.  Otherwise, the operation
-raises Capacity_Error.
+Strings.Bounded.Hash_Case_Insensitive is equivalent to the function call
+Strings.Hash_Case_Insensitive (Bounded.To_String (Key));
 
-[ARG]
+The library function Strings.Unbounded.Hash_Case_Insensitive has the
+following declaration:
 
-OK to say above "...who elements match the active elements of Source"?
+with Ada.Containers;
+function Ada.Strings.Unbounded.Hash_Case_Insensitive
+  (Key : Unbounded_String) return Containers.Hash_Type;
+pragma Preelaborate(Hash_Case_Insensitive);
 
-[END ARG]
+Strings.Unbounded.Hash_Case_Insensitive is equivalent to the function
+call Strings.Hash_Case_Insensitive (To_String (Key));
 
-[ARG]
 
-FOR BOUNDED FORM: DECLARE A CAPACITY_SUBTYPE FOR BOUNDED VECTOR
-FOR UNBOUNDED CASE TOO
+A.4.10 String Comparison
 
-USE SUBTYPE IN COPY, RES_CAP, etc
+The library function Strings.Equal_Case_Insensitive has the following
+declaration:
 
-TODO: I don't know how to declare this subtype
+function Ada.Strings.Equal_Case_Insensitive
+  (Left, Right : String) return Boolean;
+pragma Pure (Ada.Strings.Equal_Case_Insensitive);
 
-It's supposed to be
+Compares strings Left and Right, folded to lower case, for equality.
 
-  subtype Capacity_Subtype is Count_Type range 0 .. <expression>;
+The library function Strings.Fixed.Equal_Case_Insensitive has the
+following declaration:
 
-The intent was to prevent a vector object from having a capacity
-greater than the number of values in the index subtype, e.g.
+with Ada.Containers, Ada.Strings.Equal_Case_Insensitive;
+function Ada.Strings.Fixed.Equal_Case_Insensitive (Key : String)
+   return Boolean renames Ada.Strings.Equal_Case_Insensitive;
+pragma Pure(Equal_Case_Insensitive);
 
-  type IT is range 0 .. 5;
-  type ET is ...;
-  package P is new Bounded_Vectors (IT, ET);
+The generic library function Strings.Bounded.Equal_Case_Insensitive has
+the following declaration:
 
-  V : P.Vector (10);  -- only V[0] .. V[5] are accessible
+with Ada.Containers;
+generic
+   with package Bounded is
+          new Ada.Strings.Bounded.Generic_Bounded_Length (<>);
+function Ada.Strings.Bounded.Equal_Case_Insensitive
+  (Left, Right : Bounded.Bounded_String) return Boolean;
+pragma Preelaborate(Equal_Case_Insensitive);
 
-Would this work?
+Strings.Bounded.Equal_Case_Insensitive is equivalent to the function call
+Strings.Equal_Case_Insensitive (Bounded.To_String (Key));
 
-  subtype Capacity_Subtype is Count_Type
-    range 0 .. Count_Type'Max (0,
-                               Index_Type'Pos (Index_Type'Last) -
-                               Index_Type'Pos (Index_Type'First) + 1);
 
-The problem here is the instantiation:
+The library function Strings.Unbounded.Equal_Case_Insensitive has the
+following declaration:
 
-  package P is new Bounded_Vectors (Natural, ET);
+with Ada.Containers;
+function Ada.Strings.Unbounded.Equal_Case_Insensitive
+  (Left, Right : Unbounded_String) return Boolean;
+pragma Preelaborate(Equal_Case_Insensitive);
 
-Subtype Natural has more values in the type than Count_Type'Last.
+Strings.Unbounded.Equal_Case_Insensitive is equivalent to the function
+call Strings.Equal_Case_Insensitive (To_String (Key));
 
-Another option is to raise Constraint_Error (or whatever) at the point
-of declaration of the object -- but that won't work either, since
-the bounded forms aren't controlled.
 
-If there were a way to return the count of the number of values in the
-type, then the user could pass that as the capacity, and we could
-leave the declaration of the descriminant as-is:
+The library function Strings.Less_Case_Insensitive has the following
+declaration:
 
-  V : P.Vector (IT'Value_Count);  -- IT'Value_Count = 6
+function Ada.Strings.Less_Case_Insensitive
+  (Left, Right : String) return Boolean;
+pragma Pure (Ada.Strings.Less_Case_Insensitive);
 
-In a review of a draft of this document, Randy B. said:
+Performs a lexicographic comparison of strings Left and Right, folded to
+lower case.
 
-The trick here, of course, is to ensure that you're evaluating as
-Universal_Integer. But I suppose that isn't perfect, since the expressions
-don't have to be static, and you could always use a type with more values
-than the largest integer type supported by the compiler.
 
-OTOH, you don't want to support more than Count_Type'Last elements, so
-giving an index with more is dubious.
+The library function Strings.Fixed.Less_Case_Insensitive has the
+following declaration:
 
-OT3H, not allowing Natural seems annoying.
+with Ada.Containers, Ada.Strings.Less_Case_Insensitive;
+function Ada.Strings.Fixed.Less_Case_Insensitive (Key : String)
+   return Boolean renames Ada.Strings.Less_Case_Insensitive;
+pragma Pure(Less_Case_Insensitive);
 
-Anyway, if you write the expressions as boolean conditionals, they're be
-evaluated as univeral integers. One idea is something like:
-  subtype Capacity_Subtype is Count_Type
-    range 0 .. Count_Type'Max (0,
-       Boolean'Pos(Index_Type'Pos (Index_Type'Last) - Index_Type'Pos
-(Index_Type'First) + 1 > Count_Type'Pos(Count_Type'Last))*Count_Type'Last +
-       Boolean'Pos(Index_Type'Pos (Index_Type'Last) - Index_Type'Pos
-(Index_Type'First) + 1 <= Count_Type'Pos(Count_Type'Last)*(Index_Type'Pos
-(Index_Type'Last) - Index_Type'Pos (Index_Type'First) + 1));
 
-Gosh that's awful. (And it still will raise an exception if Index_Type is a
-64-bit type on GNAT.)
+The generic library function Strings.Bounded.Less_Case_Insensitive has
+the following declaration:
 
-I guess we better leave this one for the full group.
-[END ARG]
+with Ada.Containers;
+generic
+   with package Bounded is
+          new Ada.Strings.Bounded.Generic_Bounded_Length (<>);
+function Ada.Strings.Bounded.Less_Case_Insensitive
+  (Left, Right : Bounded.Bounded_String) return Boolean;
+pragma Preelaborate(Less_Case_Insensitive);
 
+Strings.Bounded.Less_Case_Insensitive is equivalent to the function call
+Strings.Less_Case_Insensitive (Bounded.To_String (Key));
 
-[ARG]
 
-   procedure Move (Target : in out Vector; Source : in out Vector);
+The library function Strings.Unbounded.Less_Case_Insensitive has the
+following declaration:
 
-My notes say:
+with Ada.Containers;
+function Ada.Strings.Unbounded.Less_Case_Insensitive
+  (Left, Right : Unbounded_String) return Boolean;
+pragma Preelaborate(Equal_Case_Insensitive);
 
-RE-WRITE UNBOUNDED FORM TO INCLUDE A CALL TO RES_CAP, which means we
-could reuse the wording for unbounded form, therefore we don't need to
-say anything special here.
-
-Here's what the RM says now:
-
-  "If Target denotes the same object as Source, then Move has no
-  effect. Otherwise, Move first calls Clear (Target); then, each
-  element from Source is removed from Source and inserted into Target
-  in the original order. The length of Source is 0 after a successful
-  call to Move."
-
-We change add a call to Reserve_Capacity to that description, subject
-to the following constraints:
-
-(1) In the bounded form, if the source length is greater than target
-capacity, we could prefer to raise Capacity_Error immediately (instead
-of clearning target as a side effect).
-
-(2) In the unbounded form, we prefer to clear first, and then reserve
-capacity.  If you do in the other way around then the existing items
-are copied (in the reserve) and then immediately deleted (in the
-clear).  Perhaps we only have to require the final effect (no items,
-and such-and-such capacity), but merely describe it in terms of a
-reserve followed by a clear.
-
-With that in mind, here's the revised description:
-
-   "If Target denotes the same object as Source, then Move has no
-   effect. Otherwise, Move first calls Target.Reserve_Capacity
-   (Source.Length) and then Target.Clear; then, each element from
-   Source is removed from Source and inserted into Target in the
-   original order. The length of Source is 0 after a successful call
-   to Move."
-
-If the original description of the Move operation is modified as above
-for the unbounded form, then there's probably nothing else we need to
-say for the bounded form (since Reserve_Capacity does what we want
-here).
+Strings.Unbounded.Less_Case_Insensitive is equivalent to the function
+call Strings.Less_Case_Insensitive (To_String (Key));
 
-[END ARG]
 
-Implementation Advice A.18.2(261/2) is deleted.
+A.18.1 Package Containers
 
-[ARG]
+Add the following after A.18.1(5/2):
 
-RLB: In the bounded form only? Or in unbounded and bounded
-forms?
+  Capacity_Error : exception;
 
-Alternatively, we would have to put as Implementation
-Advice in the bounded form:
 
-"The Implementation Advice for procedure Move is deleted."
+A.18.2 Package Containers.Vectors
 
-That's pretty weird.
+Add the following declarations after A.18.2(34/2):
 
-[END ARG]
+   procedure Assign (Target : in out Vector; Source : Vector);
 
-   procedure Reserve_Capacity
-     (Container : in out Vector;
-      Capacity  : Capacity_Subtype);
-
-If the specified Capacity is larger than the Container.Capacity, then
-Reserve_Capacity raises Capacity_Error.  Otherwise, the operation has
-no effect.
+   function Copy (Source : Vector; Capacity : Count_Type := 0)
+      return Vector;
 
-[ARG]
+Add the following after A.18.2(147/2):
 
-The bounded form has a distinct description for Reserve_Capacity,
-because it can raise Capacity_Error.  Where does this description go?
-[RLB: Under the description of Reserve_Capacity in the bounded forms,
-of course. Where else would it go?]
-
-More generally, no operations for the unbounded forms raise
-Capacity_Error.  Do we need to specify this distinct behavior of the
-bounded forms?
+   procedure Assign (Target : in out Vector; Source : Vector);
 
-[END ARG]
+If Target denotes the same object as Source, the operation has no
+effect.  If Source length is greater than Target capacity,
+Reserve_Capacity is called with the Source length as the capacity.
+Each element of Source is assigned to the corresponding elements of
+Target.
 
+   function Copy (Source : Vector; Capacity : Count_Type := 0)
+      return Vector;
 
-Bounded Doubly-Linked List
+Returns a vector whose elements are initialized from the corresponding
+elements of Source.  If Capacity is 0, then the vector capacity is the
+length of Source; if Capacity is equal to or greater than
+Source.Length, the vector capacity is at least the specified value.
+Otherwise, the operation raises Capacity_Error.
 
-The language-defined generic package
-Containers.Bounded_Doubly_Linked_Lists provides a private type List
-and a set of operations. It provides the same operations as the
-package Containers.Doubly_Linked_Lists (see A.18.3), with the
-difference that internal storage is allocated statically.
+Add the following after A.18.2(89/2):
 
-Static Semantics
+If an operation attempts to modify the vector such that the position
+of the last element would be greater than Index_Type'Last, then the
+operation raises Constraint_Error.
+
+Modify A.18.2(115/2):
+{If the capacity of Container is already greater than or equal to
+Capacity then Reserve_Capacity has no effect. Otherwise, }
+Reserve_Capacity allocates [new internal data structures such]
+{additional storage as necessary to ensure} that the length of the
+resulting vector can become at least the value Capacity without
+requiring an additional call to Reserve_Capacity, and is large enough
+to hold the current length of Container. Reserve_Capacity then
+[copies the] {, as necessary, moves} elements into the new [data
+structures] {storage} and deallocates [the old data structures] {any
+storage no longer needed}. Any exception raised during allocation is
+propagated and Container is not modified.
+
+A.18.2(148/2) is replaced by the following:
+
+If Target denotes the same object as Source, then Move has no
+effect. Otherwise, Move first calls Target.Reserve_Capacity
+(Source.Length) and then Target.Clear; then, each element from Source
+is removed from Source and inserted into Target in the original
+order. The length of Source is 0 after a successful call to Move.
 
-The declaration of the generic library package
-Containers.Bounded_Doubly_Linked_Lists has the same contents as
-Containers.Doubly_Linked_Lists except:
+Add the following after A.18.2(93/2):
 
-The package has Pure categorization.
+   * it calls Assign with V as the Target parameter; or
 
-The list container type is declared with a discriminant that specifies the
-capacity, as follows:
 
-   type List (Capacity : Count_Type) is tagged private;
+A.18.3 Package Containers.Doubly_Linked_Lists
 
 Add the following declarations after A.18.3(17/2):
 
    procedure Assign (Target : in out List; Source : List);
+
+   function Copy (Source : List) return List;
+
+Add the following after A.18.3(65/2):
 
-   function Copy (Source : List; Capacity : Count_Type := 0)
-      return List;
+   * it calls Assign with L as the Target parameter; or
 
 Add the following after A.18.3(86/2):
 
    procedure Assign (Target : in out List; Source : List);
 
 If Target denotes the same object as Source, the operation has no
-effect.  If Source length is greater than Target capacity, then the
-operation raises Capacity_Error, and Target is not modified.
-Otherwise, it clears Target, and then each element of Source is
-assigned to the matching element of Target.
-
-   function Copy (Source : List; Capacity : Count_Type := 0)
-      return List;
-
-Returns a list whose match the elements of Source.  If Capacity is 0,
-then the list capacity is the length of Source; if Capacity is equal
-to or greater than Source.Length, the list capacity is at least the
-specified value.  Otherwise, the operation raises Capacity_Error.
-
-[ARG]
-
-An issue with Assign here is that there's no Reserve_Capacity
-operation for lists, so we can't use the trick as we did for vectors
-to write a description that works for both the unbounded and bounded
-forms.  Do we write distinct descriptions of Assign for the unbounded
-vs. bounded cases?
+effect.  Otherwise, it clears Target, and each element of Source is
+assigned to the corresponding elements of Target.
 
-In general, operations that can raise Capacity_Error include:
-Append, Insert, Assign, Copy, Move, Prepend, List'Read, Splice
+   function Copy (Source : List) return List;
 
-[END ARG]
+Returns a list whose elements match the elements of Source.
 
-   procedure Move (Target : in out List; Source : in out List);
+The description of Move in A.18.3(88/2) is replaced with:
 
 Equivalent to Target.Assign (Source) followed by Source.Clear.
 
-[ARG]
-
-Will this description suffice for both the unbounded and bounded
-forms?
-
-[END ARG]
-
-Implementation Advice A.18.3(162/2) is deleted.
-
-[ARG]
-
-RLB: See notes under bounded vector.
-
-[END ARG]
 
-   procedure Splice
-     (Target : in out List;
-      Before : Cursor;
-      Source : in out List);
-
-If the sum of the Target length and Source length is greater than the
-Target capacity, then Splice raises Capacity_Error.  Otherwise the
-elements from Source are moved to Target, immediately preceding
-position Before.
+A.18.4 Maps
 
-[ARG]
-
-We say "... are moved to ..." implying a call to Move.  Do we need to
-say that explicitly?
-
-[END ARG]
+Add the following after A.18.4(10/2):
 
-   procedure Splice
-     (Target   : in out List;
-      Before   : Cursor;
-      Source   : in out List;
-      Position : in out Cursor);
+   * it calls Assign with M as the Target parameter; or
 
-If the Target length equals the Target capacity, then Splice raises
-Capacity_Error.  Otherwise the element of Source designated by
-Position is moved to Target, immediately preceeding position Before.
+The description of Move in A.18.4(43/2) is replaced with:
 
-
-Maps
-
-Implementation Advice A.18.4(83/2) is deleted.
-
-
-Bounded Hashed Map
-
-The language-defined generic package Containers.Bounded_Hashed_Maps
-provides a private type Map and a set of operations. It provides the
-same operations as the package Containers.Hashed_Maps (see A.18.5),
-with the difference that internal storage is allocated statically.
-
-Static Semantics
-
-The declaration of the generic library package
-Containers.Bounded_Hashed_Maps has the same contents as
-Containers.Hashed_Maps except:
-
-The package has Pure categorization.
-
-The container type is declared with a discriminant that specifies both
-the capacity (number of elements) and modulous (number of distinct
-hash values) of the hash table as follows:
-
-   type Map (Capacity : Count_Type; Modulus : Hash_Type) is tagged private;
+Equivalent to Target.Assign (Source) followed by Source.Clear.
 
 
-   procedure Reserve_Capacity
-     (Container : in out Map;
-      Capacity  : Count_Type);
 
-If the specified Capacity is larger than the Container.Capacity, then
-it raises Capacity_Error.  Otherwise, the operation has no effect.
+A.18.5 Containers.Hashed_Maps
 
 Add the following declarations after A.18.5(17/2):
 
    procedure Assign (Target : in out Map; Source : Map);
-
-   function Copy (Source   : Map;
-                  Capacity : Count_Type := 0;
-                  Modulus  : Hash_Type := 0) return Map;
-
-Add the following after A.18.5(53/2):
-
-   procedure Assign (Target : in out Map; Source : Map);
-
-If Target denotes the same object as Source, the operation has no
-effect.  If Source length is greater than Target capacity,
-Reserve_Capacity is called with the Source length as the capacity.
-Otherwise, it clears Target and inserts each key/element pair of
-Source into Target.
-
-[ARG]
-
-This is written very similar (i.e. in terms of Reserve_Capacity) to
-the description of Assign for the vector (with the intent that it work
-for both unbounded and bounded forms).  Whatever we decide for vector
-should probably apply here as well.
-
-Note also we say "If Source length is greater than Target capacity,
-then Reserve_Capacity is called...".  Do we need to bother with the
-if-clause?  Reserve_Capacity is allowed to return more than requested,
-so the post-condition would be satified no matter what.
-
-[END ARG]
-
-
-   function Copy (Source   : Map;
-                  Capacity : Count_Type := 0;
-                  Modulus  : Hash_Type := 0) return Map;
-
-Returns a map with key/element pairs copied from Source, and having a
-capacity and modulus determined as follows.  If Capacity is 0, then
-the map capacity is the length of Source; if Capacity is equal to or
-greater than Source.Length, the map capacity is least the specified
-value; otherwise, the operation raises Capacity_Error.  If the Modulus
-argument is 0, then the map modulus is the value returned by a call to
-Default_Modulus with the map capacity as its argument; otherwise the
-map modulus is the value of the Modulus argument.
-
-[ARG]
-
-We say "... pairs copied from Source ..." above: is this too
-tautological?
-
-[END ARG]
-
-[ARG]
-
-I have put the description of Assign and Copy here instead of in
-A.18.4 only because here I have two slightly different descriptions
-for hashed vs. ordered forms.
-
-[END ARG]
-
-   procedure Move (Target : in out Map; Source : in out Map);
-
-Equivalent to Target.Assign (Source) followed by Source.Clear.
-
-[ARG]
-
-Here we describe Move in terms of Assign (which is in turn described
-in terms of Reserve_Capacity).  Should we describe Move directly in
-terms of Reserve_Capacity, instead of in terms of Assign?
-
-[END ARG]
 
+   function Copy (Source : Map) return Map;
 
 [ARG]
-
-Make this an implementation note?
 
-KNUTH SAYS YOU SHOULD GOLDEN RATIO FOR LOAD FACTOR
-SEE JOHN'S BOOK FOR SPECIFIC REF
+Does the unbounded form of hashed map (or hashed set) have additional
+parameters for Copy?
 
 [END ARG]
 
+Add the following declaration after A.18.5(37/2):
 
    function Default_Modulus (Capacity : Count_Type) return Hash_Type;
-
-Default_Modulus returns an implementation-defined value for the length
-of the buckets array (number of distinct hash values) for hashing the
-given capacity (maximum number of elements).
-
-[ARG]
-
-Use of "implementation-defined" is OK here?
 
-[END ARG]
+Add the following after A.18.2(61/2):
 
+   procedure Assign (Target : in out Map; Source : Map);
 
-Bounded Ordered Map
+If Target denotes the same object as Source, the operation has no
+effect.  If Source length is greater than Target capacity,
+Reserve_Capacity is called with the Source length as the capacity.
+Each element of Source is then inserted into Target.
 
-The language-defined generic package Containers.Bounded_Ordered_Maps
-provides a private type Map and a set of operations. It provides the
-same operations as the package Containers.Ordered_Maps (see A.18.6),
-with the difference that internal storage is allocated statically.
+   function Copy (Source : Map) return Map;
 
-Static Semantics
+Returns a map whose keys and elements are initialized from the keys
+and elements of Source.
 
-The declaration of the generic library package
-Containers.Bounded_Ordered_Maps has the same contents as
-Containers.Ordered_Maps except:
-
-The package has Pure categorization.
+   function Default_Modulus (Capacity : Count_Type) return Hash_Type;
 
-The container type is declared with a discriminant that specifies the
-capacity (maximum number of elements) as follows:
+Default_Modulus returns an implementation-defined value for the number
+of distinct hash values to be used for the given capacity (maximum
+number of elements).
 
-   type Map (Capacity : Count_Type) is tagged private;
+A.18.6 Containers.Ordered_Maps
 
 Add the following declarations after A.18.6(16/2):
 
    procedure Assign (Target : in out Map; Source : Map);
 
-   function Copy (Source   : Map;
-                  Capacity : Count_Type := 0) return Map;
+   function Copy (Source : Map) return Map;
 
 Add the following after A.18.6(58/2):
 
    procedure Assign (Target : in out Map; Source : Map);
 
 If Target denotes the same object as Source, the operation has no
-effect.  If Source length is greater than Target capacity, then the
-operation raises Capacity_Error.  Otherwise, it clears Target and
-inserts each key/element pair of Source into Target.
-
-[ARG]
-
-This is similar to the case of lists (no Reserve_Capacity).
+effect.  Each key/element pair of Source is assigned to the
+corresponding key/element pairs of Target.
 
-[END ARG]
+   function Copy (Source : Map) return Map;
 
-   function Copy (Source   : Map;
-                  Capacity : Count_Type := 0) return Map;
+Returns a map whose keys and elements are initialized from the
+corresponding keys and elements of Source.
 
-Returns a map with key/element pairs copied from Source, and having a
-capacity determined as follows.  If Capacity is 0, then the map
-capacity is the length of Source; if Capacity is equal to or greater
-than Source.Length, the map capacity is at least the specified value;
-otherwise, the operation raises Capacity_Error.
+A.18.7 Sets
 
-[ARG]
+Add the following after A.18.7(10/2):
 
-Here's a list of operations that raise Capacity_Error:
-Assign, Copy, Include, Insert, Move, Map'Read, Reserve_Capacity
+   * it calls Assign with S as the Target parameter; or
 
-We just need to decide how to handle these, since there are
-differences between the unbounded and bounded forms.
+The description of Move in A.18.7(38/2) is replaced with:
 
-[END ARG]
+Equivalent to Target.Assign (Source) followed by Source.Clear.
 
-   procedure Move (Target : in out Map; Source : in out Map);
 
-Equivalent to Target.Assign (Source) followed by Source.Clear.
+A.18.8 Containers.Hashed_Sets
 
+Add the following declarations after A.18.8(17/2):
 
-Sets
+   procedure Assign (Target : in out Set; Source : Set);
 
-Implementation Advice A.18.7(104/2) is deleted.
+   function Copy (Source : Set) return Set;
 
-Bounded Hashed Set
+Add the following declaration after A.18.8(49/2):
 
-The language-defined generic package Containers.Bounded_Hashed_Sets
-provides a private type Set and a set of operations. It provides the
-same operations as the package Containers.Hashed_Sets (see A.18.8),
-with the difference that internal storage is allocated statically.
+   function Default_Modulus (Capacity : Count_Type) return Hash_Type;
 
-Static Semantics
+Add the following after A.18.8(87/2):
 
-The declaration of the generic library package
-Containers.Bounded_Hashed_Sets has the same contents as
-Containers.Hashed_Sets except:
+   procedure Assign (Target : in out Set; Source : Set);
 
-The package has Pure categorization.
+If Target denotes the same object as Source, the operation has no
+effect.  If Source length is greater than Target capacity,
+Reserve_Capacity is called with the Source length as the capacity.
+Each element of Source is then inserted into Target.
 
-The container type is declared with a discriminant that specifies both
-the capacity (number of elements) and modulous (number of distinct
-hash values) of the hash table as follows:
+   function Copy (Source : Set) return Set;
 
-   type Set (Capacity : Count_Type; Modulus : Hash_Type) is tagged private;
+Returns a set whose elements are initialized from the elements of
+Source.
 
+   function Default_Modulus (Capacity : Count_Type) return Hash_Type;
 
-   procedure Reserve_Capacity
-     (Container : in out Map;
-      Capacity  : Count_Type);
+Default_Modulus returns an implementation-defined value for the number
+of distinct hash values to be used for the given capacity (maximum
+number of elements).
 
-If the specified Capacity is larger than the Container.Capacity, then
-it raises Capacity_Error.  Otherwise, the operation has no effect.
+A.18.9 Containers.Ordered_Sets
 
-Add the following declarations after A.18.8(17/2):
+Add the following declarations after A.18.9(16/2):
 
    procedure Assign (Target : in out Set; Source : Set);
 
-   function Copy (Source   : Set;
-                  Capacity : Count_Type := 0;
-                  Modulus  : Hash_Type := 0) return Set;
+   function Copy (Source : Set) return Set;
 
-Add the following after A.18.8(75/2):
+Add the following after A.18.9(81/2):
 
    procedure Assign (Target : in out Set; Source : Set);
 
 If Target denotes the same object as Source, the operation has no
-effect.  If Source length is greater than Target capacity,
-Reserve_Capacity is called with the Source length as the capacity.
-Otherwise, it clears Target and inserts each element of Source into
-Target.
+effect.  Otherwise, each element of Source is assigned to the
+corresponding element of Target.
 
-   function Copy (Source   : Set;
-                  Capacity : Count_Type := 0;
-                  Modulus  : Hash_Type := 0) return Set;
-
-Returns a set with elements copied from Source, and having a capacity
-and modulus determined as follows.  If Capacity is 0, then the set
-capacity is the length of Source; if Capacity is equal to or greater
-than Source.Length, the set capacity is at least the specified value;
-otherwise, the operation raises Capacity_Error.  If the Modulus
-argument is 0, then the set modulus is the value returned by a call to
-Default_Modulus with the set capacity as its argument; otherwise the
-set modulus is the value of the Modulus argument.
+   function Copy (Source : Set) return Set;
 
-   procedure Move (Target : in out Set; Source : in out Set);
+Returns a set whose elements are initialized from the corresponding
+elements of Source.
 
-Equivalent to Target.Assign (Source) followed by Source.Clear.
 
-   function Default_Modulus (Capacity : Count_Type) return Hash_Type;
+A.18.16 Array Sorting
 
-Default_Modulus returns an implementation-defined value for the length
-of the buckets array (number of distinct hash values) for hashing the
-given capacity (maximum number of elements).
+A.18.16 (1/2) is replaced by the following:
 
-[ARG]
+The language-defined generic procedures Containers.Generic_Array_Sort,
+Containers.Generic_Constrained_Array_Sort, and Containers.Generic_Sort
+provide sorting on arbitrary array types.
 
-Use of "implementation-defined" is OK here?
+Add the following declarations after A.18.16 (9/2):
 
-[END ARG]
+generic
+   type Index_Type is (<>);
+   with function Before (Left, Right : Index_Type) return Boolean;
+   with procedure Swap (Left, Right : Index_Type);
 
+procedure Ada.Containers.Generic_Sort (First, Last : Index_Type'Base);
+pragma Pure (Ada.Containers.Generic_Sort);
 
-Bounded Ordered Set
+Reorders the elements of an indexable structure, over the range First
+.. Last, such that the elements are sorted smallest first as
+determined by the generic formal Before function provided. Generic
+formal Before compares the elements having the given indices, and
+generic formal Swap exchanges the values of the indicated
+elements. Any exception raised during evaluation of Before or Swap is
+propagated.
 
-The language-defined generic package Containers.Bounded_Ordered_Sets
-provides a private type Set and a set of operations. It provides the
-same operations as the package Containers.Ordered_Sets (see A.18.9),
-with the difference that internal storage is allocated statically.
+The actual function for the generic formal function Before of
+Generic_Sort is expected to return the same value each time it is
+called with a particular pair of element values. It should define a
+strict weak ordering relationship (see A.18); it should not modify the
+elements. If the actual for Before behaves in some other manner, the
+behavior of Generic_Sort is unspecified. How many times the
+Generic_Sort calls Before or Swap is unspecified.
 
-Static Semantics
 
-The declaration of the generic library package
-Containers.Bounded_Ordered_Sets has the same contents as
-Containers.Ordered_Sets except:
+A.18.17 Containers.Indefinite_Holders (see AI05-0069-1)
 
-The package has Pure categorization.
+Add the following declarations after A.18.17(15/3): [Before Move]
 
-The container type is declared with a discriminant that specifies the
-capacity (maximum number of elements) as follows:
+   procedure Assign (Target : in out Holder; Source : Holder);
 
-   type Set (Capacity : Count_Type) is tagged private;
+   function Copy (Source : Holder) return Holder;
 
-Add the following declarations after A.18.9(16/2):
+Add the following after A.18.17(44/3):
 
-   procedure Assign (Target : in out Set; Source : Set);
+   procedure Assign (Target : in out Holder; Source : Holder);
 
-   function Copy (Source   : Set;
-                  Capacity : Count_Type := 0) return Set;
+If Target denotes the same object as Source, the operation has no
+effect. If Source is empty, Clear (Target) is called. Otherwise, 
+Replace_Element (Target, Element (Source)) is called.
 
-Add the following after A.18.9(81/2):
+   function Copy (Source : Holder) return Holder;
 
-   procedure Assign (Target : in out Set; Source : Set);
+If Source is empty, returns an empty holder; otherwise, returns
+To_Holder (Element (Source)).
 
-If Target denotes the same object as Source, the operation has no
-effect.  If Source length is greater than Target capacity, then the
-operation raises Capacity_Error.  Otherwise, it clears Target and
-inserts each element of Source into Target.
+A.18.18 The Package Containers.Bounded_Vectors
 
-   function Copy (Source   : Set;
-                  Capacity : Count_Type := 0) return Set;
+The language-defined generic package Containers.Bounded_Vectors
+provides a private type Vector and a set of operations. It provides
+the same operations as the package Containers.Vectors (see A.18.2),
+with the difference that the maximum storage is bounded.
 
-Returns a set with elements copied from Source, and having a capacity
-determined as follows.  If Capacity is 0, then the set capacity is the
-length of Source; if Capacity is equal to or greater than
-Source.Length, the set capacity is at least the specified value;
-otherwise, the operation raises Capacity_Error.
+Static Semantics
 
-   procedure Move (Target : in out Set; Source : in out Set);
+The declaration of the generic library package
+Containers.Bounded_Vectors has the same contents and semantics as
+Containers.Vectors except:
 
-Equivalent to Target.Assign (Source) followed by Source.Clear.  Source
-is cleared.
+    * pragma Preelaborate is replaced with pragma Pure
 
-Protected Queues
+      AARM implementation note: Package Containers.Bounded_Vectors
+      cannot depend on package Ada.Finalization (because that package
+      has Preelaborate categorization).
 
-[ARG]
-Should we have priority queues too?  (Steve B. suggested something
-like fibbonacci heaps as implementation data structure.)
-[END ARG]
+    * The type Vector is declared with a discriminant that specifies
+      the capacity:
 
-The language-defined generic package Containers.Queues provides
-interface type Queue, and a set of operations for that type.
+         type Vector (Capacity : Count_Type) is tagged private;
 
-generic
-   type Element_Type is private;
+    * The type Vector does not need finalization if and only type
+      Element_Type does not need finalization.
 
-package Ada.Containers.Queues is
-   pragma Pure;
+    * In function Copy, if the Capacity parameter is equal to or
+      greater than Source.Length, the vector capacity exactly equals
+      the value of the Capacity parameter.
 
-   type Queue is synchronized interface;
+    * The description of Reserve_Capacity is replaced by:
 
-   procedure Enqueue
-     (Container : in out Queue;
-      New_Item  : Element_Type) is abstract;
-   pragma Implemented (Enqueue, By_Entry);
+      If the specified Capacity is larger than the Container.Capacity,
+      then Reserve_Capacity raises Capacity_Error.  Otherwise, the
+      operation has no effect.
 
-   procedure Dequeue
-     (Container : in out Queue;
-      Element   : out Element_Type) is abstract;
-   pragma Implemented (Dequeue, By_Entry);
+    * The implementation advice for procedure Move does not apply.
 
-   function Is_Empty (Container : Queue) return Boolean is abstract;
+[Editor's note: Matt had "The implementation advice in A.18.2(261/2)
+does not apply", but of course wording cannot refer to paragraph numbers
+(the ISO version doesn't have them). I made the above replacement,
+but I'm not happy with it - 262/2 applies to Move and we don't want
+to eliminate it.].
 
-   function Is_Full (Container : Queue) return Boolean is abstract;
+    * The implementation advice includes an additional item, stating
+      that bounded vector objects should not be implemented by
+      implicit pointers or dynamic allocation.
 
-end Ada.Containers.Queues;
+    * Vector'Write writes only Vector.Length elements to the stream.
+      Vector'Read reads only Vector.Length elements from the stream.
 
+A.18.19 Package Containers.Bounded_Doubly_Linked_Lists
 
-Interface Queue specifies a first-in, first-out queue.
+The language-defined generic package
+Containers.Bounded_Doubly_Linked_Lists provides a private type List
+and a set of operations. It provides the same operations as the
+package Containers.Doubly_Linked_Lists (see A.18.3), with the
+difference that the maximum storage is bounded.
 
-   procedure Enqueue
-     (Container : in out Queue;
-      New_Item  : Element_Type) is abstract;
+Static Semantics
 
-Copies New_Item onto the tail of the queue.  If Is_Full is True, then
-Enqueue waits on the entry for storage to become available.
+The declaration of the generic library package
+Containers.Bounded_Doubly_Linked_Lists has the same contents and
+semantics as Containers.Doubly_Linked_Lists except:
 
-   procedure Dequeue
-     (Container : in out Queue;
-      Element   : out Element_Type) is abstract;
+    * pragma Preelaborate is replaced with pragma Pure
 
-Removes the element at the head of the queue, and returns a copy of
-the element.  Is Is_Empty is True, then Dequeue waits on the entry for
-an item to become available.
+      AARM implementation note: Package
+      Containers.Bounded_Doubly_Linked_Lists cannot depend on
+      package Ada.Finalization (because that package has Preelaborate
+      categorization).
 
-   function Is_Empty (Container : Queue) return Boolean is abstract;
+    * The type List is declared with a discriminant that specifies the
+      capacity:
 
-Returns an indication of whether the queue contains items.
+         type List (Capacity : Count_Type) is tagged private;
 
-   function Is_Full (Container : Queue) return Boolean is abstract;
+    * The type List does not need finalization if and only type
+      Element_Type does not need finalization.
 
-Returns an indication of whether the queue is able to contain more
-items.
+    * The allocation of internal storage includes a check that the
+      capacity is not exceeded, and Capacity_Error is raised if this
+      check fails.
 
+    * In procedure Assign, if Source length is greater than Target
+      capacity, then Capacity_Error is raised.
 
-Bounded Queues
+    * Function Copy is declared as follows:
 
-The language-defined generic package Containers.Bounded_Queues
-provides type Queue, which implements the interface type
-Containers.Queues.Queue.
+         function Copy (Source : List; Capacity : Count_Type := 0)
+	   return List;
 
-with Ada.Containers.Queues;
-generic
-   with package Queues is new Ada.Containers.Queues (<>);
+      If Capacity is 0, then the list capacity is the length of
+      Source; if Capacity is equal to or greater than Source.Length,
+      the list capacity equals the value of the Capacity parameter;
+      otherwise, the operation raises Capacity_Error.
 
-package Ada.Containers.Bounded_Queues is
-   pragma Pure;
+    * The implementation advice for procedure Move does not apply.
 
-   type Queue (Capacity : Count_Type) is
-     synchronized new Queues.Queue with private;
+    * In three-parameter procedure Splice whose Source has type List,
+      if the sum of the Target length and Source
+      length is greater than the Target capacity, then Splice raises
+      Capacity_Error.
 
-private
+      [Editor's note: This is referring to A.18.3(112/2), but of
+      course we can't say that.]
 
-   -- not specified by the language
+    * In four-parameter procedure Splice, if the
+      Target length equals the Target capacity, then Splice raises
+      Capacity_Error.
 
-end Ada.Containers.Bounded_Queues;
+      [Editor's note: This is referring to A.18.3(114/2).]
 
-The bounded queue specifies a queue with finite capacity.  Is_Full
-returns True when the length (the current number of items) equals the
-capacity.
+    * List'Write writes only List.Length elements to the stream.
+      List'Read reads only List.Length elements from the stream.
 
-Unbounded Queues
+A.18.20 Containers.Bounded_Hashed_Maps
 
-The language-defined generic package Containers.Unbounded_Queues
-provides type Queue, which implements the interface type
-Containers.Queues.Queue.
+The language-defined generic package Containers.Bounded_Hashed_Maps
+provides a private type Map and a set of operations. It provides the
+same operations as the package Containers.Hashed_Maps (see A.18.5),
+with the difference that the maximum storage is bounded.
 
-with Ada.Containers.Queues;
-generic
-   with package Queues is new Ada.Containers.Queues (<>);
+Static Semantics
 
-package Ada.Containers.Unbounded_Queues is
-   pragma Preelaborate;
+The declaration of the generic library package
+Containers.Bounded_Hashed_Maps has the same contents and semantics as
+Containers.Hashed_Maps except:
 
-   type Queue is synchronized new Queues.Queue with private;
+    * pragma Preelaborate is replaced with pragma Pure
 
-private
+      AARM implementation note: Package Containers.Bounded_Hashed_Maps
+      cannot depend on package Ada.Finalization (because that package
+      has Preelaborate categorization).
 
-   -- not specified by the language
+    * The type Map is declared with a discriminant that specifies both
+      the capacity (number of elements) and modulus (number of
+      distinct hash values) of the hash table as follows:
+      
+         type Map (Capacity : Count_Type;
+	           Modulus  : Hash_Type) is tagged private;
 
-end Ada.Containers.Unbounded_Queues;
+    * The type Map does not need finalization if and only type
+      Key_Type or type Element_Type does not need finalization.
 
-The unbounded queue specifies a queue with no specified maximum
-capacity.  Is_Full always returns False.  Enqueue will never block
-(although it can fail for other reasons, e.g. storage is exhausted).
+    * The description of Reserve_Capacity is replaced
+      by:
 
+      If the specified Capacity is larger than the Container.Capacity,
+      then Reserve_Capacity raises Capacity_Error.  Otherwise, the
+      operation has no effect.
 
-Generic_Sort
+    * The function Copy is replaced with:
 
-The generic library procedure Containers.Generic_Sort has the
-following declaration:
+        function Copy (Source   : Map;
+                       Capacity : Count_Type := 0;
+                       Modulus  : Hash_Type := 0) return Map;
 
-generic
-   type Index_Type is (<>);
-   with function Less (Left, Right : Index_Type) return Boolean is <>;
-   with procedure Swap (Left, Right : Index_Type) is <>;
+      Returns a map with key/element pairs initialized from the values
+      in Source.  If Capacity is 0, then the map capacity is the
+      length of Source; if Capacity is equal to or greater than
+      Source.Length, the map capacity is the value of the Capacity
+      parameter; otherwise, the operation raises Capacity_Error.  If
+      the Modulus argument is 0, then the map modulus is the value
+      returned by a call to Default_Modulus with the map capacity as
+      its argument; otherwise the map modulus is the value of the
+      Modulus parameter.
 
-procedure Ada.Containers.Generic_Sort (First, Last : Index_Type'Base);
-pragma Pure (Ada.Containers.Generic_Sort);
+    * The implementation advice for procedure Move does not apply.
 
-Reorders the elements of an indexable container, over the range First
-.. Last, such that the elements are sorted smallest first as
-determined by the generic formal Less function provided. Generic
-formal Less compares the elements having the given indices, and
-generic formal Swap exchanges the values of the indicated
-elements. Any exception raised during evaluation of Less or Swap is
-propagated.
+    * Map'Write writes only Map.Length elements to the stream.
+      Map'Read reads only Map.Length elements from the stream.
 
-The actual function for the generic formal function Less of
-Generic_Sort is expected to return the same value each time it is
-called with a particular pair of element values. It should define a
-strict weak ordering relationship (see A.18); it should not modify the
-elements. If the actual for Less behaves in some other manner, the
-behavior of Generic_Sort is unspecified. How many times the
-Generic_Sorts calls Less or Swap is unspecified.
 
-Case-Insensitive Operations
+A.18.21 Containers.Bounded_Ordered_Maps
 
-The library function Strings.Hash_Case_Insensitive has the following
-declaration:
+The language-defined generic package Containers.Bounded_Ordered_Maps
+provides a private type Map and a set of operations. It provides the
+same operations as the package Containers.Ordered_Maps (see A.18.6),
+with the difference that the maximum storage is bounded.
 
-with Ada.Containers;
-function Ada.Strings.Hash_Case_Insensitive
-  (Key : String) return Containers.Hash_Type;
-pragma Pure (Ada.Strings.Hash_Case_Insensitive);
+Static Semantics
 
-Returns an implementation-defined value which is a function of the value
-of Key, folded to lower case. If A and B are strings such that A equals
-B, Hash_Case_Insensitive(A) equals Hash_Case_Insensitive(B).
+The declaration of the generic library package
+Containers.Bounded_Ordered_Maps has the same contents and semantics as
+Containers.Ordered_Maps except:
 
+    * pragma Preelaborate is replaced with pragma Pure
 
-The library function Strings.Fixed.Hash_Case_Insensitive has the
-following declaration:
+      AARM implementation note: Package Containers.Bounded_Ordered_Maps
+      cannot depend on package Ada.Finalization (because that package
+      has Preelaborate categorization).
 
-with Ada.Containers, Ada.Strings.Hash_Case_Insensitive;
-function Ada.Strings.Fixed.Hash_Case_Insensitive (Key : String)
-   return Containers.Hash_Type renames Ada.Strings.Hash_Case_Insensitive;
-pragma Pure(Hash_Case_Insensitive);
+    * The type Map is declared with a discriminant that specifies the
+      capacity (maximum number of elements) as follows:
 
+        type Map (Capacity : Count_Type) is tagged private;
 
-The generic library function Strings.Bounded.Hash_Case_Insensitive has
-the following declaration:
+    * The type Map does not need finalization if and only type
+      Key_Type or type Element_Type does not need finalization.
 
-with Ada.Containers;
-generic
-   with package Bounded is
-          new Ada.Strings.Bounded.Generic_Bounded_Length (<>);
-function Ada.Strings.Bounded.Hash_Case_Insensitive
-  (Key : Bounded.Bounded_String) return Containers.Hash_Type;
-pragma Preelaborate(Hash_Case_Insensitive);
+    * In procedure Assign, if Source length is greater than Target
+      capacity, then Capacity_Error is raised.
 
-Strings.Bounded.Hash_Case_Insensitive is equivalent to the function call
-Strings.Hash_Case_Insensitive (Bounded.To_String (Key));
+    * The function Copy is replaced with:
 
+        function Copy (Source   : Map;
+                       Capacity : Count_Type := 0) return Map;
 
-The library function Strings.Unbounded.Hash_Case_Insensitive has the
-following declaration:
+      Returns a map with key/element pairs initialized from the values
+      in Source.  If Capacity is 0, then the map capacity is the
+      length of Source; if Capacity is equal to or greater than
+      Source.Length, the map capacity is the specified value;
+      otherwise, the operation raises Capacity_Error.
 
-with Ada.Containers;
-function Ada.Strings.Unbounded.Hash_Case_Insensitive
-  (Key : Unbounded_String) return Containers.Hash_Type;
-pragma Preelaborate(Hash_Case_Insensitive);
+    * The implementation advice for procedure Move does not apply.
 
-Strings.Unbounded.Hash_Case_Insensitive is equivalent to the function
-call Strings.Hash_Case_Insensitive (To_String (Key));
+    * Map'Write writes only Map.Length elements to the stream.
+      Map'Read reads only Map.Length elements from the stream.
 
 
-The library function Strings.Equal_Case_Insensitive has the following
-declaration:
+A.18.22 Containers.Bounded_Hashed_Sets
 
-function Ada.Strings.Equal_Case_Insensitive
-  (Left, Right : String) return Boolean;
-pragma Pure (Ada.Strings.Equal_Case_Insensitive);
+The language-defined generic package Containers.Bounded_Hashed_Sets
+provides a private type Set and a set of operations. It provides the
+same operations as the package Containers.Hashed_Sets (see A.18.8),
+with the difference that the maximum storage is bounded.
 
-Compares strings Left and Right, folded to lower case, for equality.
+Static Semantics
 
-The library function Strings.Fixed.Equal_Case_Insensitive has the
-following declaration:
+The declaration of the generic library package
+Containers.Bounded_Hashed_Sets has the same contents and semantics as
+Containers.Hashed_Sets except:
 
-with Ada.Containers, Ada.Strings.Equal_Case_Insensitive;
-function Ada.Strings.Fixed.Equal_Case_Insensitive (Key : String)
-   return Boolean renames Ada.Strings.Equal_Case_Insensitive;
-pragma Pure(Equal_Case_Insensitive);
+    * pragma Preelaborate is replaced with pragma Pure
 
+      AARM implementation note: Package Containers.Bounded_Hashed_Sets
+      cannot depend on package Ada.Finalization (because that package
+      has Preelaborate categorization).
 
-The generic library function Strings.Bounded.Equal_Case_Insensitive has
-the following declaration:
+    * The type Set is declared with a discriminant that specifies both
+      the capacity (number of elements) and modulus (number of
+      distinct hash values) of the hash table as follows:
 
-with Ada.Containers;
-generic
-   with package Bounded is
-          new Ada.Strings.Bounded.Generic_Bounded_Length (<>);
-function Ada.Strings.Bounded.Equal_Case_Insensitive
-  (Left, Right : Bounded.Bounded_String) return Boolean;
-pragma Preelaborate(Equal_Case_Insensitive);
+        type Set (Capacity : Count_Type;
+	          Modulus  : Hash_Type) is tagged private;
 
-Strings.Bounded.Equal_Case_Insensitive is equivalent to the function call
-Strings.Equal_Case_Insensitive (Bounded.To_String (Key));
+    * The type Set does not need finalization if and only type
+      Element_Type does not need finalization.
 
+    * The description of Reserve_Capacity is replaced by:
 
-The library function Strings.Unbounded.Equal_Case_Insensitive has the
-following declaration:
+      If the specified Capacity is larger than the Container.Capacity,
+      then Reserve_Capacity raises Capacity_Error.  Otherwise, the
+      operation has no effect.
 
-with Ada.Containers;
-function Ada.Strings.Unbounded.Equal_Case_Insensitive
-  (Left, Right : Unbounded_String) return Boolean;
-pragma Preelaborate(Equal_Case_Insensitive);
+    * The function Copy is replaced with:
 
-Strings.Unbounded.Equal_Case_Insensitive is equivalent to the function
-call Strings.Equal_Case_Insensitive (To_String (Key));
+        function Copy (Source   : Set;
+                       Capacity : Count_Type := 0;
+                       Modulus  : Hash_Type := 0) return Set;
 
+      Returns a set whose elements are initialized from the values in
+      Source.  If Capacity is 0, then the set capacity is the length
+      of Source; if Capacity is equal to or greater than
+      Source.Length, the set capacity is the value of the Capacity
+      parameter; otherwise, the operation raises Capacity_Error.  If
+      the Modulus argument is 0, then the set modulus is the value
+      returned by a call to Default_Modulus with the set capacity as
+      its argument; otherwise the set modulus is the value of the
+      Modulus parameter.
 
-The library function Strings.Less_Case_Insensitive has the following
-declaration:
+    * The implementation advice for procedure Move does not apply.
 
-function Ada.Strings.Less_Case_Insensitive
-  (Left, Right : String) return Boolean;
-pragma Pure (Ada.Strings.Less_Case_Insensitive);
+    * Set'Write writes only Set.Length elements to the stream.
+      Set'Read reads only Set.Length elements from the stream.
 
-Performs a lexicographic comparison of strings Left and Right, folded to
-lower case.
 
+A.18.23 Containers.Bounded_Ordered_Sets
 
-The library function Strings.Fixed.Less_Case_Insensitive has the
-following declaration:
+The language-defined generic package Containers.Bounded_Ordered_Sets
+provides a private type Set and a set of operations. It provides the
+same operations as the package Containers.Ordered_Sets (see A.18.9),
+with the difference that the maximum storage is bounded.
 
-with Ada.Containers, Ada.Strings.Less_Case_Insensitive;
-function Ada.Strings.Fixed.Less_Case_Insensitive (Key : String)
-   return Boolean renames Ada.Strings.Less_Case_Insensitive;
-pragma Pure(Less_Case_Insensitive);
+Static Semantics
 
+The declaration of the generic library package
+Containers.Bounded_Ordered_Sets has the same contents and semantics as
+Containers.Ordered_Sets except:
 
-The generic library function Strings.Bounded.Less_Case_Insensitive has
-the following declaration:
+    * pragma Preelaborate is replaced with pragma Pure
 
-with Ada.Containers;
-generic
-   with package Bounded is
-          new Ada.Strings.Bounded.Generic_Bounded_Length (<>);
-function Ada.Strings.Bounded.Less_Case_Insensitive
-  (Left, Right : Bounded.Bounded_String) return Boolean;
-pragma Preelaborate(Less_Case_Insensitive);
+      AARM implementation note: package Containers.Bounded_Ordered_Sets
+      cannot depend on package Ada.Finalization (because that package
+      has Preelaborate categorization).
 
-Strings.Bounded.Less_Case_Insensitive is equivalent to the function call
-Strings.Less_Case_Insensitive (Bounded.To_String (Key));
+    * The type Set is declared with a discriminant that specifies the
+      capacity (maximum number of elements) as follows:
 
+        type Set (Capacity : Count_Type) is tagged private;
 
-The library function Strings.Unbounded.Less_Case_Insensitive has the
-following declaration:
+    * The type Set does not need finalization if and only type
+      Element_Type does not need finalization.
 
-with Ada.Containers;
-function Ada.Strings.Unbounded.Less_Case_Insensitive
-  (Left, Right : Unbounded_String) return Boolean;
-pragma Preelaborate(Equal_Case_Insensitive);
+    * In procedure Assign, if Source length is greater than Target
+      capacity, then Capacity_Error is raised.
 
-Strings.Unbounded.Less_Case_Insensitive is equivalent to the function
-call Strings.Less_Case_Insensitive (To_String (Key));
+    * The function Copy is replaced with:
+
+        function Copy (Source   : Set;
+                       Capacity : Count_Type := 0) return Set;
+
+      Returns a set whose elements are initialized from the values in
+      Source.  If Capacity is 0, then the set capacity is the length
+      of Source; if Capacity is equal to or greater than
+      Source.Length, the set capacity is the specified value;
+      otherwise, the operation raises Capacity_Error.
+
+    * The implementation advice for procedure Move does not apply.
+
+    * Set'Write writes only Set.Length elements to the stream.
+      Set'Read reads only Set.Length elements from the stream.
 
 !discussion
 
 The forms added were decided at the September subcommittee meeting in New York.
+See also AI05-0069-1 (Indefinite_Holder), AI05-0136-1 (Multiway_Trees), and
+AI05-0159-1 (Queues)
 
 We need to copy some info from the notes from that meeting here to justify
 these choices better.

Questions? Ask the ACAA Technical Agent