Resultを使用してエラー以外の関数をラップする慣習的な方法は何ですか？

Question

私は数にstrを解析し、それを返すか、エラー

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

SaleErrorは私のカスタムのエラー構造体である機能を持っています。

解析した後、数値がis_sign_positive()で正であるかどうかを確認するなど、結果値に他のチェックを行いたい場合は、Err(SaleError)を発行します。

私がやっただけboolis_sign_positive()戻ると、この関数を作成しましたので：

fn is_positive(number: f64) -> Result<f64, SaleError> { 
    match number.is_sign_positive() { 
     true => Ok(number), 
     false => 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)))); 

が、なおvalue1とvalue2の特定のSaleErrorインスタンスが必要なので、or()関数を使用しました。

私は常にis_positiveが私に戻ってくるのではなく、特定のエラーが欲しいので、is_sign_positive()をラップすることができるので、関数is_positiveを作成する必要はありません。

そのような何か：

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

Answer 1

私はおそらくちょうどifを使用します。

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

---

あなたが実際にもそれをしたい場合は、あなたがそれを行うことができます。

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), 
     } 
    } 
}