RustのResult型の処理が分かりません。(rustlingsの問題)

Question

rustlingsのerrors6の問題が分かりません。
ParsePosNonzeroError Enumのメソッド追加とparse_pos_nonzero関数の編集を行って、下にあるtest_parse_errorというテストをパスするように改修するというのが全体の目的です。
不親切にもrustlingsは回答を一切用意していないのでここで質問させていただきます。
分かる方よろしくお願いします。

// errors6.rs

// Using catch-all error types like `Box<dyn error::Error>` isn't recommended
// for library code, where callers might want to make decisions based on the
// error content, instead of printing it out or propagating it further. Here,
// we define a custom error type to make it possible for callers to decide
// what to do next when our function returns an error.

// Make these tests pass! Execute `rustlings hint errors6` for hints :)

// I AM NOT DONE

use std::num::ParseIntError;

// This is a custom error type that we will be using in `parse_pos_nonzero()`.
#[derive(PartialEq, Debug)]
enum ParsePosNonzeroError {
    Creation(CreationError),
    ParseInt(ParseIntError)
}

impl ParsePosNonzeroError {
    fn from_creation(err: CreationError) -> ParsePosNonzeroError {
        ParsePosNonzeroError::Creation(err)
    }
    // TODO: add another error conversion function here.
}

fn parse_pos_nonzero(s: &str)
    -> Result<PositiveNonzeroInteger, ParsePosNonzeroError>
{
    // TODO: change this to return an appropriate error instead of panicking
    // when `parse()` returns an error.
    let x: i64 = s.parse().unwrap();
    PositiveNonzeroInteger::new(x)
        .map_err(ParsePosNonzeroError::from_creation)
}

// Don't change anything below this line.

#[derive(PartialEq, Debug)]
struct PositiveNonzeroInteger(u64);

#[derive(PartialEq, Debug)]
enum CreationError {
    Negative,
    Zero,
}

impl PositiveNonzeroInteger {
    fn new(value: i64) -> Result<PositiveNonzeroInteger, CreationError> {
        match value {
            x if x < 0 => Err(CreationError::Negative),
            x if x == 0 => Err(CreationError::Zero),
            x => Ok(PositiveNonzeroInteger(x as u64))
        }
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn test_parse_error() {
        // We can't construct a ParseIntError, so we have to pattern match.
        assert!(matches!(
            parse_pos_nonzero("not a number"),
            Err(ParsePosNonzeroError::ParseInt(_))
        ));
    }

    #[test]
    fn test_negative() {
        assert_eq!(
            parse_pos_nonzero("-555"),
            Err(ParsePosNonzeroError::Creation(CreationError::Negative))
        );
    }

    #[test]
    fn test_zero() {
        assert_eq!(
            parse_pos_nonzero("0"),
            Err(ParsePosNonzeroError::Creation(CreationError::Zero))
        );
    }

    #[test]
    fn test_positive() {
        let x = PositiveNonzeroInteger::new(42);
        assert!(x.is_ok());
        assert_eq!(parse_pos_nonzero("42"), Ok(x.unwrap()));
    }
}

Comments

[tatsuya6502]

Teratialではコードを書いてほしい、課題を解いてほしいなどの質問は推奨されていません。 https://teratail.com/help/avoid-asking

実際に作業に取り組んで、つまづいたことについて質問してください。`rustlings hint errors6`でヒントを表示すると少し先に進めるかもしれません。

[KOTTON]

もちろん自分でいろいろ試したんですが、質問した時点で最初の状態まで戻してしまっていたのでこのような形で質問してしまいました。すみませんでした。
今朝改めて試したところ無事クリアできました。

[tatsuya6502]

そうだったんですね。承知しました。また、無事クリアできたということで良かったです！

参考までに、模範解答のようなものを回答欄に書きました。

rustlingsなどを進めるうえでのカジュアルな質問（解き方のヒントや、回答を添削してほしいなど）については、SlackのRust日本語コミュニティーで聞いてみるのもいいかもしれません。よかったら参加してみてください。

- https://rust-jp.slack.com/
- 入会フォーム： http://rust-jp.herokuapp.com/

Answer 1

自力でクリアできたということで良かったです！

回答の以下のところですが、

let x = s.parse();
let x = match x {
    Ok(n) => n,
    Err(err) => {
        return Err(ParsePosNonzeroError::from_parseint(err));
    }
};

これが最も基本的な書き方なので、もちろんこれも正解の一つなわけですが、参考までに、もう少し簡潔に書ける方法を紹介します。

このmatch式ですが、以下のような形をしています。

match x {
    // Okのときはunwrapする
    Ok(n) => n,
    // Errのときは、別のエラーに変換し、早期リターンする
    Err(err) => return Err(別のエラー),
}

このパターンはRustのエラー処理で頻出しますので、もっと簡単に書けるようにメソッドなどが提供されています。それらを使うと回答は以下のように書けます。

let x = s.parse().map_err(ParsePosNonzeroError::from_parse_int)?;

これについて詳しく見てみましょう。

map_err

まずmap_errに注目します。これは頻出パターンに出てきた「Errのときは別のエラーに変換する」ためのメソッドです。

map_err(ParsePosNonzeroError::from_parse_int)

Result型のmap_errメソッド（ドキュメント）は、クロージャーを引数にとり、そのクロージャーを使って、あるErr型から別のErr型へ変換します。定義は以下のようになっています。

pub fn map_err<F, O: FnOnce(E) -> F>(self, op: O) -> Result<T, F> {
    match self {
        Ok(t) => Ok(t),
        Err(e) => Err(op(e)),
    }
}

クロージャーopの型Oの定義はFnOnce(E) -> Fで、これは、任意の型Eの引数を1つとり、任意の型Fの値を返すクロージャーを意味します。

さて、上の回答例ではmap_errにクロージャーではなく、関数名（ParsePosNonzeroError::from_parse_int）が渡されています。これは以下のようにクロージャーを使って書くのと同じ動きをします。

map_err(|e| ParsePosNonzeroError::from_parse_int(e))

Rustではクロージャーが求められているところに関数名やメソッド名を渡すことができます。ただし、その関数・メソッドは、求められているクロージャーの引数と関数の型の要件を満たしていなければなりません。

from_parse_intメソッドはParseIntError型の引数を1つとり、ParsePosNonzeroError型の値を返します。これはmap_errがopクロージャーに求める「任意の型Eの引数を1つとり、任意の型Fの値を返す」という要件を満たしています。そういうときは、わざわざ|e| ParsePosNonzeroError::from_parse_int(e)のようにクロージャーを作らずに、ParsePosNonzeroError::from_parse_intを渡すことができます。

?演算子

次に回答例の行の右端にある?に注目しましょう。これは「Okのときはunwrapし、Errのときは早期リターンする」演算子です。

map_err(ParsePosNonzeroError::from_parse_int)?;

?はRust組み込みの演算子なのでRustコードによる定義はないのですが、以下のコードと大体同じことをします。

match x {
    Ok(t) => t,
    // From::fromはある型から別の型への変換が可能なら、それを行う
    Err(e) => return Err(std::convert::From::from(e)),
}

説明は以上になります。これらを組み合わせることで、以下のmatch式を

let x = s.parse();
let x = match x {
    Ok(n) => n,
    Err(err) => {
        return Err(ParsePosNonzeroError::from_parseint(err));
    }
};

以下のように書くことができるわけです。

let x = s.parse().map_err(ParsePosNonzeroError::from_parse_int)?;

参考になれば幸いです。

Comments

[KOTTON]

すぐ気が付かず、返信が遅れてしまい申し訳ありません！
とてもとても丁寧な説明、ありがとうございます！
一番簡潔な書き方についてよく理解できました！
Rustのコミュニティを探していたので、Slackにも参加させていただきます、ありがとうございます！

[tatsuya6502]

> Rustのコミュニティを探していたので、Slackにも参加させていただきます

はい。では、そちらでもお会いしましょう！

Answer 2

自己解決しました。
let x = match x {}
という表現を使い、さらにその中でResult型をreturnすることで解決できました。

fn parse_pos_nonzero(s: &str)
    -> Result<PositiveNonzeroInteger, ParsePosNonzeroError>
{
    // TODO: change this to return an appropriate error instead of panicking
    // when `parse()` returns an error.
    let x = s.parse();
    let x = match x {
        Ok(n) => n,
        Err(err) => {
            return Err(ParsePosNonzeroError::from_parseint(err));
        }
    };
    PositiveNonzeroInteger::new(x).map_err(ParsePosNonzeroError::from_creation)
}