template <typename T, typename V>
class is_customly_convertible {
    typedef char first;
    struct second { char x[2]; };

    template <typename C> static first test(decltype(&C::operator()));
    template <typename C> static second test(...);

 public:
    enum { val = sizeof(test<Convert<T, V>>(0)) == sizeof(char) };
};

class NoTriviallyConstructible {
 public:
    NoTriviallyConstructible() = delete;
};

class NoCopyConstructible {
 public:
    NoCopyConstructible(const NoCopyConstructible&) = delete;
    NoCopyConstructible& operator=(const NoCopyConstructible&) = delete;
};

template<>
struct Convert<NoTriviallyConstructible, int> {
    int operator()(const int &a) {
        return a;
    }
};

template<>
struct Convert<NoCopyConstructible, NoTriviallyConstructible> {
    int operator()(const int &a) {
        return a;
    }
};