[Feature Issue] undefined operator of custom data type should not be called

[fasxmut]

#include <iostream>
#include <boost/proto/proto.hpp>
#include <vector>

namespace proto = boost::proto;

namespace space
{

template <int I>
class placeholder {};

template <typename data_type>
class vector_space:
    public proto::callable_context<space::vector_space<data_type>>
{
public:
    using result_type = data_type;
private:
    std::vector<result_type> __data;
public:
    template <std::same_as<result_type> ... type_list>
    vector_space(const type_list & ... value_list)
    {
        (__data.push_back(value_list), ...);
    }
public:
    auto & get_ref() const
    {
        return __data;
    }
public:
    template <int I>
    result_type operator()(proto::tag::terminal, space::placeholder<I>) const
    {
        return __data[I];
    }
};

template <typename data_type>
class eval_class
{
public:
    template <typename expr_type>
    data_type operator()(const expr_type & expr, const data_type & d1, const data_type & d2) const
    {
        auto ctx = space::vector_space<data_type>{d1, d2};
        return proto::eval(expr, ctx);
    }
};

template <std::floating_point data_type>
class anti_linear
{
private:
    data_type __data;
public:
    anti_linear(): __data{0} {}
    anti_linear(const data_type & data__):
        __data{data__}
    {
    }
public:
    operator data_type & ()
    {
        return __data;
    }
    operator data_type () const
    {
        return __data;
    }
public:
    auto operator+(const anti_linear & al) const
    {
        std::cout << "[info] operator+ #1 is called\n";
        return anti_linear{__data + al.__data};
    }
    auto operator+(const data_type & dt) const
    {
        std::cout << "[info] operator+ #2 is called\n";
        return anti_linear{__data + dt};
    }
public:
    void print() const
    {
        std::cout << "__data: " << __data << std::endl;
    }
};

}   // namespace space

int main()
{
    {
        const auto x0 = proto::terminal<space::placeholder<0>>::type{};
        const auto x1 = proto::terminal<space::placeholder<1>>::type{};
        const auto eval = space::eval_class<space::anti_linear<double>>{};
        const auto a0 = space::anti_linear{2.1};
        const auto a1 = space::anti_linear{-3.2};
        std::cout << "------------------------------------------------\n";
        {
            eval(x0+x1, a0, a1).print();        // (1)
        }
        std::cout << "------------------------------------------------\n";
        {
            eval(x0+3.0, a0, a1).print();       // (2)
        }
        std::cout << "------------------------------------------------\n";
        {
            eval(x0*x1 + x0/2.0 + x1/3.0, a0, a1).print();      // (3)
        }
        std::cout << "------------------------------------------------\n";
    }
}

Output:

------------------------------------------------
[info] operator+ #1 is called
__data: -1.1
------------------------------------------------
[info] operator+ #2 is called
__data: 5.1
------------------------------------------------
__data: -6.73667
------------------------------------------------

operator/ and operator* are not defined for space::anti_linear, it should make a compiling error, but not.