Diem Move 语言循环完全指南:while、loop、break 与 continue 的语法、类型与源码实现

原创2026-09-21 17:37:181,946 阅读
文章标签:区块链金融科技

Diem Move 语言循环完全指南:while、loop、break 与 continue 的语法、类型与源码实现

导读

本文是 Diem 区块链的 Move 智能合约语言编程指南系列之一,完整讲解 Move 中仅有的两种循环构造 while 与 loop,以及配套的 break、continue 表达式。读完本文,你将掌握 Move 循环的完整语法、break/continue 独有的"任意类型"灵活语义、while/loop 表达式本身的类型规则,并能结合源码理解循环从解析、类型检查到中间表示(HLIR/CFGIR)的完整编译路径。文中的所有代码示例与结论均可直接用于编写可编译的 Move 模块与脚本。

Move 中的循环构造概览

Move 语言(本仓库中位于 language/ 目录)为开发者提供了两种循环构造:

  • while 循环:先判断布尔条件,条件为 true 时重复执行循环体;
  • loop 表达式:无条件反复执行循环体,直到在循环体内遇到 break。

两者都以"表达式"(expression)而非"语句"的形式存在——这在 Move 中是一个重要事实,因为 Move 中几乎一切都是表达式,循环也不例外,它们的类型规则会在后文专门讨论。

while 循环

while 构造的语法为 while (condition) body,其中:

  • condition 必须是类型为 bool 的表达式;
  • body(循环体)必须是类型为 unit(即 ())的表达式。

循环体被反复执行,直到条件求值结果为 false。

下面的示例是一个简单的 while 循环,计算从 1 到 n 的整数之和:

fun sum(n: u64): u64 {
    let sum = 0;
    let i = 1;
    while (i <= n) {
        sum = sum + i;
        i = i + 1
    };

    sum
}

注意示例中的两个细节:

  1. while 的条件 (i <= n) 必须用圆括号包裹(语法解析层面的强制要求,详见下文源码分析);
  2. 循环体内部最后一条表达式 i = i + 1 之后没有分号,整个 while 表达式以分号 ; 结束,然后函数返回 sum。

无限循环是合法的

只要条件永远不为 false,while 就会一直执行下去。Move 允许无限循环存在:

fun foo() {
    while (true) { }
}

无限循环(以及下文的无 break 的 loop)在类型系统中属于"发散"表达式,Move 编译器会依据其类型规则做出特殊处理,这一点在 while 与 loop 的类型一节中会详细展开。

break:提前退出循环

break 表达式用于在条件尚未求值为 false 时提前退出循环。

例如,下面的循环使用 break 找到 n 的大于 1 的最小因子:

fun upper_bound_sqrt(n: u64): u64 {
    // assuming the input is not 0 or 1
    let i = 2;
    while (i <= n) {
        if (n % i == 0) break;
        i = i + 1
    };

    i
}

当 n % i == 0 成立时,break 立即终止 while 循环,此时 i 就是 n 的最小因子,函数返回该值。

使用限制:break 表达式不能用在循环之外。这一点不仅在文档层面声明,也在编译器的类型检查阶段强制实施——见下文"源码实现"中的 LoopInfo 追踪机制。

continue:跳过本次迭代剩余部分

continue 表达式会跳过循环体的剩余部分,直接进入下一次迭代。

下面的循环计算 1, 2, ..., n 之和,但跳过所有能被 10 整除的数:

fun sum_intermediate(n: u64): u64 {
    let sum = 0;
    let i = 1;
    while (i <= n) {
        if (i % 10 == 0) continue;
        sum = sum + i;
        i = i + 1
    };

    sum
}

当 i % 10 == 0 时,continue 会让控制流直接回到循环条件判断,跳过 sum = sum + i 与 i = i + 1。

使用限制:与 break 相同,continue 表达式也不能用在循环之外。

break 与 continue 的类型:Move 独有的灵活性

这是 Move 循环最值得注意的语言特性之一:break 和 continue,就像 return 和 abort 一样,可以具有任意类型。

这意味着它们可以作为任意需要值的表达式位置出现,而不会产生类型错误。下面的两个示例展示了这种灵活类型的实际用途。

示例一:break 具有任意类型

下面的函数同时从两个向量(vector)尾部弹出元素,每次取出较小的那个,直到两个向量有一个为空,返回收集结果的向量:

fun pop_smallest_while_not_equal(
    v1: vector<u64>,
    v2: vector<u64>,
): vector<u64> {
    let result = Vector::empty();
    while (!Vector::is_empty(&v1) && !Vector::is_empty(&v2)) {
        let u1 = *Vector::borrow(&v1, Vector::length(&v1) - 1);
        let u2 = *Vector::borrow(&v1, Vector::length(&v1) - 1);
        let popped =
            if (u1 < u2) Vector::pop_back(&mut v1)
            else if (u2 < u1) Vector::pop_back(&mut v2)
            else break; // Here, `break` has type `u64`
        Vector::push_back(&mut result, popped);
    };

    result
}

关键点在于注释标注的位置:let popped = ... else break;。在这个上下文中,if-else 表达式期望产生一个 u64 类型的值,而 break 被赋予了类型 u64,因此类型检查可以通过。

示例二:continue 具有任意类型

fun pick(
    indexes: vector<u64>,
    v1: &vector<address>,
    v2: &vector<address>
): vector<address> {
    let len1 = Vector::length(v1);
    let len2 = Vector::length(v2);
    let result = Vector::empty();
    while (!Vector::is_empty(&indexes)) {
        let index = Vector::pop_back(&mut indexes);
        let chosen_vector =
            if (index < len1) v1
            else if (index < len2) v2
            else continue; // Here, `continue` has type `&vector<address>`
        Vector::push_back(&mut result, *Vector::borrow(chosen_vector, index))
    };

    result
}

同理,这里 if-else 需要产生一个 &vector<address> 类型的引用,continue 被赋予该类型,于是合法。

这种设计背后的原理是:break、continue(以及 return、abort)是"发散"(diverging)控制流,它们永远不会正常地"产生"一个值,因此可以兼容任何预期类型——这与许多现代编程语言中的 bottom type(如 Rust 的 !)思想一致。Move 文档中明确说明 break/continue 的类型约束与 return/abort 相同。

loop 表达式

loop 表达式会反复执行循环体(类型为 () 的表达式),直到遇到 break。它的语法是 loop body,与 while 不同,loop 不需要也不允许在关键字后写括号条件——它本身就是无条件的。

没有 break 时永不停止

fun foo() {
    let i = 0;
    loop { i = i + 1 }
}

上面的 loop 没有 break,会无限执行下去。

用 loop 重写 sum

下面是用 loop 实现前文 sum 函数的版本,通过 if (i > n) break; 主动退出:

fun sum(n: u64): u64 {
    let sum = 0;
    let i = 0;
    loop {
        i = i + 1;
        if (i > n) break;
        sum = sum + i
    };

    sum
}

在 loop 中使用 continue

continue 同样可以用于 loop。前文的 sum_intermediate(跳过被 10 整除的数)用 loop 改写如下:

fun sum_intermediate(n: u64): u64 {
    let sum = 0;
    let i = 0;
    loop {
        if (i % 10 == 0) continue;
        i = i + 1;
        if (i > n) break;
        sum = sum + i
    };

    sum
}

注意这个版本与 while 版本在语义上的细微差别:由于 continue 会直接跳到下一次迭代的开头,这里把 i = i + 1 放在 continue 之后、break 判断之前,确保被 continue 跳过的迭代不会漏掉递增。这个例子也提醒我们:在改写循环构造时,continue 的跳转位置会直接影响变量更新的时机。

while 与 loop 的类型

Move 的循环是"有类型的表达式"(typed expressions),理解这一点对编写类型正确的代码至关重要。

while 表达式的类型永远是 ()

无论循环体是什么,while 表达式整体始终具有 unit 类型:

let () = while (i < 10) { i = i + 1 };

上面的 let () = ... 语法明确将 while 表达式的类型绑定为 (),这是合法的。

含 break 的 loop 类型为 ()

如果 loop 中包含 break,那么该 loop 表达式的类型就是 unit ():

(loop { if (i < 10) i = i + 1 else break }: ());
let () = loop { if (i < 10) i = i + 1 else break };

第一行用显式类型标注 : () 断言,第二行用 let () = ... 绑定验证。

无 break 的 loop 具有任意类型

如果 loop 中没有 break,那么它永远不会正常结束,属于发散表达式,可以具有任何类型——这与 return、abort、break、continue 的行为一致:

(loop (): u64);
(loop (): address);
(loop (): &vector<vector<u8>>);

同一个 loop () 可以分别被断言为 u64、address 甚至嵌套引用类型 &vector<vector<u8>>,全部合法。这个特性可用于"已知不会返回"的占位位置。

源码实现:从语法解析到控制流表示

本文档所在仓库的 Move 语言编译器实现(language/move-lang/)完整支撑了上述语法与类型规则。下面沿着编译管线梳理循环相关的实现证据。

语法解析:while 必须带括号,loop 直接跟表达式

在 语言解析器 中,parse_exp 函数对两种循环的解析逻辑非常清晰:

  • 遇到 Tok::While 时,先 consume_token(tokens, Tok::LParen) 消费左括号,解析条件表达式后再消费右括号,最后解析循环体,构造 Exp_::While(eb, eloop);
  • 遇到 Tok::Loop 时,直接解析循环体表达式,构造 Exp_::Loop(eloop),不需要括号。

对应地,语法 AST 定义 中:

While(Box<Exp>, Box<Exp>),
Loop(Box<Exp>),

While 携带两个表达式(条件与循环体),Loop 只携带一个表达式。这从语法层面解释了为什么 while 的条件必须用圆括号包裹,而 loop 不能带条件。

类型检查:break/continue 必须位于循环内部

在类型检查阶段,编译器需要确认 break 与 continue 没有被用在循环之外。从 类型检查核心 的实现可以看到一个专门的追踪机制:

LoopInfo_::NotInLoop => panic!("ICE exit_loop called while not in a loop"),

类型检查器通过维护循环上下文信息(LoopInfo)来判断 break/continue 是否合法:只有当当前正处于某个循环内部时,"退出循环"操作才是被允许的;否则会触发内部错误。这正是文档中"break 表达式不能用在循环之外""continue 表达式不能用在循环之外"两条规则的编译器级保障。

中间表示:HLIR 中的循环节点与跳转命令

解析与类型检查之后,循环会被翻译到高层中间表示 HLIR。在 HLIR AST 定义 中可以看到循环的正式表示:

pub enum Statement_ {
    ...
    While {
        cond: (Block, Box<Exp>),
        block: Block,
    },
    Loop {
        block: Block,
        has_break: bool,
    },
    ...
}

pub enum Command_ {
    ...
    Break,
    Continue,
    ...
}

两个值得注意的实现细节:

  1. Loop 节点带有 has_break 标记:HLIR 在翻译 loop 时会记录该循环体内是否出现过 break,这个标记正是前文"含 break 的 loop 类型为 ()、无 break 的 loop 可以是任意类型"这一类型规则的直接依据;
  2. Break 与 Continue 被建模为命令(Command):它们与 Abort、Return 并列,在后续的 CFGIR(控制流图中间表示)阶段会被转换为基本块之间的跳转,最终映射到底层字节码中的分支指令。

在 HLIR 翻译器 中可以看到 Exp_::While、Exp_::Loop、TE::Break、TE::Continue 分别被转换为上述 HLIR 语句与命令的过程。

测试用例:循环语义的正确性验证

仓库中提供了大量与循环相关的编译测试,用于验证上述语义。这些测试分布在 language/move-lang/tests/move_check/ 目录下:

特别值得关注的是 liveness/trailing_semi_loops.move 中的这段用例,它同时覆盖了 loop 的类型断言、continue/break 在条件分支中的使用,以及循环体变量在退出后的延续使用:

script {
    fun main(cond: bool) {
        let x;
        loop {
            if (cond) {
                x = 1;
                break
            } else {
                x = 2;
                continue
            };
        };
        x;
    }
}

这里 loop 中同时存在 break 与 continue,两个分支都先为 x 赋值;循环退出后 x 被继续使用——类型检查器需要能够证明无论走哪条路径,x 都已被初始化。这正是 Move 控制流分析在循环场景下的核心验证目标。

小结与实践要点

  • Move 只有两种循环构造:while (cond) body 与 loop body,且它们都是表达式;
  • while 的条件必须是 bool 类型、必须用圆括号包裹,循环体类型必须为 ();
  • loop 无条件执行,只能通过循环体内的 break 退出;
  • break 与 continue 只能出现在循环内部(编译器通过 LoopInfo 上下文强制检查);
  • break、continue 与 return、abort 一样,可以具有任意类型,可在需要特定类型值的位置使用;
  • while 表达式的类型恒为 ();含 break 的 loop 类型为 ();无 break 的 loop(发散)可以是任意类型;
  • 改写循环构造时要注意 continue 的跳转位置对循环体变量更新时机的影响。

掌握这些规则,你就能在 Diem Move 智能合约中安全、高效地编写各种循环逻辑,并理解其背后的编译期保证。

登录后查看全文
diem