Tuan 编程语言：完整规范与实现 (双语版)

 

Tuan Programming Language: Complete Specification & Implementation (Bilingual)

 

---

 

🎯 一、Tuan语言设计哲学 / Tuan Language Design Philosophy

 

核心理念 / Core Philosophy

 

```

Tuan（图安） = 图灵完备 + 安全 + 实用

Turing Complete + Safe + Practical

 

设计目标：让编程回归本质，让表达更自然

Design Goal: Return to the essence of programming, make expression more natural

```

 

设计原则 / Design Principles

 

1. 简约性：语法简洁，学习曲线平缓

      Simplicity: Concise syntax, gentle learning curve

2. 实用性：解决实际问题，生产力优先

      Practicality: Solve real problems, productivity first

3. 安全性：类型安全，内存安全，并发安全

      Safety: Type safety, memory safety, concurrency safety

4. 可扩展性：易于扩展，支持多种编程范式

      Extensibility: Easy to extend, supports multiple paradigms

5. 跨平台：一次编写，到处运行

      Cross-platform: Write once, run anywhere

 

---

 

📝 二、Tuan基础语法 / Tuan Basic Syntax

 

Hello, Tuan!

 

```tuan

// 单行注释 / Single-line comment

/*

   多行注释

   Multi-line comment

   This is Tuan's first program

*/

 

// 输出语句 / Print statement

输出("你好，Tuan世界！") // Output to console / 控制台输出

print("Hello, Tuan World!") // English alias

 

// 变量定义 / Variable definition

名字 = "张三"

name = "Zhang San"

年龄 = 25

age = 25

分数 = 95.5

score = 95.5

是否通过 = 真

is_passed = true

 

// 同时定义多个变量 / Define multiple variables simultaneously

(姓名, 年龄, 城市) = ("李四", 30, "北京")

(name, age, city) = ("Li Si", 30, "Beijing")

 

// 类型注解（可选）/ Type annotations (optional)

学号: 整数 = 2024001

student_id: int = 2024001

成绩: 小数 = 88.5

grade: float = 88.5

```

 

基本数据类型 / Basic Data Types

 

```tuan

// 数值类型 / Numeric types

整数 = 42 // 整数 / integer

小数 = 3.14159 // 浮点数 / floating-point

长整数 = 1000000000L // 长整数 / long integer

复数 = 3 + 4i // 复数 / complex number

 

// 文本类型 / Text types

字符串 = "Tuan编程语言"

text = "Tuan Programming Language"

字符 = 'A'

character = 'A'

多行文本 = """

   这是多行

   文本字符串

"""

multiline_text = """

   This is a multi-line

   text string

"""

 

// 布尔类型 / Boolean type

是 = 真

yes = true

否 = 假

no = false

 

// 空值类型 / Null type

空值 = 空

null_value = null

 

// 范围类型 / Range type

范围 = 1..10 // 1到10（包含10）/ 1 to 10 (inclusive)

range = 1..10

半开范围 = 1..<10 // 1到9 / 1 to 9 (exclusive)

half_open = 1..<10

```

 

运算符 / Operators

 

```tuan

// 算术运算符 / Arithmetic operators

加 = 10 + 5 // 15 / addition

减 = 10 - 5 // 5 / subtraction

乘 = 10 * 5 // 50 / multiplication

除 = 10 / 3 // 3.333... / division

整除 = 10 // 3 // 3 / integer division

取余 = 10 % 3 // 1 / modulo

幂 = 2 ** 3 // 8 / exponentiation

 

// 比较运算符 / Comparison operators

等于 = 5 == 5 // 真 / equal to

不等于 = 5 != 3 // 真 / not equal to

大于 = 10 > 5 // 真 / greater than

小于 = 3 < 5 // 真 / less than

大于等于 = 5 >= 5 // 真 / greater than or equal to

小于等于 = 4 <= 5 // 真 / less than or equal to

 

// 逻辑运算符 / Logical operators

与 = 真 && 假 // 假 / and

或 = 真 || 假 // 真 / or

非 = !真 // 假 / not

 

// 位运算符 / Bitwise operators

位与 = 0b1010 & 0b1100 // 0b1000 / bitwise AND

位或 = 0b1010 | 0b1100 // 0b1110 / bitwise OR

异或 = 0b1010 ^ 0b1100 // 0b0110 / bitwise XOR

左移 = 0b1010 << 2 // 0b101000 / left shift

右移 = 0b1010 >> 1 // 0b0101 / right shift

```

 

---

 

🏗️ 三、Tuan数据结构 / Tuan Data Structures

 

数组（固定大小）/ Array (fixed size)

 

```tuan

// 数组定义 / Array definition

数字数组: 整数[5] = [1, 2, 3, 4, 5]

number_array: int[5] = [1, 2, 3, 4, 5]

字符串数组 = ["苹果", "香蕉", "橙子"]

string_array = ["apple", "banana", "orange"]

 

// 数组操作 / Array operations

长度 = 数字数组.长度() // 5 / length

第一个元素 = 数字数组[0] // 1 / first element

最后元素 = 数字数组[-1] // 5 / last element

子数组 = 数字数组[1..3] // [2, 3, 4] / subarray

 

// 多维数组 / Multidimensional array

矩阵: 整数[3][3] = [

    [1, 2, 3],

    [4, 5, 6],

    [7, 8, 9]

]

matrix: int[3][3] = [

    [1, 2, 3],

    [4, 5, 6],

    [7, 8, 9]

]

 

元素 = 矩阵[1][2] // 6 / element

```

 

列表（动态数组）/ List (dynamic array)

 

```tuan

// 列表定义 / List definition

成绩列表 = 列表<小数>() // 空列表 / empty list

grade_list = list<float>()

商品列表 = 列表<字符串>(["电脑", "手机", "平板"])

product_list = list<string>(["computer", "phone", "tablet"])

 

// 列表操作 / List operations

商品列表.添加("耳机") // 添加元素 / add element

product_list.append("headphones")

商品列表.插入(1, "键盘") // 在位置1插入 / insert at position 1

product_list.insert(1, "keyboard")

商品列表.移除("手机") // 移除元素 / remove element

product_list.remove("phone")

是否包含 = 商品列表.包含("电脑") // 真 / contains

contains = product_list.contains("computer")

 

// 列表推导式 / List comprehension

平方列表 = [x ** 2 对于 x 在 1..10] // [1, 4, 9, ..., 100]

squares = [x ** 2 for x in 1..10]

偶数列表 = [x 对于 x 在 1..20 如果 x % 2 == 0]

evens = [x for x in 1..20 if x % 2 == 0]

```

 

字典（键值对）/ Dictionary (key-value pairs)

 

```tuan

// 字典定义 / Dictionary definition

学生信息 = 字典<字符串, 任意类型>()

student_info = dict<string, any>()

学生成绩 = {

    "张三": 95,

    "李四": 88,

    "王五": 92

}

student_grades = {

    "Zhang San": 95,

    "Li Si": 88,

    "Wang Wu": 92

}

 

// 字典操作 / Dictionary operations

成绩 = 学生成绩["张三"] // 95 / get value

grade = student_grades["Zhang San"]

学生成绩["赵六"] = 90 // 添加/更新 / add/update

student_grades["Zhao Liu"] = 90

是否包含键 = 学生成绩.包含键("李四") // 真 / contains key

has_key = student_grades.has_key("Li Si")

所有键 = 学生成绩.键() // ["张三", "李四", "王五"]

all_keys = student_grades.keys()

所有值 = 学生成绩.值() // [95, 88, 92]

all_values = student_grades.values()

 

// 字典遍历 / Dictionary iteration

对于 (姓名, 成绩) 在 学生成绩.条目() {

    输出("姓名：{姓名}，成绩：{成绩}")

}

for (name, grade) in student_grades.entries() {

    print("Name: {name}, Grade: {grade}")

}

```

 

集合 / Set

 

```tuan

// 集合定义 / Set definition

数字集合 = 集合<整数>([1, 2, 3, 3, 2]) // {1, 2, 3}

number_set = set<int>([1, 2, 3, 3, 2])

字符串集合 = 集合<字符串>(["A", "B", "C"])

string_set = set<string>(["A", "B", "C"])

 

// 集合操作 / Set operations

数字集合.添加(4) // 添加元素 / add element

number_set.add(4)

数字集合.移除(2) // 移除元素 / remove element

number_set.remove(2)

并集 = 集合1 | 集合2 // 并集 / union

union = set1 | set2

交集 = 集合1 & 集合2 // 交集 / intersection

intersection = set1 & set2

差集 = 集合1 - 集合2 // 差集 / difference

difference = set1 - set2

```

 

元组 / Tuple

 

```tuan

// 元组定义 / Tuple definition

坐标 = (10.5, 20.3) // 二元组 / 2-tuple

coordinates = (10.5, 20.3)

学生 = ("张三", 20, "计算机") // 三元组 / 3-tuple

student = ("Zhang San", 20, "Computer Science")

 

// 元组解构 / Tuple destructuring

(x, y) = 坐标

(姓名, 年龄, 专业) = 学生

(name, age, major) = student

 

// 元组访问 / Tuple access

横坐标 = 坐标[0] // 10.5 / x-coordinate

纵坐标 = 坐标[1] // 20.3 / y-coordinate

```

 

---

 

🔄 四、控制流程 / Control Flow

 

条件判断 / Conditional Statements

 

```tuan

// 如果-否则如果-否则 / If-else if-else

分数 = 85

score = 85

 

如果 分数 >= 90 {

    等级 = "优秀"

} 否则如果 分数 >= 80 {

    等级 = "良好"

} 否则如果 分数 >= 60 {

    等级 = "及格"

} 否则 {

    等级 = "不及格"

}

 

if score >= 90 {

    grade = "Excellent"

} else if score >= 80 {

    grade = "Good"

} else if score >= 60 {

    grade = "Pass"

} else {

    grade = "Fail"

}

 

// 三目运算符 / Ternary operator

结果 = 分数 >= 60 ? "通过" : "不通过"

result = score >= 60 ? "Pass" : "Fail"

 

// 匹配语句（类似switch）/ Match statement (like switch)

月份 = 3

month = 3

 

匹配 月份 {

    情况 1, 2, 3: 季节 = "春季"

    情况 4, 5, 6: 季节 = "夏季"

    情况 7, 8, 9: 季节 = "秋季"

    情况 10, 11, 12: 季节 = "冬季"

    默认: 季节 = "未知"

}

 

match month {

    case 1, 2, 3: season = "Spring"

    case 4, 5, 6: season = "Summer"

    case 7, 8, 9: season = "Autumn"

    case 10, 11, 12: season = "Winter"

    default: season = "Unknown"

}

 

// 卫语句 / Guard statements

匹配 值 {

    情况 x 如果 x > 0: 输出("正数")

    情况 x 如果 x < 0: 输出("负数")

    情况 _: 输出("零")

}

 

match value {

    case x if x > 0: print("Positive")

    case x if x < 0: print("Negative")

    case _: print("Zero")

}

```

 

循环 / Loops

 

```tuan

// 对于循环（for-each）/ For loop (for-each)

水果列表 = ["苹果", "香蕉", "橙子"]

fruits = ["apple", "banana", "orange"]

对于 水果 在 水果列表 {

    输出(水果)

}

for fruit in fruits {

    print(fruit)

}

 

// 范围循环 / Range loop

对于 i 在 1..10 {

    输出(i) // 1, 2, 3, ..., 10

}

for i in 1..10 {

    print(i) // 1, 2, 3, ..., 10

}

 

// 当循环（while）/ While loop

计数 = 0

count = 0

当 计数 < 5 {

    输出(计数)

    计数 = 计数 + 1

}

while count < 5 {

    print(count)

    count = count + 1

}

 

// 执行-当循环（do-while）/ Do-while loop

计数 = 0

count = 0

执行 {

    输出(计数)

    计数 = 计数 + 1

} 当 计数 < 5

 

do {

    print(count)

    count = count + 1

} while count < 5

 

// 循环控制 / Loop control

对于 i 在 1..10 {

    如果 i == 3 {

        继续 // 跳过本次迭代 / skip iteration

    }

    如果 i == 7 {

        中断 // 退出循环 / break loop

    }

    输出(i)

}

 

for i in 1..10 {

    if i == 3 {

        continue // skip iteration

    }

    if i == 7 {

        break // break loop

    }

    print(i)

}

```

 

---

 

🏢 五、函数 / Functions

 

函数定义 / Function Definition

 

```tuan

// 基本函数 / Basic function

函数 问候(姓名: 字符串): 字符串 {

    返回 "你好，" + 姓名 + "！"

}

function greet(name: string): string {

    return "Hello, " + name + "!"

}

 

// 带默认参数的函数 / Function with default parameters

函数 计算面积(长: 小数, 宽: 小数 = 1.0): 小数 {

    返回 长 * 宽

}

function calculate_area(length: float, width: float = 1.0): float {

    return length * width

}

 

// 多返回值函数 / Function with multiple returns

函数 统计(数据: 列表<小数>): (小数, 小数, 小数) {

    总和 = 0.0

    sum = 0.0

    对于 值 在 数据 {

        总和 = 总和 + 值

        sum = sum + value

    }

    平均值 = 总和 / 数据.长度()

    average = sum / data.length()

    最大值 = 数据.最大值()

    max_value = data.max()

    最小值 = 数据.最小值()

    min_value = data.min()

    

    返回 (平均值, 最大值, 最小值)

    return (average, max_value, min_value)

}

 

// 匿名函数（lambda）/ Anonymous function (lambda)

平方 = 函数(x: 整数): 整数 { 返回 x * x }

square = function(x: int): int { return x * x }

平方(5) // 25

square(5) // 25

 

// 箭头函数简写 / Arrow function shorthand

平方 = (x: 整数) => x * x

square = (x: int) => x * x

加 = (a: 整数, b: 整数) => a + b

add = (a: int, b: int) => a + b

```

 

高阶函数 / Higher-order Functions

 

```tuan

// 函数作为参数 / Function as parameter

函数 应用函数(数据: 列表<整数>, 转换器: 函数<整数, 整数>): 列表<整数> {

    结果 = 列表<整数>()

    对于 值 在 数据 {

        结果.添加(转换器(值))

    }

    返回 结果

}

function apply_function(data: list<int>, transformer: function<int, int>): list<int> {

    result = list<int>()

    for value in data {

        result.append(transformer(value))

    }

    return result

}

 

// 使用 / Usage

数据 = [1, 2, 3, 4, 5]

data = [1, 2, 3, 4, 5]

平方数据 = 应用函数(数据, (x) => x * x) // [1, 4, 9, 16, 25]

squared_data = apply_function(data, (x) => x * x)

 

// 内置高阶函数 / Built-in higher-order functions

数据 = [1, 2, 3, 4, 5]

data = [1, 2, 3, 4, 5]

 

// 映射 / Map

平方列表 = 数据.映射((x) => x * x)

squares = data.map((x) => x * x)

 

// 过滤 / Filter

偶数列表 = 数据.过滤((x) => x % 2 == 0)

evens = data.filter((x) => x % 2 == 0)

 

// 归约 / Reduce

总和 = 数据.归约(0, (累计, 当前) => 累计 + 当前)

sum = data.reduce(0, (accumulator, current) => accumulator + current)

 

// 排序 / Sort

排序列表 = 数据.排序((a, b) => a - b)

sorted_list = data.sort((a, b) => a - b)

```

 

闭包 / Closures

 

```tuan

函数 创建计数器(): 函数<空, 整数> {

    计数 = 0

    返回 函数(): 整数 {

        计数 = 计数 + 1

        返回 计数

    }

}

function create_counter(): function<null, int> {

    count = 0

    return function(): int {

        count = count + 1

        return count

    }

}

 

计数器 = 创建计数器()

counter = create_counter()

计数器() // 1

counter() // 1

计数器() // 2

counter() // 2

计数器() // 3

counter() // 3

```

 

---

 

🎯 六、面向对象编程 / Object-Oriented Programming

 

类定义 / Class Definition

 

```tuan

// 基本类 / Basic class

类 学生 {

    // 属性 / Properties

    私有 姓名: 字符串

    private name: string

    私有 年龄: 整数

    private age: int

    私有 成绩: 小数

    private score: float

    

    // 构造函数 / Constructor

    构造(姓名: 字符串, 年龄: 整数, 成绩: 小数 = 0.0) {

        本.姓名 = 姓名

        本.年龄 = 年龄

        本.成绩 = 成绩

    }

    constructor(name: string, age: int, score: float = 0.0) {

        self.name = name

        self.age = age

        self.score = score

    }

    

    // 方法 / Methods

    函数 获取姓名(): 字符串 {

        返回 本.姓名

    }

    function get_name(): string {

        return self.name

    }

    

    函数 设置成绩(新成绩: 小数) {

        如果 新成绩 >= 0 且 新成绩 <= 100 {

            本.成绩 = 新成绩

        }

    }

    function set_score(new_score: float) {

        if new_score >= 0 and new_score <= 100 {

            self.score = new_score

        }

    }

    

    函数 获取等级(): 字符串 {

        如果 本.成绩 >= 90 { 返回 "A" }

        否则如果 本.成绩 >= 80 { 返回 "B" }

        否则如果 本.成绩 >= 70 { 返回 "C" }

        否则如果 本.成绩 >= 60 { 返回 "D" }

        否则 { 返回 "F" }

    }

    function get_grade(): string {

        if self.score >= 90 { return "A" }

        else if self.score >= 80 { return "B" }

        else if self.score >= 70 { return "C" }

        else if self.score >= 60 { return "D" }

        else { return "F" }

    }

    

    // 字符串表示 / String representation

    覆盖 函数 转字符串(): 字符串 {

        返回 "学生{姓名: {本.姓名}, 年龄: {本.年龄}, 成绩: {本.成绩}}"

    }

    override function to_string(): string {

        return "Student{name: {self.name}, age: {self.age}, score: {self.score}}"

    }

}

 

// 使用类 / Using class

张三 = 学生("张三", 20, 88.5)

zhang_san = Student("Zhang San", 20, 88.5)

输出(张三.获取姓名()) // "张三"

print(zhang_san.get_name()) // "Zhang San"

张三.设置成绩(92.0)

zhang_san.set_score(92.0)

输出(张三.获取等级()) // "A"

print(zhang_san.get_grade()) // "A"

输出(张三) // "学生{姓名: 张三, 年龄: 20, 成绩: 92.0}"

print(zhang_san) // "Student{name: Zhang San, age: 20, score: 92.0}"

```

 

继承与多态 / Inheritance & Polymorphism

 

```tuan

// 基类 / Base class

抽象类 图形 {

    // 抽象方法 / Abstract methods

    抽象 函数 计算面积(): 小数

    abstract function calculate_area(): float

    抽象 函数 计算周长(): 小数

    abstract function calculate_perimeter(): float

    

    // 具体方法 / Concrete method

    函数 显示信息() {

        输出("面积: {本.计算面积()}, 周长: {本.计算周长()}")

    }

    function display_info() {

        print("Area: {self.calculate_area()}, Perimeter: {self.calculate_perimeter()}")

    }

}

 

// 派生类 / Derived class

类 圆形 继承 图形 {

    私有 半径: 小数

    private radius: float

    

    构造(半径: 小数) {

        本.半径 = 半径

    }

    constructor(radius: float) {

        self.radius = radius

    }

    

    覆盖 函数 计算面积(): 小数 {

        返回 3.14159 * 本.半径 * 本.半径

    }

    override function calculate_area(): float {

        return 3.14159 * self.radius * self.radius

    }

    

    覆盖 函数 计算周长(): 小数 {

        返回 2 * 3.14159 * 本.半径

    }

    override function calculate_perimeter(): float {

        return 2 * 3.14159 * self.radius

    }

}

 

类 矩形 继承 图形 {

    私有 长: 小数

    private length: float

    私有 宽: 小数

    private width: float

    

    构造(长: 小数, 宽: 小数) {

        本.长 = 长

        本.宽 = 宽

    }

    constructor(length: float, width: float) {

        self.length = length

        self.width = width

    }

    

    覆盖 函数 计算面积(): 小数 {

        返回 本.长 * 本.宽

    }

    override function calculate_area(): float {

        return self.length * self.width

    }

    

    覆盖 函数 计算周长(): 小数 {

        返回 2 * (本.长 + 本.宽)

    }

    override function calculate_perimeter(): float {

        return 2 * (self.length + self.width)

    }

}

 

// 使用多态 / Using polymorphism

图形列表 = 列表<图形>([

    圆形(5.0),

    矩形(4.0, 6.0),

    圆形(3.0)

])

shape_list = list<Shape>([

    Circle(5.0),

    Rectangle(4.0, 6.0),

    Circle(3.0)

])

 

对于 图形 在 图形列表 {

    图形.显示信息()

}

for shape in shape_list {

    shape.display_info()

}

```

 

接口 / Interfaces

 

```tuan

// 接口定义 / Interface definition

接口 可打印 {

    函数 打印(): 空

}

interface Printable {

    function print(): null

}

 

接口 可比较<T> {

    函数 比较(其他: T): 整数

}

interface Comparable<T> {

    function compare(other: T): int

}

 

// 实现接口 / Implementing interfaces

类 文档 实现 可打印, 可比较<文档> {

    私有 内容: 字符串

    private content: string

    

    构造(内容: 字符串) {

        本.内容 = 内容

    }

    constructor(content: string) {

        self.content = content

    }

    

    实现 函数 打印(): 空 {

        输出("文档内容: {本.内容}")

    }

    implement function print(): null {

        print("Document content: {self.content}")

    }

    

    实现 函数 比较(其他: 文档): 整数 {

        返回 本.内容.长度() - 其他.内容.长度()

    }

    implement function compare(other: Document): int {

        return self.content.length() - other.content.length()

    }

}

```

 

枚举 / Enums

 

```tuan

// 基本枚举 / Basic enum

枚举 星期 {

    星期一,

    星期二,

    星期三,

    星期四,

    星期五,

    星期六,

    星期日

}

enum Weekday {

    Monday,

    Tuesday,

    Wednesday,

    Thursday,

    Friday,

    Saturday,

    Sunday

}

 

今天 = 星期.星期一

today = Weekday.Monday

如果 今天 == 星期.星期六 或 今天 == 星期.星期日 {

    输出("周末愉快！")

}

if today == Weekday.Saturday or today == Weekday.Sunday {

    print("Happy weekend!")

}

 

// 带值的枚举 / Enum with values

枚举 HTTP状态码 {

    成功 = 200,

    创建成功 = 201,

    错误请求 = 400,

    未授权 = 401,

    未找到 = 404,

    服务器错误 = 500

}

enum HTTPStatusCode {

    OK = 200,

    Created = 201,

    BadRequest = 400,

    Unauthorized = 401,

    NotFound = 404,

    ServerError = 500

}

 

状态 = HTTP状态码.成功

status = HTTPStatusCode.OK

输出(状态.值()) // 200

print(status.value()) // 200

输出(状态.名称()) // "成功"

print(status.name()) // "OK"

 

// 枚举方法 / Enum methods

枚举 颜色 {

    红,

    绿,

    蓝;

    

    函数 十六进制值(): 字符串 {

        匹配 本 {

            情况 红: 返回 "#FF0000"

            情况 绿: 返回 "#00FF00"

            情况 蓝: 返回 "#0000FF"

        }

    }

}

enum Color {

    Red,

    Green,

    Blue;

    

    function hex_value(): string {

        match self {

            case Red: return "#FF0000"

            case Green: return "#00FF00"

            case Blue: return "#0000FF"

        }

    }

}

```

 

---

 

📊 七、泛型编程 / Generic Programming

 

泛型类 / Generic Class

 

```tuan

// 泛型容器 / Generic container

类 盒子<T> {

    私有 内容: T

    

    构造(内容: T) {

        本.内容 = 内容

    }

    

    函数 获取内容(): T {

        返回 本.内容

    }

    

    函数 设置内容(新内容: T) {

        本.内容 = 新内容

    }

}

class Box<T> {

    private content: T

    

    constructor(content: T) {

        self.content = content

    }

    

    function get_content(): T {

        return self.content

    }

    

    function set_content(new_content: T) {

        self.content = new_content

    }

}

 

// 使用 / Usage

整数盒子 = 盒子<整数>(42)

int_box = Box<int>(42)

字符串盒子 = 盒子<字符串>("Hello")

string_box = Box<string>("Hello")

 

输出(整数盒子.获取内容()) // 42

print(int_box.get_content()) // 42

输出(字符串盒子.获取内容()) // "Hello"

print(string_box.get_content()) // "Hello"

```

 

泛型函数 / Generic Functions

 

```tuan

// 泛型函数 / Generic function

函数 交换<T>(a: 引用 T, b: 引用 T): 空 {

    临时 = a

    a = b

    b = 临时

}

function swap<T>(a: ref T, b: ref T): null {

    temp = a

    a = b

    b = temp

}

 

// 使用 / Usage

x = 10

y = 20

交换(x, y)

swap(x, y)

输出("x: {x}, y: {y}") // x: 20, y: 10

print("x: {x}, y: {y}") // x: 20, y: 10

 

// 泛型约束 / Generic constraints

接口 可比较<T> {

    函数 比较(其他: T): 整数

}

interface Comparable<T> {

    function compare(other: T): int

}

 

函数 最大值<T 实现 可比较<T>>(a: T, b: T): T {

    如果 a.比较(b) > 0 {

        返回 a

    } 否则 {

        返回 b

    }

}

function max<T implements Comparable<T>>(a: T, b: T): T {

    if a.compare(b) > 0 {

        return a

    } else {

        return b

    }

}

```

 

---

 

🚀 八、错误处理 / Error Handling

 

异常处理 / Exception Handling

 

```tuan

// 抛出异常 / Throw exception

函数 安全除法(被除数: 小数, 除数: 小数): 小数 {

    如果 除数 == 0 {

        抛出 异常("除数不能为零")

    }

    返回 被除数 / 除数

}

function safe_divide(dividend: float, divisor: float): float {

    if divisor == 0 {

        throw Exception("Divisor cannot be zero")

    }

    return dividend / divisor

}

 

// 捕获异常 / Catch exception

尝试 {

    结果 = 安全除法(10, 0)

    输出("结果: {结果}")

} 捕获 数学异常: 异常 {

    输出("数学错误: {数学异常.消息}")

} 捕获 其他异常: 异常 {

    输出("其他错误: {其他异常.消息}")

} 最终 {

    输出("计算完成")

}

try {

    result = safe_divide(10, 0)

    print("Result: {result}")

} catch math_error: Exception {

    print("Math error: {math_error.message}")

} catch other_error: Exception {

    print("Other error: {other_error.message}")

} finally {

    print("Calculation completed")

}

 

// 自定义异常 / Custom exception

类 文件未找到异常 继承 异常 {

    构造(文件名: 字符串) {

        本.父构造("文件 '{文件名}' 未找到")

    }

}

class FileNotFoundException extends Exception {

    constructor(filename: string) {

        super("File '{filename}' not found")

    }

}

 

// 结果类型（函数式错误处理）/ Result type (functional error handling)

类 结果<T, E> {

    私有 值: T | 空

    私有 错误: E | 空

    

    私有 构造(值: T | 空, 错误: E | 空) {

        本.值 = 值

        本.错误 = 错误

    }

    

    静态 函数 成功(值: T): 结果<T, E> {

        返回 结果<T, E>(值, 空)

    }

    

    静态 函数 失败(错误: E): 结果<T, E> {

        返回 结果<T, E>(空, 错误)

    }

    

    函数 是成功(): 布尔 {

        返回 本.值 != 空

    }

    

    函数 是失败(): 布尔 {

        返回 本.错误 != 空

    }

    

    函数 解包(): T {

        如果 本.值 != 空 {

            返回 本.值!

        } 否则 {

            抛出 异常("尝试解包失败的结果")

        }

    }

    

    函数 获取错误(): E {

        如果 本.错误 != 空 {

            返回 本.错误!

        } 否则 {

            抛出 异常("没有错误")

        }

    }

}

```

 

---

 

⚡ 九、并发编程 / Concurrency

 

异步/等待 / Async/Await

 

```tuan

// 异步函数 / Async function

异步 函数 获取数据(网址: 字符串): 字符串 {

    输出("开始获取 {网址}")

    

    // 模拟网络延迟 / Simulate network delay

    等待 时间.睡眠(1000) // 等待1秒 / Wait 1 second

    

    返回 "来自 {网址} 的数据"

}

async function fetch_data(url: string): string {

    print("Starting to fetch {url}")

    

    // Simulate network delay

    await time.sleep(1000) // Wait 1 second

    

    return "Data from {url}"

}

 

// 使用异步函数 / Using async function

异步 函数 主函数() {

    数据1 = 等待 获取数据("https://api.example.com/data1")

    数据2 = 等待 获取数据("https://api.example.com/data2")

    

    输出("数据1: {数据1}")

    输出("数据2: {数据2}")

    

    返回 "完成"

}

async function main() {

    data1 = await fetch_data("https://api.example.com/data1")

    data2 = await fetch_data("https://api.example.com/data2")

    

    print("Data1: {data1}")

    print("Data2: {data2}")

    

    return "Done"

}

 

// 并发执行 / Concurrent execution

异步 函数 并发获取() {

    任务1 = 获取数据("https://api.example.com/data1")

    任务2 = 获取数据("https://api.example.com/data2")

    

    // 等待所有任务完成 / Wait for all tasks to complete

    (结果1, 结果2) = 等待 任务.所有([任务1, 任务2])

    

    输出("结果1: {结果1}")

    输出("结果2: {结果2}")

}

async function concurrent_fetch() {

    task1 = fetch_data("https://api.example.com/data1")

    task2 = fetch_data("https://api.example.com/data2")

    

    // Wait for all tasks to complete

    (result1, result2) = await Task.all([task1, task2])

    

    print("Result1: {result1}")

    print("Result2: {result2}")

}

```

 

协程 / Coroutines

 

```tuan

// 生成器函数 / Generator function

函数 数字生成器(最大值: 整数): 生成器<整数> {

    对于 i 在 1..最大值 {

        生成 i

    }

}

function number_generator(max: int): generator<int> {

    for i in 1..max {

        yield i

    }

}

 

// 使用生成器 / Using generator

对于 数字 在 数字生成器(5) {

    输出(数字) // 1, 2, 3, 4, 5

}

for number in number_generator(5) {

    print(number) // 1, 2, 3, 4, 5

}

 

// 协程通信 / Coroutine communication

函数 生产者(通道: 通道<整数>) {

    对于 i 在 1..5 {

        输出("生产: {i}")

        通道.发送(i)

        时间.睡眠(500)

    }

    通道.关闭()

}

function producer(channel: channel<int>) {

    for i in 1..5 {

        print("Produce: {i}")

        channel.send(i)

        time.sleep(500)

    }

    channel.close()

}

 

函数 消费者(通道: 通道<整数>) {

    对于 项目 在 通道 {

        输出("消费: {项目}")

        时间.睡眠(1000)

    }

}

function consumer(channel: channel<int>) {

    for item in channel {

        print("Consume: {item}")

        time.sleep(1000)

    }

}

 

// 启动协程 / Start coroutines

通道 = 通道<整数>(容量: 3)

channel = channel<int>(capacity: 3)

协程.启动(生产者(通道))

coroutine.start(producer(channel))

协程.启动(消费者(通道))

coroutine.start(consumer(channel))

```

 

线程安全 / Thread Safety

 

```tuan

// 互斥锁 / Mutex

类 线程安全计数器 {

    私有 计数: 整数 = 0

    私有 锁: 互斥锁 = 互斥锁()

    

    函数 增加() {

        锁.锁定()

        尝试 {

            计数 = 计数 + 1

        } 最终 {

            锁.解锁()

        }

    }

    

    函数 获取(): 整数 {

        锁.锁定()

        尝试 {

            返回 计数

        } 最终 {

            锁.解锁()

        }

    }

}

class ThreadSafeCounter {

    private count: int = 0

    private lock: mutex = mutex()

    

    function increment() {

        lock.lock()

        try {

            count = count + 1

        } finally {

            lock.unlock()

        }

    }

    

    function get(): int {

        lock.lock()

        try {

            return count

        } finally {

            lock.unlock()

        }

    }

}

 

// 原子操作 / Atomic operations

原子整数 = 原子<整数>(0)

atomic_int = atomic<int>(0)

原子整数.增加获取() // 原子增加并返回新值

atomic_int.increment_and_get() // Atomically increment and return new value

原子整数.获取增加() // 获取当前值然后增加

atomic_int.get_and_increment() // Get current value then increment

```

 

---

 

📚 十、标准库 / Standard Library

 

输入输出 / Input/Output

 

```tuan

// 控制台输入输出 / Console I/O

输出("请输入你的名字：")

print("Please enter your name: ")

名字 = 输入() // 读取一行输入

name = input() // Read a line of input

输出("你好，{名字}！")

print("Hello, {name}!")

 

// 格式化输出 / Formatted output

价格 = 99.99

price = 99.99

数量 = 3

quantity = 3

总价 = 价格 * 数量

total = price * quantity

输出("价格: {价格:0.2f}, 数量: {数量}, 总价: {总价:0.2f}")

print("Price: {price:0.2f}, Quantity: {quantity}, Total: {total:0.2f}")

 

// 文件操作 / File operations

内容 = "Hello, Tuan!"

content = "Hello, Tuan!"

文件.写入文本("test.txt", 内容)

file.write_text("test.txt", content)

 

读取内容 = 文件.读取文本("test.txt")

read_content = file.read_text("test.txt")

输出(读取内容)

print(read_content)

 

// 目录操作 / Directory operations

如果 目录.存在("data") {

    输出("目录已存在")

} 否则 {

    目录.创建("data")

}

if directory.exists("data") {

    print("Directory exists")

} else {

    directory.create("data")

}

 

文件列表 = 目录.列表文件(".")

file_list = directory.list_files(".")

对于 文件 在 文件列表 {

    输出(文件.名称())

}

for file in file_list {

    print(file.name())

}

```

 

数学函数 / Math Functions

 

```tuan

导入 数学

import math

 

绝对值 = 数学.绝对值(-10) // 10

abs_value = math.abs(-10) // 10

平方根 = 数学.平方根(16) // 4.0

sqrt_value = math.sqrt(16) // 4.0

正弦值 = 数学.正弦(数学.PI / 2) // 1.0

sin_value = math.sin(math.PI / 2) // 1.0

自然对数 = 数学.对数(数学.E) // 1.0

ln_value = math.log(math.E) // 1.0

常用对数 = 数学.对数10(100) // 2.0

log10_value = math.log10(100) // 2.0

幂运算 = 数学.幂(2, 3) // 8.0

pow_value = math.pow(2, 3) // 8.0

四舍五入 = 数学.四舍五入(3.14159, 2) // 3.14

round_value = math.round(3.14159, 2) // 3.14

向下取整 = 数学.向下取整(3.9) // 3

floor_value = math.floor(3.9) // 3

向上取整 = 数学.向上取整(3.1) // 4

ceil_value = math.ceil(3.1) // 4

 

// 随机数 / Random numbers

随机种子 = 随机.种子(42)

random.seed(42)

随机整数 = 随机.整数(1, 100)

random_int = random.int(1, 100)

随机小数 = 随机.小数()

random_float = random.float()

随机选择 = 随机.选择(["A", "B", "C"])

random_choice = random.choice(["A", "B", "C"])

```

 

日期时间 / Date & Time

 

```tuan

导入 时间

import time

 

现在 = 时间.现在()

now = time.now()

输出("当前时间: {现在}")

print("Current time: {now}")

 

年 = 现在.年()

year = now.year()

月 = 现在.月()

month = now.month()

日 = 现在.日()

day = now.day()

时 = 现在.时()

hour = now.hour()

分 = 现在.分()

minute = now.minute()

秒 = 现在.秒()

second = now.second()

 

// 格式化 / Formatting

格式化时间 = 现在.格式化("YYYY-MM-DD HH:mm:ss")

formatted_time = now.format("YYYY-MM-DD HH:mm:ss")

输出(格式化时间) // "2024-01-15 14:30:25"

print(formatted_time) // "2024-01-15 14:30:25"

 

// 时间计算 / Time calculations

明天 = 现在 + 时间.时长(天数: 1)

tomorrow = now + time.duration(days: 1)

一周后 = 现在 + 时间.时长(星期: 1)

one_week_later = now + time.duration(weeks: 1)

一小时前 = 现在 - 时间.时长(小时: 1)

one_hour_ago = now - time.duration(hours: 1)

 

// 解析时间 / Parse time

解析时间 = 时间.解析("2024-01-15", "YYYY-MM-DD")

parsed_time = time.parse("2024-01-15", "YYYY-MM-DD")

```

 

网络请求 / Network Requests

 

```tuan

导入 网络

import network

 

// HTTP GET请求 / HTTP GET request

响应 = 网络.HTTP.获取("https://api.example.com/data")

response = network.HTTP.get("https://api.example.com/data")

如果 响应.状态码 == 200 {

    数据 = 响应.正文.转字符串()

    输出("获取到数据: {数据}")

} 否则 {

    输出("请求失败: {响应.状态码}")

}

if response.status_code == 200 {

    data = response.body.to_string()

    print("Got data: {data}")

} else {

    print("Request failed: {response.status_code}")

}

 

// HTTP POST请求 / HTTP POST request

数据 = {

    "姓名": "张三",

    "年龄": 25

}

data = {

    "name": "Zhang San",

    "age": 25

}

响应 = 网络.HTTP.发布("https://api.example.com/users", JSON.序列化(数据))

response = network.HTTP.post("https://api.example.com/users", JSON.serialize(data))

 

// WebSocket

套接字 = 网络.WebSocket.连接("ws://example.com/socket")

socket = network.WebSocket.connect("ws://example.com/socket")

套接字.发送("Hello, Server!")

socket.send("Hello, Server!")

消息 = 套接字.接收()

message = socket.receive()

套接字.关闭()

socket.close()

```

 

---

 

🔧 十一、模块系统 / Module System

 

模块定义 / Module Definition

 

```tuan

// 文件: math_utils.tuan / File: math_utils.tuan

模块 数学工具

module math_utils

 

// 导出函数 / Export functions

公开 函数 加法(a: 小数, b: 小数): 小数 {

    返回 a + b

}

public function add(a: float, b: float): float {

    return a + b

}

 

公开 函数 乘法(a: 小数, b: 小数): 小数 {

    返回 a * b

}

public function multiply(a: float, b: float): float {

    return a * b

}

 

// 内部函数（不导出）/ Internal function (not exported)

私有 函数 内部计算(): 整数 {

    返回 42

}

private function internal_compute(): int {

    return 42

}

 

// 导出类 / Export class

公开 类 计算器 {

    函数 计算表达式(表达式: 字符串): 小数 {

        // 实现... / Implementation...

        返回 0.0

        return 0.0

    }

}

public class Calculator {

    function compute_expression(expression: string): float {

        // Implementation...

        return 0.0

    }

}

```

 

模块导入 / Module Import

 

```tuan

// 导入整个模块 / Import entire module

导入 数学工具

import math_utils

 

结果1 = 数学工具.加法(3, 5)

result1 = math_utils.add(3, 5)

结果2 = 数学工具.乘法(4, 6)

result2 = math_utils.multiply(4, 6)

 

// 导入特定项目 / Import specific items

从 数学工具 导入 {加法, 计算器}

from math_utils import {add, Calculator}

 

结果 = 加法(2, 3)

result = add(2, 3)

计算器实例 = 计算器()

calculator = Calculator()

 

// 别名导入 / Alias import

导入 数学工具 作为 工具

import math_utils as utils

 

结果 = 工具.乘法(3, 4)

result = utils.multiply(3, 4)

 

// 条件导入 / Conditional import

如果 系统.平台() == "windows" {

    导入 windows工具

} 否则 {

    导入 unix工具

}

if system.platform() == "windows" {

    import windows_utils

} else {

    import unix_utils

}

 

// 动态导入 / Dynamic import

模块路径 = "my_module.tuan"

module_path = "my_module.tuan"

动态模块 = 导入(模块路径)

dynamic_module = import(module_path)

```

 

---

 

📦 十二、包管理 / Package Management

 

包定义 / Package Definition

 

```tuan

// 文件: my_package/package.tuan / File: my_package/package.tuan

包 {

    名称: "my_package",

    版本: "1.0.0",

    作者: "Tuan开发者",

    描述: "我的Tuan包",

    许可证: "MIT",

    依赖: {

        "tuan_http": ">=1.2.0",

        "tuan_json": ">=2.0.0"

    },

    入口点: "src/main.tuan"

}

package {

    name: "my_package",

    version: "1.0.0",

    author: "Tuan Developer",

    description: "My Tuan package",

    license: "MIT",

    dependencies: {

        "tuan_http": ">=1.2.0",

        "tuan_json": ">=2.0.0"

    },

    entry_point: "src/main.tuan"

}

```

 

包结构 / Package Structure

 

```

my_package/

├── package.tuan # 包定义文件 / Package definition

├── README.md # 说明文档 / Documentation

├── src/ # 源代码 / Source code

│ ├── main.tuan # 主入口 / Main entry point

│ ├── utils.tuan # 工具模块 / Utility module

│ └── lib/ # 库文件 / Library files

├── tests/ # 测试文件 / Test files

├── examples/ # 示例代码 / Example code

└── docs/ # 文档 / Documentation

```

 

包管理器命令 / Package Manager Commands

 

```bash

# 初始化新包 / Initialize new package

tuan init my_package

 

# 添加依赖 / Add dependency

tuan add tuan_http

 

# 安装依赖 / Install dependencies

tuan install

 

# 运行程序 / Run program

tuan run

 

# 构建发布版本 / Build release version

tuan build --release

 

# 测试 / Test

tuan test

 

# 发布到包仓库 / Publish to package registry

tuan publish

```

 

---

 

🎯 十三、实战项目：学生管理系统 / Practical Project: Student Management System

 

完整代码 / Complete Code

 

```tuan

// 文件: student_management.tuan / File: student_management.tuan

 

// 学生类 / Student class

类 学生 {

    // 属性 / Properties

    私有 学号: 字符串

    private student_id: string

    私有 姓名: 字符串

    private name: string

    私有 年龄: 整数

    private age: int

    私有 成绩: 字典<字符串, 小数>

    private grades: dict<string, float>

    

    // 构造函数 / Constructor

    构造(学号: 字符串, 姓名: 字符串, 年龄: 整数) {

        本.学号 = 学号

        本.姓名 = 姓名

        本.年龄 = 年龄

        本.成绩 = 字典<字符串, 小数>()

    }

    constructor(student_id: string, name: string, age: int) {

        self.student_id = student_id

        self.name = name

        self.age = age

        self.grades = dict<string, float>()

    }

    

    // 公共方法 / Public methods

    公开 函数 获取学号(): 字符串 { 返回 本.学号 }

    public function get_student_id(): string { return self.student_id }

    公开 函数 获取姓名(): 字符串 { 返回 本.姓名 }

    public function get_name(): string { return self.name }

    公开 函数 获取年龄(): 整数 { 返回 本.年龄 }

    public function get_age(): int { return self.age }

    

    公开 函数 添加成绩(科目: 字符串, 分数: 小数): 空 {

        如果 分数 >= 0 且 分数 <= 100 {

            本.成绩[科目] = 分数

        } 否则 {

            抛出 异常("分数必须在0-100之间")

        }

    }

    public function add_grade(subject: string, score: float): null {

        if score >= 0 and score <= 100 {

            self.grades[subject] = score

        } else {

            throw Exception("Score must be between 0 and 100")

        }

    }

    

    公开 函数 获取成绩(科目: 字符串): 小数 | 空 {

        返回 本.成绩.获取(科目, 空)

    }

    public function get_grade(subject: string): float | null {

        return self.grades.get(subject, null)

    }

    

    公开 函数 获取平均分(): 小数 {

        如果 本.成绩.长度() == 0 {

            返回 0.0

        }

        

        总分 = 0.0

        total_score = 0.0

        对于 分数 在 本.成绩.值() {

            总分 = 总分 + 分数

            total_score = total_score + score

        }

        

        返回 总分 / 本.成绩.长度()

        return total_score / self.grades.length()

    }

    

    公开 函数 获取等级(): 字符串 {

        平均分 = 本.获取平均分()

        average = self.get_average()

        

        匹配 {

            情况 如果 平均分 >= 90: 返回 "A"

            情况 如果 平均分 >= 80: 返回 "B"

            情况 如果 平均分 >= 70: 返回 "C"

            情况 如果 平均分 >= 60: 返回 "D"

            否则: 返回 "F"

        }

        match {

            case if average >= 90: return "A"

            case if average >= 80: return "B"

            case if average >= 70: return "C"

            case if average >= 60: return "D"

            else: return "F"

        }

    }

    

    公开 覆盖 函数 转字符串(): 字符串 {

        返回 "学生{学号: {本.学号}, 姓名: {本.姓名}, 年龄: {本.年龄}, 平均分: {本.获取平均分():.1f}}"

    }

    public override function to_string(): string {

        return "Student{ID: {self.student_id}, Name: {self.name}, Age: {self.age}, Average: {self.get_average():.1f}}"

    }

}

 

// 学生管理器 / Student manager

类 学生管理器 {

    私有 学生列表: 字典<字符串, 学生> = 字典<字符串, 学生>()

    private students: dict<string, Student> = dict<string, Student>()

    

    公开 函数 添加学生(学生: 学生): 布尔 {

        如果 本.学生列表.包含键(学生.获取学号()) {

            输出("学生 {学生.获取学号()} 已存在")

            返回 假

        }

        

        本.学生列表[学生.获取学号()] = 学生

        输出("学生 {学生.获取姓名()} 添加成功")

        返回 真

    }

    public function add_student(student: Student): bool {

        if self.students.contains_key(student.get_student_id()) {

            print("Student {student.get_student_id()} already exists")

            return false

        }

        

        self.students[student.get_student_id()] = student

        print("Student {student.get_name()} added successfully")

        return true

    }

    

    公开 函数 删除学生(学号: 字符串): 布尔 {

        如果 本.学生列表.移除(学号) != 空 {

            输出("学生 {学号} 删除成功")

            返回 真

        } 否则 {

            输出("学生 {学号} 不存在")

            返回 假

        }

    }

    public function remove_student(student_id: string): bool {

        if self.students.remove(student_id) != null {

            print("Student {student_id} removed successfully")

            return true

        } else {

            print("Student {student_id} does not exist")

            return false

        }

    }

    

    公开 函数 查找学生(学号: 字符串): 学生 | 空 {

        返回 本.学生列表.获取(学号, 空)

    }

    public function find_student(student_id: string): Student | null {

        return self.students.get(student_id, null)

    }

    

    公开 函数 获取所有学生(): 列表<学生> {

        返回 列表<学生>(本.学生列表.值())

    }

    public function get_all_students(): list<Student> {

        return list<Student>(self.students.values())

    }

    

    公开 函数 按成绩排序(): 列表<学生> {

        学生列表 = 本.获取所有学生()

        返回 学生列表.排序((a, b) => b.获取平均分() - a.获取平均分())

    }

    public function sort_by_grade(): list<Student> {

        student_list = self.get_all_students()

        return student_list.sort((a, b) => b.get_average() - a.get_average())

    }

    

    公开 函数 生成报告(): 字典<字符串, 任意类型> {

        总人数 = 本.学生列表.长度()

        total_students = self.students.length()

        

        如果 总人数 == 0 {

            返回 {

                "总人数": 0,

                "平均分": 0.0,

                "最高分": 0.0,

                "最低分": 0.0

            }

            return {

                "total_students": 0,

                "average_score": 0.0,

                "highest_score": 0.0,

                "lowest_score": 0.0

            }

        }

        

        总分 = 0.0

        total_score = 0.0

        最高分 = 0.0

        highest_score = 0.0

        最低分 = 100.0

        lowest_score = 100.0

        

        对于 学生 在 本.学生列表.值() {

            平均分 = 学生.获取平均分()

            average = student.get_average()

            总分 = 总分 + 平均分

            total_score = total_score + average

            

            如果 平均分 > 最高分 {

                最高分 = 平均分

            }

            if average > highest_score {

                highest_score = average

            }

            

            如果 平均分 < 最低分 {

                最低分 = 平均分

            }

            if average < lowest_score {

                lowest_score = average

            }

        }

        

        平均分 = 总分 / 总人数

        overall_average = total_score / total_students

        

        返回 {

            "总人数": 总人数,

            "平均分": 平均分,

            "最高分": 最高分,

            "最低分": 最低分,

            "优秀率": (本._计算等级比例("A") / 总人数) * 100

        }

        return {

            "total_students": total_students,

            "average_score": overall_average,

            "highest_score": highest_score,

            "lowest_score": lowest_score,

            "excellent_rate": (self._calculate_grade_ratio("A") / total_students) * 100

        }

    }

    

    私有 函数 _计算等级比例(等级: 字符串): 整数 {

        计数 = 0

        count = 0

        对于 学生 在 本.学生列表.值() {

            如果 学生.获取等级() == 等级 {

                计数 = 计数 + 1

            }

            if student.get_grade() == grade {

                count = count + 1

            }

        }

        返回 计数

        return count

    }

    private function _calculate_grade_ratio(grade: string): int {

        count = 0

        for student in self.students.values() {

            if student.get_grade() == grade {

                count = count + 1

            }

        }

        return count

    }

}

 

// 主程序 / Main program

函数 主() {

    输出("🎓 学生管理系统")

    print("🎓 Student Management System")

    输出("=" * 30)

    print("=" * 30)

    

    管理器 = 学生管理器()

    manager = StudentManager()

    

    // 添加测试数据 / Add test data

    学生1 = 学生("2024001", "张三", 20)

    student1 = Student("2024001", "Zhang San", 20)

    学生1.添加成绩("数学", 95.5)

    student1.add_grade("Math", 95.5)

    学生1.添加成绩("英语", 88.0)

    student1.add_grade("English", 88.0)

    学生1.添加成绩("编程", 92.0)

    student1.add_grade("Programming", 92.0)

    

    学生2 = 学生("2024002", "李四", 21)

    student2 = Student("2024002", "Li Si", 21)

    学生2.添加成绩("数学", 85.0)

    student2.add_grade("Math", 85.0)

    学生2.添加成绩("英语", 90.5)

    student2.add_grade("English", 90.5)

    学生2.添加成绩("编程", 78.5)

    student2.add_grade("Programming", 78.5)

    

    学生3 = 学生("2024003", "王五", 19)

    student3 = Student("2024003", "Wang Wu", 19)

    学生3.添加成绩("数学", 76.0)

    student3.add_grade("Math", 76.0)

    学生3.添加成绩("英语", 82.5)

    student3.add_grade("English", 82.5)

    学生3.添加成绩("编程", 88.0)

    student3.add_grade("Programming", 88.0)

    

    管理器.添加学生(学生1)

    manager.add_student(student1)

    管理器.添加学生(学生2)

    manager.add_student(student2)

    管理器.添加学生(学生3)

    manager.add_student(student3)

    

    // 显示所有学生 / Display all students

    输出("\n👥 所有学生:")

    print("\n👥 All Students:")

    对于 学生 在 管理器.获取所有学生() {

        输出(" - {学生}")

    }

    for student in manager.get_all_students() {

        print(" - {student}")

    }

    

    // 按成绩排序 / Sort by grade

    输出("\n🏆 按成绩排序:")

    print("\n🏆 Sorted by Grade:")

    对于 学生 在 管理器.按成绩排序() {

        输出(" - {学生.获取姓名()}: {学生.获取平均分():.1f} ({学生.获取等级()})")

    }

    for student in manager.sort_by_grade() {

        print(" - {student.get_name()}: {student.get_average():.1f} ({student.get_grade()})")

    }

    

    // 生成报告 / Generate report

    报告 = 管理器.生成报告()

    report = manager.generate_report()

    输出("\n📊 系统报告:")

    print("\n📊 System Report:")

    输出(" 总人数: {报告["总人数"]}")

    print(" Total Students: {report['total_students']}")

    输出(" 平均分: {报告["平均分"]:.1f}")

    print(" Average Score: {report['average_score']:.1f}")

    输出(" 最高分: {报告["最高分"]:.1f}")

    print(" Highest Score: {report['highest_score']:.1f}")

    输出(" 最低分: {报告["最低分"]:.1f}")

    print(" Lowest Score: {report['lowest_score']:.1f}")

    输出(" 优秀率: {报告["优秀率"]:.1f}%")

    print(" Excellent Rate: {report['excellent_rate']:.1f}%")

    

    // 查找学生 / Find student

    输出("\n🔍 查找学生:")

    print("\n🔍 Find Student:")

    找到学生 = 管理器.查找学生("2024001")

    found_student = manager.find_student("2024001")

    如果 找到学生 != 空 {

        输出(" 找到: {找到学生.获取姓名()}")

        输出(" 成绩单:")

        对于 (科目, 分数) 在 [(科目, 分数) 对于 科目, 分数 在 找到学生.成绩.条目()] {

            输出(" {科目}: {分数}")

        }

    }

    if found_student != null {

        print(" Found: {found_student.get_name()}")

        print(" Grade Report:")

        for (subject, score) in [(subject, score) for subject, score in found_student.grades.entries()] {

            print(" {subject}: {score}")

        }

    }

    

    输出("\n✅ 程序执行完成")

    print("\n✅ Program execution completed")

}

 

// 运行主程序 / Run main program

如果 __文件名__ == "__主__" {

    主()

}

if __filename__ == "__main__" {

    main()

}

```

 

---

 

📚 十四、学习资源 / Learning Resources

 

快速入门 / Quick Start

 

```tuan

// 1. 安装Tuan / Install Tuan

# 从官网下载安装包

# Download from official website

# https://tuan-lang.org

 

// 2. 第一个程序 / First program

输出("你好，Tuan！")

print("Hello, Tuan!")

 

// 3. 运行程序 / Run program

# tuan run hello.tuan

 

// 4. 交互式环境 / Interactive environment

# tuan repl

> 1 + 2

3

> 输出("Hello")

Hello

```

 

官方文档结构 / Official Documentation Structure

 

```

📚 Tuan官方文档 / Tuan Official Documentation

├── 快速开始 / Getting Started

├── 语言教程 / Language Tutorial

├── 标准库参考 / Standard Library Reference

├── 包管理指南 / Package Management Guide

├── 最佳实践 / Best Practices

└── 进阶主题 / Advanced Topics

```

 

社区资源 / Community Resources

 

· 官网 / Website: https://tuan-lang.org

· GitHub: https://github.com/tuan-lang

· 论坛 / Forum: https://forum.tuan-lang.org

· 包仓库 / Package Registry: https://packages.tuan-lang.org

 

---

 

🎉 总结 / Conclusion

 

特色功能 / Key Features

 

1. 中文友好的语法，同时支持英文关键字

      Chinese-friendly syntax, also supports English keywords

2. 强大的类型系统，静态类型+类型推断

      Powerful type system, static typing + type inference

3. 现代化的错误处理，异常+结果类型

      Modern error handling, exceptions + result types

4. 内置并发支持，异步/等待+协程

      Built-in concurrency support, async/await + coroutines

5. 丰富的标准库，覆盖常用开发需求

      Rich standard library, covers common development needs

6. 完善的包管理器，依赖管理简单

      Complete package manager, simple dependency management

 

适用场景 / Use Cases

 

· Web开发：前后端开发，API服务

    Web Development: Frontend/backend, API services

· 数据科学：数据分析，机器学习

    Data Science: Data analysis, machine learning

· 系统编程：操作系统，嵌入式开发

    Systems Programming: OS, embedded development

· 教育领域：编程教学，算法学习

    Education: Programming teaching, algorithm learning

· 脚本工具：自动化脚本，系统管理

    Scripting: Automation scripts, system administration

 

Tuan语言旨在提供一种既强大又易用的编程体验，让开发者能够专注于解决问题，而不是语言本身的复杂性。

Tuan aims to provide a programming experience that is both powerful and easy to use, allowing developers to focus on solving problems rather than the complexity of the language itself.