使用Self作为类型参数时为何需要Sized trait？

Great question! This ties into Rust's core rules around sized vs. unsized types, and how trait constraints interact with them. Let's break this down clearly:

1. Rust's default Sized constraint for traits #

First, a quick refresher: By default, every trait you define implicitly requires Self: Sized. That means any type implementing the trait must have a known size at compile time—unless you explicitly add ?Sized to the trait definition (like trait Foo: ?Sized { ... }) to opt out of this default.

In your example, when you use Self as a type parameter (for Qux<Self>) or as the bound for an associated type (for Baz<F = Self>), those positions enforce that Self meets the constraints of the target trait. Let's look at each case:

• For type Bar: Baz<F = Self>: The Baz trait requires its associated type F to implement Foo. Since Foo defaults to Self: Sized, F (which is Self) must be Sized.
• For type Quiz: Qux<Self>: The Qux trait's type parameter F is constrained to Foo, which again defaults to requiring F: Sized. So Self (passed as F) must be Sized.

If you omit the Sized bound on Foo, the compiler gets confused because it can't guarantee that Self will meet the implicit Sized requirements of the traits you're referencing. Explicitly adding trait Foo: Sized removes that ambiguity and confirms your intent.

2. Why unsized types cause problems here #

Unsized types (like [i32], dyn Trait, or custom unsized types) have no fixed size at compile time. This creates two key issues for the scenario in your code:

• No direct instantiation: You can't create a direct instance of an unsized type—you can only interact with them via pointers (like &[i32] or Box<dyn Trait>). When a trait expects a type parameter to be Sized, it's often because the trait's methods need to work with owned instances (not just pointers), which requires knowing the type's size upfront.
• Constraint propagation: When you pass Self as a type parameter to another trait (like Qux<Self>), that trait's constraints are applied to Self. If Qux expects F: Foo and Foo doesn't allow unsized types, Self can't be unsized—because the compiler can't ensure that all methods of Foo (and any traits it depends on) can handle an unsized Self.

What if we wanted to support unsized types? #

If you did want Foo to be implementable by unsized types, you'd need to relax constraints everywhere:

1. Mark Foo with ?Sized: trait Foo: ?Sized { ... }
2. Update Baz to allow unsized F: trait Baz { type F: Foo + ?Sized; }
3. Update Qux to allow unsized F: trait Qux<F: Foo + ?Sized> {}

But this would limit what you can do with Foo's methods, since you couldn't assume Self has a fixed size anymore (e.g., you couldn't return Self from a method, only references or pointers to it).

内容的提问来源于stack exchange，提问作者Some Name