Implementation of concepts in C++17 - c++

Question

I'd seen the Bjarne stroustrup's talk named "Concepts the future of generic programming" and I thought maybe I can write "Concepts" in C++17...
But I'm a C programmer I've start with C++ about 6 months ago... so I don't know why but I've got e trouble with this code. Somebody can help me?
I'd implemented the Addable's concept with a shortly tmp code...
The idea is that will be in C++20 will be something like this:
template<typename T>
concept Summable = requires(T x) { x + x; };
template<typename T> requires Summable<T>
T sum(T n1, T n2) {
return n1 + n2;
}
And this code is what actually have in C++17:
template <typename, typename, typename = void>
struct Addable : std::false_type {};
template <typename T, typename U>
struct Addable < T, U,
std::void_t<decltype(std::declval<T&>()+std::declval<U&>())> >
: std::true_type {};
The top's code compile and works, but when I whrite the following code doesn't compile...
template<typename Head, typename ... Tail>
auto sum(Head h, Tail ... args) {
static_assert(Addable<Head, Tail...>::value, "Requires addable objects");
return h+(args+...);
}

Answer 1

You might change you assertion to
template <typename Head, typename ... Tail>
auto sum(Head h, Tail ... args) {
static_assert((Addable<Head, Tail>::value || ...), "Requires addable objects");
return (h + ... + args);
}
as your traits only works for 2 types.
Notice that SFINAE looks more like concept than static_assert.

Answer 2

Your code does work as long as you only provide two arguments to sum.
The problem is that when you call something like sum(1, 2, 3), Addable<Head, Tail...> becomes Addable<int, int, int>, which doesn't match your Addable<T, U, void> partial specialization. If you call sum with more than three arguments then there's no Addable template that matches at all, since Addable only accepts three template parameters.
If you want to be able to deal with more than two arguments, you'll need a different approach. This is what I came up with. It uses a similar approach to what you used, just with an extra layer indirection to support more than two arguments:
template <typename T, typename U, typename = void>
struct Helper : std::false_type {};
template <typename T, typename U>
struct Helper<T, U, std::void_t<decltype(std::declval<T>() + std::declval<U>())>> : std::true_type {};
template <typename, typename...>
struct Addable : std::false_type {};
template <typename T, typename U, typename... V>
struct Addable<T, U, V...> : std::conditional_t<Addable<T, U>::value,
Addable<U, V...>,
std::false_type> {};
template <typename T, typename U>
struct Addable<T, U> : Helper<T, U> {};
template<typename Head, typename ... Tail>
auto sum(Head h, Tail ... args) {
static_assert(Addable<Head, Tail...>::value, "Requires addable objects");
return h+(args+...);
}
Live Demo