mokurin000's blog - Rust

一些不错的 Rust Unstable 特性

2021-07-28T15:04:00+00:00

注意</h2>
本文原文发布于2021-07-26，其中部分内容可能已经过时。请以 Rust RFC 为准。已经稳定的特性见 accepted.rs</a>。</p>
最后一次更新：2024-02-08</p>

关于翻译</h2>
主要译者：poly000</a>，比那名居</a></p>
术语翻译部分参考了 Rust 语言术语中英文对照表</a>。</p>
如果有原文错误，请联系 Ethan Brierley</a> 且联系我更新翻译。</p>
参与：Maverick/demo_src</a></p>

Credits</h2>
原文</a> by Ethan Brierley</a></p>

简介</h2>
这篇文章介绍了一些尚不稳定的 Rust 编译器特性。我将会简单叙述这些特性，并不会深入太多细节。</p>
什么是Unstable Rust？</h2>
Rust 有三个发布版本： stable，beta，nightly。</p>
Nightly 编译器每天都会发布，而且只有它允许你启用 Unstable Rust 特性。</p>

这篇文章只讨论 Unstable 编译器特性，不讨论此版本的标准库特性。</p> </blockquote>
为什么要用 Unstable 特性？</h2>
Unstable Rust 可以让你使用在Stable Rust 中不允许使用的API。为此，编译器与标准库都使用了 Unstable 特性。</p>
使用 Unstable 特性总是伴随着一些风险。它们经常会有一些不期望行为，有时甚至会破坏 Rust 的内存安全保证，导致未定义行为。这些特性可能开发的很好，但也能未开发完善。</p>
使用Unstable特性的 Nightly 编译器，遇到“内部编译器错误”并不少见，这种情况通常称为 ICE</a>。它发生于编译过程中，编译器将会panic。这可能是由于数据与查询操作因未完成的特性而被破坏，甚至可能只是因为没做完的特性中打了个 `todo!()</code>。</p>`
`如果你遇到了ICE，检查一下是否已经被反馈，没有的话就把它报告给bug tracker</a>。</p>`
`Rust 不保证在未来继续支持它的 Unstable 特性。作为 Rust 开发者，我们享受着优秀的向下兼容性与稳定性，而启用 Unstable 特性时，Rust不再提供这些保证。今天工作的程序可能明天就寄了！</p>`
`我决定学习 Unstable 特性，不是因为我需要用它们去解决实际问题，而是觉得他们很有意思。对我来说，使用 Unstable 特性，可以让我有趣地，更多的参与语言本身的开发过程。</p>`
Unstable 特性的完整列表见Unstable 特性列表</a>。</p> </blockquote> 启用 Unstable 特性</h2> 若要使用 Unstable 特性，首先你需要安装 Nightly 工具链：</p> rustup</span> toolchain install nightly</span></span></code></pre> 临时使用 Nightly 工具链，你可以在运行cargo时加上 +nightly</code>。</p> <</span>rust-command</span>></span> +nightly </span><</span>args</span>></span></span></code></pre> 例如：</p> cargo</span> +nightly run</span></span></code></pre> 另外，你可以将你的默认编译器改为 Nightly ，这样你就不再需要加上 `+nightly。</p> rustup</span> default nightly</span></span></code></pre> 切换到 nightly 编译器后，你就可以使用 Unstable 特性。让我们试一试吧！</p> fn</span> main</span>() {</span></span> let</span> my_box</span> =</span> box</span> 5</span>;</span></span> }</span></span></code></pre> 你会得到如下编译错误：</p> error</span>[</span>E0658</span>]</span>:</span> box</span> expression syntax is experimental</span>;</span> you can call `</span>Box</span>::</span>new` instead</span></span> --></span> src</span>/</span>main</span>.</span>rs</span>:</span>2</span>:</span>18</span></span> |</span></span> 2</span> |</span> let</span> my_box</span> =</span> box</span> 5</span>;</span></span> | ^^^^^</span></span> |</span></span> =</span> note</span>:</span> see issue #</span>49733</span> <</span>https</span>:</span>//github.com/rust-lang/rust/issues/49733> for more information</span></span> =</span> help</span>:</span> add `</span>#!</span>[</span>feature</span>(</span>box_syntax</span>)]</span>` to the</span> crate</span> attributes to enable</span></span></code></pre> Rust 在 help</code> 消息中准确地告诉了我们应该做什么—— 我们需要用 #![feature(box_syntax)]</code> 启用这个特性。</p> #!</span>[</span>feature</span>(</span>box_syntax</span>)]</span></span> fn</span> main</span>() {</span></span> let</span> my_box</span> =</span> box</span> 5</span>;</span></span> }</span></span></code></pre> 所有 Unstable 特性都需要用 #![feature(..)]</code> 启用。即使你忘记了，编译器通常也会指出要如何做，虽然不总会是。</p> 现在，我们看看这些特性。我把需要启用的特性名称放在每个特性的标题中的代码块</code> 中，在代码片段中省略，以保持简洁。</p> 控制流、模式和块</h2> destructuring_assignment</code></h3> 于 Rust 1.59 稳定。</p> </blockquote> 在Rust中，我们经常在绑定到定义时解构某个类型。我们一般会使用let</code>绑定：</p> // 创建两个变量, 一个是 x, 一个是 y </span></span> let</span> Point</span> {</span> x</span>,</span> y</span> }</span> =</span> Point</span>::</span>random</span>();</span></span></code></pre> 目前这种写法只得在实例化新的定义时使用。 destructuring_assignment</code> 将它拓展到赋值。</p> 换句话说，我们可以不使用 let</code> 完成解构。</p> let</span> (</span>mut</span> x</span>,</span> mut</span> y</span>)</span> =</span> (</span>0</span>,</span> 0</span>);</span></span> </span> Point</span> {</span> x</span>,</span> y</span> }</span> =</span> Point</span>::</span>random</span>();</span></span></code></pre>从任意块提前返回，label_break_value</code></h3> 于 Rust 1.65 稳定。</p> </blockquote> Rust 有一个不那么广为人知的特性，loop</code>可以带值退出</a>。就像 Rust 中许多其它的结构，在 Rust 中 loop</code> 并不仅仅是语句, 而是表达式</a>。</p> // 保持请求用户输入一个数字，直到他们给出一个有效的数字。</span></span> let</span> number</span>:</span> u8</span> =</span> loop</span> {</span></span> if let</span> Ok</span>(</span>n</span>)</span> =</span> input</span>()</span>.</span>parse</span>() {</span></span> break</span> n</span>;</span></span> }</span> else</span> {</span></span> println!</span>(</span>"Invaid number, Please input a valid number"</span>);</span></span> }</span></span> };</span></span></code></pre> label_break_value</code> 把这拓展到任何被标记的块，而不仅仅是 loop</code>。它的行为，就像是一种提前的 return</code> ，不过适用于任何代码块，而不只是函数体。</p> 标记代码块的语法，和生命周期很相似。</p> '</span>block</span>:</span> {</span></span> // 这个代码块现在被标记为 "block" 。</span></span> }</span></span></code></pre> 现在也可以用同样的方式标记loop</code></a>。</p> 我们可以把标签放在 break</code> 后面，从那个代码块提前返回。</p> let</span> number</span> =</span> '</span>block</span>:</span> {</span></span> if</span> s</span>.</span>is_empty</span>() {</span></span> break</span> '</span>block</span> 0</span>;</span> // 从代码块提前返回</span></span> }</span></span> s</span>.</span>parse</span>()</span>.</span>unwrap</span>()</span></span> }</span></span></code></pre> 这个特性不等价于goto</a>。它没有 goto 那样的破坏性影响，他只是往后继续执行，从一个代码块中退出。</p> </blockquote> 使用 try_blocks</code> 内联 ?</code> 操作符的功能</h3> 版本引导</a>用这个例子解释问号运算符的工作方式：</p> fn</span> read_username_from_file</span>()</span> -></span> Result</span><</span>String</span>,</span> io</span>::</span>Error</span>></span> {</span></span> let</span> f</span> =</span> File</span>::</span>open</span>(</span>"username.txt"</span>);</span></span> </span> let mut</span> f</span> =</span> match</span> f</span> {</span></span> Ok</span>(</span>file</span>)</span> =></span> file</span>,</span></span> Err</span>(</span>e</span>)</span> =></span> return</span> Err</span>(</span>e</span>),</span></span> };</span></span> </span> let mut</span> s</span> =</span> String</span>::</span>new</span>();</span></span> </span> match</span> f</span>.</span>read_to_string</span>(</span>&</span>mut</span> s</span>) {</span></span> Ok</span>(</span>_</span>)</span> =></span> Ok</span>(</span>s</span>),</span></span> Err</span>(</span>e</span>)</span> =></span> Err</span>(</span>e</span>),</span></span> }</span></span> }</span></span></code></pre> 使用 ?</code> 操作符简化，可以得到等效的代码：</p> fn</span> read_username_from_file</span>()</span> -></span> Result</span><</span>String</span>,</span> io</span>::</span>Error</span>></span> {</span></span> let mut</span> f</span> =</span> File</span>::</span>open</span>(</span>"username.txt"</span>)</span>?</span>;</span></span> let mut</span> s</span> =</span> String</span>::</span>new</span>();</span></span> </span> f</span>.</span>read_to_string</span>(</span>&</span>mut</span> s</span>)</span>?</span>;</span></span> </span> Ok</span>(</span>s</span>)</span></span> }</span></span></code></pre> ?</code> 可以在函数中提前返回 Err</code>。 try_blocks</code> 提供了适用于任意代码块的相同功能。使用 try_blocks</code> ，我们可以内联 read_usernames_from_file</code> 函数。</p> try_blocks</code> 和 ?</code> 的关系就像是 label_break_value</code> 和 return</code> 的关系。 try_blocks</code> 的RFC提到了 label_break_value</code> ，作为 try_blocks</code> 一种可能的解糖。</p> 接下来重写我们的 read_username_from_file</code> ，我们得到了一个简单的 let</code> 绑定和 try</code> 代码块。</p> let</span> read_username_from_file</span>:</span> Result</span><</span>String</span>,</span> io</span>::</span>Error</span>></span> =</span> try</span> {</span></span> let mut</span> f</span> =</span> File</span>::</span>open</span>(</span>"username.txt"</span>)</span>?</span>;</span></span> let mut</span> s</span> =</span> String</span>::</span>new</span>();</span></span> </span> f</span>.</span>read_to_string</span>(</span>&</span>mut</span> s</span>)</span>?</span>;</span></span> </span> Ok</span>(</span>s</span>)</span></span> }</span></span></code></pre> 我喜欢这个特性。特别是对于较小的表达式，如果不提取成函数，可读性会更好。</p> inline_const</code></h3> 目前，指定某个值编译时计算需要定义一个常量。</p> const</span> PI_APPROX</span>:</span> f64</span> =</span> 22</span>.</span>0</span> /</span> 7</span>.</span>0</span>;</span></span> </span> fn</span> main</span>() {</span></span> let</span> value</span> =</span> func</span>(</span>PI_APPROX</span>);</span></span> }</span></span></code></pre> 有了 inline_const</code> 我们可以用匿名表达式完成同样的事。</p> fn</span> main</span>() {</span></span> let</span> value</span> =</span> func</span>(</span>const</span> {</span> 22</span>.</span>0</span> /</span> 7</span>.</span>0</span> });</span></span> }</span></span></code></pre> 在这个简单的例子中，因为编译器优化 constant propagation</a>，const</code> 块是不必要的。但是对于更复杂的常量，用块来表示，可能会更好。</p> 这个特性也允许在const块中使用模式匹配。如 match x { 1 + 3 => {} }</code> 会导致语法错误，而 match x { const { 1 + 3 } => {} }</code> 不会。</p> if_let_guard</code></h3> 拓展 match</code> 中的 if</code> 守卫</a> ，使其允许使用 if let</code>。</p> let_chains</code></h3> 于 Rust 1.64 稳定。</p> </blockquote> 目前，if let</code> 和 while let</code> 表达式不能以 ||</code> 或 &&</code> 连接，这个特性添加了支持。</p> Traits</h2> associated_type_bounds</code></h3> 这是一个 stable Rust 函数：</p> fn</span> fizzbuzz</span>()</span> -></span> impl</span> Iterator</span><</span>Item</span> =</span> String</span>></span> {</span></span> (</span>1</span>..</span>)</span>.</span>map</span>(</span>|</span>val</span>|</span> match</span> (</span>val</span> %</span> 3</span>,</span> val</span> %</span> 5</span>) {</span></span> (</span>0</span>,</span> 0</span>)</span> =></span> "FizzBuzz"</span>.</span>to_string</span>(),</span></span> (</span>0</span>,</span> _</span>)</span> =></span> "Fizz"</span>.</span>to_string</span>(),</span></span> (</span>_</span>,</span> 0</span>)</span> =></span> "Buzz"</span>.</span>to_string</span>(),</span></span> (</span>_</span>,</span> _</span>)</span> =></span> val</span>.</span>to_string</span>(),</span></span> })</span></span> }</span></span></code></pre> 有了 associated_type_bounds</code> 特性，对于这种情况，我们可以使用一个匿名类型：</p> fn</span> fizzbuzz</span>()</span> -></span> impl</span> Iterator</span><</span>Item</span>:</span> Display</span>></span> {</span> ...</span> }</span></span></code></pre> 看看这个冗长重复的函数签名：</p> fn</span> flatten_twice</span><</span>T</span>></span>(</span>iter</span>:</span> T</span>)</span> -></span> Flatten</span><</span>Flatten</span><</span>T</span>>></span></span> where</span></span> T</span>:</span> Iterator</span>,</span></span> <</span>T</span> as</span> Iterator</span>></span>::</span>Item</span>:</span> IntoIterator</span>,</span></span> <<</span>T</span> as</span> Iterator</span>></span>::</span>Item</span> as</span> IntoIterator</span>></span>::</span>Item</span>:</span> IntoIterator</span>,</span></span> {</span></span> iter</span>.</span>flatten</span>()</span>.</span>flatten</span>()</span></span> }</span></span></code></pre> 有了这个特性，我们就可以简单地写成：</p> fn</span> flatten_twice</span><</span>T</span>></span>(</span>iter</span>:</span> T</span>)</span> -></span> Flatten</span><</span>Flatten</span><</span>T</span>>></span></span> where</span></span> T</span>:</span> Iterator</span><</span>Item</span>:</span> IntoIterator</span><</span>Item</span>:</span> IntoIterator</span>>></span>,</span></span> {</span></span> iter</span>.</span>flatten</span>()</span>.</span>flatten</span>()</span></span> }</span></span></code></pre> 这种写法容易理解许多。</p> default_type_parameter_fallback</code>, associated_type_defaults</code>以及const_generics_defaults</code></h3> const_generics_defaults</code> 于 Rust 1.59 稳定。</p> </blockquote> 这些特性允许你为泛型类型</a>, 关联类型</a> 以及 const 变量</a> 在更多地方指定默认值。</p> 它们允许你作为开发者创建更好的 API 。如果一个crate的用户对细节不感兴趣，而它有默认值，则可以忽略细节。这也让拓展 API 变得容易，无需做出破坏性更新。</p> negative_impls</code> 和 auto_traits</code></h3> 这些特性都被标准库使用。Send</code></a> 和 Sync</code></a> 都是自动 trait。</p> Send</code> trait 定义于标准库</a>：</p> pub unsafe</span> auto</span> trait</span> Send</span> {</span></span> // 空的</span></span> }</span></span></code></pre> 注意auto</code>关键字，它让编译器为任意结构体/枚举体/联合体自动实现 Send</code> trait，（前提是构成这个类型的类型都实现了Send</code>）</p> 如果每个类型都能简单地实现自动trait ，它们也不会那么有用。这正是引入 negative_impls</code> 的原因。</p> negative_impls</code> 允许一个类型不实现某个auto trait。举个例子，UnsafeCell</code>。不受限制的 UnsafeCell</code> 在线程间共享非常不安全，因此它被标记为 Sync</code> 也不安全。</p> impl</span><</span>T</span>: ?</span>Sized</span>></span> !</span>Sync</span> for</span> UnsafeCell</span><</span>T</span>></span> {}</span></span></code></pre> 注意 !</code> ，表示 “不Sync</code>”。</p> marker_trait_attr</code></h3> 这个特性为 trait 添加了#[marker]</code> 属性。</p> 详见 Unstable Book</a></p> </blockquote> Rust 不允许定义trait的实现时覆盖此前的实现。这样编译器就能确定要使用哪个实现——只有一个。</p> 标志为 #[marker]</code> 的 trait 不能在实现中覆盖任何东西。这样它们就能允许重叠的实现，因为所有的实现都是一样的。</p> type_alias_impl_trait</code>, impl_trait_in_bindings</code> and trait_alias</code></h3> impl Trait</code> 让编译器推导具体类型，把它换成实现了Trait</code>的类型。目前，impl Trait</code>只能在函数参数或返回类型中使用，无法应用于变量绑定。</p> 注：impl_trait_in_binding 临时被移除(2022-07-26)，可能是因为它导致了破坏性更新</a></p> </blockquote> 需要注意的是，使用 type_alias_impl_trait</code> 时，类型必须是固定的。编译器会推断且应用单一具体的类型。</p> #!</span>[</span>feature</span>(</span>type_alias_impl_trait</span>)]</span></span> </span> type</span> Foo</span> =</span> impl</span> AsRef</span><</span>str</span>></span>;</span></span> </span> fn</span> foo</span>(</span>_</span>:</span> Foo</span>) {}</span></span> </span> fn</span> main</span>() {</span></span> foo</span>(</span>String</span>::</span>new</span>());</span></span> foo</span>(</span>""</span>);</span></span> }</span></span></code></pre>error[E0308]: mismatched types</span></span> --> src/main.rs:9:9</span></span> |</span></span> 3 | type Foo = impl AsRef<str>;</span></span> | --------------- the expected opaque type</span></span> ...</span></span> 9 | foo("");</span></span> | --- ^^ expected opaque type, found `&str`</span></span> | |</span></span> | arguments to this function are incorrect</span></span> |</span></span> = note: expected opaque type `Foo`</span></span> found reference `&'static str`</span></span> note: function defined here</span></span> --> src/main.rs:5:4</span></span> |</span></span> 5 | fn foo(_: Foo) {}</span></span> | ^^^ ------</span></span></code></pre>fn_traits</code> and unboxed_closures</code></h3> Fn</code>，FnMut</code>和FnOnce</code>被认为是fn</code>的trait。它们会被任何函数或者你创建的闭包自动实现，它们允许你给它们传参。</p> 目前它们只能被自动实现。 fn_trait</code> 则允许为任意类型提供自定义实现。这就像是操作符重载，但要自定义的是()</code>调用。</p> #!</span>[</span>feature</span>(</span>unboxed_closures</span>)]</span> // 实现带有`extern "rust-call"`的函数</span></span> #!</span>[</span>feature</span>(</span>fn_traits</span>)]</span></span> </span> struct</span> Multiply</span>;</span></span> </span> #</span>[</span>allow</span>(</span>non_upper_case_globals</span>)]</span></span> const</span> multiply</span>:</span> Multiply</span> =</span> Multiply</span>;</span></span> </span> impl</span> FnOnce</span><</span>(</span>u32</span>,</span> u32</span>)</span>></span> for</span> Multiply</span> {</span></span> type</span> Output</span> =</span> u32</span>;</span></span> extern</span> "rust-call"</span> fn</span> call_once</span>(</span>self</span>,</span> a</span>:</span> (</span>u32</span>,</span> u32</span>))</span> -></span> Self</span>::</span>Output</span> {</span></span> a</span>.</span>0</span> </span> a</span>.</span>1</span></span> }</span></span> }</span></span> </span> impl</span> FnOnce</span><</span>(</span>u32</span>,</span> u32</span>,</span> u32</span>)</span>></span> for</span> Multiply</span> {</span></span> type</span> Output</span> =</span> u32</span>;</span></span> extern</span> "rust-call"</span> fn</span> call_once</span>(</span>self</span>,</span> a</span>:</span> (</span>u32</span>,</span> u32</span>,</span> u32</span>))</span> -></span> Self</span>::</span>Output</span> {</span></span> a</span>.</span>0</span> </span> a</span>.</span>1</span> *</span> a</span>.</span>2</span></span> }</span></span> }</span></span> </span> impl</span> FnOnce</span><</span>(</span>&</span>str</span>,</span> usize</span>)</span>></span> for</span> Multiply</span> {</span></span> type</span> Output</span> =</span> String</span>;</span></span> extern</span> "rust-call"</span> fn</span> call_once</span>(</span>self</span>,</span> a</span>:</span> (</span>&</span>str</span>,</span> usize</span>))</span> -></span> Self</span>::</span>Output</span> {</span></span> a</span>.</span>0</span>.</span>repeat</span>(</span>a</span>.</span>1</span>)</span></span> }</span></span> }</span></span> </span> fn</span> main</span>() {</span></span> assert_eq!</span>(</span>multiply</span>(</span>2</span>,</span> 3</span>),</span> 6</span>);</span></span> assert_eq!</span>(</span>multiply</span>(</span>2</span>,</span> 3</span>,</span> 4</span>),</span> 24</span>);</span></span> assert_eq!</span>(</span>multiply</span>(</span>"hello "</span>,</span> 3</span>),</span> "hello hello hello "</span>);</span></span> }</span></span></code></pre> 这可被用于实现有点 hacky 的函数重载</a>和不定参函数</a>.</p> 语法糖</h2> box_patterns</code> and box_syntax</code></h3> 这两个特性让Box</code>的构造和析构变得更容易。 box关键字将取代Box::new(...)</code>，并且允许在模式匹配中解引用Box</code>。</p> struct</span> TrashStack</span><</span>T</span>></span> {</span></span> head</span>:</span> T</span>,</span></span> body</span>:</span> Option</span><</span>Box</span><</span>TrashStack</span><</span>T</span>>>></span>,</span></span> }</span></span> </span> impl</span><</span>T</span>></span> TrashStack</span><</span>T</span>></span> {</span></span> pub fn</span> push</span>(</span>self</span>,</span> elem</span>:</span> T</span>)</span> -></span> Self</span> {</span></span> Self</span> {</span></span> head</span>:</span> elem</span>,</span></span> body</span>:</span> Some</span>(</span>box</span> self</span>),</span></span> }</span></span> }</span></span> </span> pub fn</span> peek</span>(</span>self</span>)</span> -></span> Option</span><</span>T</span>></span> {</span></span> if let</span> TrashStack</span> {</span></span> body</span>:</span> Some</span>(</span>box</span> TrashStack</span> {</span> head</span>,</span> ..</span> }),</span></span> ..</span></span> }</span> =</span> self</span></span> {</span></span> Some</span>(</span>head</span>)</span></span> }</span> else</span> {</span></span> None</span></span> }</span></span> }</span></span> }</span></span></code></pre> 正如原文作者所说，rust（包括内部实现）正在减少box syntax的使用。</p> 所以这个章节咕了（理直气壮）</p> </blockquote> This makes things a little more ergonomic but I don’t think there is much chance that this feature will ever be stabilised. It seems to have existed forever with no plan for stabilisation but instead a little discussion about removing the feature. box_synatx</code> is used heavily in the compiler’s source and a little in the standard library.</p> It is interesting to note that box</code> does not desugar to Box::new</code> but Box::new</code> is implemented in the standard library with box</code>.</p> impl</span><</span>T</span>></span> Box</span><</span>T</span>></span> {</span></span> ...</span></span> pub fn</span> new</span>(</span>x</span>:</span> T</span>)</span> -></span> Self</span> {</span></span> box</span> x</span></span> }</span></span> ...</span></span> }</span></span></code></pre>async_closure</code></h3> 目前在闭包中使用异步代码你需要加async块。</p> app</span>.</span>at</span>(</span>"/"</span>)</span>.</span>get</span>(</span>|</span>_</span>|</span> async</span> {</span> Ok</span>(</span>"Hi"</span>) });</span></span></code></pre> async_closure</code> 允许你将闭包本身标记为异步的，像异步函数那样写</p> app</span>.</span>at</span>(</span>"/"</span>)</span>.</span>get</span>(</span>async</span> |</span>_</span>|</span> Ok</span>(</span>"Hi"</span>));</span></span></code></pre>in_band_lifetimes</code></h3> 于 Rust #93845</a> 移除；</p> 原始 RFC 中，不单独标注的提案被 Rust 拒绝。</p> 详见 Rust #44524</a> 。</p> </blockquote> 使用生命周期标记时，必须事先定义：</p> fn</span> select</span><</span>'</span>data</span>></span>(</span>data</span>: &</span>'</span>data</span> Data</span>,</span> params</span>: &</span>Params</span>)</span> -> &</span>'</span>data</span> Item</span>;</span></span></code></pre> 使用 in_band_lifetimes</code> ，生命周期可以不先显式定义。</p> fn</span> select</span>(</span>data</span>: &</span>'</span>data</span> Data</span>,</span> params</span>: &</span>Params</span>)</span> -> &</span>'</span>data</span> Item</span>;</span></span></code></pre> 这是生命周期</a>在rust 1.0.0</code>前的写法。</p> format_args_capture</code></h3> 于 Rust 1.58 稳定。</p> </blockquote> This allows for named arguments to be placed inside of strings inside any macro that depends on std::format_args!</code>. That includes print!</code>, format!</code>, write!</code> and many more.</p> let</span> name</span> =</span> "Ferris"</span>;</span></span> let</span> age</span> =</span> 11</span>;</span></span> println!</span>(</span>"你好</span>{</span>name</span>}</span>，你</span>{</span>age</span>}</span>岁了。"</span>);</span></span></code></pre>crate_visibility_modifier</code></h3> 已于 Rust #97254</a> 移除。</p> 理由：</p> pub struct</span> Foo</span>(</span>crate</span> ::</span>std</span>::</span>path</span>::</span>Path</span>);</span> </span></span></code></pre> 会产生歧义 1</a></sup></p> </blockquote> 这个特性允许你写 crate struct Foo</code> 而不是 pub(crate) struct Foo</code> ，语义不变。</p> Types</h2> type_ascription</code></h3> 已于 Rust #101728</a> 移除</p> 理由：语法不Rust</p> </blockquote> 用Iterator</code>的collect</code>方法举个例子： collect将迭代器转换到集合</p> let</span> word</span> =</span> "hello"</span>.</span>chars</span>()</span>.</span>collect</span>();</span></span> println!</span>(</span>"</span>{</span>:?</span>}</span>"</span>,</span> word</span>);</span></span></code></pre> 这个不能编译，因为rust无法推导出word</code>的类型。可以把第一行换成：</p> let</span> word</span>:</span> Vec</span><</span>char</span>></span> =</span> "hello"</span>.</span>chars</span>()</span>.</span>collect</span>();</span></span></code></pre> 有了type_ascription</code>就不需要再加上let绑定，我们可以直接：</p> println!</span>(</span>"</span>{</span>:?</span>}</span>"</span>,</span> "hello"</span>.</span>chars</span>()</span>.</span>collect</span>()</span>:</span> Vec</span><</span>char</span>></span>);</span></span></code></pre> : Type</code> 语法可以用在任何一处，提醒编译器“我在这里想要得到这个类型”</p> never_type</code></h3> 你可以定义没有变体的枚举体，这种枚举体也存在于标准库中。</p> pub enum</span> Infallible</span> {}</span></span></code></pre> 你可以在泛型或函数签名中使用该类型，但它不可能被构造。</p> 元类型 ()</code> 等价于只有一个变体的枚举。 never_type</code> 引入了一种新的类型，!</code>等价于没有变体的 Infallible</code>。</p> Because !</code> can never be constructed it can be given special powers. We don’t have to handle the case of !</code> because we have proven it will never exist.</p> fn</span> main</span>()</span> -> !</span> {</span></span> loop</span> {</span></span> println!</span>(</span>"Hello, world!"</span>);</span></span> }</span></span> }</span></span></code></pre> Loops without a break</code> “return !</code>” because they don’t ever return.</p> !</code> can be very useful for expressing impossible outcomes in the type system. Take for example the FromStr</code> implementation on this UserName</code> type. This implementation is infallible because its implementation can never fail. This allows us to set the Err</code> variant to type !</code>.</p> struct</span> UserName</span>(</span>String</span>);</span></span> </span> impl</span> FromStr</span> for</span> UserName</span> {</span></span> type</span> Err</span> = !</span>;</span></span> fn</span> from_str</span>(</span>s</span>: &</span>str</span>)</span> -></span> Result</span><</span>Self</span>,</span> Self</span>::</span>Err</span>></span> {</span></span> Ok</span>(</span>Self</span>(</span>s</span>.</span>to_owned</span>()))</span></span> }</span></span> }</span></span></code></pre> It is then possible to use an empty match</code> on the Err</code> variant because !</code> has no variants.</p> let</span> user_name</span> =</span> match</span> UserName</span>::</span>from_str</span>(</span>"ethan"</span>) {</span></span> Ok</span>(</span>u</span>)</span> =></span> u</span>,</span></span> Err</span>(</span>e</span>)</span> =></span> match</span> e</span> {},</span></span> };</span></span></code></pre>exhaustive_patterns</code></h3> 译注：原作者的解释和 RFC，Issue 都对不上。</p> 原Issue目标为，不可达的分支可以省略</p> 如析构一个 Result<T, !></code> ，</p> fn</span> safe_unwrap</span><</span>T</span>></span>(</span>x</span>:</span> Result</span><</span>T</span>,</span> !</span>></span>)</span> -></span> T</span> {</span></span> match</span> x</span> {</span></span> Ok</span>(</span>y</span>)</span> =></span> y</span>,</span></span> }</span></span> }</span></span></code></pre></blockquote> With the feature exhaustive_patterns</code> the type system becomes smart enough for us to eliminate the Err</code> branch altogether.</p> let</span> user_name</span> =</span> match</span> UserName</span>::</span>from_str</span>(</span>"ethan"</span>) {</span></span> Ok</span>(</span>u</span>)</span> =></span> u</span>,</span></span> };</span></span></code></pre> We can combine this with destructuring to remove the match</code> leaving a beautiful line of code.</p> let</span> Ok</span>(</span>user_name</span>)</span> =</span> UserName</span>::</span>from_str</span>(</span>"ethan"</span>);</span></span></code></pre>attribute</h2> 这个小节由 @Hinanawi_Tenshi_M</a> 提供翻译，有改动</p> </blockquote> optimize attribute</h3> 你可以用 Cargo.toml</code> 的 opt-level</code></a> 选项指定你想要怎么优化你的二进制文件。</p> opt-level</code> 指定的是整个 crate 的优化方式，如果你想要分别控制每一个项目的优化方式，你可以使用 optimize_attribute</code> 选项。</p> #</span>[</span>optimize</span>(</span>speed</span>)]</span></span> fn</span> fast_but_large</span>() {</span></span> ...</span></span> }</span></span> </span> #</span>[</span>optimize</span>(</span>size</span>)]</span></span> fn</span> slow_but_small</span>() {</span></span> ...</span></span> }</span></span></code></pre> 这对微调应用程序非常有用。在这些应用程序中，大小和性能的权衡特别重要。例如使用 web assembly</a> 时。</p> stmt_expr_attributes</code></h3> 这个特性让你可以在几乎任何地方标记属性，而不仅仅是顶层项目。例如，你可以在一个闭包上放一个optimize attribute</a></p> cfg_version</code></h3> 该特性允许根据编译器版本进行条件编译。</p> #</span>[</span>cfg</span>(</span>version</span>(</span>"1.42"</span>))]</span> // 1.42 以上</span></span> fn</span> a</span>() {</span></span> // ...</span></span> }</span></span> </span> #</span>[</span>cfg</span>(</span>not</span>(</span>version</span>(</span>"1.42"</span>)))]</span> // 1.41 以下</span></span> fn</span> a</span>() {</span></span> // ...</span></span> }</span></span></code></pre> 这使得你的 crate 能够使用最新的编译器功能，同时仍然保持对旧编译器的后备支持。</p> no_core</code></h3> 不依赖 ::std</code> 的 #![no_std]</code> 选项已经存在很久了，</p> #![no_core]</code> 则对应着不依赖 ::core</code> 。</p> 这对于不在完整环境中运行的应用非常重要，如嵌入式系统。嵌入式系统通常没有操作系统，甚至没有动态内存，所以 std</code> 中的许多功能都无法使用。</p> 你现在可以通过 #![no_core]</code> 表明不使用 libcore。</p> 这样不会留下任何东西——你甚至不能使用libc。</p> 其它</h2> Const Generic</h3> 这个小节由 @Hinanawi_Tenshi_M</a> 提供翻译，有改动。</p> 已经在 Stable Rust 部分实现。 2</a></sup></p> </blockquote> 在都柏林 Rust 集会中，关于 const_generics</code> ，我做过一场演讲</a>。与其重复那些内容，我更推荐大家去看这个演讲</a>。</p> Macros 2.0</h3> Rust的声明式宏非常强大。然而， macro_rules!</code> 的一些规则，让我很困惑。</p> macro_rules!</code> 是一个简单的token转换过程，或者说，</p> 它接受一个token列表，输出新的token列表</li> 可见性原则会遵从宏的调用处的规则。</li> </ul> ——因为代码只是被简单地粘贴回原处。</p> Macros 2.0</a> 介绍了macro_rules!</code>的一种替代。</p> 编写 Macros 2.0 只需使用关键字 macro</code></p> 它引入了一种新的格式，Hygiene 。Hygiene 允许宏应用它们定义处的可见性规则，而不是调用处。</p> generators</code></h3> 生成器（协程）提供了一种特殊的函数，可以在执行过程中暂停，“yield” 中间值给调用者。</p> 生成器允许你使用yield</code>关键字返回多个值，每次暂停该函数并返回给调用者。</p> 生成器中也可以return</code>单个值，不可再恢复。</p> 大约三年前，我尝试编写算法，沿对角线遍历一个无穷的矩阵。我发现用Rust的迭代器编写它非常困难，最终放弃了。</p> 这是我的实现，使用了Rust的生成器（协程）和一些我们刚刚讨论过的特性。</p> #!</span>[</span>feature</span>(</span></span> try_blocks</span>,</span></span> generators</span>,</span></span> generator_trait</span>,</span></span> associated_type_bounds</span>,</span></span> type_ascription</span></span> )]</span></span> </span> use</span> std</span>::</span>{</span></span> iter</span>,</span></span> ops</span>::</span>{</span>Generator</span>,</span> GeneratorState</span>},</span></span> pin</span>::</span>Pin</span>,</span></span> };</span></span> </span> /// Input</span></span> /// [[1, 2, 3]</span></span> /// ,[4, 5, 6]</span></span> /// ,[7, 8, 9]]</span></span> /// Output</span></span> /// [1, 2, 4, 3, 5, 7]</span></span> fn</span> diagonalize</span><</span>T</span>></span>(</span></span> mut</span> matrix</span>:</span> impl</span> Iterator</span><</span>Item</span>:</span> Iterator</span><</span>Item</span> =</span> T</span>>></span>,</span></span> )</span> -></span> impl</span> Generator</span><</span>Yield</span> =</span> T</span>,</span> Return</span> =</span> ()</span>></span> {</span></span> move</span> ||</span> {</span></span> let mut</span> rows</span> =</span> Vec</span>::</span>new</span>();</span></span> (</span>try</span> {</span></span> rows</span>.</span>push</span>(</span>matrix</span>.</span>next</span>()</span>?</span>);</span></span> for</span> height</span> in</span> 0</span>..</span> {</span></span> for</span> row</span> in</span> 0</span>..</span>height</span> {</span></span> if</span> row</span> >=</span> rows</span>.</span>len</span>() {</span></span> rows</span>.</span>push</span>(</span>matrix</span>.</span>next</span>()</span>?</span>);</span></span> }</span></span> yield</span> rows</span>[</span>row</span>]</span>.</span>next</span>()</span>?</span>;</span></span> }</span></span> }</span></span> })</span>:</span> Option</span><</span>()</span>></span>;</span></span> }</span></span> }</span></span> </span> fn</span> main</span>() {</span></span> let</span> matrix</span> =</span> (</span>0</span>..</span>)</span>.</span>map</span>(</span>|</span>x</span>|</span> iter</span>::</span>once</span>(</span>x</span>)</span>.</span>cycle</span>()</span>.</span>enumerate</span>());</span></span> let mut</span> diagonals</span> =</span> diagonalize</span>(</span>matrix</span>);</span></span> while let</span> GeneratorState</span>::</span>Yielded</span>(</span>value</span>)</span> =</span> Pin</span>::</span>new</span>(</span>&</span>mut</span> diagonals</span>)</span>.</span>resume</span>(()) {</span></span> dbg!</span>(</span>value</span>);</span></span> }</span></span> }</span></span></code></pre> It is understandable if you found the above snippet hard to interpret. It makes use of a number of features that you may have just been introduced to.</p> There is a compelling argument against adding too many new features as they can greatly increase the learning curve.</p> </blockquote> 生成器让一些没有这个特性会难以编写甚至无法编写的实现变为可能。</p> 生成器在标准库中是为了实现 async/await 添加的。具体的语义在稳定化前很可能被修改，但它很有趣。</p> 总结</h3> 我很抱歉，没有介绍其他三个不错的unstable特性：GAT</a>, 内联汇编</a>和特化</a>。我只是感觉，在这篇文章中，我做不到客观的评价它们，不过将来我可能会尝试。</p> 如果你想了解更多unstable特性，我推荐你看the unstable book</a>，这里会列出绝大部分。 Unstable book会连接到tracking issue</a>，而后者往往会链接到RFC</a>。组合使用这些来源，你可以很好地了解新特性。</p> Thank you for reading my first blog post 😃. The best way to support me is by following my Twitter</a>. I am also looking for employment opportunities so please get in touch if you would like to talk about that.</p> https://github.com/rust-lang/rust/issues/53120#issuecomment-1124065083 ↩</a></p> </li> https://github.com/rust-lang/rust/issues/44580#issuecomment-1074040208 ↩</a></p> </li> </ol> </section>