high quality rust: beware

messy.rs

fn main() {
    let x: &Expr<&ValT> = &Unit::<&ValT> {
        expr: &IntValue { size: 5 }
    };
}

trait ValT {}

trait Expr<T> {}

struct Unit<T> {
    expr: T
}

struct IntValue {
    size: i32
}

impl<T> Expr<T> for Unit<T>  {}

impl ValT for IntValue {}

nonscalarcast.rs

fn main() {
    let x = &Unit {
        expr: Box::new(IntValue { size: 5 })
    };

    // I want to be able to forget about the contained type but
    // error: the trait `core::marker::Sized` is not implemented for the type `ValT`
    // error: non-scalar cast: `&Unit<IntValue>` as `&Unit<ValT>`
    let y = x as &Unit<ValT>;
}

trait ValT {}

trait Expr<T> {}

struct Unit<T> {
    expr: Box<T>
}

struct IntValue {
    size: i32
}

impl<T: ValT> Expr<T> for Unit<T>  {}

impl ValT for IntValue {}

notworking.rs

fn main() {
    // error: the trait `core::marker::Sized` is not implemented for the type `ValT`
    // note: `ValT` does not have a constant size known at compile-time
    let x: &Expr<ValT> = &Unit::<ValT> {
    //                    ^~~~~~~~~~~~
        expr: &IntValue { size: 5 }
    };
}

trait ValT {}

trait Expr<T> {}

struct Unit<'a, T: 'a> {
    expr: &'a T
}

struct IntValue {
    size: i32
}

impl<'a, T> Expr<T> for Unit<'a, T>  {}

impl ValT for IntValue {}