1. はじめに

ここではRustの新奇性のみにしぼって解説する。 実際的なこと(インストール方法とか)は説明しない。

• NULL参照
• Double free
• Dangling pointer

背景

• 2006年〜 (2009年よりMozilla公式)
• LLVM経由で C ABI を生成
• www.rust-lang.org
• Mozilla はこれでFirefoxを安全に書き直そうとしている。

2. 最初のプログラム

fn main() {
  let x = 2;  // これは
  let y = 3;  // コメント
  println!("x+y={}", x+y);
}

• 変数の型は推論される。
• ! がつくものはマクロ (hygienic) である。

3. 構造体

struct Point {
  x: i32,
  y: i32,
}

fn main() {
  let p = Point { x:2, y:3 };
  println!("p={},{}", p.x, p.y);
}

• 構造体はサイズを知る必要があるので、型を指定する。
• i32 = int
• p はスタック上に存在。

4. ヒープを使う

fn main() {
  let q = Box::new(Point { x:2, y:3 });
  println!("q={},{}", (*q).x, (*q).y);
  println!("q={},{}", q.x, q.y);  // OK
}

• Box::new() = 基本的に malloc。
• 参照は * で解決する。
• 自明な参照は自動的に解決される。

5. C++ における RAII

main() {
  file f("hello.txt");  // ファイルが開かれる。
  string s(f.read());   // 文字列が初期化される。
  cout << s << endl;
  // f, s が自動的に解放される。
}

• RAII (Resource Acquisition Is Initialization)
  • 変数ができたのと同時に初期化されている。
  • 変数がスコープから外れるのと同時に解放される。
• 厳密なRAIIでは、ポインタがNULLになることはない。

5. RustにおけるRAII

fn main() {
  {
    let q = Box::new(Point { x:2, y:3 });
    println!("q={},{}", q.x, q.y);
    // q は勝手に解放される。
  }
  println!("q={},{}", q.x, q.y); // ERROR
}

• Rustでは、厳密なRAIIを使っている。
• よってNULLポインタが存在しない。
• GCは使っていない。

6. 余談: Option型

fn main()
{
  let s = Some(Point { x:2, y:3 });
  // または s = None;
  match s {
    Some(p) => println!("p={},{}", p.x, p.y),
    None    => println!("p=null"),
  }
}

• NULLをポインタとして認めるのではなく、
  「boolean | 有効なポインタ」として処理すべき。

Swiftの場合

• Swiftのoptional型はやや限定されている。
  「nilかどうか」しか判定できない。

  let s: Point?
  if let p = s {
     print("p=\(p.x),\(p.y)")
  } else {
     print("p=null")
  }
  

7. ここまでの復習

• NULL参照 (RAII, Option型)
• Double free
• Dangling pointer

8. C++では…

show(Point* p) {
  printf("p=%d,%d\n", p->x, p->y);
  delete p;
}

main() {
  Point* p = new Point(2, 3);
  show(p);
  delete p;  // Double free
}

9. Rustでは…

fn show(p: Box<Point>) {
  println!("p={},{}", p.x, p.y);
  // RAIIにより勝手に解放される。
}

fn main() {
  let p = Box::new(Point { x:2, y:3 });
  show(p);  // pの所有権がshowに移る。
}

• Rust では、すべての値に所有権という概念が存在する。
• 所有権 = free する責任。

10. Rustでは…

fn show(p: Box<Point>) {
  println!("p={},{}", p.x, p.y);
}

fn main() {
  let p = Box::new(Point { x:2, y:3 });
  show(p);
  // この時点で、pはすでにmainのものではない。
  println!("area={}", p.x * p.y); // ERROR
}

• 所有権を渡したらもうアクセスできない。
• 所有権の移動はコンパイル時に静的に決定される。 (GCは使わない)

11. 所有権つづき

fn alloc() -> Box<Point> {
  let p = Box::new(Point { x:2, y:3 });
  // 所有権を返す。
  return p;
}

fn main() {
  let p = alloc();  // 所有権を得る。
  println!("p={},{}", p.x, p.y);
  // RAIIにより解放。
}

• 所有権は呼び出し先 → 呼び出し元に移動することもある。

12. データの共有

fn show(p: &Box<Point>) {  // pは借り物。
  println!("p={},{}", p.x, p.y);
}

fn main() {
  let p = Box::new(Point { x:2, y:3 });
  show(p);  // 貸しただけ。
  println!("area={}", p.x * p.y);
  // 所有者はまだ俺だから解放しなきゃ。
}

• & がついた型は「借り物 (borrow)」であることを表す。
• 借り物は所有権が移らない (→ 勝手に解放できない)。
• 所有者 (解放する責任者) はつねに1人だけ。

13. また貸し

fn area(p: Box<Point>) -> i32 { // 本物
  return p.x * p.y;
}
fn show(p: &Box<Point>) { // 借り物
  println!("p={},{}", p.x, p.y);
  // 借り物を本物として渡そうとすると
  println!("area={}", area(p)); // ERROR
}

fn main() {
  let p = Box::new(Point { x:2, y:3 });
  show(p);
}

• 「借り物」の所有権を渡すことはできない。

14. ちなみに…

fn main() {
  let p = Point { x:2, y :3 };
  println!("p={},{}", p.x, p.y);
  let q = p;
  println!("area={}", q.x * q.y); // OK
  println!("area={}", p.x * p.y); // ERROR
}  

• たんに参照を代入しただけでも所有権は移動する。
• 参照型でない値 (=intなど) は暗黙コピーされる。

15. ここまでの復習

• NULL参照 (RAII, Option型)
• Double free (所有権)
• Dangling pointer

16. C/C++ では…

class Foo {
  Point* p;
public:
  Foo(Point* p) {
    this->p = p;
  }
};

main() {
  Point* p = new Point(2,3);
  Foo* foo = new Foo(p);
  delete p;
  // foo->p は Dangling
}

図で表すと…

17. Rustでは…

struct Foo {
  pt: Box<Point>,  // 所有権をもつ。
}

fn main() {
  let p = Box::new(Point { x:2, y:3 });
  // pの所有権は foo内に移動する。
  let foo = Foo { pt:p };
  // もう p は俺の物じゃない。
  println!("p={},{}", p.x, p.y); // ERROR
  // fooが解放されると p も解放される。
}

• 所有権を移動する場合は簡単。

18. どーなんの?

struct Foo {
  pt: &Box<Point>,  // 借り物
}
fn alloc(&Box<Point>) -> Foo {
  return Foo { pt:p };  // 借り物が入った本物
}

fn main() {
  let p = Box::new(Point { x:2, y:3 });
  let foo = alloc(&p);
  println!("p={},{}", p.x, p.y); // OK...のはず
}
// 実際にはコンパイル不可

19. 生存期間という考え

struct Foo {
  pt: &Box<Point>,  // 借り物
}

• 「借り物」が入った Foo 型は限られた期間だけ有効。
• この「限られた期間」は、借り物の有効期間に依存する。 つまり Foo はパラメータ化された型なのである。
• このパラメータのことを「生存期間 (lifetime)」と呼ぶ。

図で表すと…

20. 生存期間識別子

struct Foo<'a> {
  // pt は、少なくとも Foo本体と期間は生きる。
  pt: &'a Box<Point>,
}

// 「与えられた p と同じ期間は生きる Foo」を返す。
fn alloc<'a>(p: &'a Box<Point>) -> Foo<'a> {
  return Foo { pt:p };
}

• 生存期間識別子は 'a, 'b のように表す。 (型をさらに限定するという意味で <...> が使われている。)
• 生存期間が必要なのは「借り物 (&)」に対してのみ。

生存期間つきの型を使う

fn main() {
  let p = Box::new(Point { x:2, y:3 });
  let foo = alloc(&p);  // p と同じ生存期間をもつ。
  println!("p={},{}", p.x, p.y);
}

• 型の使用時にコンパイラが生存時間を推測する。
  したがって呼び出し時には何も指定する必要がない。

21. 生存期間識別子の省略

struct Foo<'a> {
  pt: &'a Box<Point>,
}
// 簡略版。
fn alloc(p: &Box<Point>) -> Foo {
  return Foo { pt:p };
}

• 生存期間がすべて同じ場合は、引数の識別子は省略できる。 (ただし Foo 構造体の定義では省略不可)

22.複数の生存期間

// 「与えられた p と同じ期間は生きる Foo」を返す。
// でも q は関係ないので別の生存期間。
fn alloc<'a>(p: &'a Box<Point>, 
             q: &'b Box<Point>) -> Foo<'a> {
  println!("q={},{}", q.x, q.y);
  return Foo { pt:p };
}

23. まとめ

• NULL参照 (RAII, Option型)
• Double free (所有権)
• Dangling pointer (生存期間)

• Rustは、いままでC/C++プログラマが 無意識に使っていた概念を型システムとして 定式化させたといえる。
• すべて静的な検査なので、実行時のオーバーヘッドは C/C++ と同じ。
• 機械的にチェックできるのでミスは減るが、覚えるのは面倒。
• 欠点: 「なんとなくコードを書き始める」のは難しい。事前計画が必要。

24. 余談: 並列化への応用

• Java/Erlangと違って、Rustはネイティブのthreadを使っている。
• スレッドに関する問題にも所有権を使って対応している:
  • channel … メッセージ送受信に使う。 一旦メッセージを送ったら、そのデータの所有権は移動する。
  • ARC … 借り物を共有するときに使われる 排他制御 + 参照カウンタつきスマートポインタ。
  • RC … 所有権を移動するときに使われる 参照カウンタつきスマートポインタ。

25. 余談: ほかのCライブラリとの共存

• 既存の Cライブラリと ABI が同じであり、相互にリンク可能。
• 逃げ道: unsafe { ... } で囲んだ部分は、所有権・生存期間の規則を無視できる。