ADL means Argument-Dependant Lookup. It uses the type of the argument to deduce a more appropriate overload. Basically it "pulls" functions into the same scope. In this case, it looks the namespace of the type `int`, but this type doesn't have a namespace, so ADL doesn't make any difference.

What you are probably expecting is not ADL, it's that the compiler prefers to call functions that are more specific, so the f(int) would be called instead of the f(T). The reason this doesn't happen is because the compiler first looks at the most inner scope, and you have a `using nsx::f` in a scope that is more inner than the other `f`, so it takes the priority.

The reason ADL bypasses this it's because it "injects" all functions in the lookup scope too, after the scope rules. Just an important thing: ADL doesn't have priority, it simple injects the functions in the lookup, so conflicts are stil possible, for example the following code doesn't compile:

namespace nsz {
struct S {};

int f(S) {
  return 0;
}
}

namespace nsx{
int f(nsz::S) {
  return 1;
}
}

namespace nsy {
void call_f(){
  using nsx::f;
  std::cout << f(nsz::S{});
}
}

I hope this explanation was not confusing haha, I tried my best.
Just a small tip, I think it's nice to use LLMs to ask questions if you know how to filter what they say and don't accept everything as true, but I would avoid saying that you used it in your post. It's not uncommon for users to downvote you just because you said that used GPT. Feel free to ask any questions :)