• "Saaa" <empty needmail.com> Jun 11 2009
• BCS <none anon.com> Jun 11 2009
• Jarrett Billingsley <jarrett.billingsley gmail.com> Jun 11 2009
• "Saaa" <empty needmail.com> Jun 11 2009
• "Saaa" <empty needmail.com> Jun 11 2009
• "Saaa" <empty needmail.com> Jun 11 2009
• "Saaa" <empty needmail.com> Jun 11 2009
• "Saaa" <empty needmail.com> Jun 11 2009
• "Saaa" <empty needmail.com> Jun 11 2009
• Jarrett Billingsley <jarrett.billingsley gmail.com> Jun 11 2009
• Jarrett Billingsley <jarrett.billingsley gmail.com> Jun 11 2009
• Jarrett Billingsley <jarrett.billingsley gmail.com> Jun 11 2009
• "Saaa" <empty needmail.com> Jun 11 2009

"Saaa" <empty needmail.com> writes:

Is this a good way to get the depth of an array?

int getArrayDepth(T)(ref T array)
{
static if( is(T A:A[]) )
{
A arr;
return 1 + getArrayDepth(arr);
}
else
{
return 0;
}
return -1;
} 

BCS <none anon.com> writes:

Hello Saaa,

 Is this a good way to get the depth of an array?
 
 int getArrayDepth(T)(ref T array)
 {
 static if( is(T A:A[]) )
 {
 A arr;
 return 1 + getArrayDepth(arr);
 }
 else
 {
 return 0;
 }
 return -1;
 }


I just posted this today

http://www.dsource.org/projects/scrapple/browser/trunk/Serial/utill.d

Jarrett Billingsley <jarrett.billingsley gmail.com> writes:

On Thu, Jun 11, 2009 at 9:15 PM, Saaa<empty needmail.com> wrote:
 Is this a good way to get the depth of an array?

 int getArrayDepth(T)(ref T array)
 {
 static if( is(T A:A[]) )
 {
 A arr;
 return 1 + getArrayDepth(arr);
 }
 else
 {
 return 0;
 }
 return -1;
 }


It's kind of the right idea, but.. it's also kind of weird.

template ArrayDepth(T: T[]) { const ArrayDepth = 1 + ArrayDepth!(T); }
template ArrayDepth(T)       { const ArrayDepth = 0; }

This lets you get the depth of any array _type_, like
ArrayDepth!(int[][]) gives 2.

"Saaa" <empty needmail.com> writes:

 It's kind of the right idea, but.. it's also kind of weird.

 template ArrayDepth(T: T[]) { const ArrayDepth = 1 + ArrayDepth!(T); }
 template ArrayDepth(T)       { const ArrayDepth = 0; }

 This lets you get the depth of any array _type_, like
 ArrayDepth!(int[][]) gives 2.


Ah , that's how you make it do at compile time, using const.

BCS also did it a bit like me (one template that is) I just didn't know you 
could also just pass the type :D
Any advantage to using two?

He also does :  is( T B ==B[])  iso  is( T B:B[] )
Any significant difference there? 

"Saaa" <empty needmail.com> writes:

Also, what's the advantage of explicitly defining it as a template? 

"Saaa" <empty needmail.com> writes:

 Any advantage to using two?


 I just tend to prefer template specialization when doing type pattern
 matching.  It works out better than is() in some cases.


 He also does :  is( T B ==B[])  iso  is( T B:B[] )
 Any significant difference there?


 I'm.. not sure, in this case anyway.  Normally == does strict type
 comparison while : does implicit type conversion, but in this case,
 is() is being (ab)used to pick apart a type rather than test one.  I
 think it'll always return 'true' in either case if T is an array, so I
 don't think there's a functional difference.


Implicit convertion sounds a bit dangerous, might start using == instead

 Also, what's the advantage of explicitly defining it as a template?


 As opposed to what, implicitly defining it as a template?  This
 question doesn't really make sense.


I mean, I was using a function template.

 template ArrayDepth(T: T[]) { const ArrayDepth = 1 + ArrayDepth!(T); }
 template ArrayDepth(T)       { const ArrayDepth = 0; }


The code looks a bit strange to me:
ArrayDepth is both a (const) value and template name and where is the return 
value ?

"Saaa" <empty needmail.com> writes:

 It's kind of the right idea, but.. it's also kind of weird.

 template ArrayDepth(T: T[]) { const ArrayDepth = 1 + ArrayDepth!(T); }
 template ArrayDepth(T)       { const ArrayDepth = 0; }

 This lets you get the depth of any array _type_, like
 ArrayDepth!(int[][]) gives 2.


Although I don't fully understand your code, I think I modified it correctly 
to get the base type of an array :)

template BaseType(T: T[]) { const BaseType = BaseType!(T); }
template BaseType(T) {const BaseType = T; } 

"Saaa" <empty needmail.com> writes:

 template BaseType(T: T[]) { const BaseType = BaseType!(T); }
 template BaseType(T) {const BaseType = T; }


..
else static if( std2.traits.isNumeric!( BaseType!(T) ) )
{
..

ddata\ddata.d(192): template instance isNumeric!(int) does not match any 
template declaration
ddata\ddata.d(192): Error: expression isNumeric!(int) is not constant or 
does not evaluate to a bool

What am I doing wrong? 

"Saaa" <empty needmail.com> writes:

 Your template.  Types are not values, you cannot declare a constant
 that is a type.  You have to use alias instead:

 template BaseType(T: T[]) { alias BaseType!(T) BaseType; }
 template BaseType(T) { alias T BaseType; }


Erm, why did this print corretly?

writefln(`BaseType = `, BaseType!(T).stringof );

btw. Thanks for everything !!
It's nice to get some comments after a fews days of struggling with them 
templates :)

I can now parse any numeric type (array) till depth 4; still haven't found a 
way to generalize this part :(

private void Parse(T)(ref T parsed)
{

..

switch( depth )
{
case 0:
if( temp.length < index[depth] ) temp.length = temp.length * 2;
break;
static if( is(T A:A[][]))
{
case 1:
if( temp[ index[0] ].length < index[depth] ) temp[index[0]].length = 
temp[index[0]].length * 2;
break;
}
static if( is(T A:A[][][]))
{
case 2:
if( temp[ index[0] ][ index[1] ].length < index[depth] ) temp[ index[0] ][ 
index[1] ].length = temp[ index[0] ][ index[1] ].length * 2;
break;
}
default:
assert(false);
break;
}

..
} 

Jarrett Billingsley <jarrett.billingsley gmail.com> writes:

On Thu, Jun 11, 2009 at 11:02 PM, Saaa<empty needmail.com> wrote:
 Any advantage to using two?


I just tend to prefer template specialization when doing type pattern
matching.  It works out better than is() in some cases.

 He also does :  is( T B ==B[])  iso  is( T B:B[] )
 Any significant difference there?


I'm.. not sure, in this case anyway.  Normally == does strict type
comparison while : does implicit type conversion, but in this case,
is() is being (ab)used to pick apart a type rather than test one.  I
think it'll always return 'true' in either case if T is an array, so I
don't think there's a functional difference.

 Also, what's the advantage of explicitly defining it as a template?


As opposed to what, implicitly defining it as a template?  This
question doesn't really make sense.

Jarrett Billingsley <jarrett.billingsley gmail.com> writes:

On Fri, Jun 12, 2009 at 12:04 AM, Saaa<empty needmail.com> wrote:
 template BaseType(T: T[]) { const BaseType = BaseType!(T); }
 template BaseType(T) {const BaseType = T; }


 ..
 else static if( std2.traits.isNumeric!( BaseType!(T) ) )
 {
 ..

 ddata\ddata.d(192): template instance isNumeric!(int) does not match any
 template declaration
 ddata\ddata.d(192): Error: expression isNumeric!(int) is not constant or
 does not evaluate to a bool

 What am I doing wrong?


Your template.  Types are not values, you cannot declare a constant
that is a type.  You have to use alias instead:

template BaseType(T: T[]) { alias BaseType!(T) BaseType; }
template BaseType(T) { alias T BaseType; }

Jarrett Billingsley <jarrett.billingsley gmail.com> writes:

On Thu, Jun 11, 2009 at 11:45 PM, Saaa<empty needmail.com> wrote:

 I'm.. not sure, in this case anyway. =A0Normally =3D=3D does strict type
 comparison while : does implicit type conversion, but in this case,
 is() is being (ab)used to pick apart a type rather than test one. =A0I
 think it'll always return 'true' in either case if T is an array, so I
 don't think there's a functional difference.


 Implicit convertion sounds a bit dangerous, might start using =3D=3D inst=



Um, there's no "one's better than the other."  Don't overgeneralize on
things you don't understand.  Implicit conversion is necessary in some
cases, and in others, exact comparison is needed.

 Also, what's the advantage of explicitly defining it as a template?


 As opposed to what, implicitly defining it as a template? =A0This
 question doesn't really make sense.


 I mean, I was using a function template.


A function template is just a function in a template.  Templates can
work just fine on their own.  If you're manipulating types, there's
really no need to get functions involved.

 template ArrayDepth(T: T[]) { const ArrayDepth =3D 1 + ArrayDepth!(T); }
 template ArrayDepth(T) =A0 =A0 =A0 { const ArrayDepth =3D 0; }


 The code looks a bit strange to me:
 ArrayDepth is both a (const) value and template name and where is the ret=


 value ?


See "Implicit Template Properties" here:
http://www.digitalmars.com/d/1.0/template.html

When you create a member in a template with the same name as the
template, you can access it from the template without explicitly
writing ArrayDepth!(int[]).ArrayDepth.

"Saaa" <empty needmail.com> writes:

Um, there's no "one's better than the other."  Don't overgeneralize on


cases, and in others, exact comparison is needed.

I didn't mean it like that, don't worry :)
I mean, I apparently used implicit when I actually wanted explicit.

A function template is just a function in a template.  Templates can


really no need to get functions involved.

Check

See "Implicit Template Properties" here:



Reading . .

When you create a member in a template with the same name as the


writing ArrayDepth!(int[]).ArrayDepth.