Clone into closures

[jonhoo]

When working with move closures, and especially when spawning new threads, I often find myself having to clone a bunch of state (usually Arcs, but not always). This is either because I want that state to be shared between many instances of a closure or with the closure and the code below the closure (e.g., Arc/Rc), or for mundane reasons like I need to have a String in each closure, and since thread::spawn requires 'static, I need to clone. In futures-based code, this happens a lot with Rc<Self> where I need to carry self along into futures chained with and_then. Usually, this results in code like this:

for _ in 0..nthreads {
    let foo = Arc::clone(&foo);
    let bar = Arc::clone(&bar);
    let baz = Arc::clone(&baz);
    thread::spawn(move || {

This appears a lot in the wild. Some very quick sampling yields: [1], [2], [3], [4], [5], [6], [7], [8].

Even if you're just spawning a single thread, you often need to use weirdly tweaked variable names. For example, this code:

let foo = Arc::new(...);
thread::spawn(move || {
    foo.baz();
});
foo.baz();

must be written as

let foo = Arc::new(...);
let foo_clone = foo.clone();
thread::spawn(move || {
    foo_clone.baz();
});
foo.baz();

or if you want to retain the foo name (which you often do), you need to introduce an extra artificial scope:

let foo = Arc::new(...);
{
    let foo = foo.clone();
    thread::spawn(move || {
        foo.baz();
    });
}
foo.baz();

I don't have a concrete proposal for how this would be fixed. It'd be really neat to have something like clone ||, but that's probably overly simplistic as often you want to move some variables and clone others. Some better ergonomics for this would be great!

[oli-obk]

A c++-lambda-ish macro could do all that boilerplate for us.

[mcarton]

Lambda captures are one of the rare points where I think C++ did it better than Rust: they are explicit and you can express how to capture on a per-capture basis (in Rust that would be by reference, by Clone, by move, by some arbitrary expression (C++ allows [x=f(y)])).

[rpjohnst]

I like the idea of clone ||, I run into this quite a bit.

For reference, C++-style explicit lambda captures were considered pre-1.0. IIRC the reason for what we have now was that it requires fewer language features- you can get the same effects via the combination of a) default capture-by-reference and b) move closures that can capture temporary bindings.

In the limit it's not even very different syntactically:

[x = abc, y = def, &z]() { ... x ... y ... z }

{ let x = abc; let y = def; let z = &z; move || { ... x ... y ... z } }

I think what tips the balance is that C++'s equivalent of .clone() is the default there, so when dealing with reference counting Rust has quite a bit more noise. So in the interest of keeping clone explicit (doing away with it is a question for another thread, I think), clone || is certainly a nice way to do things.

The hard part is that move || has a natural opt-out- you selectively capture-by-move &Ts. That still works for clone, but I'm not sure if there's a great way to opt-out "half way" and selectively move Ts.

[shepmaster]

macro could do all that boilerplate

I can't find the one I'm thinking about, but I know that macros exist for this. A quick search found:

• capture
• closet

Although one of those looks real old.

[RalfJung]

Scala has a proposal something similar to C++'s explicit capturing annotations in the form of spores. I think the corresponding Rust syntax would look a lot like what @rpjohnst suggested above

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

fn main() {
    let foo = Arc::new(Mutex::new(0));
    thread::spawn({ let foo = foo.clone(); move || {
        let _x = foo.lock();
    }});
    let _y = foo.lock();
}

[jonhoo]

While that syntax seems fine if you only need to manipulate a few variables, it gets quite hairy in situations like this. That's why I proposed copy || so that you could change the default behavior to clone. I think it's quite common to either copy most things or move most things into a closure (especially in the context of thread::spawn or making futures).

[SoniEx2]

What about a clone_all macro?

Hygiene stops at passed-in identifiers. A macro can take that identifier and create a let binding with it.

You can have let $name = $name.clone().

Maybe this macro should be built-in: https://play.rust-lang.org/?gist=f3e8daccce06320e831aeb29dc26ea5c&version=stable&mode=debug

[SoniEx2]

So this:

        let args = Arc::clone(args);
        let quiet_matched = quiet_matched.clone();
        let paths_searched = paths_searched.clone();
        let match_line_count = match_line_count.clone();
        let paths_matched = paths_matched.clone();
        let bufwtr = Arc::clone(&bufwtr);
        let mut buf = bufwtr.buffer();
        let mut worker = args.worker();

Becomes:

        let args = Arc::clone(args);
        clone_all!(quiet_matched, paths_searched, match_line_count, paths_matched);
        let bufwtr = Arc::clone(&bufwtr);
        let mut buf = bufwtr.buffer();
        let mut worker = args.worker();

It should also be possible to modify the macro to take optional mut before $i:ident, so you can do this:

clone_all!(a, mut b, c);

[SoniEx2]

Aaand I just make a crate for it. because y'know, I just had to. https://crates.io/crates/clone_all

[burdges]

There are many scenarios where you should use either Cow::from(..)/Cow::Borrowed(..) or else do let foo = Arc/Rc::new(foo) followed by .clone(), instead of .clone() itself.

In any case, you could address the syntax directly without special casing clone with capture expressions that evaluate just outside the closure being created, so

foo(|..| { ... capture { Cow::from(bar) } ... })

becomes

{  let capture0 = Cow::from(bar);  foo(|..| { ... capture0 ... })  }

We avoid noise around the |..| too, while supporting more scenarios ala Cow.

Ideally, you could do this via a capture! proc macro crate, rather extending rust itself, which avoids any debate about "complexity budget". I've never looked into proc macros that access the AST outside their call site, but if that works then that's clearly the way to go.

[Diggsey]

There's this enclose macro that's used in a load of places including stdweb:

macro_rules! enclose {
    ( ($( $x:ident ),*) $y:expr ) => {
        {
            $(let $x = $x.clone();)*
            $y
        }
    };
}

Example use:
https://github.com/rust-webplatform/rust-todomvc/blob/master/src/main.rs#L142

[lukaspiatkowski]

@SoniEx2 would you consider adding this to your crate? https://gist.github.com/rust-play/1cc71ed137157bb8115a9f063aabbea3

It allows using clone_all! on self.attribute:

struct A {
    x: String,
    y: String,
    z: String,
}
impl A {
    fn foo(&self) {
        clone_all!(self.x, self.y, self.z);
        (move || {
            println!("{} {} {}", x, y, z);
        })();
    }
}

[SoniEx2]

@lukaspiatkowski I encourage ppl to fork the things I've made. The whole point of free software is the ability to fork things, so please fork my things! (I'm not sure why ppl don't fork things...)