diff --git a/libcxx/include/iterator b/libcxx/include/iterator
--- a/libcxx/include/iterator
+++ b/libcxx/include/iterator
@@ -68,6 +68,14 @@
 template<class Out, class T>
   concept indirectly_writable = see below;                // since C++20
 
+// [iterator.concept.winc], concept weakly_­incrementable
+template<class I>
+  concept weakly_incrementable = see below;                // since C++20
+
+// [iterator.concept.inc], concept incrementable
+template<class I>
+  concept incrementable = see below;                       // since C++20
+
 template<class Category, class T, class Distance = ptrdiff_t,
          class Pointer = T*, class Reference = T&>
 struct iterator
@@ -2544,6 +2552,32 @@
     const_cast<const iter_reference_t<_Out>&&>(*_VSTD::forward<_Out>(__o)) = _VSTD::forward<_Tp>(__t); // not required to be equality-preserving
   };
 
+// [iterator.concept.winc]
+template<class _Tp>
+inline constexpr bool __is_signed_integer_like = signed_integral<_Tp>;
+
+template<class _Ip>
+concept weakly_incrementable =
+  default_initializable<_Ip> &&
+  movable<_Ip> &&
+  requires(_Ip __i) {
+    typename iter_difference_t<_Ip>;
+    requires __is_signed_integer_like<iter_difference_t<_Ip>>;
+    { ++__i } -> same_as<_Ip&>;   // not required to be equality-preserving
+    __i++;                        // not required to be equality-preserving
+  };
+
+// [iterator.concept.inc]
+template<class _Ip>
+concept incrementable =
+  regular<_Ip> &&
+  weakly_incrementable<_Ip> &&
+  requires(_Ip __i) {
+    { __i++ } -> same_as<_Ip>;
+  };
+
+// [iterator.concept.inc]
+
 #undef _LIBCPP_NOEXCEPT_RETURN
 #endif // !defined(_LIBCPP_HAS_NO_RANGES)
 
diff --git a/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/incrementable.h b/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/incrementable.h
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/incrementable.h
@@ -0,0 +1,195 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+#ifndef LIBCPP_TEST_STD_ITERATORS_ITERATOR_REQUIREMENTS_ITERATOR_CONCEPTS_INCREMENTABLE_H
+#define LIBCPP_TEST_STD_ITERATORS_ITERATOR_REQUIREMENTS_ITERATOR_CONCEPTS_INCREMENTABLE_H
+
+struct postfix_increment_returns_void {
+  using difference_type = int;
+  postfix_increment_returns_void& operator++();
+  void operator++(int);
+};
+
+struct postfix_increment_returns_copy {
+  using difference_type = int;
+  postfix_increment_returns_copy& operator++();
+  postfix_increment_returns_copy operator++(int);
+};
+
+struct has_integral_minus {
+  has_integral_minus& operator++();
+  has_integral_minus operator++(int);
+
+  long operator-(has_integral_minus) const;
+};
+
+struct has_distinct_difference_type_and_minus {
+  using difference_type = short;
+
+  has_distinct_difference_type_and_minus& operator++();
+  has_distinct_difference_type_and_minus operator++(int);
+
+  long operator-(has_distinct_difference_type_and_minus) const;
+};
+
+struct missing_difference_type {
+  missing_difference_type& operator++();
+  void operator++(int);
+};
+
+struct floating_difference_type {
+  using difference_type = float;
+
+  floating_difference_type& operator++();
+  void operator++(int);
+};
+
+struct non_const_minus {
+  non_const_minus& operator++();
+  non_const_minus operator++(int);
+
+  long operator-(non_const_minus);
+};
+
+struct non_integral_minus {
+  non_integral_minus& operator++();
+  non_integral_minus operator++(int);
+
+  void operator-(non_integral_minus);
+};
+
+struct bad_difference_type_good_minus {
+  using difference_type = float;
+
+  bad_difference_type_good_minus& operator++();
+  void operator++(int);
+
+  int operator-(bad_difference_type_good_minus) const;
+};
+
+struct missing_default_initializable {
+  using difference_type = int;
+  missing_default_initializable() = delete;
+
+  missing_default_initializable& operator++();
+  void operator++(int);
+};
+
+struct missing_movable {
+  using difference_type = int;
+
+  missing_movable() = default;
+  missing_movable(missing_movable&&) = delete;
+
+  missing_movable& operator++();
+  void operator++(int);
+};
+
+struct missing_preinc {
+  using difference_type = int;
+
+  void operator++(int);
+};
+
+struct missing_postinc {
+  using difference_type = int;
+
+  missing_postinc& operator++();
+};
+
+struct incrementable_with_difference_type {
+  using difference_type = int;
+
+  incrementable_with_difference_type& operator++();
+  incrementable_with_difference_type operator++(int);
+
+  bool operator==(incrementable_with_difference_type const&) const;
+};
+
+struct incrementable_without_difference_type {
+  incrementable_without_difference_type& operator++();
+  incrementable_without_difference_type operator++(int);
+
+  bool operator==(incrementable_without_difference_type const&) const;
+
+  int operator-(incrementable_without_difference_type) const;
+};
+
+struct difference_type_and_void_minus {
+  using difference_type = int;
+
+  difference_type_and_void_minus& operator++();
+  difference_type_and_void_minus operator++(int);
+
+  bool operator==(difference_type_and_void_minus const&) const;
+
+  void operator-(difference_type_and_void_minus) const;
+};
+
+struct noncopyable_with_difference_type {
+  using difference_type = int;
+
+  noncopyable_with_difference_type() = default;
+  noncopyable_with_difference_type(noncopyable_with_difference_type&&) =
+      default;
+  noncopyable_with_difference_type(noncopyable_with_difference_type const&) =
+      delete;
+
+  noncopyable_with_difference_type&
+  operator=(noncopyable_with_difference_type&&) = default;
+  noncopyable_with_difference_type&
+  operator=(noncopyable_with_difference_type const&) = delete;
+
+  noncopyable_with_difference_type& operator++();
+  noncopyable_with_difference_type operator++(int);
+
+  bool operator==(noncopyable_with_difference_type const&) const;
+};
+
+struct noncopyable_without_difference_type {
+  noncopyable_without_difference_type() = default;
+  noncopyable_without_difference_type(noncopyable_without_difference_type&&) =
+      default;
+  noncopyable_without_difference_type(
+      noncopyable_without_difference_type const&) = delete;
+
+  noncopyable_without_difference_type&
+  operator=(noncopyable_without_difference_type&&) = default;
+  noncopyable_without_difference_type&
+  operator=(noncopyable_without_difference_type const&) = delete;
+
+  noncopyable_without_difference_type& operator++();
+  noncopyable_without_difference_type operator++(int);
+
+  int operator-(noncopyable_without_difference_type const&) const;
+
+  bool operator==(noncopyable_without_difference_type const&) const;
+};
+
+struct noncopyable_with_difference_type_and_minus {
+  using difference_type = int;
+
+  noncopyable_with_difference_type_and_minus() = default;
+  noncopyable_with_difference_type_and_minus(
+      noncopyable_with_difference_type_and_minus&&) = default;
+  noncopyable_with_difference_type_and_minus(
+      noncopyable_with_difference_type_and_minus const&) = delete;
+
+  noncopyable_with_difference_type_and_minus&
+  operator=(noncopyable_with_difference_type_and_minus&&) = default;
+  noncopyable_with_difference_type_and_minus&
+  operator=(noncopyable_with_difference_type_and_minus const&) = delete;
+
+  noncopyable_with_difference_type_and_minus& operator++();
+  noncopyable_with_difference_type_and_minus operator++(int);
+
+  int operator-(noncopyable_with_difference_type_and_minus const&) const;
+
+  bool operator==(noncopyable_with_difference_type_and_minus const&) const;
+};
+
+#endif // #define LIBCPP_TEST_STD_ITERATORS_ITERATOR_REQUIREMENTS_ITERATOR_CONCEPTS_INCREMENTABLE_H
diff --git a/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.inc/incrementable.compile.pass.cpp b/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.inc/incrementable.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.inc/incrementable.compile.pass.cpp
@@ -0,0 +1,202 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// template<class In>
+// concept indirectly_readable;
+
+#include <iterator>
+
+#include <array>
+#include <concepts>
+#include <deque>
+#ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
+#include <filesystem>
+#endif
+#include <forward_list>
+#include <istream>
+#include <list>
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <string_view>
+#include <optional>
+#include <ostream>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "../incrementable.h"
+
+static_assert(std::incrementable<int>);
+static_assert(std::incrementable<int*>);
+static_assert(std::incrementable<int**>);
+static_assert(!std::incrementable<int[]>);
+static_assert(!std::incrementable<int[10]>);
+static_assert(!std::incrementable<double>);
+static_assert(!std::incrementable<int&>);
+static_assert(!std::incrementable<int()>);
+static_assert(!std::incrementable<int (*)()>);
+static_assert(!std::incrementable<int (&)()>);
+
+struct S {};
+static_assert(!std::weakly_incrementable<int S::*>);
+
+#define CHECK_POINTER_TO_MEMBER_FUNCTIONS(qualifier)                           \
+  static_assert(!std::incrementable<int (S::*)() qualifier>);                  \
+  static_assert(!std::incrementable<int (S::*)() qualifier noexcept>);         \
+  static_assert(!std::incrementable<int (S::*)() qualifier&>);                 \
+  static_assert(!std::incrementable<int (S::*)() qualifier & noexcept>);       \
+  static_assert(!std::incrementable<int (S::*)() qualifier&&>);                \
+  static_assert(!std::incrementable < int (S::*)() qualifier&& noexcept >);
+
+#define NO_QUALIFIER
+CHECK_POINTER_TO_MEMBER_FUNCTIONS(NO_QUALIFIER);
+CHECK_POINTER_TO_MEMBER_FUNCTIONS(const);
+CHECK_POINTER_TO_MEMBER_FUNCTIONS(volatile);
+CHECK_POINTER_TO_MEMBER_FUNCTIONS(const volatile);
+
+static_assert(!std::incrementable<postfix_increment_returns_void>);
+static_assert(!std::incrementable<postfix_increment_returns_copy>);
+static_assert(!std::incrementable<has_integral_minus>);
+static_assert(!std::incrementable<has_distinct_difference_type_and_minus>);
+static_assert(!std::incrementable<missing_difference_type>);
+static_assert(!std::incrementable<floating_difference_type>);
+static_assert(!std::incrementable<non_const_minus>);
+static_assert(!std::incrementable<non_integral_minus>);
+static_assert(!std::incrementable<bad_difference_type_good_minus>);
+static_assert(!std::incrementable<missing_default_initializable>);
+static_assert(!std::incrementable<missing_movable>);
+static_assert(!std::incrementable<missing_preinc>);
+static_assert(!std::incrementable<missing_postinc>);
+static_assert(std::incrementable<incrementable_with_difference_type>);
+static_assert(std::incrementable<incrementable_without_difference_type>);
+static_assert(std::incrementable<difference_type_and_void_minus>);
+static_assert(!std::incrementable<noncopyable_with_difference_type>);
+static_assert(!std::incrementable<noncopyable_without_difference_type>);
+static_assert(!std::incrementable<noncopyable_with_difference_type_and_minus>);
+
+namespace standard_types {
+static_assert(std::incrementable<int*>);
+static_assert(std::incrementable<int const*>);
+static_assert(std::incrementable<int volatile*>);
+static_assert(std::incrementable<int const volatile*>);
+
+// <array>
+static_assert(std::incrementable<std::array<int, 10>::iterator>);
+static_assert(std::incrementable<std::array<int, 10>::const_iterator>);
+static_assert(std::incrementable<std::array<int, 10>::reverse_iterator>);
+static_assert(std::incrementable<std::array<int, 10>::const_reverse_iterator>);
+
+// <deque>
+static_assert(std::incrementable<std::deque<int>::iterator>);
+static_assert(std::incrementable<std::deque<int>::const_iterator>);
+static_assert(std::incrementable<std::deque<int>::reverse_iterator>);
+static_assert(std::incrementable<std::deque<int>::const_reverse_iterator>);
+
+// <filesystem>
+#ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
+static_assert(!std::incrementable<std::filesystem::directory_iterator>);
+static_assert(
+    !std::incrementable<std::filesystem::recursive_directory_iterator>);
+#endif
+
+// <forward_list>
+static_assert(std::incrementable<std::forward_list<int>::iterator>);
+static_assert(std::incrementable<std::forward_list<int>::const_iterator>);
+
+// <iterator>
+static_assert(
+    !std::incrementable<std::back_insert_iterator<std::vector<int> > >);
+static_assert(
+    !std::incrementable<std::front_insert_iterator<std::deque<int> > >);
+static_assert(!std::incrementable<std::insert_iterator<std::deque<int> > >);
+static_assert(std::incrementable<std::istream_iterator<int, char> >);
+static_assert(!std::incrementable<std::istreambuf_iterator<char> >);
+static_assert(
+    std::incrementable<std::move_iterator<std::vector<int>::iterator> >);
+static_assert(!std::incrementable<std::ostream_iterator<int, char> >);
+static_assert(!std::incrementable<std::ostreambuf_iterator<int, char> >);
+
+// <list>
+static_assert(std::incrementable<std::list<int>::iterator>);
+static_assert(std::incrementable<std::list<int>::const_iterator>);
+static_assert(std::incrementable<std::list<int>::reverse_iterator>);
+static_assert(std::incrementable<std::list<int>::const_reverse_iterator>);
+
+// <map>
+static_assert(std::incrementable<std::map<int, int>::iterator>);
+static_assert(std::incrementable<std::map<int, int>::const_iterator>);
+static_assert(std::incrementable<std::map<int, int>::reverse_iterator>);
+static_assert(std::incrementable<std::map<int, int>::const_reverse_iterator>);
+
+static_assert(std::incrementable<std::multimap<int, int>::iterator>);
+static_assert(std::incrementable<std::multimap<int, int>::const_iterator>);
+static_assert(std::incrementable<std::multimap<int, int>::reverse_iterator>);
+static_assert(
+    std::incrementable<std::multimap<int, int>::const_reverse_iterator>);
+
+// <memory>
+static_assert(!std::incrementable<std::shared_ptr<int> >);
+static_assert(!std::incrementable<std::shared_ptr<void> >);
+static_assert(!std::incrementable<std::unique_ptr<int> >);
+static_assert(!std::incrementable<std::unique_ptr<void> >);
+
+// <optional>
+static_assert(!std::incrementable<std::optional<int> >);
+
+// <set>
+static_assert(std::incrementable<std::set<int>::iterator>);
+static_assert(std::incrementable<std::set<int>::const_iterator>);
+static_assert(std::incrementable<std::set<int>::reverse_iterator>);
+static_assert(std::incrementable<std::set<int>::const_reverse_iterator>);
+
+static_assert(std::incrementable<std::multiset<int>::iterator>);
+static_assert(std::incrementable<std::multiset<int>::const_iterator>);
+static_assert(std::incrementable<std::multiset<int>::reverse_iterator>);
+static_assert(std::incrementable<std::multiset<int>::const_reverse_iterator>);
+
+// <string>
+static_assert(std::incrementable<std::string::iterator>);
+static_assert(std::incrementable<std::string::const_iterator>);
+static_assert(std::incrementable<std::string::reverse_iterator>);
+static_assert(std::incrementable<std::string::const_reverse_iterator>);
+
+// <string_view>
+static_assert(std::incrementable<std::string_view::iterator>);
+static_assert(std::incrementable<std::string_view::const_iterator>);
+static_assert(std::incrementable<std::string_view::reverse_iterator>);
+static_assert(std::incrementable<std::string_view::const_reverse_iterator>);
+
+// <unordered_map>
+static_assert(std::incrementable<std::unordered_map<int, int>::iterator>);
+static_assert(std::incrementable<std::unordered_map<int, int>::const_iterator>);
+
+static_assert(std::incrementable<std::unordered_multimap<int, int>::iterator>);
+static_assert(
+    std::incrementable<std::unordered_multimap<int, int>::const_iterator>);
+
+// <unordered_set>
+static_assert(std::incrementable<std::unordered_set<int>::iterator>);
+static_assert(std::incrementable<std::unordered_set<int>::const_iterator>);
+
+static_assert(std::incrementable<std::unordered_multiset<int, int>::iterator>);
+static_assert(
+    std::incrementable<std::unordered_multiset<int, int>::const_iterator>);
+
+// <vector>
+static_assert(std::incrementable<std::vector<int>::iterator>);
+static_assert(std::incrementable<std::vector<int>::const_iterator>);
+static_assert(std::incrementable<std::vector<int>::reverse_iterator>);
+static_assert(std::incrementable<std::vector<int>::const_reverse_iterator>);
+static_assert(!std::incrementable<std::vector<int> >);
+} // namespace standard_types
diff --git a/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.winc/weakly_incrementable.compile.pass.cpp b/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.winc/weakly_incrementable.compile.pass.cpp
new file mode 100644
--- /dev/null
+++ b/libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.winc/weakly_incrementable.compile.pass.cpp
@@ -0,0 +1,222 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+
+// template<class In>
+// concept std::weakly_incrementable;
+
+#include <iterator>
+
+#include <array>
+#include <concepts>
+#include <deque>
+#ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
+#include <filesystem>
+#endif
+#include <forward_list>
+#include <istream>
+#include <list>
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <string_view>
+#include <optional>
+#include <ostream>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "../incrementable.h"
+
+static_assert(std::weakly_incrementable<int>);
+static_assert(std::weakly_incrementable<int*>);
+static_assert(std::weakly_incrementable<int**>);
+static_assert(!std::weakly_incrementable<int[]>);
+static_assert(!std::weakly_incrementable<int[10]>);
+static_assert(!std::weakly_incrementable<double>);
+static_assert(!std::weakly_incrementable<int&>);
+static_assert(!std::weakly_incrementable<int()>);
+static_assert(!std::weakly_incrementable<int (*)()>);
+static_assert(!std::weakly_incrementable<int (&)()>);
+
+struct S {};
+static_assert(!std::weakly_incrementable<int S::*>);
+
+#define CHECK_POINTER_TO_MEMBER_FUNCTIONS(qualifier)                           \
+  static_assert(!std::weakly_incrementable<int (S::*)() qualifier>);           \
+  static_assert(!std::weakly_incrementable<int (S::*)() qualifier noexcept>);  \
+  static_assert(!std::weakly_incrementable<int (S::*)() qualifier&>);          \
+  static_assert(                                                               \
+      !std::weakly_incrementable<int (S::*)() qualifier & noexcept>);          \
+  static_assert(!std::weakly_incrementable<int (S::*)() qualifier&&>);         \
+  static_assert(!std::weakly_incrementable < int (S::*)()                      \
+                                                 qualifier&& noexcept >);
+
+#define NO_QUALIFIER
+CHECK_POINTER_TO_MEMBER_FUNCTIONS(NO_QUALIFIER);
+CHECK_POINTER_TO_MEMBER_FUNCTIONS(const);
+CHECK_POINTER_TO_MEMBER_FUNCTIONS(volatile);
+CHECK_POINTER_TO_MEMBER_FUNCTIONS(const volatile);
+
+static_assert(std::weakly_incrementable<postfix_increment_returns_void>);
+static_assert(std::weakly_incrementable<postfix_increment_returns_copy>);
+static_assert(std::weakly_incrementable<has_integral_minus>);
+static_assert(
+    std::weakly_incrementable<has_distinct_difference_type_and_minus>);
+static_assert(!std::weakly_incrementable<missing_difference_type>);
+static_assert(!std::weakly_incrementable<floating_difference_type>);
+static_assert(!std::weakly_incrementable<non_const_minus>);
+static_assert(!std::weakly_incrementable<non_integral_minus>);
+static_assert(!std::weakly_incrementable<bad_difference_type_good_minus>);
+static_assert(!std::weakly_incrementable<missing_default_initializable>);
+static_assert(!std::weakly_incrementable<missing_movable>);
+static_assert(!std::weakly_incrementable<missing_preinc>);
+static_assert(!std::weakly_incrementable<missing_postinc>);
+static_assert(std::weakly_incrementable<incrementable_with_difference_type>);
+static_assert(std::weakly_incrementable<incrementable_without_difference_type>);
+static_assert(std::weakly_incrementable<difference_type_and_void_minus>);
+static_assert(std::weakly_incrementable<noncopyable_with_difference_type>);
+static_assert(std::weakly_incrementable<noncopyable_without_difference_type>);
+static_assert(
+    std::weakly_incrementable<noncopyable_with_difference_type_and_minus>);
+
+namespace standard_types {
+static_assert(std::weakly_incrementable<int*>);
+static_assert(std::weakly_incrementable<int const*>);
+static_assert(std::weakly_incrementable<int volatile*>);
+static_assert(std::weakly_incrementable<int const volatile*>);
+
+// <array>
+static_assert(std::weakly_incrementable<std::array<int, 10>::iterator>);
+static_assert(std::weakly_incrementable<std::array<int, 10>::const_iterator>);
+static_assert(std::weakly_incrementable<std::array<int, 10>::reverse_iterator>);
+static_assert(
+    std::weakly_incrementable<std::array<int, 10>::const_reverse_iterator>);
+
+// <deque>
+static_assert(std::weakly_incrementable<std::deque<int>::iterator>);
+static_assert(std::weakly_incrementable<std::deque<int>::const_iterator>);
+static_assert(std::weakly_incrementable<std::deque<int>::reverse_iterator>);
+static_assert(
+    std::weakly_incrementable<std::deque<int>::const_reverse_iterator>);
+
+// <filesystem>
+#ifndef _LIBCPP_HAS_NO_FILESYSTEM_LIBRARY
+static_assert(std::weakly_incrementable<std::filesystem::directory_iterator>);
+static_assert(
+    std::weakly_incrementable<std::filesystem::recursive_directory_iterator>);
+#endif
+
+// <forward_list>
+static_assert(std::weakly_incrementable<std::forward_list<int>::iterator>);
+static_assert(
+    std::weakly_incrementable<std::forward_list<int>::const_iterator>);
+
+// <iterator>
+static_assert(
+    !std::weakly_incrementable<std::back_insert_iterator<std::vector<int> > >);
+static_assert(
+    !std::weakly_incrementable<std::front_insert_iterator<std::deque<int> > >);
+static_assert(
+    !std::weakly_incrementable<std::insert_iterator<std::deque<int> > >);
+static_assert(std::weakly_incrementable<std::istream_iterator<int, char> >);
+static_assert(std::weakly_incrementable<std::istreambuf_iterator<char> >);
+static_assert(
+    std::weakly_incrementable<std::move_iterator<std::vector<int>::iterator> >);
+static_assert(!std::weakly_incrementable<std::ostream_iterator<int, char> >);
+static_assert(!std::weakly_incrementable<std::ostreambuf_iterator<int, char> >);
+
+// <list>
+static_assert(std::weakly_incrementable<std::list<int>::iterator>);
+static_assert(std::weakly_incrementable<std::list<int>::const_iterator>);
+static_assert(std::weakly_incrementable<std::list<int>::reverse_iterator>);
+static_assert(
+    std::weakly_incrementable<std::list<int>::const_reverse_iterator>);
+
+// <map>
+static_assert(std::weakly_incrementable<std::map<int, int>::iterator>);
+static_assert(std::weakly_incrementable<std::map<int, int>::const_iterator>);
+static_assert(std::weakly_incrementable<std::map<int, int>::reverse_iterator>);
+static_assert(
+    std::weakly_incrementable<std::map<int, int>::const_reverse_iterator>);
+
+static_assert(std::weakly_incrementable<std::multimap<int, int>::iterator>);
+static_assert(
+    std::weakly_incrementable<std::multimap<int, int>::const_iterator>);
+static_assert(
+    std::weakly_incrementable<std::multimap<int, int>::reverse_iterator>);
+static_assert(
+    std::weakly_incrementable<std::multimap<int, int>::const_reverse_iterator>);
+
+// <memory>
+static_assert(!std::weakly_incrementable<std::shared_ptr<int> >);
+static_assert(!std::weakly_incrementable<std::shared_ptr<void> >);
+static_assert(!std::weakly_incrementable<std::unique_ptr<int> >);
+static_assert(!std::weakly_incrementable<std::unique_ptr<void> >);
+
+// <optional>
+static_assert(!std::weakly_incrementable<std::optional<int> >);
+
+// <set>
+static_assert(std::weakly_incrementable<std::set<int>::iterator>);
+static_assert(std::weakly_incrementable<std::set<int>::const_iterator>);
+static_assert(std::weakly_incrementable<std::set<int>::reverse_iterator>);
+static_assert(std::weakly_incrementable<std::set<int>::const_reverse_iterator>);
+
+static_assert(std::weakly_incrementable<std::multiset<int>::iterator>);
+static_assert(std::weakly_incrementable<std::multiset<int>::const_iterator>);
+static_assert(std::weakly_incrementable<std::multiset<int>::reverse_iterator>);
+static_assert(
+    std::weakly_incrementable<std::multiset<int>::const_reverse_iterator>);
+
+// <string>
+static_assert(std::weakly_incrementable<std::string::iterator>);
+static_assert(std::weakly_incrementable<std::string::const_iterator>);
+static_assert(std::weakly_incrementable<std::string::reverse_iterator>);
+static_assert(std::weakly_incrementable<std::string::const_reverse_iterator>);
+
+// <string_view>
+static_assert(std::weakly_incrementable<std::string_view::iterator>);
+static_assert(std::weakly_incrementable<std::string_view::const_iterator>);
+static_assert(std::weakly_incrementable<std::string_view::reverse_iterator>);
+static_assert(
+    std::weakly_incrementable<std::string_view::const_reverse_iterator>);
+
+// <unordered_map>
+static_assert(
+    std::weakly_incrementable<std::unordered_map<int, int>::iterator>);
+static_assert(
+    std::weakly_incrementable<std::unordered_map<int, int>::const_iterator>);
+
+static_assert(
+    std::weakly_incrementable<std::unordered_multimap<int, int>::iterator>);
+static_assert(std::weakly_incrementable<
+              std::unordered_multimap<int, int>::const_iterator>);
+
+// <unordered_set>
+static_assert(std::weakly_incrementable<std::unordered_set<int>::iterator>);
+static_assert(
+    std::weakly_incrementable<std::unordered_set<int>::const_iterator>);
+
+static_assert(
+    std::weakly_incrementable<std::unordered_multiset<int, int>::iterator>);
+static_assert(std::weakly_incrementable<
+              std::unordered_multiset<int, int>::const_iterator>);
+
+// <vector>
+static_assert(std::weakly_incrementable<std::vector<int>::iterator>);
+static_assert(std::weakly_incrementable<std::vector<int>::const_iterator>);
+static_assert(std::weakly_incrementable<std::vector<int>::reverse_iterator>);
+static_assert(
+    std::weakly_incrementable<std::vector<int>::const_reverse_iterator>);
+static_assert(!std::weakly_incrementable<std::vector<int> >);
+} // namespace standard_types