Thread overview | |||||||
---|---|---|---|---|---|---|---|
|
January 21, 2013 [Issue 9365] New: Allow partially specified template aliases | ||||
---|---|---|---|---|
| ||||
http://d.puremagic.com/issues/show_bug.cgi?id=9365 Summary: Allow partially specified template aliases Product: D Version: D2 Platform: All OS/Version: All Status: NEW Severity: enhancement Priority: P2 Component: DMD AssignedTo: nobody@puremagic.com ReportedBy: peter.alexander.au@gmail.com --- Comment #0 from Peter Alexander <peter.alexander.au@gmail.com> 2013-01-21 12:50:45 PST --- It would be helpful if it were possible to alias partially specified templates. An example: void foo(A, B)() {} alias foo!int fooInt; Currently this fails with "Error: template instance foo!(int) foo!(int) does not match template declaration foo(A, B)()". However, if you write foo as: template foo(A) { void foo(B)() {} } Then it works. This would be useful because it would allow you to write things like: alias equalRoR = equal!equal; instead of having to write: alias equalRoR = binaryFun!((a, b) => equal!equal(a, b)); -- Configure issuemail: http://d.puremagic.com/issues/userprefs.cgi?tab=email ------- You are receiving this mail because: ------- |
January 21, 2013 [Issue 9365] Allow partially specified template aliases | ||||
---|---|---|---|---|
| ||||
Posted in reply to Peter Alexander | http://d.puremagic.com/issues/show_bug.cgi?id=9365 Andrej Mitrovic <andrej.mitrovich@gmail.com> changed: What |Removed |Added ---------------------------------------------------------------------------- CC| |andrej.mitrovich@gmail.com --- Comment #1 from Andrej Mitrovic <andrej.mitrovich@gmail.com> 2013-01-21 13:15:33 PST --- This can be implemented in the library, the last thing you want is for templates being partially instantiated when you pass too few arguments instead of getting an error. -- Configure issuemail: http://d.puremagic.com/issues/userprefs.cgi?tab=email ------- You are receiving this mail because: ------- |
January 21, 2013 [Issue 9365] Allow partially specified template aliases | ||||
---|---|---|---|---|
| ||||
Posted in reply to Peter Alexander | http://d.puremagic.com/issues/show_bug.cgi?id=9365 --- Comment #2 from Peter Alexander <peter.alexander.au@gmail.com> 2013-01-21 15:11:58 PST --- (In reply to comment #1) > This can be implemented in the library, the last thing you want is for templates being partially instantiated when you pass too few arguments instead of getting an error. There will be no partial instantiation (what it that anyway?) What I'm asking for is a rewrite from: alias A = B!(x, y); to alias A = ((args...) => B!(x, y)(args)); // if this was valid syntax when B has more than 2 non-default template parameters. The rest are determined using type deduction when A is invoked. This is frustrating: void foo(A, B)(A a, B b) {} foo(1, 2); // OK foo!(int)(1, 2); // OK foo!(int, int)(1, 2); // OK alias X = foo; // OK alias Y = foo!(int); // ERROR alias Z = foo!(int, int); // OK -- Configure issuemail: http://d.puremagic.com/issues/userprefs.cgi?tab=email ------- You are receiving this mail because: ------- |
January 22, 2013 [Issue 9365] Allow partially specified template aliases | ||||
---|---|---|---|---|
| ||||
Posted in reply to Peter Alexander | http://d.puremagic.com/issues/show_bug.cgi?id=9365 yebblies <yebblies@gmail.com> changed: What |Removed |Added ---------------------------------------------------------------------------- CC| |yebblies@gmail.com --- Comment #3 from yebblies <yebblies@gmail.com> 2013-01-22 15:19:02 EST --- Something like alias A(T) = B!(x, T); Is more likely and more flexible. Expanding to: template A(T) { alias A B!(x, T) } -- Configure issuemail: http://d.puremagic.com/issues/userprefs.cgi?tab=email ------- You are receiving this mail because: ------- |
June 10, 2013 [Issue 9365] Allow partially specified template aliases | ||||
---|---|---|---|---|
| ||||
Posted in reply to Peter Alexander | http://d.puremagic.com/issues/show_bug.cgi?id=9365 --- Comment #4 from Peter Alexander <peter.alexander.au@gmail.com> 2013-06-09 23:35:09 PDT --- (In reply to comment #3) > Something like > > alias A(T) = B!(x, T); > > Is more likely and more flexible. See my use case, with your suggestions, this wouldn't work: alias equalRoR = equal!equal; An alternative suggestion, is to change how function templates are expanded. Currently we have: void foo(A, B)(A a, B b) expanding to template foo(A, B) { void foo(A a, B b); } If instead, it expanded to: template foo(A) { template foo(B) { void foo(A a, B b); } } Then foo!int becomes a valid, alias-able symbol, which would solve the problem as well. -- Configure issuemail: http://d.puremagic.com/issues/userprefs.cgi?tab=email ------- You are receiving this mail because: ------- |
Copyright © 1999-2021 by the D Language Foundation