新增多个测试文件，涵盖数组类型、函数指针数组及Lambda闭包的功能测试

Author: HelloAIXIAOJI

examples/debug_array_type_test.cn

@@ -0,0 +1,15 @@
+using lib <io>;
+using ns std;
+
+// 调试数组类型测试
+
+fn main() : int {
+    std::println("=== 调试数组类型测试 ===");
+    
+    // 测试基本数组类型
+    numbers : []int = [1, 2, 3];
+    std::println("基本数组测试通过");
+    
+    std::println("=== 测试完成 ===");
+    return 0;
+};

examples/debug_function_pointer_array_access_test.cn

@@ -0,0 +1,27 @@
+using lib <io>;
+using ns std;
+
+// 调试函数指针数组访问测试
+
+fn add(a : int, b : int) : int {
+    return a + b;
+};
+
+fn subtract(a : int, b : int) : int {
+    return a - b;
+};
+
+fn main() : int {
+    std::println("=== 调试函数指针数组访问测试 ===");
+    
+    // 测试函数指针数组初始化
+    operations : []*fn(int, int) : int = [add, subtract];
+    std::println("函数指针数组初始化成功");
+    
+    // 测试数组索引访问
+    firstOp : *fn(int, int) : int = operations[0];
+    std::println("数组索引访问成功");
+    
+    std::println("=== 测试完成 ===");
+    return 0;
+};

examples/debug_function_pointer_array_call_test.cn

@@ -0,0 +1,32 @@
+using lib <io>;
+using ns std;
+
+// 调试函数指针数组调用测试
+
+fn add(a : int, b : int) : int {
+    return a + b;
+};
+
+fn subtract(a : int, b : int) : int {
+    return a - b;
+};
+
+fn main() : int {
+    std::println("=== 调试函数指针数组调用测试 ===");
+    
+    // 测试函数指针数组初始化
+    operations : []*fn(int, int) : int = [add, subtract];
+    std::println("函数指针数组初始化成功");
+    
+    // 分步测试：先获取函数指针，再调用
+    firstOp : *fn(int, int) : int = operations[0];
+    result1 : int = firstOp(10, 5);
+    std::println("operations[0](10, 5) = " + result1);
+    
+    secondOp : *fn(int, int) : int = operations[1];
+    result2 : int = secondOp(10, 5);
+    std::println("operations[1](10, 5) = " + result2);
+    
+    std::println("=== 测试完成 ===");
+    return 0;
+};

examples/debug_function_pointer_array_declaration_test.cn

@@ -0,0 +1,19 @@
+using lib <io>;
+using ns std;
+
+// 调试函数指针数组声明测试
+
+fn add(a : int, b : int) : int {
+    return a + b;
+};
+
+fn main() : int {
+    std::println("=== 调试函数指针数组声明测试 ===");
+    
+    // 测试函数指针数组类型声明
+    operations : []*fn(int, int) : int;
+    std::println("函数指针数组声明成功");
+    
+    std::println("=== 测试完成 ===");
+    return 0;
+};

examples/debug_function_pointer_array_init_test.cn

@@ -0,0 +1,23 @@
+using lib <io>;
+using ns std;
+
+// 调试函数指针数组初始化测试
+
+fn add(a : int, b : int) : int {
+    return a + b;
+};
+
+fn subtract(a : int, b : int) : int {
+    return a - b;
+};
+
+fn main() : int {
+    std::println("=== 调试函数指针数组初始化测试 ===");
+    
+    // 测试函数指针数组初始化
+    operations : []*fn(int, int) : int = [add, subtract];
+    std::println("函数指针数组初始化成功");
+    
+    std::println("=== 测试完成 ===");
+    return 0;
+};

examples/lambda_closure_test.cn

@@ -0,0 +1,111 @@
+using lib <io>;
+using ns std;
+
+// Lambda函数闭包测试
+
+fn main() : int {
+    std::println("=== Lambda函数闭包测试 ===");
+    std::println("");
+    
+    // 测试1：基础闭包
+    testBasicClosure();
+    
+    // 测试2：多变量闭包
+    testMultiVariableClosure();
+    
+    // 测试3：嵌套作用域闭包
+    testNestedScopeClosure();
+    
+    // 测试4：闭包修改外部变量
+    testClosureModification();
+    
+    std::println("");
+    std::println("=== Lambda函数闭包测试完成 ===");
+    return 0;
+};
+
+fn testBasicClosure() : void {
+    std::println("1. 基础闭包测试");
+    std::println("===============");
+    
+    // 外部变量
+    multiplier : int = 3;
+    
+    // Lambda函数捕获外部变量
+    multiply : *fn(int) : int = (x => x * multiplier);
+    
+    result1 : int = multiply(5);
+    std::println("multiply(5) = " + result1 + " (应该是 15)");
+    
+    result2 : int = multiply(7);
+    std::println("multiply(7) = " + result2 + " (应该是 21)");
+    
+    std::println("");
+};
+
+fn testMultiVariableClosure() : void {
+    std::println("2. 多变量闭包测试");
+    std::println("=================");
+    
+    // 多个外部变量
+    base : int = 10;
+    offset : int = 5;
+    
+    // Lambda函数捕获多个外部变量
+    calculate : *fn(int) : int = (x => x + base + offset);
+    
+    result1 : int = calculate(3);
+    std::println("calculate(3) = " + result1 + " (应该是 18)");
+    
+    result2 : int = calculate(7);
+    std::println("calculate(7) = " + result2 + " (应该是 22)");
+    
+    std::println("");
+};
+
+fn testNestedScopeClosure() : void {
+    std::println("3. 嵌套作用域闭包测试");
+    std::println("=====================");
+    
+    // 外部作用域变量
+    outerVar : int = 100;
+    
+    // 创建返回Lambda的函数
+    createAdder : *fn(int) : *fn(int) : int = getAdderFunction();
+    
+    // 使用返回的Lambda
+    adder : *fn(int) : int = createAdder(outerVar);
+    result : int = adder(25);
+    std::println("adder(25) = " + result + " (应该是 125)");
+    
+    std::println("");
+};
+
+fn testClosureModification() : void {
+    std::println("4. 闭包修改外部变量测试");
+    std::println("=======================");
+    
+    // 外部变量
+    counter : int = 0;
+    
+    // Lambda函数使用外部变量（只读）
+    getCounter : *fn() : int = (() => counter);
+    
+    result1 : int = getCounter();
+    std::println("getCounter() = " + result1 + " (应该是 0)");
+    
+    // 修改外部变量
+    counter = 42;
+    
+    // 注意：由于闭包是在创建时捕获的，所以仍然是原来的值
+    result2 : int = getCounter();
+    std::println("getCounter() = " + result2 + " (仍然是 0，因为闭包捕获了创建时的值)");
+    
+    std::println("");
+};
+
+// 返回Lambda函数的函数
+fn getAdderFunction() : *fn(int) : *fn(int) : int {
+    // 这个函数返回一个Lambda，该Lambda接受一个参数并返回另一个Lambda
+    return (base => (x => x + base));
+};

examples/simple_function_pointer_array_test.cn

@@ -0,0 +1,29 @@
+using lib <io>;
+using ns std;
+
+// 简单函数指针数组测试
+
+fn add(a : int, b : int) : int {
+    return a + b;
+};
+
+fn subtract(a : int, b : int) : int {
+    return a - b;
+};
+
+fn main() : int {
+    std::println("=== 简单函数指针数组测试 ===");
+    
+    // 测试函数指针数组类型声明
+    operations : []*fn(int, int) : int = [add, subtract];
+    
+    // 测试数组索引访问
+    result1 : int = operations[0](10, 5);
+    std::println("operations[0](10, 5) = " + result1);
+    
+    result2 : int = operations[1](10, 5);
+    std::println("operations[1](10, 5) = " + result2);
+    
+    std::println("=== 测试完成 ===");
+    return 0;
+};

examples/simple_lambda_closure_test.cn

@@ -0,0 +1,58 @@
+using lib <io>;
+using ns std;
+
+// 简单Lambda函数闭包测试
+
+fn main() : int {
+    std::println("=== 简单Lambda函数闭包测试 ===");
+    std::println("");
+    
+    // 测试1：基础闭包
+    testBasicClosure();
+    
+    // 测试2：多变量闭包
+    testMultiVariableClosure();
+    
+    std::println("");
+    std::println("=== Lambda函数闭包测试完成 ===");
+    return 0;
+};
+
+fn testBasicClosure() : void {
+    std::println("1. 基础闭包测试");
+    std::println("===============");
+    
+    // 外部变量
+    multiplier : int = 3;
+    
+    // Lambda函数捕获外部变量
+    multiply : *fn(int) : int = (x => x * multiplier);
+    
+    result1 : int = multiply(5);
+    std::println("multiply(5) = " + result1 + " (应该是 15)");
+    
+    result2 : int = multiply(7);
+    std::println("multiply(7) = " + result2 + " (应该是 21)");
+    
+    std::println("");
+};
+
+fn testMultiVariableClosure() : void {
+    std::println("2. 多变量闭包测试");
+    std::println("=================");
+    
+    // 多个外部变量
+    base : int = 10;
+    offset : int = 5;
+    
+    // Lambda函数捕获多个外部变量
+    calculate : *fn(int) : int = (x => x + base + offset);
+    
+    result1 : int = calculate(3);
+    std::println("calculate(3) = " + result1 + " (应该是 18)");
+    
+    result2 : int = calculate(7);
+    std::println("calculate(7) = " + result2 + " (应该是 22)");
+    
+    std::println("");
+};