std::projected(3)

✨ std::projected(3) ✨

okay so bestie, this is from the C++ Standard Libary manpage (yes, "Libary" — that's literally how it's spelled in the header, no cap 💀). it's giving C++20/26 template metaprogramming realness and i'm obsessed. let's go 🫶

---

🌸 NAME 🌸

std::projected — std::projected (yes the name is literally the same, it's iconic, periodt 💅)

---

✨ Synopsis ✨

here's the whole vibe. don't panic, it's just templates:

Defined in header <iterator>
template< std::indirectly_readable I,

          std::indirectly_regular_unary_invocable<I> Proj >
struct projected
{
(since C++20)
    using value_type =
(until C++26)
std::remove_cvref_t<std::indirect_result_t<Proj&, I>>;
    std::indirect_result_t<Proj&, I> operator*() const; //
not defined

};
template< std::indirectly_readable I,

          std::indirectly_regular_unary_invocable<I> Proj >
(since C++26)

using projected = /*projected-impl*/<I, Proj>::/*__type*/; //
see (3)
template< std::weakly_incrementable I, class Proj >

struct incrementable_traits<std::projected<I, Proj>>          (1)
(since C++20)
{                                                                 (2)
(until C++26)
    using difference_type = std::iter_difference_t<I>;

};
template< class I, class Proj >

struct /*projected-impl*/
{
    struct /*__type*/
    {
        using value_type =
(since C++26)
std::remove_cvref_t<std::indirect_result_t<Proj&, I>>;            (3)
(exposition
    using difference_type = std::iter_difference_t<I>; //
only*)
conditionally present

        std::indirect_result_t<Proj&, I> operator*() const;
// not defined
    };

};

now the numbered tea ☕:

1. (1) okay so it's a Class until C++26, and an Alias since C++26. the template projected combines an indirectly_readable type I and a callable object type Proj into a new indirectly_readable type whose reference type is the result of applying Proj to the std::iter_reference_t<I>. slay 💅
2. (2) this specialization of std::incrementable_traits makes std::projected<I, Proj> a weakly_incrementable type when I is also a weakly_incrementable type. periodt.
3. (3) an indirect layer used for avoiding unexpected argument-dependent lookup. the member type difference_type exists only if I models weakly_incrementable. iykyk.

and like, projected is used only to constrain algorithms that accept callable objects and projections, and hence its operator*() is not defined. so don't try to call it, bestie 😭

---

🎀 Template parameters 🎀

• I — an indirectly readable type
• Proj — projection applied to a dereferenced I

---

🦋 Notes 🦋

the indirect layer stops I and Proj from being associated classes of projected. when an associated class of I or Proj is an incomplete class type, the indirect layer saves you from the unnecessary attempt to inspect the definition of that type, which would result in a hard error. no cap, that's a whole mood 🫶

---

🔥 Example 🔥

// Run this code

#include <algorithm>
#include <cassert>
#include <functional>
#include <iterator>

template<class T>
struct Holder
{
    T t;
};

struct Incomplete;

using P = Holder<Incomplete>*;

static_assert(std::equality_comparable<P>); // OK
static_assert(std::indirectly_comparable<P*, P*, std::equal_to<>>); //
Error before C++26
static_assert(std::sortable<P*>); // Error before C++26

int main()
{
    P a[10] = {}; // ten null pointers
    assert(std::count(a, a + 10, nullptr) == 10); // OK
    assert(std::ranges::count(a, a + 10, nullptr) == 10); // Error
before C++26
}

---

🌈 See also 🌈

• projected_value_t (C++26) (alias template) — computes the value type of an indirectly_readable type by projection.

---

okay that's the whole thing bestie! source: http://cppreference.com 💖 version/date: 2024.06.10 ✨ page: std::projected(3) 🎀 now go slay those templates 💅👑