Rust 1.51を早めに深掘り

こんにちは、R&Dチームの齋藤（@aznhe21）です。書きたい記事がいっぱいあるのに時間が取れません。悲しい。

さて、本日、日本時間3/26(金)、Rust 1.51がリリースされました。この記事ではRust 1.51での変更点を詳しく紹介します。

ピックアップ
安定化されたAPIのドキュメント
変更点リスト
関連リンク
さいごに
ライセンス表記

ピックアップ

個人的に注目する変更点を「ピックアップ」としてまとめました。全ての変更点を網羅したリストは変更点リストをご覧ください。

ジェネリクスの引数として定数を使えるようになった

これまで、Rustのジェネリクスは型しか取ることが出来ませんでした。例えば、要素数を任意に変更出来る、ジェネリックな配列型を自分で定義することは出来ません。

struct Array<T> {
    array: [T; N], // Nはどうやって指定する？
}

今回、ジェネリクスで定数値が使えるようになり、これが実現できるようになりました（ただし使える定数値の型には今のところ制限があります）。

struct Array<T, const N: usize> {
    array: [T; N], // Nを可変に出来る
}

他によくある使い方としては、配列へのメソッドの実装です。定数ジェネリクスがない場合、「要素数0の配列への実装」「要素数1の配列への実装」・・・のように地道に実装していく必要がありました。

pub trait Print {
    fn print(&self);
}

impl<T: std::fmt::Display, const N: usize> Print for [T; N] {
    fn print(&self) {
        for v in self {
            println!("{}", v);
        }
    }
}

fn main() {
    [0, 1, 2].print(); // "0\n1\n2"
}

制限等に関しては以下の記事に詳しいため、そちらもご参照ください。

配列要素の所有権を奪いつつイテレート出来るようになった

配列をforで使う時、所有権が欲しいのに参照が取れてしまって困ったことはないでしょうか？

fn main() {
    let array = ["hoge".to_string(), "fuga".to_string()];
    for s in array {
        // sがStringになって欲しいのに&Stringになってしまう
    }
}

Rustは後方互換性を重要視する言語です。これはバージョン1.0の時点で紛れ込んでしまったバグであり、 1.0リリース後に報告はされていたものの、後方互換性を壊すため直せなかったバグです。上記のような間違ったコードを使っているクレートはそこそこあり、この挙動を変えるとそれらのクレートのコンパイルが通らなくなるのです。

今回、配列そのものをイテレートするための新しいオブジェクトIntoIterが追加され、間接的ではありますが、これが出来るようになりました。

use std::array::IntoIter;

fn main() {
    let array = ["hoge".to_string(), "fuga".to_string()];
    for mut s in IntoIter::new(array) {
        s.push_str("-piyo");
        println!("{}", s);
    }
}

なお、配列そのものをイテレートする仕組みですが、まずは現状の間違ったコードをRust 2021でコンパイル出来ないようにし、互換性を確保した後で導入されると噂されています。

featureの新しい解決機構が使えるようになった

Cargoがクレートをコンパイルする時、コンパイルする回数を減らすため、同じクレートを別々のクレートから別々のfeatureで参照した時はそれらのfeatureを統合するようになっています。例えば、以下のような依存関係を考えてみましょう。

binary
- crateAに依存
- crateBに依存
crateA
- crateC[feature="feature-1"]に依存
crateB
- crateC[feature="feature-2"]に依存

この時、binaryにリンクされるcrateCは、feature-1とfeature-2のどちらも指定された状態でコンパイルされます。これ自体は嬉しい機能ではありますが、ビルド時だけの依存関係においても、このfeatureの統合が行われてしまっていました。

例えば以下の依存関係を考えた時、binaryにリンクされるcrateCのfeatureはfeature-2だけになって欲しいところですが、上記と同じくfeature-1とfeature-2のどちらも指定された状態でコンパイルされてしまっていました。

binary
- crateAに依存
- crateBに依存
crateA
- ビルド時のみ：crateC[feature="feature-1"]に依存
crateB
- crateC[feature="feature-2"]に依存

これは特にno_std環境では深刻で、依存クレートのどれかがビルド時にstd featureに依存してしまっていると、 no_stdなのにstdに依存してしまうということで成果物自体のコンパイルが出来なくなってしまっていました。

今回追加されたfeature解決機構バージョン2により、ビルド時の依存や手続きマクロの依存、そして成果物としての依存が別々に解決されるようになり、上記の問題が発生しなくなります。

これを使うには、Cargo.tomlの[package]セクションや[workspace]セクションでresolver = 2と指定します。

[package]
resolver = "2"
# あるいは
[workspace]
resolver = "2"

安定化されたAPIのドキュメント

安定化されたAPIのドキュメントを独自に訳して紹介します。リストだけ見たい方は安定化されたAPIをご覧ください。

`Arc::decrement_strong_count`

原典

impl<T: ?Sized> Arc<T> {
    #[inline]
    #[stable(feature = "arc_mutate_strong_count", since = "1.51.0")]
    pub unsafe fn decrement_strong_count(ptr: *const T)
    { /* 実装は省略 */ }
}

指定されたポインタと紐付いたArc<T>の強参照のカウントを1つ減らす。

安全性

ポインタはArc::into_rawによって取得したものでなければならず、かつ紐付いたArc<T>のインスタンスは（強参照のカウントが少なくとも1であるなど）有効である必要がある。このメソッドは最後のArcとその背後の領域の解放に使えるが、最後のArcの解放後に呼ぶべきではない。

サンプル

use std::sync::Arc;

let five = Arc::new(5);

unsafe {
    let ptr = Arc::into_raw(five);
    Arc::increment_strong_count(ptr);

    // スレッド間で`Arc`を共有していないため、これらのアサートは決定的である。
    let five = Arc::from_raw(ptr);
    assert_eq!(2, Arc::strong_count(&five));
    Arc::decrement_strong_count(ptr);
    assert_eq!(1, Arc::strong_count(&five));
}

`Arc::increment_strong_count`

原典

impl<T: ?Sized> Arc<T> {
    #[inline]
    #[stable(feature = "arc_mutate_strong_count", since = "1.51.0")]
    pub unsafe fn increment_strong_count(ptr: *const T)
    { /* 実装は省略 */ }

指定されたポインタと紐付いたArc<T>の強参照のカウントを1つ増やす。

安全性

ポインタはArc::into_rawによって取得したものでなければならず、かつ紐付いたArc<T>のインスタンスはこのメソッドが呼び出されている間（強参照のカウントが少なくとも1であるなど）有効である必要がある。

サンプル

use std::sync::Arc;

let five = Arc::new(5);

unsafe {
    let ptr = Arc::into_raw(five);
    Arc::increment_strong_count(ptr);

    // スレッド間で`Arc`を共有していないため、これらのアサートは決定的である。
    let five = Arc::from_raw(ptr);
    assert_eq!(2, Arc::strong_count(&five));
}

`Once::call_once_force`

原典

impl Once {
    #[stable(feature = "once_poison", since = "1.51.0")]
    pub fn call_once_force<F>(&self, f: F)
    where
        F: FnOnce(&OnceState),
    { /* 実装は省略 */ }
}

汚染を無視する以外はcall_once()を呼び出すのと同じ。

call_once()とは異なり、もしこのOnceが汚染（前回のcall_once()やcall_once_force()呼び出しがパニックしたなど）されても、 call_once_force()は変わらずクロージャfが呼び出され、すぐにパニックする結果にはならない。もしfがパニックした場合、このOnceは汚染状態のままとなる。もしfがパニックしなかった場合、このOnceは汚染状態ではなくなり、今後のcall_once()やcall_once_force()の呼び出しは何もしなくなる。

クロージャfにはOnceStateが渡され、これによりOnceの汚染状態を照会出来る。

サンプル

use std::sync::Once;
use std::thread;

static INIT: Once = Once::new();

// onceを汚染
let handle = thread::spawn(|| {
    INIT.call_once(|| panic!());
});
assert!(handle.join().is_err());

// 汚染は伝播する
let handle = thread::spawn(|| {
    INIT.call_once(|| {});
});
assert!(handle.join().is_err());

// call_once_forceは実行でき、汚染状態がリセットされる
INIT.call_once_force(|state| {
    assert!(state.is_poisoned());
});

// 成功したら汚染の伝播は止まる
INIT.call_once(|| {});

`Peekable::next_if_eq`

原典

impl<I: Iterator> Peekable<I> {
    #[stable(feature = "peekable_next_if", since = "1.51.0")]
    pub fn next_if_eq<T>(&mut self, expected: &T) -> Option<I::Item>
    where
        T: ?Sized,
        I::Item: PartialEq<T>,
    { /* 実装は省略 */ }
}

次の値がexpectedと等しい場合、それを消費して返す。

サンプル

0と等しい値を消費する。

let mut iter = (0..5).peekable();
// イテレータの最初のアイテムは0。消費する。
assert_eq!(iter.next_if_eq(&0), Some(0));
// 次に返されるアイテムは1なので`consume`は`false`を返す。
assert_eq!(iter.next_if_eq(&0), None);
// `next_if_eq`は、`expected`と次のアイテムの値が異なっていた場合は値を保存する。
assert_eq!(iter.next(), Some(1));

`Peekable::next_if`

原典

impl<I: Iterator> Peekable<I> {
    #[stable(feature = "peekable_next_if", since = "1.51.0")]
    pub fn next_if(&mut self, func: impl FnOnce(&I::Item) -> bool) -> Option<I::Item>
    { /* 実装は省略 */ }
}

条件を満たす場合、このイテレータの次の値を消費して返す。

もしこのイテレータの次の値に対してfuncがtrueを返したら、それを消費して返す。さもなくばNoneを返す。

サンプル

0と等しい値を消費する。

let mut iter = (0..5).peekable();
// イテレータの最初のアイテムは0。消費する。
assert_eq!(iter.next_if(|&x| x == 0), Some(0));
// 次に返されるアイテムは1なので`consume`は`false`を返す。
assert_eq!(iter.next_if(|&x| x == 0), None);
// `next_if_eq`は、`expected`と次のアイテムの値が異なっていた場合は値を保存する。
assert_eq!(iter.next(), Some(1));

10未満の値を消費する。

let mut iter = (1..20).peekable();
// 10未満の値を全て消費する
while iter.next_if(|&x| x < 10).is_some() {}
// 次に返される値は10。
assert_eq!(iter.next(), Some(10));

`Seek::stream_position`

原典

#[stable(feature = "rust1", since = "1.0.0")]
pub trait Seek {
    #[stable(feature = "seek_convenience", since = "1.51.0")]
    fn stream_position(&mut self) -> Result<u64>
    { /* 実装は省略 */ }
}

このストリームの、始点からのシーク位置を返す。

これはself.seek(SeekFrom::Current(0))と同義である。

サンプル

use std::{
    io::{self, BufRead, BufReader, Seek},
    fs::File,
};

fn main() -> io::Result<()> {
    let mut f = BufReader::new(File::open("foo.txt")?);

    let before = f.stream_position()?;
    f.read_line(&mut String::new())?;
    let after = f.stream_position()?;

    println!("最初の行の長さは{}だった", after - before);
    Ok(())
}

`array::IntoIter`

原典

#[stable(feature = "array_value_iter", since = "1.51.0")]
pub struct IntoIter<T, const N: usize> { /* フィールドは省略 */ }

値による配列のイテレータ。

`array::IntoIter::new`

原典

impl<T, const N: usize> IntoIter<T, N> {
    #[stable(feature = "array_value_iter", since = "1.51.0")]
    pub fn new(array: [T; N]) -> Self
    { /* 実装は省略 */ }
}

渡されたarrayに対する新たなイテレータを生成する。

参考：配列に対するIntoIteratorが実装された後、将来的にこのメソッドは非推奨となる。

サンプル

use std::array;

for value in array::IntoIter::new([1, 2, 3, 4, 5]) {
    // `value`の型は`&i32`ではなく`i32`
    let _: i32 = value;
}

`array::IntoIter::as_slice`

原典

impl<T, const N: usize> IntoIter<T, N> {
    #[stable(feature = "array_value_iter", since = "1.51.0")]
    pub fn as_slice(&self) -> &[T]
    { /* 実装は省略 */ }
}

まだ達していない全ての要素の不変スライスを返す。

`array::IntoIter::as_mut_slice`

原典

impl<T, const N: usize> IntoIter<T, N> {
    #[stable(feature = "array_value_iter", since = "1.51.0")]
    pub fn as_mut_slice(&mut self) -> &mut [T]
    { /* 実装は省略 */ }
}

まだ達していない全ての要素の可変スライスを返す。

`panic::panic_any`

原典

#[stable(feature = "panic_any", since = "1.51.0")]
#[inline]
pub fn panic_any<M: 'static + Any + Send>(msg: M) -> !
{ /* 実装は省略 */ }

渡されたメッセージをパニックの内容とし、現在のスレッドをパニックさせる。

メッセージには文字列だけでなく、あらゆる（Any + Sendを満たす）型が使える。

メッセージはBox<'static + Any + Send>に割賦され、後ほどPanicInfo::payloadによって参照できる。

パニックに関するさらなる情報はpanic!マクロを参照。

`ptr::addr_of!`

原典

#[stable(feature = "raw_ref_macros", since = "1.51.0")]
#[rustc_macro_transparency = "semitransparent"]
#[allow_internal_unstable(raw_ref_op)]
pub macro addr_of($place:expr)
{ /* 実装は省略 */ }

中間の参照を作ること無く、場所へのconstな生ポインタを生成する。

&や&mutによる参照の生成は、ポインタが正しくアライメントされており、かつ初期化されたデータに対してだけ行える。これらの要件が満たされない場合は代わりに生ポインタを代わりに使うべきである。しかし&expr as *const _は生ポインタへキャストする前に参照を作り出してしまい、全ての参照と同じ規則に従うこととなる。このマクロは、参照を最初に作ること無く生のポインタを作り出すことが出来る。

サンプル

use std::ptr;

#[repr(packed)]
struct Packed {
    f1: u8,
    f2: u16,
}

let packed = Packed { f1: 1, f2: 2 };
// `&packed.f2`は未アライン状態の参照を作ることになるが、それは未定義の挙動となってしまう！
let raw_f2 = ptr::addr_of!(packed.f2);
assert_eq!(unsafe { raw_f2.read_unaligned() }, 2);

`ptr::addr_of_mut!`

原典

#[stable(feature = "raw_ref_macros", since = "1.51.0")]
#[rustc_macro_transparency = "semitransparent"]
#[allow_internal_unstable(raw_ref_op)]
pub macro addr_of($place:expr)
{ /* 実装は省略 */ }

中間の参照を作ること無く、場所へのmutな生ポインタを生成する。

&や&mutによる参照の生成は、ポインタが正しくアライメントされており、かつ初期化されたデータに対してだけ行える。これらの要件が満たされない場合は代わりに生ポインタを代わりに使うべきである。しかし&mut expr as *mut _は生ポインタへキャストする前に参照を作り出してしまい、全ての参照と同じ規則に従うこととなる。このマクロは、参照を最初に作ること無く生のポインタを作り出すことが出来る。

サンプル

use std::ptr;

#[repr(packed)]
struct Packed {
    f1: u8,
    f2: u16,
}

let mut packed = Packed { f1: 1, f2: 2 };
// `&mut packed.f2`は未アライン状態の参照を作ることになるが、それは未定義の挙動となってしまう！
let raw_f2 = ptr::addr_of_mut!(packed.f2);
unsafe { raw_f2.write_unaligned(42); }
assert_eq!({packed.f2}, 42); // `{...}`によって、参照を作ないフィールドのコピーを強制する

`slice::fill_with`

原典

#[lang = "slice"]
#[cfg(not(test))]
impl<T> [T] {
    #[doc(alias = "memset")]
    #[stable(feature = "slice_fill_with", since = "1.51.0")]
    pub fn fill_with<F>(&mut self, mut f: F)
    where
        F: FnMut() -> T,
    { /* 実装は省略 */ }
}

クロージャを繰り返し呼び出すことにより、selfの要素を埋める。

このメソッドは新しい値を生成するためにクロージャを利用する。値をCloneしても良いならfillを使う。値の生成にDefaultトレイトを使いたい場合、引数にDefault::defaultを渡すと良い。

サンプル

let mut buf = vec![1; 10];
buf.fill_with(Default::default);
assert_eq!(buf, vec![0; 10]);

`slice::split_inclusive_mut`

原典

#[lang = "slice"]
#[cfg(not(test))]
impl<T> [T] {
    #[stable(feature = "split_inclusive", since = "1.51.0")]
    #[inline]
    pub fn split_inclusive_mut<F>(&mut self, pred: F) -> SplitInclusiveMut<'_, T, F>
    where
        F: FnMut(&T) -> bool,
    { /* 実装は省略 */ }
}

predとマッチする値で区切られた、可変の部分スライスに対するイテレータを返す。マッチした値は、直前の部分スライスの終端として含められる。

サンプル

let mut v = [10, 40, 30, 20, 60, 50];

for group in v.split_inclusive_mut(|num| *num % 3 == 0) {
    let terminator_idx = group.len()-1;
    group[terminator_idx] = 1;
}
assert_eq!(v, [10, 40, 1, 20, 1, 1]);

`slice::split_inclusive`

原典

#[lang = "slice"]
#[cfg(not(test))]
impl<T> [T] {
    #[stable(feature = "split_inclusive", since = "1.51.0")]
    #[inline]
    pub fn split_inclusive<F>(&self, pred: F) -> SplitInclusive<'_, T, F>
    where
        F: FnMut(&T) -> bool,
    { /* 実装は省略 */ }
}

predとマッチする値で区切られた、部分スライスに対するイテレータを返す。マッチした値は、直前の部分スライスの終端として含められる。

サンプル

let slice = [10, 40, 33, 20];
let mut iter = slice.split_inclusive(|num| num % 3 == 0);

assert_eq!(iter.next().unwrap(), &[10, 40, 33]);
assert_eq!(iter.next().unwrap(), &[20]);
assert!(iter.next().is_none());

もしスライスの最後の値がマッチした場合、その値は前のスライスの終端として扱われる。そのスライスはイテレータから返される最後のアイテムとなる。

let slice = [3, 10, 40, 33];
let mut iter = slice.split_inclusive(|num| num % 3 == 0);

assert_eq!(iter.next().unwrap(), &[3]);
assert_eq!(iter.next().unwrap(), &[10, 40, 33]);
assert!(iter.next().is_none());

`slice::strip_prefix`

原典

#[lang = "slice"]
#[cfg(not(test))]
impl<T> [T] {
    #[must_use = "returns the subslice without modifying the original"]
    #[stable(feature = "slice_strip", since = "1.51.0")]
    pub fn strip_prefix<P: SlicePattern<Item = T> + ?Sized>(&self, prefix: &P) -> Option<&[T]>
    where
        T: PartialEq,
    { /* 実装は省略 */ }
}

先頭が削除された部分スライスを返す。

もしスライスがprefixで始まる場合、それ以降の部分スライスをSomeに包んで返す。もしprefixが空の場合、単に元のスライスを返す。

もしスライスがprefixで始まらない場合、Noneを返す。

サンプル

let v = &[10, 40, 30];
assert_eq!(v.strip_prefix(&[10]), Some(&[40, 30][..]));
assert_eq!(v.strip_prefix(&[10, 40]), Some(&[30][..]));
assert_eq!(v.strip_prefix(&[50]), None);
assert_eq!(v.strip_prefix(&[10, 50]), None);

let prefix : &str = "he";
assert_eq!(b"hello".strip_prefix(prefix.as_bytes()),
           Some(b"llo".as_ref()));

`slice::strip_suffix`

原典

#[lang = "slice"]
#[cfg(not(test))]
impl<T> [T] {
    #[must_use = "returns the subslice without modifying the original"]
    #[stable(feature = "slice_strip", since = "1.51.0")]
    pub fn strip_suffix<P: SlicePattern<Item = T> + ?Sized>(&self, suffix: &P) -> Option<&[T]>
    where
        T: PartialEq,
    { /* 実装は省略 */ }
}

末尾が削除された部分スライスを返す。

もしスライスがsuffixで終わる場合、それ以前の部分スライスをSomeに包んで返す。もしsuffixが空の場合、単に元のスライスを返す。

もしスライスがsuffixで終わらない場合、Noneを返す。

サンプル

let v = &[10, 40, 30];
assert_eq!(v.strip_suffix(&[30]), Some(&[10, 40][..]));
assert_eq!(v.strip_suffix(&[40, 30]), Some(&[10][..]));
assert_eq!(v.strip_suffix(&[50]), None);
assert_eq!(v.strip_suffix(&[50, 30]), None);

`str::split_inclusive`

原典

#[lang = "str"]
#[cfg(not(test))]
impl str {
    #[stable(feature = "split_inclusive", since = "1.51.0")]
    #[inline]
    pub fn split_inclusive<'a, P: Pattern<'a>>(&'a self, pat: P) -> SplitInclusive<'a, P> {
    { /* 実装は省略 */ }
}

文字列をパターンにマッチする文字で分割し、文字列スライスへの部分文字列に対するイテレータを返す。 splitで生成されるイテレータと違い、split_inclusiveはマッチした部分を終端として部分文字列に残す。

patternには&strやString、charのスライスや、文字とマッチするかどうかを判定する関数・クロージャが使える。

サンプル

let v: Vec<&str> = "Mary had a little lamb\nlittle lamb\nlittle lamb."
    .split_inclusive('\n').collect();
assert_eq!(v, ["Mary had a little lamb\n", "little lamb\n", "little lamb."]);

文字列の最後の要素がマッチした場合、その要素は前の部分スライスの終端として扱われる。その部分文字列はイテレータから返される最後のアイテムとなる。

let v: Vec<&str> = "Mary had a little lamb\nlittle lamb\nlittle lamb.\n"
    .split_inclusive('\n').collect();
assert_eq!(v, ["Mary had a little lamb\n", "little lamb\n", "little lamb.\n"]);

`sync::OnceState`

原典

#[stable(feature = "once_poison", since = "1.51.0")]
#[derive(Debug)]
pub struct OnceState { /* フィールドは省略 */ }

Once::call_once_force()のクロージャの引数として渡される状態。 Onceの汚染状態を照会するのに使える。

`sync::OnceState::is_poisoned`

原典

impl OnceState {
    #[stable(feature = "once_poison", since = "1.51.0")]
    pub fn is_poisoned(&self) -> bool
    { /* 実装は省略 */ }
}

Once::call_once_force()に渡されたクロージャがが呼び出される時点で、紐づくOnceが汚染されていればtrueを返す。

サンプル

汚染されたOnce：

use std::sync::Once;
use std::thread;

static INIT: Once = Once::new();

// onceを汚染
let handle = thread::spawn(|| {
    INIT.call_once(|| panic!());
});
assert!(handle.join().is_err());

INIT.call_once_force(|state| {
    assert!(state.is_poisoned());
});

未汚染のOnce：

use std::sync::Once;

static INIT: Once = Once::new();

INIT.call_once_force(|state| {
    assert!(!state.is_poisoned());
});

`task::Wake`

原典

#[stable(feature = "wake_trait", since = "1.51.0")]
pub trait Wake { /* 定義は省略 */ }

実行機構（executor）上のタスクを起床させるための実装。

このトレイトはWakerを生成するのに使う。実行機構はこのトレイトの実装を定義することで、実行機構上で実行されたタスクに、それを使ったWakerを生成して渡すことが出来る。

このトレイトは、RawWakerを構築することに対するメモリ安全かつ人間工学的な代替手段である。これは、タスクを起床させるためのデータをArcに格納するという一般的な実行機構の設計を支援する。いくつかの（特に組込みシステム向けの）実行機構はこのAPIを使えない。そのようなシステム向けにこそ、代替手段としてのRawWakerが存在する。

サンプル

futureを取って完了するまで現在のスレッドで実行する、基礎的なblock_on。

参考：このサンプルはシンプルである代償として正確さを欠く。デッドロックを防ぐため、本番向けの実装はthread::unparkの中間的な呼び出しやネストされた呼び出しを処理する必要がある。

use std::future::Future;
use std::sync::Arc;
use std::task::{Context, Poll, Wake};
use std::thread::{self, Thread};

/// 呼び出された際、現在のスレッドを起床させるwaker。
struct ThreadWaker(Thread);

impl Wake for ThreadWaker {
    fn wake(self: Arc<Self>) {
        self.0.unpark();
    }
}

/// futureを、完了するまで現在のスレッドで実行する。
fn block_on<T>(fut: impl Future<Output = T>) -> T {
    // ポーリングするためにfutureをピン留めする。
    let mut fut = Box::pin(fut);

    // futureに渡される新しいコンテキストを生成する。
    let t = thread::current();
    let waker = Arc::new(ThreadWaker(t)).into();
    let mut cx = Context::from_waker(&waker);

    // 完了するまでfutureを実行する。
    loop {
        match fut.as_mut().poll(&mut cx) {
            Poll::Ready(res) => return res,
            Poll::Pending => thread::park(),
        }
    }
}

block_on(async {
    println!("futureの中からこんにちは！");
});

`task::Wake::wake`

原典

#[stable(feature = "wake_trait", since = "1.51.0")]
pub trait Wake {
    #[stable(feature = "wake_trait", since = "1.51.0")]
    fn wake(self: Arc<Self>);
}

このタスクを起床させる。

`task::Wake::wake_by_ref`

原典

#[stable(feature = "wake_trait", since = "1.51.0")]
pub trait Wake {
    #[stable(feature = "wake_trait", since = "1.51.0")]
    fn wake_by_ref(self: &Arc<Self>)
    { /* 実装は省略 */ }
}

wakerを消費せずにタスクを起床させる。

もし実行機構が、より安価に、wakerを消費せずに起床させることが出来る場合、このメソッドをオーバーライドするべきである。標準では、Arcを複製した上でwakeを呼び出す。

変更点リスト

公式リリースノートをベースに意訳・編集・追記をした変更点リストです。

言語

関数やトレイト、構造体などを、型やライフタイムに加えて定数値でパラメータ化出来るようになった。これは定数ジェネリクス（const generics）として知られる。以下のように欠くことが出来る。参考：今のところ、プリミティブな数値やbool、charと言った型のみ使用可能

struct GenericArray<T, const LENGTH: usize> {
    inner: [T; LENGTH]
}

impl<T, const LENGTH: usize> GenericArray<T, LENGTH> {
    const fn last(&self) -> Option<&T> {
        if LENGTH == 0 {
            None
        } else {
            Some(&self.inner[LENGTH - 1])
        }
    }
}

コンパイラ

macOSプラットフォームにおいてコード生成のオプションに-Csplit-debuginfoを追加。このオプションは、デバッグ情報を複数のファイルに分割するか、1つのファイルにまとめるかを制御する。参考：他のプラットフォームではこのオプションは安定化されていない
次のターゲットがティア3でサポートされるようになった： aarch64_be-unknown-linux-gnu・aarch64-unknown-linux-gnu_ilp32・aarch64_be-unknown-linux-gnu_ilp32
次のターゲットがティア3でサポートされるようになった：i386-unknown-linux-gnu・i486-unknown-linux-gnu
オプションtarget-cpu=nativeがCPUの個々の機能を検出するようになった

※Rustのティアで管理されるプラットフォームの詳細はPlatform Supportのページ（英語）を参照

ライブラリ

安定化されたAPI

※各APIのドキュメントを独自に訳した安定化されたAPIのドキュメントもご参照ください。

Cargo

コード生成オプション-Csplit-debuginfoを制御するためのプロファイルオプションsplit-debuginfoが追加された
Cargo.tomlにresolverフィールドが追加され、新しいfeatureの解決機構とCLIオプションの挙動を有効化出来るようになった。 feature解決機構のバージョン2は依存関係でのfeatureの不要な統合を出来るだけ避ける。ビルドスクリプトや手続きマクロで同じ依存関係のstd featureを使うが、最終バイナリにおいてはno-std featureを使う場合などが考えられる。 featureに関する詳細はCargo book documentation（訳注：英語）を参照

Rustdoc

ドキュメント内リンクへの多数の改善：

さいごに

次のRust 1.52は、人によってはGW真っ直中の2021/5/7(金)に予定されています。

オプティムでは普通エンジニアを募集しています。

ライセンス表記

この記事はApache 2/MITのデュアルライセンスで公開されている公式リリースノートを翻訳・追記をしています
冒頭の画像中にはRust公式サイトで配布されているロゴを使用しており、このロゴはRust財団によってCC-BYの下で配布されています（はず）
冒頭の画像中にはStackOverflow公式サイトで配布されているロゴを、利用規約に則り使用しています
冒頭の画像中にはTypeScript公式サイトで配布されているロゴを、利用規約に則り使用しています
冒頭の画像はいらすとやさんの画像を使っています。いつもありがとうございます

MIT License

Permission is hereby granted, free of charge, to any
person obtaining a copy of this software and associated
documentation files (the "Software"), to deal in the
Software without restriction, including without
limitation the rights to use, copy, modify, merge,
publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software
is furnished to do so, subject to the following
conditions:

The above copyright notice and this permission notice
shall be included in all copies or substantial portions
of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.

Apache License

                              Apache License
                        Version 2.0, January 2004
                     http://www.apache.org/licenses/

TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

1. Definitions.

   "License" shall mean the terms and conditions for use, reproduction,
   and distribution as defined by Sections 1 through 9 of this document.

   "Licensor" shall mean the copyright owner or entity authorized by
   the copyright owner that is granting the License.

   "Legal Entity" shall mean the union of the acting entity and all
   other entities that control, are controlled by, or are under common
   control with that entity. For the purposes of this definition,
   "control" means (i) the power, direct or indirect, to cause the
   direction or management of such entity, whether by contract or
   otherwise, or (ii) ownership of fifty percent (50%) or more of the
   outstanding shares, or (iii) beneficial ownership of such entity.

   "You" (or "Your") shall mean an individual or Legal Entity
   exercising permissions granted by this License.

   "Source" form shall mean the preferred form for making modifications,
   including but not limited to software source code, documentation
   source, and configuration files.

   "Object" form shall mean any form resulting from mechanical
   transformation or translation of a Source form, including but
   not limited to compiled object code, generated documentation,
   and conversions to other media types.

   "Work" shall mean the work of authorship, whether in Source or
   Object form, made available under the License, as indicated by a
   copyright notice that is included in or attached to the work
   (an example is provided in the Appendix below).

   "Derivative Works" shall mean any work, whether in Source or Object
   form, that is based on (or derived from) the Work and for which the
   editorial revisions, annotations, elaborations, or other modifications
   represent, as a whole, an original work of authorship. For the purposes
   of this License, Derivative Works shall not include works that remain
   separable from, or merely link (or bind by name) to the interfaces of,
   the Work and Derivative Works thereof.

   "Contribution" shall mean any work of authorship, including
   the original version of the Work and any modifications or additions
   to that Work or Derivative Works thereof, that is intentionally
   submitted to Licensor for inclusion in the Work by the copyright owner
   or by an individual or Legal Entity authorized to submit on behalf of
   the copyright owner. For the purposes of this definition, "submitted"
   means any form of electronic, verbal, or written communication sent
   to the Licensor or its representatives, including but not limited to
   communication on electronic mailing lists, source code control systems,
   and issue tracking systems that are managed by, or on behalf of, the
   Licensor for the purpose of discussing and improving the Work, but
   excluding communication that is conspicuously marked or otherwise
   designated in writing by the copyright owner as "Not a Contribution."

   "Contributor" shall mean Licensor and any individual or Legal Entity
   on behalf of whom a Contribution has been received by Licensor and
   subsequently incorporated within the Work.

2. Grant of Copyright License. Subject to the terms and conditions of
   this License, each Contributor hereby grants to You a perpetual,
   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
   copyright license to reproduce, prepare Derivative Works of,
   publicly display, publicly perform, sublicense, and distribute the
   Work and such Derivative Works in Source or Object form.

3. Grant of Patent License. Subject to the terms and conditions of
   this License, each Contributor hereby grants to You a perpetual,
   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
   (except as stated in this section) patent license to make, have made,
   use, offer to sell, sell, import, and otherwise transfer the Work,
   where such license applies only to those patent claims licensable
   by such Contributor that are necessarily infringed by their
   Contribution(s) alone or by combination of their Contribution(s)
   with the Work to which such Contribution(s) was submitted. If You
   institute patent litigation against any entity (including a
   cross-claim or counterclaim in a lawsuit) alleging that the Work
   or a Contribution incorporated within the Work constitutes direct
   or contributory patent infringement, then any patent licenses
   granted to You under this License for that Work shall terminate
   as of the date such litigation is filed.

4. Redistribution. You may reproduce and distribute copies of the
   Work or Derivative Works thereof in any medium, with or without
   modifications, and in Source or Object form, provided that You
   meet the following conditions:

   (a) You must give any other recipients of the Work or
       Derivative Works a copy of this License; and

   (b) You must cause any modified files to carry prominent notices
       stating that You changed the files; and

   (c) You must retain, in the Source form of any Derivative Works
       that You distribute, all copyright, patent, trademark, and
       attribution notices from the Source form of the Work,
       excluding those notices that do not pertain to any part of
       the Derivative Works; and

   (d) If the Work includes a "NOTICE" text file as part of its
       distribution, then any Derivative Works that You distribute must
       include a readable copy of the attribution notices contained
       within such NOTICE file, excluding those notices that do not
       pertain to any part of the Derivative Works, in at least one
       of the following places: within a NOTICE text file distributed
       as part of the Derivative Works; within the Source form or
       documentation, if provided along with the Derivative Works; or,
       within a display generated by the Derivative Works, if and
       wherever such third-party notices normally appear. The contents
       of the NOTICE file are for informational purposes only and
       do not modify the License. You may add Your own attribution
       notices within Derivative Works that You distribute, alongside
       or as an addendum to the NOTICE text from the Work, provided
       that such additional attribution notices cannot be construed
       as modifying the License.

   You may add Your own copyright statement to Your modifications and
   may provide additional or different license terms and conditions
   for use, reproduction, or distribution of Your modifications, or
   for any such Derivative Works as a whole, provided Your use,
   reproduction, and distribution of the Work otherwise complies with
   the conditions stated in this License.

5. Submission of Contributions. Unless You explicitly state otherwise,
   any Contribution intentionally submitted for inclusion in the Work
   by You to the Licensor shall be under the terms and conditions of
   this License, without any additional terms or conditions.
   Notwithstanding the above, nothing herein shall supersede or modify
   the terms of any separate license agreement you may have executed
   with Licensor regarding such Contributions.

6. Trademarks. This License does not grant permission to use the trade
   names, trademarks, service marks, or product names of the Licensor,
   except as required for reasonable and customary use in describing the
   origin of the Work and reproducing the content of the NOTICE file.

7. Disclaimer of Warranty. Unless required by applicable law or
   agreed to in writing, Licensor provides the Work (and each
   Contributor provides its Contributions) on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
   implied, including, without limitation, any warranties or conditions
   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
   PARTICULAR PURPOSE. You are solely responsible for determining the
   appropriateness of using or redistributing the Work and assume any
   risks associated with Your exercise of permissions under this License.

8. Limitation of Liability. In no event and under no legal theory,
   whether in tort (including negligence), contract, or otherwise,
   unless required by applicable law (such as deliberate and grossly
   negligent acts) or agreed to in writing, shall any Contributor be
   liable to You for damages, including any direct, indirect, special,
   incidental, or consequential damages of any character arising as a
   result of this License or out of the use or inability to use the
   Work (including but not limited to damages for loss of goodwill,
   work stoppage, computer failure or malfunction, or any and all
   other commercial damages or losses), even if such Contributor
   has been advised of the possibility of such damages.

9. Accepting Warranty or Additional Liability. While redistributing
   the Work or Derivative Works thereof, You may choose to offer,
   and charge a fee for, acceptance of support, warranty, indemnity,
   or other liability obligations and/or rights consistent with this
   License. However, in accepting such obligations, You may act only
   on Your own behalf and on Your sole responsibility, not on behalf
   of any other Contributor, and only if You agree to indemnify,
   defend, and hold each Contributor harmless for any liability
   incurred by, or claims asserted against, such Contributor by reason
   of your accepting any such warranty or additional liability.

END OF TERMS AND CONDITIONS

APPENDIX: How to apply the Apache License to your work.

   To apply the Apache License to your work, attach the following
   boilerplate notice, with the fields enclosed by brackets "[]"
   replaced with your own identifying information. (Don't include
   the brackets!)  The text should be enclosed in the appropriate
   comment syntax for the file format. We also recommend that a
   file or class name and description of purpose be included on the
   same "printed page" as the copyright notice for easier
   identification within third-party archives.

Copyright [yyyy] [name of copyright owner]

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

  http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

ピックアップ

ジェネリクスの引数として定数を使えるようになった

配列要素の所有権を奪いつつイテレート出来るようになった

featureの新しい解決機構が使えるようになった

安定化されたAPIのドキュメント

Arc::decrement_strong_count

安全性

サンプル

Arc::increment_strong_count

安全性

サンプル

Once::call_once_force

サンプル

Peekable::next_if_eq

サンプル

Peekable::next_if

サンプル

Seek::stream_position

サンプル

array::IntoIter

array::IntoIter::new

サンプル

array::IntoIter::as_slice

array::IntoIter::as_mut_slice

panic::panic_any

ptr::addr_of!

サンプル

ptr::addr_of_mut!

サンプル

slice::fill_with

サンプル

slice::split_inclusive_mut

サンプル

slice::split_inclusive

サンプル

slice::strip_prefix

サンプル

slice::strip_suffix

サンプル

str::split_inclusive

サンプル

sync::OnceState

sync::OnceState::is_poisoned

サンプル

task::Wake

サンプル

task::Wake::wake

task::Wake::wake_by_ref

変更点リスト

言語

コンパイラ

ライブラリ

安定化されたAPI

Cargo

Rustdoc

その他

互換性メモ

内部のみ

関連リンク

さいごに

ライセンス表記

`Arc::decrement_strong_count`

`Arc::increment_strong_count`

`Once::call_once_force`

`Peekable::next_if_eq`

`Peekable::next_if`

`Seek::stream_position`

`array::IntoIter`

`array::IntoIter::new`

`array::IntoIter::as_slice`

`array::IntoIter::as_mut_slice`

`panic::panic_any`

`ptr::addr_of!`

`ptr::addr_of_mut!`

`slice::fill_with`

`slice::split_inclusive_mut`

`slice::split_inclusive`

`slice::strip_prefix`

`slice::strip_suffix`

`str::split_inclusive`

`sync::OnceState`

`sync::OnceState::is_poisoned`

`task::Wake`

`task::Wake::wake`

`task::Wake::wake_by_ref`