Cannot move out of type `[Foo;2]`, a non-copy array

Question

I fail to understand what the problem in the following code is supposed to be:

extern crate rand;
use rand::*;

#[derive(Debug)]
enum Foo {
    A,
    B,
}

static FOOS: [Foo; 2] = [Foo::A, Foo::B];

fn random_foo() -> Foo {
    let i = rand::thread_rng().gen_range(0, FOOS.len());
    FOOS[i]
}

fn main() {
    println!(
        "First: {:?} Second: {:?} Random: {:?}",
        FOOS[0],
        FOOS[1],
        random_foo()
    );
}

I get the error:

error[E0508]: cannot move out of type `[Foo; 2]`, a non-copy array
  --> src/main.rs:14:5
   |
14 |     FOOS[i]
   |     ^^^^^^^ cannot move out of here

Using only the first 2 parts of the println!() and removing fn random_foo(), the code compiles. I cannot see what random_foo() does differently which is worth a compiler error. It only accesses an element of FOOS and tries to return the value, just like the arguments in the print statement in main() do.

Answer 1

In your example you're trying to return a value. Once you return FOOS[1], the value is copied to be returned, but in your case your struct can't be copied.

The easiest way is to use references:

extern crate rand;
use rand::*;

#[derive(Debug)]
enum Foo {
    A,
    B,
}
//Your array still uses two values of type Foo
static FOOS: [Foo; 2] = [Foo::A, Foo::B];

/*
 * random_foo() now returns a reference. So the value in FOOS
 * is no longer borrowed.
 */
fn random_foo() -> &'static Foo {
    let i = rand::thread_rng().gen_range(0, FOOS.len());
    &FOOS[i]
}

fn main() {
    println!(
        "First: {:?} Second: {:?} Random: {:?}",
        FOOS[0],
        FOOS[1],
        random_foo()
    );
}

See the Rust book about ownership and borrowing.

See the Rust book about static lifetime used in the example.

The println! macro can use your variables without taking ownership nor copying, it uses them as references. Macros are not functions, they could be compared to C++ macros on this point. They are replaced by the corresponding code before compiling. In a macro, it's possible to use the address of operator for example. See Does println! borrow or own the variable? for more information.

If you really want to use a value instead of the reference, it's possible but you'll have to derive the traits Copy and Clone for your struct. With that done, you can copy the value and return it.

The difference is in your struct:

#[derive(Debug, Copy, Clone)]
enum Foo {
    A,
    B,
}

Please see Move vs Copy in Rust for further information about move and copy.