d插件与模板插件

本是古典何须时尚 2022-09-11 11:16 399阅读 0赞

[原文][Link 1]  
作者:亚当.  
`mixin()`带串,解析`串`为`ast`节点.  
`foo()`是类似`FunctionCall { args: [] }`这样的`ast`节点.而`if(foo) {}`类似`IfStatement { condition: Expression { arg: Variable { name: foo }, body : EmptyStatement }`.  
然后将解析后的`ast节点`粘贴到`mixin`出现位置.但要求`该串`在此`必须表示`完整元素,并且在`上下文`不会出错.`插件`必须单独是个`完整节点`.这样`int a = bmixin(c)`是不行的.  
粘贴后,编译器视为`原本`在那写的,因而在`相应上下文`中查找`引用名`.  
而`模板插件`,另一方面,在`ast`中仍然有个`查找名字`的`容器元素(a)`,`(a)`与编译器中的`构/类`类似,都有按`单元`在一起的`子声明`列表.  
最大区别是,可自动从`父上下文`中访问`模板插件`内容.它遵循类似`class Foo:Bar`中`子可见父`的`类继承`的规则,也可调用独立于`子覆盖`的.`super.method();`  
还有`重载和劫持`,[原理在此][Link 2]  
但为了避免`第三方代码`加新函数时`默默`改变程序行为,D要求`程序员`在`使用点`合并所有`重载函数集`,并且对`插件`重载`操作符`更严格,因为`操作符`有默认行为.

mixin template B(T) { 
       void foo(T t) { }
    }
    class A { 
       mixin B!int;
       mixin B!string;
    }

上面是普通函数,现在加个`重载`:

mixin template B(T) { 
       void foo(T t) { }
    }
    class A { 
       mixin B!int;
       mixin B!string;
    
       void foo(float t) { }
    }
    //"错误:不能用(串)参数类型调用poi.A.foo(float t)",

它会失败,为什么不用`插件`呢.这是`模板插件`的规则,编译器把它们视为`一个单元`,而不仅是一组粘贴的声明.查看`模板插件`前,先用`外部对象(这里为A)`的`名字`.  
这里,他看见`A.foo`了,就不再查找`模板插件`里面了.这对`覆盖`模板插件`特定内容`很有用,但`加重载`就麻烦了.解决方法是在`顶级`用`alias`告诉`编译器`去查找`模板插件`里面.先给插件`一个名字`,然后显式转发`该名字`给它.

mixin template B(T) { 
       void foo(T t) { }
    }
    class A { 
       mixin B!int bint; // 加个名字
       mixin B!string bstring; //同上 
    
       alias foo = bint.foo; // 转发
       alias foo = bstring.foo; //转发
    
       void foo(float t) { }
    }
    
    void main() { 
        A a = new A;
        a.foo("a");
    }

现在对`float,int和string`都管用,但有点`违背`了模板`mixin`加`重载`的目的.你可在`A`中放个`顶级模板函数`,然后就转发至`插件`了.只是需要不同名来`注册`.  
`D`特别挑剔重载运算符,它们总是`覆盖`正常行为,你要在`顶级`明确说明.

import std.stdio;
    import std.string : format;
    
    mixin template define_opbinary(alias other_type) { 
        //重命名为opBinaryHelper,因为不直接用它
        Matrix opBinaryHelper(string op)(Matrix!(other_type) other) { 
            if(op == "*") { 
                Matrix result;
                if(this.columns == other.rows) { 
                    result = new Matrix(this.rows, other.columns);
                } else { 
                    result = new Matrix(0,0);
                }
                return result;
            } else assert(0, "Operator "~op~" not implemented");
        }
    }
    
    
    class Matrix(T) { 
        T[][] storage;
        size_t rows;
        size_t columns;
        const string type = T.stringof;
    
        this(size_t rows, size_t columns) { 
            this.storage = new T[][](rows, columns);
            this.rows = rows;
            this.columns = columns;
        }
    
        void opIndexAssign(T value, size_t row, size_t column) { 
            storage[row][column] = value;
        }
    
        mixin define_opbinary!(int);
        mixin define_opbinary!(uint);
    
        // 现在我们做调用`帮助器`的顶级`opBinary`
        auto opBinary(string op, M)(M rhs) { 
            return this.opBinaryHelper!(op)(rhs);
        }
    }
    
    
    
    void main()
    { 
        Matrix!int mymat = new Matrix!(int)(2, 2);
        mymat[0,0] = 5;
        writeln(mymat.type);
    
        Matrix!uint mymat2 = new Matrix!(uint)(2, 2);
        writeln(mymat2.type);
        auto result = mymat * mymat2;
        writeln("result.rows=", result.rows);
        writeln("result.columns=", result.columns);
        auto result2 = mymat2 * mymat;
        writeln("result.type=",result.type);
        writeln("result2.type=",result2.type);
    }

实际上只有两个更改,如果加`重载`,得利用上面`别名`方法.这里在`if`处分发.它自动`合并`帮助器.  
而`串插件`不需要这些,只是`复制/粘贴`.  
`模板插件`有自己的`域`来允许选择性覆盖等,这样更严格.

//`MatrixType`:接受任何矩阵,并从中提取其他类型的`矩类型`
    //写代表类型模式,用逗号分隔占位符.
    auto opBinary(string op, MatrixType : Matrix!Other_Type, Other_Type)(MatrixType other) { 
        alias PromotedType = typeof(T.init * Other_Type.init);
    //让编译器来提升,我们只获取两种`类型乘积`的类型,只关注类型,由于不能`乘类型`,所以`乘值`.
        static if(op == "*") { 
            Matrix!PromotedType result;
            //编译时参数,可用`静如`.更灵活,如可在每个操作中改返回值.
            if(this.columns == other.rows) { 
                result = new Matrix!PromotedType(this.rows, other.columns);
            } else { 
                result = new Matrix!PromotedType(0,0);
            }
            return result;
        } else static assert(0, "Operator "~op~" not implemented");
    }

现在`opBinary`可处理所有情况,不需要列举类型,不需要`插件`.除非需要用`子类`来`虚覆盖`.可用`static foreach`.  
`模板`中`模式`是`d`中更高级的`D编译时反射`中概念.  
[另一篇参考][Link 3]  
可见`模板插件`类似`自带域的插入构`.有时非常方便.

[Link 1]: https://stackoverflow.com/questions/57711357/understanding-mixins-vs-mixin-templates/57712459#57712459
[Link 2]: https://dlang.org/articles/hijack.html
[Link 3]: http://dpldocs.info/this-week-in-d/Blog.Posted_2020_01_20.html