RFC: Integrate capture clause into parameter list

[nikomatsakis]

Currently, a capture clause is written:

fn@[move x, y; copy z](a: T) { ... }

I was thinking that maybe we should write it inline with the parameters, like so:

fn@(a: T; move x, y; copy z) { ... }

The reasons are (1) I find it easier to read but also (2) it integrates with the sugared closures better:

task::spawn {|move x, y; copy z|
    ...
}

In general, then, the parameter list for a closure would have three parts:

• the normal parameters
• the move mode captures
• the copy mode captures

[marijnh]

No objection from me.

[pcwalton]

This is closer to what @graydon originally had in mind with bind. Sounds good to me.

[brson]

What about getting rid of the semi colons and just making move and copy indicate a captured argument, like

fn&(a: int, b: int, copy c: int) as opposed to fn&(a: int, b: int; copy c)

It's potentially a little unclear that copy means capture, but you have that same confusion with the semi-colon syntax if there are only captures: fn&(copy c). So I don't think the semi-colon accomplishes much.

This is doubly confusing because we also have move-mode and copy-mode parameters. What's the difference between fn&(-c) and fn&(move c). It's not obvious.

[nikomatsakis]

@brson there is no need to list the types for parameters that are copied or moved. I thought about removing the semi-colons so that there are no "sections" in the parameter list. the main downside is the need to repeat the move keyword a lot. It seems like it might be common to want to copy and move a number of variables, in which case I think:

fn@(a: int, b: int;
    move x, y;
    copy w, z)

seems nicer than fn@(a: int, b: int, move x, move y, copy w, copy z).

But I don't feel too strongly about this.

[brson]

I don't know that repeating move is a big deal. I hope that using capture clauses at all is very rare. Usually the last move pass just does the right thing I think.

[brson]

Though if we do the nocopy stuff then I guess explicit copy captures would be more common.

[catamorphism]

No objections from me. I like @brson 's suggestion beginning with "What about getting rid of the semi colons and just making move and copy indicate a captured argument?" I don't think the semicolon would be very enlightening to me if I didn't understand what it meant already. It's not a huge deal to me, though.

[nikomatsakis]

Ok, I am happy with writing something like fn foo(..., move x, copy y, move z).

[pcwalton]

This is basically done, isn't it?

[pcwalton]

cc @nikomatsakis

[nikomatsakis]

yes, all done. (Except perhaps killing the old syntax)