Как преобразовать std::variant, применив указанную функцию

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

template<class Fn, class...Args>
using ret_t = decltype([] {
    if constexpr (std::is_invocable_v<Fn, Args...>) {
      using R = std::invoke_result_t<Fn, Args...>;
      if constexpr (std::is_void_v<R>)
        return std::type_identity<void_type>{};
      else
        return std::type_identity<R>{};
    } else
      return std::type_identity<wrong_arg_type>{};
  }())::type;

Я нашел решение проблемы std::conditional, изменив реализацию invoke_fn, поскольку оценивается только одна if constexpr ветвь, а ret_t является лишь decltype ее.

template<class Fn, class... Args>
constexpr auto invoke_fn(Fn fn, Args&&...args)
{
    if constexpr(not std::is_invocable_v<Fn, Args...>)
        return wrong_arg_type{};
    else if constexpr(std::is_void_v<std::invoke_result_t<Fn, Args...>>)
        return std::invoke(std::forward<Fn>(fn), std::forward<Args>(args)...), 
            void_type{};
    else
        return std::invoke(fn, std::forward<Args>(args)...);
}

template<class Fn, class... Args>
using ret_t = decltype(invoke_fn(std::declval<Fn>(), std::declval<Args>()...));

Вторая проблема связана с ошибочной реализацией рекурсивной лямбды в MSVC. Замена ее функцией шаблона решает эту проблему.

template<auto N, class Fn, class...T>
auto transform_helper(Fn fn, const std::variant<T...>& v)
->std::variant<ret_t<Fn, T>...>
{
    using variant_type = std::variant<ret_t<Fn, T>...>;

    if constexpr(N == sizeof...(T))
        { throw "transform error"; }
    else if (N == v.index())
        return variant_type(std::in_place_index<N>, invoke_fn(fn, std::get<N>(v)));
    else
        return transform_helper<N+1>(fn, v);
}

template<class Fn, class...T>
auto transform(Fn fn, const std::variant<T...>& v)
{
    return transform_helper<0>(fn, v);
}

Вот рабочая демо

Обычно я использую шаблоны ограничений C++20:

template<class Fn, class...Args>
struct ret_impl:
std::conditional
   < std::is_void_v<std::invoke_result_t<Fn, Args...>> 
   , void_type
   , std::invoke_result_t<Fn, Args...> > {};

template<class Fn, class...Args>
    requires not std::is_invocable_v<Fn, Args...> 
struct ret_impl:
std::type_identity<wrong_arg_type> {};

template<class Fn, class...Args>
using ret_t = typename ret_impl::type;

Это снимает необходимость иметь дело с несуществующими типами в случае, если ограничения не выполняются. Более простое решение — decltype. У вас уже есть invoke_fn:

template<typename...T>
requires sizeof...(T) > 0
using ret_t = decltype(invoke_fn(std::declval<T>()...));

Далее я заметил, что вы увернулись std::visit:

template<class Fn, class...T>
auto transform(Fn fn, const std::variant<T...>& v)
{
    using variant = std::variant<ret_t<Fn, T>...>;
    return std::visit
              ( [](auto&& a)
                  { return variant {invoke_fn(std::forward<Fn>(fn), a)}; }
              , v );
};

Это предполагаемый вариант использования std::variant. Использование метапрограммирования в таких случаях не считается хорошей практикой.