Has someone considered an owned trait object?

[lqf96]

Apart from &dyn Trait and &mut dyn Trait, both of which are borrowed trait objects, why don't we have an owned trait object type dyn Trait? Such type will likely be a DST with pointers to vtables (including Drop), size and align of the original value, followed by the value itself. Object safety rules will be relaxed on the owned trait object type to allow self to be consumed.

Together with DerefMove this can be used to replace FnBox for Box<dyn FnOnce(...) -> ...> syntax.

[SimonSapin]

The own trait object is Box<dyn Trait> a.k.a. Box<Trait>.

DerefMove still requires the value being moved to be Sized, in order to figure out how much stack space to allocate. This is why Box<dyn FnOnce> doesn’t work today.

[lqf96]

I'm actually thinking of implementing it in the opposite way. dyn Trait is owned and can be placed anywhere, either on the stack or on the heap. And then Box will only allocate memory and move the dyn Trait object from the stack to the heap.

[Ixrec]

@lqf96 That's basically "unsized rvalues", for which the tracking issue is: rust-lang/rust#48055

[lqf96]

@Ixrec Yes, such type will have to rely on unsized rvalues. What I want to propose is that object safety rules on dyn Trait can be relaxed so that self can be consumed. An example would be like this:

struct A(u32);

trait Test {
    fn test(self) -> u32;
}

impl Test for A {
    fn test(self) -> u32 { self.0 }
}

And then you can cast variable with type A to type dyn Test and call method test without knowing the type of underlying value:

// Create an `A` instance and cast it to an owned trait object
let a = A(10) as dyn Test;
// Consume the owned trait object
println!("{}", a.test());
// `a` is consumed and can no longer be used

With dyn Trait type we no longer need to do anything special to support dynamic dispatch on arbitrary self types, as every arbitrary self type can Deref, DerefMut or DerefMove to &dyn Trait, &mut dyn Trait or Dyn Trait, and the latter trait object types will all support dynamic dispatch right out of the box.

[qnighy]

object safety rules on dyn Trait can be relaxed so that self can be consumed

That is the part of the unsized rvalues RFC. In fact, it's one of the two achievements which the RFC aims at. The other one is the fast allocation of small arrays.

With dyn Trait type we no longer need to do anything special to support dynamic dispatch on arbitrary self types,

I'm not sure which problem you're referring, but at least the problem listed here doesn't seem to be relevant to unsized self: Self.

[Centril]

This seems to be completed as per the unsized rvalues RFC per notes above, thus, I'll close this issue.