Rust Study Session #18

パターンとマッチング

本題.

パターンは値の構造に合致する

• パターンが使用されることのある箇所全部
• 論駁可能性: パターンが合致しないかどうか
• パターン記法

match アーム

match VALUE {
    PATTERN => EXPRESSION,
    PATTERN => EXPRESSION,
    PATTERN => EXPRESSION,
}

• 全体がmatch式
• それぞれのPATTERN => EXPRESSIONがアーム
• PATTERNがパターン

if 条件分岐

fn main() {
    let favorite_color: Option<&str> = None;
    let is_tuesday = false;
    let age: Result<u8, _> = "34".parse();
 
    if let Some(color) = favorite_color {
        println!("Using your favorite color, {}, as the background", color);
    } else if is_tuesday {
        println!("Tuesday is green day!");
    } else if let Ok(age) = age {
        if age > 30 {
            println!("Using purple as the background color");
        } else {
            println!("Using orange as the background color");
        }
    } else {
        println!("Using blue as the background color");
    }
}

• if let PATTERN=hoge {}の形式

while ループ

#![allow(unused_variables)]
fn main() {
    let mut stack = Vec::new();
 
    stack.push(1);
    stack.push(2);
    stack.push(3);
 
    while let Some(top) = stack.pop() {
        println!("{}", top);
    }
}

• while let PATTERNの形式

for ループ

#![allow(unused_variables)]
fn main() {
    let v = vec!['a', 'b', 'c'];
 
    for (index, value) in v.iter().enumerate() {
        println!("{} is at index {}", value, index);
    }
}

• for PATTERN in ..の形式

let 文

let x = 5;

は

let PATTERN = EXPRESSION;

に対応したパターンらしい

このパターンは実質的に「値が何であれ、全てを変数xに束縛しろ」を意味します。

let (x, y, z) = (1, 2, 3);

とかもパターン
他の言語と違って括弧()は必須

関数の引数

fn foo(x: i32) {
    // code goes here
}

fn print_coordinates(&(x, y): &(i32, i32)) {
    println!("Current location: ({}, {})", x, y);
}
 
fn main() {
    let point = (3, 5);
    print_coordinates(&point);
}

• fn hoge(PATTERN){}の形式

例

• 論駁不可能の例
  • let x = 5;でのx
• 論駁可能
  • if let Some(x) = a_valueでのSome(x)

もう少し例 (論駁不可能)

• OK
  • let x = 5
• NG
  • if let x = a_value{ .. }
• 他の論駁不可能な例
  • (a,b): タプル

もう少し例 (論駁可能)

• NG
  • let Some(x) = 5
• OK
  • if let Some(x) = a_value{ .. }
• 他の論駁不可能な例
  • Someの周辺以外は存在しない？

もう少し例 (if let)

これが

let some_u8_value = Some(0u8);
match some_u8_value {
    Some(3) => println!("three"),
    _ => (),
}

もう少し例 (if let)

こう書ける

let some_u8_value = Some(0u8);
if let Some(3) = some_u8_value {
    println!("three");
}

https://doc.rust-jp.rs/book-ja/ch06-03-if-let.html

if letを使うと、タイプ数が減り、インデントも少なくなり、定型コードも減ります。しかしながら、 matchでは強制された包括性チェックを失ってしまいます。matchかif letかの選択は、 特定の場面でどんなことをしたいかと簡潔性を得ることが包括性チェックを失うのに適切な代償となるかによります。

名前付き変数にマッチする

fn main() {
    let x = Some(5);
    let y = 10;
 
    match x {
        Some(50) => println!("Got 50"),
        Some(y) => println!("Matched, y = {:?}", y),
        _ => println!("Default case, x = {:?}", x),
    }
 
    println!("at the end: x = {:?}, y = {:?}", x, y);
}

複数のパターン

let x = 1;
 
match x {
    1 | 2 => println!("one or two"),
    3 => println!("three"),
    _ => println!("anything"),
}

…で値の範囲に合致させる

let x = 5;
 
match x {
    1 ... 5 => println!("one through five"),
    _ => println!("something else"),
}

• 1...5は1から4にmatchする
• 1 | 2 | 3 | 4 でも同じ
• 1...=4でも同じ

構造体を分解する

struct Point {
    x: i32,
    y: i32,
}
 
fn main() {
    let p = Point { x: 0, y: 7 };
 
    let Point { x: a, y: b } = p;
    assert_eq!(0, a);
    assert_eq!(7, b);
}

enumを分配する

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}
 
fn main() {
    let msg = Message::ChangeColor(0, 160, 255);
 
    match msg {
        Message::Quit => {
            // Quit列挙子には分配すべきデータがない
            println!("The Quit variant has no data to destructure.")
        },
        Message::Move { x, y } => {
            println!(
                // x方向に{}、y方向に{}だけ動く
                "Move in the x direction {} and in the y direction {}",
                x,
                y
            );
        }
        // テキストメッセージ: {}
        Message::Write(text) => println!("Text message: {}", text),
        Message::ChangeColor(r, g, b) => {
            println!(
                // 色を赤{}, 緑{}, 青{}に変更
                "Change the color to red {}, green {}, and blue {}",
                r,
                g,
                b
            )
        }
    }
}

参照を分配する

let points = vec![
    Point { x: 0, y: 0 },
    Point { x: 1, y: 5 },
    Point { x: 10, y: -3 },
];
 
let sum_of_squares: i32 = points
    .iter()
    .map(|&Point { x, y }| x * x + y * y)
    .sum();

構造体とタプルを分配する

let ((feet, inches), Point {x, y}) = ((3, 10), Point { x: 3, y: -10 });

気が利くなあ

_で値全体を無視する

fn foo(_: i32, y: i32) {
    println!("This code only uses the y parameter: {}", y);
}
 
fn main() {
    foo(3, 4);
}

トレイトを実装する際、 特定の型シグニチャが必要だけれども、自分の実装の関数本体では引数の1つが必要ない時など
そうすれば、代わりに名前を使った場合のようには、未使用関数引数についてコンパイラが警告することはないでしょう。

ネストされた_で値の一部を無視する

let mut setting_value = Some(5);
let new_setting_value = Some(10);
 
match (setting_value, new_setting_value) {
    (Some(_), Some(_)) => {
        // 既存の値の変更を上書きできません
        println!("Can't overwrite an existing customized value");
    }
    _ => {
        setting_value = new_setting_value;
    }
}

2番目のアームの_パターンで表現される他のあらゆる場合(setting_valueとnew_setting_valueどちらかがNoneなら)には、 new_setting_valueにsetting_valueになってほしいです。

名前を_で始めて未使用変数を無視する

fn main() {
    let _x = 5;
    let y = 10;
}

• yについてのみ未使用の警告

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

let s = Some(String::from("Hello!"));
 
if let Some(_s) = s {
    println!("found a string");
}
 
println!("{:?}", s);

解決するには:

let s = Some(String::from("Hello!"));
 
if let Some(_) = s {
    println!("found a string");
}
 
println!("{:?}", s);

..で値の残りの部分を無視する

struct Point {
    x: i32,
    y: i32,
    z: i32,
}
 
let origin = Point { x: 0, y: 0, z: 0 };
 
match origin {
    Point { x, .. } => println!("x is {}", x),
}

• 気が利くのでPoint { .., x, .. }とかはエラーになります

refとref mutでパターンに参照を生成する

let robot_name = Some(String::from("Bors"));
 
match robot_name {
    Some(name) => println!("Found a name: {}", name),
    None => (),
}
 
println!("robot_name is: {:?}", robot_name);

• ↑これはエラー
• 所有権を奪わせずに借用する↓

let robot_name = Some(String::from("Bors"));
 
match robot_name {
    Some(ref name) => println!("Found a name: {}", name),
    None => (),
}
 
println!("robot_name is: {:?}", robot_name);

• &が使えないのでrefをつかう
  • Rustの"&"と"ref"の違い
• ref mutを使用して、パターンの一部として値への可変参照を生成することもできます

マッチガードで追加の条件式 (1)

let num = Some(4);
 
match num {
    // 5未満です: {}
    Some(x) if x < 5 => println!("less than five: {}", x),
    Some(x) => println!("{}", x),
    None => (),
}

マッチガードで追加の条件式 (2)

fn main() {
    let x = Some(5);
    let y = 10;
 
    match x {
        Some(50) => println!("Got 50"),
        Some(n) if n == y => println!("Matched, n = {:?}", n),
        _ => println!("Default case, x = {:?}", x),
    }
 
    println!("at the end: x = {:?}, y = {:?}", x, y);
}

マッチガードで追加の条件式 (3)

let x = 4;
let y = false;
 
match x {
    4 | 5 | 6 if y => println!("yes"),
    _ => println!("no"),
}

• (4 | 5 | 6) if yであって4 | 5 | (6 if y)でない

@束縛

enum Message {
    Hello { id: i32 },
}
 
let msg = Message::Hello { id: 5 };
 
match msg {
    Message::Hello { id: id_variable @ 3...7 } => {
        println!("Found an id in range: {}", id_variable)
    },
    Message::Hello { id: 10...12 } => {
        println!("Found an id in another range")
    },
    Message::Hello { id } => {
        println!("Found some other id: {}", id)
    },
}

• 値を保持する変数の生成と同時に、その値のパターン一致を調べることが可能