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 form118 of P,

P_{i}

subsumes every conjunctive clause

Q_{j}

in the conjunctive normal form119 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 ∧ B subsumes A, but A does not subsume A ∧ B.

The constraint A subsumes A ∨ B, but A ∨ 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 ([temp.arg.template]),
(2.4)
the partial ordering of class template specializations ([temp.spec.partial.order]), and
(2.5)
the partial ordering of function templates ([temp.func.order]).

— 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]

118)118)

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 ∧ (B ∨ C) is (A ∧ B) ∨ (A ∧ C).

Its disjunctive clauses are (A ∧ B) and (A ∧ C).

119)119)

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 ∧ (B ∨ C) is in conjunctive normal form.

Its conjunctive clauses are A and (B ∨ C).