• Byron (68/68) Jun 09 2014 Should this work? It seems like the short circuit booleans are not
• Artur Skawina via Digitalmars-d-learn (9/26) Jun 10 2014 Static-if is special. Outside of static-if [1], code needs to be valid,
• Byron Heads (4/20) Jun 10 2014 Still feels like a bug to me (ie turtles all the way down is not being

Byron <byron.heads gmail.com> writes:

Should this work?  It seems like the short circuit booleans are not 
working:

--------------------------------
import std.traits;

enum isPrimitive(T) = isBasicType!T || (isArray!T && isBasicType!
(ForeachType!T));

void main() {

        assert(isPrimitive!int);
        assert(isPrimitive!char);
        assert(isPrimitive!string);
        assert(isPrimitive!(byte[]));

        assert(!isPrimitive!test1);
        assert(!isPrimitive!test2);
        assert(!isPrimitive!test3);

}

class test1 {}
struct test2 {}
interface test3 {}
----------------------------------------

dmd test
C:\D\dmd2\windows\bin\..\..\src\phobos\std\traits.d(5762): Error: invalid 
foreach aggregate 0
test.d(5): Error: template instance std.traits.ForeachType!int error 
instantiating
test.d(9):        instantiated from here: isPrimitive!int
test.d(9): Error: template instance test.isPrimitive!int error 
instantiating
C:\D\dmd2\windows\bin\..\..\src\phobos\std\traits.d(5762): Error: invalid 
foreach aggregate '\xff'
test.d(5): Error: template instance std.traits.ForeachType!char error 
instantiating
test.d(10):        instantiated from here: isPrimitive!char
test.d(10): Error: template instance test.isPrimitive!char error 
instantiating
C:\D\dmd2\windows\bin\..\..\src\phobos\std\traits.d(5762): Error: invalid 
foreach aggregate null
test.d(5): Error: template instance std.traits.ForeachType!(test1) error 
instantiating
test.d(14):        instantiated from here: isPrimitive!(test1)
test.d(14): Error: template instance test.isPrimitive!(test1) error 
instantiating
C:\D\dmd2\windows\bin\..\..\src\phobos\std\traits.d(5762): Error: invalid 
foreach aggregate test2()
test.d(5): Error: template instance std.traits.ForeachType!(test2) error 
instantiating
test.d(15):        instantiated from here: isPrimitive!(test2)
test.d(15): Error: template instance test.isPrimitive!(test2) error 
instantiating
C:\D\dmd2\windows\bin\..\..\src\phobos\std\traits.d(5762): Error: invalid 
foreach aggregate null
test.d(5): Error: template instance std.traits.ForeachType!(test3) error 
instantiating
test.d(16):        instantiated from here: isPrimitive!(test3)
test.d(16): Error: template instance test.isPrimitive!(test3) error 
instantiating
--------------------------------

DMD32 D Compiler v2.065


But this style works:

template isPrimitive(T) 
{
    static if(isBasicType!T || (isArray!T && isBasicType!(ForeachType!T))) 
{
        enum isPrimitive = true;
    } else {
        enum isPrimitive = false;
    }
}



-Byron

Artur Skawina via Digitalmars-d-learn <digitalmars-d-learn puremagic.com> writes:

On 06/10/14 02:28, Byron via Digitalmars-d-learn wrote:
 Should this work?  It seems like the short circuit booleans are not 
 working:
 
 enum isPrimitive(T) = isBasicType!T || (isArray!T && isBasicType!
 (ForeachType!T));

[...]

 But this style works:
 
 template isPrimitive(T) 
 {
     static if(isBasicType!T || (isArray!T && isBasicType!(ForeachType!T))) 
 {
         enum isPrimitive = true;
     } else {
         enum isPrimitive = false;
     }
 }

Static-if is special. Outside of static-if [1], code needs to be valid, 
even if it ends up never being executed.

 Should this work?

No. Allowing invalid code just because it will be skipped when the code
executes (either at RT or CT) would create other problems, while only
solving a minor and relatively rare one (the verbosity of static-if).

artur

[1] and a few other contexts, like in template constraints, is-expressions etc.

Byron Heads <byron.heads gmail.com> writes:

On Tue, 10 Jun 2014 17:06:08 +0200, Artur Skawina via Digitalmars-d-learn
wrote:

 On 06/10/14 02:28, Byron via Digitalmars-d-learn wrote:
 Should this work?  It seems like the short circuit booleans are not
 working:
 
 enum isPrimitive(T) = isBasicType!T || (isArray!T && isBasicType!
 (ForeachType!T));

 
 
 No. Allowing invalid code just because it will be skipped when the code
 executes (either at RT or CT) would create other problems, while only
 solving a minor and relatively rare one (the verbosity of static-if).
 
 artur
 
 [1] and a few other contexts, like in template constraints,
 is-expressions etc.


Still feels like a bug to me (ie turtles all the way down is not being 
applied here)