部分

提供可配置的 推导宏，该宏生成另一个具有相同字段的结构体，但字段被包裹在 Option<T> 中，并实现 Partial 以允许有条件地将生成的结构体字段应用于基本结构体字段。

部分 提供了 Partial trait，允许将另一个结构体的值应用于 self，意图是另一个结构体反映 self 的字段，但被包裹在 Option<T> 中。

此外，部分推导（或启用 derive 功能的 部分）支持自动生成一个镜像结构体，每个字段都被包裹在 Option<T> 中，并生成一个 Partial 实现，允许将镜像结构体的 Some 字段应用于基本结构体。我预计大多数人会对使用推导宏感兴趣。

使用方法

使用 derive

// `partially` installed with feature `derive`
use partially::Partial;

// define a base structure, with the `Partial` derive macro
#[derive(Partial)]
// further, instruct the macro to derive `Default` on the generated structure
#[partially(derive(Default))]
struct Data {
    // since no field options are specified, this field will be mapped
    // to an `Option<String>` in the generated structure
    value: String,
}

// example usage
fn main() {
    // since we derived default for the generated struct, we can use that
    // to obtain a partial struct filled with `None`.
    let empty_partial = PartialData::default();

    // we can, of course, also specify values ourself
    let full_partial = PartialData {
        value: Some("modified".to_string()),
    };

    // define a "base" that we'll operate against
    let mut full = Data {
        value: "initial".to_string(),
    };

    // apply the empty partial (note that `false` is returned, indicating nothing was applied)
    assert!(!full.apply_some(empty_partial));

    // note that applying the empty partial had no effect
    assert_eq!(full.value, "initial".to_string());

    // apply the full partial (note that `true` is returned, indicating something was applied)
    assert!(full.apply_some(full_partial));

    // note that applying the full partial modified the value
    assert_eq!(full.value, "modified".to_string());
}

不使用 derive

use partially::Partial;

struct Base {
    value: String,
}

#[derive(Default)]
struct PartialBase {
    value: Option<String>,
}

impl Partial for Base {
    type Item = PartialBase;

    #[allow(clippy::useless_conversion)]
    fn apply_some(&mut self, partial: Self::Item) -> bool {
        let will_apply_some = partial.value.is_some();

        if let Some(value) = partial.value {
            self.value = value.into();
        }

        will_apply_some
    }
}

fn main() {
    let empty_partial = PartialBase::default();
    let full_partial = PartialBase {
        value: Some("modified".to_string()),
    };

    let mut data = Base {
        value: "initial".to_string(),
    };

    assert!(!data.apply_some(empty_partial));

    assert_eq!(data.value, "initial".to_string());

    assert!(data.apply_some(full_partial));

    assert_eq!(data.value, "modified".to_string())
}

结构体选项

derive

使用示例：#[部分(derive(Debug, Default))]。