Rustでの借入と生涯

Yahoo!のエンジニアであるArthur Liaoのブログの記事「Rust Borrow and Lifetimes」の翻訳を紹介します。



Rustは、 バージョン1.0から活発に開発されている新しいプログラミング言語です。 Rustとそれがなぜクールなのかについて別のブログを書くことができますが、今日は借用システムと自分自身を含む多くの新人を混乱させる寿命に焦点を当てます。 この投稿では、Rustの基本的な理解があることを前提としています。 そうでない場合は、最初にガイド自体と道案内ガイドを読むことができます。

リソース所有権と借入

Rustは、洗練された借用システムを使用することにより、ガベージコレクションなしでメモリセキュリティを提供します。 リソースを解放しているリソースには、少なくとも1人の所有者がいます。 ＆または＆mutを使用してリソースにアクセスするための新しいバインダーを作成できます。これは、借用および可変借用と呼ばれます。 コンパイラは、すべての所有者と借り手の適切な動作を監視します。

コピーして移動

借用システムに移行する前に、Rustでcopyおよびmoveメソッドがどのように処理されるかを知る必要があります。 StackOverflowからのこの回答は、読むだけで十分です。 一般に、割り当てと関数では、次のように呼び出されます。



1.値がコピーされる場合（プリミティブ型のみが関与し、メモリやファイル処理などのリソースが関与しない場合）、コンパイラーはデフォルトでコピーします。

2.それ以外の場合、コンパイラは所有権を転送（転送）し、元のバインディングを無効にします。



要するに、ポッド（古いデータの読み取り）=>コピー、非ポッド（線形タイプ）=>移動。



参考のために、追加の注意事項がいくつかあります。



* Rustコピー方法はCに似ています。 値ごとの使用は、セマンティックコピーまたはクローンではなく、バイトコピー（シャドウmemcpyコピーメソッド）です。

*ポッド構造をコピー不可にするには、NoCopyマーカーフィールドを使用するか、ドロップ特性を実装します。



移動後、所有権は次の所有者に移されます。

リソースリリース

Rustでは、次の場合など、所有権がなくなるとすぐにオブジェクトが解放されます。



1.所有者はエリアの外にいるか、

2.バインディングの所有権が変更されます（それにより、元のバインディングは無効になります）

所有者（借り手）と借り手（借り手）の特権と制限

このセクションは、特権の観点からコピーと移動の方法を参照したRustハンドブックに基づいています。



所有者にはいくつかの特権があります。 そして多分：



1.リソース割り当てを監視する

2.リソースを変更せずに借りる（複数の借り入れ）または変更可能（排他的）で、

3.所有権の移転（移転を伴う）。



所有者にはいくつかの制限もあります。



1.借用のプロセスでは、所有者は（a）リソースを変更したり、（b）変更された形式で借用することはできません。

2.可変借入のプロセスでは、所有者は（a）リソースにアクセスすることも（b）借りることもできません。



借り手にはいくつかの特権もあります。 借り手は、アクセスの取得または借りたリソースの変更に加えて、別の借り手と共有することもできます。



1.借用者は、ポインタ不変の借用を配布（コピー）できます。

2.変動借入人は変動借入を譲渡（移動）できます。 （可変参照が移動されていることに注意してください）。

コード例

十分な話。 いくつかのコードを見てみましょう（play.rust-lang.orgでRustコードを実行できます）。 次のすべての例では、「struct Foo」を使用します。これは、パックされた（動的に割り当てられた）値を含むためコピーできないFoo構造です。 コピー不可能なリソースを使用すると、操作の可能性が制限されます。これは、調査段階では良い考えです。



サンプルコードごとに、所有者、借り手などの領域を示すために「地域グラフ」も示されています。タイトルバーの波括弧は、コード自体の中括弧と一致しています。

所有者は、変数借入のプロセスでリソースにアクセスできません

「println：」の最後の行のコメントを外さない限り、次のコードはコンパイルされません。

struct Foo { f: Box<int>, } fn main() { let mut a = Foo { f: box 0 }; //   let x = &mut a; // :    `af`  , . . `a`     // println!("{}", af); } { ax * }  a |_____|  x |___| x = &mut a  af | 
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

これは所有者の制限＃2（a）に違反します。 ネストされたブロックに「let x =＆mut a;」を入れると、println行の前で借用が終了します。 これはうまくいくかもしれません：

 fn main() { let mut a = Foo { f: box 0 }; { //   let x = &mut a; //     } println!("{}", af); } { a { x } * }  a |_________|  x |_| x = &mut a  af | OK
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

借り手は変数の借り入れを新しい借り手に移すことができます

このコードは、借り手＃2の特権を示しています。変数借り手xは、変数借り入れを新しい借り手yに転送（移動）できます。

 fn main() { let mut a = Foo { f: box 0 }; //   let x = &mut a; //       y let y = x; // :   : `xf` // println!("{}", xf); } { axy * }  a |_______|  x |_| x = &mut a  y |___| y = x  xf | 
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

移動後、元の借り手xは借りたリソースにアクセスできなくなります。

借入エリア

ここにリンク（＆と＆mut）を渡すとすべてが面白くなり、多くの初心者が混乱します。

生涯

借入の全歴史において、借り手による借り入れはどこで始まり、どこで終わるかを知ることが重要です。 ライフタイムガイドでは、これをライフタイムと呼びます。



ライフタイムは、ポインターが有効な実行距離の静的な推定値です。常に、プログラム内の式またはブロックに対応します。

＆=借用

借用についてのいくつかの言葉。 まず、＆=借用、および＆mut =可変借用であることを思い出してください。 ＆記号が表示されるところはどこでも、これは借用です。



次に、＆記号が各構造体（フィールド内）または関数/クロージャー（戻り値型またはキャプチャーされたリンク）に表示される場合、そのような構造体/関数/クロージャーは借用者であり、すべての借用規則が適用されます。



第三に、借入ごとに所有者と単一の借り手または複数の借り手がいます。

ローンエリアの拡大

ローンの分野について一言。 まず、ローン地域：

借入が有効な地域であり、

-借り手はローンの範囲を拡大できます（以下を参照）。



第二に、借り手は、割り当てまたは関数呼び出しで発生するコピー（不変の借入）または移動（不変のローン）を通じてローンの範囲を拡大できます。 受信者（これは、新しい接続、構造、機能、またはクロージャである場合があります）が新しい借り手になります。



第三に、ローン地域はすべての借り手のエリアの結合であり、借りたリソースはローン地域全体で有効でなければなりません。

ローン式

これで、ローンの公式ができました。

リソース領域> =ローン領域=すべての借り手の領域の結合

コード例

ローンの範囲を拡大するいくつかの例を見てみましょう。 struct Foo構造は以前と同じです。

 fn main() { let mut a = Foo { f: Box::new(0) }; let y: &Foo; if false { //  let x = &a; //     y,    y = x; } // :     `af`, ,    // af = Box::new(1); } { a { xy } * }  a |___________|  x |___| x = &a  y |_____| y = x   |=======|  af | 
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ローンがifブロック内で発生し、借り手xがifブロックを超えたとしても、彼は割り当てy = x;を介して借り入れの範囲を拡大したため、2つの借り手xとyがあります。 ローンの式によると、ローンの領域は借り手xと借り手yの結合であり、最初のローンlet x =＆a; 本体の最後まで。 （let y：＆Foo;バインディングは借り手ではないことに注意してください）



条件は常にfalseであるため、ifブロックは決して満たされないことに気付いたかもしれませんが、コンパイラはリソース `a`の所有者がリソースにアクセスすることを依然として防ぎます。 これは、すべてのローンチェックがコンパイル時に行われ、実行時には何もしないためです。

複数のリソースを借りる

これまでのところ、1つのリソースからの借用のみに焦点を当ててきました。 借り手は複数のリソースを取ることができますか？ もちろん！ たとえば、関数は2つのリンクを取得し、特定の基準に応じて1つを返すことができます。たとえば、どちらのリンクが他のリンクよりも大きいかなどです。

 fn max(x: &Foo, y: &Foo) -> &Foo
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

max関数は＆ポインターを返すため、借り手です。 返される結果はインバウンドリンクのいずれかになる可能性があるため、2つのリソースを借用します。

名前付きローンエリア

入力として複数の＆ポインターがある場合、ライフタイムガイドで定義された名前で、ライフタイムを使用してそれらの関係を示す必要があります。 しかし、今のところは、それらを名前付きローンエリアと呼びましょう。



上記のコードは、借り手間の関係を示すことなしにコンパイラーによって受け入れられません。つまり、借り手、つまりローン領域にグループ化された借り手です。 この実装は正しいでしょう：

 fn max<'a>(x: &'a Foo, y: &'a Foo) -> &'a Foo { if xf > yf { x } else { y } } (        'a'.) max( { } )  *x <-------------->  *y <-------------->   'a <==============>  x |___|  y |___|   |___|   
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

この関数には、1つのローン領域「a」と3つの借り手があります。2つの入力パラメーターと、関数によって返される結果です。 上記の借入式は引き続き適用されますが、今ではすべての借入リソースが式を満たす必要があります。 以下の例を参照してください。

コード例

次のコードでmax関数を使用して、aとbから最も多くを選択してみましょう。

 fn main() { let a = Foo { f: Box::new(1) }; let y: &Foo; if false { let b = Foo { f: Box::new(0) }; let x = max(&a, &b); // : `b`     // y = x; } } { a { bx ( ) y } }  a |________________|   b |__________|    |==========|   |_| &a   |_| &b  x |________| x = max(&a, &b)  y |___| y = x
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

let x = max（＆a、＆b）;の前に ＆aおよび＆bは式でのみ有効な一時参照であり、3番目の借り手xはifブロックの最後まで2つのリソース（両方とも借り手チェックがある場合はaまたはbのいずれか）を使用するため、すべてが順調です。ローンはlet x = max（＆a、＆b）; ifブロックの最後まで。 リソースaおよびbは、ローン領域全体で有効であるため、ローンの式を満たします。



ここで、最後の値y = x;のコメントを外すと、yが4番目の借り手になり、メインブロックの最後までローン領域が増加し、その結果、リソースbがローン計算式テストに失敗します。

借り手としての構造

関数とクロージャに加えて、構造はその領域で複数の参照を維持しながら、いくつかのリソースを占有することもできます。 以下の例と、ローンの式がどのように適用されるかを見てみましょう。 Link構造を使用してリンクを保存しましょう（不変の借用）：

 struct Link<'a> { link: &'a Foo, }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

構造はいくつかのリソースを借ります

フィールドが1つだけの場合でも、リンク構造には複数のリソースを使用できます。

 fn main() { let a = Foo { f: Box::new(0) }; let mut x = Link { link: &a }; if false { let b = Foo { f: Box::new(1) }; // : `b`     // x.link = &b; } } { ax { b * } }  a |___________|   b |___|    |=========|  x |_________| x.link = &a  x |___| x.link = &b
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

上記の例では、借り手xは所有者aからリソースを借りており、貸し出しエリアはメインブロックの最後まで行きます。 すべて順調です。 最後の行x.link =＆b;のコメントを外すと、xは所有者bからリソースを借用しようとし、リソースbはローン計算式テストに失敗します。

返り値なしでローン領域を拡張する機能

戻り値のない関数は、入力パラメーターを介してローンの範囲を拡張することもできます。 たとえば、store_foo関数はLinkへの可変リンクを受け入れ、Foo（不変な借用）リンクをそこに保存します。

 fn store_foo<'a>(x: &mut Link<'a>, y: &'a Foo) { x.link = y; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

次のコードでは、借用したリソースがリソースを所有しています。 リンク構造は相互に借り手xを参照します（つまり、* xは借り手です）。 ローンエリアはメインブロックの最後まで行きます。

 fn main() { let a = Foo { f: Box::new(0) }; let x = &mut Link { link: &a }; if false { let b = Foo { f: Box::new(1) }; // store_foo(x, &b); } } { ax { b * } }  a |___________|   b |___|    |=========|  *x |_________| x.link = &a  *x |___| x.link = &b
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

最後の行のコメントを解除する場合store_foo（x、＆b）; この関数は、＆bをx.linkに保存しようとします。リソースbの領域はローン領域全体をカバーしていないため、リソースbを別の借入リソースにし、ローン計算式のテストに失敗します。

複数のローンエリア

関数には、いくつかの名前付きローン領域があります。 例：

 fn superstore_foo<'a, 'b>(x: &mut Link<'a>, y: &'a Foo, x2: &mut Link<'b>, y2: &'b Foo) { x.link = y; x2.link = y2; }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

この（おそらくあまり有用ではない）機能には、2つの異なるローン領域が含まれます。 各ローン地域には、独自の借入式があります。

生涯が混乱する理由

最後に、Rustのローンシステムで使用される存続期間という用語が紛らわしいと思う理由を説明します（したがって、このブログではこの用語の使用を避けています）。



ローンについて話すとき、「生涯」には3つのタイプがあります。



A：リソースの所有者の寿命（または所有/借用したリソース）

B：ローン全体の「存続期間」、つまり 最初のローンから返品まで

C：個々の借り手または借りたポインタの寿命



誰かが「存在時間」という用語を話すとき、彼は上記のいずれかを意味するかもしれません。 複数のリソースと借り手が関与している場合、すべてがさらに混乱します。 たとえば、関数または構造体の宣言で「名前付きライフタイム」は何をしますか？ これはA、B、またはCを意味しますか？



以前のmax関数では：

 fn max<'a>(x: &'a Foo, y: &'a Foo) -> &'a Foo { if xf > yf { x } else { y } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

「a」の存続期間とはどういう意味ですか？ 2つのリソースが関係し、存在時間が異なるため、これはAであってはなりません。 x、y、および関数の戻り値の3つの借り手があり、それらはすべて異なるライフタイムを持っているため、Cにすることはできません。 これはBを意味しますか？ おそらく。 しかし、ローンの全領域は特定のオブジェクトではありません。どのようにして「存在時間」を持つことができますか？ それを存在の時間と呼ぶのは間違っています。



これは、借りたリソースのライフタイムの最小要件を意味すると言うかもしれません。 場合によっては、これが違いを生む可能性がありますが、どのようにしてそれらを「存在時間」と呼ぶことができますか？



所有権/借入の概念自体は複雑です。 「ライフタイム」を与えるものをめぐる混乱は、開発をさらに理解しにくいものにしていると思います。



PS上記で定義したA、B、およびCを使用すると、ローンの式は次のようになります。

  A >= B = C1 U C2 U … U Cn
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

Rustを学ぶのはあなたの価値があります！

ローンと習得を学ぶには長い時間がかかりますが、勉強するのは面白いです。 Rustはガベージコレクションなしでセキュリティを達成しようとしますが、それでも非常にうまく機能します。 Haskellをマスターすると、プログラムの方法が変わると言う人もいます。 Rustを開発することもあなたの時間の価値があると思います。



この投稿がお役に立てば幸いです。