Guide: closures

[steveklabnik]

No description provided.

[ben0x539]

imo you should mention explicitly that the point of the restriction that proc()s are callable only once is to lift the restriction that other closures have that they can't consume values.

[ben0x539]

i'm also surprised that your example closure only infers the return type and not the argument type. I know it works in some contexts (like some_iter.map(|x| *x)) and I would have expected it to work here...

[steveklabnik]

I was having a weird error with inference at first, so I left that out.

[huonw]

Why ignore?

[steveklabnik]

Does fn let you put spaces after like that?

[steveklabnik]

apparently it does

[mdinger]

I learned about closures before they had the tutorial's current expanded state and found them very confusing (which led to it's current expanded state; I worked on the previous one and so I'm very interested in this one). So I wonder if this brief treatment will be enough. Having said that, I don't see any big problems in the current treatment. So I'm hoping someone unfamiliar with them will come along to detail any difficulties or lack of they have with this treatment.

[steveklabnik]

I'm going to wait to fix up this section until after unboxed closures land, since that should be soonish.

[steveklabnik]

Fixed up a bunch of these comments. After the doc meeting with @nikomatsakis and @brson yesterday, we decided to land this section as-is, without regard for unboxed closures, and when unboxed closures get here, we can update it to properly reflect whatever changes they bring.

[mdinger]

For the next closure revision:

Also, I believe it's idiomatic for short simple one-expression closures to just be written without the { ... }, e.g. |x: int| x * x - by @huonw

Kimundi posted here an explanation of the updated closures. This example from his work looks sorta like mixing of those types:

let mut counter = 0u;
let a = 128;

let counter_ref = &mut counter;
let by_mix = |b| if b > a { *counter_ref += 1; }; 
// Captures a and counter_ref as value

by_mix(64);
by_mix(256);
by_mix(1024);
assert!(counter == 2)

Specifically here it looks like a mixing of the no braces allowance and requiring it. It also looks a little like a pattern guard on a match:

let by_mix = |b| if b > a { *counter_ref += 1; }; 

I don't know if it's worth calling out an example like this in the future or not but I wanted to point it out in case it's worth it.