Error handling 什么'；用Result包装非错误函数的惯用方法是什么？

我有一个函数，它将

str

解析为一个数字，并返回它或一个错误

fn parse_str<T: FromStr>(text: &str) -> Result<T, SaleError> {
    match text.parse::<T>() {
        Ok(value) => Ok(value),
        _ => Err(SaleError::new(6010, 1999)),
    }
}

现在我可以这样使用它：

let value1 = try!(parse_str::<f64>("123").and_then(is_positive)
                  .or(Err(SaleError::new(6010, 1465))));
let value2 = try!(parse_str::<f64>("321").and_then(is_positive)
                  .or(Err(SaleError::new(6010, 5000))));

let value1 = try!(parse_str::<f64>("123").check_if(|n| n.is_sign_positive())
                  .or(Err(SaleError::new(6010, 1465))));

---

如果，我可能会使用

：

"123"
    .parse::<f64>()
    .map_err(|_| SaleError(6010, 1999))
    .and_then(|n| {
        if n.is_sign_positive() {
            Ok(n)
        } else {
            Err(SaleError(6010, 1465))
        }
    });

“123”
.parse:：（）
.map_err（| | SaleError（60101999））
.然后| n |{
如果n.是正负号（）{
Ok（n）
}否则{
错误（SaleError（60101465））
}
});


如果你真的想要，你可以：

struct SaleError(i32, i32);

fn main() {
    "123"
        .parse::<f64>()
        .map_err(|_| SaleError(6010, 1999))
        .wonky(SaleError(6010, 1465), |n| n.is_sign_positive());
}

trait Wonky<T, E> {
    fn wonky<F>(self, error: E, f: F) -> Result<T, E>
        where F: FnOnce(&T) -> bool;
}

impl<T, E> Wonky<T, E> for Result<T, E> {
    fn wonky<F>(self, error: E, f: F) -> Result<T, E>
        where F: FnOnce(&T) -> bool
    {
        match self {
            Ok(n) => if f(&n) { Ok(n) } else { Err(error) },
            Err(e) => Err(e),
        }
    }
}

struct SaleError（i32，i32）；
fn main（）{
"123"
.parse:：（）
.map_err（| | SaleError（60101999））
.wonky（SaleError（60101465），|n | n.为正符号（）；
}
特质不稳定{
fn不稳定（自身，错误：E，f:f）->结果
其中F:FnOnce（&T）->bool；
}
对结果的质疑{
fn不稳定（自身，错误：E，f:f）->结果
其中F:FnOnce（&T）->bool
{
匹配自我{
Ok（n）=>如果f（&n）{Ok（n）}否则{Err（error）}，
误差（e）=>误差（e），
}
}
}
另请参见，谢谢，这正是我想要的！
struct SaleError(i32, i32);

fn main() {
    "123"
        .parse::<f64>()
        .map_err(|_| SaleError(6010, 1999))
        .wonky(SaleError(6010, 1465), |n| n.is_sign_positive());
}

trait Wonky<T, E> {
    fn wonky<F>(self, error: E, f: F) -> Result<T, E>
        where F: FnOnce(&T) -> bool;
}

impl<T, E> Wonky<T, E> for Result<T, E> {
    fn wonky<F>(self, error: E, f: F) -> Result<T, E>
        where F: FnOnce(&T) -> bool
    {
        match self {
            Ok(n) => if f(&n) { Ok(n) } else { Err(error) },
            Err(e) => Err(e),
        }
    }
}