Двойная диспетчеризация :)

#include <Core/Core.h>
 
#include <variant>
 
using namespace Upp;
 
class line {};
 
class arc {};
 
struct intersects_algo
{
    bool operator()( One<line>&, One<line>&) const
    {
        LOG("line vs line");
        return true;
    }
    bool operator()( One<arc>&,  One<arc>&) const
    {
        LOG("arc vs arc"); 
        return true;
    }
    bool operator()(One<line>&, One<arc>&) const
    {
        LOG("line vs arc"); 
        return true;
    }
    bool operator()(One<arc>& a, One<line>& l) const
        { return this->operator()(l, a); }
};
 
 
template <typename X>
using refwrap = std::reference_wrapper<X>;
 
using element = std::variant<refwrap<One<line>>, refwrap<One<arc>>>;
 
//using element = std::variant<One<line>, One<arc>>;
 
bool intersect(const element& e1, const element& e2  )
{
    return std::visit(intersects_algo(), e1, e2 );
}
 
CONSOLE_APP_MAIN
{
    StdLogSetup(LOG_COUT|LOG_FILE);
    
    One<line> e1;
    e1.Create<line>();
    
    One<arc> e2;
    e2.Create<arc>();
    
    const bool result = intersect(e1, e2);
    
    LOG(result);
}

const bool result = intersect(pick(e1), pick(e2));

using element = std::variant<One<line>, One<arc>>;
 
bool intersect(const element& e1, const element& e2  )
{
    return std::visit(intersects_algo(), e1, e2 );
}
 
CONSOLE_APP_MAIN
{
    StdLogSetup(LOG_COUT|LOG_FILE);
   
    One<line> e1;
    e1.Create<line>();
    
    element ea1 = std::move(e1); // e1 теперь не владеет
    
    One<arc> e2;
    e2.Create<arc>();
    
    element ea2 = std::move(e2); // e2 теперь не владеет
    
    const bool result = intersect(ea1, ea2);
    
    LOG(result);
}

CONSOLE_APP_MAIN
{
    StdLogSetup(LOG_COUT|LOG_FILE);
    
    const element e1=MakeOne<line>();   
    const element e2=MakeOne<arc>();
    
    const bool result = intersect(pick(e1), pick(e2));
    
    LOG(result);
}

#include <iostream>
#include <string>
#include <variant>
 
template<class... Ts> struct overload : Ts... { using Ts::operator()...; };
template<class... Ts> overload(Ts...) -> overload<Ts...>;
 
int main() {
    std::variant<int, float, std::string> intFloatString { "Hello" };
    std::visit(overload  {
        [](const int& i) { std::cout << "int: " << i; },
        [](const float& f) { std::cout << "float: " << f; },
        [](const std::string& s) { std::cout << "string: " << s; }
      },
      intFloatString
    );        
}