->Change "insert" and "push_back"/"push_front" to catch non-const rvalues
->Add an example with stateful allocators
->Add test to check convertible types in push_back/insert
->Add SCARY iterators.
->Align with C++11 [multi]map::insert(P &&p) overload.
->Unify all allocator version traits in one class (starting from stable_vector_detail::allocator_version_wrapper)
   maybe in allocator_traits?


Review allocator traits
-> Avoid any rebind<>::other
-> Review select_on_container_copy_xxx
-> Review propagate_on_xxx
-> Put default constructed containers with their own constructor (different nothrow guarantees). Optimization, not needed
-> Default + swap move constructors correct?
-> Review container documentation in swap/copy/move regarding allocators

Check all move constructors: swap might not be a valid idiom, allocators must be move constructed,
intrusive containers are now movable

Add and test:

Test different propagation values and with inequal allocators

propagate_on_container_move_assignment
select_on_container_copy_construction
propagate_on_container_swap
propagate_on_container_copy_assignment

Test move constructors with data values and unequal allocators

An allocator should use a smart allocator not constructible from raw pointers to catch missing pointer_traits calls

Add initializer lists

Write forward_list

check move if noexcept conditions in vector, deque and stable_vector

Add noexcept testing using static_assert (Howard Hinnants's suggestion):

   #include <type_traits>

   struct A
   {
      void foo() noexcept;
   };

   static_assert(noexcept(std::declval<A&>().foo()), "A::foo() should be noexcept");

Detect always equal or unequal allocators at compiler time. operator== returns true_type or false_type

change virtual functions with pointers to avoid template instantiation for every type

Add hash for containers

Add std:: hashing support

Fix trivial destructor after move and other optimizing traits

Mark previous() in slist/and forward_list as non-standard

Function order:

----------type------------
value_type;
pointer;
const_pointer;
reference;
const_reference;
size_type;
difference_type;
allocator_type;
stored_allocator_type;
iterator;
const_iterator;
reverse_iterator;
const_reverse_iterator;
----------func------------
container()
container(allocator_type)
container(size_type)
container(size_type, value_type, allocator_type = ())
container(InpIt, InpIt)
container(const container &)
container(container &&)
container(const container &, allocator_type)
container(container &&, allocator_type)
container(initializer_list<T>, allocator)
~container()
container operator=(const container &)
container operator=(container &&)
container operator=(initializer_list<T>)
assign(size_type, const T &)

assign(InpIt, InptIt)
assign(initializer_list)
get_allocator()

begin()
begin() const
end()
end() const
rbegin()
rbegin() const
rend()
rend() const

cbegin() const
cend() const
crbegin() const
crend() const

empty()
size()
max_size()
resize(size_type)
resize(size_type, cont T&)
capacity()
reserve(size_type)
shrink_to_fit()

front()
front() const
back()
back() const
operator[] ()
operator[] ()const
at()
at() const


data()
data() const

emplace_front()
emplace_back()
emplace()
push_front(const T&)
push_front(T&&)
push_back(const T&)
push_back(T&&)
insert(iterator, const T &)
insert(iterator, T &&)
insert(size_type, const T &)
insert(InpIt, InpIt)
pop_front()
pop_back()
erase(const_iterator)
erase(const_iterator, const_iterator)
swap(container &)
clear()