using std::visit with specialization of a deleted function

I am trying to parse a string generically based on some prior knowledge.
str is passed to convert<T>() with overloads for the types I want to support, and try to use std::visit() to call the right overload:

#include <iostream>
#include <variant>
#include <vector>
#include <charconv>

template <class ...Request, class ...Types>
constexpr bool holdsAlternative(const std::variant<Types...>& v) noexcept
{
   return (std::holds_alternative<Request>(v) || ...);
}
template <typename T>
T convert(const std::string &str) = delete;

template <>
float convert<float>(const std::string &str)
{
    float result = 0;
    std::from_chars(str.data(), str.data() + str.size(), result);
    return result;
}
template <>
int32_t convert<int32_t >(const std::string &str)
{
    int32_t result = 0;
    std::from_chars(str.data(), str.data() + str.size(), result);
    return result;
}
using data_type = std::variant<int32_t, float, std::string>;
std::vector<data_type> Types {float{}, int32_t{}, std::string{}};
int main()
{
    std::string str{"123"};
    bool r = holdsAlternative<int32_t, float>(Types[1]);
    if (r)
    {
       std::visit([&](auto &t) { return convert<decltype(t)>(str); }, Types[1]);
    }
}

There are three issues with your code:

1. The visitor must be applicable to all possible variants, so deleting the non-specialized convert won't work. You can however have the non-specialized version throw a runtime exception.
2. The visitor passed to std::visit must have the same return type for all variants. If this is an issue for you depends on what you want to do. If you want to set the variant value by the output of convert, you are fine: The visitors could all return void.
3. You should pass std::decay_t<decltype(t)> as the template parameter in the visitor, because decltype(t) would otherwise be deduced as a reference, and you don't have specializations for e.g. float&.

Here is the fixed code: https://godbolt.org/z/abqv6xKde

#include <iostream>
#include <variant>
#include <vector>
#include <charconv>

template <class ...Request, class ...Types>
constexpr bool holdsAlternative(const std::variant<Types...>& v) noexcept
{
   return (std::holds_alternative<Request>(v) || ...);
}

template <typename T>
T convert(const std::string &str){
    throw std::logic_error("Conversion not supported\n");
};

template <>
float convert<float>(const std::string &str)
{
    std::cout << "float\n";
    float result = 0;
    std::from_chars(str.data(), str.data() + str.size(), result);
    return result;
}
template <>
int32_t convert<int32_t >(const std::string &str)
{
    std::cout << "int32_t\n";
    int32_t result = 0;
    std::from_chars(str.data(), str.data() + str.size(), result);
    return result;
}

using data_type = std::variant<int32_t, float, std::string>;

std::vector<data_type> Types {float{}, int32_t{}, std::string{}};

int main()
{
    std::string str{"123"};
    bool r = holdsAlternative<int32_t, float>(Types[1]);
    if (r)
    {
       std::visit([&](auto &t) { t = convert<std::decay_t<decltype(t)>>(str); }, Types[1]);
    }
}