Default style for iterator chains will cause excessive diffs

[kinghajj]

I have some code that rustfmt makes look like this:

let fakes = KINDS.iter()
                 .cycle()
                 .take(COUNT)
                 .fold((Vec::new(), UTC::now()), |(mut fakes, when), &kind| {
                     fakes.push(generate_fake_details(kind, when));
                     (fakes, when + interval)
                 })
                 .0;

The problem is that, if "KINDS" is renamed, then the entire chain will have to be shifted. For example:

let fakes = KINDS_2.iter()
                   .cycle()
                   .take(COUNT)
                   .fold((Vec::new(), UTC::now()), |(mut fakes, when), &kind| {
                       fakes.push(generate_fake_details(kind, when));
                       (fakes, when + interval)
                   })
                   .0;

To avoid this, I would prefer something like:

let fakes = KINDS_2.iter()
    .cycle()
    .take(COUNT)
    .fold((Vec::new(), UTC::now()), |(mut fakes, when), &kind| {
        fakes.push(generate_fake_details(kind, when));
        (fakes, when + interval)
    })
    .0;

Or perhaps:

let fakes =
    KINDS_2
    .iter()
    .cycle()
    .take(COUNT)
    .fold((Vec::new(), UTC::now()), |(mut fakes, when), &kind| {
        fakes.push(generate_fake_details(kind, when));
        (fakes, when + interval)
    })
    .0;

[nrc]

You should be able to get this effect by using either the chain_base_indent or chain_indent options (not quite sure which one to use).

[arthurprs]

What key/value do I need to achieve that output? I can't get my cargo fmt to do that.

[nrc]

I'm not actually sure. But, by coincidence, this is something I'm looking at right now, so I should have an answer (or a code fix) for you in the next few days.

[arthurprs]

Thank you!

[nrc]

So, currently, chain_indent only has an effect if we would insert a newline after the first item in the chain. I wonder if we should force a newline or accept formatting which doesn't lineup the dots. E.g.:

item_1
    .item_2
    .item_3
    .item4

or

item_1.item_2
    .item_3
    .item4

current visual layout:

item_1.item_2
      .item_3
      .item4

[arthurprs]

Definitely, as far as I'm aware that's the default for python, java and others. The current impl. is too right leaning.

I've stuff like

        let mut candidates: Vec<_> = self.nodes
                                         .iter()
                                         .filter_map(|(&k, v)| {
                                             if (alive && v.status != NodeStatus::Dead) ||
                                                (!alive && v.status == NodeStatus::Dead) {
                                                 Some(k)
                                             } else {
                                                 None
                                             }
                                         })
                                         .collect();