This code worked with dmd 2.060:

import std.stdio;
import std.traits;

struct OhWhy(S) {
    S[] arr;
    alias arr this;
}

void main() {
	static assert(isArray!(OhWhy!(float)));

}

But fails with dmd 2.061:
ss.d(10): Error: static assert  (isArray!(OhWhy!(float))) is false

(same happens with alias this to static arrays and isArray/isStaticArray)


Is this intended or a regression? If latter, I'll submit a bug-ticket.

On Saturday, 5 January 2013 at 14:43:49 UTC, David wrote:
> This code worked with dmd 2.060:
>
> import std.stdio;
> import std.traits;
>
> struct OhWhy(S) {
>     S[] arr;
>     alias arr this;
> }
>
> void main() {
> 	static assert(isArray!(OhWhy!(float)));
> 	
> }
>
> But fails with dmd 2.061:
> ss.d(10): Error: static assert  (isArray!(OhWhy!(float))) is false
>
> (same happens with alias this to static arrays and isArray/isStaticArray)
>
>
> Is this intended or a regression? If latter, I'll submit a bug-ticket.

All traits in std trait of the type were explicitly changed to return true only if *the exact type* meets the traits requirement.

The rationale is simply tha OhWhy isn't an array. It can be implicitly cast to array, but it isn't an array.

This is problematic when instanciating template functions with automatic type inference: when you write "myTemplateFunction(myOhWhy)", then you will instanciate "myTemplateFuction!OhWhy" when what you may have wanted was to actually call "myTemplateFunction!(S[])".

The new "isArray" definition protects from that.

On Saturday, January 05, 2013 22:57:51 monarch_dodra wrote:
> On Saturday, 5 January 2013 at 14:43:49 UTC, David wrote:
> > This code worked with dmd 2.060:
> > 
> > import std.stdio;
> > import std.traits;
> > 
> > struct OhWhy(S) {
> > 
> >     S[] arr;
> >     alias arr this;
> > 
> > }
> > 
> > void main() {
> > 
> > 	static assert(isArray!(OhWhy!(float)));
> > 
> > }
> > 
> > But fails with dmd 2.061:
> > ss.d(10): Error: static assert  (isArray!(OhWhy!(float))) is
> > false
> > 
> > (same happens with alias this to static arrays and
> > isArray/isStaticArray)
> > 
> > 
> > Is this intended or a regression? If latter, I'll submit a bug-ticket.
> 
> All traits in std trait of the type were explicitly changed to return true only if *the exact type* meets the traits requirement.
> 
> The rationale is simply tha OhWhy isn't an array. It can be implicitly cast to array, but it isn't an array.
> 
> This is problematic when instanciating template functions with automatic type inference: when you write "myTemplateFunction(myOhWhy)", then you will instanciate "myTemplateFuction!OhWhy" when what you may have wanted was to actually call "myTemplateFunction!(S[])".
> 
> The new "isArray" definition protects from that.

Exactly. The std.traits traits are testing for exact types. If you want to test for implicit conversion, then use the : operator. e.g.

    static assert(is(OhWhy!float : float[]));

- Jonathan M Davis

Thanks for your answers, but:

> Exactly. The std.traits traits are testing for exact types. If you want to test for implicit conversion, then use the : operator. e.g.
> 
>     static assert(is(OhWhy!float : float[]));

"OyWhy" is a templated struct for a reason, I have no idea which type of array is "alias this'ed" is there a way I can check if it's implicitly convertable to any array type with some `is` magic I am not aware of?

On Sun, Jan 6, 2013 at 1:36 PM, David <d@dav1d.de> wrote:

> Thanks for your answers, but:
>
> > Exactly. The std.traits traits are testing for exact types. If you want
> to
> > test for implicit conversion, then use the : operator. e.g.
> >
> >     static assert(is(OhWhy!float : float[]));
>
> "OyWhy" is a templated struct for a reason, I have no idea which type of array is "alias this'ed" is there a way I can check if it's implicitly convertable to any array type with some `is` magic I am not aware of?
>
>
Like this?

struct MyType(Elem)
{
    Elem[] inner;
    alias inner this;
}

void main()
{
    static assert(is(MyType!float _ : T[], T));
}

> Like this?
> 
> struct MyType(Elem)
> {
>     Elem[] inner;
>     alias inner this;
> }
> 
> void main()
> {
>     static assert(is(MyType!float _ : T[], T));
> }
> 

And how does that work for a static array?

On Wed, Jan 9, 2013 at 10:57 PM, David <d@dav1d.de> wrote:
>> Like this?
>>
>> struct MyType(Elem)
>> {
>>     Elem[] inner;
>>     alias inner this;
>> }
>>
>> void main()
>> {
>>     static assert(is(MyType!float _ : T[], T));
>> }
>>
>
> And how does that work for a static array?

For a static array, the generic type is T[n], for some T and a size_t n. So:

static assert(is(MyType!float _ : T[n], T, size_t n));