Why code failed to compile for foo2?

[Tejas]

On Tuesday, 14 December 2021 at 13:25:04 UTC, apz28 wrote:
> On Tuesday, 14 December 2021 at 05:04:46 UTC, 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`?
>
> 1. A template function should behave as to replace 4 overload 
> functions
> There is special logic for parameter type (2 vs 4...)
>
> 2. Your implementation does not remove 'const' as below
> import std.traits : Unconst;
> import std.stdio : writeln;
>
>     void foo2(T)(T x) if(is(Unconst!(T) : ulong)) {//You don't 
> need Unqual for this
>         pragma(msg, T.stringof);
>         writeln(x);
>     }
>
>     void main()
>     {
>         import std.math;
>
>         const int s1 = -3;
>         int s2 = -2;
>         foo2(abs(s1));
>         foo2(abs(s2));
>
>         enum byte b1 = 0;
>         const byte b2;
>         byte b3;
>         foo2(b1);
>         foo2(b2);
>         foo2(b3);
>     }
>     --Output
>     const(int)
>     int
>     byte
>     const(byte)
>     3
>     2
>     0
>     0
>     0

Then I suggest using `inout`, if you're trying to reduce number 
of template instantiations

```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);
	writeln(x);
}

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);
	
}

Output(Compile-time):
int
byte
long

Output(Runtime):
3
2
24342

0
0
0

4554
12313
3242343
```