Linux Programming

Rust の基礎知識

●演算子の多重定義

• Rust の場合、多くの演算子はメソッド呼び出しの糖衣構文になっている
• トレイトを使って演算子を「多重定義 (オーバーロード)」することができる
• 多重定義できる演算子用のトレイトは Module std::ops に定義されている
• Add (+), Mul (*), Sub (-), Div (/) などなど

リスト : トレイト Add の定義

pub trait Add<RHS = Self> {
    type Output;
    fn add(self, rhs: RHS) -> Self::Output;
}

• a + b は a.add(b) というメソッド呼び出しになる
• RHS は右辺式 b のデータ型を表す型パラメータ
• 省略した場合はデフォルト値 Self (左辺式 a のデータ型) になる

リスト : 演算子の多重定義

use std::ops::Add;

#[derive(Debug, Copy, Clone)]
struct Point {
    x: f64, y: f64
}

#[derive(Debug, Copy, Clone)]
struct Point3d {
    x: f64, y: f64, z: f64
}

impl Point {
    fn new(x0: f64, y0: f64) -> Point {
        Point { x: x0, y: y0 }
    }
}

impl Point3d {
    fn new(x0: f64, y0: f64, z0: f64) -> Point3d {
        Point3d { x: x0, y: y0, z: z0 }
    }
}

// 左辺と右辺でデータ型が同じ場合
impl Add for Point {
    type Output = Point;
    fn add(self, other: Point) -> Point {
        Point {
             x: self.x + other.x,
             y: self.y + other.y
        }
    }
}

impl Add for Point3d {
    type Output = Point3d;
    fn add(self, other: Point3d) -> Point3d {
        Point3d {
             x: self.x + other.x,
             y: self.y + other.y,
             z: self.z + other.z
        }
    }
}

// 右辺と左辺でデータ型が違う場合
impl Add<Point3d> for Point {
    type Output = Point3d;
    fn add(self, other: Point3d) -> Point3d {
        Point3d {
            x: self.x + other.x,
            y: self.y + other.y,
            z: other.z
        }
    }
}

impl Add<Point> for Point3d {
    type Output = Point3d;
    fn add(self, other: Point) -> Point3d {
        Point3d {
            x: self.x + other.x,
            y: self.y + other.y,
            z: self.z
        }
    }
}

fn main() {
    let p1 = Point::new(1.0, 1.0);
    let p2 = Point::new(2.0, 2.0);
    let p3 = Point3d::new(10.0, 10.0, 10.0);
    let p4 = Point3d::new(20.0, 20.0, 20.0);
    println!("{:?}", p1 + p2);
    println!("{:?}", p3 + p4);
    println!("{:?}", p1 + p3);
    println!("{:?}", p4 + p2);
}

Point { x: 3, y: 3 }
Point3d { x: 30, y: 30, z: 30 }
Point3d { x: 11, y: 11, z: 10 }
Point3d { x: 22, y: 22, z: 20 }

●サイズ不定型

• Sized はコンパイル時にサイズを決定できるデータ型を表すトレイト
• サイズを決定できないデータ型を「サイズ不定型」とか「動的サイズ型」という
• たとえば、配列を表すデータ型 [T] だけでは、その大きさを決定できない
• サイズ不定型はポインタ (参照) を使ってアクセスする
• let や関数の引数にサイズ不定型を指定することはできない
• [T] はだめだが &[T] ならば OK
• 構造体の最後のフィールドに限りサイズ不定型を指定できる
• ジェネリクスの型パラメータには暗黙のうちに Sized が付加される
• この制約を外すには ?Sized を指定する

リスト : サイズ不定型の簡単な使用例

struct Foo<T: ?Sized> {
    buff: T      // 大きさが異なる配列でも格納できる
}

fn main() {
    let a = [1,2,3];
    let b = [1,2,3,4,5,6];
    let c = Foo { buff: a };
    let d = Foo { buff: b };
    let e = Foo { buff: [1,2,3,4,5,6,7,8,9]};
    println!("{:?}", c.buff);
    println!("{:?}", d.buff);
    println!("{:?}", e.buff);
}

[1, 2, 3]
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

●Deref

• Deref は参照外し (デリファレンス) の演算子 * を多重定義するためのトレイト

リスト : トレイト Deref の定義

pub trait Deref {
    type Target: ?Sized;
    fn deref(&self) -> &Self::Target;
}

リスト : トレイト Deref の簡単な使用例

use std::ops::Deref;

struct Foo<T: ?Sized> {
    buff: T
}

impl<T> Deref for Foo<T> {
    type Target = T;
    fn deref(&self) -> &T {
        &self.buff
    }
}

struct Bar {
    num: i32
}

impl Deref for Bar {
    type Target = i32;
    fn deref(&self) -> &i32 {
        &self.num
    }
}

fn main() {
    let a = Foo { buff: [1,2,3] };
    let b = Foo { buff: [4,5,6,7,8,9] };
    let c = Bar { num: 123 };
    let d = Bar { num: 456 };
    println!("{:?}", *a);
    println!("{:?}", *b);
    println!("{:?}", *c);
    println!("{:?}", *d);
}

[1, 2, 3]
[4, 5, 6, 7, 8, 9]
123
456

• 変数 a, b, c, d に格納されているデータは参照 (リファレンス) ではない
• しかしながら、Foo と Bar には Deref が実装されいるので、演算子 * を使ってフィールドにアクセスできる
• Deref は immutable なので、*c = 999; のような代入はできない
• 値を書き換えたい場合はトレイト DerefMut を使う

リスト : トレイト DerefMut

pub trait DerefMut: Deref {
    fn deref_mut(&mut self) -> &mut Self::Target;
}

リスト : DerefMut の簡単な使用例

use std::ops::{Deref, DerefMut};

struct Bar {
    num: i32
}

impl Deref for Bar {
    type Target = i32;
    fn deref(&self) -> &i32 {
        &self.num
    }
}

impl DerefMut for Bar {
    fn deref_mut(&mut self) -> &mut i32 {
        &mut self.num
    } 
}

fn main() {
    let mut c = Bar { num: 123 };
    let d = Bar { num: 456 };
    println!("{:?}", *c);
    println!("{:?}", *d);
    *c = 789;
    println!("{:?}", *c);
}

123
456
789

●型強制

• Rust の型強制は他の言語でいう「暗黙のキャスト」のこと
• たとえば、&mut T は暗黙のうちに &T に変換される
• Deref は型強制にも使用することができる (deref の型強制)
• データ型 T が Deref<Target=U> を実装しているとき、&T は &U に型強制される
• 関連型を含むトレイトのデータ型は トレイト名<関連型=データ型> で表すことができる

リスト : deref の型強制

use std::ops::{Deref, DerefMut};

struct Bar {
    num: i32
}

impl Deref for Bar {
    type Target = i32;
    fn deref(&self) -> &i32 {
        &self.num
    }
}

impl DerefMut for Bar {
    fn deref_mut(&mut self) -> &mut i32 {
        &mut self.num
    } 
}

fn bar(x: &i32) {
    println!("{}", x);
}

fn main() {
    let mut c = Bar { num: 123 };
    let d = Bar { num: 456 };
    println!("{:?}", *c);
    println!("{:?}", *d);
    *c = 789;
    println!("{:?}", *c);
    bar(&c);
    bar(&d);
    let e = Box::new(1000);
    bar(&e);
    let f = Box::new(Bar { num: 2000 });
    bar(&f);
}

123
456
789
789
456
1000
2000

• Bar は Deref<Target=i32> を実装しているので、&Bar は &i32 に型強制される
• 関数 bar() の引数の型は &i32 なので、&c や &d を渡してもコンパイルできる
• Box<T> は Deref<Target=T> を実装している
• 変数 e の型は Box<i32> なので、関数 bar() に &e を渡すことができる
• 型強制は該当する型が見つかるまで行われる
• たとえば、bar() に &f を渡す場合、&Box -> &Bar -> &i32 のように二段階の型強制が行われる
• deref の型強制はメソッド呼び出しでも行われる

リスト : メソッド呼び出しの型強制

use std::ops::Deref;

struct Foo {
    num: i32
}

impl Foo {
    fn foo(&self) {
        println!("{}", self.num)
    }
}

struct Bar {
    content: Foo
}

impl Deref for Bar {
    type Target = Foo;
    fn deref(&self) -> &Foo {
        &self.content
    }
}

fn main() {
    let a = Box::new(Foo { num: 123 });
    let b = Bar { content: Foo { num: 456 } };
    let c = Box::new(Bar { content: Foo { num: 789 } });
    a.foo();
    b.foo();
    c.foo();
}

123
456
789

• a.foo() は &Box -> &Foo の型強制が行われる
• b.foo() は Bar に Deref<Target=Foo> が実装されているので、&Bar -> &Foo の型強制が行われる
• c.foo() は &Box -> &Bar -> &Foo と三段階の型強制が行われる

●Rc<T>

• Rc<T> は Box<T> に「参照カウンタ (Reference Count)」を付けたもの
• 複数の変数から Rc が保持しているヒープ上のデータを共有することができる
• Rc を clone() すると、Rc が保持しているデータはコピーされずに、参照カウンタが +1 される
• Rc を保持している変数がスコープから外れると、参照カウンタが -1 される
• 参照カウンタが 0 になったとき、Rc が保持しているヒープ上のデータが解放される
• Rc<T> の動作は C++ の shared_ptr<T> に近い
• Rc<T> にも Deref<Target=T> が実装されている

リスト : Rc<T> の簡単な使用例 (1)

use std::rc::Rc;

#[derive(Clone)]
struct Foo {
    num: i32
}

impl Drop for Foo {
    fn drop(&mut self) {
        println!("Drop foo {}", self.num);
    }
}

fn main() {
    let a = Rc::new(Foo { num: 123 });
    println!("{}", Rc::strong_count(&a));
    let x = Box::new(Foo { num: 456 });
    println!("{}", x.num);
    {
        let b = a.clone();
        println!("{}", Rc::strong_count(&a));
        println!("{}", Rc::strong_count(&b));
        let c = &a;
        println!("{}", Rc::strong_count(&a));
        println!("{}", Rc::strong_count(c));
        let y = x.clone();
        println!("{}", y.num);
    }
    println!("{}", Rc::strong_count(&a));
}

1
456
2
2
2
2
456
Drop foo 456
1
Drop foo 456
Drop foo 123

• 構造体 Foo はトレイト Clone を実装しているので、clone() で複製を作ることができる
• Rc<Foo> を clone() しても Foo は複製されない
• Rc の参照カウンタは関数 Rc::strong_count() で求めることができる
• let b = a.clone() のあと、参照カウンタは 2 になる
• let c = &a; のように、Rc を借用しただけでは参照カウンタは増加しない
• 変数 b がスコープから外れると、参照カウンタは 1 に戻る
• Box<Foo> を clone() すると、Foo は複製される
• Box<T> の T が Clone を実装していない場合、Box<T> に clone() は適用できない (コンパイルエラー)
• let y = x.clone(); は x が保持しているデータも複製する
• 変数 y がスコープから外れると、保持しているデータが解放される
• 最後に、変数 a と x がスコープから外れ、保持しているデータが解放される

リスト : Rc<T> の簡単な使用例 (2)

use std::rc::Rc;

#[derive(Debug)]
struct Foo {
    num: i32
}

fn main() {
    let a = Box::new(Foo { num: 123 });
    let b = *a;   // move
    // println!("{}", a.num); コンパイルエラー
    println!("{}", b.num);

    let c = Rc::new(Foo { num: 456 });
    // let x = *c;    Rc の場合は単純に move することはできない
    {
        let d = c.clone();
        // 参照カウンタが 1 よりも多いと Err
        match Rc::try_unwrap(d) {
            Ok(x) => println!("{}", x.num),
            Err(x) => println!("error {:?}", x)
        }
    }
    // 参照カウンタが 1 ならば Ok
    match Rc::try_unwrap(c) {
        Ok(x) => println!("{}", x.num),
        Err(x) => println!("error {:?}", x)
    }
}

123
error Foo { num: 456 }
456

• Box はデリファレンス (*) でデータを簡単に move できるが、Rc はできない
• Rc が保持しているデータを move する場合はメソッド Rc::try_unwrap() を使う

fn try_unwrap(this: Rc<T>) -> Result<T, Rc<T>>

• 引数 this の参照カウンタが 1 の場合、データを取り出して Ok() に包んで返す
• 参照カウンタが 1 よりも多い場合、this 自身を Err() に包んで返す

リスト : 簡単な連結リスト (Rc 版)

use std::rc::Rc;

#[derive(Debug)]
enum List {
    Nil,
    Cons(i32, Rc<List>)
}

use List::*;

impl List {
    fn new() -> Rc<List> {
        Rc::new(Nil)
    }
    fn cons(x: i32, xs: &Rc<List>) -> Rc<List> {
        Rc::new(Cons(x, xs.clone()))
    }
}

impl Drop for List {
    fn drop(&mut self) {
        match *self {
            Nil => println!("drop Nil"),
            Cons(x, _) => println!("drop {}", x)
        }
    }
}

fn main() {
    let a = List::new();
    println!("{:?}", a);
    {
        let b = List::cons(1, &a);
        println!("{:?}", a);
        println!("{:?}", b);
        println!("{}", Rc::strong_count(&a));
        println!("{}", Rc::strong_count(&b));
        {
            let c = List::cons(2, &b);
            println!("{:?}", a);
            println!("{:?}", b);
            println!("{:?}", c);
            println!("{}", Rc::strong_count(&a));
            println!("{}", Rc::strong_count(&b));
            println!("{}", Rc::strong_count(&c));
        }
        println!("{}", Rc::strong_count(&a));
        println!("{}", Rc::strong_count(&b));
    }
    println!("{}", Rc::strong_count(&a));
}

• コンパイルすると warning が表示される
• これも「だめな実装」なのかもしれない

Nil
Nil
Cons(1, Nil)
2
1
Nil
Cons(1, Nil)
Cons(2, Cons(1, Nil))
2
2
1
drop 2
2
1
drop 1
1
drop Nil

●Cell<T> と RefCell<T>

• Cell<T> は immutable なデータの中で mutable な操作をするときに使用する
• T には Copy 型の制約がある
• Cell はメソッド Cell::new(値) で生成する
• メソッド get() でデータを読み取り、メソッド set() でデータを書き換える

リスト : Cell の簡単な使用例

use std::cell::Cell;

struct Foo {
    x: i32,
    y: Cell<i32>
}

fn main() {
    let a = Cell::new(123);
    println!("{:?}", a);
    println!("{}", a.get());
    a.set(456);
    println!("{:?}", a);
    println!("{}", a.get());

    let b = Foo { x: 789, y: Cell::new(999) };
    println!("{}. {:?}", b.x, b.y);
    b.y.set(1000);
    println!("{}, {:?}", b.x, b.y);

    let c = Box::new(Cell::new(1.234));
    println!("{}", c.get());
    c.set(5.678);
    println!("{}", c.get());
}

Cell { value: 123 }
123
Cell { value: 456 }
456
789, Cell { value: 999 }
789, Cell { value: 1000 }
1.234
5.678

• RefCell<T> の場合、T に Copy 型の制約はない
• RefCell はメソッド RefCell::new() で生成する
• メソッド borrow() は immutable な参照を返す (正確には Ref<T> 型を返す)
• メソッド borrow_mut() は mutable な参照を返す (正確には RefMut<T> 型を返す)
• RefCell 型の場合、借用のチェックはプログラムの実行時に行われる
• 違反するとパニック
• RefCell 内のデータを取り出す場合はメソッド into_inner() を使う
• 所有権が移動するので、再度 RefCell にアクセスすることはできない (コンパイルエラー)

リスト : RefCell の簡単な使用例

use std::cell::RefCell;

#[derive(Debug)]
struct Foo {
    x: i32,
}

impl Drop for Foo {
    fn drop(&mut self) {
        println!("drop foo {}", self.x);
    }
}

#[derive(Debug)]
struct Bar {
    foo: RefCell<Foo>
}

fn main() {
    let a = RefCell::new(123);
    println!("{:?}", a);
    {
        println!("{}", *a.borrow());  // immutable な参照
    }
    {
        let mut ref_a = a.borrow_mut();   // mutable な参照
        *ref_a = 456;
        // println!("{}", *a.borrow());  immutable な参照を借りるとパニック
    }
    println!("{}", *a.borrow());  //immutable な参照
    
    let b = Bar { foo: RefCell::new(Foo { x: 123 })};
    println!("{:?}", b);
    {
        println!("{:?}", *b.foo.borrow());  // immutable な参照
    }
    {
        let mut ref_b = b.foo.borrow_mut();   // mutable な参照
        *ref_b = Foo { x: 456 };              // Foo { x: 123 } は廃棄される
    }
    println!("{:?}", b);

    let c = Box::new(RefCell::new(Foo { x: 789 }));
    println!("{:?}", c);
    {
        println!("{}", c.borrow().x);     // フィールド x の値を参照する
        c.borrow_mut().x = 999;           // フィールド x の値を書き換える
        println!("{:?}", c);
    }
    {
        let mut ref_c = c.borrow_mut();   // mutable な参照
        *ref_c = Foo { x: 1000 };         // Foo { x: 999 } は廃棄される
    }

    let d = c.into_inner();    // メソッド into_inner() は中身のデータを move する
    // println!("{:?}", c);    コンパイルエラーになる
    println!("{:?}", d);
}

RefCell { value: 123 }
123
456
Bar { foo: RefCell { value: Foo { x: 123 } } }
Foo { x: 123 }
drop foo 123
Bar { foo: RefCell { value: Foo { x: 456 } } }
RefCell { value: Foo { x: 789 } }
789
RefCell { value: Foo { x: 999 } }
drop foo 999
Foo { x: 1000 }
drop foo 1000
drop foo 456

• 構造体のフィールドを書き換えるメソッドを定義する場合、mutable な参照 (&mut self) を受け取れば実装できる
• ただし、Rust には immutable と mutable な参照を同時に使うことはできない、という制約がある
• Cell と RefCell を使うと、この制約を緩和することができる
• Rust の場合、immutable な参照はいくつでも借用することができる
• Cell や RefCell を使うと、どの参照からでも値を書き換えることが可能になる
• 使用には十分な注意が必要

リスト : Cell の簡単な使用例 (その２)

use std::cell::Cell;

struct Foo {
    num: Cell<i32>
}

impl Foo {
    fn new(x: i32) -> Foo {
        Foo { num: Cell::new(x) }
    }
    fn get_num(&self) -> i32 {
        self.num.get()
    }
    fn set_num(&self, x: i32) {   // immutable な参照でも更新できる
        self.num.set(x)
    }
}

fn main() {
    let a = Foo::new(100);
    let b = &a;
    let c = &a;
    println!("{}", a.get_num());
    println!("{}", b.get_num());
    println!("{}", c.get_num());
    c.set_num(200);
    println!("{}", a.get_num());
    println!("{}", b.get_num());
    println!("{}", c.get_num());
}

100
100
100
200
200
200

●format! と Display

• format! マクロはＣ言語の関数 sprintf() と同じような動作をする
• format! は書式文字列に従ってデータを整形し、その結果を文字列にして返す
• print!, println! マクロは書式文字列に従ってデータを整形して標準出力に書き込む
• write!, writeln! マクロは第 1 引数に整形した結果を書き込む
• 第 1 引数はトレイト std::io::Write を実装しているデータ型であること
• write!, writeln! は Result 型を返す
• 書式文字列の {} は引数を文字列に変換する
• {n} とすると n 番目の引数を変換する
• {:変換指示子}
• {:b}, 2 進数表示
• {:o}, 8 進数表示
• {:x}, {:X}, 16 進数表示 (英小文字, 英大文字)
• {:e}, {:E}, 指数表示 (英小文字, 英大文字)
• {:?}, Debug 表示
• : と変換指示子の間に桁数などを指定することができる
• {:n}, n 桁表示
• {:<n}, 左詰め
• {:>n}, 右詰め
• {:^n}, 中央
• {:0n}, n 桁表示で空きを 0 で埋める
• {:.n}, 小数点以下の桁数を指定する
• この他にもいろいろな機能がある

リスト : write! の簡単な使用例

use std::io::{self, Write};

fn main () {
    let mut buff = Vec::new();
    write!(&mut buff, "hello, world").unwrap();
    write!(&mut buff, "{}, {}, {}", 1, 1.2345, "foo bar baz").unwrap();
    io::stdout().write(&buff).unwrap();
}

hello, world1, 1.2345, foo bar baz

• Vec<u8> にはトレイト Write が実装されている

• std::fmt::Display トレイトを実装すると、書式文字列の {} でデータを変換できる

リスト : Display トレイトの定義

pub trait Display {
    fn fmt(&self, f: &mut Formatter) -> Result<(), Error>;
}

• 実装するメソッドは fmt()
• 第 2 引数の Formatter に write! でデータを書き込めばよい

リスト : Display トレイトの簡単な実装例

use std::fmt;

struct Point {
    x: i32, y: i32
}

impl fmt::Display for Point {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "({}, {})", self.x, self.y)
    }
}

fn main() {
    let a = Point { x: 0, y: 0 };
    let b = Point { x: 10, y: 20 };
    println!("{}, {}", a, b);
}

(0, 0), (10, 20)

●VecDeque<T>

• std::collections::VecDeque は「両端キュー (double ended queue: deque)」のこと
• VecDeque は VecDeque::new() で生成する
• push_back(item) で末尾にデータを追加する
• push_front(item) で先頭にデータを追加する
• pop_back() -> Option<T> で末尾からデータを取り出す
• pop_front() -> Option<T> で先頭からデータを取り出す
• front() -> Option<&T> は先頭要素への参照を返す
• back() -> Option<&T> は末尾要素への参照を返す
• get(n) -> Option<&T> は n 番目の要素への参照を返す
• iter() は先頭からデータを順番に取り出すイテレータを生成する
• len() は VecDeque に格納されているデータ数を返す
• is_empty() は VecDeque が空であれば true を返す
• clear() は VecDeque を空にする

リスト : VecDeque の簡単な使用例

use std::collections::VecDeque;

fn main() {
    // スタック (Stack) の動作
    let mut s = VecDeque::new();
    for x in 0 .. 10 {
        s.push_back(x);
    }
    println!("{:?}", s);
    while !s.is_empty() {
        println!("{}", s.pop_back().unwrap());
    }
    // キュー (Queue) の動作
    let mut q = VecDeque::new();
    for x in 10 .. 20 {
        q.push_back(x);
    }
    println!("{:?}", q);
    while !q.is_empty() {
        println!("{}", q.pop_front().unwrap());
    }
}

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
9
8
7
6
5
4
3
2
1
0
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
10
11
12
13
14
15
16
17
18
19

●LinkedList<T>

• std::collections::LinkedList<T> は「双方向連結リスト (doubly linked list)」のこと
• LinkedList は LinkedList::new() で生成する
• VecDeque のように「両端キュー」として使用できる
• 両端キューとして使用する場合、メソッドは VecDeque と同じ
• LinkedList にメソッド get(n) は用意されていない

リスト : LinkedList の簡単な使用例

use std::collections::LinkedList;

fn main() {
    // スタック (Stack) の動作
    let mut s = LinkedList::new();
    for x in 0 .. 10 {
        s.push_back(x);
    }
    println!("{:?}", s);
    while !s.is_empty() {
        println!("{}", s.pop_back().unwrap());
    }
    // キュー (Queue) の動作
    let mut q = LinkedList::new();
    for x in 10 .. 20 {
        q.push_back(x);
    }
    println!("{:?}", q);
    while !q.is_empty() {
        println!("{}", q.pop_front().unwrap());
    }
}

結果は VecDeque の簡単な使用例と同じ。

●HashMap<K, V> と HashSet<T>

• std::collections::HashMap<K, V> は「連想配列」のことで、他の言語では「ハッシュ」とか「辞書」と呼ばれる
• K がキーのデータ型、V がキーに対応する値のデータ型を表す
• キーはブーリアン、整数、文字列など、Eq と Hash トレイトを保持する型なら何でもよい
• HashMap は HashMap::new() で生成する
• キーと値はメソッド insert(key, value) で挿入する
• 返り値は Option<V>
• キーが存在している場合、新しい値に更新して、古い値を Some に包んで返す
• キーが存在しいない場合、キーと値を追加して None を返す
• キーの有無は contains_key(&key) -> bool で判定する
• 値は get(&key) -> Option<&V> で取得する
• キーと値は remove(&key) -> Option<V> で削除できる
• keys() はキーを取り出すイテレータを生成する
• values() は値をを取り出すイテレータを生成する
• iter() はキーと値を取り出すイテレータを生成する
• len() は HashMap に格納されているデータ数を返す
• is_empty() は HashMap が空であれば true を返す
• clear() は HashMap を空にする
• ハッシュのかわりに多分木 (B-tree) を用いた BTreeMap もある
• BTreeMap のキーにはトレイト Ord が必要

リスト : HashMap の簡単な使用例

use std::collections::HashMap;

fn main() {
    let mut ht = HashMap::new();
    ht.insert("foo", 1);
    ht.insert("bar", 2);
    ht.insert("baz", 3);
    ht.insert("oops", 4);
    println!("{:?}", ht);
    println!("{}", ht.contains_key("baz"));
    println!("{}", ht.contains_key("Baz"));
    println!("{:?}", ht.get("foo"));
    println!("{:?}", ht.get("Foo"));
    println!("{:?}", ht.remove("Oops"));
    println!("{:?}", ht.remove("oops"));
    println!("{:?}", ht.insert("foo", 100));
    println!("{:?}", ht.insert("oops", 200));
    for (k, v) in ht.iter() {
        println!("{}, {}", k, v);
    }
}

{"oops": 4, "bar": 2, "foo": 1, "baz": 3}
true
false
Some(1)
None
None
Some(4)
Some(1)
None
oops, 200
bar, 2
foo, 100
baz, 3

• std::collections::HashSet<T> は集合を表すコレクション
• データ型 T は HashMap のキーと同じ
• HashSet は HashSet::new() で生成する
• データは insert(item) -> bool で挿入する
• データの有無は contains(item) -> bool で判定する
• データの削除は remove(item) -> bool で行う
• iter() はデータを取り出すイテレータを生成する
• len() は HashSet に格納されているデータ数を返す
• is_empty() は HashSet が空であれば true を返す
• clear() は HashSet を空にする
• 部分集合は is_subset(&other_hashset) -> bool で判定する
• union(), difference(), intersection() などの集合演算も用意されている
• これらの集合演算はイテレータを返す
• ハッシュのかわりに多分木 (B-tree) を用いた BTreeSet もある
• BTreeSet のキーにはトレイト Ord が必要

リスト : HashSet の簡単な使用例

use std::collections::HashSet;

fn main() {
    let a: HashSet<_> = [1,2,3,4].iter().cloned().collect();
    let b: HashSet<_> = [3,4,5,6].iter().cloned().collect();
    println!("{:?}", a);
    println!("{:?}", b);
    println!("{}", a.contains(&1));
    println!("{}", b.contains(&1));
    let c: HashSet<_> = a.union(&b).cloned().collect();
    println!("{:?}", c);
    let d: HashSet<_> = a.intersection(&b).collect();
    println!("{:?}", d);
    let e: HashSet<_> = a.difference(&b).collect();
    println!("{:?}", e);
    println!("{}", a.is_subset(&c));
    println!("{}", b.is_subset(&c));
    println!("{}", a.is_subset(&b));
}

• イテレータのメソッド cloned() は map(|&x| x) と同じ

{1, 2, 3, 4}
{4, 6, 3, 5}
true
false
{4, 5, 3, 6, 2, 1}
{3, 4}
{1, 2}
true
true
false

●Option<T>

• Option<T> はエラー処理だけではなく、データ構造の構築にも使用される
• LinkedList<T> は Option<T> を使って構成されている
• ここでは、まだ説明していない Option の便利なメソッドを簡単に紹介する

• fn is_some(&self) -> bool, Some ならば真を返す
• fn is_none(&self) -> bool, None ならば真を返す
• fn as_ref(&self) -> Option<&T>, Option<T> を Option<&T> に変換する
• fn as_mut(&self) -> Option<&T>, Option<T> を Option<&mut T> に変換する
• fn map<U, F>(self, f: F) -> Option<U>, マッピングはとても重要
• fn iter(&self) -> Iter<T>, immutable なイテレータを返す
• fn iter_mut(&mut self) -> IterMut<T>, mutable なイテレータを返す
• fn take(&mut self) -> Option<T>, T を新しい Option に包んで返す、元の値は None に書き換えられる

リスト : Option の簡単な使用例

fn main() {
    let mut a: Option<i32> = Some(100);
    let mut b: Option<i32> = None;
    println!("{}", a.is_some());
    println!("{}", b.is_none());
    {
        let c = a.as_mut().unwrap();
        *c = 200;
    }
    {
        let d = a.as_ref().unwrap();
        println!("{}", d);
    }
    let e = a.take();
    println!("{:?}", a);
    println!("{:?}", e);
    let f = b.take();
    println!("{:?}", b);
    println!("{:?}", f);
    let g = e.map(|v| v * v);
    println!("{:?}", e);
    println!("{:?}", g);
}

true
true
200
None
Some(200)
None
None
Some(200)
Some(40000)

●AsRef と AsMut

• AsRef はジェネリックなコードにおいて値を immutable な参照に変換するトレイト

リスト : AsRef トレイト

pub trait AsRef<T> where T: ?Sized
{
    fn as_ref(&self) -> &T;
}

• たとえば、Foo<T> から &T を取得するために使用する
• AsMut はジェネリックなコードにおいて値を mutable な参照に変換するトレイト

リスト : AsMut トレイト

pub trait AsMut<T> where T: ?Sized
{
    fn as_mut(&mut self) -> &mut T;
}

• たとえば、Foo<T> から &mut T を取得するために使用する
• Option や Result のメソッド as_ref(), as_mut() とは違うことに注意

リスト : 簡単な使用例

struct Foo<T> {
    item: T
}

impl<T> AsRef<T> for Foo<T> {
    fn as_ref(&self) -> &T {
        &self.item
    }
}

impl<T> AsMut<T> for Foo<T> {
    fn as_mut(&mut self) -> &mut T {
        &mut self.item
    }
}

fn get<T: AsRef<i32>>(n: &T) -> &i32 {
    n.as_ref()
}

fn inc<T: AsMut<i32>>(n: &mut T, m: i32) {
    *n.as_mut() += m;
}

fn main() {
    let mut a = Foo { item: 100 };
    println!("{}", get(&a));
    inc(&mut a, 100);
    println!("{}", get(&a));
}

100
200

●Borrow

• トレイト Borrow<T> はある値を &T に変換するために使用する

リスト : Borrow トレイト

pub trait Borrow<Borrowed: ?Sized> {
    fn borrow(&self) -> &Borrowed;
}

• たとえば、標準ライブラリでは impl Borrow<str> for String が実装されている
• この場合、メソッド borrow() により String が &str に変換される
• Borrow はマップやセットなどのデータを探索するメソッドで使用されている

リスト : HashMap のメソッド contains_key() の仕様

fn contains_key<Q: ?Sized>(&self, k: &Q) -> bool
        where K: Borrow<Q>,
              Q: Hash + Eq

• 探索するキー k の型は Q で、HashMap のキーの型 K と同じではない
• K が Borrow<Q> を実装していれば、K を &Q に変換して引数 k と比較することができる
• たとえば、String がキーの HashMap でも、Borrow により &str で探索することができる
• ちなみに、標準ライブラリには impl<T> Borrow<T> for T が定義されている
• K と Q が同じデータ型であればメソッドの仕様を満たすことになる

リスト : Borrow の簡単な使用例

use std::borrow::Borrow;
use std::collections::HashMap;

#[derive(Hash, Eq, PartialEq)]
struct Foo {
    num: i32
}

impl Borrow<i32> for Foo {
    fn borrow(&self) -> &i32 {
        &self.num
    }
}

fn main() {
    let mut ht: HashMap<Foo, i32> = HashMap::new();
    ht.insert(Foo { num: 1 }, 100);
    ht.insert(Foo { num: 2 }, 200);
    ht.insert(Foo { num: 3 }, 300);
    println!("{:?}", ht.get(&1));
    println!("{:?}", ht.get(&4));
    println!("{:?}", ht.get(&Foo { num: 2 }));
    println!("{:?}", ht.get(&Foo { num: 5 }));
}

Some(100)
None
Some(200)
None

●スレッド

• Rust は std::thread::spawn() で OS のネイティブスレッドを起動する

pub fn spawn<F, T>(f: F) -> JoinHandle<T> 
where
    F: FnOnce() -> T,
    F: Send + 'static,
    T: Send + 'static, 

• spawn() にはクロージャを渡す
• 局所変数をキャプチャする場合は move クロージャを使う
• 新しいスレッドでクロージャが実行される
• トレイト Send はスレッド間でデータの受け渡し (所有権の移動) が可能であることを表す
• spawn() の返り値はスレッドを表す JoinHandle 型
• メソッド join() でスレッドが終了するまで待機する
• join() の返り値は std::thread::Result<T>
• スレッドがパニックした場合は Err が返される
• スレッドのスケジューリングは OS 側で行われる

リスト : スレッドの簡単な使用例 (1)

use std::{thread, time};

fn foo(msg: &str, n: u64) {
    let m = time::Duration::from_millis(n);
    for _ in 1 .. 10 {
        println!("{}", msg);
        thread::sleep(m);
    }
}

fn main() {
    let t1 = thread::spawn(|| {
        foo("oops", 500);
    });
    let t2 = thread::spawn(|| {
        foo("piyopiyo", 400);
    });
    println!("{:?}", t1.join().unwrap());
    println!("{:?}", t2.join().unwrap());
}

oops
piyopiyo
piyopiyo
oops
piyopiyo
oops
piyopiyo
oops
piyopiyo
piyopiyo
oops
piyopiyo
oops
piyopiyo
oops
piyopiyo
oops
oops
()
()

リスト : スレッドの簡単な使用例 (2)

use std::thread;
use std::time::Instant;

// フィボナッチ数列
fn fibo(n: i64) -> i64 {
    if n < 2 {
        n
    } else {
        fibo(n - 1) + fibo(n - 2)
    }
}

fn main() {
    let s1 = Instant::now();
    println!("{}", fibo(40));
    let e1 = s1.elapsed();
    println!("{}.{:03}秒経過しました。", e1.as_secs(), e1.subsec_nanos() / 1_000_000);

    let s2 = Instant::now();
    let mut buff: Vec<_> = vec![];
    buff.push(thread::spawn(|| fibo(40)));
    buff.push(thread::spawn(|| fibo(40)));
    for x in buff {
        println!("{}", x.join().unwrap());
    }
    let e2 = s2.elapsed();
    println!("{}.{:03}秒経過しました。", e2.as_secs(), e2.subsec_nanos() / 1_000_000);
}

$ rustc -O sample61.rs
$ ./sample61
102334155
0.372秒経過しました。
102334155
102334155
0.407秒経過しました。

• M.Hiroi のパソコンは CORE i5 (物理コア数 2、ハイパースレッディングで 2 * 2 = 4)
• 2 つの fibo() が並列に実行されていることがわかる

●チャネル

• Rust は「チャネル (channels)」を経由してスレッド間でデータを受け渡しすることができる
• チャネルは std::sync::mpsc::channel() で生成する

pub fn channel<T>() -> (Sender<T>, Receiver<T>)

• Sender が送信チャンネル、Receiver が受信チャンネルを表す
• データは Sender から Receiver に送られる
• Sender は clone() でコピーすることで、複数生成することができる
• データの送信は　Sender のメソッド send() で、受信は Receiver のメソッド recv() で行う

fn send(&self, t: T) -> Result<(), SendError<T>>
fn recv(&self) -> Result<T, RecvError>

• recv() はデータを受信するまで、スレッドの実行をブロックする

リスト : チャネルの簡単な使用例

use std::thread;
use std::sync::mpsc;

fn fibo(n: i64) -> i64 {
    if n < 2 {
        n
    } else {
        fibo(n - 1) + fibo(n - 2)
    }
}

fn main() {
    let (tx, rx) = mpsc::channel();
    for x in vec![40, 39, 38, 37] {
        let tx = tx.clone();
        thread::spawn(move || tx.send(fibo(x)).unwrap());
    }
    for _ in 0 .. 4 {
        println!("{}", rx.recv().unwrap());
    }
}

24157817
39088169
63245986
102334155

• データを送信した順番 (スレッドが終了した順番) でデータが受信される

●Arc と Mutex / RwLock

• スレッド間で immutable なデータを共有したい場合は Arc<T> を使う
• Rc をスレッドでも使用できるようにしたものが Arc
• 共有するデータにはトレイト Send と Sync が実装されていること
• mutable なデータを共有したい場合は Arc<Mutex<T>> を使う
• Mutex はデータを保護するために使用する
• データにアクセスするときはメソッド lock() でロックを取得する必要がある

fn lock(&self) -> LockResult<MutexGuard<T>>

• lock() はロックを取得するまでスレッドの実行をブロックする
• ロックを取得できないとき、Err を返してほしい場合はメソッド try_lock() を使う
• データのアクセスは MutexGuard 型を介して行う
• 具体的には演算子 * でデリファレンスする
• MutexGuard がスコープから外れたときにロックが解除される

リスト : Arc と Mutex の簡単な使用例

use std::thread;
use std::sync::{Arc, Mutex};

fn main() {
    let data = Arc::new(vec![10, 20, 30, 40]);
    for i in 0 .. 4 {
        let data = data.clone();
        thread::spawn(move || {
            println!("{}", data[i]);
        }).join().unwrap();
    }
    let data1 = Arc::new(Mutex::new(vec![1, 2, 3, 4]));
    for i in 0 .. 4 {
        let data1 = data1.clone();
        thread::spawn(move || {
            let mut buff = data1.lock().unwrap();
            buff[i] += 10;
            println!("{}", buff[i]);
        }).join().unwrap();
    }
    println!("{:?}", data1);
}

10
20
30
40
11
12
13
14
Mutex { data: [11, 12, 13, 14], poisoned: false, .. }

• RwLock はデータにアクセス (read/write) するときにロックをかける
• 基本的な考え方は借用チェッカーに似ている

fn read(&self) -> LockResult<RwLockReadGuard<T>>
fn write(&self) -> LockResult<RwLockWriteGuard<T>>

• メソッド read() は immutable な借用 (実際は RwLockReadGuard<T>) を生成する
• read() で immutable な参照はいくつでも作ることができる
• メソッド write() は mutable な借用 (実際は RwLockWriteGuard<T>) を生成する
• mutable な参照はひとつしか生成できないし、immutable な参照と共存することもできない
• read() と write() はロックを取得できるまでスレッドの実行をブロックする
• Err を返してほしい場合は try_read() と try_write() を使う
• データにアクセスするときは演算子 * でデリファレンスする
• 借用がスコープの範囲外になったとき、ロックが解除される

リスト : RwLock の簡単な使用例 (1)

use std::sync::RwLock;

fn main() {
    let lock = RwLock::new(123);
    {
        let r1 = lock.read().unwrap();
        let r2 = lock.read().unwrap();
        println!("{}, {}", *r1, *r2);
        //let mut w1 = lock.write().unwrap();   ブロックされる
        //*w1 = 456;
        //println!("{}", *w1);
    }
    {
        let mut w1 = lock.write().unwrap();
        *w1 = 456;
        println!("{}", *w1);
        //let mut w2 = lock.write().unwrap();   ブロックされる
        //*w2 = 789;
        //println!("{}", *w2);
        //let r3 = lock.read().unwrap();   　   ブロックされる
        //println!("{}", *r3);
    }
}

123, 123
456

リスト : RwLock の簡単な使用例 (2)

use std::{thread, time};
use std::sync::{Arc, RwLock};

fn main() {
    let lock = Arc::new(RwLock::new(1));
    let t1;
    let t2;
    {
        let lock = lock.clone();
        t1 = thread::spawn(move || {
            for _ in 0 .. 10 {
                match lock.try_read() {
                    Ok(r) => println!("read data {}", *r),
                    _ => println!("Can't read data")
                }
                thread::sleep(time::Duration::from_millis(500));
            }
        });
    }
    {
        let lock = lock.clone();
        t2 = thread::spawn(move || {
            for _ in 0 .. 10 {
                match lock.try_write() {
                    Ok(mut w) => {
                        *w+= 1;
                        println!("write data {}", *w);
                    }
                    _ => println!("Can't write data")
                }
                thread::sleep(time::Duration::from_millis(500));
            }
        });
    }
    t1.join().unwrap();
    t2.join().unwrap();
}

read data 1
write data 2
read data 2
Can't write data
read data 2
Can't write data
read data 2
Can't write data
read data 2
Can't write data
write data 3
Can't read data
read data 3
Can't write data
read data 3
Can't write data
read data 3
Can't write data
read data 3
Can't write data

• 書き込み側の休止間隔を 499 msec に変更した実行例

read data 1
Can't write data
write data 2
read data 2
write data 3
read data 3
write data 4
read data 4
write data 5
read data 5
write data 6
read data 6
write data 7
read data 7
write data 8
read data 8
write data 9
read data 9
write data 10
read data 10