Создать пакет параметров складного шаблона

Is it possible to create template parameter pack that can be folded to avoid writing same fragment of code multiple times?

На месте? Не в C++ 17. Вам нужно будет обернуть ваши типы в какой-то template <typename...> struct typelist;, а затем развернуть их где-нибудь еще. Это требует одного уровня косвенного обращения.

Насколько я знаю, нет возможности записать что-нибудь вроде std::pack.

I've tried to solve the problem using T pack and aliasing single L and R. [...]

В вашем коде T... всегда будет пустым, поскольку он ничем не выводится. Значения параметров шаблона по умолчанию для L и R игнорируются, поскольку они выводятся при вызове функции.

Вам понадобится что-то вроде:

template<
    typename... T,
    typename = std::enable_if_t<(... && std::is_same_v<int, T>)>
>
int F(T...){
    return 0x70D0;
}

В C++ 20 вы должны иметь возможность использовать лямбда следующим образом:

template<
    typename L,
    typename R,
    typename = std::enable_if_t<[]<typename... Ts>(){
        return (... && std::is_same_v<int, Ts>)
    }.operator()<L, R>()>
>
int F(L Left, R Right){
    return 0x70D0;
}

Слишком поздно играть?

Is it possible to create template parameter pack that can be folded to avoid writing same fragment of code multiple times?

Насколько мне известно, не в самом F().

Но вы можете перепаковать типы, например, в список вызываемой функции.

Я имею в виду ... если вы объявлять определите (только объявить: нет необходимости определять его, потому что он используется только в decltype()) следующую функцию [Обновлено: как было предложено Барри (спасибо), определение функции упрощает использование]

template <typename T, typename ... Ts>
constexpr auto isSameList ()
   -> std::bool_constant<(... && std::is_same_v<T, std::decay_t<Ts>>)>
 { return {}; } 

где вы можете использовать сворачивание шаблонов, вы можете SFINAE для включения / отключения F() следующим образом

template <typename L, typename R,
          std::enable_if_t<isSameList<int, L, R>(), bool> = true>
int F(L Left, R Right)
 { return 0x70D0; }

Ниже приведен полный пример компиляции.

#include <type_traits>

template <typename T, typename ... Ts>
constexpr auto isSameList ()
   -> std::bool_constant<(... && std::is_same_v<T, std::decay_t<Ts>>)>
 { return {}; } 

template <typename L, typename R,
          std::enable_if_t<isSameList<int, L, R>(), bool> = true>
int F(L Left, R Right)
 { return 0x70D0; }

int main ()
 {
    F(3, 5);   // compile
    //F(3, "5"); // compilation error
 }

У вас это почти было:

template <typename L,typename R,
  typename = std::enable_if_t<std::is_same_v<std::tuple<int,L,R>,std::tuple<L,R,int>>>>
int F(L Left, R Right){
    return 0x70D0;
}

int main(){
    F(3, 5);   // OK
    F(3, "5"); // Does not compile
    F("5", 3); // Does not compile
}

или вариативная версия:

template <typename... T,
  typename = std::enable_if_t<std::is_same_v<std::tuple<int,T...>,std::tuple<T...,int>>>>
int F(T... args){
    return 0x70D0;
}

int main(){
    F(3, 5);   // OK
    F(3, "5"); // Does not compile
    F("5", 3); // Does not compile
}