using TypeId = int * ;

template <class T>
struct TypeIdNode
 {
  static int Anchor; 
 };

template <class T>
int TypeIdNode<T>::Anchor;

template <class T>
inline constexpr TypeId TypeIdOf = &TypeIdNode<T>::Anchor ; 

/* main() */

template <int &ref> struct Spec {} ;

int main()
 {
  constexpr TypeId a=TypeIdOf<int>; 
  constexpr TypeId b=TypeIdOf<long>; 

  Spec<*a> va;
  Spec<*b> vb;

  //static_assert( a!=b ); 

  return 0;
 }

R>>template <typename> struct TypeID;

R>>template<> struct TypeID<int> : std::integral_constant<int, 1> { };
R>>template<> struct TypeID<std::string> : std::integral_constant<int, 2> { };
R>>template<> struct TypeID<MyType1> : std::integral_constant<int, 3> { };
R>>template<> struct TypeID<MyType2> : std::integral_constant<int, 4> { };

R>>template <typename T>
R>>struct TypeID<MyType3<T>> : std::integral_constant<int, 420000 + TypeID<T>::value> {};
R>>

template <typename...T>
struct TypeID<MyType3<T...>> : std::integral_constant<int, 420000 + ... + TypeID<T>::value> {};

// Реализацию функции join берем отсюда(спасибо автору Klemens Morgenstern): https://gist.github.com/klemens-morgenstern/b75599292667a4f53007
template<typename T, std::size_t L, std::size_t R>
constexpr std::array<T, L+R> join(std::array<T, L> rhs, std::array<T, R> lhs) {...};

struct IntCodec
{
    static constexpr auto Id() { return array<int8_t,1>{1}; }
    // ...
};

struct CharCodec
{
    static constexpr auto Id() { return array<int8_t,1>{2}; }
    // ...
};

template<typename T>
struct VectorCodec
{
    static constexpr auto Id() 
    { 
        return join(array<int8_t,1>{3}, T::Id());  
    }
    // ...
};

int main()
{
    constexpr auto id1 = IntCodec::Id();  // 1
    constexpr auto id1 = VectorCodec<CharCodec>::Id(); // 3,2
    constexpr auto id2 = VectorCodec<VectorCodec<IntCodec>>::Id(); // 3,3,1
    return 0;
}

template <typename... Types>
constexpr auto MakeTypeId(Types&&... t)
{
    return std::array<int8_t, sizeof...(Types)>{ std::forward<Types>(t)... };
}

template<typename... TArrs>
constexpr auto join(const TArrs&... arrs)
{
    std::size_t i = 0;
    std::array<int8_t, (arrs.size() + ...)> ret{};
    ([&](const auto& arr)
     {
        for (const int8_t& val : arr)
            ret[i++] = val;
     }(arrs), ...);
    return ret;
}

template <typename> struct TypeID;

template<> struct TypeID<int> : std::integral_constant<int, 1> { };
template<> struct TypeID<std::string> : std::integral_constant<int, 2> { };
template<> struct TypeID<MyType1> : std::integral_constant<int, 3> { };
template<> struct TypeID<MyType2> : std::integral_constant<int, 4> { };

template <typename T>
struct TypeID<MyType3<T>> : std::integral_constant<int, 420000 + TypeID<T>::value> {};

using MyAlias = MyType;

// ---Модуль main---
/* Создание делегата с двумя параметрами, для кодирования которых используются void IntCodec::Encode(std::byte *buffer, int Value) и void StringCodec::Encode(std::byte *buffer, string Value) */
MyDelegate<IntCodec, StringCodec> d; 

/* Делегат может быть связан с вызываемыми сущностями, которые предварительно должны быть зарегистрированы */
// Создание вызываемых сущностей
Callee f1 = LocalFunction<IntCodec, StringCodec>(func); // func - локальная функция с сигнатурой func(int, char)
Callee f2 = GetFromDll("libname", index); // index - номер функции, которая зарегистрирвоана в dll
Callee f3 = GetRemoteFunction("url", index); // index - номер функции, которая зарегистрирвоана на удаленном узле

d.Bind(f1); // связывание с локальной функцией
d(1, "direct call == std::funcion()"); // вызов
d.Bind(f2); // связывание с функцией из DLL
d(2, "Call with encoding/decoding"); // вызов
d.Bind(f3); // связывание с удаленной функцией
d(3, "Remote call with encoding/decoding"); // вызов

// ---Модуль DLL---
int index = RegisterFunction<IntCodec, StringCodec>(func); // func - внутренняя функция dll

// ---Remote module---
int index = RegisterFunction<IntCodec, StringCodec>(func); // func - внутренняя функция dll