what does it mean “generic type parameters that are filled in with concrete type parameters when the trait is used” An example that won’t work is when the type parameter is part of a method: trait Foo { fn foo<T>(t: T) {} } When a function has a type parameter, Rust will monomorphize the function … Read more
Box::new only works with sized types; that is, it takes a value of a sized type T and returns Box<T>. In certain places a Box<T> can be coerced into a Box<U> (if T: Unsize<U>). Such coercion does not happen in .map(Box::new), but does in Some(Box::new(s)); the latter is basically the same as Some(Box::new(s) as Box<FooTrait>). … Read more
(An older revision of this answer essentially advised to clone the underlying struct and put it in a new Rc<RefCell<Box<MyTrait>> object; this was necessary at the time on stable Rust, but since not long after that time, Rc<RefCell<MyStruct>> will coerce to Rc<RefCell<MyTrait>> without trouble.) Drop the Box<> wrapping, and you can coerce Rc<RefCell<MyStruct>> to Rc<RefCell<MyTrait>> … Read more
Why does this particular example not work? The chapter Trait Objects states: So what makes a method object-safe? Each method must require that Self: Sized Isn’t that fulfilled? This question really is: What is a trait object? A trait object is an interface in the Object-Oriented paradigm: it exposes a limited set of methods, which … Read more
This problem can be reduced to the following simple example (thanks to turbulencetoo): trait Foo {} fn make_dyn<T: Foo + ?Sized>(arg: &T) -> &dyn Foo { arg } At first glance, it really looks like this should compile, as you observed: If T is Sized, the compiler knows statically what vtable it should use to … Read more
You can either add a type parameter to your struct, as in Zernike’s answer, or use a trait object. Using the type parameter is better for performance because each value of T will create a specialized copy of the struct, which allows for static dispatch. A trait object uses dynamic dispatch so it lets you … Read more
It’s possible. You can add a Send constraint to a trait object like this: let foo = Box::new(Foo { foo: 1 }) as Box<dyn Bar + Send>; let (tx, rx): (Sender<Box<dyn Bar + Send>>, Receiver<Box<dyn Bar + Send>>) = channel();
You have trait objects when you have a pointer to a trait. Box, Arc, Rc and the reference & are all, at their core, pointers. In terms of defining a “trait object” they work in the same way. “Trait objects” are Rust’s take on dynamic dispatch. Here’s an example that I hope helps show what … Read more