Haxe3新增特性：抽象类型 -- Abstract Types

官网文档链接在此：http://haxe.org/manual/abstracts

还没有在项目中具体使用Haxe3，先参考英文文档说一下自己的理解：

抽象类型主要有两种应用方式：

1. 定义基本数值类型的隐式转换，如Int, Float, Void等，这种方式主要是Haxe核心数据部分在使用，一般开发中可能很少直接遇到；

2. 定义一个不透明的外包装类型（显式定义，显式使用的新类型），用以包装另外一种类型，并在外包装类型上定义针对被包装类型的隐式转换，和操作符重载。

第二种应用方式非常强大，比如在上面官网文档的例子中，定义了一个StringSplitter抽象类型，用以把字符串经过隐式转换拆成字符数组（实际上是单字符组成的字符串数组），而且，因为Haxe3中允许内联构造函数，以及抽象类型允许对this直接赋值，因此最终生成的代码极其简洁，完全没有对象创建、函数调用等导致的效率损失。

抽象类型的定义：

abstract StringSplitter(Array<String>) {
    inline function new(a:Array<String>)
        this = a
        
    @:from static public inline function fromString(s:String) {
        return new StringSplitter(s.split(""));
    }
}

抽象类型的使用：

class Main {
    static function main() {
        var splitter:StringSplitter = "Hello";
        trace(splitter); // [H,e,l,l,o]
    }
}

实际生成的Haxe代码：

 // dump/Main.dump
class Main{
    static main(method) : Void -> Void

     = function() = {
        var splitter = cast "Hello".split("");
        haxe.Log.trace(splitter,{fileName : "Main.hx",lineNumber : 13,className : "Main",methodName : "main"});
    };

}

另外值得大书特书的就是操作符重载机制了，原来就有一些大牛使用Haxe2的宏macro机制实现了运算符重载，现在Haxe3带来了官方的，更优雅，更强大的运算符重载机制：

abstract MyInt(Int) from Int to Int {
    // MyInt + MyInt can be used as is, and returns a MyInt
    @:op(A + B) static public function add(lhs:MyInt, rhs:MyInt):MyInt;

    @:commutative @:op(A * B) static public function repeat(lhs:MyInt, rhs:String):String {
        var s:StringBuf = new StringBuf();
        for (i in 0...lhs)
            s.add(rhs);
        return s.toString();
    }
}

也可以重载数组访问符即中括号：

abstract MyReflect({}) from {} {
    @:arrayAccess public inline function arrayAccess(key:String):Dynamic {
        return Reflect.field(this, key);
    }
    
    @:arrayAccess public inline function arrayWrite<T>(key:String, value:T):T {
        Reflect.setField(this, key, value);
        return value;
    }
}

特别值得指出的是，抽象类型应该是用类似宏的机制实现的，也就是说，抽象类型是纯编译期概念，是用来定义其被包装类型的操作的，它并不实际存在于运行期。因此你在运行期用反射是无法找到或使用抽象类型的。