diff --git a/libcxx/include/iterator b/libcxx/include/iterator
--- a/libcxx/include/iterator
+++ b/libcxx/include/iterator
@@ -2533,6 +2533,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,189 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 winc1 {
+  using difference_type = int;
+  winc1& operator++();
+  void operator++(int);
+};
+
+struct winc2 {
+  using difference_type = int;
+  winc2& operator++();
+  winc2 operator++(int);
+};
+
+struct winc3 {
+  winc3& operator++();
+  winc3 operator++(int);
+
+  long operator-(winc3) const;
+};
+
+struct winc4 {
+  using difference_type = short;
+
+  winc4& operator++();
+  winc4 operator++(int);
+
+  long operator-(winc4) 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 inc1 {
+  using difference_type = int;
+
+  inc1& operator++();
+  inc1 operator++(int);
+
+  bool operator==(inc1) const;
+  bool operator!=(inc1) const;
+};
+
+struct inc2 {
+  inc2& operator++();
+  inc2 operator++(int);
+
+  bool operator==(inc2) const;
+  bool operator!=(inc2) const;
+
+  int operator-(inc2) const;
+};
+
+struct inc3 {
+  using difference_type = int;
+
+  inc3& operator++();
+  inc3 operator++(int);
+
+  bool operator==(inc3) const;
+  bool operator!=(inc3) const;
+
+  void operator-(inc3) const;
+};
+
+struct noncopyable1 {
+  using difference_type = int;
+
+  noncopyable1() = default;
+  noncopyable1(noncopyable1&&) = default;
+  noncopyable1(noncopyable1 const&) = delete;
+
+  noncopyable1& operator=(noncopyable1&&) = default;
+  noncopyable1& operator=(noncopyable1 const&) = delete;
+
+  noncopyable1& operator++();
+  noncopyable1 operator++(int);
+
+  bool operator==(noncopyable1) const;
+  bool operator!=(noncopyable1) const;
+};
+
+struct noncopyable2 {
+  noncopyable2() = default;
+  noncopyable2(noncopyable2&&) = default;
+  noncopyable2(noncopyable2 const&) = delete;
+
+  noncopyable2& operator=(noncopyable2&&) = default;
+  noncopyable2& operator=(noncopyable2 const&) = delete;
+
+  noncopyable2& operator++();
+  noncopyable2 operator++(int);
+
+  int operator-(noncopyable2 const&) const;
+
+  bool operator==(noncopyable2) const;
+  bool operator!=(noncopyable2) const;
+};
+
+struct noncopyable3 {
+  using difference_type = int;
+
+  noncopyable3() = default;
+  noncopyable3(noncopyable3&&) = default;
+  noncopyable3(noncopyable3 const&) = delete;
+
+  noncopyable3& operator=(noncopyable3&&) = default;
+  noncopyable3& operator=(noncopyable3 const&) = delete;
+
+  noncopyable3& operator++();
+  noncopyable3 operator++(int);
+
+  int operator-(noncopyable3 const&) const;
+
+  bool operator==(noncopyable3) const;
+  bool operator!=(noncopyable3) 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<winc1>);
+static_assert(!std::incrementable<winc2>);
+static_assert(!std::incrementable<winc3>);
+static_assert(!std::incrementable<winc4>);
+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<inc1>);
+static_assert(std::incrementable<inc2>);
+static_assert(std::incrementable<inc3>);
+static_assert(!std::incrementable<noncopyable1>);
+static_assert(!std::incrementable<noncopyable2>);
+static_assert(!std::incrementable<noncopyable3>);
+
+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,220 @@
+//===----------------------------------------------------------------------===//
+//
+// 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<winc1>);
+static_assert(std::weakly_incrementable<winc2>);
+static_assert(std::weakly_incrementable<winc3>);
+static_assert(std::weakly_incrementable<winc4>);
+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<inc1>);
+static_assert(std::weakly_incrementable<inc2>);
+static_assert(std::weakly_incrementable<inc3>);
+static_assert(std::weakly_incrementable<noncopyable1>);
+static_assert(std::weakly_incrementable<noncopyable2>);
+static_assert(std::weakly_incrementable<noncopyable3>);
+
+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