#[deriving()], concrete implementations and problems with traits

[seb-m]

The following code fails to compile:

pub trait FooTrait {
    fn new() -> Self;
}

pub struct Foo {
    elem: int
}

impl FooTrait for Foo {
    fn new() -> Foo {
        Foo {
            elem: 42
        }
    }
}

pub struct SFoo<T> {
    elem: int
}

impl<T: FooTrait> SFoo<T> {
    pub fn new() -> SFoo<T> {
        SFoo {
            elem: 42
        }
    }
}

impl<T: FooTrait> Clone for SFoo<T> {
    fn clone(&self) -> SFoo<T> {
        SFoo {
            elem: self.elem
        }
    }
}

#[deriving(Clone)]
struct Bar<T> {
    elem: SFoo<T>
}

impl<T: FooTrait> Bar<T> {
    fn new() -> Bar<T> {
        Bar {
            elem: SFoo::new()
        }
    }
}

fn main() {
    let bar: Bar<Foo> = Bar::new();
}

With the following error:

r.rs:41:5: 41:18 error: failed to find an implementation of trait FooTrait for T
r.rs:41     elem: SFoo<T>
            ^~~~~~~~~~~~~
note: in expansion of #[deriving]

Whereas when #[deriving(Clone)] is used on SFoo instead of providing a concrete implementation for the Clone trait it compiles correctly:

pub trait FooTrait {
    fn new() -> Self;
}

pub struct Foo {
    elem: int
}

impl FooTrait for Foo {
    fn new() -> Foo {
        Foo {
            elem: 42
        }
    }
}

#[deriving(Clone)]
pub struct SFoo<T> {
    elem: int
}

impl<T: FooTrait> SFoo<T> {
    pub fn new() -> SFoo<T> {
        SFoo {
            elem: 42
        }
    }
}

#[deriving(Clone)]
struct Bar<T> {
    elem: SFoo<T>
}

impl<T: FooTrait> Bar<T> {
    fn new() -> Bar<T> {
        Bar {
            elem: SFoo::new()
        }
    }
}

fn main() {
    let bar: Bar<Foo> = Bar::new();
}

It seems to me that the code in the first case should also compile without error.

[alexcrichton]

Closing as working as intended, the deriving(Clone) code will automatically add T: Clone for all type parameters on a struct. In the first piece of code you require T to adhere to FooTrait to implement Clone, but in the second piece you only require Clone (from deriving(Clone)).

You'll likely want to either derive clone in both circumstances or manually implement Clone in both.

[seb-m]

Ok, thanks for the explanation, that's too bad though :(

Of course I'd prefer using deriving(Clone) as much as possible but because on one struct I can't rely on the code generated by deriving(Clone) I now must also implement Clone in a lot more places.

[alexcrichton]

We've been discussing recently how one might customize deriving, but nothing concrete is currently implemented as of yet.