Max Samukha <> changed:

           What    |Removed                     |Added
                 CC|                            |

--- Comment #2 from Max Samukha <> 2010-12-20 04:28:28 
PST ---
I am sure that using homonym templates for testing types and expressions is a
bad idea. It results in some syntactic compression but at the same time brings
lots of confusion. There should be two distinct templates. Something like this:

template isExpression(alias expression)
    enum isExpression = is(typeof(expression));

template isDelegate(alias expression) if (isExpression!expression)
    enum isDelegate = isDelegateType!(typeof(expression));

template isDelegateType(T)
    static enum isDelegateType = is(T == delegate);

template isFunctionPointer(alias expression) if (isExpression!expression)
    enum isFunctionPointer = isFunctionPointerType!(typeof(expression));

template isFunctionPointerType(T)
    static if (__traits(compiles, *T.init))
        enum isFunctionPointerType = isFunctionType!(typeof((*T.init)));
        enum isFunctionPointerType = false;

template isFunctionType(T)
    enum isFunctionType = is(T == function);

    alias void delegate() Dg;
    Dg dg;
    alias void function() Fn;
    Fn fn;

    static void foo()

    static assert(isDelegate!dg);    
    static assert(isDelegateType!Dg);
    static assert(!__traits(compiles, isDelegate!Dg));
    static assert(!isDelegateType!Fn);    

    static assert(isFunctionPointer!fn);
    static assert(!__traits(compiles, isFunctionPointer!Fn));
    static assert(!isFunctionType!Fn);

    static assert(isFunctionPointerType!Fn);
    static assert(!isFunctionPointerType!Dg);

    static assert(isFunctionType!(typeof(*&foo)));
    static assert(!isFunctionType!Fn);
    static assert(!isFunctionType!Dg);

Configure issuemail:
------- You are receiving this mail because: -------

Reply via email to