Fix invoke call and add projection

Author: winner245

libcxx/include/__algorithm/for_each.h

@@ -13,9 +13,9 @@
 #include <__algorithm/for_each_segment.h>
 #include <__config>
 #include <__functional/identity.h>
-#include <__functional/invoke.h>
 #include <__iterator/segmented_iterator.h>
 #include <__type_traits/enable_if.h>
+#include <__type_traits/invoke.h>
 #include <__utility/move.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -27,46 +27,45 @@ _LIBCPP_PUSH_MACROS
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class _InputIterator, class _Sent, class _Function, class _Proj>
+template <class _InputIterator, class _Sent, class _Func, class _Proj>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _InputIterator
-__for_each(_InputIterator __first, _Sent __last, _Function& __f, _Proj& __proj) {
+__for_each(_InputIterator __first, _Sent __last, _Func& __f, _Proj& __proj) {
   for (; __first != __last; ++__first)
-    std::invoke(__f, std::invoke(__proj, *__first));
+    std::__invoke(__f, std::__invoke(__proj, *__first));
   return __first;
 }
 
-// __segment_processor handles the per-segment processing by applying the user-provided function to each element
-// within the segment. It acts as a functor passed to the segmented iterator algorithm __for_each_segment.
-template <class _SegmentedIterator, class _Function, class _Proj>
+// __segment_processor handles the per-segment processing by applying the function object __func_ to the
+// projected value of each element within the segment. It serves as a functor utilized by the segmented
+// iterator algorithms such as __for_each_segment and __for_each_n_segment.
+template <class _SegmentedIterator, class _Func>
 struct __segment_processor {
   using _Traits _LIBCPP_NODEBUG = __segmented_iterator_traits<_SegmentedIterator>;
 
-  _Function& __func_;
-  _Proj& __proj_;
+  _Func& __func_;
 
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit __segment_processor(_Function& __func, _Proj& __proj)
-      : __func_(__func), __proj_(__proj) {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR explicit __segment_processor(_Func& __f) : __func_(__f) {}
 
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void
-  operator()(typename _Traits::__local_iterator __lfirst, typename _Traits::__local_iterator __llast) {
-    std::__for_each(__lfirst, __llast, __func_, __proj_);
+  template <class _Proj>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+  operator()(typename _Traits::__local_iterator __lfirst, typename _Traits::__local_iterator __llast, _Proj& __proj) {
+    std::__for_each(__lfirst, __llast, __func_, __proj);
   }
 };
 
 template <class _SegmentedIterator,
-          class _Function,
+          class _Func,
           class _Proj,
           __enable_if_t<__is_segmented_iterator<_SegmentedIterator>::value, int> = 0>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _SegmentedIterator
-__for_each(_SegmentedIterator __first, _SegmentedIterator __last, _Function& __func, _Proj& __proj) {
-  std::__for_each_segment(
-      __first, __last, std::__segment_processor<_SegmentedIterator, _Function, _Proj>(__func, __proj));
+__for_each(_SegmentedIterator __first, _SegmentedIterator __last, _Func& __f, _Proj& __proj) {
+  std::__for_each_segment(__first, __last, std::__segment_processor<_SegmentedIterator, _Func>(__f), __proj);
   return __last;
 }
 
-template <class _InputIterator, class _Function>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Function
-for_each(_InputIterator __first, _InputIterator __last, _Function __f) {
+template <class _InputIterator, class _Func>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Func
+for_each(_InputIterator __first, _InputIterator __last, _Func __f) {
   __identity __proj;
   std::__for_each(__first, __last, __f, __proj);
   return std::move(__f);

libcxx/include/__algorithm/for_each_n.h

@@ -14,10 +14,10 @@
 #include <__algorithm/for_each_n_segment.h>
 #include <__config>
 #include <__functional/identity.h>
-#include <__functional/invoke.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/segmented_iterator.h>
 #include <__type_traits/enable_if.h>
+#include <__type_traits/invoke.h>
 #include <__utility/convert_to_integral.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
@@ -28,7 +28,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InputIterator,
           class _Size,
-          class _Function,
+          class _Func,
           class _Proj,
           __enable_if_t<!__has_random_access_iterator_category<_InputIterator>::value &&
                             (!__is_segmented_iterator<_InputIterator>::value
@@ -38,11 +38,11 @@ template <class _InputIterator,
                                 // during SFINAE, which is a hard error to be fixed. Once fixed, we should uncomment.
                         int> = 0>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _InputIterator
-__for_each_n(_InputIterator __first, _Size __orig_n, _Function& __f, _Proj& __proj) {
+__for_each_n(_InputIterator __first, _Size __orig_n, _Func& __f, _Proj& __proj) {
   typedef decltype(std::__convert_to_integral(__orig_n)) _IntegralSize;
   _IntegralSize __n = __orig_n;
   while (__n > 0) {
-    std::invoke(__f, std::invoke(__proj, *__first));
+    std::__invoke(__f, std::__invoke(__proj, *__first));
     ++__first;
     --__n;
   }
@@ -51,36 +51,35 @@ __for_each_n(_InputIterator __first, _Size __orig_n, _Function& __f, _Proj& __pr
 
 template <class _RandIter,
           class _Size,
-          class _Function,
+          class _Func,
           class _Proj,
           __enable_if_t<__has_random_access_iterator_category<_RandIter>::value, int> = 0>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandIter
-__for_each_n(_RandIter __first, _Size __orig_n, _Function& __f, _Proj& __proj) {
+__for_each_n(_RandIter __first, _Size __orig_n, _Func& __f, _Proj& __proj) {
   typedef decltype(std::__convert_to_integral(__orig_n)) _IntegralSize;
   _IntegralSize __n = __orig_n;
   return std::__for_each(__first, __first + __n, __f, __proj);
 }
 
 template <class _SegmentedIterator,
           class _Size,
-          class _Function,
+          class _Func,
           class _Proj,
           __enable_if_t<!__has_random_access_iterator_category<_SegmentedIterator>::value &&
                             __is_segmented_iterator<_SegmentedIterator>::value &&
                             __has_random_access_iterator_category<
                                 typename __segmented_iterator_traits<_SegmentedIterator>::__local_iterator>::value,
                         int> = 0>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _SegmentedIterator
-__for_each_n(_SegmentedIterator __first, _Size __orig_n, _Function& __f, _Proj& __proj) {
-  return std::__for_each_n_segment(
-      __first, __orig_n, std::__segment_processor<_SegmentedIterator, _Function, _Proj>(__f, __proj));
+__for_each_n(_SegmentedIterator __first, _Size __orig_n, _Func& __f, _Proj& __proj) {
+  return std::__for_each_n_segment(__first, __orig_n, std::__segment_processor<_SegmentedIterator, _Func>(__f), __proj);
 }
 
 #if _LIBCPP_STD_VER >= 17
 
-template <class _InputIterator, class _Size, class _Function>
+template <class _InputIterator, class _Size, class _Func>
 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _InputIterator
-for_each_n(_InputIterator __first, _Size __orig_n, _Function __f) {
+for_each_n(_InputIterator __first, _Size __orig_n, _Func __f) {
   __identity __proj;
   return std::__for_each_n(__first, __orig_n, __f, __proj);
 }

libcxx/include/__algorithm/for_each_n_segment.h

@@ -23,14 +23,13 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // __for_each_n_segment optimizes linear iteration over segmented iterators. It processes a segmented
-// input range defined by [__first, __first + __n), where __first is the starting segmented iterator
-// and __n is the number of elements to process. The functor __func is applied to each segment using
-// local iterator pairs for that segment. The return value of __func is ignored, and the function
-// returns an iterator pointing to one past the last processed element in the input range.
+// input range [__first, __first + __n) by applying the functor __func to the result of projection on
+// each element within that segment. The return value of __func is ignored, and the function returns
+// an iterator pointing to one past the last processed element in the input range.
 
-template <class _SegmentedIterator, class _Size, class _Functor>
+template <class _SegmentedIterator, class _Size, class _Functor, class _Proj>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _SegmentedIterator
-__for_each_n_segment(_SegmentedIterator __first, _Size __orig_n, _Functor __func) {
+__for_each_n_segment(_SegmentedIterator __first, _Size __orig_n, _Functor __func, _Proj& __proj) {
   static_assert(__is_segmented_iterator<_SegmentedIterator>::value &&
                     __has_random_access_iterator_category<
                         typename __segmented_iterator_traits<_SegmentedIterator>::__local_iterator>::value,
@@ -50,13 +49,13 @@ __for_each_n_segment(_SegmentedIterator __first, _Size __orig_n, _Functor __func
   // Single-segment case: input range fits within a single segment (may not align with segment boundaries)
   if (__n <= __seg_size) {
     auto __llast = std::next(__lfirst, __n);
-    __func(__lfirst, __llast);
+    __func(__lfirst, __llast, __proj);
     return _Traits::__compose(__seg, __llast);
   }
 
   // Multi-segment case: input range spans multiple segments.
   // Process the first segment which might not start at the beginning of the segment
-  __func(__lfirst, __slast);
+  __func(__lfirst, __slast, __proj);
   ++__seg;
   __n -= __seg_size;
 
@@ -69,12 +68,12 @@ __for_each_n_segment(_SegmentedIterator __first, _Size __orig_n, _Functor __func
     // The last (potentially partial) segment
     if (__n <= __seg_size) {
       auto __llast = std::next(__sfirst, __n);
-      __func(__sfirst, __llast);
+      __func(__sfirst, __llast, __proj);
       return _Traits::__compose(__seg, __llast);
     }
 
     // Middle whole segments that are completely in the range
-    __func(__sfirst, __slast);
+    __func(__sfirst, __slast, __proj);
     ++__seg;
     __n -= __seg_size;
   }

libcxx/include/__algorithm/for_each_segment.h

@@ -19,33 +19,33 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // __for_each_segment is a utility function for optimizing iterating over segmented iterators linearly.
-// __first and __last are expected to be a segmented range. __func is expected to take a range of local iterators.
-// Anything that is returned from __func is ignored.
+// __first and __last are expected to be a segmented range. __func is expected to take a range of local
+// iterators and a projection function __proj. Anything that is returned from __func is ignored.
 
-template <class _SegmentedIterator, class _Functor>
+template <class _SegmentedIterator, class _Functor, class _Proj>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void
-__for_each_segment(_SegmentedIterator __first, _SegmentedIterator __last, _Functor __func) {
+__for_each_segment(_SegmentedIterator __first, _SegmentedIterator __last, _Functor __func, _Proj& __proj) {
   using _Traits = __segmented_iterator_traits<_SegmentedIterator>;
 
   auto __sfirst = _Traits::__segment(__first);
   auto __slast  = _Traits::__segment(__last);
 
   // We are in a single segment, so we might not be at the beginning or end
   if (__sfirst == __slast) {
-    __func(_Traits::__local(__first), _Traits::__local(__last));
+    __func(_Traits::__local(__first), _Traits::__local(__last), __proj);
     return;
   }
 
   // We have more than one segment. Iterate over the first segment, since we might not start at the beginning
-  __func(_Traits::__local(__first), _Traits::__end(__sfirst));
+  __func(_Traits::__local(__first), _Traits::__end(__sfirst), __proj);
   ++__sfirst;
   // iterate over the segments which are guaranteed to be completely in the range
   while (__sfirst != __slast) {
-    __func(_Traits::__begin(__sfirst), _Traits::__end(__sfirst));
+    __func(_Traits::__begin(__sfirst), _Traits::__end(__sfirst), __proj);
     ++__sfirst;
   }
   // iterate over the last segment
-  __func(_Traits::__begin(__sfirst), _Traits::__local(__last));
+  __func(_Traits::__begin(__sfirst), _Traits::__local(__last), __proj);
 }
 
 _LIBCPP_END_NAMESPACE_STD

libcxx/include/__algorithm/ranges_for_each.h

@@ -15,7 +15,6 @@
 #include <__concepts/assignable.h>
 #include <__config>
 #include <__functional/identity.h>
-#include <__functional/invoke.h>
 #include <__iterator/concepts.h>
 #include <__iterator/projected.h>
 #include <__ranges/access.h>

libcxx/include/__algorithm/ranges_for_each_n.h

@@ -12,8 +12,6 @@
 #include <__algorithm/for_each_n.h>
 #include <__algorithm/in_fun_result.h>
 #include <__config>
-#include <__functional/identity.h>
-#include <__functional/invoke.h>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iterator_traits.h>