Chim（启语） 4.0.0 语法规范

原创已于 2026-02-14 13:07:22 修改 · 612 阅读

20 ·

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

GEO检测

标签

#算法 #青少年编程 #开发语言 #编辑器 #华为

于 2026-02-10 14:25:04 首次发布

Chim 4.0.0 语法规范

1. 概述

1.1 版本信息

版本：4.0.0
发布日期：2026-02-10
设计目标：分层安全模型，简化的控制流，高效的并发，无运行时依赖

1.2 核心特性

双层安全模型：Safe 模式提供完全内存安全，Base 模式提供底层控制
统一并发模型：使用 routine 和 channel 实现并发
无运行时：所有代码编译为原生机器码，无垃圾收集器
嵌入资源：支持 C23 embed 语法糖
极简控制流：只保留 match 语法，移除 if-else 和 for

1.3 设计原则

安全性优先：Safe 模式强制内存安全，Base 模式提供选择性控制
简洁性：减少语法结构，提高代码一致性
表达力：在简化约束下保持强大表达能力
性能：零成本抽象，适合系统级编程
可实现性：语法设计清晰无歧义

2. 模式分层

2.1 Safe 模式

Safe 模式提供完全内存安全保证，类似于 Elm 的纯粹性和 Nim 的优雅：

# 文件顶部声明模式
safe

fn factorial(n: int): int
  match n
    0 | 1 => 1
    _ => n * factorial(n - 1)

特性：

强制所有权和借用检查
禁止原始指针操作
自动内存管理
纯函数鼓励

2.2 Base 模式

Base 模式提供底层系统编程能力，类似于 Zig 的直接控制：

# 文件顶部声明模式
base

fn memset(dest: *u8, value: u8, size: usize): *u8
  let ptr = dest
  for i in 0..size
    ptr[i] = value
  ptr

特性：

支持原始指针运算
可选的所有权约束
直接内存访问
内联汇编支持

2.3 混合使用

可以在同一个项目中混合使用两种模式：

# safe_utils.chim
safe

pub fn safe_add(a: int, b: int): int
  a + b

# base_memory.chim
base

pub fn alloc(size: usize): *u8
  sys.malloc(size)

3. 基本语法

3.1 语法风格

缩进：使用 4 个空格作为标准缩进
分号：语句结束不需要分号
括号：通过缩进和冒号组织代码块
注释：使用 # 进行单行注释

3.2 标识符

命名规则：由字母、数字和下划线组成，不能以数字开头
大小写敏感：区分大小写
关键字：不能使用关键字作为标识符

3.3 关键字

safe      # Safe 模式声明
base      # Base 模式声明
let       # 不可变变量声明
var       # 可变变量声明
fn        # 函数定义
routine   # 并发执行单元
channel   # 消息传递通道
pub       # 导出修饰符
import    # 模块导入
as        # 别名/类型转换
return    # 返回值
break     # 跳出循环
continue  # 继续下一次迭代
embed     # 嵌入资源
match     # 模式匹配
true      # 布尔真
false     # 布尔假
null      # 空指针
self      # 当前实例

4. 数据类型

4.1 基本类型

整数类型：

int       # 平台相关有符号整数
u8        # 8位无符号整数
u16       # 16位无符号整数
u32       # 32位无符号整数
u64       # 64位无符号整数
u128      # 128位无符号整数
i8        # 8位有符号整数
i16       # 16位有符号整数
i32       # 32位有符号整数
i64       # 64位有符号整数
i128      # 128位有符号整数
usize     # 平台相关无符号整数（指针大小）
isize     # 平台相关有符号整数

浮点类型：

float     # 32位浮点数
double    # 64位浮点数

其他类型：

bool      # 布尔类型（true 或 false）
char      # Unicode 字符
string    # 字符串（不可变）
byte      # 字节（u8 别名）

4.2 复合类型

数组：

[ int ]           # 整数数组
[ byte, 1024 ]    # 固定大小字节数组

元组：

(int, string)           # 二元元组
(bool, int, float)      # 三元元组

Record：

{ name: string, age: int }
{ x: float, y: float }

4.3 函数类型

fn(int, int) -> int           # 接收两个int，返回int
fn(string) -> void            # 接收string，无返回值
fn(*u8, usize) -> *u8         # 指针参数，返回指针

4.4 指针类型

Base 模式支持：

*T                    # 不可变指针
*mut T                # 可变指针
*const T               # 常量指针

4.5 引用类型

Safe 模式支持：

&T                     # 不可变引用
&mut T                 # 可变引用

5. 控制流

5.1 Match 语法

Match 是唯一的控制流结构，用于所有条件判断和模式匹配场景。

5.1.1 基本模式匹配

match value
  0 => "Zero"
  1 => "One"
  2 => "Two"
  _ => "Other"

5.1.2 条件判断

match x > 0
  true => "Positive"
  false =>
    match x < 0
      true => "Negative"
      false => "Zero"

5.1.3 复合模式

match (x, y)
  (0, 0) => "Origin"
  (0, _) => "Y-axis"
  (_, 0) => "X-axis"
  _ => "Other"

5.1.4 范围模式

match age
  0..12 => "Child"
  13..19 => "Teenager"
  20..59 => "Adult"
  _ => "Senior"

5.1.5 守卫表达式

match n
  n if n < 0 => "Negative"
  n if n == 0 => "Zero"
  n => "Positive"

5.1.6 解构 Record

match person
  { name: "Alice", age } => "Alice is " ++ age ++ " years old"
  { name, age: 18 } => name ++ " just turned 18"
  { name, age } => name ++ " is " ++ age ++ " years old"

5.2 循环结构

虽然移除了传统的 for 循环，但仍可通过 match 实现循环：

# 模拟 while 循环
let condition = true
loop condition
  match should_continue()
    true => continue
    false =>
      condition = false
      break
  # 循环体

# 遍历范围
for i in 0..10
  process(i)

# 遍历数组
for item in items
  process(item)

for 语句语法：

for <variable> in <iterator>
  <body>

for <variable>, <index> in <iterator>
  <body>

6. 并发模型

6.1 Routine

Routine 是轻量级执行单元，类似协程。

6.1.1 创建 Routine

# 简单 routine
routine
  print("Hello from routine")

# 带参数 routine
routine (name: string)
  print("Hello ", name)
("Alice")

# 多 routine
for i in 0..4
  routine (id: int)
    print("Routine ", id)
(i)

6.1.2 Routine 通信

let ch = channel[string]()

routine (ch: channel[string])
  ch.send("Message 1")
  ch.send("Message 2")
(ch)

routine (ch: channel[string])
  match ch.recv()
    msg => print("Received: ", msg)
(ch)

6.2 Channel

Channel 用于 routine 之间的消息传递。

6.2.1 创建 Channel

# 无缓冲 channel
let ch = channel[int]()

# 有缓冲 channel
let ch = channel[int](10)

6.2.2 发送和接收

# 发送数据
ch.send(42)

# 接收数据
let value = ch.recv()

# 尝试接收（非阻塞）
match ch.try_recv()
  Ok(v) => print(v)
  Err => print("No message")

6.2.3 关闭 Channel

ch.close()

6.2.4 遍历 Channel

for value in ch
  print(value)

6.3 并发模式

6.3.1 生产者-消费者

fn producer_consumer()
  let ch = channel[int](5)

  routine (ch: channel[int])
    for i in 0..10
      ch.send(i)
    ch.close()
  (ch)

  routine (ch: channel[int])
    for msg in ch
      print("Received: ", msg)
  (ch)

6.3.2 并行计算

fn parallel_sum(list: [int]): int
  let ch = channel[int]()
  let len = list.len()
  let mid = len / 2

  routine (ch: channel[int], list: [int], start: int, end: int)
    let sum = 0
    for i in start..end
      sum = sum + list[i]
    ch.send(sum)
  (ch, list, 0, mid)

  routine (ch: channel[int], list: [int], start: int, end: int)
    let sum = 0
    for i in start..end
      sum = sum + list[i]
    ch.send(sum)
  (ch, list, mid, len)

  let sum1 = ch.recv()
  let sum2 = ch.recv()
  sum1 + sum2

7. 函数定义

7.1 基本函数

fn add(a: int, b: int): int
  a + b

fn greet(name: string): void
  print("Hello, ", name)

7.2 匿名函数

let add = fn(a: int, b: int): int
  a + b

let apply = fn(f: fn(int) -> int, x: int): int
  f(x)

7.3 高阶函数

fn map(list: [int], f: fn(int) -> int): [int]
  let result = []
  for item in list
    result.push(f(item))
  result

fn filter(list: [int], f: fn(int) -> bool): [int]
  let result = []
  for item in list
    match f(item)
      true => result.push(item)
      false => none
  result

7.4 多态函数

fn first[T](list: [T]): T
  list[0]

8. 类型系统

8.1 类型声明

# 显式类型
let age: int = 25
let name: string = "Alice"

# 类型推断
let price = 9.99  # float
let is_valid = true  # bool

8.2 类型别名

type IntList = [int]
type Point = { x: float, y: float }
type Callback = fn(*void) -> void

8.3 泛型类型

struct Option[T]
  value: T
  is_some: bool

struct Result[T, E]
  ok: T
  err: E
  is_ok: bool

8.4 类型转换

# Safe 模式
let num = 42
let float_num = num as float

# Base 模式
let ptr = 0x1000 as *int

9. Safe 模式特性

9.1 所有权系统

safe

fn take_ownership(value: [int]): int
  value[0]

fn borrow_example(list: &[int]): int
  list[0]

fn mutate_example(list: &mut [int]): void
  list[0] = 42

9.2 生命周期

safe

fn longest<'a>(s1: &'a string, s2: &'a string): &'a string
  match s1.len() > s2.len()
    true => s1
    false => s2

9.3 错误处理

safe

fn divide(a: int, b: int): Result[int, string]
  match b == 0
    true => Err("Division by zero")
    false => Ok(a / b)

# 使用
match divide(10, 0)
  Ok(result) => print(result)
  Err(e) => print("Error: ", e)

10. Base 模式特性

10.1 指针操作

base

fn pointer_demo()
  let x: int = 42
  let ptr: *int = &x
  
  let arr = [1, 2, 3, 4, 5]
  let arr_ptr: *int = &arr[0]
  
  # 指针运算
  let second = arr_ptr + 1
  *second = 100

10.2 内存管理

base

fn manual_memory()
  # 分配
  let buf: *u8 = sys.malloc(1024)
  
  match buf == null
    true => print("Allocation failed")
    false =>
      # 使用
      sys.memset(buf, 0, 1024)
      
      # 释放
      sys.free(buf)

10.3 内存复制

base

fn memcpy_demo()
  let src = [1, 2, 3, 4, 5]
  let dst: *int = sys.malloc(20)
  
  sys.memcpy(dst as *void, src as *void, 20)

10.4 直接硬件访问

base

fn write_serial(port: u16, data: u8): void
  let port_ptr = port as *u8
  *port_ptr = data

fn read_framebuffer(): void
  let fb = 0xB8000 as *u32
  fb[0] = 0x0720  # 绿色背景，白色字符

10.5 内联汇编

base

fn cpu_id(): u32
  asm
    "mov eax, 0"
    "cpuid"
    "mov eax, ebx"
  end

fn halt(): void
  asm "hlt" end

11. 资源嵌入

11.1 Embed 语法

支持 C23 风格的资源嵌入语法：

# 嵌入文本文件
embed "assets/config.json" as config_json: string

# 嵌入二进制文件
embed "assets/image.png" as image_data: [byte]

# 嵌入多个资源
embed {
  "shader.vert" as vert_shader: string,
  "shader.frag" as frag_shader: string,
  "texture.atlas" as atlas: [byte]
}

11.2 使用示例

base

embed "assets/shader.glsl" as shader_source: string

fn load_shader(): void
  print("Shader loaded: ", shader_source.len(), " bytes")

fn main()
  let shader = shader_source
  # 使用着色器

12. 模块系统

12.1 模块定义

每个文件是一个独立模块，模块名默认与文件名相同：

# 文件：math.chim
pub fn add(a: int, b: int): int
  a + b

pub fn multiply(a: int, b: int): int
  a * b

let PI: float = 3.14159

12.2 导入模块

# 导入整个模块
import math
math.add(1, 2)

# 导入特定符号
import math { add, multiply }
add(1, 2)

# 重命名导入
import math as m
m.add(1, 2)

# 相对导入
import ./utils
import ../other/module

12.3 导出控制

# 显式导出
pub fn public_function(): void
  # ...

fn private_function(): void
  # ...

# 条件导出
pub fn conditional_export(x: int): int
  match x > 0
    true => x
    false => 0

13. 标准库

13.1 核心模块

# prelude - 自动导入
# 提供基础类型和函数

# io - 输入输出
import io
io.print("Hello")
io.read_line()

# sys - 系统调用
import sys
sys.exit(0)
sys.sleep(1000)

# str - 字符串操作
import str
let s = "Hello"
str.len(s)
str.concat("Hello", " World")
str.split("a,b,c", ",")

13.2 容器模块

# vec - 动态数组
import vec
let v = vec.new[int]()
v.push(1)
v.push(2)
let first = v[0]

# map - 哈希表
import map
let m = map.new[string, int]()
m.set("key", 42)
let value = m.get("key")

13.3 并发模块

# sync - 同步原语
import sync
let mutex = sync.mutex.new()
sync.mutex.lock(&mutex)
# 临界区
sync.mutex.unlock(&mutex)

# atomic - 原子操作
import atomic
let counter = atomic.i32.new(0)
atomic.add(&counter, 1)

14. 语法示例

14.1 Safe 模式示例

safe

# 计算斐波那契数列
fn fib(n: int): int
  match n
    0 | 1 => n
    _ => fib(n - 1) + fib(n - 2)

# 列表处理
fn process_list(list: &[int]): int
  let sum = 0
  for item in list
    match item > 0
      true => sum = sum + item
      false => none
  sum

# 主函数
pub fn main(): int
  for i in 0..10
    io.print("Fib(", i, ") = ", fib(i))
  0

14.2 Base 模式示例

base

# 内存管理示例
fn memory_demo(): void
  let size = 1024
  let buf = sys.malloc(size)
  
  match buf == null
    true => 
      io.print("Allocation failed")
      return
    
    false =>
      sys.memset(buf, 0, size)
      
      # 使用内存
      let ptr = buf as *int
      ptr[0] = 42
      ptr[1] = 100
      
      io.print("First: ", ptr[0])
      io.print("Second: ", ptr[1])
      
      sys.free(buf)

# 主函数
pub fn main(): int
  memory_demo()
  0

14.3 并发示例

safe

# 并行计算示例
pub fn main(): int
  let list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  let sum = parallel_sum(list)
  io.print("Sum: ", sum)
  0

fn parallel_sum(list: &[int]): int
  let ch = channel[int]()
  let len = list.len()
  let mid = len / 2
  
  routine (ch: channel[int], list: &[int], start: int, end: int)
    let sum = 0
    for i in start..end
      sum = sum + list[i]
    ch.send(sum)
  (ch, list, 0, mid)
  
  routine (ch: channel[int], list: &[int], start: int, end: int)
    let sum = 0
    for i in start..end
      sum = sum + list[i]
    ch.send(sum)
  (ch, list, mid, len)
  
  let sum1 = ch.recv()
  let sum2 = ch.recv()
  sum1 + sum2

14.4 资源嵌入示例

base

embed "assets/styles.css" as css_content: string
embed "assets/script.js" as js_content: string

pub fn load_web_resources(): void
  io.print("CSS loaded: ", css_content.len(), " bytes")
  io.print("JS loaded: ", js_content.len(), " bytes")