Cfrgtkky

Given the following code (https://wandbox.org/permlink/Eof3RQs49weJMWan)

#include <tuple>

#include <type_traits>

#include <utility>



template <typename T>

inline constexpr auto always_false = false;



template <typename T>

class HardError {

    static_assert(always_false<T>);

};



int main() {

    std::ignore = std::conjunction<std::false_type, HardError<int>>{};

}

I am trying to understand why this does not error out with std::conjunction as used above. I understand that it is meant to allow short-circuiting so this does not happen, and that this is by design.

However, I don't understand the language rules that allow this to happen. Given the implementation of std::conjunction below

template<class...> struct conjunction : std::true_type { };

template<class B1> struct conjunction<B1> : B1 { };

template<class B1, class... Bn>

struct conjunction<B1, Bn...> 

    : std::conditional_t<bool(B1::value), conjunction<Bn...>, B1> {};

We end up inheriting from this specialization of std::conditional

template<class T, class F>

struct conditional<false, T, F> { typedef F type; };

This requires both class types for instantiation. Then how is the conjunction<Bn...> elided by the language?

cppreference (the page you pulled that implementation from) provides an explanation for how it works:

Conjunction is short-circuiting: if there is a template type argument Bi with bool(Bi::value) == false, then instantiating conjunction<B1, ..., BN>::value does not require the instantiation of Bj::value for j > i.

Concretely, we can see this in action. Your line in main:

std::ignore = std::conjunction<std::false_type, HardError<int>>{};

is equivalent to:

std::ignore.operator=(conjunction<std::integral_constant<bool, 0>, HardError<int> >{{}});

Which should cause an instantiation, something like the following:

template<>

struct conjunction<std::integral_constant<bool, 0>, HardError<int> > : public std::integral_constant<bool, 0>

{

  inline ~conjunction() noexcept = default;



};

The instantiation of a template does not trigger the instantiation of its template arguments. See [temp.inst/2]

This is a typical way to delay hard error.

template<class T> struct delay {

    using run = T;

};



int main() {

    // force instantiation of delay<HardError<int>>,

    // but HardError<int> itself is not instantiated

    sizeof(delay<HardError<int>>);



    delay<HardError<int>> a; // OK, same as above



    // Now HardError<int> is instantiated, static_assert failure

    // sizeof(delay<HardError<int>>::run);

}

For the same reason, the instantiation of std::conditional<false, int, HardError<int>> won't cause the instantiation of HardError<int>

Furthermore, the template argument doesn't even need to be complete.

The following code is also valid:

struct incomplete_tag;



int main() { sizeof(delay<incomplete_tag>); }