21 Dec 2015

Programming / Rust

Syntax and Semantics

Rustには強力なパターンマッチがあります。今回はその紹介です。

Match

まずは簡単な例から。matchのsyntaxは以下のようになっています。

let x = 5;

match x {
    1 => println!("one");
    2 => println!("two");
    3 => println!("three");
    4 => println!("four");
    5 => println!("five");
    _ => println!("something else");
}

matchはexpressionをとり、{}で囲んで、 val => expressionの形で枝を連ねます。

_をつかうと、なんにでもmatchすることができます。 Haskellとおなじですね。

if-elseとちがって、 matchはすべての場合を網羅することがコンパイル時にチェックされます。

ちなみに、

match x {
    _ => println!("something else");
    5 => println!("five");
}

のように、_を上に書くと、5の枝に分岐しないよ！というコンパイルエラーがでました。

match自体もexpressionなので、代入できます。

let x = 5;

let number = match x {
    1 => "one",
    2 => "two",
    3 => "three",
    4 => "four",
    5 => "five",
    _ => "somehing else",
}

println!("x is {}", number);

Matching on enums

matchと相性がいいのがenumです。

enum Message {
    Quit,
    ChangeColor(i32, i32, i32),
    Move { x: i32, y: i32 },
    Write(String),
}

fn quit() { /* ... */ }
fn change_color(r: i32, g: i32, b: i32) { /* ... */ }
fn move_cursor(x: i32, y: i32) { /* ... */ }

fn process_message(msg: Message) {
    match msg {
        Message::Quit => quit(),
        Message::ChangeColor(r, g, b) => change_color(r, g, b),
        Message::Move { x: x, y: y } => move_cursor(x, y),
        Message::Write(s) => println!("{}", s),
    };
}

Enumをmatchするときも、すべての場合を網羅しているかチェックされます。

上の例のように、Matchの際にstructの中身をとりだすことができます。このような、patternの詳細は次の章から詳しく見ていきます。

Patterns

もっとも簡単なpatternの例は最初に扱いました。次に進みましょう。

Multiple patterns

|をつかうと、orパターンが実現できます。

let x = 1;

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

Destructing

Enumのmatchで扱いましたが、 structやenumなどの複合型をmatchするときは、そのなかみをとりだすことができます。

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

let origin = Point { x: 0, y: 0 };

match origin {
    Point { x, y } => println!("({},{})", x, y),
}

structなら、要素に別の名前をつけることもできます。

match origin {
    Point { x: x1, y: y1 } => println!("({},{})", x1, y1),
}

さらに、すべての要素が必要でない問は、..が使えます。

match origin {
    Point { y, .. } => println!("y is {}", y),
}

Ignoring bindings

_をつかえばなんにでもmatchしますが、次のようにも使えます。

match some_value {
    Ok(value) => println!("got a value: {}", value),
    Err(_) => println!("an error occurred"),
}

some_valueはResult<T, E>という型で、 OkかErrというenumの可能性があります。

Err(_)は、Errであるという情報だけでmatchし、中身がなんであるかは捨てています。

match以外でも_が使えて、たとえば、

fn coodinate() -> (i32, i32, i32) {
    // generate and return some sort of triple tuple
}

let (x, _, z) = coodinate();

のように、tupleを返す関数の戻り値の一部を捨てることができます。

また、複数のものを捨てるときは、_, _などの代わりに、..が使えます。

enum OptionalTuple {
    Value(i32, i32, i32),
    Missing,
}

let x = OptionalTuple::Value(5, -2, 3);

match x {
    OptionalTuple::Value(..) => println!("Got a tuple!"),
    OptionalTuple::Missing => println!("No such luck."),
}

ref and ref mut

Matchしたものを参照で受け取りたいときは、refをつけます。

let x = 5;

match x {
    ref r => println!("Got a reference to {}", r),
}

このときrの型は&i32になっています。

mutableな参照なら、ref mutとします。

Ranges

整数型とcharは、...を使ってrangeでmatchができます。

let x = 1;

match x {
    1 ... 5 => println!("one through five"),
    _ => println!("anything"),
}

let x = '💅'

match x {
    'a' ... 'j' => println!("early letter"),
    'k' ... 'z' => println!("late letter"),
    _ => println!("something else"),
}

Bindings

Matchした結果を@をつかってbindすることができます。

let x = 1;

match x {
    e @ 1 ... 5 => println!("got a range element {}", e),
    _ => println!("anything"),
}

この例だと、xを表示すればいいですが、複雑なstructなどにつかうと便利です。

#[derive(Debug)]
struct Person {
    name: Option<String>,
}

let name = "Steve".to_string();
let mut x: Option<Person> = Some(Person { name: Some(name) });

match x {
    Some(Person { name: ref a @ Some(_), .. }) => println!("{:?}", a),
    _ => {}
}

aにnameをbindしています。

@を|といっしょにつかうときは、

let x = 5;
match x {
    e @ 1 ... 5 | e @ 8 ... 10 => println!("got a range element {}", e),
    _ => println!("anything"),
}

のように、|で区切ったすべての部分についてbindするように書きます。

Guards

Matchの条件にifを書くことで、guardも実現できます。

enum OptionalInt {
    Value(i32),
    Missing,
}

let x = OptionalInt::Value(5);

match x {
    OptionalInt::Value(i) if i > 5 => println!("Got an int bigger than five!"),
    OptionalInt::Value(..) => println!("Got an int!"),
    OptionalInt::Missing => println!("No such luck."),
}

i > 5がfalseなので、ひとつ目のパターンにはマッチせず、ふたつ目に入ります。

match x {
    OptionalInt::Value(i) => if i > 5 {
            println!("Got an int bigger than five!");
        } else {
            println!("Got an int!"),
        },
    OptionalInt::Missing => println!("No such luck."),
}

としても同じですが、guardをつかったほうが多少わかりやすいでしょうか。

|と組み合わせるときは、guardのifは|で区切ったすべての部分に掛かります。つまり、

let x = 4;
let y = false;

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

と書くと、4 | (5 if y)ではなく、(4 | 5) if yと解釈されます。