#include <shogun/lib/any.h>
#include <iostream>
#include <vector>

using namespace shogun;

/**
 *
 */
template <typename T>
struct generic_checker
{
    public:
        generic_checker(T val): m_val(val) {};
        bool operator()(T val) {return check(val);};

    protected:
        T m_val;
        virtual bool check(T val) = 0;
};

template <typename T>
struct less_than: generic_checker<T>
{
    public:
        less_than(T val): generic_checker<T>(val) {};
    protected:
        bool check(T val) override {return val < this->m_val;}
};

template <typename T>
struct greater_than: generic_checker<T>
{
    public:
        greater_than(T val): generic_checker<T>(val) {};
    protected:
        bool check(T val) override {return val > this->m_val;}
};

template <typename T = double>
struct positive: greater_than<T>
{
    public:
        positive(): greater_than<T>(0) {};
};

template <typename T = double>
struct negative: less_than<T>
{
    public:
        negative(): less_than<T>(0) {};
};

struct None
{
};

template <typename... Args>
struct Types
{
	using Head = None;
	static constexpr int size = 0;
};

template <typename T1, typename... Args>
struct Types<T1, Args...> : Types<Args...>
{
	using Tail = Types<Args...>;
	using Head = T1;
	static constexpr int size = sizeof...(Args) + 1;
};

template <typename T>
struct is_type : std::false_type {};

template <typename ...Args>
struct is_type<Types<Args...>> : std::true_type {};

// template <template <typename,typename> class Container, typename element, typename Allocator>
// double apply(Container<element, Allocator> & a)
// {
//     return 1;
// }

template<typename T1, typename T2, std::enable_if_t<std::is_same_v<typename T1::Head, None>>* = nullptr>
bool apply_helper(T2 val)
{
	return true;
}

template<typename T1, typename T2, std::enable_if_t<!std::is_same_v<typename T1::Head, None>>* = nullptr>
bool apply_helper(T2 val)
{
	return typename T1::Head{}(val) && apply_helper<typename T1::Tail>(val);
}

template <typename T1, typename T2, std::enable_if_t<is_type<T1>::value>* = nullptr>
bool apply(T2 val)
{
	return apply_helper<T1>(val);
}

template<typename ...Args>
struct real
{
    using funcs = Types<Args...>;
    real()
    {
    };
    real(double val)
    {
        if (apply<funcs>(val))
            m_val = val;
    };
    real& operator=(double val)
    {
        if (apply<funcs>(val))
            m_val = val;
        return *this;
    }
    double m_val;
};

int main(int argc, char **argv)
{
	real<positive<double>> x;
	x = -1;
}