Почему ADL не находит шаблоны функций?

Эта часть объясняет это:

Стандарт C++ 03 14.8.1.6:

[Примечание. Для простых имен функций поиск, зависящий от аргумента (3.4.2), применяется, даже если имя функции не отображается в области вызова. Это связано с тем, что вызов по-прежнему имеет синтаксическую форму вызова функции (3.4.1). Но когда используется шаблон функции с явными аргументами шаблона, вызов не имеет правильной синтаксической формы, если в точке вызова не отображается шаблон функции с таким именем. Если такое имя не отображается, вызов синтаксически некорректен и поиск, зависящий от аргумента, не применяется. Если какое-то такое имя видимо, применяется поиск, зависящий от аргумента, и дополнительные шаблоны функций могут быть найдены в других пространствах имен.

namespace A {
  struct B { };
  template<int X> void f(B);
}
namespace C {
  template<class T> void f(T t);
}
void g(A::B b) {
  f<3>(b);    //ill-formed: not a function call
  A::f<3>(b); //well-formed
  C::f<3>(b); //ill-formed; argument dependent lookup
              // applies only to unqualified names
  using C::f;
  f<3>(b);    //well-formed because C::f is visible; then
              // A::f is found by argument dependent lookup
}

Начиная с С++ 20, adl также отлично работает с явным шаблоном функции. Вот предложение: P0846R0: ADL и шаблоны функций невидимые:

Вместо того, чтобы требовать от пользователя использовать ключевое слово шаблона, был предложен пересмотр правил поиска, чтобы имя, для которого обычный поиск либо не давал результата, либо находил одну или несколько функций, за которым следует символ «‹», рассматривалось как если бы имя шаблона функции было найдено и вызвало бы выполнение ADL.

В настоящее время эта функция реализована только в GCC 9, поэтому ваш пример может быть скомпилирован.

live demo.

Я хотел бы уточнить немного принятый ответ. В вопросе ОП неясно, но важная часть стандарта (цитируется Корнелем) такова (выделено мной):

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

поэтому запрещено полагаться на ADL и использовать явные аргументы шаблона. К сожалению, использование нетиповых аргументов шаблона требует использования явных аргументов (если они не имеют значений по умолчанию).

Ниже приведен пример кода, показывающий это.:

[live]

#include <string>
#include <utility>

namespace C {
  struct B { };
  template<class T> void f(T t){}
}

void g(C::B b) {
  f(b);           // OK
  //f<C::B>(b);   // ill-formed: not a function call, but only 
                  //  because explicit template argument were used

  std::string s;
  move(s);                      // OK
  //move<std::string&>(s);      // Error, again because 
                                //  explicit template argument were used
  std::move<std::string&>(s);   // Ok
}

int main()
{
 C::B b;
 g(b);
}

Редактировать: Нет, это неправильно. См. @Kornel answer.

Я не совсем уверен, но, ознакомившись с «Языком программирования C++» Страуструпа, я думаю, что причиной может быть раздел 13.8.4 Приложения C, может.

Поскольку frob является шаблоном, его можно было бы специализировать для i=0 в какой-то момент после его вызова. Это означает, что реализация останется с двумя возможными способами выбора, какой frob вызывать, как кажется, он может выбрать его в точке создания экземпляра или в конце обработки единицы перевода.

Итак, я думаю, проблема в том, что вы могли бы сделать

namespace ns {
    struct foo {};
    template<int i> void frob(foo const&) {}
}

int main() {
    ns::foo f;
    frob<0>(f);
    return 0;
}

namespace ns {
    template<> void frob< 0 >(foo const&) { /* Do something different*/ }
}