traits

This snippet is valid in Rust 1.26.1: use std::ops::AddAssign; trait Trait where for<'a> Self: AddAssign<Self> + AddAssign<&'a Self> + Sized, { } trait Trait2 { type Associated: Trait; fn method(u32) -> Self::Associated; } fn func<T2: Trait2>() { let mut t = T2::method(1); let t2 = T2::method(2); t += &t2; } Notice that Trait implements both AddAssign<Self> and AddAssign<&'a Trait> (in that order, which is important later). Therefore, in func we know that both t += t2 and t += &t2 should be valid. As seen on the playground , t += &t2 is valid, but using t += t2 isn't : error[E0308]: mismatched

When compiling the following code: trait RenderTarget {} struct RenderWindow; impl RenderTarget for RenderWindow {} trait Drawable { fn draw<RT: RenderTarget>(&self, target: &mut RT); } fn main() { let mut win = RenderWindow; let mut vec: Vec<Box<Drawable>> = Vec::new(); for e in &vec { e.draw(&mut win); } } I get the error: error: the trait `Drawable` is not implemented for the type `Drawable` [E0277] src/main.rs:15 e.draw(&mut win); ^~~~~~~~~~~~~~ What is the error message trying to tell? Also, how to fix it? There's a related question but the solution there was to modify the trait A (which

I have a Vec<Box<T>> where T implements Foo . Why can I not coerce it to a Vec<Box<Foo>> even though I can coerce anything of type Box<T> into a Box<Foo> ? Why does the below code not compile? use std::vec; trait Foo {} struct Bar {} impl Foo for Bar {} fn main() { let v = vec![Box::new(Bar {})]; let v_1 = v as Vec<Box<Foo>>; } Because Box<Bar> is a different size than Box<Foo> . The coercion is allowed on a single value, but here you'd have to resize the whole vector. The book goes into some detail on this in the section on Representation of Trait Objects . Short version: Box<Bar> is a