新增泛型功能测试示例代码，涵盖泛型函数、类、枚举、接口及带约束的泛型函数，增强了泛型系统的测试覆盖。

Author: HelloAIXIAOJI

example/test_generics.cn

@@ -0,0 +1,76 @@
+// 测试泛型功能的示例代码
+
+// 泛型函数示例
+fn max<T>(a: T, b: T) : T {
+    if (a > b) {
+        return a;
+    } else {
+        return b;
+    };
+};
+
+// 泛型类示例
+class Container<T> {
+    private T value;
+    
+    constructor(T initial_value) {
+        this.value = initial_value;
+    };
+    
+    fn get<T>() : T {
+        return this.value;
+    };
+    
+    fn set<T>(T new_value) : void {
+        this.value = new_value;
+    };
+};
+
+// 泛型枚举示例
+enum Option<T> {
+    Some(T value),
+    None
+};
+
+// 泛型接口示例
+interface Comparable<T> {
+    fn compare(T other) : int;
+};
+
+// 使用泛型的函数
+fn test_generics() : void {
+    // 测试泛型函数调用
+    let int_max = max<int>(10, 20);
+    let float_max = max<float>(3.14, 2.71);
+    
+    // 测试泛型对象创建
+    let int_container = new Container<int>(42);
+    let string_container = new Container<string>("Hello");
+    
+    // 测试泛型方法调用
+    let value = int_container.get<int>();
+    int_container.set<int>(100);
+    
+    // 测试泛型枚举
+    let some_value = Option<int>::Some(42);
+    let none_value = Option<int>::None;
+    
+    // 测试类型转换
+    let converted = value as float;
+    
+    // 测试类型查询
+    let type_info = typeof(value);
+    
+    print("泛型测试完成");
+};
+
+// 带约束的泛型函数
+fn sort<T: Comparable<T>>(array<T> items) : array<T> where T: Copy {
+    // 简单的排序实现
+    return items;
+};
+
+// 主函数
+fn main() : void {
+    test_generics();
+};

example/test_strong_typing.cn

@@ -0,0 +1,51 @@
+// 强类型系统测试
+
+// 测试显式类型声明
+fn test_explicit_types() : void {
+    // 显式类型声明 - 强类型语言的标准做法
+    x: int = 42;
+    y: float = 3.14;
+    z: string = "Hello";
+    b: bool = true;
+    l: long = 1000000;
+    
+    // 这些都是安全的，因为类型明确
+};
+
+// 测试自动类型推断
+fn test_auto_inference() : void {
+    // 自动类型推断 - 编译器推断类型，但仍然是强类型
+    a: auto = 100;      // 推断为 int
+    b: auto = 2.71;     // 推断为 float
+    c: auto = "World";  // 推断为 string
+    d: auto = false;    // 推断为 bool
+    e: auto = 999999;   // 推断为 int (或 long，取决于实现)
+    
+    // 复杂表达式的类型推断
+    sum: auto = a + 50;         // int + int = int
+    product: auto = b * 2.0;    // float * float = float
+    concat: auto = c + "!";     // string + string = string
+};
+
+// 测试类型安全 - 不允许隐式转换
+fn test_type_safety() : void {
+    x: int = 42;
+    y: float = 3.14;
+    
+    // 在强类型语言中，这些操作需要显式转换
+    // 不能直接混合不同类型的运算
+    
+    // 正确的做法是使用显式转换（如果语法支持）
+    // result: auto = x + (y as int);  // 需要显式转换
+    
+    // 或者保持类型一致
+    int_result: auto = x + 10;      // int + int = int
+    float_result: auto = y + 1.0;   // float + float = float
+};
+
+// 主函数
+fn main() : void {
+    test_explicit_types();
+    test_auto_inference();
+    test_type_safety();
+};