Возврат необязательного параметра из шаблонной функции преобразования

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

template<typename In, typename Out>
bool Convert(const In& p_in, Out& p_out);

// Returns `true` if the conversion succeeded, `false` otherwise.

чтобы вместо этого я мог использовать std::optional. Что-то вроде (параметры шаблона уведомления были переключены):

template<typename Out, typename In>
std::optional<Out> Convert(const In& p_in);

Что касается шаблонов, произошли большие изменения: один из типов шаблонов теперь используется в возвращаемом типе Convert. Из-за этого компиляция завершается неудачно, если я не укажу параметры функции. Пример:

#include <optional>

class A
{
public:
    A() = default;

    A(int p_value)
    : m_value(p_value)
    {}

private:
    int m_value = 0;
};

template<typename In, typename Out>
bool Convert(const In& p_in, Out& p_out)
{
    return false;
}

template<>
bool Convert(const int& p_in, A& p_out)
{
    p_out = A(p_in);
    return true;
}

template<typename Out, typename In>
std::optional<Out> Convert2(const In& p_in)
{
    return std::nullopt;
}

template<>
std::optional<A> Convert2(const int& p_in)
{
    return A(p_in);
}

int main()
{
    const int in = 2;

    // Fine, but not ideal since we have `std::optional` available:
    A out;
    const bool result1 = Convert(in, out);

    // Failed:
    //const std::optional<A> result2 = Convert2(in);

    // Ok, but sadly A is repeated at called site:
    const std::optional<A> result3 = Convert2<A>(in);

    return 0;
}

Вот сообщение об ошибке (gcc), если я раскомментирую второй вызов:

<source>: In function 'int main()':
<source>:62:46: error: no matching function for call to 'Convert2(const int&)'
   62 |     const std::optional<A> result2 = Convert2(in);
      |                                      ~~~~~~~~^~~~
<source>:30:20: note: candidate: 'template<class Out, class In> std::optional<_Tp> Convert2(const In&)'
   30 | std::optional<Out> Convert2(const In& p_in)
      |                    ^~~~~~~~
<source>:30:20: note:   template argument deduction/substitution failed:
<source>:62:46: note:   couldn't deduce template parameter 'Out'
   62 |     const std::optional<A> result2 = Convert2(in);
      |                                      ~~~~~~~~^~~~

Используя auto, мне удалось заставить это работать:

template<typename In>
auto Convert(const In& p_in)
{
    return std::nullopt;
}

template<>
auto Convert(const int& p_in)
{
    return std::make_optional<A>(p_in);
}

Преимущество этого заключается в том, что его можно использовать по своему усмотрению на месте вызова:

const std::optional<A> result4 = Convert3(in)

Но я чувствую, что сигнатура функции теперь гораздо менее информативна о том, что делает функция. Чтобы узнать, возвращается ли std::optional<A>, нужно прочитать реализацию.

Есть ли способ заставить это работать без необходимости указывать шаблонные типы на месте вызова?

template<typename Out, typename In>
std::optional<Out> Convert(const In& p_in)
{
    // ?
}

template<>
std::optional<A> Convert(const int& p_in)
{
    // ?
}

int main()
{
    const std::optional<A> result = Convert(in)

    return 0;
}

Источники о Godbolt: https://godbolt.org/z/bYjrcPsPx.