links: Object Safety

Object safety is an important concept in Rust when working with trait objects. A trait is considered object safe if it meets certain criteria that allow it to be used as a trait object, enabling polymorphism. Here’s a summary of the key points on object safety from the official Rust documentation:

Key Points on Object Safety

1. Definition:

   • Trait Object: A way to call methods on types that implement a trait when the concrete type is not known at compile time. This is done through dynamic dispatch.
   • Object Safety: A trait is object safe if it can be turned into a trait object.

2. Object Safety Rules:

   • Self Type in Methods: Methods in the trait must not have a Self type in their signatures, except for the receiver. This means you can't use methods that return Self or have Self as a parameter.

     trait NotObjectSafe {
         fn foo(&self) -> Self; // This is not allowed
     }
     

   • Generic Methods: Methods that have generic type parameters are not allowed in object-safe traits.

     trait NotObjectSafe {
         fn foo<T>(&self, x: T); // This is not allowed
     }
     

   • Sized: The trait must not require Self: Sized because trait objects are dynamically sized.

     trait ObjectSafe: Sized {} // This is not allowed
     

3. Receiver Types:

   • Methods in object-safe traits can only have certain types of receivers:
     • &self
     • &mut self
     • self (but not Self: Sized)

4. Examples of Object-Safe Traits:

   trait ObjectSafe {
       fn foo(&self);
       fn bar(&mut self);
       fn baz(self: Box<Self>);
   }
   

5. Non-Object-Safe Traits:

   • Any trait that does not meet the above rules is not object-safe and cannot be used to create a trait object.

   trait NotObjectSafe {
       fn foo(&self) -> Self; // Returns Self
       fn bar<T>(&self, x: T); // Has generic parameters
   }
   

Practical Implications

• Using Trait Objects: If you need polymorphism where the exact type isn’t known until runtime, ensure your trait is object-safe so you can use it as a trait object (dyn Trait).
• Designing Traits: When designing traits intended for dynamic dispatch, adhere to object safety rules to avoid compilation errors and make your traits flexible for use as trait objects.

Summary

Object safety ensures that traits can be turned into trait objects, enabling dynamic dispatch. The key rules are avoiding Self in method signatures (except as a receiver), not having generic methods, and ensuring the trait does not require Self: Sized. These constraints are crucial for enabling polymorphism in Rust.

For a more detailed explanation and examples, refer to the official Rust documentation on object safety.