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

[mclow.lists]

This is a mess.
The changes in libcxx/CMakeLists.txt are unrelated to P0616.
The changes in algorithm are also unrelated to P0616.
The changes in forward_list are also unrelated to P0616, and are based on an outdated version of that file.
You proposed the changes in numeric before (in D69286) and then never came back to them.
And you have no tests.

Please don't keep proposing the same things over and over.

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/algorithm

 
 template <class ForwardIterator>
     ForwardIterator
     rotate(ForwardIterator first, ForwardIterator middle, ForwardIterator last);
 
 template <class ForwardIterator, class OutputIterator>
     OutputIterator
     rotate_copy(ForwardIterator first, ForwardIterator middle, ForwardIterator last, OutputIterator result);
  
+template<class ForwardIterator>
+    constexpr ForwardIterator shift_left(ForwardIterator first, ForwardIterator last,
+    typename iterator_traits<ForwardIterator>::difference_type n);
+
 template <class RandomAccessIterator>
     void
     random_shuffle(RandomAccessIterator first, RandomAccessIterator last); // deprecated in C++14, removed in C++17
 
 template <class RandomAccessIterator, class RandomNumberGenerator>
     void
     random_shuffle(RandomAccessIterator first, RandomAccessIterator last,
                    RandomNumberGenerator& rand);  // deprecated in C++14, removed in C++17
if (__d > 1)
             difference_type __i = __rand(__d);
             if (__i != difference_type(0))
               swap(*__first, *(__first + __i));
         }
     }
 }
 #endif
 
+// shift_left
+#if _LIBCPP_STD_VER > 17
+template<class _ForwardIterator>
+_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
+_ForwardIterator shift_left(_ForwardIterator __first, _ForwardIterator __last,
+                                      difference_type_t<_ForwardIterator> __d)
+{
+    if (__d <= 0)
+        return __last;
+    
+    const auto __vf = *__first;
+    const auto __vl = *__last;
+    auto begin      = __vf;
+    
+    if constexpr (__is_random_access_iterator<_ForwardIterator>::value)
+    {
+        if (__d >= __vl - __vf)
+        {
+            return __first;
+        }
+        begin += __d;
+    }
+    else
+    {
+        for (; 0 < __d; --__d)
+        {
+            if (begin == __vl)
+                return __first;
+            ++begin;
+        }
+    }
+    return __first;
+}
+#endif
+
 template <class _PopulationIterator, class _SampleIterator, class _Distance,
           class _UniformRandomNumberGenerator>
 _LIBCPP_INLINE_VISIBILITY
 _SampleIterator __sample(_PopulationIterator __first,
                          _PopulationIterator __last, _SampleIterator __output_iter,
                          _Distance __n,
                          _UniformRandomNumberGenerator & __g,
                          input_iterator_tag) {

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