d的一些小技巧

c++的缺点是什么,就是元编程太麻烦.
c++必须要有根本性的改变,才能让元编程更方便.虽然c++20已经不错了.
d自定义打印格式
传统:

struct S
{
    ... // my sooper sekret data here!
    string toString() const pure @safe
    {
        // 最小化构造串
        auto app = appender!string();
        ... //数据转为串
        return app.data;
    }                                                                                        
}

void main()
{
    auto s = S();
    ... //处理s
    writeln(s);
}

变化

struct S
{
    void toString(scope void delegate(const(char)[]) sink,
                  FormatSpec!char fmt) const
    {//其实就是加几个模板参数.
        switch(fmt.spec)
        {
            // Look, ma! I invented my own format specs!
            case 'i':
                // output first format to sink
                break;
            case 'j':
                // output second format to sink
                break;
            case 's':
                // output boring default string format
                break;
            default:
                throw new Exception("Unknown format specifier: %" ~                                fmt.spec);
        }
    }
}

注意:使用FormatSpec!char作为格式化为UTF-8字符串的最常见情况。如果您还希望以16位wstring或32位dstring实现格式化，则必须实现以FormatSpec!wchar或FormatSpec!dchar作为参数的toString函数

更好的C:

import core.stdc.stdio;

extern(C):

int main()
{
    printf("1 + 1 = %d!\n", 1 + 1);
    return 0;
}

$ dmd -betterC example.d
$ ./example
1 + 1 = 2!

将枚举类型的名称作为数组:

enum State
{
    stopped,
    starting,
    running,
    stopping,
}

string[] state_names = [__traits(allMembers, State)];

一篇文章对比c++与d的元编程:在此
什么是编译时查找.编译时查找已知的串,就是这个串,我编译时就已经知道了,类似手写串.而不是运行时才知道.因而这时根本就没必要再进行运行时查找了.就相当于串作为模板的参数,因为串已知.所以模板<串>就是个固定已知的函数了,没必要再查找这个函数了.直接调用即可.
直接看d语言的实现.c++如果不进行一番大的改造,是不能优雅实现的,借助于hana,但仍不是很漂亮.因为反射及很多还未实现.
D的元编程为什么厉害,就是把一切符号当作占位符.最后填占位符就是了.其实现代的宏编程也是这个玩意.最后都是AST(语法树).

void main() {
  EventSystem!("foo", "bar", "baz") events;//编译时字符串与常规串一样.

  events.on!"foo"(() { writeln("foo triggered!"); });
  events.on!"foo"(() { writeln("foo again!"); });
  events.on!"bar"(() { writeln("bar triggered!"); });
  events.on!"baz"(() { writeln("baz triggered!"); });
  // events.on!"unknown"(() {}); // compile error!

  events.trigger!"foo";
  events.trigger!"baz";
  events.trigger("bar"); // overload for dynamic dispatch
  // events.trigger!"unknown"; // compile error!
}
//接着
 void on(string event)(Callback c) {
    enum index = staticIndexOf!(event, events);//枚是关键
    static assert(index >= 0,
      "trying to add a callback to an unknown event: " ~ event);

    callbacks_[index] ~= c;
  }

  void trigger(string event)() {
    enum index = staticIndexOf!(event, events);//枚
    static assert(index >= 0,
      "trying to trigger an unknown event: " ~ event);

    foreach (callback; callbacks_[index])
      callback();
  }

d有两个编译时阶段:一,ast树,二,ctfe.前面有文章.

void trigger(string event) {
    foreach (i, e; events) {
      if (event == e) {
        foreach (c; callbacks_[i])
          c();
        return;
      }
    }
    assert(false, "trying to trigger an unknown event: " ~ event);
  }  
 struct Entity(arg...)
  if (arg.length == 1)
{
  static if (is(arg[0])) {
    alias Type = arg[0];
  } else static if (is(typeof(arg[0]) T)) {
    alias Type = T;
    enum value = arg[0];
  }
}
这样来用Entity!"foo"()来创建对象Entity!double(),简化:
enum c(arg...) = Entity!arg();

static assert(is(c!int.Type == int));
static assert(is(c!"foo".Type == string));
static assert(c!"foo".value == "foo");
static assert(c!42.value == 42);

下面:
我们需要一种可以存储不同类型的值的东西（例如std.typecons.Tuple，其中键是类型或编译时值，其实例化如下：

struct Bar {}
Map!(//存储不同类型的键与值.
  "foo",  int,           // string "foo" maps to a value of type int
  Bar,    string,        // type Bar maps to a value of type string
  "한",   string[]) map; // string "한" maps to a value of type string[]
我们需要将交织键和值类型分开，并声明值本身的存储：

struct Map(spec...) {//这就是个把整个类型序化,然后对这个类型序列求值.
  alias Keys = Even!spec;//偶数项,编译时求类型值
  alias Values = Odd!spec;//所有奇数项类型.
  Values values;
实现见下:

template Stride(size_t first, size_t stride, A...) {
  static if (A.length > first)
    alias Stride = AliasSeq!(A[first], Stride!(stride, stride, A[first .. $]));//这里,又是个静态递归.stride为步数.估计就是递归取第几项,相当求所有余3等等的序列.只不过是静态编译时求值.
  else
    alias Stride = AliasSeq!();//别名序列.序列这个玩意儿还是不错
}

alias Odd(A...) = Stride!(1, 2, A);//这个其实就是个索引,2%1的
alias Even(A...) = Stride!(0, 2, A);//第2项的第0项,2%0的项.与我前面

使用:
  // 初化
  auto map =
    Map!("foo", int, Bar, string, "한", string[])(
      42, "baz", ["lorem", "ipsum", "dolor"]);

  //迭代键
  foreach (K; map.Keys)
    writeln(K.stringof);

  //迭代值类型
  foreach (V; map.Values)
    writeln(V.stringof);

  // 迭代值
  foreach (value; map.values)
    writeln(value);

重载in.最后了,坚持下去.

static bool opBinaryRight(string op, Key...)(Entity!Key key)
    if (op == "in")
  {//静仅取决于编译时,二分右,
    enum index = staticIndexOf!(Key, Keys);//即某个类型是否在类型序列中.
    return index >= 0;
  }
   static assert(c!"foo" in map);
  static assert(c!Bar in map);
  static assert(c!"한" in map);
  static assert(c!42 !in map);
   private template IndexOf(alias Key) {
    enum IndexOf = staticIndexOf!(Key, Keys);
    static assert(IndexOf >= 0,
      "trying to access a nonexistent key: " ~ Key);
  }//包装.
   auto opIndex(Key...)(Entity!Key key) const {
    return values[IndexOf!Key];
  }

  auto opIndexAssign(T, Key...)(auto ref T value, Entity!Key key) {
    return values[IndexOf!Key] = value;
  }

  auto opIndexOpAssign(string op, T, Key...)(auto ref T value, Entity!Key key) {
    return mixin(`values[IndexOf!Key] ` ~ op ~ `= value`);
  }//映射的键索引.类似 映[键]
测试:
 //编译时查找键的类型/值,运行时比较
  map[c!"foo"] = 42;        // opIndexAssign
  map[c!Bar] = "baz";
  map[c!"한"] ~= "lorem";    // opIndexOpAssign!"~"
  map[c!"한"] ~= "ipsum";
  map[c!"한"] ~= "dolor";

//同样
  assert(map[c!"foo"] == 42);  // opIndex
  assert(map[c!Bar] == "baz");
  assert(map[c!"한"] == ["lorem", "ipsum", "dolor"]);