I implemented the features listed in this document: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0616r0.pdf and built libc++ using ninja without any errors/warnings. I Also ran the test suite it using `lit` and passed all the unit tests.

[Afadyfarag]

Summary

1. Changes:
   
   libcxx/include/numeric

[EricWF]

libcxx/include/set

489 ↗

(On Diff #225972)

What's up with this?

[EricWF]

Please correct the patch description and title to be clearer and not all on one line.

Also, any change to libc++ requires tests that demonstrate the changed behavior. The test should fail without your change and pass with it.
Please add some tests.

Also, please remove any unintentional changes from the patch under review.

libcxx/CMakeLists.txt

539

This change is unrelated to this patch and shouldn't be included.

libcxx/include/numeric

146

Just always include limits. No need to guard this.

[Afadyfarag]

Implemented P0646R1: Erase-Like Algorithms Should Return size_type.

Removed changes to Library Fundamentals V2, as that is already released.
Split the Library Fundamentals bits into a new paper to be released when LFv3 opens shop.
Changed the return type from size t to container::size type (as per LEWG request in Toronto).

Reviewers:

EricWF
ldionne

[mclow.lists]

One feature per patch, please.

You've got at least three different bits of functionality here.

1. Some random Cmake changes (no description)
2. Some changes to forward_list that are wildly out of date.
3. Some changes to numeric which look a lot like D61170

and you have no tests.

libcxx/include/forward_list

1505

I don't know what version of forward_list you started with, but it's not the current one.

libcxx/CMakeLists.txt

if(NOT ${SUPPORTS_DIALECT_NAME} AND NOT ${SUPPORTS_DIALECT_NAME_MSVC})
   endif()
 endif()
 
 # On all systems the system c++ standard library headers need to be excluded.
 # MSVC only has -X, which disables all default includes; including the crt.
 # Thus, we do nothing and hope we don't accidentally include any of the C++
 # headers
 add_compile_flags_if_supported(-nostdinc++)
+add_compile_flags_if_supported(-fcolor-diagnostics)
+
+option (FORCE_COLORED_OUTPUT "Always produce ANSI-colored output (GNU/Clang only)." FALSE)
+if (${FORCE_COLORED_OUTPUT})
+    if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+       add_compile_options (-fdiagnostics-color=always)
+    elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+       add_compile_options (-fcolor-diagnostics)
+    endif ()
+endif ()
 
 # Hide all inline function definitions which have not explicitly been marked
 # visible. This prevents new definitions for inline functions from appearing in
 # the dylib when get ODR used by another function.
 add_compile_flags_if_supported(-fvisibility-inlines-hidden)
 
 if (LIBCXX_CONFIGURE_IDE)
   # This simply allows IDE to process <experimental/coroutine>

libcxx/include/forward_list

forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
                                         const_iterator __f, const_iterator __l)
 {
     splice_after(__p, __x, __f, __l);
 }
 
 #endif  // _LIBCPP_CXX03_LANG
 
 template <class _Tp, class _Alloc>
-void
+decltype(auto)
 forward_list<_Tp, _Alloc>::remove(const value_type& __v)
 {
     forward_list<_Tp, _Alloc> __deleted_nodes(get_allocator()); // collect the nodes we're removing
     iterator __e = end();
+    __VSTD::size_type __rm = 0;
     for (iterator __i = before_begin(); __i.__get_begin()->__next_ != nullptr;)
     {
         if (__i.__get_begin()->__next_->__value_ == __v)
         {
             iterator __j = _VSTD::next(__i, 2);
             for (; __j != __e && *__j == __v; ++__j)
                 ;
             __deleted_nodes.splice_after(__deleted_nodes.before_begin(), *this, __i, __j);
+            ++__rm;
             if (__j == __e)
                 break;
             __i = __j;
         }
         else
             ++__i;
     }
+#if _LIBCPP_STD_VER > 17
+    return __rm;
+#else
+    (void) __rm;
+#endif
 }
 
 template <class _Tp, class _Alloc>
 template <class _Predicate>
-void
+decltype(auto)
 forward_list<_Tp, _Alloc>::remove_if(_Predicate __pred)
 {
     forward_list<_Tp, _Alloc> __deleted_nodes(get_allocator()); // collect the nodes we're removing
     iterator __e = end();
+    __VSTD::size_type __rm = 0;
     for (iterator __i = before_begin(); __i.__get_begin()->__next_ != nullptr;)
     {
         if (__pred(__i.__get_begin()->__next_->__value_))
         {
             iterator __j = _VSTD::next(__i, 2);
             for (; __j != __e && __pred(*__j); ++__j)
                 ;
             __deleted_nodes.splice_after(__deleted_nodes.before_begin(), *this, __i, __j);
+            ++__rm;
             if (__j == __e)
                 break;
             __i = __j;
         }
         else
             ++__i;
     }
+#if _LIBCPP_STD_VER > 17
+    return __rm;
+#else
+    (void) __rm;
+#endif
 }
 
 template <class _Tp, class _Alloc>
 template <class _BinaryPredicate>
 void
 forward_list<_Tp, _Alloc>::unique(_BinaryPredicate __binary_pred)
 {
     forward_list<_Tp, _Alloc> __deleted_nodes(get_allocator()); // collect the nodes we're removing

libcxx/include/numeric

 floating_point  midpoint(floating_point a, floating_point b);    // C++20
 
 }  // std
 
 */
 
 #include <__config>
 #include <iterator>
+#if _LIBCPP_STD_VER > 17 
 #include <limits> // for numeric_limits
+#endif
 #include <functional>
 #include <cmath> // for isnormal
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
accumulate(_InputIterator __first, _InputIterator __last, _Tp __init)
     return __init;
 }
 
 template <class _InputIterator, class _Tp, class _BinaryOperation>
 inline _LIBCPP_INLINE_VISIBILITY
 _Tp
 accumulate(_InputIterator __first, _InputIterator __last, _Tp __init, _BinaryOperation __binary_op)
 {
-    for (; __first != __last; ++__first)
+    for (; __first != __last; ++__first) {
+#if _LIBCPP_STD_VER > 17
+        __init = __binary_op(_VSTD::move(__init), *__first);    
+#else
         __init = __binary_op(__init, *__first);
+#endif
+    }
     return __init;
 }
 
 #if _LIBCPP_STD_VER > 14
 template <class _InputIterator, class _Tp, class _BinaryOp>
 inline _LIBCPP_INLINE_VISIBILITY
 _Tp
 reduce(_InputIterator __first, _InputIterator __last, _Tp __init, _BinaryOp __b)

 }
 
 template <class _InputIterator1, class _InputIterator2, class _Tp, class _BinaryOperation1, class _BinaryOperation2>
 inline _LIBCPP_INLINE_VISIBILITY
 _Tp
 inner_product(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2,
               _Tp __init, _BinaryOperation1 __binary_op1, _BinaryOperation2 __binary_op2)
 {
-    for (; __first1 != __last1; ++__first1, (void) ++__first2)
+    for (; __first1 != __last1; ++__first1, (void) ++__first2) {
+#if _LIBCPP_STD_VER > 17
+        __init = __binary_op1(_VSTD::move(__init), __binary_op2(*__first1, *__first2));
+#else
         __init = __binary_op1(__init, __binary_op2(*__first1, *__first2));
+#endif
+    }
     return __init;
 }
 
 #if _LIBCPP_STD_VER > 14
 template <class _InputIterator, class _Tp, class _BinaryOp, class _UnaryOp>
 inline _LIBCPP_INLINE_VISIBILITY
 _Tp
 transform_reduce(_InputIterator __first, _InputIterator __last,
partial_sum(_InputIterator __first, _InputIterator __last, _OutputIterator __result,
               _BinaryOperation __binary_op)
 {
     if (__first != __last)
     {
         typename iterator_traits<_InputIterator>::value_type __t(*__first);
         *__result = __t;
         for (++__first, (void) ++__result; __first != __last; ++__first, (void) ++__result)
         {
+#if _LIBCPP_STD_VER > 17
+            __t = __binary_op(_VSTD::move(__t), *__first);
+            *__result = __t;
+#else
             __t = __binary_op(__t, *__first);
             *__result = __t;
+#endif
         }
     }
     return __result;
 }
 
 #if _LIBCPP_STD_VER > 14
 template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp>
 inline _LIBCPP_INLINE_VISIBILITY

 {
     if (__first != __last)
     {
         typename iterator_traits<_InputIterator>::value_type __t1(*__first);
         *__result = __t1;
         for (++__first, (void) ++__result; __first != __last; ++__first, (void) ++__result)
         {
             typename iterator_traits<_InputIterator>::value_type __t2(*__first);
+#if _LIBCPP_STD_VER > 17
+            *__result = __binary_op(__t2, _VSTD::move(__t1));
+#else
             *__result = __binary_op(__t2, __t1);
+#endif
             __t1 = _VSTD::move(__t2);
         }
     }
     return __result;
 }
 
 template <class _ForwardIterator, class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY