List of Enumeration [text.Baldanders.info]

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

2020-04-06T12:11:43+00: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); 評価

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

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); 評価

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

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

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

列挙型での遊び方

2019-08-31T14:49:53+00:00

どうも Go 1.13 は8月中には出なさそうなので，軽く小話を。

列挙型と定数生成器

Go 言語にはいわゆる「列挙型」や「列挙クラス」といったものは存在しない。シンボルの定義には const を使えばいいので敢えて「列挙型」のようなものを考える必要はないわけだ。それでも

const (
    ONE   = 1
    TWO   = 2
    THREE = 3
)

などといちいち書いていくのは面倒である。そこで Go 言語には iota と呼ばれる定数生成器が用意されている。

先ほどのコードであれば

package main

import "fmt"

const (
    ONE = iota + 1
    TWO
    THREE
)

func main() {
    fmt.Println(ONE, TWO, THREE)
    //Output:
    //1 2 3
}

と記述できる。整数値に限れば iota の応用範囲は結構広くて

const (
    BIT0 = 1 << iota
    BIT1
    BIT2
    BIT3
)

てな感じにビットフラグのシンボルを定義することもできる。

列挙専用の型を定義する

実際に Go 言語で列挙を記述する場合は列挙専用の型を定義するのが定石である。たとえば

type BitFlag uint

という型を定義して

const (
    BIT0 BitFlag = 1 << iota
    BIT1
    BIT2
    BIT3
)

という感じに書ける。型にはメソッドを関連付けられるので，上の BitFlag 型に対して

func (f BitFlag) String() string {
    return fmt.Sprintf("%#02x", uint(f))
}

のような Stringer を用意すると

func main() {
    fmt.Println(BIT0, BIT1, BIT2, BIT3)
    //Output:
    //0x01 0x02 0x04 0x08
}

てな感じに使える。

列挙シンボルに「値」を関連付ける

ここまで説明すれば列挙シンボルに「値」を関連付けるのはそんなに難しくないと気づくだろう。

以下のような列挙シンボルを考える。

type CharEncoding int

const (
    Unknown CharEncoding = iota
    UTF8
    ShiftJIS
    EUCJP
    ISO2022JP
)

これらの列挙シンボルに対応する文字列を定義する。こんな感じ。

var encodingNameMap = map[CharEncoding]string{
    UTF8:      "UTF-8",
    ShiftJIS:  "Shift_JIS",
    EUCJP:     "EUC-JP",
    ISO2022JP: "ISO-2022-JP",
}

これで Stringer を

func (c CharEncoding) String() string {
    if s, ok := encodingNameMap[c]; ok {
        return s
    }
    return "Unknown"
}

と書けば

func main() {
    fmt.Println(UTF8)
    //Output:
    //UTF-8
}

てな感じにできる。

あるいは文字列から列挙シンボルに変換する

func GetCharEncoding(s string) CharEncoding {
    for key, value := range encodingNameMap {
        if strings.EqualFold(value, s) {
            return key
        }
    }
    return Unknown
}

という関数を作れば

func main() {
    fmt.Println(GetCharEncoding("utf-8"))
    //Output:
    //UTF-8
}

といった感じで簡易バリデーションみたいなこともできるだろう。

もちろん「値」との関連付けは文字列に限るわけではなく，たとえば

import (
    "golang.org/x/text/encoding"
    "golang.org/x/text/encoding/japanese"
    "golang.org/x/text/encoding/unicode"
)

var encodingMap = map[CharEncoding]encoding.Encoding{
    UTF8:      unicode.UTF8,
    ShiftJIS:  japanese.ShiftJIS,
    EUCJP:     japanese.EUCJP,
    ISO2022JP: japanese.ISO2022JP,
}

func (c CharEncoding) Encoding() encoding.Encoding {
    if e, ok := encodingMap[c]; ok {
        return e
    }
    return nil
}

などと幾らでも追加できる。

参考図書

プログラミング言語Go (ADDISON-WESLEY PROFESSIONAL COMPUTING SERIES): Alan A.A. Donovan (著), Brian W. Kernighan (著), 柴田芳樹 (翻訳); 丸善出版 2016-06-20; 単行本（ソフトカバー）; 4621300253 (ASIN), 9784621300251 (EAN), 4621300253 (ISBN); 評価

[Comment] 著者のひとりは（あの「バイブル」とも呼ばれる）通称 “K&R” の K のほうである。この本は Go 言語の教科書と言ってもいいだろう。と思ったら絶版状態らしい（2025-01 現在）。復刊を望む！