Summary table

Abbrv.	Meaning	Abbrv.	Meaning
T	container type eg Map	H_T	Hash_Type
C: T	Container: container type	I_T	Index_Type
P: C	Position: Cursor	K_T	Key_Type
L, R	Left, Right	Ex_Index	Extended_Index
C_T	Count_Type	B	Boolean
E_T	Element_Type

	vectors	lists	hashed maps	ordered maps	hashed sets	ordered sets
generic	Y	Y	Y	Y	Y	Y
type Index_Type is range <>;	Y
type Key_Type is private;			Y	Y
type Element_Type is private;	Y	Y	Y	Y	Y	Y
with function Hash( ... ) return Hash_Type;			on Key		on Element
with function Equivalent_...(L, R: ...) return Boolean;			on Key		on Element
with function "<" (L, R: ... ) return Boolean is <>;				on Key		on Element
with function "=" (L, R: E_T) return B is <>;	Y	Y	Y	Y	Y	Y
package Ada.Containers.... is	Vectors	Doubly_ Linked_ Lists	Hashed_ Maps	Ordered_ Maps	Hashed_ Sets	Ordered_ Sets
pragma Preelaborate( ... );	Y	Y	Y	Y	Y	Y
function Equivalent_...(L, R: ...) return Boolean;				on Key		on Element
subtype Extended_Index ... No_Index: constant Ex_Ind := Ex_Ind'First;	Y
type T is tagged private; pragma Preelaborable_Initialization(T);	Vector	List	Map	Map	Set	Set
type Cursor is private; pragma Preelaborable_Initialization(Cursor);	Y	Y	Y	Y	Y	Y
Empty_T: constant T;	Vector	List	Map	Map	Set	Set
No_Element: constant Cursor;	Y	Y	Y	Y	Y	Y
function "=" (Left, Right: T) return Boolean;	Y	Y	Y	Y	Y	Y
function Equivalent_Sets(L, R: Set) return Boolean; function To_Set(New_Item: E_T) return Set;					Y	Y
function To_Vector(Length: C_T) return Vector; function To_Vector( New_Item: E_T; Length: C_T) return Vector;	Y
function "&" (L, R: Vector) return Vector; function "&" (L: Vector; R: E_T) return Vector; function "&" (L: E_T; R: Vector) return Vector; function "&" (L, R: E_T) return Vector;	Y
function Capacity(C: T) return C_T; procedure Reserve_Capacity( C: T; Capacity: C_T);	Y		Y		Y
function Length(C: T) return Count_Type;	Y	Y	Y	Y	Y	Y
procedure Set_Length( C: in out T; Length: in C_T);	Y
function Is_Empty(C: T) return B; procedure Clear(C: in out T);	Y	Y	Y	Y	Y	Y
function To_Cursor(C: Vector; Index: Ex_Ind) return Cursor; function To_Index(P: C) return Ex_Ind;	Y
function Key(P: C) return K_T;			Y	Y
function Element(P: C) return E_T;	Y also Index	Y	Y	Y	Y	Y
procedure Replace_Element( C: in out T; P: C; New_Item: E_T);	Y also Index	Y	Y	Y	Y	Y
procedure Query_Element(P: C; Process: not null acc proc( ... ) );	in Element also Index	in Element	in Key, in Element	in Key, in Element	in Element	in Element
procedure Update_Element(C: in out T; P: C; Process: not null acc proc( ... ) );	in out Elem also Index	in out Elem	in Key, in out Elem	in Key, in out Elem
procedure Move(Target, Source: in out T);	Y	Y	Y	Y	Y	Y
procedure Insert( C: in out Vector; Before: Ex_Ind; New_Item: Vector); procedure Insert( C: in out Vector; Before: Cursor; New_Item: Vector); procedure Insert( C: in out Vector; Before: Cursor; New_Item: Vector; Position: out Cursor);	Y
procedure Insert( C: in out T; Before: C; New_Item: E_T; Count: C_T := 1);	Y also Index	Y
procedure Insert( C: in out T; Before: C; New_Item: E_T; Position: out Cursor; Count: C_T := 1);	Y	Y
procedure Insert( C: in out T; Before: C; Position: out Cursor; Count: C_T := 1); element has default value	Y also Index	Y
procedure Insert( C: in out T; Key: K_T; New_Item: E_T; Position: out Cursor; Inserted: out B);			Y	Y	Y (no key)	Y (no key)
procedure Insert( C: in out T; Key: K_T; Position: out Cursor; Inserted: out B); element has default value			Y	Y
procedure Insert( C: in out T; Key: K_T; New_Item: E_T);			Y	Y	Y (no key)	Y (no key)
procedure Prepend( C: in out Vector; New_Item: Vector);	Y
procedure Prepend( C: in out T; New_Item: E_T; Count: C_T := 1);	Y	Y
procedure Append( C: in out Vector; New_Item: Vector);	Y
procedure Append( C: in out T; New_Item: E_T; Count: C_T := 1);	Y	Y
procedure Insert_Space( C: in out V; Before: Cursor; Position: out Cursor; Count: C_T := 1);	Y also Index
procedure Include( C: in out T; Key: Key_Type; New_Item: E_T);			Y	Y	Y (no key)	Y (no key)
procedure Replace( C: in out T; Key: Key_Type; New_Item: E_T);			Y	Y	Y (no key)	Y (no key)
procedure Exclude( C: in out T; Key: Key_Type);			Y	Y	Y (Item not key)	Y (item not key)
procedure Delete( C: in out T; P: in out C; Count: C_T := 1);	Y also Index	Y	Y (no count) also Key	Y (no count) also Key	Y (no count) also Element	Y (no count) also Element
procedure Delete_First( C: in out T; Count: C_T := 1); procedure Delete_Last( C: in out T; Count: C_T := 1);	Y	Y		Y (no count)		Y (no count)
procedure Reverse_Elements(C: in out T);	Y	Y
procedure Swap(C: in out T; I, J: Cursor);	Y also Index	Y
procedure Swap_Links( C: in out List; I, J: Cursor);		Y
procedure Splice( Target: in out List; Before: Cursor; Source: in out List); procedure Splice( Target: in out List; Before: Cursor; Source: in out List; Position: in out Cursor); procedure Splice( Container: in out List; Before: Cursor; Position: Cursor);		Y
procedure Union( Target: in out Set; Source: Set); function Union(L, R: Set) return Set; function "or" (L, R: Set) return Set renames Union;					Y	Y
procedure Intersection( Target: in out Set; Source: Set); function Intersection(L, R: Set) return Set; function "and" (L, R: Set) return Set renames Intersection;					Y	Y
procedure Difference( Target: in out Set; Source: Set); function Difference(L, R: Set) return Set; function "–" (L, R: Set) return Set renames Difference;					Y	Y
procedure Symmetric_Difference( Target: in out Set; Source: Set); function Symmetric_Difference (L, R: Set) return Set; function "xor" (L, R: Set) return Set renames Symmetric_Difference;					Y	Y
function Overlap(L, R: Set) return Boolean; function Is_Subset(Subset: Set; Of_Set: Set) return B;					Y	Y
function First_Index(C: T) return Index_Type;	Y
function First(C: T) return Cursor;	Y	Y	Y	Y	Y	Y
function First_Element(C: T) return Element_Type;	Y	Y		Y		Y
function First_Key(C: T) return Key_Type;				Y
function Last_Index(C: T) return Ex_Ind;	Y
function Last(C: T) return Cursor;	Y	Y		Y		Y
function Last_Element(C: T) return Element_Type;	Y	Y		Y		Y
function Last_Key(C: T) return Key_Type;				Y
function Next(P: C) return Cursor; procedure Next(P: in out C);	Y	Y	Y	Y	Y	Y
function Previous(P: C) return Cursor; procedure Previous(P: in out C);	Y	Y		Y		Y
function Find_Index( C: T; Item: E_T; Index: I_T := I_T'First) return Ex_Ind;	Y
function Find(C: T; ... ; P: C := No_Element) return Cursor;	Element	Element	Key (no position)	Key (no position)	Element (no position)	Element (no position)
function Element(C: T; Key: K_T) return E_T;			Y	Y
function Reverse_Find_Index( C: T; Item: E_T; Index: I_T := I_T'First) return Ex_Ind;	Y
function Reverse_Find( C: T; ... ; P: C := No_Element) return Cursor;	Element	Element
function Floor(C: T; ...) return Cursor; function Ceiling(C: T; ...) return Cursor;				Key: K_T		Item: E_T
function Contains(C: T; ...) return Boolean;	Element	Element	Key	Key	Element	Element
function Has_Element(P: C) return Boolean;	Y	Y	Y	Y	Y	Y
function Equivalent_... (L, R: Cursor) return Boolean; function Equivalent_... (L: Cursor; R:...) return Boolean; function Equivalent_... (L:...; R: Cursor) return Boolean;			Keys		Elements
function "<" (L, R: Cursor) return Boolean; function ">" (L, R: Cursor) return Boolean; function "<" (L, Cursor; R: ...) return Boolean; function ">" (L, Cursor; R: ...) return Boolean; function "<" (L:...; R: Cursor) return Boolean; function ">" (L:...; R: Cursor) return Boolean;				Key		Element
procedure Iterate(C: in T; Process: not null acc proc (P: C) );	Y	Y	Y	Y	Y	Y
procedure Reverse_Iterate(C: in T; Process: not null acc proc (P: C) );	Y	Y		Y		Y
generic with function "<" (Left, Right: E_T) return B is <>; package Generic_Sorting is function Is_Sorted(C: T) return Boolean; procedure Sort(C: in out T); procedure Merge(Target, Source: in out T); end Generic_Sorting;	Y	Y
generic type Key_Type (<>) is private;					Y	Y
with function Key(Element: E_T) return Key_Type;					Y	Y
with function Hash(Key: K_T) return Hash_Type;					Y
with function Equivalent_Keys ( L, R: Key_Type) return Boolean;					Y
with function "<" (L, R: Key_Type) return B is <>;						Y
package Generic_Keys is					Y	Y
function Equivalent_Keys(L, R: Key_Type) return B;						Y
function Key(P: C) return Key_Type;					Y	Y
function Element(C: T; Key: K_T) return Element_T;					Y	Y
procedure Replace(C: in out T; Key: Key_Type; New_Item: E_T); procedure Exclude( C: in out T; Key: Key_Type); procedure Delete(C: in out T; Key: Key_Type);					Y	Y
function Find(C: T; Key: K_T) return Cursor;					Y	Y
function Floor(C: T; Key: K_T) return Cursor; function Ceiling(C: T; Key: K_T) return Cursor;						Y
function Contains(C: T; Key: K_T) return Boolean;					Y	Y
procedure Update_Element_Preserving_Key (C: in out T; P: C; Process: not null acc proc ( Element: in out E_T) );					Y	Y
end Generic_Keys;					Y	Y
private ... -- not specified by the language end Ada.Containers....;	Y	Y	Y	Y	Y	Y

Rationale for Ada 2005

8.7 Summary table