On Thu, Dec 24, 2020 at 12:48 AM Paco Arjonilla via Std-Proposals <
std-proposals_at_[hidden]> wrote:

> Hi all,
>
> I want to propose a variation to ADL that goes in the opposite direction.
> Instead of function lookup dependent on arguments, it would perform
> argument lookup dependant on the function. I will call it Function
> Dependent Lookup (FDL) from here on.
>

[Basically, make `A::f(x)` consider looking up `x` in associated namespaces
of `A::f`.]

Besides the general shootdown you've been getting in this thread (which is
certainly correct and reasonable, but maybe a little too
"nonconstructive-proof" or "economists' $20 bill joke" for your liking) —
here are some practical concerns you'd have to solve before you could turn
this into a proposal.

(1) You seem to be proposing that "FDL" should kick in whenever the
function name is found by qualified lookup, not when it's found by
unqualified lookup. And maybe only if all the arguments are of the form
`keyword=value`? What if those assignment expressions are parenthesized,
e.g. `A::f((x=1))`?

(2) Are you proposing that "FDL" would apply only to function calls, and
never when unqualified lookup finds a non-function? That is, what happens in
    namespace A { auto g = [](auto) {}; int x; }
    int main() { A::g(x=1); }

(3) What if unqualified lookup of `x` would have found a variable in the
local scope? What if it would have found a lambda capture? What if it would
have found a structured binding?
    namespace A { void f(int); int x; }
    int main() { int x = 1; A::f(x=2); }

(4) What if the function call is separated from the qualified lookup of
`A::f`, e.g. by parentheses? This disables ADL; should it disable your
"FDL"? (And if not: how are you going to *prevent* it from disabling FDL?)
    namespace A { void f(int); int x; }
    int main() { (A::f)(x=1); }

(5) Does your modified lookup apply only to "keywords" or also to the
right-hand "value" side of each assignment expression? Does it apply to
non-assignment expressions? Your example on Gitlab implies that the
modified lookup should apply to right-hand sides:
    namespace A {
        struct Flag {} loose, tight;
        struct Arg { Arg& operator=(std::initializer_list<Flag>); }
xy_views;
        void f(Arg);
    }
    int main() { A::f(xy_views={loose, tight}); }

So then what if I do something like this, Python-style?
    namespace A {
        struct Arg { Arg& operator=(int); } x;
        void f(Arg);
    }
    int main() {
        int x = 1;
        A::f(x=x); // calls Arg::operator=(const Arg&)??
    }

Basically, if you want to go this route, you have to specify your answers
to these problems. I predict that by the time you've specified those
answers, you'll have decided this proposal isn't worth pursuing after all,
because it's not going to provide any solution that's fit for your purpose.

–Arthur