Call template function with typename combinations

I want to loop over a "list of typenames" and look at all combinations of them. I was thinking of using a tuple for this, compare:

template<typename T, typename R>
void foo() {
    std::cout << std::numeric_limits<T>::max() << ", " << std::numeric_limits<R>::max();
}

void call() {
    using int_types = std::tuple<int8_t, uint8_t, int16_t, uint16_t, int32_t, uint32_t, int64_t, uint64_t>;
    //Just to visualize my idea, this code does not work! (see comments)
    constexpr auto indices = std::make_integer_sequence<size_t, 8>();
    for (auto i: indices) {
        using T = std::tuple_element_t<i, int_types>;
        for (auto j: indices) {
            using R = std::tuple_element_t<j, int_types>;
            foo<T, R>();
        }
    }
}

Of course for loops are not consteval, thus this approach does not work. I think it might work using recursion or some consteval stuff from the STL but I can't quite figure it out.

You can expand pack that way

using int_types = std::tuple<int8_t, uint8_t, int16_t, uint16_t,
                             int32_t, uint32_t, int64_t, uint64_t>;

[]<typename... Ts>(std::tuple<Ts...>){
    ([]<typename T, typename... Us>(std::type_identity<T>, std::tuple<Us...>){
        (foo<T, Us>(), ...);
    }(std::type_identity<Ts>{}, int_types{}), ...);
}(int_types{});

Demo

Here's an index based version where the inner lambda has access to the concrete indices, here L and K. In that you can do validation if you want to exclude calls to foo if the indices are equal for example:

void call() {
   using int_types = std::tuple<int8_t, uint8_t, int16_t, uint16_t, int32_t,
                                uint32_t, int64_t, uint64_t>;

   constexpr auto tsize = std::tuple_size_v<int_types>;

   []<std::size_t... Is>(std::index_sequence<Is...>) {
      (  // fold 1
         []<size_t I, std::size_t... Js>(std::integral_constant<std::size_t, I>,
                                         std::index_sequence<Js...>) 
         {
            ( // fold 2:
               []<std::size_t K, std::size_t L>(
                   std::integral_constant<std::size_t, K>,
                   std::integral_constant<std::size_t, L>)
               {
                        
                  if constexpr(K != L) foo<std::tuple_element_t<K, int_types>,
                                           std::tuple_element_t<L, int_types>>();

               }(std::integral_constant<std::size_t, I>(),
                 std::integral_constant<std::size_t, Js>()),
               ...);

         }(std::integral_constant<std::size_t, Is>(),
           std::make_index_sequence<tsize>()),
         ...);
   }(std::make_index_sequence<tsize>());
}

Demo