std::ranges::fold_right_last
(on partitioned ranges)
std::ranges
<algorithm>
/*indirectly-binary-right-foldable*/<std::iter_value_t <I>, I> F >
requires std::constructible_from <
std::iter_value_t <I>, std::iter_reference_t <I>>
constexpr auto
/*indirectly-binary-right-foldable*/<
ranges::range_value_t <R>, ranges::iterator_t <R>> F >
requires std::constructible_from <
ranges::range_value_t <R>, ranges::range_reference_t <R>>
constexpr auto
Right-folds the elements of given range, that is, returns the result of evaluation of the chain expression:f(x1, f(x2, ...f(xn-1, xn)))
, where x1
, x2
, ..., xn
are elements of the range.
Informally, ranges::fold_right_last
behaves like ranges::fold_left (views::reverse (r), *--last, /*flipped*/(f)) (assuming the range is not empty).
The behavior is undefined if [
first,
last)
is not a valid range.
[
first,
last)
. Given U as decltype(ranges::fold_right (first, last, std::iter_value_t <I>(*first), f)), equivalent to:
if (first == last) return std::optional <U>(); I tail = ranges::prev (ranges::next (first, std::move(last))); return std::optional <U>(std::in_place, ranges::fold_right (std::move(first), tail, std::iter_value_t <I>(*tail), std::move(f)));
concept /*indirectly-binary-left-foldable-impl*/ =
std::movable <T> &&
std::movable <U> &&
std::convertible_to <T, U> &&
std::invocable <F&, U, std::iter_reference_t <I>> &&
std::assignable_from <U&,
concept /*indirectly-binary-left-foldable*/ =
std::copy_constructible <F> &&
std::indirectly_readable <I> &&
std::invocable <F&, T, std::iter_reference_t <I>> &&
std::convertible_to <std::invoke_result_t <F&, T, std::iter_reference_t <I>>,
std::decay_t <std::invoke_result_t <F&, T, std::iter_reference_t <I>>>> &&
/*indirectly-binary-left-foldable-impl*/<F, T, I,
concept /*indirectly-binary-right-foldable*/ =
class /*flipped*/
{
F f; // exposition only
public:
template< class T, class U >
requires std::invocable <F&, U, T>
std::invoke_result_t <F&, U, T> operator()( T&&, U&& );
The function-like entities described on this page are algorithm function objects (informally known as niebloids), that is:
An object of type std::optional <U> that contains the result of right-fold of the given range over f.
If the range is empty, std::optional <U>() is returned.
struct fold_right_last_fn { template<std::bidirectional_iterator I, std::sentinel_for <I> S, /*indirectly-binary-right-foldable*/<std::iter_value_t <I>, I> F> requires std::constructible_from <std::iter_value_t <I>, std::iter_reference_t <I>> constexpr auto operator()(I first, S last, F f) const { using U = decltype( ranges::fold_right (first, last, std::iter_value_t <I>(*first), f)); if (first == last) return std::optional <U>(); I tail = ranges::prev (ranges::next (first, std::move(last))); return std::optional <U>(std::in_place, ranges::fold_right (std::move(first), tail, std::iter_value_t <I>(*tail), std::move(f))); } template<ranges::bidirectional_range R, /*indirectly_binary_right_foldable*/< ranges::range_value_t <R>, ranges::iterator_t <R>> F> requires std::constructible_from <ranges::range_value_t <R>, ranges::range_reference_t <R>> constexpr auto operator()(R&& r, F f) const { return (*this)(ranges::begin (r), ranges::end (r), std::ref (f)); } }; inline constexpr fold_right_last_fn fold_right_last;
Exactly ranges::distance (first, last) applications of the function object f.
The following table compares all constrained folding algorithms:
Fold function template | Starts from | Initial value | Return type |
---|---|---|---|
ranges::fold_left | left | init | U |
ranges::fold_left_first | left | first element | std::optional <U> |
ranges::fold_right | right | init | U |
ranges::fold_right_last | right | last element | std::optional <U> |
ranges::fold_left_with_iter | left | init |
(1) ranges::in_value_result <I, U> (2) ranges::in_value_result <BR, U>, where BR is ranges::borrowed_iterator_t <R> |
ranges::fold_left_first_with_iter | left | first element |
(1) ranges::in_value_result <I, std::optional <U>> (2) ranges::in_value_result <BR, std::optional <U>> where BR is ranges::borrowed_iterator_t <R> |
Feature-test macro | Value | Std | Feature |
---|---|---|---|
__cpp_lib_ranges_fold |
202207L |
(C++23) | std::ranges fold algorithms
|
#include <algorithm> #include <functional> #include <iostream> #include <ranges> #include <utility> #include <vector> int main() { auto v = {1, 2, 3, 4, 5, 6, 7, 8}; std::vector <std::string > vs {"A", "B", "C", "D"}; auto r1 = std::ranges::fold_right_last(v.begin(), v.end(), std::plus <>()); // (1) std::cout << "*r1: " << *r1 << '\n'; auto r2 = std::ranges::fold_right_last(vs, std::plus <>()); // (2) std::cout << "*r2: " << *r2 << '\n'; // Use a program defined function object (lambda-expression): auto r3 = std::ranges::fold_right_last(v, [](int x, int y) { return x + y + 99; }); std::cout << "*r3: " << *r3 << '\n'; // Get the product of the std::pair::second of all pairs in the vector: std::vector <std::pair <char, float>> data {{'A', 3.f}, {'B', 3.5f}, {'C', 4.f}}; auto r4 = std::ranges::fold_right_last ( data | std::ranges::views::values, std::multiplies <>() ); std::cout << "*r4: " << *r4 << '\n'; }
Output:
*r1: 36 *r2: ABCD *r3: 729 *r4: 42