www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - auto parameter causing template (suggestion for D)

reply david <davidl 126.com> writes:
take a look at this:

import std.stdio;
void myoverload(auto foo)
{
static if (is ( typeof(foo):int ) )
     { writefln("int");
     }
else
     static if (is ( typeof(foo):char[] ) )
     { writefln("char[]");
     }
}
void main()
{
  myoverload(3);
  myoverload("asdkjf");
}


Though this is a trivial improvement to D language. but I think that  
affect people differently in their mind. People would no longer notice  
they are writing a template for that myoverload
People would see that function as a normal function.
Though that would lost the type information where we can get from void  
myoverload(T)(T t) directly from T, I think typeof(foo) won't bother too  
much! And it's really elegant way to implement in that way.
Sep 22 2006
parent reply Reiner Pope <reiner.pope REMOVE.THIS.gmail.com> writes:
david wrote:

 take a look at this:
 
 import std.stdio;
 void myoverload(auto foo)
 {
 static if (is ( typeof(foo):int ) )
     { writefln("int");
     }
 else
     static if (is ( typeof(foo):char[] ) )
     { writefln("char[]");
     }
 }
 void main()
 {
  myoverload(3);
  myoverload("asdkjf");
 }
 
 
 Though this is a trivial improvement to D language. but I think that 
 affect people differently in their mind. People would no longer notice 
 they are writing a template for that myoverload
 People would see that function as a normal function.
 Though that would lost the type information where we can get from void 
 myoverload(T)(T t) directly from T, I think typeof(foo) won't bother too 
 much! And it's really elegant way to implement in that way.


Yes, it's quite elegant. This suggestion is similar to mine from 'Some 
more template syntax sugar,' but yours has the advantage of an 
unambiguous syntax (since auto is a keyword, it can't be used as a 
type). Add this to type inference of return values, and you get dead 
easy templating, or compile time duck typing, in other words. (adding 
return type inference basically means that every type can be inferred, 
and typeof expressions shouldn't be needed much)

The example I posted earlier:

T sqr(T) (T x)
{
     return x*x;
}

would become

auto sqr(auto x)
{
     return x*x;
}

and the compiler would understand this to be equivalent to:

typeof(__ret) sqr(__t1) ( __t1 x)
{
     auto __ret = x * x;
     return __ret;
}

This could work very well.

Cheers,

Reiner
Sep 22 2006
parent david <davidl 126.com> writes:
在 Sat, 23 Sep 2006 12:54:48 +0800，Reiner Pope  
<reiner.pope REMOVE.THIS.gmail.com> 写道:


 david wrote:

 take a look at this:
  import std.stdio;
 void myoverload(auto foo)
 {
 static if (is ( typeof(foo):int ) )
     { writefln("int");
     }
 else
     static if (is ( typeof(foo):char[] ) )
     { writefln("char[]");
     }
 }
 void main()
 {
  myoverload(3);
  myoverload("asdkjf");
 }
   Though this is a trivial improvement to D language. but I think that  
 affect people differently in their mind. People would no longer notice  
 they are writing a template for that myoverload
 People would see that function as a normal function.
 Though that would lost the type information where we can get from void  
 myoverload(T)(T t) directly from T, I think typeof(foo) won't bother  
 too much! And it's really elegant way to implement in that way.


 Yes, it's quite elegant. This suggestion is similar to mine from 'Some  
 more template syntax sugar,' but yours has the advantage of an  
 unambiguous syntax (since auto is a keyword, it can't be used as a  
 type). Add this to type inference of return values, and you get dead  
 easy templating, or compile time duck typing, in other words. (adding  
 return type inference basically means that every type can be inferred,  
 and typeof expressions shouldn't be needed much)

 The example I posted earlier:

 T sqr(T) (T x)
 {
      return x*x;
 }

 would become

 auto sqr(auto x)
 {
      return x*x;
 }

 and the compiler would understand this to be equivalent to:

 typeof(__ret) sqr(__t1) ( __t1 x)
 {
      auto __ret = x * x;
      return __ret;
 }

 This could work very well.

 Cheers,

 Reiner


Yeah, auto can be generalized to return type too. Good point. This way is  
quite elegant. Hope we can see that in dmd 0.168 :p

-- 
使用 Opera 革命性的电子邮件客户程序: http://www.opera.com/mail/
Sep 23 2006