Question

如何测试别名是否是D 2.0中的模板？

template isTemplate(alias T)
{
    enum bool isTemplate = ???;
}

更新

应该像：

struct S(T)
{
    int opCall() { return 0; }
    int opUnary(string s)() if (s == "-") { return 0; }
}

pragma(msg, isTemplate!(S));                 //Should print true
pragma(msg, isTemplate!(S!(int)));           //Should print false
pragma(msg, isTemplate!((S!(int)).opCall));  //Should print false
pragma(msg, isTemplate!((S!(int)).opUnary)); //Should print true

供参考，不工作的东西：

您不能使用T!(...)之类的任何表达式，因为您不知道应该用什么代替省略号。
您不能说&T，因为如果您只是一个普通的旧类型名称，这也不起作用。

Answer 1

除了the other answer

中列出的2项测试外，其他所有测试都通过了

import std.algorithm : startsWith, canFind;

template isTemplate(alias B) {
    enum isTemplate = !__traits(compiles, {auto x=B;})      // excludes values
                   && !__traits(compiles, {B x;})           // excludes types
                   && __traits(compiles, {alias B x;})      // excludes instance members
                   && !B.stringof.startsWith("module ", "package ") // excludes modules
                   && !B.stringof.canFind("!(");             // excludes instantiated templates
}

失败的2项测试如下：

struct Inner2(string U="!(") {}
static assert(isTemplate(Inner2));

如果您确定模板没有包含"...!(..."的默认参数，我认为使用它是安全的。

Answer 2

template isTemplate(alias T, Args...)
{
    enum bool isTemplate = __traits(compiles, T!(Args));
}

这也会增加额外的约束 - 它必须是可以用给定参数实例化的模板。

Answer 3

此代码正在应用'＆amp;'的运营商地址这不适用于模板，以识别模板标识符。

struct S (T) {
    int a;
    int foo () () {}
    int xyz (A) (A a) {}
    void bar (T t) {}
}

void main () {
    S!(int) s;
    foreach (m; __traits(allMembers, S!(int)))
        writeln (m, " is template: ", !__traits(compiles, mixin("&s." ~ m)));
}

输出是：

a is template: false
foo is template: true
xyz is template: true
bar is template: false

Answer 4

template alias parameter可以接受很多东西：变量，自定义类型，模块，模板和文字。

因此isTemplate应该通过以下测试用例：

struct FooS(T) {
    struct Inner {}
    struct Inner2(string U="!(") {}
    int func(U)() { return 0; }
    int bar;
}
FooS!int foo;

class FooC { int x; }
union FooU { int x;}
enum FooE { x }
interface FooI { int x(); }

template FooT(T) {
    struct Inner {}
    struct Inner2(string U="!(") {}
    int func(U)() { return 0; }
    int bar;
}

static assert(! isTemplate!0 );
static assert(! isTemplate!"0" );
static assert(! isTemplate!0.0f );
static assert(! isTemplate!'0' );
static assert(! isTemplate!'!' );
static assert(! isTemplate!"module std.stdio" );
static assert(! isTemplate!null );
static assert(! isTemplate!true );
static assert(! isTemplate!__FILE__ );
static assert(! isTemplate!__LINE__ );
static assert(! isTemplate!([]) );
static assert(  isTemplate!FooS );
static assert(! isTemplate!(FooS!int) );
static assert(  isTemplate!(FooS!int.func) );
static assert(! isTemplate!(FooS!int.func!float) );
static assert(! isTemplate!(FooS!int.bar) );
static assert(! isTemplate!(FooS!int.Inner) );
static assert(  isTemplate!(FooS!int.Inner2) );
static assert(! isTemplate!(FooS!int.Inner2!"?") );
static assert(  isTemplate!FooT );
static assert(! isTemplate!(FooT!int) );
static assert(  isTemplate!(FooT!int.func) );
static assert(! isTemplate!(FooT!int.func!float) );
static assert(! isTemplate!(FooT!int.bar) );
static assert(! isTemplate!(FooT!int.Inner) );
static assert(  isTemplate!(FooT!int.Inner2) );
static assert(! isTemplate!(FooT!int.Inner2!"?") );
static assert(! isTemplate!foo );
static assert(  isTemplate!(foo.func) );
static assert(  isTemplate!isTemplate );
static assert(! isTemplate!(isTemplate!isTemplate) );
static assert(! isTemplate!FooC );
static assert(! isTemplate!FooU );
static assert(! isTemplate!FooE );
static assert(! isTemplate!FooI );
static assert(! isTemplate!((int x){return x;}) );
static assert(  isTemplate!(std.stdio.writefln) );
static assert(! isTemplate!(std.stdio) );
static assert(! isTemplate!std );

测试别名是否为D 2.0中的模板

4 个答案: