On Sunday, 4 January 2015 at 01:34:51 UTC, Manu via Digitalmars-d
wrote:
I kinda feel something like this ought to work, but I can kinda
see
why it doesn't...
void foo(T = Unqual!U, U)(T a, T b);
Thing is, it perceives that 'T' as typed by the argument
received *is*
T, but it's not; T is already assigned a type. It would need to
see
that T is a function of U which is unknown (available to be
inferred),
and to forward the incoming type to U, such that T's function
can be
applied to it.
...yeah, it would need to transfer the type received to U,
because T's
type is already assigned as an explicit function of unknown U.
I'm not sure if that made sense, but I can visualise the
process. I'm
sure it *could* work, but would it be sturdy?
I've run into this many times in the past too... never really
thought
on it whether it's a problem that could actually be solved.
This works for mutable, const, and immutable scalar types.
import std.traits;
U fun(T: const(U), U)(T val)
if (isScalarType!T)
{
return val;
}
void main()
{
const int n = 10;
static assert(is(typeof(n.fun) == int));
int m = 10;
static assert(is(typeof(m.fun) == int));
immutable int x = 10;
static assert(is(typeof(x.fun) == int));
}
