On Wed, Sep 23, 2009 at 9:55 AM, Justin Johansson
<[email protected]> wrote:
> D1.0
>
> If you have a function template of one type parameter, T, that takes a class
> template of the same type parameter, T, as an argument, then typical template
> usage scenario goes like this:
>
> /* Class template definition */
> class Foo(T) {
> }
>
> /* Function template definition */
> void bar(T)( Foo!(T) arg) {
> // ...
> }
>
> /* Instantiation usage */
> main()
> {
> auto foo = new Foo!(float)(); /* line A */
> bar!(float)( foo); /* line B */
> }
>
>
> Now since in the main function the compiler knows that T is float at line A,
> it occurs to me that code noise could be reduced a bit if the compiler could
> somehow deduce at line B that the function template parameter, T, is float
> without it having to be explicitly written.
>
> The instantiation usage would now look like this:
>
> /* Less-noisy instantiation usage */
> main()
> {
> auto foo = new Foo!(float)(); /* line A */
> bar( foo); /* line B */
> }
>
>
> The only problem is how then to write the function template definition so
> that T can be defaulted to the class parameter, T, that accompanies Foo.
>
> One idea I had, which of course doesn't work, is to define the function
> template's argument with the auto keyword and then somehow figure out T from
> the argument like so:
>
> /* Function template definition */
> void bar(T = typeof( arg))( auto arg) {
> // ...
> }
>
>
> Since I'm getting used to finding cool features in D that always lets you do
> stuff you never dreamed of,
> and since I have a lot of template instantiation code,
> it would be really neat to be able to reduce the noise a bit as outlined
> above.
>
> Any ideas anybody? (Note D1.0)
>
> Perhaps this is a no brainer and I just goofed up but have given up after a
> spending way too much time on it thus far.
>
> Thanks all.
>
> Justin Johansson
>
>
class Foo(T) {}
void bar(T : Foo!(U), U)(T t) {}
void main()
{
auto foo = new Foo!(float)();
bar(foo);
}
:)
