Understanding Rust Error E0504

Introduction to Rust Error E0504

Rust Error E0504 occurs when an attempt is made to move a borrowed variable into a closure. In Rust, this is disallowed to preserve the integrity of the borrow. This article will guide you through detailed examples to help you understand the concepts behind this error, as well as how to resolve it.

Initial Erroneous Code Example

struct FancyNum {
    num: u8,
}

fn main() {
    let fancy_num = FancyNum { num: 5 };
    let fancy_ref = &fancy_num;

    let x = move || {
        println!("child function: {}", fancy_num.num);
        // error: cannot move `fancy_num` into closure because it is borrowed
    };

    x();
    println!("main function: {}", fancy_ref.num);
}

Explanation of the Error

In the provided code, 'fancy_num' is borrowed by 'fancy_ref'. When we try to move 'fancy_num' into the closure 'x', the compiler emits Error E0504 because it would invalidate the borrow. To resolve this error, we can use a reference, limit the lifetime of the borrow, or use a reference counted value with Arc.

Solution 1: Using a Reference

In this solution, instead of moving 'fancy_num', we can use 'fancy_ref' directly inside the closure which uses a reference and doesn't require moving the original variable. Here's an example:

struct FancyNum {
    num: u8,
}

fn main() {
    let fancy_num = FancyNum { num: 5 };
    let fancy_ref = &fancy_num;

    let x = move || {
        println!("child function: {}", fancy_ref.num);
    };

    x();
    println!("main function: {}", fancy_num.num);
}

Solution 2: Limiting Borrow Lifetime

By scoping the borrow with a block, we can limit its lifetime so that the value can be moved into the closure after the borrow goes out of scope. This can be helpful in certain situations as seen in the following example:

struct FancyNum {
    num: u8,
}

fn main() {
    let fancy_num = FancyNum { num: 5 };

    {
        let fancy_ref = &fancy_num;
        println!("main function: {}", fancy_ref.num);
    }

    let x = move || {
        println!("child function: {}", fancy_num.num);
    };

    x();
}

Solution 3: Using an Arc

In cases where the lifetime of a reference isn't sufficient, such as when dealing with threading, we can use Arc (Atomic Reference Counting) to create a reference-counted value. Arc allows multiple references to the same value with a shared ownership. Here's how it's done:

use std::sync::Arc;
use std::thread;

struct FancyNum {
    num: u8,
}

fn main() {
    let fancy_ref1 = Arc::new(FancyNum { num: 5 });
    let fancy_ref2 = fancy_ref1.clone();

    let x = thread::spawn(move || {
        println!("child thread: {}", fancy_ref1.num);
    });

    x.join().expect("child thread should finish");
    println!("main thread: {}", fancy_ref2.num);
}