重载模板函数的声明顺序

我有一些代码，读起来像这样:

#include <map>
#include <string>
#include <functional>
using std::map;
using std::string;
using std::function;
using std::forward;
template<typename ToType, typename... FromTypes>
ToType construct(FromTypes&&... fromTypes) {
  return ToType(forward<FromTypes>(fromTypes)...);
}
class Variant {
public:
  map<string, Variant> toMap() const;
};
map<string, Variant> Variant::toMap() const {
  return {
      {"test", {}},
      {"test1", {}},
    };
}
// #1
template <typename MapType>
MapType variantToMap(Variant const& v) {
  // I expect an error on the following line because it's referencing the function labeled #4 which has not been declared yet.
  return variantToMap<MapType>(v, construct<typename MapType::key_type, string>, construct<typename MapType::mapped_type, Variant>);
}
// #2
template <typename MapType>
MapType variantToMap(Variant const& v, function<typename MapType::key_type(string)> const& keyConvert) {
  // I expect an error on the following line because it's referencing the function labeled #4 which has not been declared yet.
  return variantToMap<MapType>(v, keyConvert, construct<typename MapType::mapped_type, Variant>);
}
// #3
template <typename MapType>
MapType variantToMap(Variant const& v, function<typename MapType::mapped_type(Variant)> const& valueConvert) {
  // I expect an error on the following line because it's referencing the function labeled #4 which has not been declared yet.
  return variantToMap<MapType>(v, construct<typename MapType::key_type, string>, valueConvert);
}
// #4
template <typename MapType>
MapType variantToMap(Variant const& v, function<typename MapType::key_type(string)> const& keyConvert, function<typename MapType::mapped_type(Variant)> const& valueConvert) {
  MapType res;
  for (auto pair : v.toMap()) {
    res[keyConvert(pair.first)] = valueConvert(pair.second);
  }
  return res;
}
int main() {
  Variant a;
  // #1
  variantToMap<map<string, Variant>>(a);
  // #2
  {
    int counter = 0;
    variantToMap<map<int, Variant>>(a, [&counter](string) -> int { return ++counter; });
  }
  // #3
  variantToMap<map<string, int>>(a, [](Variant) -> int { return 42; });
  // #4
  {
    int counter = 0;
    variantToMap<map<int, int>>(a, [&counter](string) -> int { return ++counter; }, [](Variant) -> int { return 42; });
  }
  return 0;
}

编译和工作正常。

然而，因为它被声明为无序的，我希望它会抛出错误。我认为原因是这些函数都是模板化的。然而，这对我来说仍然有点困惑，因为(例如)在varianttomap# 1中对varianttomap# 4的调用有3个参数，这意味着

是Clang和GCC不适当地接受这些函数，还是这是允许的?如果允许，理由是什么?

应该注意的是，我已经重新排序了这些函数，我只是好奇为什么它在第一个地方工作。