Rust のキホン [text.Baldanders.info]

Rust の型に関する覚え書き

2020-04-08T16:33:06+09:00

この記事では Rust の型（type）に関することを思いつくまま脈絡なく書き記しておく。随時更新予定。

組み込みデータ型

組み込みデータ型には大きく分けてスカラ型と複合型がある。

スカラ型

スカラ型はスカラ値を有する型である。型によって値のサイズが決まっていて，受け渡しは copy semantics で行われる。

スカラ型に分類される型は以下の通り。

1. 整数型

サイズ	符号あり	符号なし
8 bits	`i8`	`u8`
16 bits	`i16`	`u16`
32 bits	`i32`	`u32`
64 bits	`i64`	`u64`
—	`isize`	`usize`

isize/usize のサイズはアーキテクチャに依存する¹。また，リテラル表記時等での型推測の既定は i32 型となる²。

let x = 123; //type i32

ただしリテラル表記の後ろに型名を付けることで型を指定することが可能。

let x = 123i64; //type i64

もちろん変数に型注釈を付けて明示することも可能。

let x: u8 = 123; //type u8

2. 浮動小数点数型

サイズ	型名	既定
32 bits (仮数部 23 bits)	`f32`
64 bits (仮数部 52 bits)	`f64`

型の推定・評価は整数型と同じで，リテラル表記時等での型推測の既定は f64 型となる³。

let x = 1.23; //type f64

3. 文字型

文字型 char は Unicode 符号点を示す。リテラル表記はこんな感じ。

let c = '♡';

Rust における文字列と文字の関係については「Rust の文字列操作（1）」を参照のこと。

4. 論理値型

論理値型 bool は true と false の2値のみ取り得る。

複合型

複合型は複数の要素を組み合わせた型で，タプル型と配列型がある。

複合型は定義毎に型と要素数が決まっている。要素の型が全てスカラ型であれば copy semantics で値の受け渡しが可能。

1. タプル型

タプル型は（名前の通り）複数の型を組み合わせた型で，こんな感じに記述できる。

fn main() {
	let tup = (500, 6.4, 1u8);
    println!("tup = {:?}", tup); //Output: tup = (500, 6.4, 1)
}

2. 配列型

配列型は，単一の型で構成される複数要素の型で⁴，こんな感じに記述できる。

fn main() {
	let ary = [1, 2, 3];
	println!("ary = {:?}", ary); //Output: ary = [1, 2, 3]
}

型エイリアス

型の別名定義。名前は変わっても機能は変わらない。総称型と組み合わせると吉？

type Strings = Vec<String>;

fn main() {
    let planets: Strings = vec![
        "Mercury".to_string(),
        "Venus".to_string(),
        "Earth".to_string(),
        "Mars".to_string(),
    ];
    planets.iter().for_each(|p| {
        println!("{}", p);
    });
}

構造体

0個以上のフィールド（型と名前）を含むデータ構造
構造体に紐づく関連関数およびメソッドを実装可能
トレイトからの実現（realization）が可能。構造体間の継承（inheritance）は不可

struct Planet {
	name: String,
    mass: f64,
    distance: f64,
}

構造体のインスタンス化

リテラル表現を使ったインスタンス化。

#[derive(Debug)]
struct Planet {
    name: String,
    mass: f64,
    distance: f64,
}

fn main() {
    let p = Planet {
        name: "Earth".to_string(),
        mass: 1.0,
        distance: 1.0,
    };
    println!("{:?}", p); //Output: Planet { name: "Earth", mass: 1.0, distance: 1.0 }
}

インスタンス化関数を実装してみる。

#[derive(Debug)]
struct Planet {
    name: String,
    mass: f64,
    distance: f64,
}

impl Planet {
    fn new(s: &str, mass: f64, distance: f64) -> Planet {
        Planet {
            name: s.to_string(),
            mass,
            distance,
        }
    }
}

fn main() {
    let p = Planet::new("Earth", 1.0, 1.0);
    println!("{:?}", p); //Output: Planet { name: "Earth", mass: 1.0, distance: 1.0 }
}

構造体のコピー

コピー用のメソッドを書いてみた。

impl Planet {
    fn copy(&self) -> Planet {
        Planet {
            name: self.name.clone(),
            ..*self
        }
    }
}

あるいは derive 構文を使って Clone トレイトから clone() メソッドを自動生成する。

#[derive(Debug, Clone)]
struct Planet {
    name: String,
    mass: f64,
    distance: f64,
}

fn main() {
    let p = Planet::new("Earth", 1.0, 1.0);
    let cpy = p.clone();
    println!("{:?}", p); //Output: Planet { name: "Earth", mass: 1.0, distance: 1.0 }
    println!("{:?}", cpy); //Output: Planet { name: "Earth", mass: 1.0, distance: 1.0 }
}

なお String 等の Copy トレイトを実装できないフィールドを含む構造体は Copy トレイトを実装できないため，代入構文で値のコピーが発生しない。この場合は move semantics により所有権が移動する。

タプル構造体

構造体の特殊なパターンで，名前のないフィールドを定義する。フィールドがタプルで定義される以外は通常の構造体と同じ。関連関数およびメソッドも実装可能。

#[derive(Debug, Copy, Clone)]
struct Point(i64, i64);

impl Point {
    fn new(x: i64, y: i64) -> Point {
        Point(x, y)
    }
}

fn main() {
    let p1 = Point(1, 2);
    let p2 = Point::new(3, 4);
    let p3 = p1; //copy semantics
    println!("{:?}", p1); //Output: PPoint(1, 2)
    println!("{:?}", p2); //Output: PPoint(3, 4)
    println!("{:?}", p3); //Output: PPoint(1, 2)
}

列挙型

Rust の列挙型 enum はどちらかというと関数型プログラミング言語の影響を強く受けているらしい。

enum VariantType {
    Int(i32),
    Float(f64),
    Text(String),
}

列挙型の評価には match 式を用いる。

fn main() {
    let list: Vec<VariantType> = vec![
        VariantType::Int(123),
        VariantType::Float(1.23),
        VariantType::Text("hello".to_string()),
    ];

    list.iter().for_each(|e| {
        match e {
            VariantType::Int(v) => println!("{:#x}", v), //Output: 0x7b
            VariantType::Float(v) => println!("{:e}", v), //Output: 1.23e0
            VariantType::Text(v) => println!("{:?}", v), //Output: "hello"
        };
    });
}

列挙型も構造体と同じく関連関数やメソッドを実装できる。

impl VariantType {
    fn is_integer(&self) -> bool {
        match self {
            VariantType::Int(_) => true,
            _ => false, //others
        }
    }
}

fn main() {
    let list = vec![
        VariantType::Int(123),
        VariantType::Float(1.23),
        VariantType::Text("hello".to_string()),
    ];

    list.iter().for_each(|e| {
        println!("Is {:?} an integer?: {}", e, e.is_integer());
    });
}

総称型

Rust ではオブジェクトの抽象化の手段として総称型をサポートしている。

関数における総称型

以下の max() 関数で使われる型 T が総称型と呼ばれているもの。

fn max<T: std::cmp::PartialOrd>(left: T, right: T) -> T {
    if left >= right {
        left
    } else {
        right
    }
}

fn main() {
    let x = 1;
    let y = 2;
    println!("max({}, {}) = {}", x, y, max(x, y)); //Output: max(1, 2) = 2
}

<T: std::cmp::PartialOrd> の表現は型 T の制約条件を示すもので std::cmp::PartialOrd トレイトを実装する型のみ max() 関数が有効になる。このようなトレイトを使った制約の定義を「トレイト境界（trait bound）」と呼ぶらしい。

トレイト境界は where 節を使って記述することもできる。

fn max<T>(left: T, right: T) -> T
where
    T: std::cmp::PartialOrd,
{
    if left >= right {
        left
    } else {
        right
    }
}

トレイト境界の記述は煩雑になりがちなので，これで多少はスッキリするだろう。

ちなみに std::cmp::PartialOrd トレイトは >, >=, <, <= の順序比較演算子を使うためのもので，少なくとも組み込みデータ型は全て std::cmp::PartialOrd トレイトを実装している。

たとえば比較可能でない構造体

#[derive(Debug)]
struct Person {
    age: u32,
    name: String,
}

に max() 関数を使おうとしても

fn max<'a, T: std::cmp::PartialOrd>(left: &'a T, right: &'a T) -> &'a T {
    if left >= right {
        left
    } else {
        right
    }
}

fn main() {
    let p1 = Person {
        age: 24,
        name: "Alice".to_string(),
    };
    let p2 = Person {
        age: 24,
        name: "Bob".to_string(),
    };
    println!("max({:?}, {:?}) = {:?}", p1, p2, max(&p1, &p2)); //Error: can't compare `Person` with `Person`
}

コンパイルエラーになる。

構造体における総称型

構造体のフィールドやメソッドも総称型で記述することができる。

struct Point<T> {
    x: T,
    y: T,
}

impl<T> Point<T> {
    fn new(x: T, y: T) -> Self {
        Self { x, y }
    }
}

impl<T: std::ops::Add<Output = T> + Copy> Point<T> {
    fn add(&self, p: &Self) -> Self {
        Self::new(self.x + p.x, self.y + p.y)
    }
}

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

fn main() {
    let p1 = Point::new(1, 2);
    let p2 = Point::new(3, 4);
    println!("{} + {} = {}", p1, p2, p1.add(&p2)); //Output: <1, 2>
}

上述のように impl 構文毎に個別にトレイト境界を設定できる。

列挙型における総称型

列挙型も構造体と同じように総称型が使える。列挙型と総称型の組み合わせでもっとも有名なのが Result 型だろう。

enum Result<T, E> {
    Ok(T),
    Err(E),
}

参考図書

プログラミング言語Rust 公式ガイド: Steve Klabnik (著), Carol Nichols (著), 尾崎亮太 (翻訳); KADOKAWA 2019-06-28 (Release 2019-06-28); 単行本; 4048930702 (ASIN), 9784048930703 (EAN), 4048930702 (ISBN); 評価

公式ドキュメントの日本語版。索引がちゃんとしているので，紙の本を買っておいて手元に置いておくのが吉。

reviewed by Spiegel on 2020-02-24 (powered by PA-APIv5)

プログラミングRust: Jim Blandy (著), Jason Orendorff (著), 中田秀基 (翻訳); オライリージャパン 2018-08-10; 単行本（ソフトカバー）; 4873118557 (ASIN), 9784873118550 (EAN), 4873118557 (ISBN); 評価

Eブック版あり。公式ドキュメントよりも系統的に書かれているので痒いところに手が届く感じ。ただし量が多いので，一度斜め読みしたらあとは傍らに置いて必要に応じてつまみ食いしていくのがいいだろう。

reviewed by Spiegel on 2020-03-08 (powered by PA-APIv5)

isize/usize は C 言語等でいう int と同じと思って構わない。まぁ，どちらかと言うと size_t みたいな感じかもしれないけど。 ↩︎
現在のアーキテクチャの主流が 64 bits にも関わらず整数型の既定が i32 なのは， 32 bits アクセスのほうが「速い」かららしい。 ↩︎
浮動小数点数型の場合，単精度（f32）と倍精度（f64）の間でパフォーマンス上の違いは殆どないそうだ。それならサイズが大きい方を既定にすればいいよね，ってことらしい。 ↩︎
配列型でも列挙型（enum）と組み合わせることで複数の型に対応させることは可能。 ↩︎

関数閉包で遊ぶ

2020-04-07T18:55:33+09:00

今回は小ネタとして関数閉包（closure）で遊んでみる。起点となるコードはこれにしよう。

fn add(x: i32, y: i32) -> i32 {
    x + y
}

fn main() {
    let x = 1;
    let y = 2;
    println!("{} + {} = {}", x, y, add(x, y)); //Output: 1 + 2 = 3
}

add() 関数は見ての通り整数の足し算。この関数を関数閉包で表してみたい。

関数閉包で記述する

関数閉包の記述では fn 構文は使えない。こんな感じに書く。

fn main() {
    let add = |x, y| {x + y};
    let x = 1;
    let y = 2;
    println!("{} + {} = {}", x, y, add(x, y)); //Output: 1 + 2 = 3
}

|...| で囲まれている部分で引数を定義し {...} で囲まれている部分が関数本体になる。ちなみに，上のような記述であれば波括弧は省略できる。ていうか rustfmt コマンドで整形すると問答無用で消される（笑）

let add = |x, y| x + y;

引数や返り値の型は推論可能であれば省略できるが，型注釈で明示することもできる。

let add = |x: i32, y: i32| -> i32 { x + y };

この関数閉包をもう少し弄ってみよう。

スマートポインタ

関数閉包はスマートポインタを表すトレイト Box<T> で囲むことができる。

fn main() {
    let add = Box::new(|x, y| x + y);
    let x = 1;
    let y = 2;
    println!("{} + {} = {}", x, y, add(x, y)); //Output: 1 + 2 = 3
}

敢えて add に型注釈を付けるとこんな感じになる。

let add: Box<dyn Fn(i32, i32) -> i32> = Box::new(|x, y| x + y);

ちなみに Fn は関数閉包を表すトレイトである。

これだけでは何も面白くないが，実は「高階関数（higher-order function）」で威力を発揮する。高階関数の定番といえばアレだよね。そう「カリー化（currying）」である¹。

カリー化と所有権

では早速 add() 関数をカリー化してみよう。こんな感じ。

fn add(x: i32) -> Box<dyn Fn(i32) -> i32> {
    Box::new(move |y| x + y)
}

fn main() {
    let x = 1;
    let y = 2;
    println!("{} + {} = {}", x, y, add(x)(y)); //Output: 1 + 2 = 3
    let increment = add(x); //partial application
    println!("add({}) -> increment({}) = {}", x, y, increment(y)); //Output: add(1) -> increment(2) = 3
}

move キーワードを使って関数閉包内の変数 x の所有権を明示的に移動してる点に注意。 move を付けないと借用とみなされるが add() 関数を抜けるとスコープから外れるためコンパイルエラーになる。

ちなみに関数等のスコープ内であれば，もっと簡単に記述できる。こんな感じ。

fn main() {
    let add = |x| move |y| x + y;
    let x = 1;
    let y = 2;
    println!("{} + {} = {}", x, y, add(x)(y)); //Output: 1 + 2 = 3
    let increment = add(x); //partial application
    println!("add({}) -> increment({}) = {}", x, y, increment(y)); //Output: add(1) -> increment(2) = 3
}

よーし，うむうむ，よーし。

参考図書

プログラミング言語Rust 公式ガイド: Steve Klabnik (著), Carol Nichols (著), 尾崎亮太 (翻訳); KADOKAWA 2019-06-28 (Release 2019-06-28); 単行本; 4048930702 (ASIN), 9784048930703 (EAN), 4048930702 (ISBN); 評価

公式ドキュメントの日本語版。索引がちゃんとしているので，紙の本を買っておいて手元に置いておくのが吉。

reviewed by Spiegel on 2020-02-24 (powered by PA-APIv5)

プログラミングRust: Jim Blandy (著), Jason Orendorff (著), 中田秀基 (翻訳); オライリージャパン 2018-08-10; 単行本（ソフトカバー）; 4873118557 (ASIN), 9784873118550 (EAN), 4873118557 (ISBN); 評価

reviewed by Spiegel on 2020-03-08 (powered by PA-APIv5)

カリー化については拙文「カリー化に関する覚え書き」を参考にどうぞ。 ↩︎

エラー・ハンドリングのキホン

2020-04-06T21:11:43+09:00

今日の起点となるコードはこれにしよう。

fn parse_string(s: &str) -> Result<u32, std::num::ParseIntError> {
    s.parse::<u32>()
}

fn main() {
    println!("{:?}", parse_string("-1")); //Output: Err(ParseIntError { kind: InvalidDigit })
}

parse_string() 関数の返り値の型 Result は列挙型 enum で¹，以下の2つの列挙子（variant）で構成されている。

enum Result<T, E> {
    Ok(T),
    Err(E),
}

Result など列挙型の評価には match 式を使う。たとえば parse() に失敗した際に 0 をセットしたいなら

fn main() {
    let n = match parse_string("-1") {
        Ok(x) => x,
        Err(_) => 0,
    };
    println!("{}", n); //Output: 0
}

などと書くことができる。

Result 型を使ったエラー・ハンドリング

このように Result 型を使うことで基本的なエラー・ハンドリングが可能になる。いくつか例を挙げていこう。

Panic を投げる

parse_string() 関数が Err を返した場合に強制終了したいのであれば

fn main() {
    let n = match parse_string("-1") {
        Ok(x) => x,
        Err(e) => panic!(e), //Output: thread 'main' panicked at 'Box<Any>', src/main.rs:8:19
    };
    println!("{}", n); //do not reach
}

と panic! マクロで panic を投げればよい。ちなみに，環境変数 RUST_BACKTRACE に 1 をセットすると panic 時にスタックトレース情報も吐く。

単に panic を投げればいいのであれば Result::unwrap() メソッドを使えば上述のコードとほぼ同じ結果が得られる。

fn main() {
    let n = parse_string("-1").unwrap(); //Output: thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: ParseIntError { kind: InvalidDigit }', src/main.rs:6:13
    println!("{}", n); //do not reach
}

Panic を投げる際のメッセージを指定するには Result::expect() メソッドを使う。

fn main() {
    let n = parse_string("-1").expect("error in parse_string() function"); //Output: thread 'main' panicked at 'error in parse_string() function: ParseIntError { kind: InvalidDigit }', src/main.rs:6:13
    println!("{}", n); //do not reach
}

Panic 以外のハンドリング

エラー時に単に panic を投げるのではなく，何らかの処理を行って普通にプロセスを終了したいのであれば Result::unwrap_or_else() メソッドを使って

fn main() {
    let n = parse_string("-1").unwrap_or_else(|e| {
        println!("Error in parse_string() function: {:?}", e); //Output: Error in parse_string() function: ParseIntError { kind: InvalidDigit }
        std::process::exit(1);
    });
    println!("{}", n); //do not reach
}

などとすることもできる。プロセスを終了するのではなく，最初の例のように解析失敗時に 0 をセットしたいなら

fn main() {
    let n = parse_string("-1").unwrap_or_else(|_| 0);
    println!("{}", n); //Output: 0
}

てな感じにも書ける。あるいはもっと簡単に Result::unwrap_or() メソッドを使って

fn main() {
    let n = parse_string("-1").unwrap_or(0);
    println!("{}", n); //Output: 0
}

とも書ける。

エラーの委譲

次に以下の関数を考える。 2つの数文字列を与えて組（tuple）にして返す。

fn parse_pair_strings(s1: &str, s2: &str) -> Result<(u32, u32), std::num::ParseIntError> {
    let x = match s1.parse::<u32>() {
        Ok(n) => n,
        Err(e) => return Err(e),
    };
    let y = match s2.parse::<u32>() {
        Ok(n) => n,
        Err(e) => return Err(e),
    };
    Ok((x, y))
}

fn main() {
    println!("{:?}", parse_pair_strings("1", "-1")); //Output: Err(ParseIntError { kind: InvalidDigit })
}

parse_pair_strings() の仮引数 s1 および s2 に対してそれぞれ parse() を行うのだが，返り値が Err の際にはエラーをそのまま返して呼び出し元にハンドリングを委譲している。

返り値の型が同じ Result なら ? 演算子を使ってエラーの委譲をもっと簡単に書くことができる。こんな感じ。

fn parse_pair_strings(s1: &str, s2: &str) -> Result<(u32, u32), std::num::ParseIntError> {
    Ok((s1.parse::<u32>()?, s2.parse::<u32>()?))
}

すっきりー！

エラーの汎化

今度は，引数に文字列を渡すのではなく，標準入力から文字列を取得して parse() してみよう。

fn parse_from_stdin() -> Result<u32, std::num::ParseIntError> {
    let mut buf = String::new();
    std::io::stdin().read_line(&mut buf)?; //Compile error: `?` couldn't convert the error to `std::num::ParseIntError`
    buf.trim().parse::<u32>()
}

当然ながらこれはコンパイルエラーになる。何故なら read_line() 関数では Err の値が std::io::Error 型になるので std::num::ParseIntError 型とはマッチしないためだ。

これを解決するには std::error::Error 型を汎化型として使えばよい。

std::error::Error 型を使う際は Box<dyn Trait> にするようだ。こんな感じ。

fn parse_from_stdin() -> Result<u32, Box<dyn std::error::Error>> {
    let mut buf = String::new();
    std::io::stdin().read_line(&mut buf)?;
    let n = buf.trim().parse::<u32>()?;
    Ok(n)
}

fn main() {
    println!("{:?}", parse_from_stdin());
}

実行するとこんな感じになる。

$ echo -1 | cargo run
Err(ParseIntError { kind: InvalidDigit })

main() 関数側でもう少し細かくエラーを見てみよう。こんな感じかなぁ。

fn main() {
    let n = match parse_from_stdin() {
        Ok(x) => x,
        Err(err) => {
            match err.downcast_ref::<std::io::Error>() {
                Some(e) => {
                    println!("io::Error in parse_from_stdin(): {}", e);
                    std::process::exit(1);
                }
                _ => (),
            };
            match err.downcast_ref::<std::num::ParseIntError>() {
                Some(e) => {
                    println!("ParseIntError in parse_from_stdin(): {}", e);
                    std::process::exit(1);
                }
                _ => (),
            };
            println!("Other error in parse_from_stdin(): {}", err);
            std::process::exit(1);
        }
    };
    println!("{}", n);
}

こうすれば Box<dyn std::error::Error> 型からもとのエラー型を抽出して個別に処理できそう。これを実行するとこんな感じ。

$ echo -1 | cargo run
ParseIntError in parse_from_stdin(): invalid digit found in string

んー。かなり面倒くさいな。もう少しマシな戦略を探すべきか。

Option 型を使ったエラー・ハンドリング

上述のコードにある downcast_ref() メソッドは Option 型の値を返す。 Option 型も列挙型で，以下の2つの列挙子で構成されている。

enum Option<T> {
    Some(T),
    None,
}

None はいわゆる Null 値，つまり値がないことを示す。関数の実行結果が Null 値を取り得る場合に Option 型を返すことで，呼び出し元に Null 値のハンドリングを促すことができる。

起点のコードはこんな感じでどうだろうか。

fn main() {
    let nihongo = "日本語";
    for i in 0..4 {
        println!("{}: {:?}", i, nihongo.chars().nth(i));
    }
}

実行するとこんな感じになる。

$ cargo run
0: Some('日')
1: Some('本')
2: Some('語')
3: None

Panic を投げる

結果が None なら panic を投げるようにしてみる。

fn main() {
    let nihongo = "日本語";
    for i in 0..4 {
        let ch = match nihongo.chars().nth(i) {
            Some(c) => c,
            None => panic!("Out of bounds"),
        };
        println!("{}: {}", i, ch)
    }
}

実行するとこんな感じ。

$ cargo run
0: 日
1: 本
2: 語
thread 'main' panicked at 'Out of bounds', src/main.rs:6:21

また Option 型にも unwrap() や expect() といったメソッドがあり， None が返ったら panic を投げる。

fn main() {
    let nihongo = "日本語";
    for i in 0..4 {
        println!("{}: {}", i, nihongo.chars().nth(i).expect("Out of bounds"));
    }
}

$ cargo run
0: 日
1: 本
2: 語
thread 'main' panicked at 'Out of bounds', src/main.rs:4:31

Panic 以外のハンドリング

たとえば，こんな感じかな。

fn main() {
    let nihongo = "日本語";
    for i in 0..4 {
        let ch = match nihongo.chars().nth(i) {
            Some(c) => c,
            None => break,
        };
        println!("{}: {}", i, ch)
    }
}

$ cargo run
0: 日
1: 本
2: 語

まぁイテレータやコレクションでこんな書き方する人はおらんじゃろうけど。あンまりいい例示じゃなくてすまん。

やっぱ例外処理は要らんよね

Rust の列挙型は（C/C++ や Java などと異なり）型の列挙を行い，パターン・マッチングによって処理を振り分ける。この仕組みを上手く使ってエラー・ハンドリングを行っているわけだ。

こうやってみると，やっぱ例外処理は要らんよね（笑）

ブックマーク

参考図書

プログラミング言語Rust 公式ガイド: Steve Klabnik (著), Carol Nichols (著), 尾崎亮太 (翻訳); KADOKAWA 2019-06-28 (Release 2019-06-28); 単行本; 4048930702 (ASIN), 9784048930703 (EAN), 4048930702 (ISBN); 評価

公式ドキュメントの日本語版。索引がちゃんとしているので，紙の本を買っておいて手元に置いておくのが吉。

reviewed by Spiegel on 2020-02-24 (powered by PA-APIv5)

プログラミングRust: Jim Blandy (著), Jason Orendorff (著), 中田秀基 (翻訳); オライリージャパン 2018-08-10; 単行本（ソフトカバー）; 4873118557 (ASIN), 9784873118550 (EAN), 4873118557 (ISBN); 評価

reviewed by Spiegel on 2020-03-08 (powered by PA-APIv5)

列挙型については「Rust の型に関する覚え書き」を参照のこと。 ↩︎

Rust の文字列操作（2）

2020-03-11T20:24:35+09:00

前回の続き。 Rust の文字列操作についてオベンキョ中です。

他の型の値を文字列に変換する

ある型が ToString トレイトを実装していれば to_string() メソッドを使って文字列に変換できる。整数や浮動小数点数などの基本型は ToString トレイトを実装している。以下のようにリテラル表現に対して直接 to_string() メソッドを起動することもできる。

fn main() {
    println!("{}", (123).to_string()); //Output: 123
    println!("{}", (1.23).to_string()); //Output: 1.23
    println!("{}", (true).to_string()); //Output: true
    println!("{}", ('あ').to_string()); //Output: あ
}

同じ基本型でもタプルや配列は ToString トレイトを実装していないため to_string() メソッドは使えない。

fn main() {
    println!("{}", ([1, 2, 3]).to_string()); //Error: no method named `to_string` found for type `[{integer}; 3]` in the current scope
}

変換する文字列を整形する

今までさんざん出てきたので今更だが， format! 等のマクロを使えば他の型の値を変換する際の文字列を整形できる。

マクロ名	機能
`format!`	文字列を整形して `String` として出力する
`print!`, `println!`	文字列を整形して標準出力に出力する
`write!`, `writeln!`	文字列を整形して指定したストリームに出力する
`panic!`	文字列を整形して panic 出力に付加する

たとえば，こんな感じ。

fn main() {
    println!("{{{} = {num:#04x} = {num:#010b}}}", num = 15); //Output: {15 = 0x0f = 0b00001111}
}

プレースホルダ {which:how} の中身の how の部分が C/C++ や Go の printf 文の書式（%d など）に相当する。意味もだいたい同じ。

書式	意味
なし	既定のテキスト
`b`	2進数
`o`	8進数
`x`	16進数（小文字）
`X`	16進数（大文字）
`e`	浮動小数点数科学技術記法（小文字）
`E`	浮動小数点数科学技術記法（大文字）
`?`	デバッグ出力
`p`	ポインタ値

実はこれらの書式には対応するトレイトがあって，独自に作成した型でもトレイトを実装することで書式に対応できる。

書式	トレイト
なし	`std::fmt::Display`
`b`	`std::fmt::Binary`
`o`	`std::fmt::Octal`
`x`	`std::fmt::LowerHex`
`X`	`std::fmt::UpperHex`
`e`	`std::fmt::LowerExp`
`E`	`std::fmt::UpperExp`
`?`	`std::fmt::Debug`
`p`	`std::fmt::Pointer`

たとえば，以下の構造体 Person に対して

struct Person {
    age: u32,
    name: String,
}

std::fmt::Display トレイトを実装してみる。こんな感じ。

use std::fmt;

struct Person {
    age: u32,
    name: String,
}

impl fmt::Display for Person {
    fn fmt(&self, dest: &mut fmt::Formatter) -> fmt::Result {
        write!(dest, "{} ({})", self.name, self.age)
    }
}

fn main() {
    let p1 = Person {
        age: 24,
        name: "alice".to_string(),
    };
    println!("p1 = {}", p1); //Output: p1 = alice (24)
    println!("p1 = {}", p1.to_string()); //Output: p1 = alice (24)
}

std::fmt::Display トレイトを実装すると ToString トレイトもセットで実装される。便利！

std::fmt::Debug トレイトの実装はもっと簡単で， derive 構文を使って

#[derive(Debug)]
struct Person {
    age: u32,
    name: String,
}

fn main() {
    let p1 = Person {
        age: 24,
        name: "alice".to_string(),
    };
    println!("p1 = {:?}", p1); //Output: p1 = Person { age: 24, name: "alice" }
}

とすればよい。

ちなみに全ての組み込み型と標準ライブラリで定義される型は std::fmt::Debug トレイトを実装済みなので，さきほど to_string() メソッドが使えないと書いたタプルや配列でも

fn main() {
    println!("{:?}", (123, 1.13)); //Output: (123, 1.13)
    println!("{:?}", [1, 2, 3]); //Output: [1, 2, 3]
}

のようにできる。

文字列から他の型の値を取得する

std::str::FromStr トレイトを実装している型であれば文字列からその型の値を取得できる。

pub trait FromStr: Sized {
    type Err;
    fn from_str(s: &str) -> Result<Self, Self::Err>;
}

整数や浮動小数点数などの基本型は std::str::FromStr トレイトを実装している。返り値は Result 型なので何らかのエラーハンドリングが必要だが，以下のコードでは端折っている¹。

use std::str::FromStr;

fn main() {
    println!("{:?}", i64::from_str("123")); //Output: Ok(123)
    println!("{:?}", f64::from_str("1.23")); //Output: Ok(1.23)
    println!("{:?}", bool::from_str("true")); //Output: Ok(true)
}

ちなみに大文字の "TRUE" はダメらしい（笑）

use std::str::FromStr;

fn main() {
    println!("{:?}", bool::from_str("TRUE")); //Output: Err(ParseBoolError { _priv: () })
}

小文字に変換すればいいかな。

use std::str::FromStr;

fn main() {
    println!("{:?}", bool::from_str(&"TRUE".to_lowercase())); //Output: Ok(true)
}

文字列に対して parse() メソッドを使う方法もある。 parse() メソッド内部で from_str() を呼び出しているらしい。

fn main() {
    println!("{:?}", "123".parse::<i64>()); //Output: Ok(123)
    println!("{:?}", "TRUE".to_lowercase().parse::<bool>()); //Output: Ok(true)
}

記述としてはどっちもどっちだな。

参考図書

プログラミング言語Rust 公式ガイド: Steve Klabnik (著), Carol Nichols (著), 尾崎亮太 (翻訳); KADOKAWA 2019-06-28 (Release 2019-06-28); 単行本; 4048930702 (ASIN), 9784048930703 (EAN), 4048930702 (ISBN); 評価

公式ドキュメントの日本語版。索引がちゃんとしているので，紙の本を買っておいて手元に置いておくのが吉。

reviewed by Spiegel on 2020-02-24 (powered by PA-APIv5)

プログラミングRust: Jim Blandy (著), Jason Orendorff (著), 中田秀基 (翻訳); オライリージャパン 2018-08-10; 単行本（ソフトカバー）; 4873118557 (ASIN), 9784873118550 (EAN), 4873118557 (ISBN); 評価

reviewed by Spiegel on 2020-03-08 (powered by PA-APIv5)

エラー・ハンドリングについては「エラー・ハンドリングのキホン」を参考にどうぞ。 ↩︎

Rust の文字列操作（1）

2020-03-08T23:08:47+09:00

さて，所有権について何とな〜く分かったところで，目先を変えて文字・文字列・文字列操作について調べていこう。

Rust の「文字列」は Unicode/UTF-8 限定

文字列操作で何が面倒かって複数の文字セットと文字エンコーディングが混在している点である。そこで今どきのプログラミング言語は「文字列」としての操作対象を Unicode/UTF-8 に限定していることが多い。 Rust もそうした言語のひとつである。

こんにちは，世界！

まずは，以下のコードを書いてみる。

fn main() {
    println!("こんにちは，世界！");
}

ここで "こんにちは，世界！" はリテラル文字列で，実行すると

$ cargo run
こんにちは，世界！

と表示される。 println! マクロ引数のリテラル文字列も出力される文字列も UTF-8 エンコーディングである。

ここでリテラル文字列の "こんにちは，世界！" を強引に Shift-JIS に書き換えて実行するとどうなるか。

$ pushd src/
$ cp main.rs main.rs.utf8.txt
$ gonkf conv -s utf8 -d sjis main.rs.utf8.txt > main.rs
$ popd
$ cargo run
error: couldn't read src/main.rs: stream did not contain valid UTF-8

というわけでコンパイルに失敗しました（笑）

Rust における文字と文字列

Rust では Unicode/UTF-8 文字および文字列を扱うために以下の3つの型が存在する。

型名	内部表現	内容
`char`	`u32`	文字（Unicode 符号点）
`String`	`Vec<u8>`	可変長文字列（UTF-8）
`str`	`[u8]`	文字列への参照（UTF-8）

char および str は組み込み型， String は標準ライブラリで定義される型である。

str 型は文字列に対するスライスで，それ自体は所有権を持たず（値を持たないため）範囲指定付きビューとして機能する。通常は &str と参照の形で使う。

String と str の関係はこんな感じ。

fn main() {
    let s: String = "Hello World".to_string();
    let hw: &str = s.as_str();
    let w: &str = &s[6..11];
    println!("{}", s); //Output: Hello World
    println!("{}", hw); //Output: Hello World
    println!("{}", w); //Output: World
}

図にするとこんな感じだろうか。

"Hello World" などのリテラル文字列は型としては &'static str と表現できる。ちなみに 'static はライフタイム注釈の特殊な表現で，生存期間がプログラム全域に及ぶという恐ろしいものである（笑）

リテラル文字列の後ろの to_string() メソッドは文字列のコピーを返す。リテラル文字列そのものがセットされているわけではない。

文字列から文字を抽出する

Rust の文字列の中身は UTF-8 バイト列なので，文字列から文字（厳密には Unicode 符号点¹）を抽出するのは単純ではない。そもそも

fn main() {
    let s = "日本語";
    println!("{}", s[0]); //Error: the type `str` cannot be indexed by `{integer}`
}

とかやってもコンパイル・エラーになるだけである。

文字列から文字を抽出するには，例えばこんな感じに書ける。

fn main() {
    let s1 = "日本語";
    println!("{:?}", s1.chars().nth(0)); //Output: Some('日')
    let s2 = s1.to_string();
    println!("{:?}", s2.chars().nth(1)); //Output: Some('本')
}

まず chars() メソッドで文字列を文字単位のイテレータ Chars に変換し，更に nth() メソッドで任意の位置の文字を抽出している。 nth() メソッドは Option 型の値を返すので本来は何らかのエラー・ハンドリングが必要だが，今回は横着している²。ゴメンペコン。

あるいはもっと簡単に collect() メソッドを使って Chars から配列 Vec<char> に変換して

fn main() {
    let nihongo = "日本語";
    let chs = nihongo.chars().collect::<Vec<char>>();
    println!("{}", chs[0]); //Output: 日
}

てな感じにも記述できる。

「文字」列から「文字列」を生成する

1文字ではなく，先頭の2文字を抽出して文字列を生成してみる。まずは素朴にこんな感じだろうか。

fn main() {
    let nihongo = "日本語";
    let mut nippon = String::new();
    for (i, c) in nihongo.chars().enumerate() {
        nippon.push(c);
        if i > 0 {
            break;
        }
    }
    println!("{}", nippon); //Output: 日本
}

うーん，微妙。たとえば take() メソッドを使えば先頭から指定した数だけ要素を有効にできる。

fn main() {
    let nihongo = "日本語";
    let mut nippon = String::new();
    for c in nihongo.chars().take(2) {
        nippon.push(c);
    }
    println!("{}", nippon); //Output: 日本
}

いや，そもそも for 文で回すってのがダサいというか… ふむむー，そっか。 fold() メソッドを使えばいいのか。

fn main() {
    let nihongo = "日本語";
    let nippon = nihongo.chars().take(2).fold(String::new(), |mut s, c| {
        s.push(c);
        s
    });
    println!("{}", nippon); //Output: 日本
}

でも「先頭の2文字を抽出する」だけなのに，コードが大袈裟すぎないか？と思ってたら，ゴメン。 collect() メソッドを使えば一発で String に変換できたわ。

fn main() {
    let nihongo = "日本語";
    let nippon = nihongo.chars().take(2).collect::<String>();
    println!("{}", nippon); //Output: 日本
}

なんだ，簡単ぢゃん orz

ブックマーク

Stringとstr入門 - Qiita
文字列操作 with Rust - Qiita
Rustで文字列の先頭文字や部分文字列を取得する - Qiita
spiegel-im-spiegel/charset_document: 「文字コードとその実装」 upLaTeX ドキュメント : 大昔に書いたドキュメントで内容が古いため，取り扱いには注意
spiegel-im-spiegel/text: Encoding/Decoding Text Package by Golang : gonkf コマンドはここで公開しています

参考図書

プログラミング言語Rust 公式ガイド: Steve Klabnik (著), Carol Nichols (著), 尾崎亮太 (翻訳); KADOKAWA 2019-06-28 (Release 2019-06-28); 単行本; 4048930702 (ASIN), 9784048930703 (EAN), 4048930702 (ISBN); 評価

公式ドキュメントの日本語版。索引がちゃんとしているので，紙の本を買っておいて手元に置いておくのが吉。

reviewed by Spiegel on 2020-02-24 (powered by PA-APIv5)

プログラミングRust: Jim Blandy (著), Jason Orendorff (著), 中田秀基 (翻訳); オライリージャパン 2018-08-10; 単行本（ソフトカバー）; 4873118557 (ASIN), 9784873118550 (EAN), 4873118557 (ISBN); 評価

reviewed by Spiegel on 2020-03-08 (powered by PA-APIv5)

Unicode ではひとつの符号点がひとつの文字を表すとは限らない点に注意。これに関して以前に「Go 言語と Unicode 正規化」という記事を書いたので参考にどうぞ。 ↩︎
エラー・ハンドリングについては「エラー・ハンドリングのキホン」を参考にどうぞ。 ↩︎

参照と借用

2020-03-08T00:51:00+09:00

前回の続きで，所有権に絡む話。

参照と借用

まずはこのコードを出発点にしよう。

struct Person {
    age: u32,
    name: String,
}

fn main() {
    let p1 = Person {
        age: 24,
        name: "Alice".to_string(),
    };
    println!("{} ({})", p1.name1, p.age); //Output: Alice (24)
}

毎回 println! マクロで出力を整形するのはかったるいので，整形を行う関数を考えてみる。こんな感じ。

struct Person {
    age: u32,
    name: String,
}

fn display_person(p: Person) -> String {
    let mut s = p.name;
    s.push_str(" (");
    s.push_str(&p.age.to_string());
    s.push_str(")");
    s
}

fn main() {
    let p1 = Person {
        age: 24,
        name: "Alice".to_string(),
    };
    println!("{}", display_person(p1)); //Output: Alice (24)
}

一見うまく行っているようだが，次の1行を足すとコンパイル・エラーになる。

fn main() {
    let p1 = Person {
        age: 24,
        name: "Alice".to_string(),
    };
    println!("{}", display_person(p1));
    println!("{}", p1.name); //Error: borrow of moved value: `p1`
}

これは変数の p1 の値の所有権が display_person() 関数の引数 p に移動したからである。

変数を引数にセットするたびに所有権が移るのは鬱陶しいので，変数の「参照」を引数にセットする。こんな感じに書き換えてみよう。

fn display_person(p: &Person) -> String {
    let mut s = p.name.clone();
    s.push_str(" (");
    s.push_str(&p.age.to_string());
    s.push_str(")");
    s
}

2行目の宣言文も変わってることに注意。実は2行目を

fn display_person(p: &Person) -> String {
    let mut s = p.name; //Error: cannot move out of `p.name` which is behind a shared reference
    s.push_str(" (");
    s.push_str(&p.age.to_string());
    s.push_str(")");
    s
}

のままにするとコンパイル・エラーになる。引数 p は元の変数の値を「借用」しているに過ぎないので，所有権の移動はできないのである。ていうか，最初の display_person() 関数は引数の値を壊してたのか。コワイコワイ（笑）

全体のコードは以下の通り。

struct Person {
    age: u32,
    name: String,
}

fn display_person(p: &Person) -> String {
    let mut s = p.name.clone();
    s.push_str(" (");
    s.push_str(&p.age.to_string());
    s.push_str(")");
    s
}

fn main() {
    let p1 = Person {
        age: 24,
        name: "Alice".to_string(),
    };
    println!("{}", display_person(&p1)); //Output: Alice (24)
    println!("{}", p1.name); //Output: Alice
}

変数と参照の関係を図式化するとこんな感じだろうか。

display_person() 関数の引数である参照変数 p は，値を直接参照しているのではなく，値の所有権を持つ変数 p1 を参照している点がポイントである。

参照のライフタイム

参照には必ずライフタイム（lifetime）が存在する¹。基本的には参照が発生してから最後に参照変数が使われたところまでがライフタイムとなる。全ての参照のライフタイムが満了すれば参照元変数の値を移動または解放できる（ヒープの解放タイミングはコンパイラが決定する）。

もう少し詳しく見てみよう。

参照されている変数の値の所有権は移動できない

先程の main() 関数を少し弄って

fn main() {
    let p1 = Person {
        age: 24,
        name: "Alice".to_string(),
    };
    let p2 = &p1;
    let p3 = p1; //Error: cannot move out of `p1` because it is borrowed
    println!("{}", display_person(p2));
    println!("{}", p3.name);
}

とするとコンパイル・エラーになる。参照されている変数の値の所有権は移動できないようだ。まぁ，当たり前か。

ただし println! マクロの位置を少し変えると

fn main() {
    let p1 = Person {
        age: 24,
        name: "Alice".to_string(),
    };
    let p2 = &p1;
    println!("{}", display_person(p2)); //Output: Alice (24)
    let p3 = p1;
    println!("{}", p3.name); //Output: Alice
}

問題なく動く。これは参照変数 p2 のライフタイムが display_person() 関数実行完了をもって満了しているため。その後の let p3 = p1; 宣言文では p1 を参照している変数はないので問題なく所有権を移動できる。

参照元変数のスコープを超えた参照はできない

ちょっとへんてこりんなコードだが

fn main() {
    let long_p;
    {
        let p1 = Person {
            age: 24,
            name: "Alice".to_string(),
        };
        long_p = &p1; //Error: `p1` does not live long enough
        println!("{}", p1.name);
    }
    println!("{}", display_person(long_p));
}

これもコンパイル・エラーになる。

変数 p1 のスコープは

fn main() {
    let long_p;
    {
        let p1 = Person {
            age: 24,
            name: "Alice".to_string(),
        };
        long_p = &p1; //Error: `p1` does not live long enough
        println!("{}", p1.name);
    }
    println!("{}", display_person(long_p));
}

となるが， p1 を参照している long_p のライフタイムは最後の

fn main() {
    let long_p;
    {
        let p1 = Person {
            age: 24,
            name: "Alice".to_string(),
        };
        long_p = &p1; //Error: `p1` does not live long enough
        println!("{}", p1.name);
    }
    println!("{}", display_person(long_p));
}

println! マクロ実行時まで続くため不整合が発生しているわけだ。

コンパイル・エラーのメッセージだけ見ても分かりにくいかもしれないが，参照のライフタイムを頭に入れながら考えれば分かりやすいだろう。ちょっとした数理パズルだと思えばいい（笑）

ライフタイム注釈

ここでもうひとつ関数を考えてみる。

欲しいのは2つの Person インスタンスの age が小さい方を選択する関数である。とりあえず何も考えずに書いてみよう。

fn younger(l: &Person, r: &Person) -> &Person { //Error: missing lifetime specifier
    if l.age < r.age {
        l
    } else {
        r
    }
}

残念。コンパイルエラーになってしまった。

この関数では参照変数 l と r のうちどちらかを返すが，どちらを返すかは実行時にしか分からない。したがって，以下の main() 関数内で

fn main() {
    let p1 = Person {
        age: 24,
        name: "Alice".to_string(),
    };
    let p2 = Person {
        age: 18,
        name: "Bob".to_string(),
    };
    let p3 = younger(&p1, &p2);
    println!("{}", display_person(p3));
}

参照変数 p3 が参照しているのが p1 なのか p2 なのか（コンパイル時に）決定できないためライフタイムも決まらないのである。

こういうときは younger() 関数に「ライフタイム注釈（lifetime annotation）」を付けるとよい。こんな感じ。

fn younger<'a>(l: &'a Person, r: &'a Person) -> &'a Person {
    if l.age < r.age {
        l
    } else {
        r
    }
}

ここでは 'a がライフタイム注釈に相当する。アポストロフィ（'）から続く文字列で構成されている。新しい younger() 関数では引数と返り値の &Person 参照変数が同じライフタイムであることをコンパイラに知らせている。

全体のコードはこんな感じ。

struct Person {
    age: u32,
    name: String,
}

fn display_person(p: &Person) -> String {
    let mut s = p.name.clone();
    s.push_str(" (");
    s.push_str(&p.age.to_string());
    s.push_str(")");
    s
}

fn younger<'a>(l: &'a Person, r: &'a Person) -> &'a Person {
    if l.age < r.age {
        l
    } else {
        r
    }
}

fn main() {
    let p1 = Person {
        age: 24,
        name: "Alice".to_string(),
    };
    let p2 = Person {
        age: 18,
        name: "Bob".to_string(),
    };
    println!("{}", display_person(younger(&p1, &p2))); //Output: Bob (18)
}

よーし，うむうむ，よーし。

ブックマーク

non-lexical lifetimes by nikomatsakis · Pull Request #2094 · rust-lang/rfcs · GitHub
- RFC 2094 (non-lexical lifetime) の非公式訳 | ubnt-intrepid’s blog

参考図書

プログラミング言語Rust 公式ガイド: Steve Klabnik (著), Carol Nichols (著), 尾崎亮太 (翻訳); KADOKAWA 2019-06-28 (Release 2019-06-28); 単行本; 4048930702 (ASIN), 9784048930703 (EAN), 4048930702 (ISBN); 評価

公式ドキュメントの日本語版。索引がちゃんとしているので，紙の本を買っておいて手元に置いておくのが吉。

reviewed by Spiegel on 2020-02-24 (powered by PA-APIv5)

Lifetime の日本語表記はサイトや参考書によって「生存期間」とカタカナの「ライフタイム」の間で揺れているようだ。ただし「ライフタイム注釈」という語については揺れがないようなので，この記事に限っては「ライフタイム」で統一する。 ↩︎

変数束縛

2020-03-01T21:08:53+09:00

Rust の所有権（ownership）のルールは以下の3つ（公式ドキュメントの「所有権とは？」より抜粋）。

Rust の各値は、所有者と呼ばれる変数と対応している
いかなる時も所有者は一つである
所有者がスコープから外れたら、値は破棄される

「値」は所有者である「変数」に束縛される。これを「変数束縛（variable bindings）」と呼ぶ。

実際に変数束縛がどのように機能しているかを見てみよう。

Copy Semantics

Rust において組み込みで定義されるデータ型は以下の通り。

スカラ型
- 整数 (i8, u8, …, isize, usize)
- 浮動小数点数型（f32, f64）
- 論理値型（bool）
- 文字型（char）: Unicode 符号点
複合型
- タプル型
- 配列型

（詳しくは「型に関する覚え書き」を参照のこと）

スカラ型およびスカラ型で構成される複合型は値と変数が一体になっていて（値が固定長で直接スタックに積まれるため），代入時に値のコピーが発生する。

fn main() {
	let mut ary1 = [1, 2, 3];
	let ary2 = ary1;
	ary1[0] *= 100;
	println!("ary1 = {:?}", ary1); //Output: ary1 = [100, 2, 3]
	println!("ary2 = {:?}", ary2); //Output: ary2 = [1, 2, 3]
}

イメージとしてはこんな感じ。

このようにデータ型では値をコピーすることによって変数束縛を担保している。

ちなみに mut は変数が可変（mutable）であることを示す。 Rust では，全ての変数は宣言時に mut キーワードを付けない限り不変（immutable）である。

Move Semantics

Rust には上述のデータ型以外にもいくつかの型が存在する。以下に主なものを挙げる。

構造体（struct）
コレクション
- 文字列（String）
- ベクタ（Vec<T>）
- ハッシュマップ（HashMap<K, V>）

たとえば構造体なら

struct Person {
	age: u32,
	name: String,
}

fn main() {
	let p1 = Person {
		age: 24,
		name: "alice".to_string(),
	};
	println!("p1 = {} ({})", p1.name, p1.age); //Output: p1 = alice (24)
}

てな感じに書ける。

組み込みのデータ型との違いは，変数で示しているものが，値そのものではなく，値への参照（のようなもの¹）という点である。

今度は変数 p1 の値を別の変数に代入してみよう。

struct Person {
	age: u32,
	name: String,
}

fn main() {
	let p1 = Person {
		age: 24,
		name: "alice".to_string(),
	};
	println!("p1 = {} ({})", p1.name, p1.age); //Output: p1 = alice (24)
	let p2 = p1;
	println!("p2 = {} ({})", p2.name, p2.age); //Output: p2 = alice (24)
}

一見うまく言っているようだが，println! マクロ² の位置を変えると

struct Person {
	age: u32,
	name: String,
}

fn main() {
	let p1 = Person {
		age: 24,
		name: "alice".to_string(),
	};
	let p2 = p1;
	println!("p1 = {} ({})", p1.name, p1.age); //Error: value borrowed here after move
	println!("p2 = {} ({})", p2.name, p2.age);
}

コンパイルエラーになる。

これは

let p2 = p1;

の部分で値がコピーされず，所有権のみ移動してしまうため。

構造体やコレクションの各型の値はヒープ領域に置かれる。ヒープ上の値に対して代入等を行うたびにコピーを行うのは高コストだし，かといって野放図に参照を増やすとヒープ管理が煩雑になってしまう。

そこで所有権を「移動」することでヒープ管理の最適化を行うわけだ。

Copy/Clone Trait

じゃあ，構造体やコレクションのコピーはできないのかというと，ちゃんと救済措置はある。

Rust の標準ライブラリには Clone および Copy トレイトが用意されていてこれらを実装することで値のコピーが可能になる³。

たとえば先程の Person 構造体に Clone トレイトを実装すると

struct Person {
	age: u32,
	name: String,
}

impl Clone for Person {
	fn clone(&self) -> Self {
		Person {
			age: self.age,
			name: self.name.clone(),
		}
	}
}

fn main() {
	let p1 = Person {
		age: 24,
		name: "alice".to_string(),
	};
	let p2 = p1.clone();
	println!("p1 = {} ({})", p1.name, p1.age); //Output: p1 = alice (24)
	println!("p2 = {} ({})", p2.name, p2.age); //Output: p2 = alice (24)
}

のように clone() メソッドでコピーを生成できるようになる。図にすると，こんな感じか。

あるいは derive 構文⁴ を使えば

#[derive(Clone)]
struct Person {
	age: u32,
	name: String,
}

fn main() {
	let p1 = Person {
		age: 24,
		name: "alice".to_string(),
	};
	let p2 = p1.clone();
    println!("p1 = {} ({})", p1.name, p1.age); //Output: p1 = alice (24)
	println!("p2 = {} ({})", p2.name, p2.age); //Output: p2 = alice (24)
}

のようにコンパイラが自動的に Clone トレイトを実装してくれる。

実を言うと

#[derive(Copy, Clone)]

とすれば代入時に値をコピーできるようになるのだが， Person 構造体ではコンパイルエラーになってしまい上手く行かなかった。色々試してみたが，どうも String 等のコレクションを含む構造体の Copy トレイトは実装できないようだ⁵。

属性にコレクション型を含まないのであれば

#[derive(Copy, Clone)]
struct Complex {
	real: f64,
	image: f64,
}

fn main() {
	let c1 = Complex {
		real: 1.23,
		image: 4.5,
	};
	let c2 = c1;
	println!("c1 = {} + {}i", c1.real, c1.image); //Output: c1 = 1.23 + 4.5i
	println!("c2 = {} + {}i", c2.real, c2.image); //Output: c2 = 1.23 + 4.5i
}

てな感じに簡単に Copy トレイトを実装できる。

ふむむー。

ブックマーク

RustのコピーセマンティクスをCopyトレイトを実装して確認する｜ Developers.IO

参考図書

プログラミング言語Rust 公式ガイド: Steve Klabnik (著), Carol Nichols (著), 尾崎亮太 (翻訳); KADOKAWA 2019-06-28 (Release 2019-06-28); 単行本; 4048930702 (ASIN), 9784048930703 (EAN), 4048930702 (ISBN); 評価

公式ドキュメントの日本語版。索引がちゃんとしているので，紙の本を買っておいて手元に置いておくのが吉。

reviewed by Spiegel on 2020-02-24 (powered by PA-APIv5)

厳密には Rust で「参照」は別のものを指すので，ここではユルく「のようなもの」という感じでご容赦を。 ↩︎
println! って関数じゃなくてマクロなんですよ，奥さん。 ↩︎
「トレイト（trait）」とは，ここでは C++ や Java で言うところの interface クラスのようなものだと思っておけばよい。トレイトに関しては多分その内ちゃんとした記事を書くと思う（笑） ↩︎
derive はマクロに似た拡張構文の一種。詳細については割愛する。ていうか，これから勉強する（笑） ↩︎
derive 構文を使った Copy トレイトの実装はあくまでも bitwise なもので，たとえ String 等で Copy トレイトを実装してもスタック上のポインタ値等がコピーされるだけなので意味がないそうな。 ↩︎

みんな大好き Hello World

2020-02-26T00:00:15+09:00

というわけで， Rust の勉強を始めることにしました。どぞよろしく。まぁ，仕事じゃないので，ゆっくりのんびりとね。

余談だが，英語不得手な私は “Rust” を「ルスト」と読んでいた。マジンガーZ¹ か！

Rust ツールチェーンのインストール

まずは Rust ツールチェーンのインストールから。

インストールの方法はいくつかあるが， Ubuntu 等の Linux プラットフォームであれば rustup-init.sh をダウンロードして実行するのが手っ取り早い。

$ curl https://sh.rustup.rs -sSf | sh
info: downloading installer

Welcome to Rust!

This will download and install the official compiler for the Rust
programming language, and its package manager, Cargo.

It will add the cargo, rustc, rustup and other commands to
Cargo's bin directory, located at:

  /home/username/.cargo/bin

This can be modified with the CARGO_HOME environment variable.

Rustup metadata and toolchains will be installed into the Rustup
home directory, located at:

  /home/username/.rustup

This can be modified with the RUSTUP_HOME environment variable.

This path will then be added to your PATH environment variable by
modifying the profile file located at:

  /home/username/.profile

You can uninstall at any time with rustup self uninstall and
these changes will be reverted.

Current installation options:


   default host triple: x86_64-unknown-linux-gnu
     default toolchain: stable
               profile: default
  modify PATH variable: yes

1) Proceed with installation (default)
2) Customize installation
3) Cancel installation
>

ここで 1 を選択する。

info: profile set to 'default'
info: default host triple is x86_64-unknown-linux-gnu
info: syncing channel updates for 'stable-x86_64-unknown-linux-gnu'
info: latest update on 2020-01-30, rust version 1.41.0 (5e1a79984 2020-01-27)
info: downloading component 'cargo'
info: downloading component 'clippy'
info: downloading component 'rust-docs'
 12.0 MiB /  12.0 MiB (100 %)   5.7 MiB/s in  2s ETA:  0s
info: downloading component 'rust-std'
 17.5 MiB /  17.5 MiB (100 %)   7.2 MiB/s in  2s ETA:  0s
info: downloading component 'rustc'
 57.9 MiB /  57.9 MiB (100 %)   6.5 MiB/s in  9s ETA:  0s
info: downloading component 'rustfmt'
info: installing component 'cargo'
info: installing component 'clippy'
info: installing component 'rust-docs'
 12.0 MiB /  12.0 MiB (100 %)  10.0 MiB/s in  1s ETA:  0s
info: installing component 'rust-std'
info: installing component 'rustc'
 57.9 MiB /  57.9 MiB (100 %)  11.6 MiB/s in  5s ETA:  0s
info: installing component 'rustfmt'
info: default toolchain set to 'stable'

  stable installed - rustc 1.41.0 (5e1a79984 2020-01-27)


Rust is installed now. Great!

To get started you need Cargo's bin directory ($HOME/.cargo/bin) in your PATH
environment variable. Next time you log in this will be done
automatically.

To configure your current shell run source $HOME/.cargo/env

これで Rust のツールチェーン一式が ~/.cargo/ および ~/.rustup/ ディレクトリ以下にインストールされた。いや，どうせなら XDG Base Directory に対応してくれよ orz …まぁいいや。

ちなみに ~/.profile ファイルの末尾に

export PATH="$HOME/.cargo/bin:$PATH"

と追記されるが，私の好みで以下のように書き換えた。

# set PATH so it includes user's private bin if it exists
if [ -d "$HOME/.cargo/bin" ] ; then
  PATH="$PATH:$HOME/.cargo/bin"
fi

Rust ツールチェーンのうち主なコマンドを以下に挙げる。

コマンド名	機能
`rustup`	ツールチェーンの導入および更新
`rustc`	コンパイラ本体
`rustfmt`	ソースコードのフォーマット
`cargo`	パッケージ管理
`rls`	Rust Language Server

たとえば

$ rustup update
info: syncing channel updates for 'stable-x86_64-unknown-linux-gnu'
info: checking for self-updates

  stable-x86_64-unknown-linux-gnu unchanged - rustc 1.41.0 (5e1a79984 2020-01-27)

info: cleaning up downloads & tmp directories

てな感じにツールチェーンのアップデートも簡単にできる。

リンカに注意

Rust ではリンカについては自前のものを持っていないようだ。 Ubuntu 等の Linux プラットフォームであれば GCC が標準で入っているため問題ないが， Windows の場合は Visual Studio 等の開発環境が必要になる。

Rust ではクロスコンパイルも可能だが，リンカはプラットフォーム毎に用意する必要があるため注意が必要である。まぁ Docker 等を使えばいいんだろうけど。

エディタ機能の拡張

Rust の Tools には各種エディタや IDE で使える拡張機能が紹介されている。私は ATOM を使うので ide-rust を使えばいいようだ。 rls に対応してるぞ。

みんな大好き Hello World

適当なディレクトリに hello.rs ファイルを作って，以下のコードを書く。

fn main() {
    println!("Hello, world!");
}

これをコンパイル&実行する。

$ rustc hello.rs 
$ ./hello 
Hello, world!

よーし，うむうむ，よーし。

Cargo でプロジェクト・ベースの環境を作る

cargo コマンドを使ってプロジェクト・ベースの環境の雛形を作ることができる。

$ cargo new hello --vcs none
     Created binary (application) `hello` package

このコマンドにより hello ディレクトリが作成され，以下のディレクトリ・ファイルが作成される。

$ tree hello
hello
├── Cargo.toml
└── src
    └── main.rs

src/main.rs の中身は先程の main() 関数と同じ内容である。 Cargo.toml の中身は以下の通り。

[package]
name = "hello"
version = "0.1.0"
authors = ["username <username@example.com>"]
edition = "2018"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]

どうも authors の項目は git のグローバル設定を読み取ってるらしい。

ちなみに，先程のコマンドの --vcs none オプションを外すと git のリポジトリとして構築される。また GitHub に空のリポジトリを作ってローカルに clone し

$ git clone https://github.com/spiegel-im-spiegel/rust-hello.git hello
$ cargo init hello
     Created binary (application) package

てな感じに初期化することもできる。

cargo コマンドで作った環境下では cargo コマンド経由でビルドやデバッグなどができる。

たとえば cargo run コマンドを使えば

$ cd hello
$ cargo run
   Compiling hello v0.1.0 (/home/username/rust/hello)
    Finished dev [unoptimized + debuginfo] target(s) in 0.32s
     Running `target/debug/hello`
Hello, world!

てな感じにコンパイル&実行が一気にできる。リリース用のビルドは

$ cargo build --release
   Compiling hello v0.1.0 (/home/username/rust/hello)
    Finished release [optimized] target(s) in 0.18s

$ ./target/release/hello 
Hello, world!

という感じ。

外部関数インターフェイス

Rust は外部関数インターフェイス（Foreign Function Interface；FFI）の仕組みを持っていて，他言語の関数を呼び出したり，逆に Rust の関数を他言語から呼び出したりすることができる。

今回は詳細な説明は省いて medimatrix/rust-plus-golang リポジトリにあるサンプルコードを紹介するに留める。

$ git clone https://github.com/medimatrix/rust-plus-golang.git

$ tree rust-plus-golang/
rust-plus-golang/
├── LICENSE
├── Makefile
├── README.md
├── lib
│   ├── hello
│   │   ├── Cargo.toml
│   │   └── src
│   │       └── lib.rs
│   └── hello.h
└── main.go

lib/hello/Cargo.toml の中身はこんな感じ。

[package]
name = "hello"
version = "0.1.0"

[lib]
crate-type = ["cdylib"]

[dependencies]
libc = "0.2.2"

更に lib/hello/src/lib.rs の中身はこんな感じ。

extern crate libc;
use std::ffi::CStr;

#[no_mangle]
pub extern "C" fn hello(name: *const libc::c_char) {
    let buf_name = unsafe { CStr::from_ptr(name).to_bytes() };
    let str_name = String::from_utf8(buf_name.to_vec()).unwrap();
    println!("Hello {}!", str_name);
}

この hello() 関数を呼び出す main.go の中身はこんな感じ。

package main

/*
#cgo LDFLAGS: -L./lib -lhello
#include "./lib/hello.h"
*/
import "C"

func main() {
    C.hello(C.CString("John Smith"))
}

ほんじゃあ，まぁ，ビルドしてみよっか。

$ make
cd lib/hello && cargo build --release
    Updating crates.io index
  Downloaded libc v0.2.67
   Compiling libc v0.2.67
   Compiling hello v0.1.0 (/home/username/rust/rust-plus-golang/lib/hello)
    Finished release [optimized] target(s) in 27.05s
cp lib/hello/target/release/libhello.so lib/
go build -ldflags="-r /home/username/rust/rust-plus-golang/lib" main.go

$ ./main
Hello John Smith!

よしよし。

今回は C 言語のインタフェースを使って Go から Rust の関数を呼び出していたが，他にも Ruby や Python などとも連携可能らしい。

ブックマーク

参考図書

プログラミング言語Rust 公式ガイド: Steve Klabnik (著), Carol Nichols (著), 尾崎亮太 (翻訳); KADOKAWA 2019-06-28 (Release 2019-06-28); 単行本; 4048930702 (ASIN), 9784048930703 (EAN), 4048930702 (ISBN); 評価

公式ドキュメントの日本語版。索引がちゃんとしているので，紙の本を買っておいて手元に置いておくのが吉。

reviewed by Spiegel on 2020-02-24 (powered by PA-APIv5)

マジンガーZの「ルスト・ハリケーン」は “rust hurricane” という説があるらしい。しかも “rust” を「ラスト」と読むと “last” と勘違いするからわざと「ルスト」と読んでいるという説まであるそうな。まぁ，真実は命名者に聞かないと分からないが（笑） ↩︎

Rust 言語に関するブックマーク

2020-02-24T23:59:59+09:00

Rust 関連の資料をブックマークとして挙げておく。

公式およびその翻訳資料

Rust Programming Language
The Rust Programming Language : 公式ドキュメント
- The Rust Programming Language : 公式ドキュメントの日本語版
Rust By Example 日本語版
Rust Playground

実装例

servo/servo: The Servo Browser Engine
Sequoia-PGP : Rust による OpenPGP 実装
Zola
- Rust 製スタティックサイトジェネレーター Zola をつかう | hiromasa.another :o)

その他，参考（になるかもしれない）ページ

参考図書

プログラミング言語Rust 公式ガイド: Steve Klabnik (著), Carol Nichols (著), 尾崎亮太 (翻訳); KADOKAWA 2019-06-28 (Release 2019-06-28); 単行本; 4048930702 (ASIN), 9784048930703 (EAN), 4048930702 (ISBN); 評価

公式ドキュメントの日本語版。索引がちゃんとしているので，紙の本を買っておいて手元に置いておくのが吉。

reviewed by Spiegel on 2020-02-24 (powered by PA-APIv5)

プログラミングRust: Jim Blandy (著), Jason Orendorff (著), 中田秀基 (翻訳); オライリージャパン 2018-08-10; 単行本（ソフトカバー）; 4873118557 (ASIN), 9784873118550 (EAN), 4873118557 (ISBN); 評価

reviewed by Spiegel on 2020-03-08 (powered by PA-APIv5)

実践Rust入門　[言語仕様から開発手法まで]: κeen (著), 河野達也 (著), 小松礼人 (著); 技術評論社 2019-04-26 (Release 2019-04-26); Kindle版; B07QVQ7RDG (ASIN)

勉強会で薦められた本。「内容がすごく重い」とのこと。読んでないが，目次を見る限りは事例が豊富な感じ？