Do not break method chains until first method

[orlp]

Perhaps I'm alone in this, but I'm often peeved by the way this gets formatted:

let left_hand_sides = self
    .rules
    .iter()
    .map(|rule| rule[0])
    .collect();

Would it be possible either by default, or with an configurable option to not start a method chain until the first actual method, assuming it fits on one line? That is the above would be:

let left_hand_sides = self.rules
    .iter()
    .map(|rule| rule[0])
    .collect();

Or with multiple dots before the first method:

let left_hand_sides = self.grammar.rules
    .iter()
    .map(|rule| rule[0])
    .collect();

Of course if the line would become too long the break should still happen:

let left_hand_sides = self
    .grammars
    .grammar_for_rust_language
    .rules_found_in_this_grammar
    .iter()
    .map(|rule| rule[0])
    .collect();

[nrc]

Given we're at 1.0 and therefore this would be a backwards incompatible change, we're unlikely to implement, sorry (it was also decided upon during the formatting RFC process and this formatting was not very controversial).

[orlp]

@nrc I understand that it can't be default behavior, but making it an configurable option would be possible, no?

[nrc]

I think the extra code complexity to do this for the fairly niche payoff would mean that it is not worth supporting this as an option, sorry

[orlp]

@nrc Alright. I did notice an inconsistency though where if the first identifier is shorter than the indent, the first method is not properly put on it's own line. For example see how this toy code is formatted by rustfmt, making .chars() misaligned:

fn strip_whitespace(s: String) -> String {
    s.chars()
        .filter(|c| *c != ' ')
        .filter(|c| *c != '\n')
        .collect()
}

vs

fn strip_whitespace(string: String) -> String {
    string
        .chars()
        .filter(|c| *c != ' ')
        .filter(|c| *c != '\n')
        .collect()
}

Should I made a new issue for that? Or is that intended?

[nrc]

Should I made a new issue for that? Or is that intended?

It is intended, in order to avoid an ugly 'orphan line, e.g.,

s
    .chars()  // :-(

[orlp]

Alright then.