• bobef (14/14) Feb 19 2006 It would be nice if there were something like auto templates. I.e. if we...
• Trevor Parscal (5/19) Feb 19 2006 This is a bit ambiguous in actual practice IMHO - but... I also can see ...
• bobef (2/28) Feb 19 2006 I mean the same way it is possible to write auto a=6;
• Hasan Aljudy (2/21) Feb 19 2006 is this the infamouse implicit template instantiation?
• bobef (2/24) Feb 19 2006 I don't know.
• nick (2/27) Feb 19 2006
• Sean Kelly (3/25) Feb 19 2006 Pretty much.

bobef <bobef lessequal.com> writes:

It would be nice if there were something like auto templates. I.e. if we 
have something like:

template mytemplate(_type)
{
	int foo(_type[] ar);
	int boo(_type ar);
}


and type something like

char[] a;
foo(a);
//or even
mytemplate.boo(a[0]);

DMD could autodetect the type and we won't need to specify the type 
every time manualy.

Trevor Parscal <Trevor_member pathlink.com> writes:

In article <dt9fqs$1v1h$1 digitaldaemon.com>, bobef says...
It would be nice if there were something like auto templates. I.e. if we 
have something like:

template mytemplate(_type)
{
	int foo(_type[] ar);
	int boo(_type ar);
}


and type something like

char[] a;
foo(a);
//or even
mytemplate.boo(a[0]);

DMD could autodetect the type and we won't need to specify the type 
every time manualy.

This is a bit ambiguous in actual practice IMHO - but... I also can see how this
would be awesome - when this ambiguity would be desired.

Thanks,
Trevor Parscal

bobef <bobef lessequal.com> writes:

Trevor Parscal wrote:
 In article <dt9fqs$1v1h$1 digitaldaemon.com>, bobef says...
 It would be nice if there were something like auto templates. I.e. if we 
 have something like:

 template mytemplate(_type)
 {
 	int foo(_type[] ar);
 	int boo(_type ar);
 }


 and type something like

 char[] a;
 foo(a);
 //or even
 mytemplate.boo(a[0]);

 DMD could autodetect the type and we won't need to specify the type 
 every time manualy.

 
 This is a bit ambiguous in actual practice IMHO - but... I also can see how
this
 would be awesome - when this ambiguity would be desired.
 
 Thanks,
 Trevor Parscal


I mean the same way it is possible to write auto a=6;

Hasan Aljudy <hasan.aljudy gmail.com> writes:

bobef wrote:
 It would be nice if there were something like auto templates. I.e. if we 
 have something like:
 
 template mytemplate(_type)
 {
     int foo(_type[] ar);
     int boo(_type ar);
 }
 
 
 and type something like
 
 char[] a;
 foo(a);
 //or even
 mytemplate.boo(a[0]);
 
 DMD could autodetect the type and we won't need to specify the type 
 every time manualy.

is this the infamouse implicit template instantiation?

bobef <bobef lessequal.com> writes:

Hasan Aljudy wrote:
 bobef wrote:
 It would be nice if there were something like auto templates. I.e. if 
 we have something like:

 template mytemplate(_type)
 {
     int foo(_type[] ar);
     int boo(_type ar);
 }


 and type something like

 char[] a;
 foo(a);
 //or even
 mytemplate.boo(a[0]);

 DMD could autodetect the type and we won't need to specify the type 
 every time manualy.

 
 is this the infamouse implicit template instantiation?

I don't know.

nick <nick.atamas gmail.com> writes:

It's a variation on it.

bobef wrote:
 Hasan Aljudy wrote:
 bobef wrote:
 It would be nice if there were something like auto templates. I.e. if
 we have something like:

 template mytemplate(_type)
 {
     int foo(_type[] ar);
     int boo(_type ar);
 }


 and type something like

 char[] a;
 foo(a);
 //or even
 mytemplate.boo(a[0]);

 DMD could autodetect the type and we won't need to specify the type
 every time manualy.

 is this the infamouse implicit template instantiation?

 
 I don't know.

Sean Kelly <sean f4.ca> writes:

Hasan Aljudy wrote:
 bobef wrote:
 It would be nice if there were something like auto templates. I.e. if 
 we have something like:

 template mytemplate(_type)
 {
     int foo(_type[] ar);
     int boo(_type ar);
 }


 and type something like

 char[] a;
 foo(a);
 //or even
 mytemplate.boo(a[0]);

 DMD could autodetect the type and we won't need to specify the type 
 every time manualy.

 
 is this the infamouse implicit template instantiation?

Pretty much.


Sean