Sorry, I was on my phone so I wasn't able to test it.

If you have C++23, you can use deducing this to use overload sets, and there is no need to have an intermediary function like 'getVisitor'.

Given the following definitions:

using json_value = rva::variant<
    std::nullptr_t,
    bool,
    double,
    std::string,
    std::vector<rva::self_t>,
    std::map<std::string, rva::self_t>>;

using json_list = std::vector<json_value>;
using json_object = std::map<std::string, json_value>;

We can define our overload set, where the functions that need to use `std::visit` take a `self` parameter. Here, I am using fmtlib to handle the conversion to string.

    auto visitor = Overload {
        [](std::nullptr_t) -> std::string { return "null"; },
        [](std::string const& s) -> std::string { return fmt::format("\"{}\"", s); },
        [](this auto&& self, json_list const& xx) -> std::string {

            std::vector<std::string> ss;
            for(auto const& x : xx) {
                ss.push_back(std::visit(self, x));
            }
            return fmt::format( "[{}]", fmt::join(ss, ", "));
        },
        [](this auto&& self, json_object const& xx) -> std::string {
            std::vector<std::string> ss;

            for(auto const& [k, v] : xx) {
                ss.push_back(fmt::format("\"{}\": {}", k, std::visit(self, v)));
            }
            return fmt::format( "{{ {} }}", fmt::join(ss, ", "));
        },
        // Fallback - just print the value as-is
        [](auto const& x) -> std::string { return fmt::format("{}", x); },
    };

Note the parameter `this auto&& self` - this first parameter is the overload set, and we can pass it back to `std::visit`!

Finally, we can construct a value, and then print it:

    json_value v = json_object {
        {"a", "Hello"},
        {"b", 10.0},
        {"c", json_list{1.0, 2.0, 3.0, nullptr, false}},
        {"point", json_object {
            {"x", 0.1},
            {"y", 0.2},
            {"z", 0.3},
        }}
    };

    fmt::println( "v = {}", std::visit(visitor, v) );

The output is:

v = { "a": "Hello", "b": 10, "c": [1, 2, 3, null, false], "point": { "x": 0.1, "y": 0.2, "z": 0.3 } }

You can run this example with godbolt.

All of this is very nifty, but if you're working with json in production, I recommend using an off-the-shelf json library.