struct a { std::string name{"a"};};
struct b { };
struct c { std::string name{"c"};};
struct d { };
using Variant = std::variant<a, b, c, d>;


template<typename T>
auto getName(const T& v) -> decltype(v.name) { return v.name; }  // можнос специализировать типы по наличию поля

inline std::string getName(const d& v) { return "type d"; }  // можнос специализировать конкретные типы

// Все варианты типов, что не подошли под спефиализации. Наименее приоритетный вариант.
inline std::string getName(...) { return ""; }

template<typename ...T>
std::string getName(const std::variant<T...>& v) // Работа с variant обязательно шаблонная. Иначе можно попасть в рекурсивный вызов для не специализированного класса.
{ 
    return std::visit( [](const auto& vi)->std::string { return getName(vi); }, v ); 
}

2) Type-based value accessor: If v holds the alternative T, returns a reference to the value stored in v. Otherwise, throws std::bad_variant_access. The call is ill-formed if T is not a unique element of Types....

M>int func(MyVariant v)
M>{
M>    auto kind = getKind(v);
M>    if (kind==Kind::A)
M>    {
M>        doSomething(get<Kind::A>(v));
M>        // doSomething(get(kind, v)); // или даже так
M>    }
M>    else if (kind==Kind::B || kind==Kind::C)
M>    {
M>        log << "Error: " << enum_serialize(kind) << " not allowed here\n";
M>        return -1; // error - B or C not allowed here
M>    }
M>    else
M>    {
M>        return 0; // OK
M>    }
M>}
M>

int func(MyVariant v)
{
    return std::visit([]<typename T>(const T& t) {
        if constexpr (std::same_as<T, A>)
        {
            doSomething(t);
        }
        else if constexpr (std::same_as<T, B> or std::same_as<T, C>)
        {
            std::cout << "Error: B or C not allowed here\n";
            return -1;
        }
        return 0; // OK
    }, v);
}

auto try_get_name(const auto& variant) {
  return std::visit(
    [](const auto& value) {
      if constexpr(requires{value.name}) {
        return value.name;
      } else {
        return std::string{};
      }
    },
    variant);
}

1) Index-based value accessor: If v.index() == I, returns a reference to the value stored in v. Otherwise, throws std::bad_variant_access. The call is ill-formed if I is not a valid index in the variant.

    std::visit([](auto&& t) {
        std::cout << "Тут лежит " << t << std::endl;
    }, v);

R>    std::visit([](auto&& t) {
R>        std::cout << "Тут лежит " << t << std::endl;
R>    }, v);
R>

int func(MyVariant v)
{
    auto kind = getKind(v);
    if (kind==Kind::A)
    {
        doSomething(get<Kind::A>(v));
        // doSomething(get(kind, v)); // или даже так
    }
    else if (kind==Kind::B || kind==Kind::C)
    {
        log << "Error: " << enum_serialize(kind) << " not allowed here\n";
        return -1; // error - B or C not allowed here
    }
    else
    {
        return 0; // OK
    }

    //...

}

M>int func(MyVariant v)
M>{
M>    auto kind = getKind(v);
M>    if (kind==Kind::A)
M>    {
M>        doSomething(get<Kind::A>(v));
M>        // doSomething(get(kind, v)); // или даже так
M>    }
M>    else if (kind==Kind::B || kind==Kind::C)
M>    {
M>        log << "Error: " << enum_serialize(kind) << " not allowed here\n";
M>        return -1; // error - B or C not allowed here
M>    }
M>    else
M>    {
M>        return 0; // OK
M>    }
M>}
M>

    std::visit([](auto&& t) {
        if constexpr(std::is_same_v(t, Kind::A)) 
        {
        }
        else if constexpr(std::is_same_v(t, Kind::B))
        {
        }
    }, v);

if (kind==Kind::B || kind==Kind::C)
{
}

L>    std::visit([](auto&& t) {
L>        if constexpr(std::is_same_v(t, Kind::A)) 
L>        {
L>        }
L>        else if constexpr(std::is_same_v(t, Kind::B))
L>        {
L>        }
L>    }, v);
L>

L>

auto kind = getKind(v);
name = getName(kind, v);

string getNameImpl(Kind kind, Variant v, initializer_list<Kind> hasNameList)
{
    for(auto k: hasNameList)
    {
        if (k==kind)
            return visit([](auto a) { return a.name; });
    }

    return string();
}

string getName(Kind kind, Variant v)
{
    return getNameImpl(kind, x, {Kind::A, Kind::B, ...});
}

void func(MyVariant v)
{
  return MyVisit(v,    
    [](const A& a) {
      doSomething(a);
      return 1;
    },
    [](const AnyTypeOfList<B, C> auto&) {
      log << "Error: B or C not allowed here not allowed here\n";
      return -1;
    },
    [](const auto&) {
      return 0; // OK
    }
  );
}

R>>void func(MyVariant v)
R>>{
R>>  return MyVisit(v,    
R>>    [](const A& a) {
R>>      doSomething(a);
R>>      return 1;
R>>    },
R>>    [](const AnyTypeOfList<B, C> auto&) {
R>>      log << "Error: B or C not allowed here not allowed here\n";
R>>      return -1;
R>>    },
R>>    [](const auto&) {
R>>      return 0; // OK
R>>    }
R>>  );
R>>}
R>>

decltype(auto) MyVisit(auto&& t, Callable auto&&...f)
{
   return std::visit(Overloaded(f...), v);
}

template<typename ... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<typename ... Ts> overloaded(Ts...) -> overloaded<Ts...>;

// use concept if liked
template <typename T> concept has_name = 
    requires(T a) {{a.name}->std::convertible_to<std::string>;};

// ...
if(k==kind)
  return std::visit(overloaded{
      [](auto && t) -> std::string requires requires {{t.name} -> std::convertible_to<std::string>;}  { return t.name; }
      , [](auto && t) -> std::string requires (not requires {{t.name} -> std::convertible_to<std::string>;}) { return {}; }
  }, v);

if constexpr(std::is_same_v(t, typeA) || std::is_same_v(t, typeB))
{
}

#include <string>
#include <variant>
#include <iostream>
#include <type_traits>

void has_name_aux(...);
template<typename T> auto has_name_aux(const T& t) -> decltype(t.name);
template<typename T> constexpr bool has_name_v =
    std::is_same_v<std::string, decltype(has_name_aux(std::declval<T>()))>;

template <typename...T>
std::string getName(const std::variant<T...>& v)
{
    return std::visit(
        []<typename X>(X&& x) -> std::string {
            if constexpr(has_name_v<X>)
                return x.name;
            else
                return {};
        }
        , v);
}

int main()
{
    struct a { std::string name{"a"};};
    struct b { };
    struct c { std::string name{"c"};};

    using Variant = std::variant<a, b, c, double>;

    auto test = [](const Variant& v) {
        auto const & name = getName(v);
        std::cout << (name.empty() ? "<<unnamed>>" : name) << '\n';
    };
    test(a{});
    test(b{});
    test(c{});
    test(3.14);
}

a
<<unnamed>>
c
<<unnamed>>