deriving(Eq) requires Eq for type parameter even when phantom

[kmcallister]

Code:

#[deriving(Eq)]
struct Foo<T> {
    x: int,
}

struct Phantom;

fn main() {
    let x : Foo<Phantom> = Foo { x: 0 };
    println((x == x).to_str());
}

Result:

$ rust -v
rust 0.7 (a2db7c1 2013-07-02 09:25:44 -0700)
host: x86_64-unknown-linux-gnu
$ rust run foo.rs 
foo.rs:10:13: 10:19 error: failed to find an implementation of trait std::cmp::Eq for Phantom
foo.rs:10     println((x == x).to_str());

[mstewartgallus]

This issue is more general than just that deriving Eq requires an Eq bound. As well, deriving Clone requires a Clone bound on all template type parameters.

[huonw]

This could possibly be controlled by, e.g., #[deriving(phantom="T", Eq, Ord)]. (At the moment, just #[deriving] the trait on the phantom type itself will mostly work.)

[glaebhoerl]

The Eq bound should be required for the types it's actually used with in the derived impl (similarly for Clone etc.). I don't see why this couldn't be determined programmatically (Haskell does it). And then there's no need for a redundant programmer-provided annotation.

[huonw]

I think Haskell's deriving is built into the type system more strongly than Rust's, which is just a standard syntax extension (it runs on exactly the same code as fmt! and fail!, just deriving is "executed" by being an attribute) and syntax extensions don't have access to type information; so, at the moment, it seems highly unlikely for a fully general programmatic solution to work, unless one pushes deriving deeper into the compiler itself.

[huonw]

triage: no change.

[cristicbz]

This hit me today with:

#[derive(Debug)] struct Foo;
struct Bar;

#[derive(Debug)] struct Baz<T>(u64);

fn main() {
    println!("{:?}", Baz::<Foo>(10));
    println!("{:?}", Baz::<Bar>(10));  // Does not compile.
}

[Kimundi]

Now that Rust has where clauses, this could probably be resolved by emitting a where clause for each field of a struct that contains a type parameter:

struct NoClone;
struct Foo<A, B, C> {
    a: u8,
    b: Option<B>,
    c: C
}

// CURRENT, wrong way to implement clone in deriving
impl<A: Clone, B: Clone, C: Clone> Clone for Foo<A, B, C> {
    fn clone(&self) -> Self {
        Foo {
            a: Clone::clone(&self.a),
            b: Clone::clone(&self.b),
            c: Clone::clone(&self.c),
        }
    }
}

// NEW, Right way to implement clone in deriving
impl<A, B, C> Clone for Foo<A, B, C> where Option<B>: Clone,
                                           C: Clone {
    fn clone(&self) -> Self {
        Foo {
            a: Clone::clone(&self.a),
            b: Clone::clone(&self.b),
            c: Clone::clone(&self.c),
        }
    }
}

fn main() {
   let t: Foo<NoClone, String, &'static str> = Foo { a: 0, b: None, c: "foo" };
   let _ = t.clone();
}

This should be implementable on a purely syntactic level.

[goffrie]

The above is implemented in #21237, but unfortunately it seems to have a problem: what if a type inside the struct is private? You can't put a bound on a private type on the trait impl, because the user of your crate (say) doesn't know what impls exist for the private type :(

edit: hm, that PR was updated since I last looked at it - maybe it's a bit different now?