[meta.logical]

🔗

template<class. B> struct conjunction : see below { };

The class template conjunction forms the logical conjunction of its template type arguments.

For a specialization conjunction<

B {1, \dots, B {N >, if there is a template type argument B {i for which bool (B {i ​::​ value) is false, then instantiating conjunction < B}_{i ​::​ value) is false, then instantiating conjunction < B}}_{i for which bool (B {i ​::​ value) is false, then instantiating conjunction < B}_{i ​::​ value) is false, then instantiating conjunction < B_{,,}}}}_{N >, if there is a template type argument B {i for which bool (B {i ​::​ value) is false, then instantiating conjunction < B}_{i ​::​ value) is false, then instantiating conjunction < B_{,,}}}_{i for which bool (B {i ​::​ value) is false, then instantiating conjunction < B_{,,}}_{i ​::​ value) is false, then instantiating conjunction < B {,,}_{, \dots,}}}}}_{1, \dots, B {N >, if there is a template type argument B {i for which bool (B {i ​::​ value) is false, then instantiating conjunction < B}_{i ​::​ value) is false, then instantiating conjunction < B_{,,}}}_{i for which bool (B {i ​::​ value) is false, then instantiating conjunction < B_{,,}}_{i ​::​ value) is false, then instantiating conjunction < B {,,}_{, \dots,}}}}_{N >, if there is a template type argument B {i for which bool (B {i ​::​ value) is false, then instantiating conjunction < B_{,,}}_{i ​::​ value) is false, then instantiating conjunction < B {,,}_{, \dots,}}}_{i for which bool (B {i ​::​ value) is false, then instantiating conjunction < B {,,}_{, \dots,}}_{i ​::​ value) is false, then instantiating conjunction < B {, \dots,}_{1, \dots,}}}}}

[Note 1:

This is analogous to the short-circuiting behavior of the built-in operator &&.

— end note]

Every template type argument for which

B {i ​::​ value is instantiated shall be usable as a base class and shall have a member value which is convertible to bool, is not hidden, and is unambiguously available in the type .}_{i ​::​ value is instantiated shall be usable as a base class and shall have a member value which is convertible to bool, is not hidden, and is unambiguously available in the type .}

The specialization conjunction<

B {1, \dots, B {N > has a public and unambiguous base that is either (5.1) the first type B {i in the list true_type, B {1, \dots,}_{1, \dots,}}_{i in the list true_type, B {1, \dots,}_{1, \dots, B}} (5.2) if there is no such B {i, the last type in the list .}_{i, the last type in the list .}}_{N > has a public and unambiguous base that is either (5.1) the first type B {i in the list true_type, B {1, \dots,}_{1, \dots, B}}_{i in the list true_type, B {1, \dots, B}_{1, \dots, B}} (5.2) if there is no such B {i, the last type in the list .}_{i, the last type in the list .}}}_{1, \dots, B {N > has a public and unambiguous base that is either (5.1) the first type B {i in the list true_type, B {1, \dots,}_{1, \dots, B}}_{i in the list true_type, B {1, \dots, B}_{1, \dots, B}} (5.2) if there is no such B {i, the last type in the list .}_{i, the last type in the list .}}_{N > has a public and unambiguous base that is either (5.1) the first type B {i in the list true_type, B {1, \dots, B}_{1, \dots, B}}_{i in the list true_type, B {1, \dots, B}_{1, \dots, B_{for which}}} (5.2) if there is no such B {i, the last type in the list .}_{i, the last type in the list .}}}

[Note 2:

This means a specialization of conjunction does not necessarily inherit from either true_type or false_type.

— end note]

The member names of the base class, other than conjunction and operator=, shall not be hidden and shall be unambiguously available in conjunction.

🔗

template<class. B> struct disjunction : see below { };

The class template disjunction forms the logical disjunction of its template type arguments.

For a specialization disjunction<

B {1, \dots, B {N >, if there is a template type argument B {i for which bool (B {i ​::​ value) is true, then instantiating disjunction < B}_{i ​::​ value) is true, then instantiating disjunction < B}}_{i for which bool (B {i ​::​ value) is true, then instantiating disjunction < B}_{i ​::​ value) is true, then instantiating disjunction < B_{,,}}}}_{N >, if there is a template type argument B {i for which bool (B {i ​::​ value) is true, then instantiating disjunction < B}_{i ​::​ value) is true, then instantiating disjunction < B_{,,}}}_{i for which bool (B {i ​::​ value) is true, then instantiating disjunction < B_{,,}}_{i ​::​ value) is true, then instantiating disjunction < B {,,}_{, \dots,}}}}}_{1, \dots, B {N >, if there is a template type argument B {i for which bool (B {i ​::​ value) is true, then instantiating disjunction < B}_{i ​::​ value) is true, then instantiating disjunction < B_{,,}}}_{i for which bool (B {i ​::​ value) is true, then instantiating disjunction < B_{,,}}_{i ​::​ value) is true, then instantiating disjunction < B {,,}_{, \dots,}}}}_{N >, if there is a template type argument B {i for which bool (B {i ​::​ value) is true, then instantiating disjunction < B_{,,}}_{i ​::​ value) is true, then instantiating disjunction < B {,,}_{, \dots,}}}_{i for which bool (B {i ​::​ value) is true, then instantiating disjunction < B {,,}_{, \dots,}}_{i ​::​ value) is true, then instantiating disjunction < B {, \dots,}_{1, \dots,}}}}}

[Note 3:

This is analogous to the short-circuiting behavior of the built-in operator ||.

— end note]

Every template type argument for which

B {i ​::​ value is instantiated shall be usable as a base class and shall have a member value which is convertible to bool, is not hidden, and is unambiguously available in the type .}_{i ​::​ value is instantiated shall be usable as a base class and shall have a member value which is convertible to bool, is not hidden, and is unambiguously available in the type .}

The specialization disjunction<

B {1, \dots, B {N > has a public and unambiguous base that is either (10.1) the first type B {i in the list false_type, B {1, \dots,}_{1, \dots,}}_{i in the list false_type, B {1, \dots,}_{1, \dots, B}} (10.2) if there is no such B {i, the last type in the list .}_{i, the last type in the list .}}_{N > has a public and unambiguous base that is either (10.1) the first type B {i in the list false_type, B {1, \dots,}_{1, \dots, B}}_{i in the list false_type, B {1, \dots, B}_{1, \dots, B}} (10.2) if there is no such B {i, the last type in the list .}_{i, the last type in the list .}}}_{1, \dots, B {N > has a public and unambiguous base that is either (10.1) the first type B {i in the list false_type, B {1, \dots,}_{1, \dots, B}}_{i in the list false_type, B {1, \dots, B}_{1, \dots, B}} (10.2) if there is no such B {i, the last type in the list .}_{i, the last type in the list .}}_{N > has a public and unambiguous base that is either (10.1) the first type B {i in the list false_type, B {1, \dots, B}_{1, \dots, B}}_{i in the list false_type, B {1, \dots, B}_{1, \dots, B_{for which}}} (10.2) if there is no such B {i, the last type in the list .}_{i, the last type in the list .}}}

[Note 4:

This means a specialization of disjunction does not necessarily inherit from either true_type or false_type.

— end note]

The member names of the base class, other than disjunction and operator=, shall not be hidden and shall be unambiguously available in disjunction.

🔗

template<class B> struct negation : see below { };

The class template negation forms the logical negation of its template type argument.

The type negation<B> is a Cpp17UnaryTypeTrait with a base characteristic of bool_constant<!bool(B::value)>.