PartialThis

LICENSE

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<T> = p.done();
    println!("{:?}", foo);
}

Multi partial overloads.

let foo: Box<T> = 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.foo());

let mut p = p.foo(1);
*p.foo_mut() = 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 fields declare order.

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>>)

partial_this 0.1.0

PartialThis