Suggestions for implementing the visitor pattern?

[WillAyd]

I am working with fixed data types but a potentially limitless amount of algorithms to apply against those types, so I figured the visitor pattern would work well for the problems I am trying to solve. Here is a simple attempt at implementing this via nanobind:

#include <nanobind/nanobind.h>
#include <nanobind/stl/string.h>
#include <nanobind/stl/variant.h>

namespace nb = nanobind;

struct BoolScalar {};
struct StringScalar {};
struct IntScalar {};

using ObjVar = std::variant<std::string, bool, int>;

class VisitorClass {
public:
  auto Visit(const BoolScalar& arg) const -> ObjVar {
    return true;
  }

  auto Visit(const StringScalar& arg) const -> ObjVar {
    return std::string{"Hello, world!"};
  }

  auto Visit(const IntScalar& arg) const -> ObjVar {
    return 42;
  }    
};

template <typename T>
auto VisitorFunc(const T& arg) -> ObjVar {
  if constexpr(std::is_same_v<T, BoolScalar>)
    return true;
  else if constexpr(std::is_same_v<T, StringScalar>)
    return std::string{"Hello, world"};
  else if constexpr(std::is_same_v<T, IntScalar>)
    return 42;
};

NB_MODULE(my_ext, m) {
  nb::class_<BoolScalar>(m, "BoolScalar")
    .def(nb::init<>())
    .def("visit", static_cast<ObjVar (VisitorClass::*)(BoolScalar&&) const>(&VisitorClass::Visit));
  nb::class_<StringScalar>(m, "StringScalar")
    .def(nb::init<>())    
    .def("visit", &VisitorFunc<StringScalar>);
  nb::class_<IntScalar>(m, "IntScalar")
    .def(nb::init<>())    
    .def("visit", &VisitorFunc<IntScalar>);
}

This compiles fine, but the BoolScalar visit method doesn't work at runtime, assumedly since the nanobind templating expects that a member function implicitly accepts a self argument as in Python:

>>> from my_ext import BoolScalar, StringScalar, IntScalar
>>> StringScalar().visit()
'Hello, world'
>>> IntScalar().visit()
42
>>> BoolScalar().visit()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: visit(): incompatible function arguments. The following argument types are supported:
    1. visit(self, arg: my_ext.BoolScalar, /) -> Union[str, bool, int]

Invoked with types: my_ext.BoolScalar

Are there any suggested ways to approach this problem? While VisitorFunc works here I was hoping to stick with a class-based structure for the algorithms

[WillAyd]

I suppose another way of doing this that might be the best is to use templated functions:

template <typename T>
auto VisitFunc(const T& arg) -> ObjVar = delete;

template <>
auto VisitFunc(const BoolScalar& arg) const -> ObjVar {
  return true;
}

template <>
auto Visit(const StringScalar& arg) const -> ObjVar {
  return std::string{"Hello, world!"};
}

template <>
auto Visit(const IntScalar& arg) const -> ObjVar {
  return 42;
}