#include <iostream>

template<typename T>
struct void_template { typedef void type; };

template<typename T>
using void_template_alias = void;

template<typename T, typename U = void>
struct fun_template
{
    void print() const
    {
        std::cout << "unspecialized" << std::endl;
    }
};
template<typename T>
struct fun_template<T, typename void_template<typename T::type>::type>
{
    void print() const
    {
        std::cout << "void" << std::endl;
    }
};

template<typename T, typename U = void>
struct fun_template_alias
{
    void print() const
    {
        std::cout << "unspecialized" << std::endl;
    }
};
template<typename T>
struct fun_template_alias<T, void_template_alias<typename T::type>>
{
    void print() const
    {
        std::cout << "void" << std::endl;
    }
};

template<typename T>
struct hard_error
{
    static_assert(sizeof(T) == 0, "Your expectations never hold");
};

template<typename T>
struct soft_error
{};

int main(int argc, char** argv)
{
    // plain template, hard error case
    // expected: compilation error
    // GCC 4.8.1: compilation error
    fun_template<hard_error<int>>{}.print();

    // template alias, hard error case
    // expected: compilation error
    // GCC 4.8.1: "void"
    fun_template_alias<hard_error<int>>{}.print();

    // plain template, soft error case
    // expected: "unspecialized"
    // GCC 4.8.1: "unspecialized"
    fun_template<soft_error<int>>{}.print();

    // template alias, soft error case
    // expected: "unspecialized"
    // GCC 4.8.1: "void"
    fun_template_alias<soft_error<int>>{}.print();

    return 0;
}