PartialThis

Type-safe partial construction

#[partial]
#[derive(Debug)]
pub struct Foo {
    pub foo: i32,
    pub bar: f32,
}

fn test() {
    let p = Foo::partial(Box::new_uninit());
    let p = p.foo(1);
    let p = p.bar(1.0);
    let foo: Box<Foo> = p.done();
    println!("{:?}", foo);
}

• Multi partial overloads.

  let foo: Box<Foo> = Foo::partial(Box::new_uninit()).done();
  
  let foo: Foo = Foo::partial(MaybeUninit::uninit()).done();
  
  let mut foo = MaybeUninit::uninit();
  let foo: &mut Foo = Foo::partial(&mut foo).done();
  

• Field initialization methods. Can be called in any order and at most once.

  // ok
  let p = p.foo(1);
  let p = p.bar(1.0);
  

  // ok
  let p = p.bar(1.0);
  let p = p.foo(1);
  

  let p = p.foo(1);
  let p = p.foo(1); // error
  

• Field access methods. Can be called after initialization.

  let p = p.foo(1);
  println!("{}", p.get_foo());
  

  let mut p = p.foo(1);
  p.set_foo(123);
  

• Done method.Can be called after all fields are initialized.

  let foo = p.done();
  

• Drop safe. Will call fields drop according to the field initialization status and in the reverse order of initialization (the last field initialized is dropped first).

  struct Some {
    field0: ...,
    field1: ...,
    field2: ...,
    ...
  }
  let p = Some::partial(Box::new_uninit());
  let p = p.field0(...);
  let p = p.field1(...);
  drop(p); // drop(field1) -> drop(field0) -> drop(Box<MaybeUninit<Some>>)