d模板元编程笔记05_d metaprogramming-CSDN博客

本文链接：https://blog.csdn.net/fqbqrr/article/details/107807549

是( 类型 (可选 标识符) )
是( 类型 (可选 标识符) :  其他类型,
         (可选 元 形参 列表) )
是( 类型 (可选 标识符) == 其他类型,
         (可选 元 形参 列表) )

是表达式,编译时自省,是(...)检查其为类型,则为真.

元 可实例化用(别名 元名, 类型...)
{
    // 元名!(类型) 是有效类型?
    静 如 (是( 元名!(类型) 结果类型 ))
    // 在此你可用 结果类型 (== 元名!(类型))
        别名 结果类型 可实例化用;
    异
        别名 空  可实例化用;
}

用模板完成,如果用函数名传递给元名,则不是有效类型,返回假,并置为空
有时,你不知道是类型还是别名,可用!is(symbol)(别名则为真).是(..)如果是类型,则为真.
检查是否是有效D代码,编译器把d块当作空闭包()
的型({代码}()),这样,就检测出了代码的有效性.如果有个真实D类型,则是(...)返回真.

极 有效调用(别名 函数, 实参...)(实参 实参)
{
    中 是( 的型({ /* 测试代码 */
                        函数(实参);//就一个
                      }()));
}//抽象出来一个模板

你不确定是否可以用(参数…)调用函数.

T 加(T)(T a, T b) { 中 a+b;}
串 连接(A,B)(A a, B b) { 中 到!串(a) ~ 到!串(b);}

空 主()
{
    断定( 有效调用!加(1, 2));   // 生成 加!(整)
    断定(!有效调用!加(1, "abc")); //无可用实例

    断定( 有效调用!连接(1, "abc")); // 连接!(整, 串)没问题.
    断定(!有效调用!连接(1)); //无单参版本
    构 S {}
    断定(!有效调用!S(1, 2.3)); // 不可调用S
}

注意,只测试fun(args);,不要求函数类型(函数,闭包,带opCall构/类.只两种情况,一,fun不能作为函数,二,参数不匹配.
D同样有__特征(编译, { /* 代码 */ }),来判定是否可编译
is(Type : AnotherType) 和 is(Type == AnotherType)
第一种,是可转换(继承),第二种,完全相同.

是(类型 标识符 == 依赖u和v的复杂类型, U, V)

模板参数,像类型的变量.就像f(U,V),表示类型是否依赖(U,V)

元 数组元素(T)
{
    静 如 (是(T t : U[], U))//T是U的数组
        别名 U 数组元素; //可用U,暴露它
    异
        别名 空 数组元素;
}

元 是关联数组(AA)
{
    静 如 (是( AA aa == 值[键], 值, 键))
        /* 可用键与值,编译器推导. */
    异
        // AA 不是关联数组,未定义键与值
}

只能用,is(Type 标识符, ...),且必须有标识符,要检查的复杂类型可以为模板类型,参数列表可以是任意模板参数(编译时值),比如,创建N维数组向量

构 向量(类型, 整 维) { ... }
向量!(?, ?) 我的向量;
// 我的向量是整向量,具任何维数?
静 如 (是(的型(我的向量) mv == 向量!(整, 维), 维))
//这样使用,
// 是1维向量?
静 如 (是(的型(我的向量) mv == 向量!(T, 1), T))

不存在is( A != B),如果(A,B都不是类型),is(A == B)仍为真.因此,这样用:is(A) && is(B) && !is(A == B).
is(子:父),表示是子类,父类:is(子:父),只是交换了下顺序
现在可以:

元 是元组(T)
{
    静 如 (是(T 元组 == 元组!(内部类型), 内部类型...)
(...)

这里,加入可变模板参数了.

模块 是元组;
导入 标.构造类型;

元 是元组(T)
{
    枚 极 是元组 =
        是(的型({
            空 元组测试器(内部类型...)(元组!(内部类型) 元组) {}
        //元组测试器,元组为参
            T.初化 可能元组;
            元组测试器(可能元组);//判断能否成立
        }()));
}

是元组对元组都成立,如果想限制,则修改元组测试器,但不能访问内部类型,虽然可以someTuple.Types,但不爽.

静 如 (是( T t == A!(U,V), U : 一些类!W, V == 整[n], W, 整 n))

模板参数列表,可用A:B/A==B语法.就像定义类型一样.
整 n,W,V,U==>A!(U,V).
类型限定.在是(类型(标识符)==T)中,T也可为类型限定,如function, delegate, return, struct, enum, union, class, interface, super, const, immutable or shared,标识符则成了类型的别名,

限定	条件	目标
`function`	类型是函数	函数参数类型元组
`delegate`	类型是闭包	闭包函数
`return`	类型是函数	中
`return`	类型是闭包	中
`struct`	类型是构	结构
`enum`	类型是枚	枚举基
`union`	类型是联	联合
`class`	类型是类	班级
`interface`	类型是接口	接口
`super`	类型是类	类型元组(基类,接口)
`const`	类型是常	类型
`immutable`	类型是不变	类型
`shared`	类型共享	类型

工厂函数,要建立类/构.用名作为参数.

模块 制造器;
导入 标.算法;
导入 标.转换;

元 造(A)如 (是(A a == 类 )|| 是(A a == 构))
{
    动 造(实参...)(实参 实参)
    {
        静 如 (是(A a == 类))
            中 新 A(实参);
        异
            中 A(实参);
    }
}

构 S {整 i;}
类 C
{
    整 i;
    本(整 ii) { i = ii;}
    盖 串 至串() @属性
    {
        中 "C("~到!串(i)~")";
    }
}

空 主()
{
    动 数组 = [0,1,2,3];

    动 构区间 = 映射!( 造!S )(数组);
    动 类区间  = 映射!( 造!C )(数组);

     断定(相等(构区间, [S(0), S(1), S(2), S(3)]));
    断定(类区间.前.至串 == "C(0)");
}