Visiting std::variant using lambda expressions in C++17

visit-variant.cpp

// $ g++ -std=c++17 -pedantic -Wall -Wextra visit-variant.cpp -o visit-variant
// $ ./visit-variant

// Implementation:
//
// Based on http://en.cppreference.com/w/cpp/utility/variant/visit

#include <variant>

template<typename... Ts> struct make_overload: Ts... { using Ts::operator()...; };
template<typename... Ts> make_overload(Ts...) -> make_overload<Ts...>;

template<typename Variant, typename... Alternatives>
decltype(auto) visit_variant(Variant&& variant, Alternatives&&... alternatives) {
    return std::visit(
        make_overload{std::forward<Alternatives>(alternatives)...},
        std::forward<Variant>(variant)
    );
}

// Usage example:

#include <iostream>
#include <string>

int main() {
    std::variant<int, double, std::string> v{"hello"};

    // The following call prints "hello":
    visit_variant(v,
        [](int i) { std::cout << i << '\n'; },
        [](double d) { std::cout << d << '\n'; },
        [](const std::string& s) { std::cout << s << '\n'; }
    );
}

auto visit_variant(auto&& variant, auto&&... alternatives)
{
    return std::visit(overloaded{std::forward<decltype(alternatives)>(alternatives)...},
           std::forward<decltype(variant)>(variant));
}