UFCS functions with both pointers and refs

[Dave P.]

On Tuesday, 15 December 2020 at 19:45:50 UTC, Q. Schroll wrote:
> On Sunday, 13 December 2020 at 19:02:34 UTC, Dave P. wrote:
>> On Sunday, 13 December 2020 at 18:44:20 UTC, Mike Parker wrote:
>>> On Sunday, 13 December 2020 at 18:31:54 UTC, Dave P. wrote:
>>>> Do I have to write both and have one forward to the other 
>>>> for more
>>>> complicated functions?
>>>
>>> For free functions, yes.
>>
>> Is there any way to write the function as a template that is 
>> generic over a parameter being a pointer or a reference, but 
>> does not allow passing a copy?
>
> I'm not sure what you mean by a reference. D doesn't have 
> references in general, only class references that are just 
> glorified pointers. There are also `ref` parameters, but those 
> aren't generally referred to as "references" and are inside the 
> function almost indiscernible from non-ref parameters. So, I'll 
> ignore that.
>
> Copying only takes place under one circumstance: When an lvalue 
> is passed to a function that does not take that argument by 
> `ref`. So one possibility is to just define that overload and 
> @disable it. You don't even need a template for this:
>
>     void f(    X x); // matches lvalues and rvalues
>     void f(ref X x); // matches lvalues only
>
> The latter is a better match than the former for lvalues. 
> @disable'ing it will do the job. On the other hand, not 
> @disable'ing it will make `f` work with any argument by moving 
> rvalues to the former overload and referencing lvalues using 
> the second one.
>
> On templates, those can be unified by slapping `auto ref` 
> before the parameter. You can also use `auto ref` (which infers 
> `ref` from the passed argument) and check it with an `if` 
> template constraint:
>
>     void f(T)(auto ref T arg)
>         if (!__tratis(isRef, arg)) // only accepts non-ref args
>     { /* your code here */ }
>
> The constraint can easily be flipped.

The use case would be to define extension methods on a struct 
outside of where the struct is defined. The extension method 
mutates the state of the struct, so I want to ensure I am 
modifying the original struct and not a copy. If it’s a method 
and I call it on a pointer to the struct, the pointer will get 
auto-dereferenced and everything is great. So my question is that 
if I want an extension method as a free function, do I have to 
write both the version whose first argument is a pointer to the 
struct and the version whose first argument is a ref, or is there 
some keyword or other technique so that the pointer gets 
auto-dereferenced the same way as if it were a method. It sounds 
like the answer is no and I have to write a version that just 
dereferences the pointer and calls the ref version.

Thanks for the explanation though!