Making Drop more magic to make it less magic

language design
10

Can I offer an idea?

I think drop can be safe and flexible with little help of intrinsic type.

Rust can have a magic container:

// holds a value of type T, and performs "default" drop
// on destruction, i. e. invokes drop on all fields
// this object is instantiated by compiler only, not directly
struct DefaultDrop<T>(T);

impl<T> DefaultDrop<T> {
  // get a reference to contained object
  fn get_mut(&mut self) -> &mut T { ... }
  // however contained object can be recovered
  fn recover(self) -> T { ... }
}

// and then drop signature provided to user could look like this:

trait BetterDrop {
  fn drop(self_holder: DefaultDrop<Self>);
}

// so by default to close resource or something get_mut can be used

impl BetterDrop for MyObjbect {
  fn drop(self_holder: DefaultDrop<MyObject>) {
    self_holder.get_mut().close_something();
    // and the default destructor will be called at the end of this function
    // when self_holder is be destroyed
  }
}

// however this API allows data recovery

impl BetterDrop for AnotherObject {
  fn drop(self_holder: DefaultDrop<AnotherObject) {
    let AnotherObject { field1, field2 } = self_holder.recover();
    // self_holder no longer exists, so no destructor will be called
    // except for destructors of individual fields
    // (unless those fields be moved elsewhere)
  }
}
1 Like