Chim （启语）2.0 语法规范

原创已于 2026-02-07 13:07:00 修改 · 585 阅读

7 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

标签

#网络 #服务器 #运维

于 2026-02-03 14:06:59 首次发布

# Chim 2.0 语法规范

> Elm + TOML 扁平化函数式编程语言

---

## 设计哲学

Chim 2.0 融合了 Elm 的函数式简洁性和 TOML 的扁平化美学：

| 特性 | 来源 | 说明 |

|------|------|------|

| **缩进代码块** | Elm | 使用缩进定义代码块，无大括号 |

| **顶层代码执行** | Elm | 无需 main()，代码按顺序直接执行 |

| **扁平化结构** | TOML | 避免嵌套，所有结构扁平化 |

| **唯一控制流** | Elm | 所有控制逻辑都用 match |

| **表达式导向** | Elm | 一切皆表达式，有返回值 |

| **函数式纯度** | Elm | 不可变数据，递归处理循环 |

---

## 核心特性

| 特性 | 值 | 说明 |

|------|-----|------|

| 类型系统 | 静态类型 | 编译期类型检查 |

| 数据可变性 | 不可变 | 所有数据默认不可变 |

| 控制流 | match 唯一 | 取代所有 if/while/for |

| 语句风格 | 表达式导向 | 一切皆表达式 |

| 代码风格 | 缩进 + 冒号 | 无大括号，扁平化 |

| 程序入口 | 顶层代码 | 代码按顺序直接执行 |

| 命名风格 | 蛇形命名 | `my_variable` |

| 类型命名 | 驼峰命名 | `MyType` |

| 函数定义 | `=` | 函数即表达式 |

---

## 语法规则

### 顶层代码（直接执行）

```chim

# 文件: hello.chim

# 顶层代码按顺序直接执行

println "Hello, Chim 2.0!"

let x = 10

let y = 20

println "x + y = " + str (x + y)

```

### 变量声明（TOML风格）

```chim

# 不可变变量（默认）

age: int = 25

score: float = 98.5

active: bool = true

# 常量（编译期确定）

const pi: float = 3.14159

const max_size: int = 1000

const app_name: string = "Chim 2.0"

# 类型别名

type UserId = int

type UserName = string

type Email = string

```

### 函数定义（Elm风格）

```chim

# 单行函数

add a b = a + b

multiply x y = x * y

# 多行函数（缩进风格）

fib n =

match n

0 -> 0

1 -> 1

_ -> fib (n - 1) + fib (n - 2)

# 带类型注解的函数

sum list: [int] -> int =

match list

[] -> 0

x :: xs -> x + sum xs

# 泛型函数

first list: [T] -> Maybe T =

match list

[] -> Nothing

x :: _ -> Just x

```

### 数据结构定义（扁平化）

```chim

# 基础记录类型（类似TOML）

type Person =

age: int

city: string

active: bool

# 联合类型（Elm风格）

type Result =

| Success value: string

| Error message: string

| Loading

| Empty

type Maybe =

| Just value: T

| Nothing

# 列表和映射类型

type UserList = [User]

type StringMap = {string: string}

type IntMap[T] = {string: T}

# 复杂配置类型

type Config =

host: string

port: int

ssl: bool

timeout: int

database_url: string

max_connections: int

```

### 唯一控制流：Match表达式

```chim

# 基础匹配

result value =

match value

x if x > 0 -> "positive"

x if x < 0 -> "negative"

0 -> "zero"

_ -> "unknown"

# 列表匹配

sum numbers =

match numbers

[] -> 0

head :: tail -> head + sum tail

# 联合类型匹配

handle_result result =

match result

Success value ->

println "Success: " + value

value

Error message ->

println "Error: " + message

"default"

Loading ->

println "Loading..."

handle_result result

Empty -> "empty"

# 递归循环（取代while）

repeat count func =

match count

0 -> ()

n ->

func()

repeat (n - 1) func

# 条件循环（取代for）

for_each items func =

match items

[] -> ()

head :: tail ->

func(head)

for_each tail func

```

---

## 完整示例程序

### 1. 用户管理系统

```chim

# 类型定义

type User =

id: int

email: string

age: int

active: bool

type UserResult =

| UserFound user: User

| UserNotFound

| DatabaseError error: string

| ValidationError fields: [string]

# 用户查找

find_user id: int -> UserResult =

match id

1 -> UserFound (User 1 "Alice" "alice@email.com" 28 true)

2 -> UserFound (User 2 "Bob" "bob@email.com" 35 false)

3 -> UserFound (User 3 "Carol" "carol@email.com" 30 true)

_ -> UserNotFound

# 用户验证

validate_user user: User -> UserResult =

match user

u if u.age < 18 -> ValidationError ["age too young"]

u if not (is_valid_email u.email) -> ValidationError ["invalid email"]

u if not u.active -> ValidationError ["user inactive"]

_ -> UserFound user

# 格式化用户信息

format_user result: UserResult -> string =

match result

UserFound user ->

match user.active

true -> user.name + " (active, age " + str user.age + ")"

false -> user.name + " (inactive, age " + str user.age + ")"

UserNotFound -> "User not found"

DatabaseError error -> "Database error: " + error

ValidationError fields -> "Validation failed: " + join fields ", "

# 过滤活跃用户

filter_active users: [User] -> [User] =

match users

[] -> []

user :: rest ->

match user.active

true -> user :: filter_active rest

false -> filter_active rest

# 顶层代码执行

main =

user_result = find_user 2

formatted = format_user user_result

println formatted

all_users = [

User 1 "Alice" "alice@email.com" 28 true

User 2 "Bob" "bob@email.com" 35 false

User 3 "Carol" "carol@email.com" 30 true

User 4 "Dave" "dave@email.com" 16 false

]

active_users = filter_active all_users

println "Active users: " + str (length active_users)

```

### 2. 表达式求值器

```chim

# 表达式AST

type Expr =

| Number value: float

| Add left: Expr, right: Expr

| Subtract left: Expr, right: Expr

| Multiply left: Expr, right: Expr

| Divide left: Expr, right: Expr

| Variable name: string

| Assign name: string, value: Expr

# 环境（变量绑定）

type Env = {string: float}

# 求值函数

eval expr: Expr, env: Env -> float =

match expr

Number value -> value

Variable name ->

match env.get name

Just value -> value

Nothing -> 0.0 # 未定义变量

Add left right -> eval left env + eval right env

Subtract left right -> eval left env - eval right env

Multiply left right -> eval left env * eval right env

Divide left right ->

match eval right env

0.0 -> 0.0 # 除零保护

divisor -> eval left env / divisor

Assign name value ->

new_env = env.set name (eval value env)

eval value new_env

# 表达式转字符串

expr_to_string expr: Expr -> string =

match expr

Number value -> str value

Variable name -> name

Add left right -> "(" + expr_to_string left + " + " + expr_to_string right + ")"

Subtract left right -> "(" + expr_to_string left + " - " + expr_to_string right + ")"

Multiply left right -> "(" + expr_to_string left + " * " + expr_to_string right + ")"

Divide left right -> "(" + expr_to_string left + " / " + expr_to_string right + ")"

Assign name value -> name + " = " + expr_to_string value

# 简化表达式

simplify expr: Expr -> Expr =

match expr

Add (Number 0) right -> simplify right

Add left (Number 0) -> simplify left

Multiply (Number 1) right -> simplify right

Multiply left (Number 1) -> simplify left

Multiply (Number 0) _ -> Number 0

Multiply _ (Number 0) -> Number 0

Divide left (Number 1) -> simplify left

_ -> expr # 无法简化

# 测试用例

main =

expr1 = Number 5

expr2 = Add (Number 3) (Number 7)

expr3 = Multiply expr2 (Number 2)

expr4 = Simplify (Multiply (Number 0) (Number 100))

empty_env = {}

println "Expression 1: " + expr_to_string expr1

println "Expression 2: " + expr_to_string expr2

println "Expression 3: " + expr_to_string expr3

println "Simplified: " + expr_to_string expr4

println "Value 1: " + str (eval expr1 empty_env)

println "Value 2: " + str (eval expr2 empty_env)

println "Value 3: " + str (eval expr3 empty_env)

```

### 3. 列表处理工具

```chim

# 基础列表操作

length list: [T] -> int =

match list

[] -> 0

_ :: tail -> 1 + length tail

append list1 list2: [T] -> [T] =

match list1

[] -> list2

head :: tail -> head :: append tail list2

reverse list: [T] -> [T] =

match list

[] -> []

head :: tail -> append (reverse tail) [head]

# 列表映射

map func list: [T] -> [U] =

match list

[] -> []

head :: tail -> func head :: map func tail

# 列表过滤

filter predicate list: [T] -> [T] =

match list

[] -> []

head :: tail ->

match predicate head

true -> head :: filter predicate tail

false -> filter predicate tail

# 列表折叠

fold_left func acc list: [T] -> U =

match list

[] -> acc

head :: tail -> fold_left func (func acc head) tail

fold_right func list acc: [T] -> U =

match list

[] -> acc

head :: tail -> func head (fold_right func tail acc)

# 查找操作

find predicate list: [T] -> Maybe T =

match list

[] -> Nothing

head :: tail ->

match predicate head

true -> Just head

false -> find predicate tail

# 列表排序（快速排序）

quicksort list: [int] -> [int] =

match list

[] -> []

pivot :: rest ->

smaller = filter (x => x <= pivot) rest

larger = filter (x => x > pivot) rest

append (quicksort smaller) [pivot] ++ quicksort larger

# 列表生成器

range from: int, to: int -> [int] =

match (from <= to)

true -> from :: range (from + 1) to

false -> []

# 实用函数组合

double_all numbers = map (x => x * 2) numbers

sum_all numbers = fold_left (acc => x => acc + x) 0 numbers

evens_only numbers = filter (x => x % 2 == 0) numbers

# 使用示例

main =

numbers = [64, 34, 25, 12, 22, 11, 90]

doubled = double_all numbers

evens = evens_only numbers

sorted = quicksort numbers

total = sum_all numbers

println "Original: " + str numbers

println "Doubled: " + str doubled

println "Evens: " + str evens

println "Sorted: " + str sorted

println "Sum: " + str total

# 生成和计算

first_ten = range 1 10

sum_first_100 = sum_all (range 1 100)

println "1-10: " + str first_ten

println "Sum 1-100: " + str sum_first_100

```

---

## 模块系统

```chim

# 模块声明（每个文件开头）

module math

# 导出函数列表

export add subtract multiply divide power

# 数学函数

add a b = a + b

subtract a b = a - b

multiply a b = a * b

divide a b =

match b

0 -> 0

_ -> a / b

power base exponent =

match exponent

0 -> 1

n -> base * power base (n - 1)

# 使用模块

import math

main =

result = math.add 5 3

result2 = math.power 2 8

println "5 + 3 = " + str result

println "2^8 = " + str result2

```

---

## 高级特性

### 1. 函数组合

```chim

# 管道操作符

process_data data =

data

|> parse_int

|> double

|> format_result

|> validate

# 函数组合

double x = x * 2

format_result x = "Result: " + str x

validate result =

match result

"Result: 0" -> "Zero value"

_ -> result

# 柯里化

add x y = x + y

multiply x y = x * y

# 部分应用

add_five = add 5

multiply_by_two = multiply 2

```

### 2. 错误处理

```chim

# 错误类型

type ParseError =

| InvalidNumber string

| UnexpectedEnd

| InvalidFormat

# 安全解析

safe_divide a b: float -> Result float string =

match b

0.0 -> Error "Division by zero"

_ -> Success (a / b)

safe_parse_float str: string -> Result float ParseError =

match str

"" -> Error UnexpectedEnd

_ ->

match is_numeric str

true -> Success (float str)

false -> Error (InvalidNumber str)

# 使用错误处理

process_number str: string -> string =

match safe_parse_float str

Ok value ->

match safe_divide value 2.0

Success result -> "Half of " + str + " is " + str result

Error msg -> "Error: " + msg

Error err ->

match err

InvalidNumber s -> "Invalid number: " + s

UnexpectedEnd -> "Empty input"

InvalidFormat -> "Bad format"

```

---

## 语法规则速查

### Match 语法

```chim

# 基础模式

match expr

pattern1 -> result1

pattern2 -> result2

_ -> default_result

# 守卫条件

match value

x if x > 0 -> "positive"

x if x < 0 -> "negative"

_ -> "zero"

# 列表模式

match list

[] -> "empty"

head :: tail -> "has elements"

[a, b] -> "two elements"

x :: [] -> "single element"

# 记录模式

match person

Person name "John" age -> "Found John"

Person name age -> "Person: " + name

```

### 数据类型模式

```chim

# 基础类型

match value

0 -> "zero"

"" -> "empty string"

true -> "true"

null -> "null"

# 联合类型

match result

Success value -> "success: " + value

Error message -> "error: " + message

# Maybe类型

match maybe_value

Just value -> "has value: " + str value

Nothing -> "no value"

```

---

## 关键字列表

| 关键字 | 用途 | 示例 |

|--------|------|------|

| `match` | 模式匹配 | `match x with pattern -> result` |

| `type` | 类型定义 | `type Person = name: string` |

| `let` | 变量绑定 | `let x = 5` |

| `const` | 常量定义 | `const pi = 3.14` |

| `export` | 导出声明 | `export function_name` |

| `import` | 模块导入 | `import math` |

| `module` | 模块声明 | `module math` |

| `fn` | 函数定义 | `fn name args = expr` |

| `if` | 条件守卫 | `x if x > 0 -> "positive"` |

---

## 运算符列表

| 类别 | 运算符 | 说明 |

|------|--------|------|

| 算术 | `+`, `-`, `*`, `/` | 四则运算 |

| 比较 | `==`, `!=`, `<`, `<=`, `>`, `>=` | 比较运算 |

| 逻辑 | `&&`, `\|\|`, `!` | 逻辑运算 |

| 位运算 | `&`, `\|`, `^`, `<<`, `>>` | 位运算 |

| 范围 | `..` | 范围运算符 |

| 管道 | `\|>` | 函数组合 |

| 列表 | `::`, `++` | 列表操作 |

---

## 内置类型

```

# 基础类型

int # 整数

float # 浮点数

bool # 布尔值

string # 字符串

char # 字符

# 复合类型

[T] # 列表

{string: T} # 映射

(A, B) # 元组

# 联合类型

Maybe T # 可选值

Result T E # 错误处理

# 函数类型

T -> U # 函数

(T, U) -> V # 多元函数

```

---

## 缩进规则

- **使用空格缩进**（推荐 2 个空格）

- **冒号标记结构开始**

- **缩进增加进入新层级**

- **缩进减少退出层级**

```chim

function_call arg1 arg2

|> transform

|> another_function

match value

pattern1 ->

nested_expression

another_expression

pattern2 -> simple_expression

type RecordType =

field1: string

field2: int

nested_type:

sub_field: bool

```

---

## 与其他语言对比

|------|-----|---------|------|--------|----------|

| 函数定义 | `add a b = a + b` | `add a b = a + b` | `fn add(a: i32, b: i32) -> i32 { a + b }` | `def add(a, b): return a + b` | ✅ `add a b = a + b` |

| 模式匹配 | `case x of pattern -> result` | `case x of pattern -> result` | `match x { pattern => result }` | `if/elif/else` | ✅ `match x<br> pattern -> result` |

| 数据结构 | type Name = field: type | data Name = Name { field :: type } | struct Name { field: type } | class Name: | ✅ `type Name = field: type` |

| 缩进风格 | ✅ | ✅ | ❌ | ✅ | ✅ |

---

## 版本信息

| 属性 | 值 |

|------|-----|

| 语言版本 | Chim 2.0 |

| 语法风格 | **Elm + TOML 混合** |

| 主要影响 | Elm（函数式）、TOML（扁平化） |

| 设计理念 | **简洁、纯函数式、扁平化** |

| 目标 | 极简函数式编程语言 |

---

## 设计亮点

### 1. 极简主义

- **单一控制流**：所有逻辑都用 match 处理

- **扁平化结构**：避免深层嵌套

- **表达式导向**：所有语句都有返回值

### 2. 函数式纯度

- **不可变数据**：所有数据默认不可变

- **递归循环**：用递归取代 while/for

- **函数组合**：支持管道操作和柯里化

### 3. 现代化语法

- **类型注解**：`name: Type` 风格

- **模式匹配**：强大的 match 表达式

- **联合类型**：优雅的代数数据类型

### 4. 开发体验

- **顶层执行**：无需 main() 函数

- **缩进友好**：无大括号，视觉清晰

- **编译器友好**：简洁的语法树

Chim 2.0 代表了现代函数式编程语言的发展方向，融合了多种语言的精华，创造出独特而强大的语法体系。