Как проверить, существует ли специализация шаблонной функции

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

template <typename...> struct always_false : std::false_type {};

template<typename T, typename U> double convert(double) {
  static_assert(always_false<T, U>::value, "No specialization exists!");
}

template <> double convert<Kilometer, Mile>(double val) { return val/1609.344; }
template <> double convert<Mile, Kilometer>(double val) { return 1609.344*val; }

Текущая демонстрация

Вы не должны обещать компилятору, что для каждой возможной комбинации SrcUnit/TgtUnit существует преобразование:

template <class SrcUnit, class TgtUnit>
double convert(double val);

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

template <class SrcUnit, class TgtUnit>
double convert(double val) = delete;

И для каждого преобразования, которое вы предоставляете, вы должны объявить это в своем заголовочном файле/файлах:

template <>
double convert<Mille,Km>(double val);
template <>
double convert<Milliseconds,Hours>(double val);

Таким образом, компилятору будет известно, что предусмотрено, а что нет.

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

Я бы подошел к этому с тегами.

template<class T>struct tag_t{constexpr tag_t(){}; using type=T;};
template<class T>constexpr tag_t<T> tag{};

это позволяет вам передавать типы как параметры функции.

Теперь вместо использования специализации и тому подобного мы просто вызываем функцию.

Мы будем использовать имя получше, чем convert, например unit_convert.

namespace my_ns {
  Declare_Unit(Mile, "mi", "English unit of length", Distance,
     0, numeric_limits<double>::max()); // macro instantiating a new Unit 
  inline double unit_convert( tag_t<Meter>, tag_t<Mile>, double val ) {
    return val/1609.344
  }
  inline double unit_convert( tag_t<Mile>, tag_t<Meter>, double val ) {
    return val*1609.344
  }
}

Затем мы пишем трейт, который говорит, существует ли unit_convert( tag<A>, tag<B>, double ):

namespace details {
  template<template<class...>class Z, class=void, class...Ts>
  struct can_apply:std::false_type{};
  template<template<class...>class Z,  class...Ts>
  struct can_apply<Z, std::void_t<Z<Ts...>>, Ts...>:std::true_type{};
}
template<template<class...>class Z, class...Ts>
using can_apply=details::can_apply<Z,void,Ts...>;

template<class...Args>
using convert_unit_result = decltype( convert_unit( std::declval<Args>()... ) );

template<class SourceUnit, class DestUnit>
using can_convert_units = can_apply< convert_unit_result, tag_t<SourceUnit>, tag_t<DestUnit>, double >;

и теперь can_convert_units<Mile,Meter> — это std::true_type, а can_conver_units<Chicken, Egg> — это std::false_type (при условии, что курица и яйцо — это типы, которые не являются конвертируемыми единицами, естественно).

В качестве бонуса этот метод позволяет вам размещать ваши единицы измерения в отдельных пространствах имен, а также определять их функции преобразования. Если и Mile, и Meter попытаются определить преобразование между собой, вы получите ошибки при попытке преобразования (неоднозначно). Функция преобразования может находиться в любом пространстве имен, но не в обоих.

Может быть, это может помочь.

template<typename Src, typename Tgt, typename Exists = void>
double convert (double val) {
    static_assert(not std::is_void<Exists>::value, " err msg");
}

template <> double convert<Kilometer, Mile>(double val) { return val/1609.344; }