How to specify a template that uses unqualified type, like any normal function
Mengu via Digitalmars-d-learn
digitalmars-d-learn at puremagic.com
Mon Aug 14 08:10:48 PDT 2017
On Monday, 14 August 2017 at 13:48:36 UTC, Dominikus Dittes
Scherkl wrote:
> if I use fixed-type functions, I can do the following:
>
> uint foo(uint n)
> {
> ++n; // modify n - as this function has received a copy of
> n, this is always possible
> return 42;
> }
>
> uint bar(const uint n)
> {
> assert(foo(n)==42);
> return 17;
> }
>
> void main()
> {
> bar(3);
> }
>
>
> But if I try the same with a template parameter, it doesn't
> work:
>
> import std.traits; // Unqual
>
> uint foo(T)(Unqual!T n) // first try
> {
> ++n; // modify should be possible
> return 42;
> }
>
> uint foo2(T)(T n) // second try
> {
> ++n; // modify fails, as T is const
> return 42;
> }
>
> uint bar(T)(const T n)
> {
> assert(foo(n)==42u); // cannot deduce arguments - why?!?
> assert(foo2(n)==42u); // here it can deduce the arguments,
> but the function cannot modify n
> return 17;
> }
>
> void main()
> {
> bar(3);
> }
>
> Any ideas what I need to do to make this work?
hi dominikus
you can call functions as func(arg) when compiler can infer the
types for your functions but when it's not you'll get an "cannot
deduce arguments" error.
when you call bar template function, you won't be able to modify
the argument n. ++n will not work and will throw an error at
compile time.
import std.traits : Unqual;
import std.stdio : writeln;
uint normalFoo(int n) {
++n;
return n;
}
uint constNormalFoo(const int n) {
++n; // will raise error
return n;
}
uint templateFoo(T)(Unqual!T n) {
++n;
return n;
}
uint constTemplateFoo(T)(const Unqual!T n) {
++n; // will raise error
return n;
}
void main() {
writeln(normalFoo(42));
// writeln(constNormalFoo(42));
writeln(templateFoo!int(42));
// writeln(constTemplateFoo!int(42));
}
more info is available at:
More information about the Digitalmars-d-learn
mailing list