Rustの必須列挙型

Rustの列挙型は非常に自由度が高く強力な仕組みなのですが、その中でもRustが標準提供している下記は、Rustの根幹を支える非常に重要な役割を持っています。

Result
Option

これらを利用せずにRustで開発することは難しいため、利用方法を学習していきましょう。

Result

概要

Resultは、成功（Ok）または失敗（Err）を表現する列挙型です。

enum Result<T, E> {
    Ok(T),   // 成功時の値
    Err(E),  // エラー時の値
}

Rustは例外によって想定外の処理が発生すること自体を嫌う設計思想となっており、try-catch機構が存在しません。
代わりに、失敗しうる処理については必ずこのResult型を使って、成功時と失敗時でそれぞれどのような結果が返されるかを明示する仕組みとなっています。

つまりこのResult型は、実質Rustにおけるエラーハンドリング機構となっています。

fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b != 0.0 {
	    Ok(a / b)
    } else {
        Err("ゼロで割ることはできません".to_string())
    }
}

パターンマッチングによる処理方法

Resultの結果を処理するには、パターンマッチングを使います。

fn main() {
    match divide(10.0, 2.0) {
        Ok(result) => println!("結果: {}", result),
        Err(error) => println!("エラー: {}", error),
    }
}

fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b != 0.0 {
	    Ok(a / b)
    } else {
        Err("ゼロで割ることはできません".to_string())
    }
}

パターンマッチングの基本構文は下記の通りです。
なお、このパターンマッチング機能もかなり自由度が高く、より柔軟な使い方もできるので、ここから少しずつ覚えていきましょう。

match [マッチング対象] {
	pattern1 => マッチした場合の処理1,
	pattern2 => マッチした場合の処理2,
	...
}

// パターンにて変数名を記述すると、マッチした値を取り出すことができます
match [マッチング対象] {
	pattern1(var1) => マッチした場合の処理1（var1が利用可能）,
	pattern2(var2) => マッチした場合の処理2（var2が利用可能）,
	...
}

?演算子によるエラー伝播

Resultもパターンマッチングも非常に優秀な仕組みですが、失敗しうる処理の度に毎回パターンマッチングを記述して、値を取り出して……と実装しなければいけないのではだいぶ負荷が高くなってしまいます。

fn main() {
	// このパターンマッチングのネスト構造はだるい & 気持ち悪い！
    match result1() {
        Ok(result) => {
            match result2() {
                Ok(result2) => println!("結果: {}", result + result2),
                Err(error) => println!("エラー: {}", error),
            }
        },
        Err(error) => println!("エラー: {}", error),
    }
}

fn result1() -> Result<f64, String> {
    let result1 = divide(10.0, 2.0);
    match result1 {
        Ok(value) => Ok(value),
        Err(e) => Err(e),
    }
}

fn result2() -> Result<f64, String> {
    let result1 = divide(30.0, 5.0);
    match result1 {
        Ok(value) => Ok(value),
        Err(e) => Err(e),
    }
}

fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b != 0.0 {
	    Ok(a / b)
    } else {
        Err("ゼロで割ることはできません".to_string())
    }
}

そこでRustでは、ResultがOkだった場合は値を取り出す、エラーだった場合はすぐさまそのエラーをreturnしてより上位の関数に処理を委ねる演算子が用意されています。
それが?です。

Resultの末尾に?を付与することで、自動的に上記処理が適用されます。

// main関数の戻り値もResultにすることができます
fn main() -> Result<(), String> {
	// ?演算子を使えばスッキリ書ける！
    let result1 = result1()?;
    let result2 = result2()?;
    println!("結果: {}", result1 + result2);
    // ()という値はユニットと呼ばれる特殊な値で、何も返さない場合の戻り値表現として利用します
    Ok(())
}

fn result1() -> Result<f64, String> {
    let result1 = divide(10.0, 2.0)?;
    Ok(result1)
}

fn result2() -> Result<f64, String> {
    let result2 = divide(30.0, 5.0)?;
    Ok(result2)
}

fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b != 0.0 {
	    Ok(a / b)
    } else {
        Err("ゼロで割ることはできません".to_string())
    }
}

unwrapによる強制Ok値抽出

前々回の講座でも出てきたunwrapメソッドを使うと、ResultをOkとみなして強制的に値を取り出すことができます。

fn main() {
	// unwrapで強制的にOkの値抽出
    let result1 = result1().unwrap();
    let result2 = result2().unwrap();
    println!("結果: {}", result1 + result2);
}

fn result1() -> Result<f64, String> {
    let result1 = divide(10.0, 2.0)?;
    Ok(result1)
}

fn result2() -> Result<f64, String> {
    let result2 = divide(30.0, 5.0)?;
    Ok(result2)
}

fn divide(a: f64, b: f64) -> Result<f64, String> {
    if b != 0.0 {
	    Ok(a / b)
    } else {
        Err("ゼロで割ることはできません".to_string())
    }
}

しかしこれはRustが担保してくれる安全性を開発者自ら破棄することを意味します。
万が一unwrapの対象がErrだった場合、Rustはpanic（例外）を発生させます。
が、try-catch構文がないので、それを適切に処理する術はありません。

なので、Resultを処理するのが面倒だからという理由でこのunwrapを使うのはNGです。
開発者自身が安全性を担保する→しかし人間は完璧ではないのでどこかで問題発生、というC/C++時代に巻き戻ってしまうことになります（Rustである意味がなくなってしまう）。

絶対に100%エラーは起きないと確信を持てる場合や、エラーだった場合はむしろ意図的に例外として処理を中断させたい場合、とりあえず動作確認したいから正常パターンを動かしてみたい時などには便利に使える機能なので、覚えておきましょう。

Option

概要

Optionは、値が存在する（Some）か存在しない（None）かを表現する列挙型です。
null参照エラーを防ぐ安全装置の役割となります。

enum Option<T> {
    Some(T), // 値が存在する
    None,    // 値が存在しない
}

例えば何らかの検索処理を実装する際、値が存在しないことを表す場合は必ずこのOptionを使って表現します。

fn find_word(text: String, word: String) -> Option<usize> {
    text.find(word.as_str()) // 見つからない場合はNoneを返す
}

fn main() {
	match find_word(String::from("hello world"), String::from("world")) {
	    Some(index) => println!("'world'は{}番目にあります", index),
	    None => println!("'world'は見つかりませんでした"),
	}
}

`if let`式による条件分岐つき値抽出

パターンマッチングで処理することもできるのですが、値が存在する場合のみ処理したい場合などもあるかと思います。
その場合、if letを使うことで、パターンがマッチする場合のみ値抽出 & 条件分岐内で処理が可能となります。

fn find_word(text: String, word: String) -> Option<usize> {
    text.find(word.as_str()) // 見つからない場合はNoneを返す
}

fn main() {
	if let Some(index) = find_word(String::from("hello world"), String::from("world")) {
	    println!("'world'は{}番目にあります", index);
	}
}

`None`の場合にデフォルトまたは指定値扱いで抽出

別の方法として、Noneだった場合に型のデフォルト値または指定した値扱いとして結果を取り出すというメソッドも提供されています。

fn find_word(text: String, word: String) -> Option<usize> {
    text.find(word.as_str()) // 見つからない場合はNoneを返す
}

fn main() {
	let index = find_word(String::from("hello world"), String::from("hoge")).unwrap_or_default();
    println!("'hoge'は{}番目にあります", index);
    
    let index2 = find_word(String::from("hello world"), String::from("fuga")).unwrap_or(999);
    println!("'fuga'は{}番目にあります", index2);
}

`None`の場合にクロージャを使って値抽出

Rustにおける匿名関数のことをクロージャと言います。
変数束縛や引数として利用することが可能です。

値がNoneだった場合、クロージャで設定した関数による処理を適用することも可能です。

fn find_word(text: String, word: String) -> Option<usize> {
    text.find(word.as_str()) // 見つからない場合はNoneを返す
}

fn main() {
	let index = find_word(String::from("hello world"), String::from("hoge")).unwrap_or_else(
        || {
            1 + 5
        }
    );
    println!("'hoge'は{}番目にあります", index);
}

クロージャ

基本構文

|argument| {
	...処理...
}

// 引数が複数の場合は,で区切る
|argument1, argument2| {
	...処理...
}

// 引数がない場合は||とだけ記述
|| {
	...処理...
}

変数のキャプチャ

クロージャが定義された関数・メソッド内のローカル変数は参照・更新することができます。

fn main() {
	let x = 10;
	let capture_by_ref = || println!("x = {}", x);
	capture_by_ref(); // x = 10
	println!("xはまだ使える: {}", x);
}

fn main() {
	let mut counter = 0;
	let mut increment = || {
	    counter += 1;
	    counter
	};
	
	println!("カウント: {}", increment()); // カウント: 1
	println!("カウント: {}", increment()); // カウント: 2
}

所有権の移動・借用

クロージャが定義された関数・メソッド内のローカル変数を参照・更新するのではなく、所有権自体を移動させたい場合はmove宣言を記述します。

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

fn main() {
	let point = Point { x: 10, y: 20 };
	// この場合は型推論できないので引数の型指定が必要
	let move_point = move |point: Point| println!("x = {}, y = {}", point.x, point.y);
	move_point(point);
	println!("pointは所有権がないので参照できずエラー: {}", point.x);
}

借用であれば問題なく動作するため、使い分けが必要です。

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

fn main() {
	let point = Point { x: 10, y: 20 };
	// &Point型とし、所有権の借用を明示する
	let move_point = move |point: &Point| println!("x = {}, y = {}", point.x, point.y);
	// 所有権を借用した引数指定
	move_point(&point);
	println!("pointは所有権を失っていないのでOK: {}", point.x);
}

高階関数

配列やベクタなどのコレクションに対してmapなどの高階関数を使う場合、クロージャが必須となります。

fn main() {
	// 配列
	let numbers = [1, 2, 3, 4, 5];

	// map: 各要素を変換
	let doubled: Vec<i32> = numbers.iter()
	    .map(|x| x * 2)
	    .collect();
	println!("2倍: {:?}", doubled); // [2, 4, 6, 8, 10]
	
	// filter: 条件に合う要素を抽出
	let evens: Vec<i32> = numbers.iter()
	    .cloned()
	    .filter(|x| x % 2 == 0)
	    .collect();
	println!("偶数: {:?}", evens); // [2, 4]
}

fn main() {
	// ベクタ
	let numbers = vec![1, 2, 3, 4, 5];

	// reduce/fold: 要素を累積処理
	let sum = numbers.iter().fold(0, |acc, x| acc + x);
	println!("合計: {}", sum); // 15
	
	// 複合処理
	let result: Vec<String> = numbers.iter()
	    .filter(|&&x| x > 2) // &&を使うと所有権を失わずにfilterできます
	    .map(|x| format!("値: {}", x))
	    .collect();
	println!("{:?}", result); // ["値: 3", "値: 4", "値: 5"]
}

スライス

概要

配列やベクタなどの連続したデータを取り扱う場合、Rustではスライスと呼ばれる特殊な参照型に変換することができます。

スライスは元のデータを所有せず、データへのポインタと要素数という情報だけを持ちます。そのため、メモリをコピーせず効率的に扱えるというのが大きなポイントです。

また、配列もベクタもスライス化すれば同じ型扱いになるため、同じ関数で処理できるという点も利点になります。

スライスの利用方法

スライスとして扱いたい場合、型表現を&[型名]と記述します。

fn print_slice(slice: &[i32]) {
    for element in slice {
        println!("{}", element);
    }
}

配列もベクタもスライスに置き換えることができるので、上記メソッドはどちらでも利用可能です。

fn main() {
	let numbers_array = [1, 2, 3, 4, 5];
    let numbers_vec = vec![1, 2, 3, 4, 5];

	print_slice(&numbers_array);
	print_slice(&numbers_vec);
}

fn print_slice(slice: &[i32]) {
    for element in slice {
        println!("{}", element);
    }
}

お疲れ様でした！

お疲れ様でした。
少しずつRustに慣れてきていますでしょうか？

次回は、Rustの文字列・ライフタイムパラメータ・マクロについて学びます。
Rust入門講座⑤文字列・ライフタイムパラメータ・マクロ

Hope you enjoy it!