std::experi...disjunction(3)

🌸 NAME 🌸

Okay so this is the std::experi...disjunction(3) page, bestie, and it lives under the manual name C++ Standard Libary — yes, “Libary” exactly like that, and we are respecting the header’s typo-era main character energy 💅.

• std::experimental::disjunction — literally std::experimental::disjunction. That’s the name, no cap.

✨ Synopsis ✨

Defined in header <experimental/type_traits>
template< class... B >                        (library fundamentals
TS v2)
struct disjunction;

Okay so what is this actually doing? It forms the logical disjunction of the type traits B... — effectively performing a logical or on the sequence of traits. That’s the whole vibe: variadic OR for type traits. 🔥

The specialization std::experimental::disjunction<B1, ..., BN> has a public and unambiguous base that is:

• if sizeof...(B) == 0, std::false_type; otherwise
• the first type Bi in B1, ..., BN for which bool(Bi::value) == true, or BN if there is no such type.

All the member names from that base class — everything except disjunction and operator= — are not hidden and are unambiguously available in disjunction. Slay, unambiguously ✨.

disjunction is short-circuiting: if there’s a template type argument Bi with bool(Bi::value) != false, then instantiating disjunction<B1, ..., BN>::value does not require the instantiation of Bj::value for j > i. It’s giving lazy evaluation but legal 😭.

🧚 Template parameters 🧚

• B... — every template argument Bi for which Bi::value is instantiated must be usable as a base class and define member value that is convertible to bool.

🎀 Helper variable template 🎀

template< class... B >
constexpr bool disjunction_v =                          (library
fundamentals TS v2)
disjunction<B...>::value;

💅 Possible implementation 💅

Here’s the possible implementation, and yes we’re keeping it exact because code is sacred:

template<class...> struct disjunction : std::false_type {};
template<class B1> struct disjunction<B1> : B1 {};
template<class B1, class... Bn>
struct disjunction<B1, Bn...>
    : std::conditional_t<bool(B1::value), B1, disjunction<Bn...>>
{};

💜 Notes 💜

A specialization of disjunction does not necessarily inherit from std::true_type or std::false_type — the original page has the little “from of either” moment, and we’re preserving that exact energy while keeping the fact: it simply inherits from the first B whose ::value, explicitly converted to bool, is true, or from the very last B when all of them convert to false. For example, disjunction<std::integral_constant<int, 2>, std::integral_constant<int, 4>>::value is 2. Not true, bestie — literally 2 😭🔥.

🦋 Example 🦋

This section is incomplete. Reason: no example. Not me making one up — the page literally says no example, so we’re leaving it as is 🫶.

🔥 See also 🔥

• disjunction — variadic logical OR metafunction, (C++17) (class template).

🍓 Category 🍓

• Todo no example

---

Source: http://cppreference.com · version/date: 2024.06.10 · page: std::experi...disjunction(3) — bye bestie, go disjunct responsibly 💅✨