Most predefined concepts expecting more than two parameters are variadic
(cf. section ref(CONPACK)). 

itemization(
ittq(constructible_from)(requires a LHS type and a variadic template parameter
    representing the types from which LHS can be constructed (which may be
    empty if a default constructor is suppported). Here is an example:
   verbinsert(//constructible examples/constructible.cc)
   )  

ittq(equivalence_relation)(this concept defines three template type
    parameters. It is a synonym of the concept tt(std::relation) (see below);)


ittq(invocable)(requires a LHS type and a variadic template parameter
    representing the types which are forwared as arguments to the function or
    functor specified as tt(invocable's) first argument. Here is an example:
   verbinsert(//invocable examples/invocable.cc)
   )

ittq(predicate)(requires a LHS type which is a predicate (functor or function
    returning a tt(bool) value), expecting arguments of the variadic template
    parameter RHS. Here is an example:
   verbinclude(//predicate examples/predicate.cc)
   ) 

ittq(regular_invocable)(synonym of tt(invocable);)

ittq(relation)(this concept defines three template type parameters. The first
    parameter is a predicate whose function call operator expects
    two arguments. The arguments are of the types of the second and/or third
    template type parameters (any combination, any order). 
    For example, the requirements of the tt(std::relation) concept are
    satisfied if the predicate's first template argument is tt(std::less), the
    second argument is tt(int) and the third argument is tt(double). 

    In the following example tt(struct Less) is a functor comparing the
    two arguments of its function call operator. Next, the function tt(cmp)
    accepts such a struct type as predicate, verifying that the predicate and
    the arguments that are passed to the function satisfy the requirements of
    the tt(std::relation) concept. If so the functor's return value is
    returned.

    Finally, in main tt(cmp) is first called with tt(int) and tt(double)
    arguments (which succeeds) and then with an tt(int) and a NTBS arguments:
    for the second call the constraints are not satisfied as tt(ints) and
    tt(NTBSs) can't be compared, and consequently compilation fails:
   verbinclude(//relation examples/relation.cc))


ittq(strict_weak_order)(this concept defines three template type
    parameters. The first parameter is the type of a predicate whose function
    call operator expects two arguments. The arguments are of the types of the
    second and/or third template type parameters (any combination, any
    order). The concept is satisfied if the predicate can verify that a strict
    weak order applies to its argument types. A relation is a strict weak
    ordering if 
    itemization(
    it() the predicate returns false if an object is compared to itself;
    it() the relation is transitive: if tt(pred(one, two)) and tt(pred(two,
        three)) are both true, then tt(pred(one, three)) is also true;
    ))
)

