Is it possible to use std::visit on variant that hold same type more than once?

Question

For example, I'm trying to implement an AST using std::variant, where a Token can be a number, keyword, or variable. Where numbers are represented by the int and keywords and variables are represented by std::string:

enum TokenType : std::size_t {
    Number = 0, Keyword = 1, Variable = 2,
};
using Token = std::variant<int, std::string, std::string>;
Token token(std::in_place_index<TokenType::Variable>, "x");

When I want to do something with token, I can first determine its type with token.index() and then decide what to do:

switch (token.index()) {
case TokenType::Number:
    return do_sth_with_number(std::get<TokenType::Number>(token));
case TokenType::Keyword:
    return do_sth_with_keyword(std::get<TokenType::Keyword>(token));
case TokenType::Variable:
    return do_sth_with_variable(std::get<TokenType::Variable>(token));
}

However, I don't know if I can use std::visit to achieve the same effect. I only know that it can call specific function depending on the type of data in the variant, but I don't know if it is possible to do this depending on the index.

I know I can accomplish my goal by wrapping Keyword and Variable in two different classes, but I'm wondering if there's a better way to do it, because as I understand it, in variant, it should be more straightforward to decide which function to use based on the index rather than the type.

Answer 1

It is possible to dispatch different functions based on the variant's index rather than the alternative type.

You can make the visitor accept an additional index constant to capture the index information of the current alternative, and then create a function table based on the size of the variant to forward different index constants and corresponding alternatives to the visitor

template<class Visitor, class Variant>
constexpr decltype(auto)
visit_i(Visitor&& vis, Variant&& var) {
  constexpr auto N = std::variant_size_v<std::remove_cvref_t<Variant>>;
  constexpr auto func_ptrs = []<std::size_t... Is>(std::index_sequence<Is...>) {
    return std::array{
      +[](Visitor& vis, Variant& var) -> decltype(auto) {
        return std::invoke(std::forward<Visitor>(vis), 
                           std::integral_constant<std::size_t, Is>{}, 
                           std::get<Is>(std::forward<Variant>(var)));
      }...
    };
  }(std::make_index_sequence<N>{});
  return func_ptrs[var.index()](vis, var);
}

Then you can visit the variant with a custom visitor that accepts an index constant

enum TokenType : std::size_t {
  Number = 0, Keyword = 1, Variable = 2,
};

using Token = std::variant<int, std::string, std::string>;

void do_sth_with_number(int);
void do_sth_with_keyword(std::string);
void do_sth_with_variable(std::string);

auto visitor = [](auto index, auto&& token) {
  if constexpr (index == TokenType::Number)
    return do_sth_with_number(token);
  else if constexpr (index == TokenType::Keyword)
    return do_sth_with_keyword(token);
  else if constexpr (index == TokenType::Variable)
    return do_sth_with_variable(token);
};

int main() {
  Token token(std::in_place_index<TokenType::Variable>, "x");
  visit_i(visitor, token);
}

Demo

Answer 2

IMO there is no need to make things over-complicated:

void foo(const MyVariant& v)
{
    auto index = v.index();
    std::visit([index](const auto& x) {
        std::cout << "Index: " << index << " value: " << x << '\n';
    }, v);
}

https://godbolt.org/z/EfET9s97c

but IMHO comment under question from ComicSansMS is best solution.