How to extension methods for Option and Result in Rust

在Rust中如何为Option扩展可执行方法

在 Rust 中，你可以为 `Option<T>` 类型扩展自定义方法，这通常通过实现一个特质（trait）来完成。以下是一个简单的示例，演示如何给 `Option<T>` 类型添加一个新的方法：

1. **定义特质（Trait）**：首先定义一个特质，其中包含你想要添加的方法。例如，我们可以定义一个特质 `OptionExtensions`。

2. **为 `Option<T>` 实现特质**：接着，为 `Option<T>` 类型实现这个特质。

下面是一个示例代码，演示了如何实现并使用这种扩展：

```rust
pub(crate) trait OptionExtensions {

    fn is_none_or<F>(&self, f: F) -> bool where F: FnOnce(&Self::Item) -> bool;

    fn is_some_then<F>(&self, f: F) where F: FnOnce(&Self::Item);

    type Item;
}

impl<T> OptionExtensions for Option<T> {

    fn is_none_or<F>(&self, f: F) -> bool where F: FnOnce(&T) -> bool, {
        match self {
            None => true,
            Some(x) => f(x),
        }
    }

    fn is_some_then<F>(&self, f: F) where F: FnOnce(&Self::Item) {
        match self {
            None => {}
            Some(x) => f(x)
        }
    }

    type Item = T;
}

fn main() {
    let maybe_number: Option<i32> = Some(10);

    // 使用扩展的方法
    if maybe_number.is_none_or(|&x| x > 5) {
        println!("The number is either None or greater than 5");
    }
}

在这个例子中，我们定义了一个名为 is_none_or 的方法，它可以用于 Option<T> 类型的实例。这个方法检查 Option 要么是 None，要么包含的值满足给定的条件。通过这种方式，你可以为 Option<T> 或其他任何类型添加更多有用的方法。

在Rust中如何为Result扩展方法

在 Rust 中，为 Result<T, E> 类型扩展方法的过程类似于为任何其他类型扩展方法。你需要定义一个特质（trait），然后为 Result<T, E> 实现这个特质。这里是一个简单的例子：

定义特质和扩展方法

1. 定义特质（Trait）：首先定义一个特质，其中包含你想要添加的方法。

2. 为 Result<T, E> 实现特质：然后，为 Result<T, E> 类型实现这个特质。

示例代码

以下是一个演示如何给 Result<T, E> 添加一个新方法的示例：

// 定义一个特质，其中包含一个新的方法
trait ResultExtensions<T, E> {
    fn is_ok_and<F>(&self, predicate: F) -> bool
    where
        F: FnOnce(&T) -> bool;

    fn is_err_and<F>(&self, predicate: F) -> bool
    where
        F: FnOnce(&E) -> bool;
}

// 为所有的 `Result<T, E>` 实现这个特质
impl<T, E> ResultExtensions<T, E> for Result<T, E> {
    // 实现方法，检查 Result 是 Ok 且满足给定的条件
    fn is_ok_and<F>(&self, predicate: F) -> bool
    where
        F: FnOnce(&T) -> bool,
    {
        match self {
            Ok(ref value) => predicate(value),
            _ => false,
        }
    }

    // 实现方法，检查 Result 是 Err 且满足给定的条件
    fn is_err_and<F>(&self, predicate: F) -> bool
    where
        F: FnOnce(&E) -> bool,
    {
        match self {
            Err(ref error) => predicate(error),
            _ => false,
        }
    }
}

fn main() {
    let result: Result<i32, String> = Ok(10);

    // 使用扩展的方法
    if result.is_ok_and(|&x| x > 5) {
        println!("Result is Ok and the value is greater than 5");
    }

    let result: Result<i32, String> = Err("Error".to_string());

    // 使用另一个扩展的方法
    if result.is_err_and(|e| e.contains("Error")) {
        println!("Result is an error and it contains 'Error'");
    }
}

在这个例子中，我们定义了两个方法：is_ok_and 和 is_err_and。这些方法分别检查 Result 是否是 Ok 且满足给定条件，以及是否是 Err 且满足另一给定条件。这种方法可以使 Result 处理更加灵活和表达性更强。