`#[deriving(ToStr)]` handles generics in a surprising manner.

[huonw]

#[deriving(ToStr)]
struct Foo<A>(A);

struct Bar;
impl ToStr for Bar {
    fn to_str(&self) -> ~str {
        ~"some string"
    }
}

fn main() {
    println(Bar.to_str());
    println(Foo(Bar).to_str());
}

prints:

some string
{__field__: {}}

Ignoring the strange struct printing, it should probably print:

some string
{__field__: some string}

i.e. use the ToStr impl of any generics.

[alexcrichton]

Edit: disregard all this, I'm working on a fix

This may also be a problem with fmt!. With deriving(ToStr), you can pass rustc --pretty expanded to get what it expands to:

#[deriving(ToStr)]
struct Foo<A>(A);
#[doc = "Automatically derived."]
pub impl <A: ::std::to_str::ToStr> ::std::to_str::ToStr for Foo<A> {
    pub fn to_str(&self) -> ~str {
        match *self { Foo(ref __self_0_0) => ::std::sys::log_str(&*self) }
    }
}

Which is basically invoking fmt("%?", self). And, as expected, the program

#[deriving(ToStr)]
struct Foo<A>(A);

struct Bar;
impl ToStr for Bar {
    fn to_str(&self) -> ~str {
        ~"some string"
    }
}

fn main() {
    println(Bar.to_str());
    println(Foo(Bar).to_str());
    println(fmt!("%?", Foo(Bar)));
}

also prints out

some string
{__field__: {}}
{__field__: {}}