// 对于入口类, 文件名需要与类名一致, 任何类型的首字母必须大写

class HxHello {
  public static function main() {
    trace("Hello, Haxe");
  }
}
//文件保存为: HxHello.hx, 我们直接在 --interp 下运行

//运行: > haxe -main HxHello --interp

// 再次强调 haxe 中所有类型名必须大写

Bool
Int
Float
// 函数空类型

Void
// 任意类型

Dynamic
// 复杂类型

String        // 不可变

var i:Int = 10;     // 标准的定义, 语句必须以 ; 结束

var s = "hello";    // 同样, 如果能明确类型


// 0. 运行时类型检测, 强制转换

trace(Std.is(1, Int));   // 使用 Std.is 方法 运行时检测类型

var ext:Dynamic;         // 假设我们有这样一个类型不明确的变量

var i = cast(ext, Int);  // 安全强制转换, 但如果转换不成功将抛出异常

var j:Int = cast ext;    // 非安全强转, 即直接将 ext 当成左边类型, 当然不保证后边运行时是否出错


// 1. haxe 中可为 null

var num:Null<Int> = null;
    // 在方法中有二种方式

    function foo(?a: Int, b:Null<Int>): Void;
    $type(foo); // a: Null<Int> -> ?b: Null<Int> -> Void


// 2. haxe 中没有委托, 只有变量类型的函数, 如:

var log: String->Void = Sys.println;
log("hello haxe");

// 3. try/catch

try{
    // do something

}catch(err: String){
    // err 类型可以是任意, 但这并不推荐使用，

    // 如果你编译到 c# 则可以把 err 的类型设置得与 c# 的一样

    // 如果是编译到其它平台则 err 类型为 Dynamic 则合合适

}catch(err: Dynamic){
    // 万能 err 类型

}
    // haxe 中没有 finally

class TheClass {
    public function new(){
    }
    // haxe 使用 new 方法作为构造函数

    // 为了避免混乱 haxe 在语言设计上没有方法重载.

    // 可选参数 or 函数式变体(enum) 能完成你想要的

    public static function main() {
        var inst = new TheClass();
    }
}

// interface 定义接口, 首字母必须大写

interface SayHello{
    function hi(s: String): Void;
}
interface Empty {}

class Base{
    public new(){}    // haxe 中, 如果想要 new 就必须定义构造函数,

                      // 但基类可以没有构造函数，由子类来创建也可以

}

// haxe 分别使用 implements 实现多接口

// 基类位置随意, 同样只允许单继承, 多接口

class Hi implements SayHello implements Empty extends Base{
    public function hi(s: String):Void {}
    public function new(){
        super(); // 如果子类有构造函数, 无论基类的构造函数是否有参数

                 // 都必须掉用父构造函数, 使用 super 关键字

    }
}

// haxe 中没有抽象基类的概念, 如果你不想一个类被 new ,

// 则不要定义或者定义成 private 形式的构建函数即可,

// haxe 中的 abstract 是一个魔法类, 是一个有些类似于 inline 的东西

// 由于使用 interface 来示例会和 c# 中的一样复杂

// 因此这里使用 typedef ,像 C 语言一样, haxe 中 typedef 只是个别名工具

typedef Length = {
    var length(default,null) : Int;
}
// haxe 中则省略了 where 这个语句

class Foo<T: Length> {
    public function new(v: T){
        trace(v.length);
    }
}

class Main{
    static function main(){
        var s = "hello haxe";
        tee(s);
        new Foo(s);
        var a = [1, 2, 3, 4];
        tee(s);
        new Foo(a);
        // String, Array 都符合 typedef 的描述带有 length 属性,

    }
    // 泛型可以直接放在静态方法名称后

    static function tee<T: Length>(v: T){
        trace(v.length);
    }
}
// haxe.Constraints 包中有一些编译器级别的约束定义,

// 比如约束某个类型必须为函数, 在 c# 中则有 "委拖" 来约束

var name = "haxe";
// 直接使用 "单引号" 的字符串, 变量则用 $ 作前缀, 如果复杂可以用大括号包围 ${}

// 若要输出 $ 字符, 重符一次即可如: $$

'[name: $name, len: ${name.length}]';

// 由于没有 char 类型, haxe 使用这种方式获得字符常量:

trace("A".code);  // 实际上展开后为: trace(65), 不可用于变量,

//

// 1. 最常见的 getter/setter, (外部可访问，但只能由定义处的类修改)

public var hi(default, null): String;
// 小括号左边为 getter 访问控制, 右边为 setter 的访问控制

// setter 的值还可以为 never, 表示不可修改


// 2. 第二种常见组合, (外部可访问及修改)

public var id(default, set):Int;
inline function set_id(v){// 声明一个 inline(推荐) 的函数，名字为 set_XXX

    // do somethins

    return id = v;        // 必须返回值， 由于会有 a = b = c = 0 这样的表达式.

}

// 3. 第三种常见组合,

public var bye(get, never): String;
inline function get_bye() {
                           // 当 getter 为 "get" 时只要 setter 为 "never" 或 "set"

    return "bye bye!";     // 这时 bye 是不存在的, 即不可以在 getter/setter 内部访问变量 bye.

}

// haxe 中没有 for(var i=0; i < 5; i += 1) 这种循环

// 1. for 循环, 0 ~ 4, 注: 这种循环不可以逆向循环

for(i in 0...5)
    // do something...


// 2. white 或 do...while 和正常一样

var a = [1, 2, 3, 4, 5];   // 类似于 JS 中的数组

for(n in a)                // 和循环一样使用 for

    trace(n);

// 1. 只要类型实现接口 Iterable<T> 或者包含有 iterator<T> 这个方法.

// 2. 或者包含有 hasNext():Bool 及 next():T 方法的类

// haxe 中的容器全已实现

enum Color {
    Red;    // 各值之间用 ; 号分隔

    Green;  // 值首字母必须大写

    Blue;   // 不可以像  cs 那样自定每个数值

}

class Main{
    static function main(){
        foo(Green);        // 可直接使用枚举的值

        trace(Hibernating);
    }
    static function foo(color: Color) {
        switch(color) {
        case Red:          // 可直接使用枚举的值

        case Green | Blue: // haxe 中的 switch 语句不需要写 break 语句

                           // 如果需要匹配多项使用 | 分隔即可

        }
    }
}

// haxe 中可自定义的则是抽象类

@:enum abstract MachineState(Int) to Int {
    var PowerOff = 0;      // 分号(;) 分隔

    var Running = 5;
    var Sleeping = 10;
    var Hibernating = Sleeping + 5;
}

// 替换这里的内容