I agree it's not separable if we don't require new syntax for it. I'm saying I don't want the UFCS functionality without new syntax, which makes it separable, since we won't be redefining what current syntax means later. That's what I meant. Apologies for not making myself clear.

I agree (and have always) agreed with your entire email.


On Tue, Jul 21, 2020 at 12:02 AM Arthur O'Dwyer <> wrote:
On Mon, Jul 20, 2020 at 6:08 PM Gašper Ažman via Std-Proposals <> wrote:
> On Mon, Jul 20, 2020, 21:53 Marcin Jaczewski via Std-Proposals <> wrote:
>> pon., 20 lip 2020 o 22:42 Barry Revzin <> napisał(a):
>>> If by "both call conventions", you mean to also Y::g(Y{}, 1, 2), then yes
>>> that already is valid as stated in the paper (because they're like static member functions)
>>> in the same way that Y{}.g(1, 2) is valid (because they're like non-static member functions).
>>> If what you mean is to allow g(Y{}, 1, 2), then... no.
>> That was my point, allow `g(Y{}, 3, 2)`, because what difference is to
>> the definition of `friend int g(Y const&, int, int);`?
>> Of course paper do not suggest this, but for me this is a logical
>> conclusion. As this is op-in we do not have problems like other
>> solutions had for that functionality.
> That is separable functionality that we will revisit in a future paper with explicit syntax to enable it.

Gašper: That's not separable functionality; it's absolutely integral to the proposal, in the sense that it cannot be added later.
I think Barry is right that WG21 shouldn't want to add it later, but anyway, if they ship the ability to say Y::g(x, y), they can't later go back and add the ability to also say `g(x, y)` unqualified.

Under the current proposal (AIUI, which is to say, not well),

namespace N {
    struct S {
        void swap(S& this lhs, S& rhs);
S a, b;
a.swap(b);  // OK
S::swap(a, b);  // OK
N::swap(a, b);  // Won't compile
swap(a, b);  // Won't compile
std::ranges::swap(a, b);  // Will compile and call std::swap(a, b)

Under the proposal "plus ADL" as Marcin was talking about (AIUI),

a.swap(b);  // OK
S::swap(a, b);  // OK but maybe not preferred?
N::swap(a, b);  // Won't compile
swap(a, b);  // OK
std::ranges::swap(a, b);  // Will compile and call S::swap(a, b)

Whenever you add a thing, you have to get it right on the first try, or else design it very carefully for extensibility.
The default is never "oh, we can just add that wrinkle later."

my $.02,