14

I have this code (playground):

trait NodeLike: Sized {}

fn main() {
    let s: Box<NodeLike> = panic!();
}

Which does not compile:

error[E0038]: the trait `NodeLike` cannot be made into an object
 --> src/main.rs:4:12
  |
4 |     let s: Box<NodeLike> = panic!();
  |            ^^^^^^^^^^^^^ the trait `NodeLike` cannot be made into an object
  |
  = note: the trait cannot require that `Self : Sized`

After all I read, I still don't understand why it does not compile and why it does without the Sized constraint.

As far as I know:

  • Box<NodeLike> is treated as Box<dyn NodeLike> which uses dynamic dispatch for method calls.
  • Box<NodeLike> is sized anyways, regardless of its item type.
  • The sized/unsized theory is necessary because there are types whose size is not known upfront (like arrays or strings).
  • The Sized marker on traits enforces implementing types to be sized.

What does requiring that implementing types are Sized have to do with not being able to have objects (with dynamic dispatch) of that trait?

Shepmaster
  • 388,571
  • 95
  • 1,107
  • 1,366
Henning
  • 579
  • 6
  • 17
  • You should use the `dyn` notation. This is a less ambiguous notation. – Boiethios Dec 31 '18 at 13:24
  • All is explained in [the documentation](https://doc.rust-lang.org/nightly/error-index.html#the-trait-cannot-require-self-sized). – Boiethios Dec 31 '18 at 13:29
  • The documentation does not explain much. > We cannot create an object of type Box or &Foo since in this case Self would not be Sized. Why? – Henning Dec 31 '18 at 13:33
  • Possible duplicate of [Why a function on a trait object cannot be called when bounded with \`Self: Sized\`?](https://stackoverflow.com/questions/51822118/why-a-function-on-a-trait-object-cannot-be-called-when-bounded-with-self-sized) – trent Dec 31 '18 at 13:49
  • @trentcl that link helped, thanks. So the `Sized` marker is basically just a switch to enable or disable object instances of a given trait? – Henning Dec 31 '18 at 14:11
  • 1
    As a supertrait, that's one thing it does. But in general `Sized` is just a trait that is satisfied by types with a compile-time-known size. You can use it as a supertrait to disable trait objects of the subtrait, but that's not its primary use. – trent Dec 31 '18 at 14:18

1 Answers1

8

Having Self: ?Sized on the trait type itself is a required property for a trait object, i.e. for 'object safety', even though you can have an impl on a Self: ?Sized trait with a Sized type. Hence confusion.

It's a drawback that was decided upon in RFC 255 which deals with object safety (warning: obsolete Rust syntax).

It's a long read, but one of the alternatives was to determine 'object safety' by only analyzing the methods of the trait. It is admitted in the RFC that having this restriction will make some code that could have worked not to compile. ("This is a breaking change and forbids some safe code which is legal today.").

We can go around this if we lower the restriction only to the trait members function that actually need it, e.g. this compiles:

trait NodeLike {
    fn method_foo(&self) -> Self
    where
        Self: Sized;
}

fn main() {
    let s: Box<NodeLike> = panic!();
    // Compiles!
}

However, we cannot call those Self: Sized methods via a trait object, and this is a limitation that is explained elsewhere. Here, calling s.method_foo(); will break compilation.

Note that the Self: Sized constraint limits compilation even if the method does not make use of Self at all and could have been a callable trait object method otherwise.

Shepmaster
  • 388,571
  • 95
  • 1,107
  • 1,366
Dan Aloni
  • 3,968
  • 22
  • 30