Ray 语法参考
====================

`Ray` 其实就是加上 Suika3 API 的 `Noct` 程式语言。

## 指派

Noct 的变数是动态型别，不需要明确宣告。指派运运算元（`=`）用来建立并设定变数值。

如下例所示，Noct 支援多种资料型别，包括整数、浮点数与字串。变数在执行过程中可以随时重新指派成不同型别。

```
func main() {
    var a = 123;
    print(a);

    var b = 1.0;
    print(b);

    var c = "string";
    print(c);
}
```

## 全域变数

全域变数可以在函式中定义，不能在函式外定义。

```
func main() {
    globalVariable = 123;
    print(globalVariable);
}
```

## 区域变数

使用 `var` 关键字可以把变数宣告为区域变数。
如果不使用 `var` 宣告，直接对变数赋值就会建立全域变数。

```
func main() {
    var a = 123;
    print(a);
}
```

## 阵列

阵列是按索引存取的有序值集合。阵列支援 `for` 回圈迭代，因此可以直接逐一走访每个值。

```
func main() {
    var array = [0, 1, 2];
    for (value in array) {
        print(value);
    }
}
```

阵列可以同时容纳不同型别的值，反映其动态型别系统。

```
func main() {
    var array = [123, "string"];
}
```

语言提供内建函式 `push()`，可以把元素加到阵列尾端。另外，`pop()` 会移除最后一个元素。

```
func main() {
    var array = []
    array->push(0);
    array->push(1);
    array->push(2);

    var last = array->pop();

    print("Length = " + array.length);
}
```

## 字典

字典会储存键值对，类似其他语言中的杂凑表或物件。它使用大括号定义，键值对以冒号分隔。字典支援迭代，且可以同时取得键与值。

```
func main() {
    var dict = {key1: "value1", key2: "value2"};
    for (key, value in dict) {
        print("key = " + key);
        print("value = " + value);
    }

    print("Length = " + dict.length);
}
```

字典也可以用一步完成的方式建立。赋值可以是使用 `[]` 的阵列式写法，或使用 `.` 的物件式写法。

```
func main() {
    var dict = {};
    dict["key1"] = "value1";
    dict.key2 = "value2";
}
```

内建函式 `remove()` 可以根据键删除专案。

```
func main() {
    var dict = {key1: "value1", key2: "value2"};
    remove(dict, "key1");
}
```

## for 回圈

for 回圈提供简洁语法，可用来走访范围、阵列与字典等序列。

范围语法（使用 `..` 运运算元）会建立一个迭代器，产生从起始值到结束值前一个数字的值。

```
func main() {
    for (i in 0..10) {
        print(i);
    }
}
```

for 回圈也可以直接迭代阵列与其他集合型别。

阵列可以使用 for-value 语法迭代。

```
func main() {
    array = [0, 1, 2];
    for (value in array) {
        print(value);
    }
}
```

字典可以使用 for-key-value 语法迭代。

```
func main() {
    var dict = {key1: "value1", key2: "value2"};
    for (key, value in dict) {
        print(key + "=" + value);
    }
}
```

## while 回圈

while 回圈提供传统的迭代机制，只要指定条件维持为真就会持续执行。与专为集合迭代设计的 for 回圈不同，while 回圈更有弹性，可用于实作各种无法事先知道迭代次数的演演算法。以下范例示范一个基本计数器，从 0 递增到 9。

```
func main() {
    var i = 0;
    while (i < 10) {
        print(i);
        i = i + 1;
    }
}
```

## if 与 else 区块

控制流程可根据运算后的表示式进行条件式执行。if-else 结构使用熟悉的语法，条件会依序进行判断。

```
func main() {
    var a = readint();
    if (a == 0) {
        print("0");
    } else if (a == 1) {
        print("1");
    } else {
        print("other");
    }
}
```

## Lambda 函式

函式在这个语言中是第一级物件。匿名函式，也就是 `lambda` 表示式，可以让你在没有名称的情况下建立函式。

```
func main() {
    var f = (a, b) => { return a + b; }
    print(f(1, 2));
}
```

Lambda 函式在编译过程中只会被转成具名函式。因此，它们无法捕捉外层函式中宣告的变数。

## 递增/递减（+=, -=, ++, --）

```
func main() {
    var a = 123;
    a += 321;
    a++;

    var b = 123;
    b -= 321;
    b--;
}
```

`++` 与 `--` 只支援作为独立叙述（`a++;`、`b--;`）。
为了避免复杂的副作用，不允许把它们放在表示式内使用。

## Noct 的 OOP

Noct 的物件导向模型是一种轻量级、基于原型的 OOP 变体。

- 类别本质上就是字典样板
- 继承与实体化是透过字典合并实现
- 没有原型链，而且修改类别不会影响既有例项

这种设计把字典视为第一级物件，作者称之为基于字典的 OOP（D-OOP）。

```
func main() {
    // 基底类别定义。（类别其实就是字典。）
    Animal = class {
        name: "Animal",
        cry: (this) => {
        }
    };

    // 子类别定义。（其实只是字典合并。）
    Cat = extend Animal {
        name: "Cat",
        voice: "meow",
        cry: (this) => {
            print(this.name + " cries like " + this.voice);
        }
    };

    // 实体化。（其实只是字典合并。）
    var myCat = new Cat {
        voice: "neee"
    };

    // this-call 使用 -> () 语法。（等同于 myCat.cry(myCat)）
    myCat->cry();
}
```

---

## 内建函式

### int()

```
var i = int(1.23);
```

### float()

```
var f = float(123);
```

### newArray()

```
var array = newArray(10);
```

### push()

```
var array = [1, 2, 3];
array->push(4);
```

### pop()

```
var array = [1, 2, 3];
var last = array->pop();
```

### resize()

```
var array = [1, 2, 3];
array->resize(2);
```

### charCount()

```
var s = "ABC汉语";
var l = s->charCount();
```

### charAt()

```
var s = "ABC汉语";
for (i in 0 .. s.length) {
   var c = s->charAt(i);
   print(c);
}
```

### substring()

```
var s1 = "ABCDEFG";
var s2 = s1.substring(0, 3); // 从字元 0 起算，共三个字元
var s3 = s1.substring(2, -1); // 从字元 1 起，直到结尾
}
```

### unset()

```
var dic = {key1: "ABC"};
dic->unset("key1");
```

---

## 数学 API

## Math

### abs()

```
var a = abs(x);
```

### random()

```
var r = random(); // 0 .. 1.0
```

### Math.sin()

```
var y = sin(x);
```

### Math.cos()

```
var y = cos(x);
```

### Math.tan()

```
var y = tan(x);
```
