Nolang：无垃圾回收的系统编程语言

Nolang：一门没有GC，却能把内存安全玩明白的系统编程语言

聊到系统编程语言，大家脑海里浮现的关键词，往往离不开“高性能”、“底层控制”，以及……“令人头疼的内存管理”。C/C++ 的性能无可挑剔，但悬垂指针、内存泄漏这些老问题，几乎是每位开发者绕不开的噩梦。而 Rust 通过所有权和生命周期机制提供了漂亮的解决方案，但陡峭的学习曲线也让不少人望而却步。

今天要介绍的 Nolang，走的是一条颇为“实验性”的路线。它同样是一门系统编程语言，同样将内存安全融入语言设计的核心，但它的设计思路，与我们熟悉的那些方案都不太相同。它没有垃圾回收（GC），却通过一套“安全作用域模型”实现了内存的绝对安全。这究竟是如何做到的？值得花时间将其设计拆开来看一看。

核心特性：为开发者减负，为性能让路

Nolang 的设计哲学，第一条就是“对开发者友好”。具体如何友好？简单来说：没有指针，没有所有权，没有生命周期。这几个在 Rust 中令人头大的概念，在 Nolang 这里直接被拿掉了。

它采用的模型是引用传递。所有函数参数都是引用，函数通过修改参数来返回结果。这意味着您无需像在 C 里那样小心翼翼传递指针，也无需像在 Rust 里那样纠结于“谁拥有这片内存”。

内存管理则交给安全作用域模型。变量离开作用域后自动释放，悬垂指针和内存泄漏这两个老大难问题，从语言层面就被彻底堵死。既然没有泄漏，自然也就不需要垃圾回收（GC）来“打扫战场”。

性能方面的考量也十分细致。小字符串在栈上分配，不涉及堆内存；变量原则上只分配一次、释放一次。加之方法重载通过单态化实现高效性能，整个语言的设计都透着一种“把性能压榨到极致”的态度。

结构体、接口、泛型（支持类型和数值泛型）、枚举……这些现代语言的标配功能，Nolang 也一一实现。它的 match 语法也做了独特的设计，使用起来更为简洁灵活。

快速上手：一眼就能看懂怎么用

语言的设计理念，最终还是要落实到写代码的体验上。这段代码示例基本展示了 Nolang 的核心用法：

// 不需要 main 入口，直接写逻辑
println('Hello, Nolang!')

// 变量声明
i64

// 函数通过参数返回结果
add(a i64, b i64, result i64) {
    result = a + b
}

// 标准库方法可以像普通函数一样用，有返回值
c = max(a, b)

// 结构体
user {
    name str
    age i64
}

u = user { name: 'Alice', age: 30 }

// 结构体方法
user.greet() {
    println('Hello, ' + self.name)
}

u.greet()

// 枚举
color {
    red,
    green,
    blue,
}

// 带参数的枚举
enum-name {
    a t,
    b u,
    c v,
}

// 定义接口
json {
    to-json()
}

// 实现接口
user json {
    name str
    age i64
}

// 接口默认实现
json.to-json() {
    return '{...}'
}

看到了吗？没有头文件、没有复杂的 main 函数签名、没有所有权的声明。函数参数默认就是引用，直接在参数上修改结果。结构体和方法写在一起，接口的实现也很直观。这种“少即是多”的设计，上手成本确实很低。

区间语法：写循环和切片就像写数学表达式

循环和数组切片是两种非常高频的操作。Nolang 的区间语法让它们变得异常清晰：

// 未来的 map, arr, vec 也适用
for i in [a..b] {   // 闭区间：a ≤ i ≤ b
    // a, a+1, ..., b
}

for i in (a..b] {   // 左开右闭：a < i ≤ b
    // a+1, a+2, ..., b
}

for i in [a..b) {   // 左闭右开：a ≤ i < b
    // a, a+1, ..., b-1
}

for i in (a..b) {   // 开区间：a < i < b
    // a+1, a+2, ..., b-1
}

// 递减
for i in [5..0] { }

// 只执行一次（包含5）
for i in [5..5] { }

// 不执行
for i in (5..5) { }

// 遍历字符串字符
for i in 'abc' { }

// 数组切片，用法和区间一致
nums[..]    // [0, 1, 2, 3, 4]
nums[1..]   // [1, 2, 3, 4]
nums[..3]   // [0, 1, 2]
nums[1..3]  // [1, 2, 3]
nums[1..3)  // [1, 2]

这种语法直观到什么程度？您几乎可以直接把数学上的区间记法照搬到代码里，无需去想“这个函数是左闭右开还是左闭右闭”。这正是优秀语言设计应有的样子——让开发者聚焦逻辑，而非记忆语言的特殊规则。

match：兼具语句和表达式的双重身份

Nolang 的 match 设计也是一大亮点。它既可以作为语句执行，也可以作为表达式返回值：

// 作为语句：分支体是一个代码块
x {
    1| 
        a = 1
        b = 2   // 多行，不返回值
    2| 
        do-something()
    | 
        c = 0
}

// 作为表达式：分支体返回一个值
result = x {
    1| 1          // 单一值
    2| 2 + 1      // 简单表达式
    | a + b
}

// 特殊 match：没有需要返回的值，按条件匹配
{
    a == 1| 
        a = 1
        b = 2
    a == 2| 
        do-something()
    | 
        c = 0
}

// 判断返回值可能出错的情况
// it 用于取参数
x {
    err| log(it)
    nil| log('nil')
    | do-right-thing(it)
}

实际编码中最常用的场景，可能还是最后那个——处理可能有错误或空值的返回值。无需 if-else 嵌套，一个 match 清晰搞定。

可空类型：优雅地处理“可能有值也可能没有”

对于可能为空或出错的场景，Nolang 提供了内置的可空类型支持：

// 声明一个可空字符串
nullableString ?str

// 赋值
nullableString = 'test'

// 设置错误
nullableString = err('some error')

// 通过 match 判断
x {
    err| log(it)
    nil| 
    | do-right-thing(it)
}

这种设计将“空值”和“错误”统一进了一种类型系统，开发者无需在代码里到处写 if (ptr != NULL) 或 try-catch。match 天然适合处理这种多分支的情况，代码更加简洁、安全。

总的来说，Nolang 为我们展示了一种系统编程语言的新可能：它放弃了指针和所有权这些传统上被认为“为了高性能必须有的东西”，转而用引用传递和安全作用域模型来实现内存安全。没有 GC、性能优先，同时对开发者足够友好。

当然，作为一门实验性语言，它还远谈不上成熟。但它的设计思路——在安全、性能、易用性三者之间找到一个全新的平衡点——确实值得关注与思考。如果您对编程语言的底层设计感兴趣，不妨亲自体验一下 Nolang。