语句

Let 语句

在 : 之后和 = 的两侧（如果存在）放置一个空格。不要在分号前放置空格。

#![allow(unused)]
fn main() {
// A comment.
let pattern: Type = expr;

let pattern;
let pattern: Type;
let pattern = expr;
}

如果可能，将声明格式化为单行。如果不可能，则尝试在 = 之后拆分，如果声明适合两行。块缩进表达式。

#![allow(unused)]
fn main() {
let pattern: Type =
    expr;
}

如果第一行仍然不适合单行，则在 : 之后拆分，并使用块缩进。如果类型需要多行，即使在 : 之后换行后，也应将第一行放在与 : 相同的行上，但要遵守组合规则。

#![allow(unused)]
fn main() {
let pattern:
    Type =
    expr;
}

例如，

#![allow(unused)]
fn main() {
let Foo {
    f: abcd,
    g: qwer,
}: Foo<Bar> =
    Foo { f, g };

let (abcd,
    defg):
    Baz =
{ ... }
}

如果表达式跨越多行，则如果表达式的第一行适合剩余空间，则它会与 = 保持在同一行，并且表达式的其余部分不会进一步缩进。如果第一行不适合，则将表达式放在后续行上，并块缩进。如果表达式是一个块，并且类型或模式跨越多行，则将左大括号放在新行上并且不缩进（这为块的内部提供了与类型的分隔）；否则，左大括号跟在 = 后面。

示例

#![allow(unused)]
fn main() {
let foo = Foo {
    f: abcd,
    g: qwer,
};

let foo =
    ALongName {
        f: abcd,
        g: qwer,
    };

let foo: Type = {
    an_expression();
    ...
};

let foo:
    ALongType =
{
    an_expression();
    ...
};

let Foo {
    f: abcd,
    g: qwer,
}: Foo<Bar> = Foo {
    f: blimblimblim,
    g: blamblamblam,
};

let Foo {
    f: abcd,
    g: qwer,
}: Foo<Bar> = foo(
    blimblimblim,
    blamblamblam,
);
}

else 块（let-else 语句）

let 语句可以包含一个 else 组件，使其成为 let-else 语句。在这种情况下，始终将相同的格式化规则应用于 else 块之前的组件（即 let pattern: Type = initializer_expr 部分），如 其他 let 语句中所述。

如果以下所有条件都为真，则将整个 let-else 语句格式化为单行

• 整个语句是短的
• else 块仅包含单行表达式且不包含语句
• else 块不包含注释
• else 块之前的 let 语句组件可以格式化为单行

#![allow(unused)]
fn main() {
let Some(1) = opt else { return };
}

否则，let-else 语句需要一些换行符。

如果在多行上分隔 let-else 语句，则永远不要在 else 和 { 之间分隔，并且始终在 } 之前分隔。

如果 else 之前的 let 语句组件可以格式化为单行，但 let-else 不符合完全放在单行上的条件，则将 else { 与初始化表达式放在同一行，它们之间有一个空格，然后在 { 之后换行。缩进关闭的 } 以匹配 let，并将包含的块进一步缩进一级。

#![allow(unused)]
fn main() {
let Some(1) = opt else {
    return;
};

let Some(1) = opt else {
    // nope
    return
};
}

如果 else 之前的 let 语句组件可以格式化为单行，但 else { 不适合放在同一行上，则在 else 之前换行。

#![allow(unused)]
fn main() {
    let Some(x) = some_really_really_really_really_really_really_really_really_really_long_name
    else {
        return;
    };
}

如果初始化表达式是多行的，则将 else 关键字和块的左大括号（即 else {）与初始化表达式的末尾放在同一行上，它们之间有一个空格，当且仅当以下所有条件都为真时

• 初始化表达式以一个或多个右括号、方括号和/或大括号结尾
• 该行上没有其他内容
• 该行的缩进级别与初始 let 关键字相同。

例如

#![allow(unused)]
fn main() {
let Some(x) = y.foo(
    "abc",
    fairly_long_identifier,
    "def",
    "123456",
    "string",
    "cheese",
) else {
    bar()
}
}

否则，将 else 关键字和左大括号放在初始化表达式末尾之后的下一行，else 关键字的缩进级别与 let 关键字相同。

例如

fn main() {
    let Some(x) = abcdef()
        .foo(
            "abc",
            some_really_really_really_long_ident,
            "ident",
            "123456",
        )
        .bar()
        .baz()
        .qux("fffffffffffffffff")
    else {
        return
    };

    let Some(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) =
        bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
    else {
        return;
    };

    let LongStructName(AnotherStruct {
        multi,
        line,
        pattern,
    }) = slice.as_ref()
    else {
        return;
    };

    let LongStructName(AnotherStruct {
        multi,
        line,
        pattern,
    }) = multi_line_function_call(
        arg1,
        arg2,
        arg3,
        arg4,
    ) else {
        return;
    };
}

语句位置中的宏

对于语句位置中的宏使用，请使用圆括号或方括号作为分隔符，并以分号终止。不要在名称、!、分隔符或 ; 周围放置空格。

#![allow(unused)]
fn main() {
// A comment.
a_macro!(...);
}

语句位置中的表达式

不要在表达式和分号之间放置空格。

<expr>;

使用分号终止语句位置中的所有表达式，除非它们以块结尾或用作块的值。

例如，

#![allow(unused)]
fn main() {
{
    an_expression();
    expr_as_value()
}

return foo();

loop {
    break;
}
}

如果表达式具有 void 类型，即使可以传播它，也请使用分号。例如，

#![allow(unused)]
fn main() {
fn foo() { ... }

fn bar() {
    foo();
}
}