Assign

Mutate instances with declarative flavor!

This module provides macro assign! to allow mutating instance with declarative flavor

The motivation of this macro is to enable programmer to document a sequence of mutations instance fields as initialization by writing it in a declarative way. assign! macro also allows programmer to skip defining fields that has default value. Such case are used when a dependency is exposing an non-exhaustive struct

Usage

```rust

[macro_use]

extern crate assign;

fn main() { struct SomeStruct { a: u32, b: Option, c: String, } impl SomeStruct { fn new() -> SomeStruct { SomeStruct { a: 1u32, b: None, c: String::from("old"), } } }

// In order to treat the mutation of field `a` and `c` as an initialization,
// Use assign to mutate field in declarative flavor, thus avoiding the risk inserting code
// between the line that defines a field and the line that defines the other
// Note that field `b` is skipped
let instance = assign!(SomeStruct::new(), {
  a: 2u32,
  c: String::from("new"),
});

// Equivalent
let instance2 = {
    let mut item = SomeStruct::new();
    item.a = 2u32;
    item.c = String::from("new");
    item
};

assert_eq!(instance.a, instance2.a);
assert_eq!(&instance.c, &instance2.c);
assert_eq!(instance.b, instance2.b);

} ```