Clone is not defined for [_; 256]

[untitaker]

#30130 broke this code:

#[derive(Copy, Clone)]
struct Array {
    arr: [[u8; 256]; 4]
}

[bluss]

Clone is not implemented for [[u8; 256]; 4] anymore, because it now requires [T; 4] where T: Clone (previously T: Copy), which doesn't hold for arrays bigger than 32.

[sfackler]

I'm assuming that trying to call clone on an Array would previously ICE the compiler?

[bluss]

In certain contexts, such as fn foo<T: Copy>(t: &T) { t.clone(); } it would / will ICE yes, issue #25733

[sfackler]

Ah, the bound was T: Copy before.

[retep998]

If only we had type level integers so we could just properly implement Clone for all fixed size array sizes without massive bloat.

[petrochenkov]

If only we had type level integers so we could just properly implement Clone for all fixed size array sizes without massive bloat.

It doesn't even requires actual numbers, most of impls act on "size-erased" arrays.
Something like impl<T> Clone for [T; _] {...} would be enough.

[durka]

@petrochenkov how would that work? Don't you need to loop N times to do the actual clone?

[petrochenkov]

Something like:

fn clone(&self) -> Self {
    unsafe {
        let result: Self = mem::uninitialized();
        clone_slice_into_uninitialized_memory(self.begin(), self.len(), result.begin());
        result
    }
}

So N is not used explicitly in the implementation, although it is still needed by Self internally. Whether it is easier to implement than type level integers or not is a separate question.