Концепция шаблона C ++, требующая определенного размера пакета параметров

Для этого вам не нужны концепции, просто используйте if constexpr:

T* f() {
    if constexpr (sizeof...(Args) != 0) {
        if (<some condition related to T...>)
            return new T;
        return f<Args...>();
    } else {
        return nullptr;
    }
}

Если вам действительно нужны разделенные функции, вы всегда можете использовать перегрузку:

template <typename T> // no pack
T* f() {
    return nullptr;
}

template <typename T, typename Arg1, typename... Args> // one of more Args
T* f() {
    if (<some condition related to T...>)
        return new T;
    return f<Arg1, Args...>();
}

Но, конечно, вы всегда можете использовать requires выражения, если действительно хотите сохранить ту же логику, что и в SFINAE. Это должно быть возможно (и достаточно) без объявленной концепции, но только с ограничением:

template <typename T, typename...> // pack logically always empty
T* f() {
    return nullptr;
}

template <typename T, typename... Args> requires (sizeof...(Args) > 0)
T* f() {
    if (<some condition related to T...>)
        return new T;
    return f<Args...>();
}

Конечно, вы также можете обернуть условие внутри концепции, но в этом случае вы получите очень мало при использовании этого метода, поскольку вам все равно придется использовать концепцию внутри предложения require:

template<typename... Args>
concept nonempty_pack = sizeof...(Args) > 0;

template <typename T, typename...> // pack logically always empty
T* f() {
    return nullptr;
}

template <typename T, typename... Args> requires nonempty_pack<Args...>
T* f() {
    if (<some condition related to T...>)
        return new T;
    return f<Args...>();
}

Синтаксис template<my_concept T> отправит T в качестве первого параметра. Вы всегда будете получать этот параметр snet автоматически, поэтому необходимо поместить концепцию в раздел requires.

Любой пакет параметров шаблона, который имеет допустимые экземпляры только для пакетов размера 0, делает вашу программу некорректной, и диагностику не требуется.

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

Из чернового варианта стандарта N3690 [temp.res] 14.6 / 8:

Если для каждой допустимой специализации вариативного шаблона требуется пустой пакет параметров шаблона, шаблон имеет неправильный формат, и диагностика не требуется.

(Я видел, что во многих версиях C ++ я просто использую случайный черновик стандарта, как он обнаружился, когда я гуглил стандартный PDF-файл C ++.)

Обратите внимание, что (а) ваши два f являются перегрузками, а не специализациями, и (б) то, что программисты C ++ подразумевают под допустимой специализацией шаблона и что стандартные средства, не совсем одно и то же.

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

Чтобы увидеть здесь проблему, мы перефразируем стандарт, используя отрицание:

Если (каждая допустимая специализация вариативного шаблона требует пустого пакета параметров шаблона), то (шаблон неверно сформирован, диагностика не требуется).

Мы можем преобразовать все это в существующее. Для всех X P (X) совпадает с Not (существует X, Not P (X)).

Если только (существует допустимая специализация вариативного шаблона с непустым пакетом параметров шаблона), то (шаблон плохо сформирован, диагностика не требуется).

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

В общем, такого рода правила существуют для того, чтобы компиляторы могли проверить, всегда ли ваш код будет бессмысленным. Такие вещи, как шаблоны, для которых никакой параметр типа не может привести к компиляции, или пакеты, которые должны быть пустыми, обычно являются признаком того, что в вашем коде есть ошибки. Сделав его некорректным и не требующим диагностики, компиляторы могут выдавать диагностику и не компилировать.

Проблема со стандартом заключается в том, что ему не просто разрешено не скомпилировать, но разрешено скомпилировать программу, которая делает буквально все, что угодно.

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

Обходной путь:

namespace implementation_details {
  struct never_use_me;
}
template <class=implementation_details::never_use_me>
std::nullptr_t f() { return nullptr; }

template <typename T, typename... Args>
T* f() {
  if (<some condition related to T...>)
    return new T;
  return f<Args...>();
}

другой вариант:

template <typename T, typename... Args>
T* f() {
  if (<some condition related to T...>)
    return new T;
  if constexpr (sizeof...(Args)==0)
    return nullptr;
  else
    return f<Args...>();
}