[Boost-commit] svn:boost r45499 - sandbox/committee/concepts/stdlib

From: dgregor_at_[hidden]
Date: 2008-05-18 17:26:17

Author: dgregor
Date: 2008-05-18 17:26:16 EDT (Sun, 18 May 2008)
New Revision: 45499
URL: http://svn.boost.org/trac/boost/changeset/45499

Log:
Allocator support for containers
Text files modified: 
   sandbox/committee/concepts/stdlib/clib-containers.tex |  1658 ++++++++++++++++++++------------------- 
   1 files changed, 853 insertions(+), 805 deletions(-)

Modified: sandbox/committee/concepts/stdlib/clib-containers.tex
==============================================================================
--- sandbox/committee/concepts/stdlib/clib-containers.tex	(original)
+++ sandbox/committee/concepts/stdlib/clib-containers.tex	2008-05-18 17:26:16 EDT (Sun, 18 May 2008)
@@ -1169,27 +1169,27 @@
 
 \begin{codeblock}
 namespace std {
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator = allocator<T> > 
+  template <@\changedConcepts{class}{ObjectType}@ T, @\changedConcepts{class}{RandomAccessAllocator}@ Alloc@\removedConcepts{ator}@ = allocator<T> > 
     @\addedConcepts{requires Destructible<T>}@
     class deque;
-  template <@\changedConcepts{class}{EqualityComparable}@ T, class Allocator>
-    bool operator==(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
-    bool operator<(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
-  template <@\changedConcepts{class}{EqualityComparable}@ T, class Allocator>
-    bool operator!=(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
-    bool operator>(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
-    bool operator>=(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
-    bool operator<=(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-    void swap(deque<T,Allocator>& x, deque<T,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-    void swap(deque<T,Allocator>&& x, deque<T,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-    void swap(deque<T,Allocator>& x, deque<T,Allocator>&& y);
+  template <@\changedConcepts{class}{EqualityComparable}@ T, class Alloc@\removedConcepts{ator}@>
+    bool operator==(const deque<T,Alloc@\removedConcepts{ator}@>& x, const deque<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+    bool operator<(const deque<T,Alloc@\removedConcepts{ator}@>& x, const deque<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{EqualityComparable}@ T, class Alloc@\removedConcepts{ator}@>
+    bool operator!=(const deque<T,Alloc@\removedConcepts{ator}@>& x, const deque<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+    bool operator>(const deque<T,Alloc@\removedConcepts{ator}@>& x, const deque<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+    bool operator>=(const deque<T,Alloc@\removedConcepts{ator}@>& x, const deque<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+    bool operator<=(const deque<T,Alloc@\removedConcepts{ator}@>& x, const deque<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+    void swap(deque<T,Alloc@\removedConcepts{ator}@>& x, deque<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+    void swap(deque<T,Alloc@\removedConcepts{ator}@>&& x, deque<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+    void swap(deque<T,Alloc@\removedConcepts{ator}@>& x, deque<T,Alloc@\removedConcepts{ator}@>&& y);
 }
 \end{codeblock}
 
@@ -1198,23 +1198,23 @@
 
 \begin{codeblock}
 namespace std {
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator = allocator<T> > 
+  template <@\changedConcepts{class}{ObjectType}@ T, @\changedConcepts{class}{Allocator}@ Alloc@\removedConcepts{ator}@ = allocator<T> > 
     @\addedConcepts{requires Destructible<T>}@
     class forward_list; 
-  template <@\changedConcepts{class}{EqualityComparable}@ T, class Allocator> 
-    bool operator==(const forward_list<T,Allocator>& x, const forward_list<T,Allocator>& y); 
-  template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator> 
-    bool operator< (const forward_list<T,Allocator>& x, const forward_list<T,Allocator>& y); 
-  template <@\changedConcepts{class}{EqualityComparable}@ T, class Allocator> 
-    bool operator!=(const forward_list<T,Allocator>& x, const forward_list<T,Allocator>& y); 
-  template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator> 
-    bool operator> (const forward_list<T,Allocator>& x, const forward_list<T,Allocator>& y); 
-  template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator> 
-    bool operator>=(const forward_list<T,Allocator>& x, const forward_list<T,Allocator>& y); 
-  template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator> 
-    bool operator<=(const forward_list<T,Allocator>& x, const forward_list<T,Allocator>& y); 
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator> 
-    void swap(forward_list<T,Allocator>& x, forward_list<T,Allocator>& y); 
+  template <@\changedConcepts{class}{EqualityComparable}@ T, class Alloc@\removedConcepts{ator}@> 
+    bool operator==(const forward_list<T,Alloc@\removedConcepts{ator}@>& x, const forward_list<T,Alloc@\removedConcepts{ator}@>& y); 
+  template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@> 
+    bool operator< (const forward_list<T,Alloc@\removedConcepts{ator}@>& x, const forward_list<T,Alloc@\removedConcepts{ator}@>& y); 
+  template <@\changedConcepts{class}{EqualityComparable}@ T, class Alloc@\removedConcepts{ator}@> 
+    bool operator!=(const forward_list<T,Alloc@\removedConcepts{ator}@>& x, const forward_list<T,Alloc@\removedConcepts{ator}@>& y); 
+  template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@> 
+    bool operator> (const forward_list<T,Alloc@\removedConcepts{ator}@>& x, const forward_list<T,Alloc@\removedConcepts{ator}@>& y); 
+  template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@> 
+    bool operator>=(const forward_list<T,Alloc@\removedConcepts{ator}@>& x, const forward_list<T,Alloc@\removedConcepts{ator}@>& y); 
+  template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@> 
+    bool operator<=(const forward_list<T,Alloc@\removedConcepts{ator}@>& x, const forward_list<T,Alloc@\removedConcepts{ator}@>& y); 
+  template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@> 
+    void swap(forward_list<T,Alloc@\removedConcepts{ator}@>& x, forward_list<T,Alloc@\removedConcepts{ator}@>& y); 
 }
 \end{codeblock}
 
@@ -1223,27 +1223,27 @@
 
 \begin{codeblock}
 namespace std {
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator = allocator<T> > 
+  template <@\changedConcepts{class}{ObjectType}@ T, @\changedConcepts{class}{Allocator}@ Alloc@\removedConcepts{ator}@ = allocator<T> > 
     @\addedConcepts{requires Destructible<T>}@
     class list;
-  template <@\changedConcepts{class}{EqualityComparable}@ T, class Allocator>
-    bool operator==(const list<T,Allocator>& x, const list<T,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
-    bool operator< (const list<T,Allocator>& x, const list<T,Allocator>& y);
-  template <@\changedConcepts{class}{EqualityComparable}@ T, class Allocator>
-    bool operator!=(const list<T,Allocator>& x, const list<T,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
-    bool operator> (const list<T,Allocator>& x, const list<T,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
-    bool operator>=(const list<T,Allocator>& x, const list<T,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
-    bool operator<=(const list<T,Allocator>& x, const list<T,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-    void swap(list<T,Allocator>& x, list<T,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-    void swap(list<T,Allocator>&& x, list<T,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-    void swap(list<T,Allocator>& x, list<T,Allocator>&& y);
+  template <@\changedConcepts{class}{EqualityComparable}@ T, class Alloc@\removedConcepts{ator}@>
+    bool operator==(const list<T,Alloc@\removedConcepts{ator}@>& x, const list<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+    bool operator< (const list<T,Alloc@\removedConcepts{ator}@>& x, const list<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{EqualityComparable}@ T, class Alloc@\removedConcepts{ator}@>
+    bool operator!=(const list<T,Alloc@\removedConcepts{ator}@>& x, const list<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+    bool operator> (const list<T,Alloc@\removedConcepts{ator}@>& x, const list<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+    bool operator>=(const list<T,Alloc@\removedConcepts{ator}@>& x, const list<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+    bool operator<=(const list<T,Alloc@\removedConcepts{ator}@>& x, const list<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+    void swap(list<T,Alloc@\removedConcepts{ator}@>& x, list<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+    void swap(list<T,Alloc@\removedConcepts{ator}@>&& x, list<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+    void swap(list<T,Alloc@\removedConcepts{ator}@>& x, list<T,Alloc@\removedConcepts{ator}@>&& y);
 }
 \end{codeblock}
 
@@ -1268,24 +1268,24 @@
     bool operator>=(const queue<T, Cont@\removedConcepts{ainer}@>& x,const queue<T, Cont@\removedConcepts{ainer}@>& y);
   template <class T, @\changedConcepts{class}{LessThanComparable}@ Cont@\removedConcepts{ainer}@>
     bool operator<=(const queue<T, Cont@\removedConcepts{ainer}@>& x,const queue<T, Cont@\removedConcepts{ainer}@>& y);
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-    void swap(queue<T,Allocator>& x, queue<T,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-    void swap(queue<T,Allocator>&& x, queue<T,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-    void swap(queue<T,Allocator>& x, queue<T,Allocator>&& y);
+  template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+    void swap(queue<T,Alloc@\removedConcepts{ator}@>& x, queue<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+    void swap(queue<T,Alloc@\removedConcepts{ator}@>&& x, queue<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+    void swap(queue<T,Alloc@\removedConcepts{ator}@>& x, queue<T,Alloc@\removedConcepts{ator}@>&& y);
 
   template <@\changedConcepts{class}{ObjectType}@ T, @\changedConcepts{class}{BackInsertionSequence}@ Cont@\removedConcepts{ainer}@ = vector<T>,
         @\changedConcepts{class}{Predicate<auto, T, T>}@ Compare = less<typename Cont@\removedConcepts{ainer}@::value_type> >
     @\addedConcepts{requires SameType<Cont::value_type, T> \&\& MutableRandomAccessIterator<Cont::iterator>}@
              @\addedConcepts{\&\& SwappableIterator<Cont::iterator> \&\& CopyConstructible<Compare>}@
   class priority_queue;
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator@\addedConcepts{, Swappable Compare}@>
-    void swap(priority_queue<T,Allocator>& x, priority_queue<T,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator@\addedConcepts{, Swappable Compare}@>
-    void swap(priority_queue<T,Allocator>&& x, priority_queue<T,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator@\addedConcepts{, Swappable Compare}@>
-    void swap(priority_queue<T,Allocator>& x, priority_queue<T,Allocator>&& y);
+  template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@@\addedConcepts{, Swappable Compare}@>
+    void swap(priority_queue<T,Alloc@\removedConcepts{ator}@>& x, priority_queue<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@@\addedConcepts{, Swappable Compare}@>
+    void swap(priority_queue<T,Alloc@\removedConcepts{ator}@>&& x, priority_queue<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@@\addedConcepts{, Swappable Compare}@>
+    void swap(priority_queue<T,Alloc@\removedConcepts{ator}@>& x, priority_queue<T,Alloc@\removedConcepts{ator}@>&& y);
 }
 \end{codeblock}
 
@@ -1309,12 +1309,12 @@
     bool operator>=(const stack<T, Cont@\removedConcepts{ainer}@>& x,const stack<T, Cont@\removedConcepts{ainer}@>& y);
   template <@\changedConcepts{class}{LessThanComparable}@ T, class Cont@\removedConcepts{ainer}@>
     bool operator<=(const stack<T, Cont@\removedConcepts{ainer}@>& x,const stack<T, Cont@\removedConcepts{ainer}@>& y);
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-    void swap(stack<T,Allocator>& x, stack<T,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-    void swap(stack<T,Allocator>&& x, stack<T,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-    void swap(stack<T,Allocator>& x, stack<T,Allocator>&& y);
+  template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+    void swap(stack<T,Alloc@\removedConcepts{ator}@>& x, stack<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+    void swap(stack<T,Alloc@\removedConcepts{ator}@>&& x, stack<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+    void swap(stack<T,Alloc@\removedConcepts{ator}@>& x, stack<T,Alloc@\removedConcepts{ator}@>&& y);
 }
 \end{codeblock}
 
@@ -1323,29 +1323,29 @@
 
 \begin{codeblock}
 namespace std {
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator = allocator<T> > 
+  template <@\changedConcepts{class}{ObjectType}@ T, @\changedConcepts{class}{RandomAccessAllocator}@ Alloc@\removedConcepts{ator}@ = allocator<T> > 
     @\addedConcepts{requires Destructible<T>}@
     class vector;
-  template <@\changedConcepts{class}{EqualityComparable}@ T, class Allocator>
-    bool operator==(const vector<T,Allocator>& x,const vector<T,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
-    bool operator< (const vector<T,Allocator>& x,const vector<T,Allocator>& y);
-  template <@\changedConcepts{class}{EqualityComparable}@ T, class Allocator>
-    bool operator!=(const vector<T,Allocator>& x,const vector<T,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
-    bool operator> (const vector<T,Allocator>& x,const vector<T,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
-    bool operator>=(const vector<T,Allocator>& x,const vector<T,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
-    bool operator<=(const vector<T,Allocator>& x,const vector<T,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-    void swap(vector<T,Allocator>& x, vector<T,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-    void swap(vector<T,Allocator>&& x, vector<T,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-    void swap(vector<T,Allocator>& x, vector<T,Allocator>&& y);
+  template <@\changedConcepts{class}{EqualityComparable}@ T, class Alloc@\removedConcepts{ator}@>
+    bool operator==(const vector<T,Alloc@\removedConcepts{ator}@>& x,const vector<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+    bool operator< (const vector<T,Alloc@\removedConcepts{ator}@>& x,const vector<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{EqualityComparable}@ T, class Alloc@\removedConcepts{ator}@>
+    bool operator!=(const vector<T,Alloc@\removedConcepts{ator}@>& x,const vector<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+    bool operator> (const vector<T,Alloc@\removedConcepts{ator}@>& x,const vector<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+    bool operator>=(const vector<T,Alloc@\removedConcepts{ator}@>& x,const vector<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+    bool operator<=(const vector<T,Alloc@\removedConcepts{ator}@>& x,const vector<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+    void swap(vector<T,Alloc@\removedConcepts{ator}@>& x, vector<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+    void swap(vector<T,Alloc@\removedConcepts{ator}@>&& x, vector<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+    void swap(vector<T,Alloc@\removedConcepts{ator}@>& x, vector<T,Alloc@\removedConcepts{ator}@>&& y);
 
-  template <class Allocator> class vector<bool,Allocator>;
+  template <@\changedConcepts{class}{RandomAccessAllocator}@ Alloc@\removedConcepts{ator}@> class vector<bool,Alloc@\removedConcepts{ator}@>;
 \end{codeblock}
 
 \rSec2[array]{\marktr{}Class template \tcode{array}}
@@ -1606,44 +1606,44 @@
 
 \begin{codeblock}
 namespace std {
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator = allocator<T> >
+  template <@\changedConcepts{class}{ObjectType}@ T, @\changedConcepts{class}{RandomAccessAllocator}@ Alloc@\removedConcepts{ator}@ = allocator<T> >
   @\addedConcepts{requires Destructible<T>}@
   class deque {
   public:
     // types:
-    typedef typename Allocator::reference         reference;
-    typedef typename Allocator::const_reference   const_reference;
+    typedef typename Alloc@\removedConcepts{ator}@::reference         reference;
+    typedef typename Alloc@\removedConcepts{ator}@::const_reference   const_reference;
     typedef @\impdef@                iterator;       // See \ref{container.requirements}
     typedef @\impdef@                const_iterator; // See \ref{container.requirements}
     typedef @\impdef@                size_type;      // See \ref{container.requirements}
     typedef @\impdef@                difference_type;// See \ref{container.requirements}
     typedef T                                     value_type;
-    typedef Allocator                             allocator_type;
-    typedef typename Allocator::pointer           pointer;
-    typedef typename Allocator::const_pointer     const_pointer;
+    typedef Alloc@\removedConcepts{ator}@                             allocator_type;
+    typedef typename Alloc@\removedConcepts{ator}@::pointer           pointer;
+    typedef typename Alloc@\removedConcepts{ator}@::const_pointer     const_pointer;
     typedef std::reverse_iterator<iterator>       reverse_iterator;
     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 
     // \ref{deque.cons} construct/copy/destroy:
-    explicit deque(const Allocator& = Allocator());
+    explicit deque(const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
     @\addedConcepts{requires DefaultConstructible<T>}@ explicit deque(size_type n);
-    @\addedConcepts{requires CopyConstructible<T>}@ deque(size_type n, const T& value,const Allocator& = Allocator());
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ deque(size_type n, const T& value,const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
     template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
       @\addedConcepts{requires HasConstructor<T, Iter::reference>}@ 
-      deque(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last,const Allocator& = Allocator());
-    @\addedConcepts{requires CopyConstructible<T>}@ deque(const deque<T,Allocator>& x);
+      deque(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last,const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ deque(const deque<T,Alloc@\removedConcepts{ator}@>& x);
     deque(deque&&);
-    @\addedConcepts{requires CopyConstructible<T>}@ deque(const deque&, const Allocator&);
-    deque(deque&&, const Allocator&);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ deque(const deque&, const Alloc@\removedConcepts{ator}@&);
+    deque(deque&&, const Alloc@\removedConcepts{ator}@&);
 
    ~deque();
-    @\addedConcepts{requires CopyConstructible<T> \&\& CopyAssignable<T>}@ 
-      deque<T,Allocator>& operator=(const deque<T,Allocator>& x);
-    deque<T,Allocator>& operator=(const deque<T,Allocator>&& x);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&> \&\& CopyAssignable<T>}@ 
+      deque<T,Alloc@\removedConcepts{ator}@>& operator=(const deque<T,Alloc@\removedConcepts{ator}@>& x);
+    deque<T,Alloc@\removedConcepts{ator}@>& operator=(const deque<T,Alloc@\removedConcepts{ator}@>&& x);
     template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
       @\addedConcepts{requires HasConstructor<T, Iter::reference> \&\& CopyAssignable<T, Iter::reference>}@
       void assign(InputIterator first, InputIterator last);
-    @\addedConcepts{requires CopyAssignable<T> \&\& CopyConstructible<T>}@ void assign(size_type n, const T& t);
+    @\addedConcepts{requires CopyAssignable<T> \&\& ConstructibleAsElement<Alloc, T, const T\&>}@ void assign(size_type n, const T& t);
     allocator_type get_allocator() const;
 
     // iterators:
@@ -1666,7 +1666,7 @@
     size_type max_size() const;
     @\addedConcepts{requires DefaultConstructible<T> \&\& MoveAssignable<T>}@ 
       void resize(size_type sz);
-    @\addedConcepts{requires CopyConstructible<T> \&\& MoveAssignable<T>}@    
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&> \&\& MoveAssignable<T>}@    
       void resize(size_type sz, const T& c);
     bool empty() const;
 
@@ -1692,11 +1692,11 @@
       @\addedConcepts{requires HasConstructor<T, Args\&\&...> \&\& MoveAssignable<T>}@ 
       iterator emplace(const_iterator position, Args&&... args);
 
-    @\addedConcepts{requires CopyConstructible<T> \&\& CopyAssignable<T>}@
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&> \&\& CopyAssignable<T>}@
       iterator insert(const_iterator position, const T& x);
-    @\addedConcepts{requires MoveConstructible<T> \&\& MoveAssignable<T>}@
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, T, T\&\&> \&\& MoveAssignable<T>}@
       iterator insert(const_iterator position, T&& x);
-    @\addedConcepts{requires CopyConstructible<T> \&\& CopyAssignable<T>}@
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&> \&\& CopyAssignable<T>}@
       void insert(const_iterator position, size_type n, const T& x);
     template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
       @\addedConcepts{requires HasCopyAssign<T, Iter::reference> \&\& HasConstructor<T, Iter::reference>}@
@@ -1708,41 +1708,41 @@
 
     @\addedConcepts{requires MoveAssignable<T>}@ iterator erase(const_iterator position);
     @\addedConcepts{requires MoveAssignable<T>}@ iterator erase(const_iterator first, const_iterator last);
-    void     swap(deque<T,Allocator>&&);
+    void     swap(deque<T,Alloc@\removedConcepts{ator}@>&&);
     void     clear();
   };
 
-  template <@\changedConcepts{class}{EqualityComparable}@ T, class Allocator>
-    bool operator==(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
-    bool operator< (const deque<T,Allocator>& x, const deque<T,Allocator>& y);
-  template <@\changedConcepts{class}{EqualityComparable}@ T, class Allocator>
-    bool operator!=(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
-    bool operator> (const deque<T,Allocator>& x, const deque<T,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
-    bool operator>=(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
-    bool operator<=(const deque<T,Allocator>& x, const deque<T,Allocator>& y);
+  template <@\changedConcepts{class}{EqualityComparable}@ T, class Alloc@\removedConcepts{ator}@>
+    bool operator==(const deque<T,Alloc@\removedConcepts{ator}@>& x, const deque<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+    bool operator< (const deque<T,Alloc@\removedConcepts{ator}@>& x, const deque<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{EqualityComparable}@ T, class Alloc@\removedConcepts{ator}@>
+    bool operator!=(const deque<T,Alloc@\removedConcepts{ator}@>& x, const deque<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+    bool operator> (const deque<T,Alloc@\removedConcepts{ator}@>& x, const deque<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+    bool operator>=(const deque<T,Alloc@\removedConcepts{ator}@>& x, const deque<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+    bool operator<=(const deque<T,Alloc@\removedConcepts{ator}@>& x, const deque<T,Alloc@\removedConcepts{ator}@>& y);
 
   // specialized algorithms:
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-    void swap(deque<T,Allocator>& x, deque<T,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-    void swap(deque<T,Allocator>&& x, deque<T,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-    void swap(deque<T,Allocator>& x, deque<T,Allocator>&& y);
-
-  template <class T, class Alloc
-    struct constructible_with_allocator_suffix<deque<T, Alloc> >
-      : true_type { };
+  template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+    void swap(deque<T,Alloc@\removedConcepts{ator}@>& x, deque<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+    void swap(deque<T,Alloc@\removedConcepts{ator}@>&& x, deque<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+    void swap(deque<T,Alloc@\removedConcepts{ator}@>& x, deque<T,Alloc@\removedConcepts{ator}@>&& y);
+
+  @\removedConcepts{template <class T, class Alloc}@
+    @\removedConcepts{struct constructible_with_allocator_suffix<deque<T, Alloc> >}@
+      @\removedConcepts{: true_type \{ \};}@
 }
 \end{codeblock}
 
 \rSec3[deque.cons]{\tcode{deque}\ constructors, copy, and assignment}
 
 \begin{itemdecl}
-explicit deque(const Allocator& = Allocator());
+explicit deque(const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -1774,9 +1774,9 @@
 \end{itemdescr}
 
 \begin{itemdecl}
-@\addedConcepts{requires CopyConstructible<T>}@
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@
 deque(size_type @\farg{n}@, const T& @\farg{value}@,
-      const Allocator& = Allocator());
+      const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -1799,7 +1799,7 @@
 template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
   @\addedConcepts{requires HasConstructor<T, Iter::reference>}@
   deque(@\changedConcepts{InputIterator}{Iter}@ @\farg{first}@, @\changedConcepts{InputIterator}{Iter}@ @\farg{last}@,
-        const Allocator& = Allocator());
+        const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -1833,7 +1833,7 @@
 \end{itemdescr}
 
 \begin{itemdecl}
-@\addedConcepts{requires CopyConstructible<T> \&\& CopyAssignable<T>}@
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&> \&\& CopyAssignable<T>}@
 void assign(size_type n, const T& t);
 \end{itemdecl}
 
@@ -1868,7 +1868,7 @@
 
 \index{resize@\tcode{resize}!\tcode{deque}}%
 \begin{itemdecl}
-@\addedConcepts{requires CopyConstructible<T> \&\& MoveAssignable<T>}@ 
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&> \&\& MoveAssignable<T>}@ 
   void resize(size_type sz, const T& c);
 \end{itemdecl}
 
@@ -1896,11 +1896,11 @@
 \index{insert@\tcode{push_back}!\tcode{deque}}%
 \index{insert@\tcode{emplace}!\tcode{deque}}%
 \begin{itemdecl}
-@\addedConcepts{requires CopyConstructible<T> \&\& CopyAssignable<T>}@
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&> \&\& CopyAssignable<T>}@
   iterator insert(const_iterator position, const T& x);
-@\addedConcepts{requires MoveConstructible<T> \&\& MoveAssignable<T>}@
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, T\&\&> \&\& MoveAssignable<T>}@
   iterator insert(const_iterator position, T&& x);
-@\addedConcepts{requires CopyConstructible<T> \&\& CopyAssignable<T>}@
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&> \&\& CopyAssignable<T>}@
   void     insert(const_iterator position, size_type n, const T& x);
 template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
   @\addedConcepts{requires HasCopyAssign<T, Iter::reference> \&\& HasConstructor<T, Iter::reference>}@
@@ -1973,12 +1973,12 @@
 \rSec3[deque.special]{\tcode{deque}\ specialized algorithms}
 
 \begin{itemdecl}
-template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-  void swap(deque<T,Allocator>& x, deque<T,Allocator>& y);
-template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-  void swap(deque<T,Allocator>&& x, deque<T,Allocator>& y);
-template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-  void swap(deque<T,Allocator>& x, deque<T,Allocator>&& y);
+template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+  void swap(deque<T,Alloc@\removedConcepts{ator}@>& x, deque<T,Alloc@\removedConcepts{ator}@>& y);
+template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+  void swap(deque<T,Alloc@\removedConcepts{ator}@>&& x, deque<T,Alloc@\removedConcepts{ator}@>& y);
+template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+  void swap(deque<T,Alloc@\removedConcepts{ator}@>& x, deque<T,Alloc@\removedConcepts{ator}@>&& y);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -1999,42 +1999,42 @@
 
 \begin{codeblock}
 namespace std { 
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator = allocator<T> > 
+  template <@\changedConcepts{class}{ObjectType}@ T, @\changedConcepts{class}{Allocator}@ Alloc@\removedConcepts{ator}@ = allocator<T> > 
   @\addedConcepts{requires Destructible<T>}@
   class forward_list { 
   public: 
     // types: 
-    typedef typename Allocator::reference reference; 
-    typedef typename Allocator::const_reference const_reference; 
+    typedef typename Alloc@\removedConcepts{ator}@::reference reference; 
+    typedef typename Alloc@\removedConcepts{ator}@::const_reference const_reference; 
     typedef @\impdef@ iterator;       // See 23.1 
     typedef @\impdef@ const_iterator; // See 23.1 
     typedef @\impdef@ size_type;      // See 23.1 
     typedef @\impdef@ difference_type;// See 23.1 
     typedef T value_type; 
-    typedef Allocator allocator_type; 
-    typedef typename Allocator::pointer pointer; 
-    typedef typename Allocator::const_pointer const_pointer; 
+    typedef Alloc@\removedConcepts{ator}@ allocator_type; 
+    typedef typename Alloc@\removedConcepts{ator}@::pointer pointer; 
+    typedef typename Alloc@\removedConcepts{ator}@::const_pointer const_pointer; 
 
     // \ref{forwardlist.cons} construct/copy/destroy: 
-    explicit forward_list(const Allocator& = Allocator()); 
+    explicit forward_list(const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@()); 
     @\addedConcepts{requires DefaultConstructible<T>}@ explicit forward_list(size_type n);
-    @\addedConcepts{requires CopyConstructible<T>}@ 
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ 
       forward_list(size_type n, const T& value, 
-                   const Allocator& = Allocator()); 
+                   const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@()); 
     template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
       @\addedConcepts{HasConstructor<T, Iter::reference>}@
       forward_list(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last, 
-                   const Allocator& = Allocator()); 
-    @\addedConcepts{requires CopyConstructible<T>}@ forward_list(const forward_list<T,Allocator>& x);
-    forward_list(forward_list<T,Allocator>&& x);
+                   const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@()); 
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ forward_list(const forward_list<T,Alloc@\removedConcepts{ator}@>& x);
+    forward_list(forward_list<T,Alloc@\removedConcepts{ator}@>&& x);
     ~forward_list(); 
     @\addedConcepts{requires CopyAssignable<T>}@ 
-      forward_list<T,Allocator>& operator=(const forward_list<T,Allocator>& x);
-    forward_list<T,Allocator>& operator=(forward_list<T,Allocator>&& x); 
+      forward_list<T,Alloc@\removedConcepts{ator}@>& operator=(const forward_list<T,Alloc@\removedConcepts{ator}@>& x);
+    forward_list<T,Alloc@\removedConcepts{ator}@>& operator=(forward_list<T,Alloc@\removedConcepts{ator}@>&& x); 
     template <@\changedConcepts{class InputIterator}{InputIterator Iter}@> 
       @\addedConcepts{requires HasConstructor<T, Iter::reference>}@
       void assign(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last); 
-    @\addedConcepts{CopyConstructible<T>}@ void assign(size_type n, const T& t); 
+    @\addedConcepts{ConstructibleAsElement<Alloc, T, const T\&>}@ void assign(size_type n, const T& t); 
     allocator_type get_allocator() const; 
 
     // \ref{forwardlist.iter} iterators:
@@ -2066,10 +2066,10 @@
     template <class... Args> 
       @\addedConcepts{requires HasConstructor<T, Args\&\&...>}@ 
       iterator emplace_after(const_iterator position, Args&&... args);
-    @\addedConcepts{requires CopyConstructible<T>}@ iterator insert_after(const_iterator position, const T& x);
-    @\addedConcepts{requires MoveConstructible<T>}@ iterator insert_after(const_iterator position, T&& x);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ iterator insert_after(const_iterator position, const T& x);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, T, T\&\&>}@ iterator insert_after(const_iterator position, T&& x);
 
-    @\addedConcepts{requires CopyConstructible<T>}@ 
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ 
       void insert_after(const_iterator position, size_type n, const T& x); 
     template <@\changedConcepts{class InputIterator}{InputIterator Iter}@> 
       @\addedConcepts{requires HasConstructor<T, Iter::reference>}@
@@ -2077,17 +2077,17 @@
 
     iterator erase_after(const_iterator position); 
     iterator erase_after(const_iterator position, iterator last); 
-    void swap(forward_list<T,Allocator>&&);
+    void swap(forward_list<T,Alloc@\removedConcepts{ator}@>&&);
 
     @\addedConcepts{requires DefaultConstructible<T>}@ void resize(size_type sz);
-    @\addedConcepts{requires CopyConstructible<T>}@ void resize(size_type sz, value_type c);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ void resize(size_type sz, value_type c);
     void clear(); 
 
     // \ref{forwardlist.ops} forward_list operations: 
-    void splice_after(const_iterator position, forward_list<T,Allocator>&& x); 
-    void splice_after(const_iterator position, forward_list<T,Allocator>&& x,
+    void splice_after(const_iterator position, forward_list<T,Alloc@\removedConcepts{ator}@>&& x); 
+    void splice_after(const_iterator position, forward_list<T,Alloc@\removedConcepts{ator}@>&& x,
                       const_iterator i); 
-    void splice_after(const_iterator position, forward_list<T,Allocator>&& x,
+    void splice_after(const_iterator position, forward_list<T,Alloc@\removedConcepts{ator}@>&& x,
                       const_iterator first, const_iterator last); 
 
     @\addedConcepts{requires EqualityComparable<T>}@ void remove(const T& value); 
@@ -2097,9 +2097,9 @@
     template <@\changedConcepts{class}{Predicate<auto, T, T>}@ BinaryPredicate>
       void unique(BinaryPredicate binary_pred); 
 
-    @\addedConcepts{requires LessThanComparable<T>}@ void merge(forward_list<T,Allocator>&& x); 
+    @\addedConcepts{requires LessThanComparable<T>}@ void merge(forward_list<T,Alloc@\removedConcepts{ator}@>&& x); 
     template <@\changedConcepts{class}{Predicate<auto, T, T>}@ Compare> 
-      void merge(forward_list<T,Allocator>&& x, Compare comp);
+      void merge(forward_list<T,Alloc@\removedConcepts{ator}@>&& x, Compare comp);
 
     @\addedConcepts{requires LessThanComparable<T>}@ void sort(); 
     template <@\changedConcepts{class}{Predicate<auto, T, T>}@ Compare> void sort(Compare comp); 
@@ -2108,33 +2108,33 @@
   }; 
 
   // Comparison operators
-  template <@\changedConcepts{class}{EqualityComparable}@ T, class Allocator> 
-    bool operator==(const forward_list<T,Allocator>& x, const forward_list<T,Allocator>& y); 
-  template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator> 
-    bool operator< (const forward_list<T,Allocator>& x, const forward_list<T,Allocator>& y); 
-  template <@\changedConcepts{class}{EqualityComparable}@ T, class Allocator> 
-    bool operator!=(const forward_list<T,Allocator>& x, const forward_list<T,Allocator>& y); 
-  template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator> 
-    bool operator> (const forward_list<T,Allocator>& x, const forward_list<T,Allocator>& y); 
-  template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator> 
-    bool operator>=(const forward_list<T,Allocator>& x, const forward_list<T,Allocator>& y); 
-  template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator> 
-    bool operator<=(const forward_list<T,Allocator>& x, const forward_list<T,Allocator>& y); 
+  template <@\changedConcepts{class}{EqualityComparable}@ T, class Alloc@\removedConcepts{ator}@> 
+    bool operator==(const forward_list<T,Alloc@\removedConcepts{ator}@>& x, const forward_list<T,Alloc@\removedConcepts{ator}@>& y); 
+  template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@> 
+    bool operator< (const forward_list<T,Alloc@\removedConcepts{ator}@>& x, const forward_list<T,Alloc@\removedConcepts{ator}@>& y); 
+  template <@\changedConcepts{class}{EqualityComparable}@ T, class Alloc@\removedConcepts{ator}@> 
+    bool operator!=(const forward_list<T,Alloc@\removedConcepts{ator}@>& x, const forward_list<T,Alloc@\removedConcepts{ator}@>& y); 
+  template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@> 
+    bool operator> (const forward_list<T,Alloc@\removedConcepts{ator}@>& x, const forward_list<T,Alloc@\removedConcepts{ator}@>& y); 
+  template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@> 
+    bool operator>=(const forward_list<T,Alloc@\removedConcepts{ator}@>& x, const forward_list<T,Alloc@\removedConcepts{ator}@>& y); 
+  template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@> 
+    bool operator<=(const forward_list<T,Alloc@\removedConcepts{ator}@>& x, const forward_list<T,Alloc@\removedConcepts{ator}@>& y); 
 
   // \ref{forwardlist.spec} specialized algorithms: 
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator> 
-    void swap(forward_list<T,Allocator>& x, forward_list<T,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator> 
-    void swap(forward_list<T,Allocator>&& x, forward_list<T,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator> 
-    void swap(forward_list<T,Allocator>& x, forward_list<T,Allocator>&& y); 
+  template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@> 
+    void swap(forward_list<T,Alloc@\removedConcepts{ator}@>& x, forward_list<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@> 
+    void swap(forward_list<T,Alloc@\removedConcepts{ator}@>&& x, forward_list<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@> 
+    void swap(forward_list<T,Alloc@\removedConcepts{ator}@>& x, forward_list<T,Alloc@\removedConcepts{ator}@>&& y); 
 }
 \end{codeblock}
 
 \rSec3[forwardlist.cons]{\tcode{forward_list} constructors, copy, assignment}
 
 \begin{itemdecl}
-explicit forward_list(const Allocator& = Allocator());
+explicit forward_list(const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2161,8 +2161,8 @@
 \end{itemdescr}
 
 \begin{itemdecl}
-@\addedConcepts{requires CopyConstructible<T>}@ 
-  forward_list(size_type n, const T& value, const Allocator& = Allocator());
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ 
+  forward_list(size_type n, const T& value, const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2180,7 +2180,7 @@
 template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
   @\addedConcepts{HasConstructor<T, Iter::reference>}@
   forward_list(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last, 
-               const Allocator& = Allocator()); 
+               const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@()); 
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2203,7 +2203,7 @@
 \end{itemdescr}
 
 \begin{itemdecl}
-@\addedConcepts{CopyConstructible<T>}@ void assign(size_type n, const T\& t);
+@\addedConcepts{ConstructibleAsElement<Alloc, T, const T\&>}@ void assign(size_type n, const T\& t);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2263,8 +2263,8 @@
 \end{itemdescr}
 
 \begin{itemdecl}
-@\addedConcepts{requires CopyConstructible<T>}@ iterator insert_after(const_iterator position, const T& x);
-@\addedConcepts{requires MoveConstructible<T>}@ iterator insert_after(const_iterator position, T&& x);
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ iterator insert_after(const_iterator position, const T& x);
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, T\&\&>}@ iterator insert_after(const_iterator position, T&& x);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2279,7 +2279,7 @@
 \end{itemdescr}
 
 \begin{itemdecl}
-@\addedConcepts{requires CopyConstructible<T>}@ 
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ 
   void insert_after(const_iterator position, size_type n, const T& x);
 \end{itemdecl}
 
@@ -2351,7 +2351,7 @@
 
 \begin{itemdecl}
 @\addedConcepts{requires DefaultConstructible<T>}@ void resize(size_type sz);
-@\addedConcepts{requires CopyConstructible<T>}@ void resize(size_type sz, value_type c);
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ void resize(size_type sz, value_type c);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2371,7 +2371,7 @@
 \rSec3[forwardlist.ops]{\tcode{forward_list} operations}
 
 \begin{itemdecl}
-void splice_after(const_iterator position, forward_list<T,Allocator>&& x);
+void splice_after(const_iterator position, forward_list<T,Alloc@\removedConcepts{ator}@>&& x);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2389,7 +2389,7 @@
 \end{itemdescr}
 
 \begin{itemdecl}
-void splice_after(const_iterator position, forward_list<T,Allocator>&& x, const_iterator i);
+void splice_after(const_iterator position, forward_list<T,Alloc@\removedConcepts{ator}@>&& x, const_iterator i);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2407,7 +2407,7 @@
 \end{itemdescr}
 
 \begin{itemdecl}
-void splice_after(const_iterator position, forward_list<T,Allocator>&& x, const_iterator first, const_iterator last);
+void splice_after(const_iterator position, forward_list<T,Alloc@\removedConcepts{ator}@>&& x, const_iterator first, const_iterator last);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2452,9 +2452,9 @@
 \end{itemdescr}
 
 \begin{itemdecl}
-@\addedConcepts{requires LessThanComparable<T>}@ void merge(forward_list<T,Allocator>&& x);
+@\addedConcepts{requires LessThanComparable<T>}@ void merge(forward_list<T,Alloc@\removedConcepts{ator}@>&& x);
 template <@\changedConcepts{class}{Predicate<auto, T, T>}@ Compare> 
-  void merge(forward_list<T,Allocator>&& x, Compare comp)
+  void merge(forward_list<T,Alloc@\removedConcepts{ator}@>&& x, Compare comp)
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2502,12 +2502,12 @@
 \rSec3[forwardlist.spec]{\tcode{forward_list} specialized algorithms}
 
 \begin{itemdecl}
-template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-  void swap(forward_list<T,Allocator>& x, forward_list<T,Allocator>& y);
-template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-  void swap(forward_list<T,Allocator>&& x, forward_list<T,Allocator>& y);
-template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-  void swap(forward_list<T,Allocator>& x, forward_list<T,Allocator>&& y);
+template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+  void swap(forward_list<T,Alloc@\removedConcepts{ator}@>& x, forward_list<T,Alloc@\removedConcepts{ator}@>& y);
+template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+  void swap(forward_list<T,Alloc@\removedConcepts{ator}@>&& x, forward_list<T,Alloc@\removedConcepts{ator}@>& y);
+template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+  void swap(forward_list<T,Alloc@\removedConcepts{ator}@>& x, forward_list<T,Alloc@\removedConcepts{ator}@>&& y);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2550,43 +2550,43 @@
 
 \begin{codeblock}
 namespace std {
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator = allocator<T> >
+  template <@\changedConcepts{class}{ObjectType}@ T, @\changedConcepts{class}{Allocator}@ Alloc@\removedConcepts{ator}@ = allocator<T> >
   @\addedConcepts{requires Destructible<T>}@
   class list {
   public:
     // types:
-    typedef typename Allocator::reference         reference;
-    typedef typename Allocator::const_reference   const_reference;
+    typedef typename Alloc@\removedConcepts{ator}@::reference         reference;
+    typedef typename Alloc@\removedConcepts{ator}@::const_reference   const_reference;
     typedef @\impdef@                iterator;       // See \ref{container.requirements}
     typedef @\impdef@                const_iterator; // See \ref{container.requirements}
     typedef @\impdef@                size_type;      // See \ref{container.requirements}
     typedef @\impdef@                difference_type;// See \ref{container.requirements}
     typedef T                                     value_type;
-    typedef Allocator                             allocator_type;
-    typedef typename Allocator::pointer           pointer;
-    typedef typename Allocator::const_pointer     const_pointer;
+    typedef Alloc@\removedConcepts{ator}@                             allocator_type;
+    typedef typename Alloc@\removedConcepts{ator}@::pointer           pointer;
+    typedef typename Alloc@\removedConcepts{ator}@::const_pointer     const_pointer;
     typedef std::reverse_iterator<iterator>       reverse_iterator;
     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 
     // \ref{list.cons} construct/copy/destroy:
-    explicit list(const Allocator& = Allocator());
+    explicit list(const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
     @\addedConcepts{requires DefaultConstructible<T>}@ explicit list(size_type n);
-    @\addedConcepts{requires CopyConstructible<T>}@ 
-      list(size_type @\farg{n}@, const T& @\farg{value}@, const Allocator& = Allocator());
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ 
+      list(size_type @\farg{n}@, const T& @\farg{value}@, const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
     template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
       @\addedConcepts{requires HasConstructor<T, Iter::reference>}@
-      list(@\changedConcepts{InputIterator}{Iter}@ @\farg{first}@, @\changedConcepts{InputIterator}{Iter}@ @\farg{last}@, const Allocator& = Allocator());
-    @\addedConcepts{requires CopyConstructible<T>}@ list(const list<T,Allocator>& @\farg{x}@);
+      list(@\changedConcepts{InputIterator}{Iter}@ @\farg{first}@, @\changedConcepts{InputIterator}{Iter}@ @\farg{last}@, const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ list(const list<T,Alloc@\removedConcepts{ator}@>& @\farg{x}@);
     list(list&& x);
-    @\addedConcepts{requires CopyConstructible<T>}@ list(const list&, const Allocator&);
-    list(list&&, const Allocator&);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ list(const list&, const Alloc@\removedConcepts{ator}@&);
+    list(list&&, const Alloc@\removedConcepts{ator}@&);
    ~list();
-    @\addedConcepts{requires CopyAssignable<T>}@ list<T,Allocator>& operator=(const list<T,Allocator>& @\farg{x}@);
-    list<T,Allocator>& operator=(list<T,Allocator>&& x);
+    @\addedConcepts{requires CopyAssignable<T>}@ list<T,Alloc@\removedConcepts{ator}@>& operator=(const list<T,Alloc@\removedConcepts{ator}@>& @\farg{x}@);
+    list<T,Alloc@\removedConcepts{ator}@>& operator=(list<T,Alloc@\removedConcepts{ator}@>&& x);
     template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
       @\addedConcepts{requires HasCopyAssign<T, Iter::reference> \&\& HasConstructor<T, Iter::reference>}@
       void assign(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last);
-    @\addedConcepts{requires CopyAssignable<T> \&\& CopyConstructible<T>}@ void assign(size_type n, const T& t);
+    @\addedConcepts{requires CopyAssignable<T> \&\& ConstructibleAsElement<Alloc, T, const T\&>}@ void assign(size_type n, const T& t);
     allocator_type get_allocator() const;
 
     // iterators:
@@ -2609,7 +2609,7 @@
     size_type size() const;
     size_type max_size() const;
     @\addedConcepts{requires DefaultConstructible<T>}@ void resize(size_type sz);
-    @\addedConcepts{requires CopyConstructible<T>}@ void resize(size_type sz, const T& c);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ void resize(size_type sz, const T& c);
 
     // element access:
     reference       front();
@@ -2630,9 +2630,9 @@
     template <class... Args> 
       @\addedConcepts{requires HasConstructor<T, Args\&\&...>}@
       iterator emplace(const_iterator position, Args&&... args);
-    @\addedConcepts{requires CopyConstructible<T>}@ iterator insert(const_iterator @\farg{position}@, const T& @\farg{x}@);
-    @\addedConcepts{requires MoveConstructible<T>}@ iterator insert(const_iterator position, T&& x);
-    @\addedConcepts{requires CopyConstructible<T>}@ 
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ iterator insert(const_iterator @\farg{position}@, const T& @\farg{x}@);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, T, T\&\&>}@ iterator insert(const_iterator position, T&& x);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ 
       void insert(const_iterator @\farg{position}@, size_type @\farg{n}@, const T& @\farg{x}@);
     template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
       @\addedConcepts{requires HasConstructor<T, Iter::reference>}@
@@ -2641,13 +2641,13 @@
 
     iterator erase(const_iterator @\farg{position}@);
     iterator erase(const_iterator @\farg{position}@, const_iterator @\farg{last}@);
-    void     swap(list<T,Allocator>&&);
+    void     swap(list<T,Alloc@\removedConcepts{ator}@>&&);
     void     clear();
 
     // \ref{list.ops} list operations:
-    void splice(const_iterator @\farg{position}@, list<T,Allocator>&& @\farg{x}@);
-    void splice(const_iterator @\farg{position}@, list<T,Allocator>&& @\farg{x}@, const_iterator @\farg{i}@);
-    void splice(const_iterator @\farg{position}@, list<T,Allocator>&& @\farg{x}@,
+    void splice(const_iterator @\farg{position}@, list<T,Alloc@\removedConcepts{ator}@>&& @\farg{x}@);
+    void splice(const_iterator @\farg{position}@, list<T,Alloc@\removedConcepts{ator}@>&& @\farg{x}@, const_iterator @\farg{i}@);
+    void splice(const_iterator @\farg{position}@, list<T,Alloc@\removedConcepts{ator}@>&& @\farg{x}@,
                 const_iterator @\farg{first}@, const_iterator @\farg{last}@);
 
     @\addedConcepts{requires EqualityComparable<T>}@ void remove(const T& @\farg{value}@);
@@ -2657,9 +2657,9 @@
     template <@\changedConcepts{class}{Predicate<auto, T, T>}@ BinaryPredicate>
       void unique(BinaryPredicate @\farg{binary_pred}@);
 
-    @\addedConcepts{requires LessThanComparable<T>}@ void merge(list<T,Allocator>&& @\farg{x}@);
+    @\addedConcepts{requires LessThanComparable<T>}@ void merge(list<T,Alloc@\removedConcepts{ator}@>&& @\farg{x}@);
     template <@\changedConcepts{class}{BinaryPredicate<auto, T, T>}@ Compare> 
-      void merge(list<T,Allocator>&& @\farg{x}@, Compare @\farg{comp}@);
+      void merge(list<T,Alloc@\removedConcepts{ator}@>&& @\farg{x}@, Compare @\farg{comp}@);
 
     @\addedConcepts{requires LessThanComparable<T>}@ void sort();
     template <@\changedConcepts{class}{BinaryPredicate<auto, T, T>}@ Compare> void sort(Compare @\farg{comp}@);
@@ -2667,37 +2667,37 @@
     void reverse();
   };
 
-  template <@\changedConcepts{class}{EqualityComparable}@ T, class Allocator>
-    bool operator==(const list<T,Allocator>& @\farg{x}@, const list<T,Allocator>& @\farg{y}@);
-  template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
-    bool operator< (const list<T,Allocator>& @\farg{x}@, const list<T,Allocator>& @\farg{y}@);
-  template <@\changedConcepts{class}{EqualityComparable}@ T, class Allocator>
-    bool operator!=(const list<T,Allocator>& @\farg{x}@, const list<T,Allocator>& @\farg{y}@);
-  template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
-    bool operator> (const list<T,Allocator>& @\farg{x}@, const list<T,Allocator>& @\farg{y}@);
-  template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
-    bool operator>=(const list<T,Allocator>& @\farg{x}@, const list<T,Allocator>& @\farg{y}@);
-  template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
-    bool operator<=(const list<T,Allocator>& @\farg{x}@, const list<T,Allocator>& @\farg{y}@);
+  template <@\changedConcepts{class}{EqualityComparable}@ T, class Alloc@\removedConcepts{ator}@>
+    bool operator==(const list<T,Alloc@\removedConcepts{ator}@>& @\farg{x}@, const list<T,Alloc@\removedConcepts{ator}@>& @\farg{y}@);
+  template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+    bool operator< (const list<T,Alloc@\removedConcepts{ator}@>& @\farg{x}@, const list<T,Alloc@\removedConcepts{ator}@>& @\farg{y}@);
+  template <@\changedConcepts{class}{EqualityComparable}@ T, class Alloc@\removedConcepts{ator}@>
+    bool operator!=(const list<T,Alloc@\removedConcepts{ator}@>& @\farg{x}@, const list<T,Alloc@\removedConcepts{ator}@>& @\farg{y}@);
+  template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+    bool operator> (const list<T,Alloc@\removedConcepts{ator}@>& @\farg{x}@, const list<T,Alloc@\removedConcepts{ator}@>& @\farg{y}@);
+  template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+    bool operator>=(const list<T,Alloc@\removedConcepts{ator}@>& @\farg{x}@, const list<T,Alloc@\removedConcepts{ator}@>& @\farg{y}@);
+  template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+    bool operator<=(const list<T,Alloc@\removedConcepts{ator}@>& @\farg{x}@, const list<T,Alloc@\removedConcepts{ator}@>& @\farg{y}@);
 
   // specialized algorithms:
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-    void swap(list<T,Allocator>& x, list<T,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-    void swap(list<T,Allocator>&& x, list<T,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-    void swap(list<T,Allocator>& x, list<T,Allocator>&& y);
-
-  template <class T, class Alloc>
-    struct constructible_with_allocator_suffix<list<T, Alloc> >
-      : true_type { };
+  template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+    void swap(list<T,Alloc@\removedConcepts{ator}@>& x, list<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+    void swap(list<T,Alloc@\removedConcepts{ator}@>&& x, list<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+    void swap(list<T,Alloc@\removedConcepts{ator}@>& x, list<T,Alloc@\removedConcepts{ator}@>&& y);
+
+  @\removedConcepts{template <class T, class Alloc>}@
+    @\removedConcepts{struct constructible_with_allocator_suffix<list<T, Alloc> >}@
+      @\removedConcepts{: true_type \{ \};}@
 }
 \end{codeblock}
 
 \rSec3[list.cons]{\tcode{list}\ constructors, copy, and assignment}
 
 \begin{itemdecl}
-explicit list(const Allocator& = Allocator());
+explicit list(const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2729,9 +2729,9 @@
 \end{itemdescr}
 
 \begin{itemdecl}
-@\addedConcepts{requires CopyConstructible<T>}@
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@
   list(size_type @\farg{n}@, const T& @\farg{value}@,
-                const Allocator& = Allocator());
+                const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2757,7 +2757,7 @@
 \begin{itemdecl}
 template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
   @\addedConcepts{requires HasConstructor<T, Iter::reference>}@
-  list(@\changedConcepts{InputIterator}{Iter}@ @\farg{first}@, @\changedConcepts{InputIterator}{Iter}@ @\farg{last}@, const Allocator& = Allocator());
+  list(@\changedConcepts{InputIterator}{Iter}@ @\farg{first}@, @\changedConcepts{InputIterator}{Iter}@ @\farg{last}@, const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2795,7 +2795,7 @@
 \end{itemdescr}
 
 \begin{itemdecl}
-@\addedConcepts{requires CopyAssignable<T> \&\& CopyConstructible<T>}@ void assign(size_type n, const T& t);
+@\addedConcepts{requires CopyAssignable<T> \&\& ConstructibleAsElement<Alloc, T, const T\&>}@ void assign(size_type n, const T& t);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2827,7 +2827,7 @@
 
 \index{resize@\tcode{resize}!\tcode{list}}%
 \begin{itemdecl}
-@\addedConcepts{requires CopyConstructible<T>}@ void resize(size_type sz, const T& c);
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ void resize(size_type sz, const T& c);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2853,9 +2853,9 @@
 
 \index{insert@\tcode{insert}!\tcode{list}}%
 \begin{itemdecl}
-@\addedConcepts{requires CopyConstructible<T>}@ iterator insert(const_iterator position, const T& x);
-@\addedConcepts{requires MoveConstructible<T>}@ iterator insert(const_iterator position, T&& x);
-@\addedConcepts{requires CopyConstructible<T>}@ 
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ iterator insert(const_iterator position, const T& x);
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, T\&\&>}@ iterator insert(const_iterator position, T&& x);
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ 
   void insert(const_iterator @\farg{position}@, size_type @\farg{n}@, const T& @\farg{x}@);
 template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
   @\addedConcepts{requires HasConstructor<T, Iter::reference>}@
@@ -2933,7 +2933,7 @@
 
 \index{splice@\tcode{splice}!\tcode{list}}%
 \begin{itemdecl}
-void splice(const_iterator @\farg{position}@, list<T,Allocator>&& @\farg{x}@);
+void splice(const_iterator @\farg{position}@, list<T,Alloc@\removedConcepts{ator}@>&& @\farg{x}@);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2970,7 +2970,7 @@
 \end{itemdescr}
 
 \begin{itemdecl}
-void splice(const_iterator @\farg{position}@, list<T,Allocator>&& @\farg{x}@, iterator @\farg{i}@);
+void splice(const_iterator @\farg{position}@, list<T,Alloc@\removedConcepts{ator}@>&& @\farg{x}@, iterator @\farg{i}@);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -3016,7 +3016,7 @@
 \end{itemdescr}
 
 \begin{itemdecl}
-void splice(const_iterator @\farg{position}@, list<T,Allocator>&& @\farg{x}@, iterator @\farg{first}@,
+void splice(const_iterator @\farg{position}@, list<T,Alloc@\removedConcepts{ator}@>&& @\farg{x}@, iterator @\farg{first}@,
             iterator @\farg{last}@);
 \end{itemdecl}
 
@@ -3137,8 +3137,8 @@
 
 \index{merge@\tcode{merge}!\tcode{list}}%
 \begin{itemdecl}
-@\addedConcepts{requires LessThanComparable<T>}@ void merge(list<T,Allocator>&& @\farg{x}@);
-template <@\changedConcepts{class}{Predicate<auto, T, T>}@ Compare> void merge(list<T,Allocator>&& @\farg{x}@, Compare @\farg{comp}@);
+@\addedConcepts{requires LessThanComparable<T>}@ void merge(list<T,Alloc@\removedConcepts{ator}@>&& @\farg{x}@);
+template <@\changedConcepts{class}{Predicate<auto, T, T>}@ Compare> void merge(list<T,Alloc@\removedConcepts{ator}@>&& @\farg{x}@, Compare @\farg{comp}@);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -3237,12 +3237,12 @@
 \rSec3[list.special]{\tcode{list}\ specialized algorithms}
 
 \begin{itemdecl}
-template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-  void swap(list<T,Allocator>& x, list<T,Allocator>& y);
-template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-  void swap(list<T,Allocator>&& x, list<T,Allocator>& y);
-template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-  void swap(list<T,Allocator>& x, list<T,Allocator>&& y);
+template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+  void swap(list<T,Alloc@\removedConcepts{ator}@>& x, list<T,Alloc@\removedConcepts{ator}@>& y);
+template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+  void swap(list<T,Alloc@\removedConcepts{ator}@>&& x, list<T,Alloc@\removedConcepts{ator}@>& y);
+template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+  void swap(list<T,Alloc@\removedConcepts{ator}@>& x, list<T,Alloc@\removedConcepts{ator}@>&& y);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -3471,9 +3471,9 @@
     struct uses_allocator<queue<T, Container>, Alloc>
       : uses_allocator<Container, Alloc>::type { };
 
-  template <class T, class Container>
-    struct constructible_with_allocator_suffix<queue<T, Container> >
-      : true_type { };
+  @\removedConcepts{template <class T, class Container>}@
+    @\removedConcepts{struct constructible_with_allocator_suffix<queue<T, Container> >}@
+      @\removedConcepts{: true_type \{ \};}@
 }
 \end{codeblock}
 
@@ -3665,10 +3665,10 @@
     struct uses_allocator<priority_queue<T, Cont@\removedConcepts{ainer}@, Compare>, Alloc>
       : uses_allocator<Cont@\removedConcepts{ainer}@, Alloc>::type { };
 
-  template <class T, class Cont@\removedConcepts{ainer}@, class Compare>
-    struct constructible_with_allocator_suffix<
-      priority_queue<T, Cont@\removedConcepts{ainer}@, Compare> >
-      : true_type { };
+  @\removedConcepts{template <class T, class Container, class Compare>}@
+    @\removedConcepts{struct constructible_with_allocator_suffix<}@
+      @\removedConcepts{priority_queue<T, Container, Compare> >}@
+      @\removedConcepts{: true_type \{ \};}@
 }
 \end{codeblock}
 
@@ -3864,20 +3864,20 @@
     bool operator>=(const stack<T, Cont@\removedConcepts{ainer}@>& x, const stack<T, Cont@\removedConcepts{ainer}@>& y);
   template <@\changedConcepts{class}{LessThanComparable}@ T, class Cont@\removedConcepts{ainer}@>
     bool operator<=(const stack<T, Cont@\removedConcepts{ainer}@>& x, const stack<T, Cont@\removedConcepts{ainer}@>& y);
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-    void swap(stack<T,Allocator>& x, stack<T,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-    void swap(stack<T,Allocator>&& x, stack<T,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-    void swap(stack<T,Allocator>& x, stack<T,Allocator>&& y);
+  template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+    void swap(stack<T,Alloc@\removedConcepts{ator}@>& x, stack<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+    void swap(stack<T,Alloc@\removedConcepts{ator}@>&& x, stack<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+    void swap(stack<T,Alloc@\removedConcepts{ator}@>& x, stack<T,Alloc@\removedConcepts{ator}@>&& y);
 
   template <class T, class Cont@\removedConcepts{ainer}@, class Alloc>
     struct uses_allocator<stack<T, Cont@\removedConcepts{ainer}@>, Alloc>
       : uses_allocator<Cont@\removedConcepts{ainer}@, Alloc>::type { };
 
-  template <class T, class Cont@\removedConcepts{ainer}@>
-    struct constructible_with_allocator_suffix<stack<T, Cont@\removedConcepts{ainer}@> >
-      : true_type { };
+  @\removedConcepts{template <class T, class Container>}@
+    @\removedConcepts{struct constructible_with_allocator_suffix<stack<T, Container> >}@
+      @\removedConcepts{: true_type \{ \};}@
 }
 \end{codeblock}
 
@@ -3992,7 +3992,7 @@
 The elements of a vector are stored contiguously, meaning that if
 \tcode{v}\
 is a
-\tcode{vector<T, Allocator>}\
+\tcode{vector<T, Alloc@\removedConcepts{ator}@>}\
 where
 \tcode{T}\
 is some type other than
@@ -4007,43 +4007,43 @@
 
 \begin{codeblock}
 namespace std {
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator = allocator<T> >
+  template <@\changedConcepts{class}{ObjectType}@ T, @\changedConcepts{class}{RandomAccessAllocator}@ Alloc@\removedConcepts{ator}@ = allocator<T> >
   @\addedConcepts{requires Destructible<T>}@
   class vector {
   public:
     // types:
-    typedef typename Allocator::reference         reference;
-    typedef typename Allocator::const_reference   const_reference;
+    typedef typename Alloc@\removedConcepts{ator}@::reference         reference;
+    typedef typename Alloc@\removedConcepts{ator}@::const_reference   const_reference;
     typedef @\impdef@                iterator;       // See \ref{container.requirements}
     typedef @\impdef@                const_iterator; // See \ref{container.requirements}
     typedef @\impdef@                size_type;      // See \ref{container.requirements}
     typedef @\impdef@                difference_type;// See \ref{container.requirements}
     typedef T                                     value_type;
-    typedef Allocator                             allocator_type;
-    typedef typename Allocator::pointer           pointer;
-    typedef typename Allocator::const_pointer     const_pointer;
+    typedef Alloc@\removedConcepts{ator}@                             allocator_type;
+    typedef typename Alloc@\removedConcepts{ator}@::pointer           pointer;
+    typedef typename Alloc@\removedConcepts{ator}@::const_pointer     const_pointer;
     typedef std::reverse_iterator<iterator>       reverse_iterator;
     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 
     // \ref{vector.cons} construct/copy/destroy:
-    explicit vector(const Allocator& = Allocator());
+    explicit vector(const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
     @\addedConcepts{requires DefaultConstructible<T>}@ explicit vector(size_type n);
-    @\addedConcepts{requires CopyConstructible<T>}@ vector(size_type n, const T& value, const Allocator& = Allocator());
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ vector(size_type n, const T& value, const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
     template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
-      @\addedConcepts{requires HasConstructor<T, Iter::reference> \&\& MoveConstructible<T>}@
+      @\addedConcepts{requires HasConstructor<T, Iter::reference> \&\& ConstructibleAsElement<Alloc, T, T\&\&>}@
       vector(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last,
-             const Allocator& = Allocator());
-    @\addedConcepts{requires CopyConstructible<T>}@ vector(const vector<T,Allocator>& x);
+             const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ vector(const vector<T,Alloc@\removedConcepts{ator}@>& x);
     vector(vector&&);
-    @\addedConcepts{requires CopyConstructible<T>}@ vector(const vector&, const Allocator&);
-    vector(vector&&, const Allocator&);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ vector(const vector&, const Alloc@\removedConcepts{ator}@&);
+    vector(vector&&, const Alloc@\removedConcepts{ator}@&);
    ~vector();
-    @\addedConcepts{requires CopyAssignable<T>}@ vector<T,Allocator>& operator=(const vector<T,Allocator>& x);
-    vector<T,Allocator>& operator=(vector<T,Allocator>&& x);
+    @\addedConcepts{requires CopyAssignable<T>}@ vector<T,Alloc@\removedConcepts{ator}@>& operator=(const vector<T,Alloc@\removedConcepts{ator}@>& x);
+    vector<T,Alloc@\removedConcepts{ator}@>& operator=(vector<T,Alloc@\removedConcepts{ator}@>&& x);
     template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
       @\addedConcepts{requires HasConstructor<T, Iter::reference> \&\& HasCopyAssign<T, Iter::reference>}@
       void assign(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last);
-    @\addedConcepts{requires CopyConstructible<T> \&\& CopyAssignable<T>}@ void assign(size_type n, const T& u);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&> \&\& CopyAssignable<T>}@ void assign(size_type n, const T& u);
     allocator_type get_allocator() const;
 
     // iterators:
@@ -4064,11 +4064,11 @@
     // \ref{vector.capacity} capacity:
     size_type size() const;
     size_type max_size() const;
-    @\addedConcepts{requires DefaultConstructible<T> \&\& MoveConstructible<T>}@ void resize(size_type sz);
-    @\addedConcepts{requires CopyConstructible<T>}@ void resize(size_type sz, const T& c);
+    @\addedConcepts{requires DefaultConstructible<T> \&\& ConstructibleAsElement<Alloc, T, T\&\&>}@ void resize(size_type sz);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ void resize(size_type sz, const T& c);
     size_type capacity() const;
     bool      empty() const;
-    @\addedConcepts{requires MoveConstructible<T>}@ void reserve(size_type n);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, T, T\&\&>}@ void reserve(size_type n);
 
     // element access:
     reference       operator[](size_type n);
@@ -4086,54 +4086,54 @@
 
     // \ref{vector.modifiers} modifiers:
     template <class... Args> 
-      @\addedConcepts{requires HasConstructor<T, Args\&\&...> \&\& MoveConstructible<T>}@
+      @\addedConcepts{requires HasConstructor<T, Args\&\&...> \&\& ConstructibleAsElement<Alloc, T, T\&\&>}@
       void push_back(Args&&... args);
     void pop_back();
 
     template <class... Args> 
-      @\addedConcepts{requires HasConstructor<T, Args\&\&...> \&\& MoveConstructible<T>}@
+      @\addedConcepts{requires HasConstructor<T, Args\&\&...> \&\& ConstructibleAsElement<Alloc, T, T\&\&>}@
       iterator emplace(const_iterator position, Args&&... args);
-    @\addedConcepts{requires CopyConstructible<T> \&\& CopyAssignable<T>}@ 
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&> \&\& CopyAssignable<T>}@ 
       iterator insert(const_iterator position, const T& x);
-    @\addedConcepts{requires MoveConstructible<T> \&\& MoveAssignable<T>}@
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, T, T\&\&> \&\& MoveAssignable<T>}@
       void insert(const_iterator position, T&& x);
-    @\addedConcepts{requires CopyConstructible<T> \&\& CopyAssignable<T>}@
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&> \&\& CopyAssignable<T>}@
       void insert(const_iterator position, size_type n, const T& x);
     template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
         @\addedConcepts{requires HasConstructor<T, Iter::reference> \&\& HasCopyAssign<T, Iter::reference>}@
-              @\addedConcepts{\&\& MoveConstructible<T> \&\& MoveAssignable<T>}@
+              @\addedConcepts{\&\& ConstructibleAsElement<Alloc, T, T\&\&> \&\& MoveAssignable<T>}@
         void insert(const_iterator position,
                     @\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last);
     @\addedConcepts{requires MoveAssignable<T>}@ iterator erase(const_iterator position);
     @\addedConcepts{requires MoveAssignable<T>}@ iterator erase(const_iterator first, const_iterator last);
-    void     swap(vector<T,Allocator>&&);
+    void     swap(vector<T,Alloc@\removedConcepts{ator}@>&&);
     void     clear();
   };
 
-  template <@\changedConcepts{class}{EqualityComparable}@ T, class Allocator>
-    bool operator==(const vector<T,Allocator>& x, const vector<T,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
-    bool operator< (const vector<T,Allocator>& x, const vector<T,Allocator>& y);
-  template <@\changedConcepts{class}{EqualityComparable}@ T, class Allocator>
-    bool operator!=(const vector<T,Allocator>& x, const vector<T,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
-    bool operator> (const vector<T,Allocator>& x, const vector<T,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
-    bool operator>=(const vector<T,Allocator>& x, const vector<T,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ T, class Allocator>
-    bool operator<=(const vector<T,Allocator>& x, const vector<T,Allocator>& y);
+  template <@\changedConcepts{class}{EqualityComparable}@ T, class Alloc@\removedConcepts{ator}@>
+    bool operator==(const vector<T,Alloc@\removedConcepts{ator}@>& x, const vector<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+    bool operator< (const vector<T,Alloc@\removedConcepts{ator}@>& x, const vector<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{EqualityComparable}@ T, class Alloc@\removedConcepts{ator}@>
+    bool operator!=(const vector<T,Alloc@\removedConcepts{ator}@>& x, const vector<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+    bool operator> (const vector<T,Alloc@\removedConcepts{ator}@>& x, const vector<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+    bool operator>=(const vector<T,Alloc@\removedConcepts{ator}@>& x, const vector<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ T, class Alloc@\removedConcepts{ator}@>
+    bool operator<=(const vector<T,Alloc@\removedConcepts{ator}@>& x, const vector<T,Alloc@\removedConcepts{ator}@>& y);
 
   // specialized algorithms:
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-    void swap(vector<T,Allocator>& x, vector<T,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-    void swap(vector<T,Allocator>&& x, vector<T,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-    void swap(vector<T,Allocator>& x, vector<T,Allocator>&& y);
-
-  template <class T, class Alloc>
-    struct constructible_with_allocator_suffix<vector<T, Alloc> >
-      : true_type { };
+  template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+    void swap(vector<T,Alloc@\removedConcepts{ator}@>& x, vector<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+    void swap(vector<T,Alloc@\removedConcepts{ator}@>&& x, vector<T,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+    void swap(vector<T,Alloc@\removedConcepts{ator}@>& x, vector<T,Alloc@\removedConcepts{ator}@>&& y);
+
+  @\removedConcepts{template <class T, class Alloc>}@
+    @\removedConcepts{struct constructible_with_allocator_suffix<vector<T, Alloc> >}@
+      @\removedConcepts{: true_type \{ \};}@
 }
 \end{codeblock}%
 \index{vector@\tcode{vector}!\tcode{operator==}}%
@@ -4143,7 +4143,7 @@
 
 \index{vector@\tcode{vector}!\tcode{vector}}
 \begin{itemdecl}
-vector(const Allocator& = Allocator());
+vector(const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -4174,9 +4174,9 @@
 
 \index{vector@\tcode{vector}!\tcode{vector}}
 \begin{itemdecl}
-@\addedConcepts{requires CopyConstructible<T>}@
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@
 explicit vector(size_type n, const T& value,
-                const Allocator& = Allocator());
+                const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -4194,9 +4194,9 @@
 \index{vector@\tcode{vector}!\tcode{vector}}
 \begin{itemdecl}
 template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
-  @\addedConcepts{requires HasConstructor<T, Iter::reference> \&\& MoveConstructible<T>}@
+  @\addedConcepts{requires HasConstructor<T, Iter::reference> \&\& ConstructibleAsElement<Alloc, T, T\&\&>}@
   vector(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last,
-         const Allocator& = Allocator());
+         const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -4242,7 +4242,7 @@
 \end{itemdescr}
 
 \begin{itemdecl}
-@\addedConcepts{requires CopyConstructible<T> \&\& CopyAssignable<T>}@ 
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&> \&\& CopyAssignable<T>}@ 
   void assign(size_type n, const T& t);
 \end{itemdecl}
 
@@ -4271,7 +4271,7 @@
 
 \index{reserve@\tcode{reserve}!\tcode{vector}}%
 \begin{itemdecl}
-@\addedConcepts{requires MoveConstructible<T>}@ void reserve(size_type n);
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, T\&\&>}@ void reserve(size_type n);
 \end{itemdecl}
 
 \pnum
@@ -4309,7 +4309,7 @@
 \footnote{
 \tcode{reserve()}\
 uses
-\tcode{Allocator::allocate()}\
+\tcode{Alloc@\removedConcepts{ator}@::allocate()}\
 which may throw an appropriate exception.
 }
 
@@ -4327,7 +4327,7 @@
 
 \index{swap@\tcode{swap}!\tcode{vector}}%
 \begin{itemdecl}
-void swap(vector<T,Allocator>&& x);
+void swap(vector<T,Alloc@\removedConcepts{ator}@>&& x);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -4346,7 +4346,7 @@
 
 \index{resize@\tcode{resize}!\tcode{vector}}%
 \begin{itemdecl}
-@\addedConcepts{requires DefaultConstructible<T> \&\& MoveConstructible<T>}@ void resize(size_type sz);
+@\addedConcepts{requires DefaultConstructible<T> \&\& ConstructibleAsElement<Alloc, T, T\&\&>}@ void resize(size_type sz);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -4363,7 +4363,7 @@
 
 \index{resize@\tcode{resize}!\tcode{vector}}%
 \begin{itemdecl}
-@\addedConcepts{requires CopyConstructible<T>}@ void resize(size_type sz, const T& c);
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&>}@ void resize(size_type sz, const T& c);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -4409,23 +4409,23 @@
 
 \index{insert@\tcode{insert}!\tcode{vector}}%
 \begin{itemdecl}
-@\addedConcepts{requires CopyConstructible<T> \&\& CopyAssignable<T>}@
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&> \&\& CopyAssignable<T>}@
   iterator insert(const_iterator position, const T& x);
-@\addedConcepts{requires MoveConstructible<T> \&\& MoveAssignable<T>}@
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, T\&\&> \&\& MoveAssignable<T>}@
   iterator insert(const_iterator position, T&& x);
-@\addedConcepts{requires CopyConstructible<T> \&\& CopyAssignable<T>}@
+@\addedConcepts{requires ConstructibleAsElement<Alloc, T, const T\&> \&\& CopyAssignable<T>}@
   void insert(const_iterator position, size_type n, const T& x);
 template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
     @\addedConcepts{requires HasConstructor<T, Iter::reference> \&\& HasCopyAssign<T, Iter::reference>}@
-          @\addedConcepts{\&\& MoveConstructible<T> \&\& MoveAssignable<T>}@
+          @\addedConcepts{\&\& ConstructibleAsElement<Alloc, T, T\&\&> \&\& MoveAssignable<T>}@
     void insert(const_iterator position,
                 @\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last);
 
 template <class... Args> 
-  @\addedConcepts{requires HasConstructor<T, Args\&\&...> \&\& MoveConstructible<T>}@
+  @\addedConcepts{requires HasConstructor<T, Args\&\&...> \&\& ConstructibleAsElement<Alloc, T, T\&\&>}@
   void push_back(Args&&... args);
 template <class... Args> 
-  @\addedConcepts{requires HasConstructor<T, Args\&\&...> \&\& MoveConstructible<T>}@
+  @\addedConcepts{requires HasConstructor<T, Args\&\&...> \&\& ConstructibleAsElement<Alloc, T, T\&\&>}@
   iterator emplace(const_iterator position, Args&&... args);
 \end{itemdecl}
 
@@ -4477,12 +4477,12 @@
 \rSec3[vector.special]{\tcode{vector}\ specialized algorithms}
 
 \begin{itemdecl}
-template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-  void swap(vector<T,Allocator>& x, vector<T,Allocator>& y);
-template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-  void swap(vector<T,Allocator>&& x, vector<T,Allocator>& y);
-template <@\changedConcepts{class}{ObjectType}@ T, class Allocator>
-  void swap(vector<T,Allocator>& x, vector<T,Allocator>&& y);
+template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+  void swap(vector<T,Alloc@\removedConcepts{ator}@>& x, vector<T,Alloc@\removedConcepts{ator}@>& y);
+template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+  void swap(vector<T,Alloc@\removedConcepts{ator}@>&& x, vector<T,Alloc@\removedConcepts{ator}@>& y);
+template <@\changedConcepts{class}{ObjectType}@ T, class Alloc@\removedConcepts{ator}@>
+  void swap(vector<T,Alloc@\removedConcepts{ator}@>& x, vector<T,Alloc@\removedConcepts{ator}@>&& y);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -4503,7 +4503,7 @@
 
 \begin{codeblock}
 namespace std {
-  template <class Allocator> class vector<bool, Allocator> {
+  template <@\changedConcepts{class}{RandomAccessAllocator}@ Alloc@\removedConcepts{ator}@> class vector<bool, Alloc@\removedConcepts{ator}@> {
   public:
     // types:
     typedef bool                                  const_reference;
@@ -4512,7 +4512,7 @@
     typedef @\impdef@                size_type;      // See \ref{container.requirements}
     typedef @\impdef@                difference_type;// See \ref{container.requirements}
     typedef bool                                  value_type;
-    typedef Allocator                             allocator_type;
+    typedef Alloc@\removedConcepts{ator}@                             allocator_type;
     typedef @\impdef@                pointer;
     typedef @\impdef@                const_pointer;
     typedef std::reverse_iterator<iterator>       reverse_iterator;
@@ -4531,20 +4531,20 @@
     };
 
     // construct/copy/destroy:
-    explicit vector(const Allocator& = Allocator());
+    explicit vector(const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
     explicit vector(size_type n, const bool& value = bool(),
-                    const Allocator& = Allocator());
+                    const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
     template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
       @\addedConcepts{requires Convertible<Iter::reference, bool>}@
       vector(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last,
-             const Allocator& = Allocator());
-    vector(const vector<bool,Allocator>& x);
-    vector(vector<bool,Allocator>&& x);
-    vector(const vector&, const Allocator&);
-    vector(vector&&, const Allocator&);
+             const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
+    vector(const vector<bool,Alloc@\removedConcepts{ator}@>& x);
+    vector(vector<bool,Alloc@\removedConcepts{ator}@>&& x);
+    vector(const vector&, const Alloc@\removedConcepts{ator}@&);
+    vector(vector&&, const Alloc@\removedConcepts{ator}@&);
    ~vector();
-    vector<bool,Allocator>& operator=(const vector<bool,Allocator>& x);
-    vector<bool,Allocator>& operator=(vector<bool,Allocator>&& x);
+    vector<bool,Alloc@\removedConcepts{ator}@>& operator=(const vector<bool,Alloc@\removedConcepts{ator}@>& x);
+    vector<bool,Alloc@\removedConcepts{ator}@>& operator=(vector<bool,Alloc@\removedConcepts{ator}@>&& x);
     template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
       @\addedConcepts{requires Convertible<Iter::reference, bool>}@
       void assign(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last);
@@ -4596,7 +4596,7 @@
 
     iterator erase(const_iterator position);
     iterator erase(const_iterator first, const_iterator last);
-    void swap(vector<bool,Allocator>&&);
+    void swap(vector<bool,Alloc@\removedConcepts{ator}@>&&);
     static void swap(reference x, reference y);
     void flip();                // flips all bits
     void clear();
@@ -4646,69 +4646,73 @@
 namespace std {
   template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, 
             @\changedConcepts{class}{Predicate<auto, Key, Key>}@ Compare = less<Key>,
-            class Allocator = allocator<pair<const Key, T> > >
+            @\changedConcepts{class}{Allocator}@ Alloc@\removedConcepts{ator}@ = allocator<pair<const Key, T> > >
     @\addedConcepts{requires Destructible<Key> \&\& Destructible<T> \&\& CopyConstructible<Compare>}@
+             @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Compare, const Compare\&>}@
+             @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Compare, Compare\&\&>}@
     class map;
-  template <@\changedConcepts{class}{EqualityComparable}@ Key, @\changedConcepts{class}{EqualityComparable}@ T, class Compare, class Allocator>
-    bool operator==(const map<Key,T,Compare,Allocator>& x,
-                    const map<Key,T,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Allocator>
-    bool operator< (const map<Key,T,Compare,Allocator>& x,
-                    const map<Key,T,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{EqualityComparable}@ Key, @\changedConcepts{class}{EqualityComparable}@ T, class Compare, class Allocator>
-    bool operator!=(const map<Key,T,Compare,Allocator>& x,
-                    const map<Key,T,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Allocator>
-    bool operator> (const map<Key,T,Compare,Allocator>& x,
-                    const map<Key,T,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Allocator>
-    bool operator>=(const map<Key,T,Compare,Allocator>& x,
-                    const map<Key,T,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Allocator>
-    bool operator<=(const map<Key,T,Compare,Allocator>& x,
-                    const map<Key,T,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Allocator>
-    void swap(map<Key,T,Compare,Allocator>& x,
-              map<Key,T,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Allocator>
-    void swap(map<Key,T,Compare,Allocator&& x,
-              map<Key,T,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Allocator>
-    void swap(map<Key,T,Compare,Allocator& x,
-              map<Key,T,Compare,Allocator>&& y);
+  template <@\changedConcepts{class}{EqualityComparable}@ Key, @\changedConcepts{class}{EqualityComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator==(const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator< (const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{EqualityComparable}@ Key, @\changedConcepts{class}{EqualityComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator!=(const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator> (const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator>=(const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator<=(const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+    void swap(map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+              map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+    void swap(map<Key,T,Compare,Alloc@\removedConcepts{ator}@&& x,
+              map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+    void swap(map<Key,T,Compare,Alloc@\removedConcepts{ator}@& x,
+              map<Key,T,Compare,Alloc@\removedConcepts{ator}@>&& y);
 
   template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, 
             @\changedConcepts{class}{Predicate<auto, Key, Key>}@ Compare = less<Key>,
-            class Allocator = allocator<pair<const Key, T> > >
+            @\changedConcepts{class}{Allocator}@ Alloc@\removedConcepts{ator}@ = allocator<pair<const Key, T> > >
     @\addedConcepts{requires Destructible<Key> \&\& Destructible<T> \&\& CopyConstructible<Compare>}@
+             @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Compare, const Compare\&>}@
+             @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Compare, Compare\&\&>}@
     class multimap;
-  template <@\changedConcepts{class}{EqualityComparable}@ Key, @\changedConcepts{class}{EqualityComparable}@ T, class Compare, class Allocator>
-    bool operator==(const multimap<Key,T,Compare,Allocator>& x,
-                    const multimap<Key,T,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Allocator>
-    bool operator< (const multimap<Key,T,Compare,Allocator>& x,
-                    const multimap<Key,T,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{EqualityComparable}@ Key, @\changedConcepts{class}{EqualityComparable}@ T, class Compare, class Allocator>
-    bool operator!=(const multimap<Key,T,Compare,Allocator>& x,
-                    const multimap<Key,T,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Allocator>
-    bool operator> (const multimap<Key,T,Compare,Allocator>& x,
-                    const multimap<Key,T,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Allocator>
-    bool operator>=(const multimap<Key,T,Compare,Allocator>& x,
-                    const multimap<Key,T,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Allocator>
-    bool operator<=(const multimap<Key,T,Compare,Allocator>& x,
-                    const multimap<Key,T,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Allocator>
-    void swap(multimap<Key,T,Compare,Allocator>& x,
-              multimap<Key,T,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Allocator>
-    void swap(multimap<Key,T,Compare,Allocator&& x,
-              multimap<Key,T,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Allocator>
-    void swap(multimap<Key,T,Compare,Allocator& x,
-              multimap<Key,T,Compare,Allocator>&& y);
+  template <@\changedConcepts{class}{EqualityComparable}@ Key, @\changedConcepts{class}{EqualityComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator==(const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator< (const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{EqualityComparable}@ Key, @\changedConcepts{class}{EqualityComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator!=(const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator> (const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator>=(const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator<=(const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+    void swap(multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+              multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+    void swap(multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@&& x,
+              multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+    void swap(multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@& x,
+              multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>&& y);
 }
 \end{codeblock}
 
@@ -4718,68 +4722,72 @@
 \begin{codeblock}
 namespace std {
   template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{Predicate<auto, Key, Key>}@ Compare = less<Key>,
-            class Allocator = allocator<Key> >
+            @\changedConcepts{class}{Allocator}@ Alloc@\removedConcepts{ator}@ = allocator<Key> >
     @\addedConcepts{requires Destructible<Key> \&\& CopyConstructible<Compare>}@
+             @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Compare, const Compare\&>}@
+             @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Compare, Compare\&\&>}@
     class set;
-  template <@\changedConcepts{class}{EqualityComparable}@ Key, class Compare, class Allocator>
-    bool operator==(const set<Key,Compare,Allocator>& x,
-                    const set<Key,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Allocator>
-    bool operator< (const set<Key,Compare,Allocator>& x,
-                    const set<Key,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{EqualityComparable}@ Key, class Compare, class Allocator>
-    bool operator!=(const set<Key,Compare,Allocator>& x,
-                    const set<Key,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Allocator>
-    bool operator> (const set<Key,Compare,Allocator>& x,
-                    const set<Key,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Allocator>
-    bool operator>=(const set<Key,Compare,Allocator>& x,
-                    const set<Key,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Allocator>
-    bool operator<=(const set<Key,Compare,Allocator>& x,
-                    const set<Key,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Allocator>
-    void swap(set<Key,Compare,Allocator>& x,
-              set<Key,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ Key, class T, class Compare, class Allocator>
-    void swap(set<Key,T,Compare,Allocator&& x,
-              set<Key,T,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ Key, class T, class Compare, class Allocator>
-    void swap(set<Key,T,Compare,Allocator& x,
-              set<Key,T,Compare,Allocator>&& y);
+  template <@\changedConcepts{class}{EqualityComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator==(const set<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const set<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator< (const set<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const set<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{EqualityComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator!=(const set<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const set<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator> (const set<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const set<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator>=(const set<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const set<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator<=(const set<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const set<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+    void swap(set<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+              set<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ Key, class T, class Compare, class Alloc@\removedConcepts{ator}@>
+    void swap(set<Key,T,Compare,Alloc@\removedConcepts{ator}@&& x,
+              set<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ Key, class T, class Compare, class Alloc@\removedConcepts{ator}@>
+    void swap(set<Key,T,Compare,Alloc@\removedConcepts{ator}@& x,
+              set<Key,T,Compare,Alloc@\removedConcepts{ator}@>&& y);
 
   template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{Predicate<auto, Key, Key>}@ Compare = less<Key>,
-            class Allocator = allocator<Key> >
+            @\changedConcepts{class}{Allocator}@ Alloc@\removedConcepts{ator}@ = allocator<Key> >
     @\addedConcepts{requires Destructible<Key> \&\& CopyConstructible<Compare>}@
+             @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Compare, const Compare\&>}@
+             @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Compare, Compare\&\&>}@
     class multiset;
-  template <@\changedConcepts{class}{EqualityComparable}@ Key, class Compare, class Allocator>
-    bool operator==(const multiset<Key,Compare,Allocator>& x,
-                    const multiset<Key,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Allocator>
-    bool operator< (const multiset<Key,Compare,Allocator>& x,
-                    const multiset<Key,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{EqualityComparable}@ Key, class Compare, class Allocator>
-    bool operator!=(const multiset<Key,Compare,Allocator>& x,
-                    const multiset<Key,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Allocator>
-    bool operator> (const multiset<Key,Compare,Allocator>& x,
-                    const multiset<Key,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Allocator>
-    bool operator>=(const multiset<Key,Compare,Allocator>& x,
-                    const multiset<Key,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Allocator>
-    bool operator<=(const multiset<Key,Compare,Allocator>& x,
-                    const multiset<Key,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Allocator>
-    void swap(multiset<Key,Compare,Allocator>& x,
-              multiset<Key,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ Key, class T, class Compare, class Allocator>
-    void swap(multiset<Key,T,Compare,Allocator&& x,
-              multiset<Key,T,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ Key, class T, class Compare, class Allocator>
-    void swap(multiset<Key,T,Compare,Allocator& x,
-              multiset<Key,T,Compare,Allocator>&& y);
+  template <@\changedConcepts{class}{EqualityComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator==(const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator< (const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{EqualityComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator!=(const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator> (const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator>=(const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator<=(const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+    void swap(multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+              multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ Key, class T, class Compare, class Alloc@\removedConcepts{ator}@>
+    void swap(multiset<Key,T,Compare,Alloc@\removedConcepts{ator}@&& x,
+              multiset<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ Key, class T, class Compare, class Alloc@\removedConcepts{ator}@>
+    void swap(multiset<Key,T,Compare,Alloc@\removedConcepts{ator}@& x,
+              multiset<Key,T,Compare,Alloc@\removedConcepts{ator}@>&& y);
 }
 \end{codeblock}
 
@@ -4829,8 +4837,10 @@
 namespace std {
   template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, 
             @\changedConcepts{class}{Predicate<auto, Key, Key>}@ Compare = less<Key>,
-            class Allocator = allocator<pair<const Key, T> > >
+            @\changedConcepts{class}{Allocator}@ Alloc@\removedConcepts{ator}@ = allocator<pair<const Key, T> > >
   @\addedConcepts{requires Destructible<Key> \&\& Destructible<T> \&\& CopyConstructible<Compare>}@
+           @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Compare, const Compare\&>}@
+           @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Compare, Compare\&\&>}@
   class map {
   public:
     // types:
@@ -4838,15 +4848,15 @@
     typedef T                                     mapped_type;
     typedef pair<const Key, T>                    value_type;
     typedef Compare                               key_compare;
-    typedef Allocator                             allocator_type;
-    typedef typename Allocator::reference         reference;
-    typedef typename Allocator::const_reference   const_reference;
+    typedef Alloc@\removedConcepts{ator}@                             allocator_type;
+    typedef typename Alloc@\removedConcepts{ator}@::reference         reference;
+    typedef typename Alloc@\removedConcepts{ator}@::const_reference   const_reference;
     typedef @\impdef@                iterator;       // See \ref{container.requirements}
     typedef @\impdef@                const_iterator; // See \ref{container.requirements}
     typedef @\impdef@                size_type;      // See \ref{container.requirements}
     typedef @\impdef@                difference_type;// See \ref{container.requirements}
-    typedef typename Allocator::pointer           pointer;
-    typedef typename Allocator::const_pointer     const_pointer;
+    typedef typename Alloc@\removedConcepts{ator}@::pointer           pointer;
+    typedef typename Alloc@\removedConcepts{ator}@::const_pointer     const_pointer;
     typedef std::reverse_iterator<iterator>       reverse_iterator;
     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 
@@ -4864,21 +4874,21 @@
 
     // \ref{map.cons} construct/copy/destroy:
     explicit map(const Compare& comp = Compare(),
-                 const Allocator& = Allocator());
+                 const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
     template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
       @\addedConcepts{requires HasConstructor<value_type, Iter::reference>}@
       map(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last,
-          const Compare& comp = Compare(), const Allocator& = Allocator());
-    @\addedConcepts{requires CopyConstructible<value_type>}@ map(const map<Key,T,Compare,Allocator>& x);
-    map(map<Key,T,Compare,Allocator>&& x);
-    map(const Allocator&);
-    @\addedConcepts{requires CopyConstructible<value_type>}@ map(const map&, const Allocator&);
-    map(map&&, const Allocator&);
+          const Compare& comp = Compare(), const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ map(const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x);
+    map(map<Key,T,Compare,Alloc@\removedConcepts{ator}@>&& x);
+    map(const Alloc@\removedConcepts{ator}@&);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ map(const map&, const Alloc@\removedConcepts{ator}@&);
+    map(map&&, const Alloc@\removedConcepts{ator}@&);
    ~map();
-    @\addedConcepts{requires CopyConstructible<value_type> \&\& CopyAssignable<value_type>}@ 
-      map<Key,T,Compare,Allocator>& operator=(const map<Key,T,Compare,Allocator>& x);
-    map<Key,T,Compare,Allocator>&
-      operator=(map<Key,T,Compare,Allocator>&& x);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&> \&\& CopyAssignable<value_type>}@ 
+      map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& operator=(const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x);
+    map<Key,T,Compare,Alloc@\removedConcepts{ator}@>&
+      operator=(map<Key,T,Compare,Alloc@\removedConcepts{ator}@>&& x);
     allocator_type get_allocator() const;
 
     // iterators:
@@ -4915,11 +4925,11 @@
     template <class... Args> 
       @\addedConcepts{requires HasConstructor<value_type, Args\&\&...>}@
       iterator emplace(const_iterator position, Args&&... args);
-    @\addedConcepts{requires CopyConstructible<value_type>}@ pair<iterator, bool> insert(const value_type& x);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ pair<iterator, bool> insert(const value_type& x);
     template <class P> 
       @\addedConcepts{requires HasConstructor<value_type, P\&\&> \&\& Convertible<P, value_type>}@
       pair<iterator, bool> insert(P&& x);
-    @\addedConcepts{requires CopyConstructible<value_type>}@ iterator insert(const_iterator position, const value_type& x);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ iterator insert(const_iterator position, const value_type& x);
     template <class P>
       @\addedConcepts{requires HasConstructor<value_type, P\&\&> \&\& Convertible<P, value_type>}@
       iterator insert(const_iterator position, P&&);
@@ -4930,7 +4940,7 @@
     iterator  erase(const_iterator position);
     size_type erase(const key_type& x);
     iterator  erase(const_iterator first, const_iterator last);
-    void swap(map<Key,T,Compare,Allocator>&&);
+    void swap(map<Key,T,Compare,Alloc@\removedConcepts{ator}@>&&);
     void clear();
 
     // observers:
@@ -4953,40 +4963,40 @@
       equal_range(const key_type& x) const;
   };
 
-  template <@\changedConcepts{class}{EqualityComparable}@ Key, @\changedConcepts{class}{EqualityComparable}@ T, class Compare, class Allocator>
-    bool operator==(const map<Key,T,Compare,Allocator>& x,
-                    const map<Key,T,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Allocator>
-    bool operator< (const map<Key,T,Compare,Allocator>& x,
-                    const map<Key,T,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{EqualityComparable}@ Key, @\changedConcepts{class}{EqualityComparable}@ T, class Compare, class Allocator>
-    bool operator!=(const map<Key,T,Compare,Allocator>& x,
-                    const map<Key,T,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Allocator>
-    bool operator> (const map<Key,T,Compare,Allocator>& x,
-                    const map<Key,T,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Allocator>
-    bool operator>=(const map<Key,T,Compare,Allocator>& x,
-                    const map<Key,T,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Allocator>
-    bool operator<=(const map<Key,T,Compare,Allocator>& x,
-                    const map<Key,T,Compare,Allocator>& y);
+  template <@\changedConcepts{class}{EqualityComparable}@ Key, @\changedConcepts{class}{EqualityComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator==(const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator< (const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{EqualityComparable}@ Key, @\changedConcepts{class}{EqualityComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator!=(const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator> (const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator>=(const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator<=(const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
 
   // specialized algorithms:
-  template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Allocator>
-    void swap(map<Key,T,Compare,Allocator>& x,
-              map<Key,T,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Allocator>
-    void swap(map<Key,T,Compare,Allocator&& x,
-              map<Key,T,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Allocator>
-    void swap(map<Key,T,Compare,Allocator& x,
-              map<Key,T,Compare,Allocator>&& y);
-
-  template <class Key, class T, class Compare, class Alloc>
-    struct constructible_with_allocator_suffix<
-      map<Key, T, Compare, Alloc> >
-        : true_type { };
+  template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+    void swap(map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+              map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+    void swap(map<Key,T,Compare,Alloc@\removedConcepts{ator}@&& x,
+              map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+    void swap(map<Key,T,Compare,Alloc@\removedConcepts{ator}@& x,
+              map<Key,T,Compare,Alloc@\removedConcepts{ator}@>&& y);
+
+  @\removedConcepts{template <class Key, class T, class Compare, class Alloc>}@
+    @\removedConcepts{struct constructible_with_allocator_suffix<}@
+      @\removedConcepts{map<Key, T, Compare, Alloc> >}@
+        @\removedConcepts{: true_type \{ \};}@
 }
 \end{codeblock}%
 
@@ -4997,7 +5007,7 @@
 
 \begin{itemdecl}
 explicit map(const Compare& comp = Compare(),
-             const Allocator& = Allocator());
+             const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -5016,7 +5026,7 @@
 template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
   @\addedConcepts{requires HasConstructor<value_type, Iter::reference>}@
   map(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last,
-      const Compare& comp = Compare(), const Allocator& = Allocator());
+      const Compare& comp = Compare(), const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -5198,15 +5208,15 @@
 \rSec3[map.special]{\tcode{map}\ specialized algorithms}
 
 \begin{itemdecl}
-template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Allocator>
-  void swap(map<Key,T,Compare,Allocator>& x,
-            map<Key,T,Compare,Allocator>& y);
-template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Allocator>
-  void swap(map<Key,T,Compare,Allocator>&& x,
-            map<Key,T,Compare,Allocator>& y);
-template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Allocator>
-  void swap(map<Key,T,Compare,Allocator>& x,
-            map<Key,T,Compare,Allocator>&& y);
+template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+  void swap(map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+            map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+  void swap(map<Key,T,Compare,Alloc@\removedConcepts{ator}@>&& x,
+            map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+  void swap(map<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+            map<Key,T,Compare,Alloc@\removedConcepts{ator}@>&& y);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -5270,8 +5280,10 @@
 namespace std {
   template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, 
             @\changedConcepts{class}{Predicate<auto, Key, Key>}@ Compare = less<Key>,
-            class Allocator = allocator<pair<const Key, T> > >
+            @\changedConcepts{class}{Allocator}@ Alloc@\removedConcepts{ator}@ = allocator<pair<const Key, T> > >
     @\addedConcepts{requires Destructible<Key> \&\& Destructible<T> \&\& CopyConstructible<Compare>}@
+           @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Compare, const Compare\&>}@
+           @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Compare, Compare\&\&>}@
   class multimap {
   public:
     // types:
@@ -5279,15 +5291,15 @@
     typedef T                                     mapped_type;
     typedef pair<const Key,T>                     value_type;
     typedef Compare                               key_compare;
-    typedef Allocator                             allocator_type;
-    typedef typename Allocator::reference         reference;
-    typedef typename Allocator::const_reference   const_reference;
+    typedef Alloc@\removedConcepts{ator}@                             allocator_type;
+    typedef typename Alloc@\removedConcepts{ator}@::reference         reference;
+    typedef typename Alloc@\removedConcepts{ator}@::const_reference   const_reference;
     typedef @\impdef@                iterator;       // See \ref{container.requirements}
     typedef @\impdef@                const_iterator; // See \ref{container.requirements}
     typedef @\impdef@                size_type;      // See \ref{container.requirements}
     typedef @\impdef@                difference_type;// See \ref{container.requirements}
-    typedef typename Allocator::pointer           pointer;
-    typedef typename Allocator::const_pointer     const_pointer;
+    typedef typename Alloc@\removedConcepts{ator}@::pointer           pointer;
+    typedef typename Alloc@\removedConcepts{ator}@::const_pointer     const_pointer;
     typedef std::reverse_iterator<iterator>       reverse_iterator;
     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 
@@ -5305,21 +5317,21 @@
 
     // construct/copy/destroy:
     explicit multimap(const Compare& comp = Compare(),
-                      const Allocator& = Allocator());
+                      const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
     template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
       @\addedConcepts{requires HasConstructor<value_type, Iter::reference>}@
       multimap(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last,
-          const Compare& comp = Compare(), const Allocator& = Allocator());
-    @\addedConcepts{requires CopyConstructible<value_type>}@ multimap(const multimap<Key,T,Compare,Allocator>& x);
-    multimap(multimap<Key,T,Compare,Allocator>&& x);
-    multimap(const Allocator&);
-    @\addedConcepts{requires CopyConstructible<value_type>}@ multimap(const multimap&, const Allocator&);
-    multimap(multimap&&, const Allocator&);
+          const Compare& comp = Compare(), const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ multimap(const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x);
+    multimap(multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>&& x);
+    multimap(const Alloc@\removedConcepts{ator}@&);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ multimap(const multimap&, const Alloc@\removedConcepts{ator}@&);
+    multimap(multimap&&, const Alloc@\removedConcepts{ator}@&);
    ~multimap();
-    @\addedConcepts{requires CopyConstructible<value_type> \&\& CopyAssignable<value_type>}@
-      multimap<Key,T,Compare,Allocator>& operator=(const multimap<Key,T,Compare,Allocator>& x);
-    multimap<Key,T,Compare,Allocator>&
-      operator=(const multimap<Key,T,Compare,Allocator>&& x);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&> \&\& CopyAssignable<value_type>}@
+      multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& operator=(const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x);
+    multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>&
+      operator=(const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>&& x);
     allocator_type get_allocator() const;
 
     // iterators:
@@ -5350,11 +5362,11 @@
     template <class... Args> 
       @\addedConcepts{requires HasConstructor<value_type, Args\&\&...>}@
       iterator emplace(const_iterator position, Args&&... args);
-    @\addedConcepts{requires CopyConstructible<value_type>}@ iterator insert(const value_type& x);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ iterator insert(const value_type& x);
     template <class P> 
       @\addedConcepts{requires HasConstructor<value_type, P\&\&> \&\& Convertible<P, value_type>}@
       iterator insert(P&& x);
-    @\addedConcepts{requires CopyConstructible<value_type>}@  iterator insert(const_iterator position, const value_type& x);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@  iterator insert(const_iterator position, const value_type& x);
     template <class P> 
       @\addedConcepts{requires HasConstructor<value_type, P\&\&> \&\& Convertible<P, value_type>}@
       iterator insert(const_iterator position, P&& x);
@@ -5365,7 +5377,7 @@
     iterator  erase(const_iterator position);
     size_type erase(const key_type& x);
     iterator  erase(const_iterator first, const_iterator last);
-    void swap(multimap<Key,T,Compare,Allocator>&&);
+    void swap(multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>&&);
     void clear();
 
     // observers:
@@ -5388,40 +5400,40 @@
       equal_range(const key_type& x) const;
   };
 
-  template <@\changedConcepts{class}{EqualityComparable}@ Key, @\changedConcepts{class}{EqualityComparable}@ T, class Compare, class Allocator>
-    bool operator==(const multimap<Key,T,Compare,Allocator>& x,
-                    const multimap<Key,T,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Allocator>
-    bool operator< (const multimap<Key,T,Compare,Allocator>& x,
-                    const multimap<Key,T,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{EqualityComparable}@ Key, @\changedConcepts{class}{EqualityComparable}@ T, class Compare, class Allocator>
-    bool operator!=(const multimap<Key,T,Compare,Allocator>& x,
-                    const multimap<Key,T,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Allocator>
-    bool operator> (const multimap<Key,T,Compare,Allocator>& x,
-                    const multimap<Key,T,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Allocator>
-    bool operator>=(const multimap<Key,T,Compare,Allocator>& x,
-                    const multimap<Key,T,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Allocator>
-    bool operator<=(const multimap<Key,T,Compare,Allocator>& x,
-                    const multimap<Key,T,Compare,Allocator>& y);
+  template <@\changedConcepts{class}{EqualityComparable}@ Key, @\changedConcepts{class}{EqualityComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator==(const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator< (const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{EqualityComparable}@ Key, @\changedConcepts{class}{EqualityComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator!=(const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator> (const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator>=(const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ Key, @\changedConcepts{class}{LessThanComparable}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator<=(const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
 
   // specialized algorithms:
-  template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Allocator>
-    void swap(multimap<Key,T,Compare,Allocator>& x,
-              multimap<Key,T,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Allocator>
-    void swap(multimap<Key,T,Compare,Allocator&& x,
-              multimap<Key,T,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Allocator>
-    void swap(multimap<Key,T,Compare,Allocator& x,
-              multimap<Key,T,Compare,Allocator>&& y);
-
-  template <class Key, class T, class Compare, class Alloc>
-    struct constructible_with_allocator_suffix<
-      multimap<Key, T, Compare, Alloc> >
-        : true_type { };
+  template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+    void swap(multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+              multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+    void swap(multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@&& x,
+              multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+    void swap(multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@& x,
+              multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>&& y);
+
+  @\removedConcepts{template <class Key, class T, class Compare, class Alloc>}@
+    @\removedConcepts{struct constructible_with_allocator_suffix<}@
+      @\removedConcepts{multimap<Key, T, Compare, Alloc> >}@
+        @\removedConcepts{: true_type \{ \};}@
 }
 \end{codeblock}%
 \index{multimap@\tcode{multimap}!\tcode{operator==}}%
@@ -5431,7 +5443,7 @@
 
 \begin{itemdecl}
 explicit multimap(const Compare& comp = Compare(),
-                  const Allocator& = Allocator());
+                  const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -5450,7 +5462,7 @@
 template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
   @\addedConcepts{requires HasConstructor<value_type, Iter::reference>}@
   multimap(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last,
-      const Compare& comp = Compare(), const Allocator& = Allocator());
+      const Compare& comp = Compare(), const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -5549,15 +5561,15 @@
 \rSec3[multimap.special]{\tcode{multimap}\ specialized algorithms}
 
 \begin{itemdecl}
-template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Allocator>
-  void swap(multimap<Key,T,Compare,Allocator>& x,
-            multimap<Key,T,Compare,Allocator>& y);
-template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Allocator>
-  void swap(multimap<Key,T,Compare,Allocator>&& x,
-            multimap<Key,T,Compare,Allocator>& y);
-template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Allocator>
-  void swap(multimap<Key,T,Compare,Allocator>& x,
-            multimap<Key,T,Compare,Allocator>&& y);
+template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+  void swap(multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+            multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+  void swap(multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>&& x,
+            multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& y);
+template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Compare, class Alloc@\removedConcepts{ator}@>
+  void swap(multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>& x,
+            multimap<Key,T,Compare,Alloc@\removedConcepts{ator}@>&& y);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -5614,8 +5626,10 @@
 \begin{codeblock}
 namespace std {
   template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{Predicate<auto, Key, Key>}@ Compare = less<Key>,
-            class Allocator = allocator<Key> >
+            @\changedConcepts{class}{Allocator}@ Alloc@\removedConcepts{ator}@ = allocator<Key> >
   @\addedConcepts{requires Destructible<Key> \&\& CopyConstructible<Compare>}@
+           @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Compare, const Compare\&>}@
+           @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Compare, Compare\&\&>}@
   class set {
   public:
     // types:
@@ -5623,35 +5637,35 @@
     typedef Key                                   value_type;
     typedef Compare                               key_compare;
     typedef Compare                               value_compare;
-    typedef Allocator                             allocator_type;
-    typedef typename Allocator::reference         reference;
-    typedef typename Allocator::const_reference   const_reference;
+    typedef Alloc@\removedConcepts{ator}@                             allocator_type;
+    typedef typename Alloc@\removedConcepts{ator}@::reference         reference;
+    typedef typename Alloc@\removedConcepts{ator}@::const_reference   const_reference;
     typedef @\impdef@                iterator;       // See \ref{container.requirements}
     typedef @\impdef@                const_iterator; // See \ref{container.requirements}
     typedef @\impdef@                size_type;      // See \ref{container.requirements}
     typedef @\impdef@                difference_type;// See \ref{container.requirements}
-    typedef typename Allocator::pointer           pointer;
-    typedef typename Allocator::const_pointer     const_pointer;
+    typedef typename Alloc@\removedConcepts{ator}@::pointer           pointer;
+    typedef typename Alloc@\removedConcepts{ator}@::const_pointer     const_pointer;
     typedef std::reverse_iterator<iterator>       reverse_iterator;
     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 
     // \ref{set.cons} construct/copy/destroy:
     explicit set(const Compare& comp = Compare(),
-                 const Allocator& = Allocator());
+                 const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
     template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
       @\addedConcepts{requires HasConstructor<value_type, Iter::reference>}@
       set(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last,
-          const Compare& comp = Compare(), const Allocator& = Allocator());
-    @\addedConcepts{requires CopyConstructible<value_type>}@ set(const set<Key,Compare,Allocator>& x);
-    set(set<Key,Compare,Allocator>&& x);
-    set(const Allocator&);
-    @\addedConcepts{requires CopyConstructible<value_type>}@ set(const set&, const Allocator&);
-    set(set&&, const Allocator&);
+          const Compare& comp = Compare(), const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ set(const set<Key,Compare,Alloc@\removedConcepts{ator}@>& x);
+    set(set<Key,Compare,Alloc@\removedConcepts{ator}@>&& x);
+    set(const Alloc@\removedConcepts{ator}@&);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ set(const set&, const Alloc@\removedConcepts{ator}@&);
+    set(set&&, const Alloc@\removedConcepts{ator}@&);
    ~set();
 
-    @\addedConcepts{requires CopyConstructible<value_type> \&\& CopyAssignable<value_type>}@
-      set<Key,Compare,Allocator>& operator=(const set<Key,Compare,Allocator>& x);
-    set<Key,Compare,Allocator>& operator=(set<Key,Compare,Allocator>&& x);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&> \&\& CopyAssignable<value_type>}@
+      set<Key,Compare,Alloc@\removedConcepts{ator}@>& operator=(const set<Key,Compare,Alloc@\removedConcepts{ator}@>& x);
+    set<Key,Compare,Alloc@\removedConcepts{ator}@>& operator=(set<Key,Compare,Alloc@\removedConcepts{ator}@>&& x);
     allocator_type get_allocator() const;
 
     // iterators:
@@ -5682,10 +5696,10 @@
     template <class... Args> 
       @\addedConcepts{requires HasConstructor<value_type, Args\&\&...>}@
       iterator emplace(const_iterator position, Args&&... args);
-    @\addedConcepts{requires CopyConstructible<value_type>}@ pair<iterator,bool> insert(const value_type& x);
-    @\addedConcepts{requires MoveConstructible<value_type>}@ pair<iterator,bool> insert(value_type&& x);
-    @\addedConcepts{requires CopyConstructible<value_type>}@ iterator insert(const_iterator position, const value_type& x);
-    @\addedConcepts{requires MoveConstructible<value_type>}@ iterator insert(const_iterator position, value_type&& x);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ pair<iterator,bool> insert(const value_type& x);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, value_type\&\&>}@ pair<iterator,bool> insert(value_type&& x);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ iterator insert(const_iterator position, const value_type& x);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, value_type\&\&>}@ iterator insert(const_iterator position, value_type&& x);
     template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
       @\addedConcepts{requires HasConstructor<value_type, Iter::reference>}@
       void insert(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last);
@@ -5693,7 +5707,7 @@
     iterator  erase(const_iterator position);
     size_type erase(const key_type& x);
     iterator  erase(const_iterator first, const_iterator last);
-    void swap(set<Key,Compare,Allocator>&);
+    void swap(set<Key,Compare,Alloc@\removedConcepts{ator}@>&);
     void clear();
 
     // observers:
@@ -5716,40 +5730,40 @@
     pair<const_iterator,const_iterator> equal_range(const key_type& x) const;
   };
 
-  template <@\changedConcepts{class}{EqualityComparable}@ Key, class Compare, class Allocator>
-    bool operator==(const set<Key,Compare,Allocator>& x,
-                    const set<Key,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Allocator>
-    bool operator< (const set<Key,Compare,Allocator>& x,
-                    const set<Key,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{EqualityComparable}@ Key, class Compare, class Allocator>
-    bool operator!=(const set<Key,Compare,Allocator>& x,
-                    const set<Key,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Allocator>
-    bool operator> (const set<Key,Compare,Allocator>& x,
-                    const set<Key,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Allocator>
-    bool operator>=(const set<Key,Compare,Allocator>& x,
-                    const set<Key,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Allocator>
-    bool operator<=(const set<Key,Compare,Allocator>& x,
-                    const set<Key,Compare,Allocator>& y);
+  template <@\changedConcepts{class}{EqualityComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator==(const set<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const set<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator< (const set<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const set<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{EqualityComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator!=(const set<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const set<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator> (const set<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const set<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator>=(const set<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const set<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator<=(const set<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const set<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
 
   // specialized algorithms:
-  template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Allocator>
-    void swap(set<Key,Compare,Allocator>& x,
-              set<Key,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Allocator>
-    void swap(set<Key,Compare,Allocator&& x,
-              set<Key,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Allocator>
-    void swap(set<Key,Compare,Allocator& x,
-              set<Key,Compare,Allocator>&& y);
-
-  template <class Key, class Compare, class Alloc>
-    struct constructible_with_allocator_suffix<
-      set<Key, Compare, Alloc> >
-        : true_type { };
+  template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+    void swap(set<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+              set<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+    void swap(set<Key,Compare,Alloc@\removedConcepts{ator}@&& x,
+              set<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+    void swap(set<Key,Compare,Alloc@\removedConcepts{ator}@& x,
+              set<Key,Compare,Alloc@\removedConcepts{ator}@>&& y);
+
+  @\removedConcepts{template <class Key, class Compare, class Alloc>}@
+    @\removedConcepts{struct constructible_with_allocator_suffix<}@
+      @\removedConcepts{set<Key, Compare, Alloc> >}@
+        @\removedConcepts{: true_type \{ \};}@
 }
 \end{codeblock}%
 \index{set@\tcode{set}!\tcode{operator==}}%
@@ -5759,7 +5773,7 @@
 
 \begin{itemdecl}
 explicit set(const Compare& comp = Compare(),
-             const Allocator& = Allocator());
+             const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -5776,7 +5790,7 @@
 template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
   @\addedConcepts{requires HasConstructor<value_type, Iter::reference>}@
   set(@\changedConcepts{InputIterator}{Iter}@ @\farg{first}@, @\changedConcepts{InputIterator}{Iter}@ @\farg{last}@,
-      const Compare& @\farg{comp}@ = Compare(), const Allocator& = Allocator());
+      const Compare& @\farg{comp}@ = Compare(), const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -5806,15 +5820,15 @@
 \rSec3[set.special]{\tcode{set}\ specialized algorithms}
 
 \begin{itemdecl}
-template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Allocator>
-  void swap(set<Key,Compare,Allocator>& x,
-            set<Key,Compare,Allocator>& y);
-template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Allocator>
-  void swap(set<Key,Compare,Allocator>&& x,
-            set<Key,Compare,Allocator>& y);
-template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Allocator>
-  void swap(set<Key,Compare,Allocator>& x,
-            set<Key,Compare,Allocator>&& y);
+template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+  void swap(set<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+            set<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+  void swap(set<Key,Compare,Alloc@\removedConcepts{ator}@>&& x,
+            set<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+  void swap(set<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+            set<Key,Compare,Alloc@\removedConcepts{ator}@>&& y);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -5872,8 +5886,10 @@
 \begin{codeblock}
 namespace std {
   template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{Predicate<auto, Key, Key>}@ Compare = less<Key>,
-            class Allocator = allocator<Key> >
+            @\changedConcepts{class}{Allocator}@ Alloc@\removedConcepts{ator}@ = allocator<Key> >
   @\addedConcepts{requires Destructible<Key> \&\& CopyConstructible<Compare>}@
+           @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Compare, const Compare\&>}@
+           @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Compare, Compare\&\&>}@
   class multiset {
   public:
     // types:
@@ -5881,35 +5897,35 @@
     typedef Key                                   value_type;
     typedef Compare                               key_compare;
     typedef Compare                               value_compare;
-    typedef Allocator                             allocator_type;
-    typedef typename Allocator::reference         reference;
-    typedef typename Allocator::const_reference   const_reference;
+    typedef Alloc@\removedConcepts{ator}@                             allocator_type;
+    typedef typename Alloc@\removedConcepts{ator}@::reference         reference;
+    typedef typename Alloc@\removedConcepts{ator}@::const_reference   const_reference;
     typedef @\impdef@                iterator;       // See \ref{container.requirements}
     typedef @\impdef@                const_iterator; // See \ref{container.requirements}
     typedef @\impdef@                size_type;      // See \ref{container.requirements}
     typedef @\impdef@                difference_type;// See \ref{container.requirements}
-    typedef typename Allocator::pointer           pointer;
-    typedef typename Allocator::const_pointer     const_pointer;
+    typedef typename Alloc@\removedConcepts{ator}@::pointer           pointer;
+    typedef typename Alloc@\removedConcepts{ator}@::const_pointer     const_pointer;
     typedef std::reverse_iterator<iterator>       reverse_iterator;
     typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
 
     // construct/copy/destroy:
     explicit multiset(const Compare& comp = Compare(),
-                      const Allocator& = Allocator());
+                      const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
     template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
       @\addedConcepts{requires HasConstructor<value_type, Iter::reference>}@
       multiset(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last,
                const Compare& comp = Compare(),
-               const Allocator& = Allocator());
-    @\addedConcepts{requires CopyConstructible<value_type>}@ multiset(const multiset<Key,Compare,Allocator>& x);
-    multiset(multiset<Key,Compare,Allocator>&& x);
-    multiset(const Allocator&);
-    @\addedConcepts{requires CopyConstructible<value_type>}@ multiset(const multiset&, const Allocator&);
-    multiset(multiset&&, const Allocator&);
+               const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ multiset(const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& x);
+    multiset(multiset<Key,Compare,Alloc@\removedConcepts{ator}@>&& x);
+    multiset(const Alloc@\removedConcepts{ator}@&);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ multiset(const multiset&, const Alloc@\removedConcepts{ator}@&);
+    multiset(multiset&&, const Alloc@\removedConcepts{ator}@&);
    ~multiset();
-    @\addedConcepts{requires CopyConstructible<value_type> \&\& CopyAssignable<value_type>}@
-      multiset<Key,Compare,Allocator>& operator=(const multiset<Key,Compare,Allocator>& x);
-    multiset<Key,Compare,Allocator>& operator=(multiset<Key,Compare,Allocator>&& x);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&> \&\& CopyAssignable<value_type>}@
+      multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& operator=(const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& x);
+    multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& operator=(multiset<Key,Compare,Alloc@\removedConcepts{ator}@>&& x);
     allocator_type get_allocator() const;
 
     // iterators:
@@ -5940,10 +5956,10 @@
     template <class... Args> 
       @\addedConcepts{requires HasConstructor<value_type, Args\&\&...>}@
       iterator emplace(const_iterator position, Args&&... args);
-    @\addedConcepts{requires CopyConstructible<value_type>}@ iterator insert(const value_type& x);
-    @\addedConcepts{requires MoveConstructible<value_type>}@ iterator insert(value_type&& x);
-    @\addedConcepts{requires CopyConstructible<value_type>}@ iterator insert(const_iterator position, const value_type& x);
-    @\addedConcepts{requires MoveConstructible<value_type>}@ iterator insert(const_iterator position, value_type&& x);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ iterator insert(const value_type& x);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, value_type\&\&>}@ iterator insert(value_type&& x);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ iterator insert(const_iterator position, const value_type& x);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, value_type\&\&>}@ iterator insert(const_iterator position, value_type&& x);
     template <@\changedConcepts{class InputIterator}{InputIterator Iter}@>
       @\addedConcepts{requires HasConstructor<value_type, Iter::reference>}@
       void insert(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last);
@@ -5951,7 +5967,7 @@
     iterator  erase(const_iterator position);
     size_type erase(const key_type& x);
     iterator  erase(const_iterator first, const_iterator last);
-    void swap(multiset<Key,Compare,Allocator>&&);
+    void swap(multiset<Key,Compare,Alloc@\removedConcepts{ator}@>&&);
     void clear();
 
     // observers:
@@ -5974,40 +5990,40 @@
     pair<const_iterator,const_iterator> equal_range(const key_type& x) const;
   };
 
-  template <@\changedConcepts{class}{EqualityComparable}@ Key, class Compare, class Allocator>
-    bool operator==(const multiset<Key,Compare,Allocator>& x,
-                    const multiset<Key,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Allocator>
-    bool operator< (const multiset<Key,Compare,Allocator>& x,
-                    const multiset<Key,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{EqualityComparable}@ Key, class Compare, class Allocator>
-    bool operator!=(const multiset<Key,Compare,Allocator>& x,
-                    const multiset<Key,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Allocator>
-    bool operator> (const multiset<Key,Compare,Allocator>& x,
-                    const multiset<Key,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Allocator>
-    bool operator>=(const multiset<Key,Compare,Allocator>& x,
-                    const multiset<Key,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Allocator>
-    bool operator<=(const multiset<Key,Compare,Allocator>& x,
-                    const multiset<Key,Compare,Allocator>& y);
+  template <@\changedConcepts{class}{EqualityComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator==(const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator< (const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{EqualityComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator!=(const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator> (const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator>=(const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{LessThanComparable}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+    bool operator<=(const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+                    const multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
 
   // specialized algorithms:
-  template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Allocator>
-    void swap(multiset<Key,Compare,Allocator>& x,
-              multiset<Key,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Allocator>
-    void swap(multiset<Key,Compare,Allocator&& x,
-              multiset<Key,Compare,Allocator>& y);
-  template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Allocator>
-    void swap(multiset<Key,Compare,Allocator& x,
-              multiset<Key,Compare,Allocator>&& y);
-
-  template <class Key, class Compare, class Alloc>
-    struct constructible_with_allocator_suffix<
-      multiset<Key, Compare, Alloc> >
-        : true_type { };
+  template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+    void swap(multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+              multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+    void swap(multiset<Key,Compare,Alloc@\removedConcepts{ator}@&& x,
+              multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+  template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+    void swap(multiset<Key,Compare,Alloc@\removedConcepts{ator}@& x,
+              multiset<Key,Compare,Alloc@\removedConcepts{ator}@>&& y);
+
+  @\removedConcepts{template <class Key, class Compare, class Alloc>}@
+    @\removedConcepts{struct constructible_with_allocator_suffix<}@
+      @\removedConcepts{multiset<Key, Compare, Alloc> >}@
+        @\removedConcepts{: true_type \{ \};}@
 }
 \end{codeblock}%
 \index{multiset@\tcode{multiset}!\tcode{operator==}}%
@@ -6017,7 +6033,7 @@
 
 \begin{itemdecl}
 explicit multiset(const Compare& @\farg{comp}@ = Compare(),
-                  const Allocator& = Allocator());
+                  const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -6035,7 +6051,7 @@
   @\addedConcepts{requires HasConstructor<value_type, Iter::reference>}@
   multiset(@\changedConcepts{InputIterator}{Iter}@ @\farg{first}@, @\changedConcepts{InputIterator}{Iter}@ @\farg{last}@,
            const Compare& @\farg{comp}@ = Compare(),
-           const Allocator& = Allocator());
+           const Alloc@\removedConcepts{ator}@& = Alloc@\removedConcepts{ator}@());
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -6065,15 +6081,15 @@
 \rSec3[multiset.special]{\tcode{multiset}\ specialized algorithms}
 
 \begin{itemdecl}
-template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Allocator>
-  void swap(multiset<Key,Compare,Allocator>& x,
-            multiset<Key,Compare,Allocator>& y);
-template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Allocator>
-  void swap(multiset<Key,Compare,Allocator>&& x,
-            multiset<Key,Compare,Allocator>& y);
-template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Allocator>
-  void swap(multiset<Key,Compare,Allocator>& x,
-            multiset<Key,Compare,Allocator>&& y);
+template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+  void swap(multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+            multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+  void swap(multiset<Key,Compare,Alloc@\removedConcepts{ator}@>&& x,
+            multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& y);
+template <@\changedConcepts{class}{ObjectType}@ Key, class Compare, class Alloc@\removedConcepts{ator}@>
+  void swap(multiset<Key,Compare,Alloc@\removedConcepts{ator}@>& x,
+            multiset<Key,Compare,Alloc@\removedConcepts{ator}@>&& y);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -6100,9 +6116,13 @@
             @\changedConcepts{class}{ObjectType}@ T,
             @\changedConcepts{class}{Callable<auto, Key>}@ Hash = hash<Key>,
             @\changedConcepts{class}{Predicate<auto, Key, Key>}@ Pred = std::equal_to<Key>,
-            class Alloc = std::allocator<std::pair<const Key, T> > >
+            @\changedConcepts{class}{Allocator}@ Alloc = std::allocator<std::pair<const Key, T> > >
     @\addedConcepts{requires SameType<Hash::result_type, std::size_t>}@
              @\addedConcepts{\&\& CopyConstructible<Hash> \&\& CopyConstructible<Pred>}@
+             @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Pred, const Pred\&>}@
+             @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Pred, Pred\&\&>}@
+             @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Hash, const Hash\&>}@
+             @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Hash, Hash\&\&>}@
     class unordered_map;
 
   // \ref{unord.multimap}, class template unordered_multimap:
@@ -6110,9 +6130,13 @@
             @\changedConcepts{class}{ObjectType}@ T,
             @\changedConcepts{class}{Callable<auto, Key>}@ Hash = hash<Key>,
             @\changedConcepts{class}{Predicate<auto, Key, Key>}@ Pred = std::equal_to<Key>,
-            class Alloc = std::allocator<std::pair<const Key, T> > >
+            @\changedConcepts{class}{Allocator}@ Alloc = std::allocator<std::pair<const Key, T> > >
     @\addedConcepts{requires SameType<Hash::result_type, std::size_t>}@
              @\addedConcepts{\&\& CopyConstructible<Hash> \&\& CopyConstructible<Pred>}@
+             @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Pred, const Pred\&>}@
+             @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Pred, Pred\&\&>}@
+             @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Hash, const Hash\&>}@
+             @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Hash, Hash\&\&>}@
     class unordered_multimap;
 
   template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Hash, class Pred, class Alloc>
@@ -6135,18 +6159,26 @@
   template <@\changedConcepts{class}{ObjectType}@ Value,
             @\changedConcepts{class}{Callable<auto, Value>}@ Hash = hash<Value>,
             @\changedConcepts{class}{Predicate<auto, Value, Value>}@ class Pred = std::equal_to<Value>,
-            class Alloc = std::allocator<Value> >
+            @\changedConcepts{class}{Allocator}@ Alloc = std::allocator<Value> >
     @\addedConcepts{requires SameType<Hash::result_type, std::size_t>}@
              @\addedConcepts{\&\& CopyConstructible<Hash> \&\& CopyConstructible<Pred>}@
+             @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Pred, const Pred\&>}@
+             @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Pred, Pred\&\&>}@
+             @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Hash, const Hash\&>}@
+             @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Hash, Hash\&\&>}@
     class unordered_set;
 
   // \ref{unord.multiset}, class template unordered_multiset:
   template <@\changedConcepts{class}{ObjectType}@ Value,
             @\changedConcepts{class}{Callable<auto, Value>}@ Hash = hash<Value>,
             @\changedConcepts{class}{Predicate<auto, Value, Value>}@ class Pred = std::equal_to<Value>,
-            class Alloc = std::allocator<Value> >
+            @\changedConcepts{class}{Allocator}@ Alloc = std::allocator<Value> >
     @\addedConcepts{requires SameType<Hash::result_type, std::size_t>}@
              @\addedConcepts{\&\& CopyConstructible<Hash> \&\& CopyConstructible<Pred>}@
+             @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Pred, const Pred\&>}@
+             @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Pred, Pred\&\&>}@
+             @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Hash, const Hash\&>}@
+             @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Hash, Hash\&\&>}@
     class unordered_multiset;
 
   template <@\changedConcepts{class}{ObjectType}@ Value, class Hash, class Pred, class Alloc>
@@ -6186,9 +6218,13 @@
             @\changedConcepts{class}{ObjectType}@ T,
             @\changedConcepts{class}{Callable<auto, Key>}@ Hash = hash<Key>,
             @\changedConcepts{class}{Predicate<auto, Key, Key>}@ Pred = std::equal_to<Key>,
-            class Alloc = std::allocator<std::pair<const Key, T> > >
+            @\changedConcepts{class}{Allocator}@ Alloc = std::allocator<std::pair<const Key, T> > >
   @\addedConcepts{requires SameType<Hash::result_type, std::size_t>}@
            @\addedConcepts{\&\& CopyConstructible<Hash> \&\& CopyConstructible<Pred>}@
+           @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Pred, const Pred\&>}@
+           @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Pred, Pred\&\&>}@
+           @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Hash, const Hash\&>}@
+           @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Hash, Hash\&\&>}@
   class unordered_map
   {
   public:
@@ -6223,12 +6259,12 @@
                     const hasher& hf = hasher(),
                     const key_equal& eql = key_equal(),
                     const allocator_type& a = allocator_type());
-    @\addedConcepts{requires CopyConstructible<value_type>}@ unordered_map(const unordered_map&);
-    unordered_map(const Allocator&);
-    @\addedConcepts{requires CopyConstructible<value_type>}@ unordered_map(const unordered_map&, const Allocator&);
-    unordered_map(unordered_map&&, const Allocator&);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ unordered_map(const unordered_map&);
+    unordered_map(const Alloc@\removedConcepts{ator}@&);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ unordered_map(const unordered_map&, const Alloc@\removedConcepts{ator}@&);
+    unordered_map(unordered_map&&, const Alloc@\removedConcepts{ator}@&);
     ~unordered_map();
-    @\addedConcepts{requires CopyConstructible<value_type> \&\& CopyAssignable<value_type>}@ 
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&> \&\& CopyAssignable<value_type>}@ 
       unordered_map& operator=(const unordered_map&);
     allocator_type get_allocator() const;
 
@@ -6252,9 +6288,9 @@
     template <class... Args> 
       @\addedConcepts{requires HasConstructor<value_type, Args\&\&...>}@
       iterator emplace(const_iterator position, Args&&... args);
-    @\addedConcepts{requires CopyConstructible<value_type>}@
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@
       std::pair<iterator, bool> insert(const value_type& obj);
-    @\addedConcepts{requires CopyConstructible<value_type>}@
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@
       iterator insert(const_iterator hint, const value_type& obj);
     template <@\changedConcepts{class InputIterator}{InputIterator Iter}@> 
       @\addedConcepts{requires HasConstructor<value_type, Iter::reference>}@
@@ -6278,7 +6314,7 @@
     std::pair<iterator, iterator>             equal_range(const key_type& k);
     std::pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
 
-    @\addedConcepts{requires DefaultConstructible<T> \&\& CopyConstructible<key_type>}@ mapped_type& operator[](const key_type& k);
+    @\addedConcepts{requires DefaultConstructible<T> \&\& CopyConstructible<Key>}@ mapped_type& operator[](const key_type& k);
 
     // bucket interface
     size_type bucket_count() const;
@@ -6294,17 +6330,17 @@
     float load_factor() const;
     float max_load_factor() const;
     void max_load_factor(float z);
-    @\addedConcepts{requires MoveConstructible<value_type>}@ void rehash(size_type n);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, value_type\&\&>}@ void rehash(size_type n);
   };
 
   template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Hash, class Pred, class Alloc>
     void swap(unordered_map<Key, T, Hash, Pred, Alloc>& x,
               unordered_map<Key, T, Hash, Pred, Alloc>& y);
 
-  template <class Key, class T, class Hash, class Pred, class Alloc>
-    struct constructible_with_allocator_suffix<
-      unordered_map<Key, T, Hash, Pred, Compare, Alloc> >
-        : true_type { };
+  @\removedConcepts{template <class Key, class T, class Hash, class Pred, class Alloc>}@
+    @\removedConcepts{struct constructible_with_allocator_suffix<}@
+      @\removedConcepts{unordered_map<Key, T, Hash, Pred, Compare, Alloc> >}@
+        @\removedConcepts{: true_type \{ \};}@
 }
 \end{codeblock}
 
@@ -6360,7 +6396,7 @@
 \index{operator[]@\tcode{operator[]}!unordered_map@\tcode{unordered_map}}%
 \index{unordered_map@\tcode{unordered_map}!element access}%
 \begin{itemdecl}
-@\addedConcepts{requires DefaultConstructible<T> \&\& CopyConstructible<key_type>}@ mapped_type& operator[](const key_type& k);
+@\addedConcepts{requires DefaultConstructible<T> \&\& CopyConstructible<Key>}@ mapped_type& operator[](const key_type& k);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -6416,9 +6452,13 @@
             @\changedConcepts{class}{ObjectType}@ T,
             @\changedConcepts{class}{Callable<auto, Key>}@ Hash = hash<Key>,
             @\changedConcepts{class}{Predicate<auto, Key, Key>}@ Pred = std::equal_to<Key>,
-            class Alloc = std::allocator<std::pair<const Key, T> > >
+            @\changedConcepts{class}{Allocator}@ Alloc = std::allocator<std::pair<const Key, T> > >
   @\addedConcepts{requires SameType<Hash::result_type, std::size_t>}@
            @\addedConcepts{\&\& CopyConstructible<Hash> \&\& CopyConstructible<Pred>}@
+           @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Pred, const Pred\&>}@
+           @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Pred, Pred\&\&>}@
+           @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Hash, const Hash\&>}@
+           @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Hash, Hash\&\&>}@
   class unordered_multimap
   {
   public:
@@ -6453,13 +6493,13 @@
                          const hasher& hf = hasher(),
                          const key_equal& eql = key_equal(),
                          const allocator_type& a = allocator_type());
-    @\addedConcepts{requires CopyConstructible<value_type>}@ unordered_multimap(const unordered_multimap&);
-    unordered_multimap(const Allocator&);
-    @\addedConcepts{requires CopyConstructible<value_type>}@
-       unordered_multimap(const unordered_multimap&, const Allocator&);
-    unordered_multimap(unordered_multimap&&, const Allocator&);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ unordered_multimap(const unordered_multimap&);
+    unordered_multimap(const Alloc@\removedConcepts{ator}@&);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@
+       unordered_multimap(const unordered_multimap&, const Alloc@\removedConcepts{ator}@&);
+    unordered_multimap(unordered_multimap&&, const Alloc@\removedConcepts{ator}@&);
     ~unordered_multimap();
-    @\addedConcepts{requires CopyConstructible<value_type> \&\& CopyAssignable<value_type>}@ 
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&> \&\& CopyAssignable<value_type>}@ 
       unordered_multimap& operator=(const unordered_multimap&);
     allocator_type get_allocator() const;
 
@@ -6483,8 +6523,8 @@
     template <class... Args> 
       @\addedConcepts{requires HasConstructor<value_type, Args\&\&...>}@
       iterator emplace(const_iterator position, Args&&... args);
-    @\addedConcepts{requires CopyConstructible<value_type>}@ iterator insert(const value_type& obj);
-    @\addedConcepts{requires CopyConstructible<value_type>}@ 
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ iterator insert(const value_type& obj);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ 
       iterator insert(const_iterator hint, const value_type& obj);
     template <@\changedConcepts{class InputIterator}{InputIterator Iter}@> 
       void insert(@\changedConcepts{InputIterator}{Iter}@ first, @\changedConcepts{InputIterator}{Iter}@ last);
@@ -6521,17 +6561,17 @@
     float load_factor() const;
     float max_load_factor() const;
     void max_load_factor(float z);
-    @\addedConcepts{requires MoveConstructible<value_type>}@ void rehash(size_type n);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, value_type\&\&>}@ void rehash(size_type n);
   };
 
   template <@\changedConcepts{class}{ObjectType}@ Key, @\changedConcepts{class}{ObjectType}@ T, class Hash, class Pred, class Alloc>
     void swap(unordered_multimap<Key, T, Hash, Pred, Alloc>& x,
               unordered_multimap<Key, T, Hash, Pred, Alloc>& y);
 
-  template <class Key, class T, class Hash, class Pred, class Alloc>
-    struct constructible_with_allocator_suffix<
-      unordered_multimap<Key, T, Hash, Pred, Alloc> >
-        : true_type { };
+  @\removedConcepts{template <class Key, class T, class Hash, class Pred, class Alloc>}@
+    @\removedConcepts{struct constructible_with_allocator_suffix<}@
+      @\removedConcepts{unordered_multimap<Key, T, Hash, Pred, Alloc> >}@
+        @\removedConcepts{: true_type \{ \};}@
 }
 \end{codeblock}
 
@@ -6622,9 +6662,13 @@
   template <@\changedConcepts{class}{ObjectType}@ Value,
             @\changedConcepts{class}{Callable<auto, Value>}@ Hash = hash<Value>,
             @\changedConcepts{class}{Predicate<auto, Value, Value>}@ class Pred = std::equal_to<Value>,
-            class Alloc = std::allocator<Value> >
+            @\changedConcepts{class}{Allocator}@ Alloc = std::allocator<Value> >
   @\addedConcepts{requires SameType<Hash::result_type, std::size_t>}@
            @\addedConcepts{\&\& CopyConstructible<Hash> \&\& CopyConstructible<Pred>}@
+           @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Pred, const Pred\&>}@
+           @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Pred, Pred\&\&>}@
+           @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Hash, const Hash\&>}@
+           @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Hash, Hash\&\&>}@
   class unordered_set
   {
   public:
@@ -6658,12 +6702,12 @@
                     const hasher& hf = hasher(),
                     const key_equal& eql = key_equal(),
                     const allocator_type& a = allocator_type());
-    @\addedConcepts{requires CopyConstructible<value_type>}@ unordered_set(const unordered_set&);
-    unordered_set(const Allocator&);
-    @\addedConcepts{requires CopyConstructible<value_type>}@ unordered_set(const unordered_set&, const Allocator&);
-    unordered_set(unordered_set&&, const Allocator&);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ unordered_set(const unordered_set&);
+    unordered_set(const Alloc@\removedConcepts{ator}@&);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ unordered_set(const unordered_set&, const Alloc@\removedConcepts{ator}@&);
+    unordered_set(unordered_set&&, const Alloc@\removedConcepts{ator}@&);
     ~unordered_set();
-    @\addedConcepts{requires CopyConstructible<value_type> \&\& CopyAssignable<value_type>}@ 
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&> \&\& CopyAssignable<value_type>}@ 
       unordered_set& operator=(const unordered_set&);
     allocator_type get_allocator() const;
 
@@ -6687,8 +6731,8 @@
     template <class... Args> 
       @\addedConcepts{requires HasConstructor<value_type, Args\&\&...>}@
       iterator emplace(const_iterator position, Args&&... args);
-    @\addedConcepts{requires CopyConstructible<value_type>}@ std::pair<iterator, bool> insert(const value_type& obj);
-    @\addedConcepts{requires CopyConstructible<value_type>}@ 
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ std::pair<iterator, bool> insert(const value_type& obj);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ 
       iterator insert(const_iterator hint, const value_type& obj);
     template <@\changedConcepts{class InputIterator}{InputIterator Iter}@> 
       @\addedConcepts{requires HasConstructor<value_type, Iter::reference>}@
@@ -6726,17 +6770,17 @@
     float load_factor() const;
     float max_load_factor() const;
     void max_load_factor(float z);
-    @\addedConcepts{requires MoveConstructible<value_type>}@ void rehash(size_type n);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, value_type\&\&>}@ void rehash(size_type n);
   };
 
   template <@\changedConcepts{class}{ObjectType}@ Value, class Hash, class Pred, class Alloc>
     void swap(unordered_set<Value, Hash, Pred, Alloc>& x,
               unordered_set<Value, Hash, Pred, Alloc>& y);
 
-  template <class Value, class Hash, class Pred, class Alloc>
-    struct constructible_with_allocator_suffix<
-      map<Value, Hash, Pred, Alloc> >
-        : true_type { };
+  @\removedConcepts{template <class Value, class Hash, class Pred, class Alloc>}@
+    @\removedConcepts{struct constructible_with_allocator_suffix<}@
+      @\removedConcepts{map<Value, Hash, Pred, Alloc> >}@
+        @\removedConcepts{: true_type \{ \};}@
 }
 \end{codeblock}
 
@@ -6826,9 +6870,13 @@
   template <@\changedConcepts{class}{ObjectType}@ Value,
             @\changedConcepts{class}{Callable<auto, Value>}@ Hash = hash<Value>,
             @\changedConcepts{class}{Predicate<auto, Value, Value>}@ class Pred = std::equal_to<Value>,
-            class Alloc = std::allocator<Value> >
+            @\changedConcepts{class}{Allocator}@ Alloc = std::allocator<Value> >
   @\addedConcepts{requires SameType<Hash::result_type, std::size_t>}@
            @\addedConcepts{\&\& CopyConstructible<Hash> \&\& CopyConstructible<Pred>}@
+           @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Pred, const Pred\&>}@
+           @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Pred, Pred\&\&>}@
+           @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Hash, const Hash\&>}@
+           @\addedConcepts{\&\& ConstructibleAsElement<Alloc, Hash, Hash\&\&>}@
   class unordered_multiset
   {
   public:
@@ -6862,12 +6910,12 @@
                          const hasher& hf = hasher(),
                          const key_equal& eql = key_equal(),
                          const allocator_type& a = allocator_type());
-    @\addedConcepts{requires CopyConstructible<value_type>}@ unordered_multiset(const unordered_multiset&);
-    unordered_multiset(const Allocator&);
-    @\addedConcepts{requires CopyConstructible<value_type>}@ unordered_multiset(const unordered_multiset&, const Allocator&);
-    unordered_multiset(unordered_multiset&&, const Allocator&);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ unordered_multiset(const unordered_multiset&);
+    unordered_multiset(const Alloc@\removedConcepts{ator}@&);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ unordered_multiset(const unordered_multiset&, const Alloc@\removedConcepts{ator}@&);
+    unordered_multiset(unordered_multiset&&, const Alloc@\removedConcepts{ator}@&);
     ~unordered_multiset();
-    @\addedConcepts{requires CopyConstructible<value_type> \&\& CopyAssignable<value_type>}@ 
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&> \&\& CopyAssignable<value_type>}@ 
       unordered_multiset& operator=(const unordered_multiset&);
     allocator_type get_allocator() const;
 
@@ -6891,8 +6939,8 @@
     template <class... Args> 
       @\addedConcepts{requires HasConstructor<value_type, Args\&\&...>}@
       iterator emplace(const_iterator position, Args&&... args);
-    @\addedConcepts{requires CopyConstructible<value_type>}@ iterator insert(const value_type& obj);
-    @\addedConcepts{requires CopyConstructible<value_type>}@ 
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ iterator insert(const value_type& obj);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, const value_type\&>}@ 
       iterator insert(const_iterator hint, const value_type& obj);
     template <@\changedConcepts{class InputIterator}{InputIterator Iter}@> 
       @\addedConcepts{requires HasConstructor<value_type, Iter::value_type>}@
@@ -6930,17 +6978,17 @@
     float load_factor() const;
     float max_load_factor() const;
     void max_load_factor(float z);
-    @\addedConcepts{requires MoveConstructible<value_type>}@ void rehash(size_type n);
+    @\addedConcepts{requires ConstructibleAsElement<Alloc, value_type, value_type\&\&>}@ void rehash(size_type n);
   };
 
   template <@\changedConcepts{class}{ObjectType}@ Value, class Hash, class Pred, class Alloc>
     void swap(unordered_multiset<Value, Hash, Pred, Alloc>& x,
               unordered_multiset<Value, Hash, Pred, Alloc>& y);
 
-  template <class Value, class Hash, class Pred, class Alloc>
-    struct constructible_with_allocator_suffix<
-      unordered_multiset<Value, Hash, Pred, Alloc> >
-        : true_type { };
+  @\removedConcepts{template <class Value, class Hash, class Pred, class Alloc>}@
+    @\removedConcepts{struct constructible_with_allocator_suffix<}@
+      @\removedConcepts{unordered_multiset<Value, Hash, Pred, Alloc> >}@
+        @\removedConcepts{: true_type \{ \};}@
 }
 \end{codeblock}