Why code failed to compile for foo2?

[Tejas]

On Tuesday, 14 December 2021 at 15:14:40 UTC, Steven 
Schveighoffer wrote:
> On 12/14/21 12:04 AM, Tejas wrote:
>> Is there anything wrong with the answer I posted?
>> 
>> Can you please tell me if there's anything dissatisfactory 
>> about it? I feel like it does everything the OP wants.
>> 
>> Also, am I wrong in using `Unconst` over `Unqual`? Isn't 
>> `Unqual` overkill if you just want to cast away `const`?
>
> Unqual is fine for value types, it should work in all cases.
>
> The OP's problem is that it's entirely possible to build an 
> overload set with *just* the unqualified types specified (in 
> this case, an integral type), but there's not a way to express 
> that and still have it work with IFTI.
>
> In other words, if you have a call like:
>
> ```d
> const int x;
> foo2(x);
> ```
>
> You want to have the parameter be mutable inside foo2. There 
> currently isn't a way to express that if `foo2` is an IFTI 
> template. The opposite is actually easily expressable:
>
> ```d
> void foo2(T)(const(T) val)
> {
>    // only one instantiation of foo2 per const(int), 
> immutable(int), int,
>    // and now val is const, even if the argument is not
> }
> ```
>
> With a standard function it works just fine due to implicit 
> conversion, but with IFTI, there's no way to express it because 
> it goes through an alias. The closest you can come is to write 
> a wrapper shim that calls the right instantiation. This should 
> be OK as long as inlining is happening, but it seems like extra 
> work for the optimizer, when it should be easy to express in 
> the language somehow.
>
> BTW, there is a related issue: 
> https://issues.dlang.org/show_bug.cgi?id=1807
>
> -Steve

Yeah, now I understand he's trying to reduce number of 
instantiations.

In that case, I'd use `inout`, but it'd be the same as your case 
: can't modify the argument anymore.

But we can pass that to another function that accepts `ulong` (as 
that seems to be the OP's usecase anyways), which can then modify 
it :D

```d
import std.traits : Unconst;
import std.stdio : writeln;

void foo2(T)(inout(T) x) if(is(Unconst!(T) : ulong)) {//You don't 
need Unqual for this
	pragma(msg, T.stringof);
	foo3(x);
}

void foo3(ulong param){
	writeln(param, " before");
	param +=10;	
	writeln(param, " after"); // can also modify params now
}
void main(){
	import std.math;
	const int ci = -3;
	int i = -2;
	immutable int ii = 24342;
	foo2(abs(ci));
	foo2(abs(i));
	foo2(ii);
	
	byte b = 0;
	const byte cb;
	immutable byte ib;
	foo2(b);
	foo2(cb);
	foo2(ib);
	
	const long cl = 4554;
	long l = 12313;
	immutable long il = 3242343;
	foo2(cl);
	foo2(l);
	foo2(il);
	
}
```