#[deriving(...)] doesn't work for fixed-size vectors

[pkgw]

Or something along those lines? I'm not quite sure what the correct terminology would be. When I try to compile this:

#[crate_type = "bin"];
extern mod std;

#[deriving(Clone)]
pub struct Hash {
    value: [u8, ..20],
}

fn main () {}

I get:

sample.rs:4:11: 4:16 error: mismatched types: expected `[u8, .. 20]` but found `&[u8, .. 20]` (expected vector but found &-ptr)
sample.rs:4 #[deriving(Clone)]
                       ^~~~~
error: aborting due to previous error

It seems like this should work straightforwardly. The same kind of issue pops up for Cmp, Eq, etc.

[huonw]

This problem is because fixed sized lists don't have impls for Clone, Eq etc. The error message when this is the case is not clear for #[deriving], but it's more obvious with the following:

fn foo<C:Clone>(x: C) {} let x: [int, .. 2] = [1,2]; foo(x)

foo.rs:10:61: 10:64 error: failed to find an implementation of trait std::clone::Clone for [int, .. 2]
foo.rs:10         fn foo<C:Clone>(x: C) {} let x: [int, .. 2] = [1,2]; foo(x)
                                                                       ^~~
note: in expansion of fmt!
foo.rs:9:10: 11:7 note: expansion site
application terminated with error code 101

(Fixed-sized vectors are strange.)

[pkgw]

OK. Naively, I think that it'd be nice if this could somehow Just Work™, but perhaps making that possible would break other things.

At the least, the error message could be a lot more helpful.

[huonw]

Yes, I agree that fixed size lists should implement the appropriate traits. (The problem is one can't parameterise the size, so to implement traits/methods for them at the moment, you have to go impl .. for [T, .. 1], impl .. for [T, .. 2] etc, which clearly doesn't scale well.)

[emberian]

still relevant

[huonw]

Linking to #7622 (this is almost certainly caused by that, but there is the possibility of some subtlety specific to #[deriving]).

[thestinger]

Closing in favour of #7622, since I don't think there are any issues unique to deriving for this.