d中变量很酷

标.变量,以变量为中心,其不是c++的变量,而是可包含任意类型值的类型安全容器.其也知道包含的值的类型,c++却用变量这个名字来实现聚集(并)类型.

  导入 标.变量;
  变量 a;
  a=42;
  断定(a.类型==具型(整));
  a+=1;
  断定(a==43);
  浮 f=a.取!浮;//转为浮
  断定(f==43);
  a/=2;
  f/=2;
  断定(a==21&&f==21.5);
  a="[!串000]";
  断定(a.类型==具型(串));
  变量 b=新 对象();
  变量 c=b;
  断定(c 是 b);//bc指向相同
  b/=2;//不匹配,错误

标.变量也提供了并类型,代数.另一个是元组.代数是编译时特定类型列表.与变量差不多.
如果类型不匹配,会报编译错误.像这样:

  别名 无效=的型(无效);//[!注释003]
  别名 选项(T)=代数!(T,无效);
  选项!大小型 的索引(整[]干草堆,整 针头){
      每一(大小型 i,整 n;干草堆)
          如(n==针头)
              中 选项!大小型(i);
      中 选项!大小型(无效);
  }
  整[]a=[4,2,210,42,7];
  选项!大小型 索引=a.的索引(42);//统调,
  断定(!索引.偷看!无效);//断定没有
  断定(索引==大小型(3));
  选项!大小型 索引2=a.的索引(117);
  断定(索引2.偷看!无效);

偷看函数,把变量作为运行时参数,T作为编译时参数.仅当变量有T类型时,返回变量的值的指针,否则返回无效针.
d的变量也能访问代数上函数.允许当为适当类型,则运行相应类型函数.
总结:
1,标.变量.变量等价于标::任何,类型安全的可包含任何值的类型.
2,标.变量.代数等价于标::变量,即并类型,是个限制类型的变量的简单包装.
3,标.变量与标::访问一样,提供访问函数来分发处理函数.
现在来说c++访问的问题.并看看d的编译时自省和生成代码的厉害.
c++问题:模板难看,元编程麻烦,工具少,实现访问者很难.用λ函数:

  元<类...Fs>
  构 重载;
  元<类 F0,类...O>
  构 重载<F0,O...>:F0,重载<O...>
  {
      重载(F0 f0,O...其余):F0(f0),重载<O...>(其余...){}
      用 F0::符号();
      用 重载<O...>::符号();
  };
  元<类 F0>
  构 重载<F0>:F0
  {
      重载(F0 f0):F0(f0){}
      用 F0::符号();
  };
  元<类...Fs>
  动 造访问者(Fs...fs)
  {
      中 重载<Fs...>(fs...);
  }

c++17可简化为:

  元<类...Ts>构 重载:Ts...{用 Ts::符号()...;};
  元<类...Ts>重载(Ts...)->重载<Ts...>;
  元<类...Fs>
  动 造访问者(Fs...fs)
  {
      中 重载<Fs...>(fs...);
  }

来自参考的示例,如何极致的使用访问:

  元<类...Ts>构 重载:Ts...{用 Ts::符号()...;};
  元<类...Ts>重载(Ts...)->重载<Ts...>;
  用 变量型=变量<整,长,双精,串>;
  向量<变量型>向量={10,15l,1.5,"你好"};
  对(动&v:向量){
      访问(重载{
          [](动 参){输出<<参<<' ';},
          [](双精 参){输出<<固定<<参<<' ';},
          [](常 串&参){输出<<引用(参)<<' ';},
      },v);
  }

d可以干得更好.实现造访问者.

导入 标.特征:形参;
构 变量访问者(函数...)
{
    函数 fs;
    本(函数 fs){本.fs=fs;}
    静 每一(i,函数;函数)//不同函数,不同重载
        动 调用操作(形参!函数 形参){中 fs[i](形参);}
}
动 造访问者(函数...)(函数 fs)
{
    中 变量访问者!函数(fs);
}

就完了,你服不服?.仅接收闭包/函数.基于签名来分发函数.
d是反样板语言,都是直接解决问题,访问以编译时函数列表为参数,不必创建新构,并写造访问者之类.
d更少选择,但更快,更安全,更轻松.用标.变量.访问,直接:

  代数!(串,整,极)v="[!串001]";
  v.访问!(
      (串 s)=>写行("[!串002]",s),
      (整    n)=>写行("[!串003]",n),
      (极   b)=>写行("[!串004]",b),
  );

比较c++:

  元<类...Ts>构 重载:Ts...{用 Ts::符号()...;};
  元<类...Ts>重载(Ts...)->重载<Ts...>;
  变量<串,整,极>v="[!串005]";
  访问(重载{
      [](常 串&s){输出<<s<<'\n';},
      [](整  n){输出<<n<<'\n';},
      [](极 b){输出<<b<<'\n';}
  },v);

d看起来与内置模式匹配语法类似.很强大.可读性:

//[!注释007]
  v.访问!((参){
    别名 T=不合格!(的型(参));//移除常/共享等
    静 如(是(T==串)){
        写行("[!串006]",参);
    }
    异 静 如(是(T==整)){
        写行("[!串007]",参);
    }
    异 静 如(是(T==极)){
        写行("[!串008]",参);
    }
  });

对比c++版,

vs.
  //C++
  访问([](动&参){
    用 T=退化型<推导(参)>;
    如 常式(是相同值<T,串>){
        打印格式("[!串009]",参.c串());
    }
    异 如 常式(是相同值<T,整>){
        打印格式("[!串010]",参);
    }
    异 如 常式(是相同值<T,极>){
        打印格式("[!串011]",参);
    }
  },v);

你选哪个?