Hay un comportamiento diferente enclang ++ yg ++ para el próximo programa:

#include <type_traits>
#include <utility>

template< std::size_t index, typename type >
struct ref { type & value; };

template< std::size_t index, typename type >
type && get(ref< index, type > const & r)
{
    return std::forward< type >(r.value);
}

template< typename F, typename ...types, std::size_t ...indices >
decltype(auto) apply_inverse(F & f, types &... values, std::index_sequence< indices... >)
{
    struct : ref< indices, types >... {} refs{{values}...};
    constexpr std::size_t top = sizeof...(indices) - 1;
    return std::forward< F >(f)(get< top - indices >(refs)...);
}

template< typename F, typename ...types >
decltype(auto) apply_inverse(F && f, types &&... values)
{
    return apply_inverse< F, types... >(f, values..., std::index_sequence_for< types... >{});
}

#include <iostream>

int main()
{
    auto const print = [] (auto const &... value) -> std::ostream & { return (std::cout << ... << value); };
    apply_inverse(print, 1, 2, 3) << std::endl;
}

Ejemplo en vivo.

Solo trata de revertir los argumentos pasados y les aplica alguna función.

porG ++ se compila bien, pero paraclang ++ (incluso desde el tronco) da el siguiente error:

error: no hay función coincidente para la llamada a 'apply_inverse'

Creo que la razón es el hecho de que en la sobrecarga superior hay un parámetro después del paquete de parámetros en el prototipo de la función. Pero los tipos para todos los argumentos en el paquete de argumentos se especifican explícitamente.

¿Es correcto que el compilador acepte el código?