std::experi...es::for_each(3)

okay so this is std::experi...es::for_each(3), straight outta the C++ Standard Libary manual — yes bestie, that’s the manual name, typo and all, we’re keeping it 💅✨

✨ NAME ✨

std::experimental::ranges::for_each — and the original literally repeats it: std::experimental::ranges::for_each. Double-name moment, no cap 🫶

🌸 Synopsis 🌸

Okay so the synopsis starts with the header, then the template soup — make it fashion:

Defined in header <experimental/ranges/algorithm>
template< InputIterator I, Sentinel<I> S, class Proj =
ranges::identity,

          IndirectUnaryInvocable<projected<I, Proj>> Fun >
(1) (ranges TS)
ranges::tagged_pair<tag::in(I), tag::fun(Fun)>

    for_each( I first, S last, Fun f, Proj proj = Proj{} );
template< InputRange R, class Proj = ranges::identity,

          IndirectUnaryInvocable<projected<ranges::iterator_t<R>,
Proj>> Fun >
(2) (ranges TS)
ranges::tagged_pair<tag::in(ranges::safe_iterator_t<R>),
tag::fun(Fun)>

    for_each( R&& r, Fun f, Proj proj = Proj{} );

1. Invokes the given function object f to the result of invoking the projection proj on dereferencing every iterator in the range [first, last) (i.e.,ranges::invoke(f, ranges::invoke(proj, *i))), in order.
2. Same as (1), but uses r as the source range, as if using ranges::begin(r) as first and ranges::end(r) as last.

For both overloads, if the iterator type is mutable, f may modify the elements of the range through the dereferenced iterator. If f returns a result, the result is ignored.

Unlike the rest of the algorithms, for_each is not allowed to make copies of the elements in the sequence even if they are trivially copyable. Like, do not clone the elements, bestie 😭

Unlike std::for_each (which requires only MoveConstructible), these functions require Fun to model CopyConstructible. That’s the vibe check for Fun, periodt.

Notwithstanding the declarations depicted above, the actual number and order of template parameters for algorithm declarations is unspecified. Thus, if explicit template arguments are used when calling an algorithm, the program is probably non-portable — so maybe don’t do that unless you’re ready for chaos 💀

🎀 Parameters 🎀

• first, last — the range to apply the function to
• r — the range to apply the function to
• f — callable object to be applied to each projected element in the range
• proj — projection to apply to the elements

💖 Return value 💖

A tagged_pair object containing the following two members:

• The first member, with the tag tag::in, is the past-the-end iterator of the source range (that is, an iterator of type I that compares equal to the sentinel last).
• The second member, with the tag tag::fun, is initialized from std::move(f) (after all applications of the function object).

🔥 Complexity 🔥

Exactly last - first applications of f and proj. That’s the whole budget, bestie — no extra passes, no sneaky loops.

🧚 Possible implementation 🧚

Here’s the possible implementation, cute and exact:

template<InputIterator I, Sentinel<I> S, class Proj =
ranges::identity,
             IndirectUnaryInvocable<ranges::projected<I, Proj>> Fun>
auto for_each(I first, S last, Fun f, Proj proj = Proj{})
    -> ranges::tagged_pair<tag::in(I), tag::fun(Fun)>
{
    for (; first != last; ++first)
        ranges::invoke(f, ranges::invoke(proj, *first));
    return {std::move(first), std::move(f)};
}

🙈 Example 🙈

This section is incomplete Reason: no example

Not me reading a manual page with no example 😭 iconic in its own way.

💜 See also 💜

• transform — applies a function to a range of elements (function template)
• range-for loop(C++11) — executes loop over range
• for_each — applies a function to a range of elements (function template)
• for_each_n (C++17) — applies a function object to the first N elements of a sequence (function template)

🍓 Category 🍓

• Todo no example

---

mwah 💋 — source/version/date vibes, because we do not skip the footer: http://cppreference.com, 2024.06.10, page std::experi...es::for_each(3). That’s the whole manual page, bestie — go slay 🫶✨