How to parameter pack pairs of types?

Question

Here's an example usage of a parameter pack:

template <typename... T>
bool foo(A x) {
  return (baz<T>(x) || ...);
}

I'd like to do something similar, but with pairs of types. Here's an example (note that this isn't real C++ syntax):

template <typename... [T, Z]>
bool foo(A x) {
  return (baz<T, Z>(x) || ...);
}

How is it possible to do something like this (i.e, a parameter pack over pairs)?

Here is a larger fleshed example of what I intend to do:

// caller
foo<{A1, A2}, {B1, B2}, C, D>(x);
// callee should expand to...
int foo(void* x) {
  if (baz<A1,A2>(x) || baz<B1, B2>(x)) return 0;
  if (bar<C>(x) || bar<D>(x)) return 1;
  return 2
}

Answer 1

You might use parameter to pack the pairs, something like:

template <typename... Ts, typename... Us>
bool foo(std::tuple<std::pair<Ts, Us>...>, A x) {
  return (baz<Ts, Us>(x) || ...);
}

Demo

Possibly wrap with std::type_identity (to avoid to construct the type), or create your own wrapper (type_list<Ts...>).

From your edit, you mix pair with non pair types, so use regular variadic template and dispatch according to the inner type:

// dispatcher helper
template <typename... Ts>
struct overloaded : Ts...
{
    using Ts::operator()...;
};

template <typename... Ts>
bool foo(A a) {
    auto func = overloaded{
        []<typename T>(std::type_identity<T>, A a){ return baz<T>(a); },
        []<typename T1, typename T2>(std::type_identity<std::pair<T1, T2>>, A a){ return baz<T1, T2>(a); },
        []<typename... Us>(std::type_identity<std::tuple<Us...>>, A a){ return baz<Us...>(a); }
    };
    
    return (func(std::type_identity<Ts>{}, a) || ...);
}

Usage similar to:

foo<
    std::pair<int, float>,
    std::pair<int, int>,
    char,
    std::tuple<char, int, float>,
    float>(A{});

Demo