Simplify flat_map example

[mdinger]

I'm not sure why core is on but it's blocking the playpen. Doesn't seem to be needed but I'm not sure. It's not on the playpen template and playpen works on release and nightly.

Seems easier to understand without take().

[rust-highfive]

r? @nikomatsakis

(rust_highfive has picked a reviewer for you, use r? to override)

[bluss]

I wanted to come back to this to make it easier to understand. I added that example a long time ago.

What do you think of something like this?

let letters = ["alpha", "beta", "gamma"];
assert_eq!(letters.iter()
                  .flat_map(|s| s.chars())
                  .collect::<String>(),
           "alphabetagamma");

Or something else that's easier to concretely understand how it maps to an iterator.

[mdinger]

I'm not sure. I don't think the wording for this is easy to understand at all. Every time I try to modify the examples it fails and I'm not sure why. Apparently I don't understand it:

let num = [[1, 2], [3, 4], [5, 6]];
let v = num.into_iter()
           .flat_map(|a| a.into_iter() )
           .collect::<Vec<i32>>();
println!("{:?}", v);

playpen

[bluss]

with .collect::<Vec<&i32>>(); it's fine. arrays don't have any by-value iterator in libstd, so that outer num.into_iter() is the same as .iter().

[mdinger]

I think the example you gave is the best it's gonna get currently. If into_iter() worked on arrays, that example I gave might be better as is emphasizes the ability to denest where it's less obvious with your example. Using vec! makes it messy.

I slightly reworded it to emphasize that it maps a function to each element. The way it was worded before, it sounds like mapping to an iterator is automatic when actually you must specify the iterator producing function.

If you think it's good, I'll ask for review.

[bluss]

The function (closure) maps each element to an iterator (actually to anything implementing IntoIterator).

".flat_map() takes a function that maps each element into a new iterator, and yields all the elements of the produced iterators.”

Let's add something you said about denesting as well? Might as well explain more at least IMO.

“This can be useful do unravel a nested structure.”

[mdinger]

@bluss updated

[mdinger]

I do think it sound much better than at the beginning.

[mdinger]

r? @steveklabnik

[bluss]

Great!

[steveklabnik]

@bors: r+ rollup

[bors]

📌 Commit 5b443b2 has been approved by steveklabnik

[bors]

⌛ Testing commit 5b443b2 with merge 1d00028...

[bors]

☀️ Test successful - auto-linux-32-nopt-t, auto-linux-32-opt, auto-linux-64-nopt-t, auto-linux-64-opt, auto-linux-64-x-android-t, auto-mac-32-opt, auto-mac-64-nopt-t, auto-mac-64-opt, auto-win-gnu-32-nopt-t, auto-win-gnu-32-opt, auto-win-gnu-64-nopt-t, auto-win-gnu-64-opt

[My-]

I'm not sure. I don't think the wording for this is easy to understand at all. Every time I try to modify the examples it fails and I'm not sure why. Apparently I don't understand it:

let num = [[1, 2], [3, 4], [5, 6]];
let v = num.into_iter()
           .flat_map(|a| a.into_iter() )
           .collect::<Vec<i32>>();
println!("{:?}", v);

playpen

You can fix by replacing Vec<i32> to Vec<_> like:

fn main() {
    let num = [[1, 2], [3, 4], [5, 6]];
    let v = num.into_iter()
               .flat_map(|a| a.into_iter() )
               .map(|it| it.clone())        // copy each element
               .collect::<Vec<_>>();        // note: Vec<_>
    println!("{:?}", v);
    
    assert_eq!(vec![1, 2, 3, 4, 5, 6], v);
}

Just in case someone's search result lands here same as my one did.