Rust随笔（四）

在 Rust 编程中，我们经常需要在不同的状态和结果表示之间进行转换。例如，一个简单的布尔条件判断可能需要升级为一个更具描述性的 Option 或包含错误信息的 Result。同样，我们也常常需要从 Result 或 Option 中提取出布尔状态。这些转换虽然基础，但掌握其实现方式能显著提升代码的可读性和函数的连贯性。这里是一些常见需求：

1. bool -> Result
2. bool -> Option
3. Option -> Result 基于这些需求，以下提供示例代码：

use thiserror::Error;
  
type CustomResult<T> = std::result::Result<T, CustomError>;  

#[derive(Error, Debug, PartialEq, Clone, Copy)] 
CustomError {  
    #[error("this is error kind")]  
    CustomErrorKind,  
}  
  
// 1. bool -> Option<()>  
fn bool_to_option(value: bool) -> Option<()> {  
    value.then_some(())  
    // 反转逻辑相当于: bool_to_option(!value)  
}  
  
// 2. bool -> Result<(), CustomError>  
fn bool_to_result(value: bool) -> CustomResult<()> {  
    value  
        .then_some(())  
        .ok_or(CustomError::CustomErrorKind)  
    // 反转逻辑相当于: bool_to_result(!value)  
}  
  
// 3. Result<(), CustomError> -> bool  
fn result_to_bool(value: CustomResult<()>) -> bool {  
    value.is_ok()  
    // 反转逻辑: value.is_err()  
}  
  
// 4. Option<()> -> bool  
fn option_to_bool(value: Option<()>) -> bool {  
    value.is_some()  
    // 反转逻辑: value.is_none()  
}  
  
// 5. Option<()> -> Result<(), CustomError> (Some -> Ok, None -> Err)  
// 虽然本例中使用的是 `Option<()>`，
// 但这些方法对于 `Option<T>`（其中 `T` 是任何类型）同样适用，
// `ok_or` 会将 `Some(value)` 转换为 `Ok(value)`。
fn option_to_result(value: Option<()>) -> CustomResult<()> {  
    value.ok_or(CustomError::CustomErrorKind)  
}  
  
// 6. Option<()> -> Result<(), CustomError> (反转: None -> Ok, Some -> Err)  
fn option_to_neg_result(value: Option<()>) -> CustomResult<()> {  
    value  
        .is_none()  
        .then_some(())  
        .ok_or(CustomError::CustomErrorKind)  
}  
  
// 7. Result<(), CustomError> -> Option<()> (Ok -> Some, Err -> None)  
fn result_to_option(value: CustomResult<()>) -> Option<()> {  
    value.ok()  
    // 提取error: value.err() -> 返回 Option<CustomError>    
    // 如果想要反转逻辑 (Err -> Some(()), Ok -> None): value.is_err().then_some(())
}  
  
fn main() {  
    println!("类型转换演示");  
  
    let true_val = true;  
    let false_val = false;  
    let some_option: Option<()> = Some(());  
    let none_option: Option<()> = None;  
    let ok_result: CustomResult<()> = Ok(());  
    let err_result: CustomResult<()> = Err(CustomError::CustomErrorKind);  
  
    //  1. bool_to_option   
	println!("\n 1. bool_to_option ");  
    println!("bool_to_option(true): {:?}", bool_to_option(true_val));  
    println!("bool_to_option(false): {:?}", bool_to_option(false_val));  
    println!("反转 (bool_to_option(!true)): {:?}", bool_to_option(!true_val));  
    println!("反转 (bool_to_option(!false)): {:?}", bool_to_option(!false_val));  
  
    //  2. bool_to_result   
	println!("\n 2. bool_to_result ");  
    println!("bool_to_result(true): {:?}", bool_to_result(true_val));  
    println!("bool_to_result(false): {:?}", bool_to_result(false_val));  
    println!("反转 (bool_to_result(!true)): {:?}", bool_to_result(!true_val));  
    println!("反转 (bool_to_result(!false)): {:?}", bool_to_result(!false_val));  
  
    //  3. result_to_bool   
	println!("\n 3. result_to_bool ");  
    println!("result_to_bool(Ok(())): {:?}", result_to_bool(ok_result));  
    println!("result_to_bool(Err(CustomErrorKind)): {:?}", result_to_bool(err_result));  
    println!("反转 (ok_result.is_err()): {:?}", ok_result.is_err());  
    println!("反转 (err_result.is_err()): {:?}", err_result.is_err());  
  
    //  4. option_to_bool   
	println!("\n 4. option_to_bool ");  
    println!("option_to_bool(Some(())): {:?}", option_to_bool(some_option));  
    println!("option_to_bool(None): {:?}", option_to_bool(none_option));  
    println!("反转 (some_option.is_none()): {:?}", some_option.is_none());  
    println!("反转 (none_option.is_none()): {:?}", none_option.is_none());  
  
    //  5. option_to_result (Some -> Ok, None -> Err)   
	println!("\n 5. option_to_result ");  
    println!("option_to_result(Some(())): {:?}", option_to_result(some_option));  
    println!("option_to_result(None): {:?}", option_to_result(none_option));  
  
    //  6. option_to_neg_result (None -> Ok, Some -> Err)   
	println!("\n 6. option_to_neg_result ");  
    println!("option_to_neg_result(Some(())): {:?}", option_to_neg_result(some_option));  
    println!("option_to_neg_result(None): {:?}", option_to_neg_result(none_option));  
  
    //  7. result_to_option (Ok -> Some, Err -> None)   
    println!("\n 7. result_to_option ");  
    println!("result_to_option(Ok(())): {:?}", result_to_option(ok_result));  
    println!("result_to_option(Err(CustomErrorKind)): {:?}", result_to_option(err_result));  
    // 提取 error    println!("提取 error (ok_result.err()): {:?}", ok_result.err());  
    println!("提取 error (err_result.err()): {:?}", err_result.err());  
    // 反转逻辑 Option<()> (Err -> Some(()), Ok -> None)    println!("反转 Option<()> (ok_result.is_err().then_some(())): {:?}", ok_result.is_err().then_some(()));  
    println!("反转 Option<()> (err_result.is_err().then_some(())): {:?}", err_result.is_err().then_some(()));  
  
    println!("\n 演示完成 ");  
}

以上例子均可以根据自身所需引用到项目上。