std::ranges::fold_left_first_with_iter, std::ranges::fold_left_first_with_iter_result - cppreference.com (original) (raw)

Left-folds the elements of given range, that is, returns the result of evaluation of the chain expression:
f(f(f(f(x1, x2), x3), ...), xn), where x1, x2, ..., xn are elements of the range.

Informally, ranges::fold_left_first_with_iter behaves like std::accumulate's overload that accepts a binary predicate, except that the *first is used internally as an initial element.

The behavior is undefined if [first, last) is not a valid range.

1. The range is [first, last).

2. Same as (1), except that uses r as the range, as if by using ranges::begin(r) as first and ranges::end(r) as last.

3. Equivalent to:

1. The return type alias. See "Return value" section for details.

The function-like entities described on this page are algorithm function objects (informally known as niebloids), that is:

• Explicit template argument lists cannot be specified when calling any of them.
• None of them are visible to argument-dependent lookup.
• When any of them are found by normal unqualified lookup as the name to the left of the function-call operator, argument-dependent lookup is inhibited.

Contents

• 1 Parameters
• 2 Return value
• 3 Possible implementations
• 4 Complexity
• 5 Notes
• 6 Example
• 7 References
• 8 See also

[edit] Parameters

[edit] Return value

Let U be decltype(ranges::fold_left(std::move(first), last, std::iter_value_t<I>(*first), f)).

1. An object of type ranges::fold_left_first_with_iter_result<I, std::optional<U>>.

• The member ranges::in_value_result::in holds an iterator to the end of the range.
• The member ranges::in_value_result::value holds the result of the left-fold of given range over f.

If the range is empty, the return value is {std::move(first), std::optional<U>()}.

[edit] Possible implementations

class fold_left_first_with_iter_fn { template<class O, class I, class S, class F> constexpr auto impl(I&& first, S&& last, F f) const { using U = decltype( ranges::fold_left(std::move(first), last, std::iter_value_t(*first), f) ); using Ret = ranges::fold_left_first_with_iter_result<O, std::optional>; if (first == last) return Ret{std::move(first), std::optional()}; std::optional init(std::in_place, *first); for (++first; first != last; ++first) *init = std::invoke(f, std::move(*init), *first); return Ret{std::move(first), std::move(init)}; }   public: template<std::input_iterator I, std::sentinel_for S, /indirectly-binary-left-foldable/<std::iter_value_t, I> F> requires std::constructible_from<std::iter_value_t, std::iter_reference_t> constexpr auto operator()(I first, S last, F f) const { return impl(std::move(first), std::move(last), std::ref(f)); }   template<ranges::input_range R, /*indirectly-binary-left-foldable*/< ranges::range_value_t, ranges::iterator_t> F> requires std::constructible_from<ranges::range_value_t, ranges::range_reference_t> constexpr auto operator()(R&& r, F f) const { return impl<ranges::borrowed_iterator_t>( ranges::begin(r), ranges::end(r), std::ref(f) ); } };   inline constexpr fold_left_first_with_iter_fn fold_left_first_with_iter;

[edit] Complexity

Exactly ranges::distance(first, last) - 1 (assuming the range is not empty) applications of the function object f.

[edit] Notes

The following table compares all constrained folding algorithms:

[edit] Example

#include #include #include #include #include #include #include   int main() { std::vector v{1, 2, 3, 4, 5, 6, 7, 8};   auto sum = std::ranges::fold_left_first_with_iter ( v.begin(), v.end(), std::plus() ); std::cout << "sum: " << sum.value.value() << '\n'; assert(sum.in == v.end());   auto mul = std::ranges::fold_left_first_with_iter(v, std::multiplies()); std::cout << "mul: " << mul.value.value() << '\n'; assert(mul.in == v.end());   // get the product of the std::pair::second of all pairs in the vector: std::vector<std::pair<char, float>> data {{'A', 2.f}, {'B', 3.f}, {'C', 7.f}}; auto sec = std::ranges::fold_left_first_with_iter ( data | std::ranges::views::values, std::multiplies<>() ); std::cout << "sec: " << sec.value.value() << '\n';   // use a program defined function object (lambda-expression): auto lambda = [](int x, int y) { return x + y + 2; }; auto val = std::ranges::fold_left_first_with_iter(v, lambda); std::cout << "val: " << val.value.value() << '\n'; assert(val.in == v.end()); }

Output:

sum: 36 mul: 40320 sec: 42 val: 50

[edit] References

• C++23 standard (ISO/IEC 14882:2024):

• 27.6.18 Fold [alg.fold]

[edit] See also