Перегрузка функций с помощью фиктивных структур и специализация шаблонов

Я занимаюсь рефакторингом C++ и наткнулся на несколько фиктивных структур, используемых для различения перегруженных функций. Я подумываю заменить это специализацией шаблонов, но сначала хочу полностью понять последствия.

У нас есть класс перечисления, который часто используется для решения того, как обрабатывать какое-либо значение:

enum class OptionEnum : int {
    optionA,
    optionB
};

void foo( const int val, const OptionEnum option ){
    if ( option == OptionEnum::optionA ){
        doSomething( val );
    } else if ( option == OptionEnum::optionB ) {
        doSomethingElse( val );
    } else {
        throw std::invalid_argument( "Unsupported Option" );
    }

    doMoreStuff();
}

Однако, когда функция особенно сложна, текущий код использует перегрузку и некоторые фиктивные структуры для получения правильного разрешения перегрузки:

struct OptionsStruct{};
static constexpr struct OptionStructA : OptionsStruct{} optionA;
static constexpr struct OptionStructB : OptionsStruct{} optionB;

void foo( const int val, const OptionStructA & ){
    doSomething( val );
}

void foo( const int val, const OptionStructB & ){
    doSomethingElse( val );
}

Это часто делается с помощью некоторой промежуточной шаблонной функции, которой не важно, какая опция используется, но ей необходимо знать, какую перегрузку вызывать:

template < typename OptionStructAorB >
void bar( const int val, const OptionStructAorB option ){
    int result = processVal( val );
    foo( result, option );
}

void baz( const int val, const OptionEnum option ){
    if ( option == OptionEnum::optionA ){
        bar( val, optionA );
    } else if ( option == OptionEnum::optionB ) {
        bar( val, optionB );
    } else {
        throw std::invalid_argument( "Unsupported Option in baz" );
    }
}

int main(int argc, char* argv[]) {
    const int inputVal = std::atoi(argv[1]);
    const std::string optionString = argv[2];

    OptionEnum inputOption;
    if ( optionString == "a" ){
        inputOption = OptionEnum::optionA;
    } else if ( optionString == "b" ) {
        inputOption = OptionEnum::optionB;
    } else {
        std::cout << "Invalid option " << optionString << std::endl;
        return 1;
    }

    baz(inputVal, inputOption);

    return 0;
}

Я подумываю избавиться от фиктивных структур и перегруженных функций и заменить их специализацией шаблонов, например:

template< OptionEnum option >
void foo(const int val);

template<>
void foo< OptionEnum::optionA >(const int val){
    doSomething(val);
}

template<>
void foo< OptionEnum::optionB >(const int val){
    doSomethingElse(val);
}

template< OptionEnum option >
void bar(const int val){
    int result = processVal(val);
    foo<option>(result);
}

void baz( const int val, const OptionEnum option ){
    if ( option == OptionEnum::optionA ){
        bar<OptionEnum::optionA>( val );
    } else if ( option == OptionEnum::optionB ) {
        bar<OptionEnum::optionB>( val );
    } else {
        throw std::invalid_argument( "Unsupported Option in baz" );
    }
}

Помимо упрямых опасений по поводу стиля и читаемости, есть ли какие-либо конкретные преимущества у исходного подхода с фиктивными структурами по сравнению с подходом со специализацией шаблонов с точки зрения производительности, безопасности типов и удобства сопровождения (специфично для C++17)? Могут ли возникнуть проблемы с удобством обслуживания при добавлении нового значения перечисления, которое, например, хуже в новом подходе?

(Да, foo(), вероятно, вообще не следует перегружать, и нам следует использовать только fooA() и fooB(), но кодовая база — это максимум спагетти, и это компромисс)