Difference in supplying two variant objects separately vs in an array

I have two variant objects of the following type

struct FigureMove {};
struct PieceMove {};
using Move = std::variant<FigureMove, PieceMove>;

I want to supply two Move objects to a function and call different functions depending on the underlying types in the variants.
I have two different versions of the function which takes the Move objects. One taking them as separate function arguments and one taking both of them in an array.
Note, I plan on supplying always one FigureMove and one PieceMove, just their order is not clear beforehand.

bool areMovesValid(const FigureMove &figureMove0, const PieceMove &pieceMove1)
{
    return {};
}

bool areMovesValid(const PieceMove &pieceMove0, const FigureMove &figureMove1)
{
    return {};
}

//#define USE_ARRAY

#ifdef USE_ARRAY
bool areMovesValid(const std::array<Move, 2> &moves)
{
    const auto &variantMove0 = moves[0];
    const auto &variantMove1 = moves[1];

#else
bool areMovesValid(const Move &variantMove0, const Move &variantMove1)
{
#endif
    return std::visit(
        [variantMove1](const auto move0)
        {
            return std::visit(
                [move0](const auto move1)
                {
                    return areMovesValid(move0, move1);
                },
                variantMove1);
        },
        variantMove0);
}

The version taking the array throws tons of compile time errors. Using gcc or clang.

Why is that and how can I fix it?

Here is the code on godbolt.

return areMovesValid(move0, move1);

When not using an array parameter this results in infinite recursion for a combination of two values that are the same type, because overload resolution will pick the same areMovesValid.

When using an array parameter version: overload resolution fails, since these two parameters cannot be converted to a single std::array, and the remaining overloads don't match.

If you choose to name the third function, the one that takes a pair of Moves as something other than areMovesValid, neither version will compile.

> I plan on supplying always one FigureMove and one PieceMove

That's nice, but your C++ compiler is not taking your word for it. The combination of the two std::visit calls will also generate the code paths where both parameters are both FigureMoves and PieceMoves. And that has to compile, somehow.

Following the explanation by @SamVarshavchik and input by @chris I came up with this solution:

// additional headers
#include <stdexcept>
#include <type_traits>

// previous code

// changes made to dispatching function
bool areMovesValid(const std::array<Move, 2> &moves)
{
    return std::visit(
        []<typename Move0, typename Move1>(Move0 move0, Move1 move1) -> bool
        {
            if constexpr (std::is_same_v<Move0, Move1>)
                throw std::invalid_argument("unsupported arguments!");
            else
                return areMovesValid(move0, move1);
        },
        moves[0], moves[1]);
}

The change is that for same underlying types in the Move variant we throw an exception.
Furthermore, we dispatch via a single std::visit.