13 Templates [temp]

13.5 Template constraints [temp.constr]

13.5.5 Partial ordering by constraints [temp.constr.order]

A constraint P subsumes a constraint Q if and only if, for every disjunctive clause

P_{i}

in the disjunctive normal form134 of P,

P_{i}

subsumes every conjunctive clause

Q_{j}

in the conjunctive normal form135 of Q, where

(1.1)
a disjunctive clause $P_{i}$ subsumes a conjunctive clause $Q_{j}$ if and only if there exists an atomic constraint $P_{i a}$ in $P_{i}$ for which there exists an atomic constraint $Q_{j b}$ in $Q_{j}$ such that $P_{i a}$ subsumes $Q_{j b}$ , and
(1.2)
an atomic constraint A subsumes another atomic constraint B if and only if A and B are identical using the rules described in [temp.constr.atomic].

[Example 1:

Let A and B be atomic constraints .

The constraint

A \land B

subsumes A, but A does not subsume

A \land B

The constraint A subsumes

A \lor B

, but

A \lor B

does not subsume A.

Also note that every constraint subsumes itself.

— end example]

[Note 1:

The subsumption relation defines a partial ordering on constraints.

This partial ordering is used to determine

(2.1)
the best viable candidate of non-template functions ([over.match.best]),
(2.2)
the address of a non-template function ([over.over]),
(2.3)
the matching of template template arguments,
(2.4)
the partial ordering of class template specializations, and
(2.5)
the partial ordering of function templates .

— end note]

A declaration D1 is at least as constrained as a declaration D2 if

(3.1)
D1 and D2 are both constrained declarations and D1's associated constraints subsume those of D2; or
(3.2)
D2 has no associated constraints.

A declaration D1 is more constrained than another declaration D2 when D1 is at least as constrained as D2, and D2 is not at least as constrained as D1.

[Example 2: template<typename T> concept C1 = requires(T t) { --t; }; template<typename T> concept C2 = C1<T> && requires(T t) { *t; }; template<C1 T> void f(T); // #1 template<C2 T> void f(T); // #2 template<typename T> void g(T); // #3 template<C1 T> void g(T); // #4 f(0); // selects #1 f((int*)0); // selects #2 g(true); // selects #3 because C1<bool> is not satisfied g(0); // selects #4 — end example]

134)

A constraint is in disjunctive normal form when it is a disjunction of clauses where each clause is a conjunction of atomic constraints.

For atomic constraints A, B, and C, the disjunctive normal form of the constraint

A \land (B \lor C)

(A \land B) \lor (A \land C)

Its disjunctive clauses are

(A \land B)

and

(A \land C)

⮥

135)

A constraint is in conjunctive normal form when it is a conjunction of clauses where each clause is a disjunction of atomic constraints.

For atomic constraints A, B, and C, the constraint

A \land (B \lor C)

is in conjunctive normal form.

Its conjunctive clauses are A and

(B \lor C)

⮥