Концептуальная сортировка в С++20

Ничто не мешает сделать шаблоны поверх JIT-компилируемого кода.

Более того, в языке они есть.

А вот взаимодействие можно было бы построить через рефлекшн (опционально сохранять метаинформацию о шаблонах и позволять им работать как дженерики в рантайме).

Нельзя так просто взять и сделать из произвольного шаблона дженерик.

Вот смотрите, я пишу:

struct IFoo {
    virtual void Foo() = 0;
};

template<typename A> void Bar(A &a) {
    static_assert(std::is_base_of<IFoo, A>::value, "A must implement IFoo" );
    return a.Baz();
}

И этот код компилируется без ошибок. Вот в этом "без ошибок" и проблема: в реализации серьезная ошибка, но компилятор ее не видит.

Юзер не может это знать, он видит сигнатуру.

Ну ок, допустим. Я не согласен, но допустим. Какая нам разница? Любой объект любого типа можно подставить вместо T? Можно. Что еще нужно?

Хорошо, конкретизирую: на этапе статического анализа.

Никакой статический анализ не скажет, что метода fooasgjknasgh1htg781gh73 не существует ни у одного объекта в проекте, и этот темплейт обречен провалиться.

template <typename T>
T add(T a, T b){
  return a.fooasgjknasgh1htg781gh73(b);
}

Ошибка возникнет в момент инстанцирования шаблона, и укажет именно на то требование к типу, которое не выполняется

Так в том-то и проблема, что все требования к типу выполняются, но ошибка компиляции все равно возникнет. Потому что ошибка — в самом шаблоне.

Спасибо за уточнение, про теминологию. Но в разрезе C++ это почти соответствует такому шаблонному коду:

template<typename T1, typename T2>
struct Cont
{
    T1* field1;
    T2* field2;
};

using BaseContainer = Cont<Base1, Base2>;
using DerivedContainer = Cont<Derived1, Derived2>;

И вроде они могли бы быть коварианты, но увы.

Можно даже было бы написать обощенный оператор приведения.

template<typename T1, typename T2>
struct Cont
{
    T1* field1;
    T2* field2;

    template<typename B1, typename B2,
        typename = enable_if_t<
            is_base_of<B1, T1>::value
            && is_base_of<B2, T2>::value>>
    operator Cont<B1, B2>()
    {
    Cont<B1, B2> c;
    c.field1 = field1;
    c.field2 = field2;
    return c;
    }
};

Но к сожалению наличие оператора приведения типа никак не поможет перегружать виртуальные метод с возвратом типа который отличается от того, который был указан при объявлении виртуального метода в базовом классе.

struct BaseStorage
{
    virtual BaseContainer foo() {
        /*...*/
    }
};

struct DerivedStorage: BaseStorage
{
    DerivedContainer foo() override { //Ошибка
        /*...*/
    }
};

Это потребует хранение дополнительной информации о необходимых трансформациях возвращаемого значения или генерации некоторой хитрой обертки над таким методом, но все это будет приводить к путанице при последующем наследовании и перегрузке.