www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - Why can't templates with default arguments be instantiated without

reply Andrej Mitrovic <andrej.mitrovich gmail.com> writes:
struct Foo(T = int) {}

void main()
{
    Foo foo;  // fail
    Foo!() bar;  // ok
}

It would be very convenient to be able to default to one type like this.

For example, in CairoD there's a Point structure which takes doubles
as its storage type, and then there's PointInt that takes ints. The
reason they're not both a template Point() that takes a type argument
is because in most cases the user will use the Point structure with
doubles, and only in rare cases Point with ints. So to simplify code
one doesn't have to write Point!double in all of their code, but
simply Point.

If the bang syntax wasn't required in presence of default arguments
then these workarounds wouldn't be needed.
Sep 15 2011
next sibling parent reply "Simen Kjaeraas" <simen.kjaras gmail.com> writes:
On Thu, 15 Sep 2011 16:46:24 +0200, Andrej Mitrovic  
<andrej.mitrovich gmail.com> wrote:


 struct Foo(T = int) {}

 void main()
 {
     Foo foo;  // fail
     Foo!() bar;  // ok
 }

 It would be very convenient to be able to default to one type like this.

 For example, in CairoD there's a Point structure which takes doubles
 as its storage type, and then there's PointInt that takes ints. The
 reason they're not both a template Point() that takes a type argument
 is because in most cases the user will use the Point structure with
 doubles, and only in rare cases Point with ints. So to simplify code
 one doesn't have to write Point!double in all of their code, but
 simply Point.

 If the bang syntax wasn't required in presence of default arguments
 then these workarounds wouldn't be needed.


How would you then pass a single-argument template as a template alias
parameter?

Example:

template Foo( ) {
     template Bar( ) {
     }
}

template Baz(alias A) {
     mixin A!();
}

void main( ) {
     mixin Baz!Foo;
}

Does this mixin Foo or Bar to main's scope?

-- 
   Simen
Sep 15 2011
parent reply travert phare.normalesup.org (Christophe) writes:
"Simen Kjaeraas" , dans le message (digitalmars.D.learn:29539), a
 écrit :

 On Thu, 15 Sep 2011 16:46:24 +0200, Andrej Mitrovic  
 <andrej.mitrovich gmail.com> wrote:
 

 struct Foo(T = int) {}

 void main()
 {
     Foo foo;  // fail
     Foo!() bar;  // ok
 }

 It would be very convenient to be able to default to one type like this.

 For example, in CairoD there's a Point structure which takes doubles
 as its storage type, and then there's PointInt that takes ints. The
 reason they're not both a template Point() that takes a type argument
 is because in most cases the user will use the Point structure with
 doubles, and only in rare cases Point with ints. So to simplify code
 one doesn't have to write Point!double in all of their code, but
 simply Point.

 If the bang syntax wasn't required in presence of default arguments
 then these workarounds wouldn't be needed.


 
 How would you then pass a single-argument template as a template alias
 parameter?
 
 Example:
 
 template Foo( ) {
      template Bar( ) {
      }
 }
 
 template Baz(alias A) {
      mixin A!();
 }
 
 void main( ) {
      mixin Baz!Foo;
 }
 
 Does this mixin Foo or Bar to main's scope?


I don't get the problem. Maybe I am not used to mixin enough. Can you 
mixin normal templates, and not only mixin templates ?

Anyway, why would this mixin Bar ?
As I understand the proposition, only "mixin Baz!(Foo.Bar);" and of 
course "mixin Baz!(Foo!().Bar)" should mixin Bar.

-- 
Christophe
Sep 15 2011
parent "Simen Kjaeraas" <simen.kjaras gmail.com> writes:
On Thu, 15 Sep 2011 17:54:19 +0200, Christophe  =

<travert phare.normalesup.org> wrote:


 "Simen Kjaeraas" , dans le message (digitalmars.D.learn:29539), a
  =C3=A9crit :

 On Thu, 15 Sep 2011 16:46:24 +0200, Andrej Mitrovic
 <andrej.mitrovich gmail.com> wrote:


 struct Foo(T =3D int) {}

 void main()
 {
     Foo foo;  // fail
     Foo!() bar;  // ok
 }

 It would be very convenient to be able to default to one type like  =







 this.

 For example, in CairoD there's a Point structure which takes doubles=







 as its storage type, and then there's PointInt that takes ints. The
 reason they're not both a template Point() that takes a type argumen=






t

 is because in most cases the user will use the Point structure with
 doubles, and only in rare cases Point with ints. So to simplify code=







 one doesn't have to write Point!double in all of their code, but
 simply Point.

 If the bang syntax wasn't required in presence of default arguments
 then these workarounds wouldn't be needed.


 How would you then pass a single-argument template as a template alia=




s

 parameter?

 Example:

 template Foo( ) {
      template Bar( ) {
      }
 }

 template Baz(alias A) {
      mixin A!();
 }

 void main( ) {
      mixin Baz!Foo;
 }

 Does this mixin Foo or Bar to main's scope?


 I don't get the problem. Maybe I am not used to mixin enough. Can you
 mixin normal templates, and not only mixin templates ?

 Anyway, why would this mixin Bar ?
 As I understand the proposition, only "mixin Baz!(Foo.Bar);" and of
 course "mixin Baz!(Foo!().Bar)" should mixin Bar.


Sorry, you're right. I meant:

template Foo( ) {
     template Foo( ) {
     }
}

-- =

   Simen
Sep 15 2011
prev sibling next sibling parent "Steven Schveighoffer" <schveiguy yahoo.com> writes:
On Thu, 15 Sep 2011 10:46:24 -0400, Andrej Mitrovic  
<andrej.mitrovich gmail.com> wrote:


 struct Foo(T = int) {}

 void main()
 {
     Foo foo;  // fail
     Foo!() bar;  // ok
 }

 It would be very convenient to be able to default to one type like this.

 For example, in CairoD there's a Point structure which takes doubles
 as its storage type, and then there's PointInt that takes ints. The
 reason they're not both a template Point() that takes a type argument
 is because in most cases the user will use the Point structure with
 doubles, and only in rare cases Point with ints. So to simplify code
 one doesn't have to write Point!double in all of their code, but
 simply Point.

 If the bang syntax wasn't required in presence of default arguments
 then these workarounds wouldn't be needed.


Perhaps a different approach:

struct PointT(T) {...}

alias PointT!(double) Point;

// and if so desired:

alias PointT!int PointInt;

Just a thought...

-Steve
Sep 15 2011
prev sibling parent Jacob Carlborg <doob me.com> writes:
On 2011-09-15 16:46, Andrej Mitrovic wrote:

 struct Foo(T = int) {}

 void main()
 {
      Foo foo;  // fail
      Foo!() bar;  // ok
 }

 It would be very convenient to be able to default to one type like this.

 For example, in CairoD there's a Point structure which takes doubles
 as its storage type, and then there's PointInt that takes ints. The
 reason they're not both a template Point() that takes a type argument
 is because in most cases the user will use the Point structure with
 doubles, and only in rare cases Point with ints. So to simplify code
 one doesn't have to write Point!double in all of their code, but
 simply Point.

 If the bang syntax wasn't required in presence of default arguments
 then these workarounds wouldn't be needed.


I've wondered the same thing, why this doesn't work:

template Foo (T = int) {}

mixin Foo;

But this works:

template Foo () {}

mixin Foo;

-- 
/Jacob Carlborg
Sep 15 2011