"the trait `Clone` is not implemented for the type `fn(&mut Foo, …)`

[SimonSapin]

Upgrading rust-encoding to Rust beta, I hit this error message:

/// A type of the bare function in `DecoderTrap` values.
#[unstable]
pub type DecoderTrapFunc =
    extern "Rust" fn(decoder: &mut RawDecoder, input: &[u8], output: &mut StringWriter) -> bool;

/// Trap, which handles decoder errors.
#[stable]
#[derive(Copy, Clone)]
pub enum DecoderTrap {
    /// Immediately fails on errors.
    /// Corresponds to WHATWG "fatal" error algorithm.
    Strict,
    /// Replaces an error with a U+FFFD (decoder).
    /// Corresponds to WHATWG "replacement" error algorithm.
    Replace,
    /// Silently ignores an error, effectively replacing it with an empty sequence.
    Ignore,
    /// Calls given function to handle decoder errors.
    /// The function is given the current decoder, input and output writer,
    /// and should return true only when it is fine to keep going.
    #[unstable] Call(DecoderTrapFunc),
}

src/types.rs:380:22: 380:37 error: the trait `core::clone::Clone` is not implemented for the type `fn(&'a mut types::RawDecoder, &'b [u8], &'c mut types::StringWriter + 'c) -> bool` [E0277]
src/types.rs:380     #[unstable] Call(DecoderTrapFunc),
                                      ^~~~~~~~~~~~~~~
src/types.rs:367:16: 367:21 note: in expansion of #[derive_Clone]
src/types.rs:367:16: 367:21 note: expansion site

Shouldn’t this fn type implement Clone? It seems to implement Copy.

[nikomatsakis]

I think the best plan for fixing this is specialization, which would allow us to add a low-priority, overridable impl like:

impl<T:Copy> Clone for T { .. }

[Florob]

This is likely a more general problem for types where the compiler itself determines they are Copy. I.e. I have also run into this with [T; N] where T: Copy.

[nikomatsakis]

@Florob more accurately, it is a problem for those cases where we don't (and can't, atm) have complete Clone impls.

[nikomatsakis]

(but I guess that's more or less the same thing as what you wrote, on second thought.)

[dgrunwald]

Note that the lack of Clone impls for Copy types can cause internal compiler errors:

fn test<T: Copy>(x: T) { x.clone(); }
fn main() { test(main); }

error: internal compiler error: Encountered error Unimplemented selecting Binder(core::clone::Clone) during trans

[nikomatsakis]

@dgrunwald oh, that's... not very good at all! that kind of ups the urgency of finding a good fix for this.

[nikomatsakis]

(though if we have to hack up something to fix the ICE, we could.)

[huonw]

This problem also applies to fixed sized arrays, e.g. @dgrunwald's example

fn test<T: Copy>(x: T) { x.clone(); }
fn main() { test([0; 1000]); }

<anon>:2:6: 2:15 error: internal compiler error: Encountered error `Unimplemented` selecting `Binder(core::clone::Clone)` during trans
<anon>:2      x.clone();
              ^~~~~~~~~

[DanielKeep]

Ran into this just now helping someone with cloneable iterators. Turns out that you can't clone a Filter due to fns not being cloneable. Also, just to be clear, functions definitely implement Copy, but don't implement Clone.

[SimonSapin]

I ran into this again with code like this:

let runs: Vec<Range<usize>> = /* ... */;
let mut iter = runs.iter().flat_map(Clone::clone);

When trying to clone iter later in the same function, I got this error message:

error: no method named `clone` found for type `core::iter::FlatMap<core::slice::Iter<'_, core::ops::Range<usize>>, core::ops::Range<usize>, fn(&core::ops::Range<usize>) -> core::ops::Range<usize> {core::clone::Clone::clone}>` in the current scope

FlatMap does implement Clone, but it’s derived and requires all type parameters to be Clone as well. I tried .flat_map(|x| x.clone()) but closures are apparently not Clone. With @eddyb’s help on IRC, the only way we found to have both FnMut and Clone on stable Rust with as fn(...):

let runs: Vec<Range<usize>> = /* ... */;
fn id(x: Range<usize>) -> Range<usize> { x }
let mut iter = runs.iter().cloned().flat_map(id as fn(x: Range<usize>) -> Range<usize>);

It’d be helpful if closure types were Clone whenever possible. (So, I think, for move closures when all captured values are Clone as well, for non-move closures when they implement Fn.)

[bluss]

@DanielKeep @SimonSapin You can clone a Map iterator with a fn pointer, but not a Filter.. :-( This since fn(T) -> R is Clone but not fn<'a>(&'a T) -> R

Best solution is probably @nikomatsakis idea of somehow providing Clone for everything that's Copy.

[steveklabnik]

Minimal reproduction here:

fn foo() {}

fn main() {
    Clone::clone(&foo);
}