Существуют ли гарантии сложности компиляции расширения пакета параметров с использованием выражений свертки

Я могу представить себе простую эффективную реализацию раскрытия выражений сгиба, когда все типы пакетов параметров одинаковы (упрощенный пример c ++ 11):

#include <type_traits>
#include <array>

template <bool...>
struct bool_pack { };

template <bool... Bs>
using and_ = std::is_same<bool_pack<true, Bs...>, bool_pack<Bs..., true>>;

template <std::size_t I, std::size_t N, class T>
constexpr typename std::enable_if<(I == N - 1),T>::type fold_impl_impl(std::array<T, N> const &arr) {
return arr[I];
}

template <std::size_t I, std::size_t N, class T>
constexpr typename std::enable_if<(I < N - 1),T>::type fold_impl_impl(std::array<T, N> const &arr) {
return arr[I] + fold_impl_impl<I+1, N>(arr);
}

template <class T, std::size_t N>
constexpr T fold_impl(std::array<T, N> arr) {
return fold_impl_impl<0, N>(arr);
}

template <class T, class... Ts>
constexpr typename std::enable_if<and_<std::is_same<T, Ts>::value...>::value, T>::type fold(T first, Ts... rest) {
return fold_impl<T, sizeof...(Ts) + 1>({{first, rest...}});
}

int main() {
static_assert(fold(1, 2, 3, 4) == 10, "!");
}

Конечно, когда мы рассматриваем более общий случай, то есть когда мы не можем предположить, что типы одинаковы, мы можем заменить ссылку на std::array со ссылкой на std::tuple типов параметров. Однако в этом случае сам кортеж, скорее всего, вызовет увеличение сложности расширения с логарифмом числа параметров.

Можно было бы сделать так, чтобы компилятор внутренне обрабатывал выражения сгиба, чтобы быть уверенным, что сложность расширения O(N), но в c ++ стандартный черновик в разделе [Expr.prim.fold] Я не вижу гарантий на это.

Можем ли мы предположить, что расширение пакета параметров с использованием выражения сложения дешево?