通用 FromStr 的 Rust 错误转换，用不满足的特征边界解包错误

Question

我正在使用thiserror crate 创建自定义错误类型

use thiserror::Error;

/// ParseTreeError enumerates all possible errors returned by this library.
#[derive(Error, Debug)]
pub enum ParseTreeError {
    /// Represents an empty source. For example, an empty text file being given
    /// as input to `count_words()`.
    #[error("Source contains no data")]
    EmptySource,

    /// Represents a failure to read from input.
    #[error("Read error")]
    ReadError,
}

pub struct Parser <'a, T>
where
    T: FromStr + PartialEq
{
    token_stream: &'a str,
    marker: (usize, usize),
}

impl<'a, T> Parser<'a, T>
where
    T: FromStr + PartialEq
{
    fn test_parse() -> Result<(), ParseTreeError> {
        let mut val = T::from_str("5").unwrap();
        Ok(())
    }
}

这会引发以下错误：

error[E0599]: the method `unwrap` exists for enum `std::result::Result<T, <T as FromStr>::Err>`, but its trait bounds were not satisfied
  --> src/tree/parser.rs:65:40
   |
65 |         let mut val = T::from_str("5").unwrap();
   |                                        ^^^^^^ method cannot be called on `std::result::Result<T, <T as FromStr>::Err>` due to unsatisfied trait bounds
   |
   = note: the following trait bounds were not satisfied:
           `<T as FromStr>::Err: Debug`

如果我像这样映射错误

let mut val2 = T::from_str("5").map_err(|_| ParseTreeError::ReadError).unwrap();

然后不会抛出错误。

如果我尝试使用 ?操作员我得到错误

error[E0277]: `?` couldn't convert the error to `ParseTreeError`
  --> src/tree/parser.rs:65:40
   |
65 |         let mut val1 = T::from_str("5")?;
   |                                        ^ the trait `From<<T as FromStr>::Err>` is not implemented for `ParseTreeError`
   |
   = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
   = note: required by `from`

我需要做什么才能使 ? operator 可以自动将错误转换为正确的错误类型，而无需使用 map_err ？

Answer 1

您的问题与thiserror 完全无关，但可以通过

use std::str::FromStr;

fn test_parse<T>() -> Result<(), ()>
where
    T: FromStr,
{
    let mut val = T::from_str("5").unwrap();
    Ok(())
}

那么，有什么问题吗？这个问题隐藏在Result 的unwrap 中。 unwrap 只有在我们可以somehow show the E in Result<T, E> 时才可用：

//      vvvvvvvvvvvvv
impl<T, E: fmt::Debug> Result<T, E> {
    //    ...
    
    fn unwrap(self) -> T {
        ...
    }
}

E 来自哪里？好吧，每个FromStr 实现都必须定义相关的错误类型Err。但是，Err 没有任何限制。它可能实现Debug，但也可能不会。因为我们在test_parse 上的特征界限表明我们可以遍历所有仅实现FromStr 的Ts，所以我们太笼统了。我们需要说test_parse 只适用于FromStr 的Ts 和 其关联的Err 类型可以通过Debug 显示：

use std::fmt;
use std::str::FromStr;

fn test_parse<T>() -> Result<(), ()>
where
    T: FromStr,
    <T as FromStr>::Err: fmt::Debug,             // <<<<
{
    let mut val = T::from_str("5").unwrap();
    Ok(())
}

现在test_parse 不能再与所有可能的FromStr 实现一起使用，而只能用于在其关联的Err 类型上也实现Debug 的那些，这正是我们所需要的。

对于? 运算符，我们需要为ParseTreeError 实现From<<T as FromStr>::Err>，但是，that's blocked by E0207。